void
CCBServer::ForwardRequestToTarget( CCBServerRequest *request, CCBTarget *target )
{
Sock *sock = target->getSock();
ClassAd msg;
msg.Assign( ATTR_COMMAND, CCB_REQUEST );
msg.Assign( ATTR_MY_ADDRESS, request->getReturnAddr() );
msg.Assign( ATTR_CLAIM_ID, request->getConnectID() );
// for easier debugging
msg.Assign( ATTR_NAME, request->getSock()->peer_description() );
MyString reqid_str;
CCBIDToString( request->getRequestID(), reqid_str);
msg.Assign( ATTR_REQUEST_ID, reqid_str );
sock->encode();
if( !msg.put( *sock ) || !sock->end_of_message() ) {
dprintf(D_ALWAYS,
"CCB: failed to forward request id %lu from %s to target "
"daemon %s with ccbid %lu\n",
request->getRequestID(),
request->getSock()->peer_description(),
target->getSock()->peer_description(),
target->getCCBID());
RequestFinished( request, false, "failed to forward request to target" );
return;
}
// Now wait for target to respond (HandleRequestResultsMsg).
// We will get the response next time we poll the socket.
// To get a faster response, we _could_ register the socket
// now, if it has not already been registered.
}
bool
DCStartd::locateStarter( const char* global_job_id,
const char *claimId,
const char *schedd_public_addr,
ClassAd* reply,
int timeout )
{
setCmdStr( "locateStarter" );
ClassAd req;
// Add our own attributes to the request ad we're sending
req.Assign(ATTR_COMMAND,getCommandString( CA_LOCATE_STARTER ));
req.Assign(ATTR_GLOBAL_JOB_ID,global_job_id);
req.Assign(ATTR_CLAIM_ID, claimId);
if ( schedd_public_addr ) {
req.Assign(ATTR_SCHEDD_IP_ADDR,schedd_public_addr);
}
// if this claim is associated with a security session
ClaimIdParser cidp( claimId );
return sendCACmd( &req, reply, false, timeout, cidp.secSessionId() );
}
bool
TransferQueueRequest::SendGoAhead(XFER_QUEUE_ENUM go_ahead,char const *reason) {
ASSERT( m_sock );
m_sock->encode();
ClassAd msg;
msg.Assign(ATTR_RESULT,(int)go_ahead);
if( reason ) {
msg.Assign(ATTR_ERROR_STRING,reason);
}
// how often should transfer processes send a report of I/O activity
// 0 means never
int report_interval = param_integer("TRANSFER_IO_REPORT_INTERVAL",10,0);
msg.Assign(ATTR_REPORT_INTERVAL,report_interval);
if(!putClassAd( m_sock, msg ) || !m_sock->end_of_message()) {
dprintf(D_ALWAYS,
"TransferQueueRequest: failed to send GoAhead to %s\n",
Description() );
return false;
}
m_gave_go_ahead = true;
m_time_go_ahead = time(NULL);
return true;
}
bool BaseResource::Invalidate () {
ClassAd ad;
/* Set the correct types */
SetMyTypeName ( ad, GRID_ADTYPE );
/* We only want to invalidate this resource. Using the tuple
(HashName,SchedName,Owner) as unique id. */
std::string line;
formatstr( line,
"((TARGET.%s =?= \"%s\") && (TARGET.%s =?= \"%s\") && "
"(TARGET.%s =?= \"%s\") && (TARGET.%s =?= \"%s\"))",
ATTR_HASH_NAME, GetHashName (),
ATTR_SCHEDD_NAME, ScheddObj->name (),
ATTR_SCHEDD_IP_ADDR, ScheddObj->addr (),
ATTR_OWNER, myUserName );
ad.AssignExpr ( ATTR_REQUIREMENTS, line.c_str() );
ad.Assign( ATTR_HASH_NAME, GetHashName() );
ad.Assign( ATTR_SCHEDD_NAME, ScheddObj->name() );
ad.Assign( ATTR_SCHEDD_IP_ADDR, ScheddObj->addr() );
ad.Assign( ATTR_OWNER, myUserName );
dprintf (
D_FULLDEBUG,
"BaseResource::InvalidateResource: \n%s\n",
line.c_str() );
return daemonCore->sendUpdates( INVALIDATE_GRID_ADS, &ad, NULL, true ) > 0;
}
Manageable::status_t
Triggerd::AddTrigger(std::string name, std::string query, std::string triggerText, std::string& text)
{
std::string attr;
ClassAd* ad = new ClassAd();
Manageable::status_t ret_val;
char* tmp;
SetMyTypeName(*ad, "EventTrigger");
SetTargetTypeName(*ad, "Trigger");
tmp = strdup(name.c_str());
ReplaceAllChars(tmp, '"', '\'');
ad->Assign(ATTR_TRIGGER_NAME, tmp);
free(tmp);
tmp = strdup(query.c_str());
ReplaceAllChars(tmp, '"', '\'');
ad->Assign(ATTR_TRIGGER_QUERY, tmp);
free(tmp);
tmp = strdup(triggerText.c_str());
ReplaceAllChars(tmp, '"', '\'');
ad->Assign(ATTR_TRIGGER_TEXT, tmp);
free(tmp);
ret_val = AddTrigger(ad, text);
delete ad;
return ret_val;
}
ClassAd *CollectorEngine::
collect (int command, Sock *sock, const condor_sockaddr& from, int &insert)
{
ClassAd *clientAd;
ClassAd *rval;
_condor_auto_accum_runtime<collector_runtime_probe> rt(CollectorEngine_ruc_runtime);
double rt_last = rt.begin;
// Avoid lengthy blocking on communication with our peer.
// This command-handler should not get called until data
// is ready to read.
sock->timeout(1);
// get the ad
clientAd = new ClassAd;
if (!clientAd) return 0;
if( !getClassAdEx(sock, *clientAd, m_get_ad_options) )
{
dprintf (D_ALWAYS,"Command %d on Sock not followed by ClassAd (or timeout occured)\n",
command);
delete clientAd;
sock->end_of_message();
return 0;
}
double delta_time = rt.tick(rt_last);
CollectorEngine_ruc_getAd_runtime.Add(delta_time);
// insert the authenticated user into the ad itself
const char* authn_user = sock->getFullyQualifiedUser();
if (authn_user) {
clientAd->Assign("AuthenticatedIdentity", authn_user);
clientAd->Assign("AuthenticationMethod", sock->getAuthenticationMethodUsed());
} else {
// remove it from the ad if it's not authenticated.
clientAd->Delete("AuthenticatedIdentity");
clientAd->Delete("AuthenticationMethod");
}
CollectorEngine_ruc_authid_runtime.Add(rt.tick(rt_last));
rval = collect(command, clientAd, from, insert, sock);
CollectorEngine_ruc_collect_runtime.Add(rt.tick(rt_last));
// Don't leak the ad on error!
if ( ! rval ) {
delete clientAd;
}
// get the end_of_message()
if (!sock->end_of_message())
{
dprintf(D_FULLDEBUG,"Warning: Command %d; maybe shedding data on eom\n",
command);
}
return rval;
}
void assign_preserve_integers(ClassAd& ad, const char* attr, double v) {
if ((v - floor(v)) > 0.0) {
ad.Assign(attr, v);
} else {
ad.Assign(attr, (long long)(v));
}
}
bool
DCStartd::releaseClaim( VacateType vType, ClassAd* reply,
int timeout )
{
setCmdStr( "releaseClaim" );
if( ! checkClaimId() ) {
return false;
}
if( ! checkVacateType(vType) ) {
return false;
}
ClassAd req;
// Add our own attributes to the request ad we're sending
req.Assign( ATTR_COMMAND, getCommandString(CA_RELEASE_CLAIM) );
req.Assign( ATTR_CLAIM_ID, claim_id );
req.Assign( ATTR_VACATE_TYPE, getVacateTypeString(vType) );
// since release could take a while, if we didn't already get
// told what timeout to use, set the timeout to 0 so we don't
// bail out prematurely...
if( timeout < 0 ) {
return sendCACmd( &req, reply, true, 0 );
} else {
return sendCACmd( &req, reply, true, timeout );
}
}
bool
CCBListener::RegisterWithCCBServer(bool blocking)
{
ClassAd msg;
if( m_waiting_for_connect || m_reconnect_timer != -1 || m_waiting_for_registration || m_registered) {
// already registered or being registered
return m_registered;
}
msg.Assign( ATTR_COMMAND, CCB_REGISTER );
if( !m_ccbid.IsEmpty() ) {
// we are reconnecting; trying to preserve ccbid so that prospective
// clients with stale information can still contact us
msg.Assign( ATTR_CCBID, m_ccbid.Value() );
msg.Assign( ATTR_CLAIM_ID, m_reconnect_cookie.Value() );
}
// for debugging purposes only, identify ourselves to the CCB server
MyString name;
name.formatstr("%s %s",get_mySubSystem()->getName(),daemonCore->publicNetworkIpAddr());
msg.Assign( ATTR_NAME, name.Value() );
bool success = SendMsgToCCB(msg,blocking);
if( success ) {
if( blocking ) {
success = ReadMsgFromCCB();
}
else {
// now we wait for CCB server to respond with our CCBID
m_waiting_for_registration = true;
}
}
return success;
}
void
CCBListener::ReportReverseConnectResult(ClassAd *connect_msg,bool success,char const *error_msg)
{
ClassAd msg = *connect_msg;
MyString request_id;
MyString address;
connect_msg->LookupString(ATTR_REQUEST_ID,request_id);
connect_msg->LookupString(ATTR_MY_ADDRESS,address);
if( !success ) {
dprintf(D_ALWAYS,
"CCBListener: failed to create reversed connection for "
"request id %s to %s: %s\n",
request_id.Value(),
address.Value(),
error_msg ? error_msg : "");
}
else {
dprintf(D_FULLDEBUG|D_NETWORK,
"CCBListener: created reversed connection for "
"request id %s to %s: %s\n",
request_id.Value(),
address.Value(),
error_msg ? error_msg : "");
}
msg.Assign(ATTR_RESULT,success);
if( error_msg ) {
msg.Assign(ATTR_ERROR_STRING,error_msg);
}
WriteMsgToCCB( msg );
}
void
HibernationManager::publish ( ClassAd &ad )
{
/* "HibernationLevel" on a running StartD is always zero;
that is, it's always "running" if it is up. We still hold
this in a variable, as we will publish the sleep state in
the last ad that is sent to the Collector*/
int level = sleepStateToInt( m_target_state );
const char *state = sleepStateToString( m_target_state );
ad.Assign ( ATTR_HIBERNATION_LEVEL, level );
ad.Assign ( ATTR_HIBERNATION_STATE, state );
MyString states;
getSupportedStates( states );
ad.Assign ( ATTR_HIBERNATION_SUPPORTED_STATES, states );
/* publish whether or not we can enter a state of hibernation */
ad.Assign ( ATTR_CAN_HIBERNATE, canHibernate () );
/* publish everything we know about the public
network adapter */
if ( m_primary_adapter ) {
m_primary_adapter->publish( ad );
}
}
// specialization: this GetFullAd has to retrieve its classad attributes
// from the history file based on index pointers
void
HistoryJobImpl::GetFullAd ( ClassAd& _ad) const
{
// fseek to he.start
// ClassAd method to deserialize from a file with "***"
FILE * hFile;
int end = 0;
int error = 0;
int empty = 0;
std::ostringstream buf;
// placeholder in case we want to expose error details to UI
std::string text;
// TODO: move the ClassAd/file deserialize back to HistoryFile???
const char* fName = m_he.file.c_str();
if ( ! ( hFile = safe_fopen_wrapper ( fName, "r" ) ) )
{
buf << "unable to open history file " << m_he.file;
text = buf.str();
dprintf ( D_ALWAYS, "%s\n", text.c_str());
_ad.Assign("JOB_AD_ERROR",text.c_str());
return;
}
if ( fseek ( hFile , m_he.start , SEEK_SET ) )
{
buf << "bad seek in " << m_he.file << " at " << m_he.start;
text = buf.str();
dprintf ( D_ALWAYS, "%s\n", text.c_str());
_ad.Assign("JOB_AD_ERROR",text.c_str());
return;
}
ClassAd myJobAd ( hFile, "***", end, error, empty );
fclose ( hFile );
// TODO: debug logging and error to i/f for now
// we might not have our original history file anymore
if ( error )
{
buf << "malformed ad for job '" << m_job->GetKey() << "' in " << m_he.file;
text = buf.str();
dprintf ( D_FULLDEBUG, "%s\n", text.c_str());
_ad.Assign("JOB_AD_ERROR",text.c_str());
return;
}
if ( empty )
{
buf << "empty ad for job '" << m_job->GetKey() << "' in " << m_he.file;
text = buf.str();
dprintf ( D_FULLDEBUG,"%s\n", text.c_str());
_ad.Assign("JOB_AD_ERROR",text.c_str());
return;
}
_ad = myJobAd;
}
int do_command_upload_sandbox(void *arg, Stream*) {
dprintf(D_ALWAYS, "FTGAHP: upload sandbox\n");
Gahp_Args args;
parse_gahp_command ((char*)arg, &args);
// first two args: result id and sandbox id:
std::string rid = args.argv[1];
std::string sid = args.argv[2];
// third arg: job ad
ClassAd ad;
classad::ClassAdParser my_parser;
if (!(my_parser.ParseClassAd(args.argv[3], ad))) {
// FAIL
write_to_pipe( ChildErrorPipe, "Failed to parse job ad" );
return 1;
}
// rewrite the IWD to the actual sandbox dir
std::string iwd;
define_sandbox_path(sid, iwd);
ad.Assign(ATTR_JOB_IWD, iwd.c_str());
char ATTR_SANDBOX_ID[] = "SandboxId";
ad.Assign(ATTR_SANDBOX_ID, sid.c_str());
// directory was created, let's set up the FileTransfer object
FileTransfer ft;
if (!ft.Init(&ad)) {
// FAIL
write_to_pipe( ChildErrorPipe, "Failed to initialize FileTransfer" );
return 1;
}
// lookup ATTR_VERSION and set it. this changes the wire
// protocol and it is important that this happens before
// calling UploadFiles.
char* peer_version = NULL;
ad.LookupString(ATTR_VERSION, &peer_version);
ft.setPeerVersion(peer_version);
free (peer_version);
dprintf(D_ALWAYS, "BOSCO: calling upload files\n");
// the "true" param to UploadFiles here means blocking (i.e. "in the foreground")
if (!ft.UploadFiles(true)) {
// FAIL
write_to_pipe( ChildErrorPipe, ft.GetInfo().error_desc.Value() );
return 1;
}
// SUCCEED
return 0;
}
void StarterStatistics::Publish(ClassAd& ad, int flags) const {
if ((flags & IF_PUBLEVEL) > 0) {
ad.Assign("StatsLifetime", (int)StatsLifetime);
if (flags & IF_VERBOSEPUB)
ad.Assign("StatsLastUpdateTime", (int)StatsLastUpdateTime);
if (flags & IF_RECENTPUB) {
ad.Assign("RecentStatsLifetime", (int)RecentStatsLifetime);
if (flags & IF_VERBOSEPUB) {
ad.Assign("RecentWindowMax", (int)RecentWindowMax);
ad.Assign("RecentStatsTickTime", (int)RecentStatsTickTime);
}
}
}
Pool.Publish(ad, flags);
if ((flags & IF_PUBLEVEL) > 0) {
ad.Assign(ATTR_BLOCK_READ_KBYTES, this->BlockReadBytes.value / 1024);
ad.Assign(ATTR_BLOCK_WRITE_KBYTES, this->BlockWriteBytes.value / 1024);
if (flags & IF_RECENTPUB) {
ad.Assign("Recent" ATTR_BLOCK_WRITE_KBYTES, this->BlockWriteBytes.recent / 1024);
ad.Assign("Recent" ATTR_BLOCK_READ_KBYTES, this->BlockReadBytes.recent / 1024);
}
}
}
bool
DCStarter::createJobOwnerSecSession(int timeout,char const *job_claim_id,char const *starter_sec_session,char const *session_info,MyString &owner_claim_id,MyString &error_msg,MyString &starter_version,MyString &starter_addr)
{
ReliSock sock;
if (IsDebugLevel(D_COMMAND)) {
dprintf (D_COMMAND, "DCStarter::createJobOwnerSecSession(%s,...) making connection to %s\n",
getCommandStringSafe(CREATE_JOB_OWNER_SEC_SESSION), _addr ? _addr : "NULL");
}
if( !connectSock(&sock, timeout, NULL) ) {
error_msg = "Failed to connect to starter";
return false;
}
if( !startCommand(CREATE_JOB_OWNER_SEC_SESSION, &sock,timeout,NULL,NULL,false,starter_sec_session) ) {
error_msg = "Failed to send CREATE_JOB_OWNER_SEC_SESSION to starter";
return false;
}
ClassAd input;
input.Assign(ATTR_CLAIM_ID,job_claim_id);
input.Assign(ATTR_SESSION_INFO,session_info);
sock.encode();
if( !putClassAd(&sock, input) || !sock.end_of_message() ) {
error_msg = "Failed to compose CREATE_JOB_OWNER_SEC_SESSION to starter";
return false;
}
sock.decode();
ClassAd reply;
if( !getClassAd(&sock, reply) || !sock.end_of_message() ) {
error_msg = "Failed to get response to CREATE_JOB_OWNER_SEC_SESSION from starter";
return false;
}
bool success = false;
reply.LookupBool(ATTR_RESULT,success);
if( !success ) {
reply.LookupString(ATTR_ERROR_STRING,error_msg);
return false;
}
reply.LookupString(ATTR_CLAIM_ID,owner_claim_id);
reply.LookupString(ATTR_VERSION,starter_version);
// get the full starter address from the starter in case it contains
// extra CCB info that we don't already know about
reply.LookupString(ATTR_STARTER_IP_ADDR,starter_addr);
return true;
}
void stats_entry_recent<Probe>::PublishDebug(ClassAd & ad, const char * pattr, int flags) const
{
MyString str;
MyString var1;
MyString var2;
ProbeToStringDebug(var1, this->value);
ProbeToStringDebug(var2, this->recent);
str.sprintf_cat("(%s) (%s)", var1.Value(), var2.Value());
str.sprintf_cat(" {h:%d c:%d m:%d a:%d}",
this->buf.ixHead, this->buf.cItems, this->buf.cMax, this->buf.cAlloc);
if (this->buf.pbuf) {
for (int ix = 0; ix < this->buf.cAlloc; ++ix) {
ProbeToStringDebug(var1, this->buf.pbuf[ix]);
str.sprintf_cat(!ix ? "[%s" : (ix == this->buf.cMax ? "|%s" : ",%s"), var1.Value());
}
str += "]";
}
MyString attr(pattr);
if (flags & this->PubDecorateAttr)
attr += "Debug";
ad.Assign(pattr, str);
}
void cp_compute_consumption(ClassAd& job, ClassAd& resource, consumption_map_t& consumption) {
consumption.clear();
string mrv;
if (!resource.LookupString(ATTR_MACHINE_RESOURCES, mrv)) {
EXCEPT("Resource ad missing %s attribute", ATTR_MACHINE_RESOURCES);
}
StringList alist(mrv.c_str());
alist.rewind();
while (char* asset = alist.next()) {
if (MATCH == strcasecmp(asset, "swap")) continue;
string ra;
string coa;
formatstr(ra, "%s%s", ATTR_REQUEST_PREFIX, asset);
formatstr(coa, "_condor_%s", ra.c_str());
bool override = false;
double ov=0;
if (job.EvalFloat(coa.c_str(), NULL, ov)) {
// Allow _condor_RequestedXXX to override RequestedXXX
// this case is intended to be operative when a scheduler has set
// such values and sent them on to the startd that owns this resource
// (e.g. I'd not expect this case to arise elsewhere, like the negotiator)
string ta;
formatstr(ta, "_cp_temp_%s", ra.c_str());
job.CopyAttribute(ta.c_str(), ra.c_str());
job.Assign(ra.c_str(), ov);
override = true;
}
void stats_entry_recent_histogram<T>::PublishDebug(ClassAd & ad, const char * pattr, int flags) const {
MyString str("(");
this->value.AppendToString(str);
str += ") (";
this->recent.AppendToString(str);
str.formatstr_cat(") {h:%d c:%d m:%d a:%d}",
this->buf.ixHead, this->buf.cItems, this->buf.cMax, this->buf.cAlloc);
if (this->buf.pbuf) {
for (int ix = 0; ix < this->buf.cAlloc; ++ix) {
// Note: this is tediously broken up into multiple lines because clang produces a format string
// warning otherwise.
if (!ix) {
str.formatstr_cat("[(");
} else if (ix == this->buf.cMax) {
str.formatstr_cat(")|(");
} else {
str.formatstr_cat(") (");
}
this->buf.pbuf[ix].AppendToString(str);
}
str += ")]";
}
MyString attr(pattr);
if (flags & this->PubDecorateAttr)
attr += "Debug";
ad.Assign(pattr, str);
}
void DefragStats::Publish(ClassAd & ad, int flags) const
{
if ((flags & IF_PUBLEVEL) > 0) {
ad.Assign("StatsLifetime", (int)Lifetime);
if (flags & IF_VERBOSEPUB)
ad.Assign("StatsLastUpdateTime", (int)LastUpdateTime);
if (flags & IF_RECENTPUB) {
ad.Assign("RecentStatsLifetime", (int)RecentLifetime);
if (flags & IF_VERBOSEPUB) {
ad.Assign("RecentWindowMax", (int)RecentWindowMax);
ad.Assign("RecentStatsTickTime", (int)RecentTickTime);
}
}
}
Pool.Publish(ad, flags);
}
bool
DCStartd::resumeClaim( ClassAd* reply, int timeout )
{
setCmdStr( "resumeClaim" );
if( ! checkClaimId() ) {
return false;
}
ClassAd req;
// Add our own attributes to the request ad we're sending
req.Assign( ATTR_COMMAND, getCommandString(CA_RESUME_CLAIM) );
req.Assign( ATTR_CLAIM_ID, claim_id );
return sendCACmd( &req, reply, true, timeout );
}
void DaemonCore::Stats::Publish(ClassAd & ad, int flags) const
{
if ((flags & IF_PUBLEVEL) > 0) {
ad.Assign("DCStatsLifetime", (int)StatsLifetime);
if (flags & IF_VERBOSEPUB)
ad.Assign("DCStatsLastUpdateTime", (int)StatsLastUpdateTime);
if (flags & IF_RECENTPUB) {
ad.Assign("DCRecentStatsLifetime", (int)RecentStatsLifetime);
if (flags & IF_VERBOSEPUB) {
ad.Assign("DCRecentStatsTickTime", (int)RecentStatsTickTime);
ad.Assign("DCRecentWindowMax", (int)RecentWindowMax);
}
}
}
double dDutyCycle = 0.0;
if (this->PumpCycle.value.Count) {
if (this->PumpCycle.value.Sum > 1e-9)
dDutyCycle = 1.0 - (this->SelectWaittime.value / this->PumpCycle.value.Sum);
}
ad.Assign("DaemonCoreDutyCycle", dDutyCycle);
dDutyCycle = 0.0;
if (this->PumpCycle.recent.Count) {
// sometimes select-wait-time can be < pump-cycle-time because of recent window
// jitter and accumulated errors adding doubles together. when that happens
// the calculated duty cycle can be negative. we don't want to publish negative
// numbers so we suppress the actual value and publish 0 instead.
double dd = 1.0 - (this->SelectWaittime.recent / this->PumpCycle.recent.Sum);
if (dd > 0.0) dDutyCycle = dd;
}
ad.Assign("RecentDaemonCoreDutyCycle", dDutyCycle);
Pool.Publish(ad, flags);
}
void test_user_policy_periodic_exit_yes(void)
{
int val;
int action;
char buf[4096];
ClassAd *result;
ClassAd *jad = new ClassAd;
if (jad == NULL)
{
printf("Out of memory!\n");
exit(EXIT_FAILURE);
}
printf("=========================================\n");
printf("Testing User Policy on Periodic Exit: YES\n");
/* set up the classad */
sprintf(buf, "%s = 42", ATTR_TOTAL_SUSPENSIONS);
jad->Insert(buf);
sprintf(buf, "%s = FALSE", ATTR_PERIODIC_HOLD_CHECK);
jad->Insert(buf);
sprintf(buf, "%s = TotalSuspensions == 42", ATTR_PERIODIC_REMOVE_CHECK);
jad->Insert(buf);
sprintf(buf, "%s = FALSE", ATTR_ON_EXIT_HOLD_CHECK);
jad->Insert(buf);
sprintf(buf, "%s = TRUE", ATTR_ON_EXIT_REMOVE_CHECK);
jad->Insert(buf);
jad->Assign(ATTR_JOB_STATUS, RUNNING);
result = user_job_policy(jad);
result->EvalBool(ATTR_USER_POLICY_ERROR, result, val);
if(val == true)
{
printf("An error happened\n");
delete result;
return;
}
result->EvalBool(ATTR_TAKE_ACTION, result, val);
if (val == true)
{
printf("%s was true.\n", ATTR_TAKE_ACTION);
result->LookupInteger(ATTR_USER_POLICY_ACTION, action);
printf("Action is: %s\n",
action==REMOVE_JOB?"REMOVE_JOB":action==HOLD_JOB?"HOLD_JOB":
"UNKNOWN");
result->LookupString(ATTR_USER_POLICY_FIRING_EXPR, buf);
printf("Reason for action: %s\n", buf);
}
else
{
printf("Something went wrong. I should have had an action to take.\n");
}
}
void
CCBServer::RequestReply( Sock *sock, bool success, char const *error_msg, CCBID request_cid, CCBID target_cid )
{
if( success && sock->readReady() ) {
// the client must have disconnected (which is expected if
// the client has already received the reversed connection)
return;
}
ClassAd msg;
msg.Assign( ATTR_RESULT, success );
msg.Assign( ATTR_ERROR_STRING, error_msg );
sock->encode();
if( !msg.put( *sock ) || !sock->end_of_message() ) {
// Would like to be completely quiet if success and the
// client has disconnected, since this is normal; however,
// the above write operations will generate noise when
// they fail, so at least in FULLDEBUG, we explain what's
// going on. Note that most of the time, we should not get
// here for successful requests, because we either observe
// the client disconnect earlier, or the above check on
// the socket catches it. Why bother sending a reply on
// success at all? Because if the client has not yet
// seen the reverse connect and we just disconnect without
// telling it the request was successful, then it will
// think something has gone wrong.
dprintf(success ? D_FULLDEBUG : D_ALWAYS,
"CCB: failed to send result (%s) for request id %lu "
"from %s requesting a reversed connection to target daemon "
"with ccbid %lu: %s %s\n",
success ? "request succeeded" : "request failed",
request_cid,
sock->peer_description(),
target_cid,
error_msg,
success ? "(since the request was successful, it is expected "
"that the client may disconnect before receiving "
"results)" : "" );
}
}
int ClassAdAssign(ClassAd & ad, const char * pattr, const Probe& probe)
{
MyString attr;
attr.sprintf("%sCount", pattr);
ad.Assign(attr.Value(), probe.Count);
attr.sprintf("%sSum", pattr);
int ret = ad.Assign(attr.Value(), probe.Sum);
if (probe.Count > 0)
{
attr.sprintf("%sAvg", pattr);
ad.Assign(attr.Value(), probe.Avg());
attr.sprintf("%sMin", pattr);
ad.Assign(attr.Value(), probe.Min);
attr.sprintf("%sMax", pattr);
ad.Assign(attr.Value(), probe.Max);
attr.sprintf("%sStd", pattr);
ad.Assign(attr.Value(), probe.Std());
}
return ret;
}
bool
BaseCodec::mapToClassAd(AttributeMapType& _map, ClassAd& ad, string& text)
{
for (AttributeMapIterator entry = _map.begin(); _map.end() != entry; entry++) {
const char* name = entry->first.c_str();
if (isKeyword(name)) {
text = "Reserved ClassAd keyword cannot be an attribute name: "+ entry->first;
return false;
}
AviaryAttribute* value = entry->second;
switch (value->getType()) {
case AviaryAttribute::INTEGER_TYPE:
ad.Assign(name, atoi(value->getValue()));
break;
case AviaryAttribute::FLOAT_TYPE:
ad.Assign(name, atof(value->getValue()));
break;
case AviaryAttribute::STRING_TYPE:
ad.Assign(name, value->getValue());
break;
case AviaryAttribute::EXPR_TYPE:
ad.AssignExpr(name, value->getValue());
break;
default:
dprintf(D_FULLDEBUG, "Warning: Unknown/unsupported type in map for attribute '%s'\n", name);
}
}
// // debug
// if (IsFulldebug(D_FULLDEBUG)) {
// ad.dPrint(D_FULLDEBUG|D_NOHEADER);
// }
return true;
}
void
NetworkAdapterBase::publish ( ClassAd &ad )
{
ad.Assign ( ATTR_HARDWARE_ADDRESS, hardwareAddress () );
ad.Assign ( ATTR_SUBNET_MASK, subnetMask () );
ad.Assign ( ATTR_IS_WAKE_SUPPORTED, isWakeSupported () );
ad.Assign ( ATTR_IS_WAKE_ENABLED, isWakeEnabled () );
ad.Assign ( ATTR_IS_WAKEABLE, isWakeable() );
MyString tmp;
ad.Assign ( ATTR_WAKE_SUPPORTED_FLAGS, wakeSupportedString(tmp) );
ad.Assign ( ATTR_WAKE_ENABLED_FLAGS, wakeEnabledString(tmp) );
}
ClassAd *CollectorEngine::
collect (int command, Sock *sock, const condor_sockaddr& from, int &insert)
{
ClassAd *clientAd;
ClassAd *rval;
// Avoid lengthy blocking on communication with our peer.
// This command-handler should not get called until data
// is ready to read.
sock->timeout(1);
clientAd = new ClassAd;
if (!clientAd) return 0;
// get the ad
if( !clientAd->initFromStream(*sock) )
{
dprintf (D_ALWAYS,"Command %d on Sock not follwed by ClassAd (or timeout occured)\n",
command);
delete clientAd;
sock->end_of_message();
return 0;
}
// insert the authenticated user into the ad itself
const char* authn_user = sock->getFullyQualifiedUser();
if (authn_user) {
clientAd->Assign("AuthenticatedIdentity", authn_user);
} else {
// remove it from the ad if it's not authenticated.
clientAd->Delete("AuthenticatedIdentity");
}
rval = collect(command, clientAd, from, insert, sock);
// Don't leak the ad on error!
if ( ! rval ) {
delete clientAd;
}
// get the end_of_message()
if (!sock->end_of_message())
{
dprintf(D_FULLDEBUG,"Warning: Command %d; maybe shedding data on eom\n",
command);
}
return rval;
}
// using a constraint for which the schedd must iterate over all the jobads.
bool
DCSchedd::requestSandboxLocation(int direction, MyString &constraint,
int protocol, ClassAd *respad, CondorError * errstack)
{
ClassAd reqad;
////////////////////////////////////////////////////////////////////////
// This request specifies a collection of job ads as defined by a
// constraint. Later, then the transfer actually happens to the transferd,
// this constraint will get converted to actual job ads at that time and
// the client will have to get them back so it knows what to send.
////////////////////////////////////////////////////////////////////////
reqad.Assign(ATTR_TREQ_DIRECTION, direction);
reqad.Assign(ATTR_TREQ_PEER_VERSION, CondorVersion());
reqad.Assign(ATTR_TREQ_HAS_CONSTRAINT, true);
reqad.Assign(ATTR_TREQ_CONSTRAINT, constraint.Value());
// XXX This should be a realized function to convert between the
// protocol enum and a string description. That way both functions can
// use it and it won't seem so bad.
switch(protocol) {
case FTP_CFTP:
reqad.Assign(ATTR_TREQ_FTP, FTP_CFTP);
break;
default:
dprintf(D_ALWAYS, "DCSchedd::requestSandboxLocation(): "
"Can't make a request for a sandbox with an unknown file "
"transfer protocol!");
return false;
break;
}
// now connect to the schedd and get the response.
return requestSandboxLocation(&reqad, respad, errstack);
}
void test_user_policy_periodic_hold_no(void)
{
int val;
char buf[4096];
ClassAd *result;
ClassAd *jad = new ClassAd;
if (jad == NULL)
{
printf("Out of memory!\n");
exit(EXIT_FAILURE);
}
printf("========================================\n");
printf("Testing User Policy on Periodic Hold: NO\n");
/* set up the classad */
sprintf(buf, "%s = 40", ATTR_TOTAL_SUSPENSIONS);
jad->Insert(buf);
sprintf(buf, "%s = TotalSuspensions == 42", ATTR_PERIODIC_HOLD_CHECK);
jad->Insert(buf);
sprintf(buf, "%s = FALSE", ATTR_PERIODIC_REMOVE_CHECK);
jad->Insert(buf);
sprintf(buf, "%s = FALSE", ATTR_ON_EXIT_HOLD_CHECK);
jad->Insert(buf);
sprintf(buf, "%s = TRUE", ATTR_ON_EXIT_REMOVE_CHECK);
jad->Insert(buf);
jad->Assign(ATTR_JOB_STATUS, RUNNING);
result = user_job_policy(jad);
result->EvalBool(ATTR_USER_POLICY_ERROR, result, val);
if(val == true)
{
printf("An error happened\n");
delete result;
return;
}
result->EvalBool(ATTR_TAKE_ACTION, result, val);
if (val == true)
{
printf("Something went wrong. I should not have had an action.\n");
}
else
{
printf("Ignoring correctly.\n");
}
}
void
CCBListener::HeartbeatTime()
{
int age = time(NULL) - m_last_contact_from_peer;
if( age > 3*m_heartbeat_interval ) {
dprintf(D_ALWAYS, "CCBListener: no activity from CCB server in %ds; "
"assuming connection is dead.\n", age);
Disconnected();
return;
}
dprintf(D_FULLDEBUG, "CCBListener: sent heartbeat to server.\n");
ClassAd msg;
msg.Assign(ATTR_COMMAND, ALIVE);
SendMsgToCCB(msg,false);
}