bool Defrag::queryMachines(char const *constraint,char const *constraint_source,ClassAdList &startdAds)
{
CondorQuery startdQuery(STARTD_AD);
validateExpr(constraint,constraint_source);
startdQuery.addANDConstraint(constraint);
CollectorList* collects = daemonCore->getCollectorList();
ASSERT( collects );
QueryResult result;
result = collects->query(startdQuery,startdAds);
if( result != Q_OK ) {
dprintf(D_ALWAYS,
"Couldn't fetch startd ads using constraint "
"%s=%s: %s\n",
constraint_source,constraint, getStrQueryResult(result));
return false;
}
dprintf(D_FULLDEBUG,"Got %d startd ads matching %s=%s\n",
startdAds.MyLength(), constraint_source, constraint);
return true;
}
bool
DCStartd::getAds( ClassAdList &adsList )
{
CondorError errstack;
// fetch the query
QueryResult q;
CondorQuery* query;
char* ad_addr;
// instantiate query object
if (!(query = new CondorQuery (STARTD_AD))) {
dprintf( D_ALWAYS, "Error: Out of memory\n");
return(false);
}
if( this->locate() ){
ad_addr = this->addr();
q = query->fetchAds(adsList, ad_addr, &errstack);
if (q != Q_OK) {
if (q == Q_COMMUNICATION_ERROR) {
dprintf( D_ALWAYS, "%s\n", errstack.getFullText(true).c_str() );
}
else {
dprintf (D_ALWAYS, "Error: Could not fetch ads --- %s\n",
getStrQueryResult(q));
}
delete query;
return (false);
}
} else {
delete query;
return(false);
}
delete query;
return(true);
}
void
Defrag::queryDrainingCost()
{
ClassAdList startdAds;
CondorQuery startdQuery(STARTD_AD);
char const *desired_attrs[6];
desired_attrs[0] = ATTR_TOTAL_MACHINE_DRAINING_UNCLAIMED_TIME;
desired_attrs[1] = ATTR_TOTAL_MACHINE_DRAINING_BADPUT;
desired_attrs[2] = ATTR_DAEMON_START_TIME;
desired_attrs[3] = ATTR_TOTAL_CPUS;
desired_attrs[4] = ATTR_LAST_HEARD_FROM;
desired_attrs[5] = NULL;
startdQuery.setDesiredAttrs(desired_attrs);
std::string query;
// only want one ad per machine
sprintf(query,"%s==1 && (%s =!= undefined || %s =!= undefined)",
ATTR_SLOT_ID,
ATTR_TOTAL_MACHINE_DRAINING_UNCLAIMED_TIME,
ATTR_TOTAL_MACHINE_DRAINING_BADPUT);
startdQuery.addANDConstraint(query.c_str());
CollectorList* collects = daemonCore->getCollectorList();
ASSERT( collects );
QueryResult result;
result = collects->query(startdQuery,startdAds);
if( result != Q_OK ) {
dprintf(D_ALWAYS,
"Couldn't fetch startd ads: %s\n",
getStrQueryResult(result));
return;
}
double avg_badput = 0.0;
double avg_unclaimed = 0.0;
int total_cpus = 0;
startdAds.Open();
ClassAd *startd_ad;
while( (startd_ad=startdAds.Next()) ) {
int unclaimed = 0;
int badput = 0;
int start_time = 0;
int cpus = 0;
int last_heard_from = 0;
startd_ad->LookupInteger(ATTR_TOTAL_MACHINE_DRAINING_UNCLAIMED_TIME,unclaimed);
startd_ad->LookupInteger(ATTR_TOTAL_MACHINE_DRAINING_BADPUT,badput);
startd_ad->LookupInteger(ATTR_DAEMON_START_TIME,start_time);
startd_ad->LookupInteger(ATTR_LAST_HEARD_FROM,last_heard_from);
startd_ad->LookupInteger(ATTR_TOTAL_CPUS,cpus);
int age = last_heard_from - start_time;
if( last_heard_from == 0 || start_time == 0 || age <= 0 ) {
continue;
}
avg_badput += ((double)badput)/age;
avg_unclaimed += ((double)unclaimed)/age;
total_cpus += cpus;
}
startdAds.Close();
if( total_cpus > 0 ) {
avg_badput = avg_badput/total_cpus;
avg_unclaimed = avg_unclaimed/total_cpus;
}
dprintf(D_ALWAYS,"Average pool draining badput = %.2f%%\n",
avg_badput*100);
dprintf(D_ALWAYS,"Average pool draining unclaimed = %.2f%%\n",
avg_unclaimed*100);
m_stats.AvgDrainingBadput = avg_badput;
m_stats.AvgDrainingUnclaimed = avg_unclaimed;
}
void
StatsD::publishMetrics()
{
dprintf(D_ALWAYS,"Starting update...\n");
double start_time = UtcTime::getTimeDouble();
m_stats_time_till_pub -= m_stats_heartbeat_interval;
if (m_stats_time_till_pub > 0) {
sendHeartbeats();
return;
}
m_stats_time_till_pub = m_stats_pub_interval;
initializeHostList();
// reset all aggregate sums, counts, etc.
clearAggregateMetrics();
ClassAdList daemon_ads;
CondorQuery query(ANY_AD);
if( !m_target_types.contains_anycase("any") ) {
if( !m_requirements.empty() ) {
query.addANDConstraint(m_requirements.c_str());
}
}
else {
char const *target_type;
while( (target_type=m_target_types.next()) ) {
std::string constraint;
if( !strcasecmp(target_type,"machine_slot1") ) {
formatstr(constraint,"MyType == \"Machine\" && SlotID==1 && DynamicSlot =!= True");
}
else {
formatstr(constraint,"MyType == \"%s\"",target_type);
}
if( !m_requirements.empty() ) {
constraint += " && (";
constraint += m_requirements;
constraint += ")";
}
query.addORConstraint(constraint.c_str());
}
}
CollectorList* collectors = daemonCore->getCollectorList();
ASSERT( collectors );
QueryResult result;
result = collectors->query(query,daemon_ads);
if( result != Q_OK ) {
dprintf(D_ALWAYS,
"Couldn't fetch schedd ads: %s\n",
getStrQueryResult(result));
return;
}
dprintf(D_ALWAYS,"Got %d daemon ads\n",daemon_ads.MyLength());
mapDaemonIPs(daemon_ads,*collectors);
if( !m_per_execute_node_metrics ) {
determineExecuteNodes(daemon_ads);
}
daemon_ads.Open();
ClassAd *daemon;
while( (daemon=daemon_ads.Next()) ) {
publishDaemonMetrics(daemon);
}
daemon_ads.Close();
publishAggregateMetrics();
sendHeartbeats();
// Did we take longer than a heartbeat period?
int heartbeats_missed = (int)(UtcTime::getTimeDouble() - start_time) /
m_stats_heartbeat_interval;
if (heartbeats_missed) {
dprintf(D_ALWAYS, "Skipping %d heartbeats\n", heartbeats_missed);
m_stats_time_till_pub -= (heartbeats_missed * m_stats_heartbeat_interval);
}
}
void Rooster::poll()
{
dprintf(D_FULLDEBUG,"C**k-a-doodle-doo! (Time to look for machines to wake up.)\n");
ClassAdList startdAds;
CondorQuery unhibernateQuery(STARTD_AD);
ExprTree *requirements = NULL;
if( ParseClassAdRvalExpr( m_unhibernate_constraint.Value(), requirements )!=0 || requirements==NULL )
{
EXCEPT("Invalid expression for ROOSTER_UNHIBERNATE: %s\n",
m_unhibernate_constraint.Value());
}
unhibernateQuery.addANDConstraint(m_unhibernate_constraint.Value());
CollectorList* collects = daemonCore->getCollectorList();
ASSERT( collects );
QueryResult result;
result = collects->query(unhibernateQuery,startdAds);
if( result != Q_OK ) {
dprintf(D_ALWAYS,
"Couldn't fetch startd ads using constraint "
"ROOSTER_UNHIBERNATE=%s: %s\n",
m_unhibernate_constraint.Value(), getStrQueryResult(result));
return;
}
dprintf(D_FULLDEBUG,"Got %d startd ads matching ROOSTER_UNHIBERNATE=%s\n",
startdAds.MyLength(), m_unhibernate_constraint.Value());
startdAds.Sort(StartdSortFunc,&m_rank_ad);
startdAds.Open();
int num_woken = 0;
ClassAd *startd_ad;
HashTable<MyString,bool> machines_done(MyStringHash);
while( (startd_ad=startdAds.Next()) ) {
MyString machine;
MyString name;
startd_ad->LookupString(ATTR_MACHINE,machine);
startd_ad->LookupString(ATTR_NAME,name);
if( machines_done.exists(machine)==0 ) {
dprintf(D_FULLDEBUG,
"Skipping %s: already attempted to wake up %s in this cycle.\n",
name.Value(),machine.Value());
continue;
}
// in case the unhibernate expression is time-sensitive,
// re-evaluate it now to make sure it still passes
if( !EvalBool(startd_ad,requirements) ) {
dprintf(D_ALWAYS,
"Skipping %s: ROOSTER_UNHIBERNATE is no longer true.\n",
name.Value());
continue;
}
if( wakeUp(startd_ad) ) {
machines_done.insert(machine,true);
if( ++num_woken >= m_max_unhibernate && m_max_unhibernate > 0 ) {
dprintf(D_ALWAYS,
"Reached ROOSTER_MAX_UNHIBERNATE=%d in this cycle.\n",
m_max_unhibernate);
break;
}
}
}
startdAds.Close();
delete requirements;
requirements = NULL;
if( startdAds.MyLength() ) {
dprintf(D_FULLDEBUG,"Done sending wakeup calls.\n");
}
}