int CondorQ::fetchQueueFromHostAndProcessV2(const char *host, const char *constraint, StringList &attrs, int fetch_opts, int match_limit, condor_q_process_func process_func, void * process_func_data, int connect_timeout, int useFastPath, CondorError *errstack, ClassAd ** psummary_ad) { classad::ClassAdParser parser; classad::ExprTree *expr = NULL; parser.ParseExpression(constraint, expr); if (!expr) return Q_INVALID_REQUIREMENTS; classad::ClassAd request_ad; // query ad to send to schedd ClassAd *ad = NULL; // job ad result request_ad.Insert(ATTR_REQUIREMENTS, expr); char *projection = attrs.print_to_delimed_string("\n"); if (projection) { request_ad.InsertAttr(ATTR_PROJECTION, projection); free(projection); } bool want_authentication = false; if (fetch_opts == fetch_DefaultAutoCluster) { request_ad.InsertAttr("QueryDefaultAutocluster", true); request_ad.InsertAttr("MaxReturnedJobIds", 2); // TODO: make this settable by caller of this function. } else if (fetch_opts == fetch_GroupBy) { request_ad.InsertAttr("ProjectionIsGroupBy", true); request_ad.InsertAttr("MaxReturnedJobIds", 2); // TODO: make this settable by caller of this function. } else { if (fetch_opts & fetch_MyJobs) { const char * owner = my_username(); if (owner) { request_ad.InsertAttr("Me", owner); } request_ad.InsertAttr("MyJobs", owner ? "(Owner == Me)" : "true"); want_authentication = true; } if (fetch_opts & fetch_SummaryOnly) { request_ad.InsertAttr("SummaryOnly", true); } if (fetch_opts & fetch_IncludeClusterAd) { request_ad.InsertAttr("IncludeClusterAd", true); } } if (match_limit >= 0) { request_ad.InsertAttr(ATTR_LIMIT_RESULTS, match_limit); } // determine if authentication can/will happen. three reasons why it might not: // 1) security negotiation is disabled (NEVER or OPTIONAL for outgoing connections) // 2) Authentication is disabled (NEVER) by the client // 3) Authentication is disabled (NEVER) by the server. this is actually impossible to // get correct without actually querying the server but we make an educated guess by // paraming the READ auth level. bool can_auth = true; char *paramer = NULL; paramer = SecMan::getSecSetting ("SEC_%s_NEGOTIATION", CLIENT_PERM); if (paramer != NULL) { char p = toupper(paramer[0]); free(paramer); if (p == 'N' || p == 'O') { // authentication will not happen since no security negotiation will occur can_auth = false; } } paramer = SecMan::getSecSetting ("SEC_%s_AUTHENTICATION", CLIENT_PERM); if (paramer != NULL) { char p = toupper(paramer[0]); free(paramer); if (p == 'N') { // authentication will not happen since client doesn't allow it. can_auth = false; } } // authentication will not happen since server probably doesn't allow it. // on the off chance that someone's config manages to trick us, leave an // undocumented knob as a last resort to disable our inference. if (param_boolean("CONDOR_Q_INFER_SCHEDD_AUTHENTICATION", true)) { paramer = SecMan::getSecSetting ("SEC_%s_AUTHENTICATION", READ); if (paramer != NULL) { char p = toupper(paramer[0]); free(paramer); if (p == 'N') { can_auth = false; } } paramer = SecMan::getSecSetting ("SCHEDD.SEC_%s_AUTHENTICATION", READ); if (paramer != NULL) { char p = toupper(paramer[0]); free(paramer); if (p == 'N') { can_auth = false; } } } if (!can_auth) { dprintf (D_ALWAYS, "detected that authentication will not happen. falling back to QUERY_JOB_ADS without authentication.\n"); } DCSchedd schedd(host); int cmd = QUERY_JOB_ADS; if (want_authentication && can_auth && (useFastPath > 2)) { cmd = QUERY_JOB_ADS_WITH_AUTH; } Sock* sock; if (!(sock = schedd.startCommand(cmd, Stream::reli_sock, connect_timeout, errstack))) return Q_SCHEDD_COMMUNICATION_ERROR; classad_shared_ptr<Sock> sock_sentry(sock); if (!putClassAd(sock, request_ad) || !sock->end_of_message()) return Q_SCHEDD_COMMUNICATION_ERROR; dprintf(D_FULLDEBUG, "Sent classad to schedd\n"); int rval = 0; do { ad = new ClassAd(); if ( ! getClassAd(sock, *ad) || ! sock->end_of_message()) { rval = Q_SCHEDD_COMMUNICATION_ERROR; break; } dprintf(D_FULLDEBUG, "Got classad from schedd.\n"); long long intVal; if (ad->EvaluateAttrInt(ATTR_OWNER, intVal) && (intVal == 0)) { // Last ad. sock->close(); dprintf(D_FULLDEBUG, "Ad was last one from schedd.\n"); std::string errorMsg; if (ad->EvaluateAttrInt(ATTR_ERROR_CODE, intVal) && intVal && ad->EvaluateAttrString(ATTR_ERROR_STRING, errorMsg)) { if (errstack) errstack->push("TOOL", intVal, errorMsg.c_str()); rval = Q_REMOTE_ERROR; } if (psummary_ad && rval == 0) { std::string val; if (ad->LookupString(ATTR_MY_TYPE, val) && val == "Summary") { ad->Delete(ATTR_OWNER); // remove the bogus owner attribute *psummary_ad = ad; // return the final ad, because it has summary information ad = NULL; // so we don't delete it below. } } break; } // Note: According to condor_q.h, process_func() will return false if taking // ownership of ad, so only delete if it returns true, else set to NULL // so we don't delete it here. Either way, next set ad to NULL since either // it has been deleted or will be deleted later by process_func(). if (process_func(process_func_data, ad)) { delete ad; } ad = NULL; } while (true); // Make sure ad is not leaked no matter how we break out of the above loop. delete ad; return rval; }
// Read history from a remote schedd static void readHistoryRemote(classad::ExprTree *constraintExpr) { printHeader(); if(longformat && use_xml) { std::string out; AddClassAdXMLFileHeader(out); printf("%s\n", out.c_str()); } classad::ClassAd ad; classad::ExprList *projList(new classad::ExprList()); classad::ExprTree *projTree = static_cast<classad::ExprTree*>(projList); ad.Insert(ATTR_PROJECTION, projTree); ad.Insert(ATTR_REQUIREMENTS, constraintExpr); ad.InsertAttr(ATTR_NUM_MATCHES, specifiedMatch <= 0 ? -1 : specifiedMatch); DCSchedd schedd(g_name.size() ? g_name.c_str() : NULL, g_pool.size() ? g_pool.c_str() : NULL); if (!schedd.locate(Daemon::LOCATE_FOR_LOOKUP)) { fprintf(stderr, "Unable to locate remote schedd (name=%s, pool=%s).\n", g_name.c_str(), g_pool.c_str()); exit(1); } Sock* sock; if (!(sock = schedd.startCommand(QUERY_SCHEDD_HISTORY, Stream::reli_sock, 0))) { fprintf(stderr, "Unable to send history command to remote schedd;\n" "Typically, either the schedd is not responding, does not authorize you, or does not support remote history.\n"); exit(1); } classad_shared_ptr<Sock> sock_sentry(sock); if (!putClassAd(sock, ad) || !sock->end_of_message()) { fprintf(stderr, "Unable to send request to remote schedd; likely a server or network error.\n"); exit(1); } while (true) { compat_classad::ClassAd ad; if (!getClassAd(sock, ad)) { fprintf(stderr, "Failed to recieve remote ad.\n"); exit(1); } long long intVal; if (ad.EvaluateAttrInt(ATTR_OWNER, intVal) && (intVal == 0)) { // Last ad. if (!sock->end_of_message()) { fprintf(stderr, "Unable to close remote socket.\n"); } sock->close(); std::string errorMsg; if (ad.EvaluateAttrInt(ATTR_ERROR_CODE, intVal) && intVal && ad.EvaluateAttrString(ATTR_ERROR_STRING, errorMsg)) { fprintf(stderr, "Error %lld: %s\n", intVal, errorMsg.c_str()); exit(intVal); } if (ad.EvaluateAttrInt("MalformedAds", intVal) && intVal) { fprintf(stderr, "Remote side had parse errors on history file"); exit(1); } if (!ad.EvaluateAttrInt(ATTR_NUM_MATCHES, intVal) || (intVal != matchCount)) { fprintf(stderr, "Client and server do not agree on number of ads sent;\n" "Indicates lost network packets or an internal error\n"); exit(1); } break; } matchCount++; printJob(ad); } if(longformat && use_xml) { std::string out; AddClassAdXMLFileFooter(out); printf("%s\n", out.c_str()); } }
int CondorQ::fetchQueueFromHostAndProcessV2(const char *host, const char *constraint, StringList &attrs, condor_q_process_func process_func, void * process_func_data, int connect_timeout, CondorError *errstack) { classad::ClassAdParser parser; classad::ExprTree *expr = NULL; parser.ParseExpression(constraint, expr); if (!expr) return Q_INVALID_REQUIREMENTS; classad::ExprList *projList = new classad::ExprList(); if (!projList) return Q_INTERNAL_ERROR; attrs.rewind(); const char *attr; while ((attr = attrs.next())) { classad::Value value; value.SetStringValue(attr); classad::ExprTree *entry = classad::Literal::MakeLiteral(value); if (!entry) return Q_INTERNAL_ERROR; projList->push_back(entry); } classad::ClassAd ad; ad.Insert(ATTR_REQUIREMENTS, expr); classad::ExprTree *projTree = static_cast<classad::ExprTree*>(projList); ad.Insert(ATTR_PROJECTION, projTree); DCSchedd schedd(host); Sock* sock; if (!(sock = schedd.startCommand(QUERY_JOB_ADS, Stream::reli_sock, connect_timeout, errstack))) return Q_SCHEDD_COMMUNICATION_ERROR; classad_shared_ptr<Sock> sock_sentry(sock); if (!putClassAd(sock, ad) || !sock->end_of_message()) return Q_SCHEDD_COMMUNICATION_ERROR; dprintf(D_FULLDEBUG, "Sent classad to schedd\n"); do { classad_shared_ptr<compat_classad::ClassAd> ad(new ClassAd()); if (!getClassAd(sock, *ad.get())) return Q_SCHEDD_COMMUNICATION_ERROR; if (!sock->end_of_message()) return Q_SCHEDD_COMMUNICATION_ERROR; dprintf(D_FULLDEBUG, "Got classad from schedd.\n"); long long intVal; if (ad->EvaluateAttrInt(ATTR_OWNER, intVal) && (intVal == 0)) { // Last ad. sock->close(); dprintf(D_FULLDEBUG, "Ad was last one from schedd.\n"); std::string errorMsg; if (ad->EvaluateAttrInt(ATTR_ERROR_CODE, intVal) && intVal && ad->EvaluateAttrString(ATTR_ERROR_STRING, errorMsg)) { if (errstack) errstack->push("TOOL", intVal, errorMsg.c_str()); return Q_REMOTE_ERROR; } break; } (*process_func) (process_func_data, ad); } while (true); return 0; }