bool
DCStartd::_suspendClaim( )
{
setCmdStr( "suspendClaim" );
if( ! checkClaimId() ) {
return false;
}
if( ! checkAddr() ) {
return false;
}
// if this claim is associated with a security session
ClaimIdParser cidp(claim_id);
char const *sec_session = cidp.secSessionId();
if (IsDebugLevel(D_COMMAND)) {
int cmd = SUSPEND_CLAIM;
dprintf (D_COMMAND, "DCStartd::_suspendClaim(%s,...) making connection to %s\n", getCommandStringSafe(cmd), _addr ? _addr : "NULL");
}
bool result;
ReliSock reli_sock;
reli_sock.timeout(20); // years of research... :)
if( ! reli_sock.connect(_addr) ) {
std::string err = "DCStartd::_suspendClaim: ";
err += "Failed to connect to startd (";
err += _addr ? _addr : "NULL";
err += ')';
newError( CA_CONNECT_FAILED, err.c_str() );
return false;
}
int cmd = SUSPEND_CLAIM;
result = startCommand( cmd, (Sock*)&reli_sock, 20, NULL, NULL, false, sec_session );
if( ! result ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::_suspendClaim: Failed to send command " );
return false;
}
// Now, send the ClaimId
if( ! reli_sock.put_secret(claim_id) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::_suspendClaim: Failed to send ClaimId to the startd" );
return false;
}
if( ! reli_sock.end_of_message() ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::_suspendClaim: Failed to send EOM to the startd" );
return false;
}
return true;
}
bool
DCStartd::drainJobs(int how_fast,bool resume_on_completion,char const *check_expr,char const *start_expr,std::string &request_id)
{
std::string error_msg;
ClassAd request_ad;
Sock *sock = startCommand( DRAIN_JOBS, Sock::reli_sock, 20 );
if( !sock ) {
formatstr(error_msg,"Failed to start DRAIN_JOBS command to %s",name());
newError(CA_FAILURE,error_msg.c_str());
return false;
}
request_ad.Assign(ATTR_HOW_FAST,how_fast);
request_ad.Assign(ATTR_RESUME_ON_COMPLETION,resume_on_completion);
if( check_expr ) {
request_ad.AssignExpr(ATTR_CHECK_EXPR,check_expr);
}
if( start_expr ) {
request_ad.AssignExpr(ATTR_START_EXPR,start_expr);
}
if( !putClassAd(sock, request_ad) || !sock->end_of_message() ) {
formatstr(error_msg,"Failed to compose DRAIN_JOBS request to %s",name());
newError(CA_FAILURE,error_msg.c_str());
delete sock;
return false;
}
sock->decode();
ClassAd response_ad;
if( !getClassAd(sock, response_ad) || !sock->end_of_message() ) {
formatstr(error_msg,"Failed to get response to DRAIN_JOBS request to %s",name());
newError(CA_FAILURE,error_msg.c_str());
delete sock;
return false;
}
response_ad.LookupString(ATTR_REQUEST_ID,request_id);
bool result = false;
int error_code = 0;
response_ad.LookupBool(ATTR_RESULT,result);
if( !result ) {
std::string remote_error_msg;
response_ad.LookupString(ATTR_ERROR_STRING,remote_error_msg);
response_ad.LookupInteger(ATTR_ERROR_CODE,error_code);
formatstr(error_msg,
"Received failure from %s in response to DRAIN_JOBS request: error code %d: %s",
name(),error_code,remote_error_msg.c_str());
newError(CA_FAILURE,error_msg.c_str());
delete sock;
return false;
}
delete sock;
return true;
}
bool
DCStartd::checkpointJob( const char* name_ckpt )
{
dprintf( D_FULLDEBUG, "Entering DCStartd::checkpointJob(%s)\n",
name_ckpt );
setCmdStr( "checkpointJob" );
if (IsDebugLevel(D_COMMAND)) {
int cmd = PCKPT_JOB;
dprintf (D_COMMAND, "DCStartd::checkpointJob(%s,...) making connection to %s\n", getCommandStringSafe(cmd), _addr ? _addr : "NULL");
}
bool result;
ReliSock reli_sock;
reli_sock.timeout(20); // years of research... :)
if( ! reli_sock.connect(_addr) ) {
std::string err = "DCStartd::checkpointJob: ";
err += "Failed to connect to startd (";
err += _addr ? _addr : "NULL";
err += ')';
newError( CA_CONNECT_FAILED, err.c_str() );
return false;
}
int cmd = PCKPT_JOB;
result = startCommand( cmd, (Sock*)&reli_sock );
if( ! result ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::checkpointJob: Failed to send command PCKPT_JOB to the startd" );
return false;
}
// Now, send the name
if( ! reli_sock.put(name_ckpt) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::checkpointJob: Failed to send Name to the startd" );
return false;
}
if( ! reli_sock.end_of_message() ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::checkpointJob: Failed to send EOM to the startd" );
return false;
}
// we're done
dprintf( D_FULLDEBUG, "DCStartd::checkpointJob: "
"successfully sent command\n" );
return true;
}
bool
DCStartd::cancelDrainJobs(char const *request_id)
{
std::string error_msg;
ClassAd request_ad;
Sock *sock = startCommand( CANCEL_DRAIN_JOBS, Sock::reli_sock, 20 );
if( !sock ) {
formatstr(error_msg,"Failed to start CANCEL_DRAIN_JOBS command to %s",name());
newError(CA_FAILURE,error_msg.c_str());
return false;
}
if( request_id ) {
request_ad.Assign(ATTR_REQUEST_ID,request_id);
}
if( !putClassAd(sock, request_ad) || !sock->end_of_message() ) {
formatstr(error_msg,"Failed to compose CANCEL_DRAIN_JOBS request to %s",name());
newError(CA_FAILURE,error_msg.c_str());
return false;
}
sock->decode();
ClassAd response_ad;
if( !getClassAd(sock, response_ad) || !sock->end_of_message() ) {
formatstr(error_msg,"Failed to get response to CANCEL_DRAIN_JOBS request to %s",name());
newError(CA_FAILURE,error_msg.c_str());
delete sock;
return false;
}
bool result = false;
int error_code = 0;
response_ad.LookupBool(ATTR_RESULT,result);
if( !result ) {
std::string remote_error_msg;
response_ad.LookupString(ATTR_ERROR_STRING,remote_error_msg);
response_ad.LookupInteger(ATTR_ERROR_CODE,error_code);
formatstr(error_msg,
"Received failure from %s in response to CANCEL_DRAIN_JOBS request: error code %d: %s",
name(),error_code,remote_error_msg.c_str());
newError(CA_FAILURE,error_msg.c_str());
delete sock;
return false;
}
delete sock;
return true;
}
bool
DCStartd::requestClaim( ClaimType cType, const ClassAd* req_ad,
ClassAd* reply, int timeout )
{
setCmdStr( "requestClaim" );
std::string err_msg;
switch( cType ) {
case CLAIM_COD:
case CLAIM_OPPORTUNISTIC:
break;
default:
err_msg = "Invalid ClaimType (";
err_msg += (int)cType;
err_msg += ')';
newError( CA_INVALID_REQUEST, err_msg.c_str() );
return false;
}
ClassAd req( *req_ad );
char buf[1024];
// Add our own attributes to the request ad we're sending
sprintf( buf, "%s = \"%s\"", ATTR_COMMAND,
getCommandString(CA_REQUEST_CLAIM) );
req.Insert( buf );
sprintf( buf, "%s = \"%s\"", ATTR_CLAIM_TYPE, getClaimTypeString(cType) );
req.Insert( buf );
return sendCACmd( &req, reply, true, timeout );
}
bool
DCCollector::initiateTCPUpdate( int cmd, ClassAd* ad1, ClassAd* ad2, bool nonblocking )
{
if( update_rsock ) {
delete update_rsock;
update_rsock = NULL;
}
if(nonblocking) {
UpdateData *ud = new UpdateData(cmd, Sock::reli_sock, ad1, ad2, this);
// Note that UpdateData automatically adds itself to the pending_update_list.
if (this->pending_update_list.size() == 1)
{
startCommand_nonblocking(cmd, Sock::reli_sock, 20, NULL, UpdateData::startUpdateCallback, ud );
}
return true;
}
Sock *sock = startCommand(cmd, Sock::reli_sock, 20);
if(!sock) {
newError( CA_COMMUNICATION_ERROR,
"Failed to send TCP update command to collector" );
dprintf(D_ALWAYS,"Failed to send update to %s.\n",idStr());
return false;
}
update_rsock = (ReliSock *)sock;
return finishUpdate( this, update_rsock, ad1, ad2 );
}
bool
DCStartd::checkpointJob( const char* name_ckpt )
{
dprintf( D_FULLDEBUG, "Entering DCStartd::checkpointJob(%s)\n",
name_ckpt );
setCmdStr( "checkpointJob" );
bool result;
ReliSock reli_sock;
reli_sock.timeout(20); // years of research... :)
if( ! reli_sock.connect(_addr) ) {
std::string err = "DCStartd::checkpointJob: ";
err += "Failed to connect to startd (";
err += _addr;
err += ')';
newError( CA_CONNECT_FAILED, err.c_str() );
return false;
}
int cmd = PCKPT_JOB;
result = startCommand( cmd, (Sock*)&reli_sock );
if( ! result ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::checkpointJob: Failed to send command PCKPT_JOB to the startd" );
return false;
}
// Now, send the name
if( ! reli_sock.code((unsigned char *)const_cast<char*>(name_ckpt)) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::checkpointJob: Failed to send Name to the startd" );
return false;
}
if( ! reli_sock.end_of_message() ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::checkpointJob: Failed to send EOM to the startd" );
return false;
}
// we're done
dprintf( D_FULLDEBUG, "DCStartd::checkpointJob: "
"successfully sent command\n" );
return true;
}
bool
DCStartd::vacateClaim( const char* name_vacate )
{
setCmdStr( "vacateClaim" );
if (IsDebugLevel(D_COMMAND)) {
int cmd = VACATE_CLAIM;
dprintf (D_COMMAND, "DCStartd::vacateClaim(%s,...) making connection to %s\n", getCommandStringSafe(cmd), _addr ? _addr : "NULL");
}
bool result;
ReliSock reli_sock;
reli_sock.timeout(20); // years of research... :)
if( ! reli_sock.connect(_addr) ) {
std::string err = "DCStartd::vacateClaim: ";
err += "Failed to connect to startd (";
err += _addr ? _addr : "NULL";
err += ')';
newError( CA_CONNECT_FAILED, err.c_str() );
return false;
}
int cmd = VACATE_CLAIM;
result = startCommand( cmd, (Sock*)&reli_sock );
if( ! result ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::vacateClaim: Failed to send command PCKPT_JOB to the startd" );
return false;
}
if( ! reli_sock.put(name_vacate) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::vacateClaim: Failed to send Name to the startd" );
return false;
}
if( ! reli_sock.end_of_message() ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::vacateClaim: Failed to send EOM to the startd" );
return false;
}
return true;
}
void eaps8000UsbUICharWindow::portError( QString error )
{
LOG(INFO) << this->windowTitle().toStdString() << ": port error: "
<< error.toStdString();
_ui->lbl_info->setText( error );
_ui->lbl_info->setStyleSheet( STYLE_ERROR );
emit newError( this->windowTitle() + ": " + error );
emit changeWindowState( this->windowTitle(), false );
}
void RKProgressControl::newOutput (RCommand *, ROutput *output) {
RK_TRACE (MISC);
RK_ASSERT (output);
if (output->type == ROutput::Output) {
newOutput (output->output);
} else {
newError (output->output);
}
}
void Error::newErrorPrototype(QScriptValueImpl *result, const QScriptValueImpl &proto,
QScriptValueImpl &ztor, const QString &name)
{
newError(result, proto);
result->setProperty(QLatin1String("name"), QScriptValueImpl(engine(), name));
result->setProperty(QLatin1String("constructor"), ztor,
QScriptValue::Undeletable
| QScriptValue::SkipInEnumeration);
ztor.setProperty(QLatin1String("prototype"), *result,
QScriptValue::Undeletable
| QScriptValue::ReadOnly
| QScriptValue::SkipInEnumeration);
}
bool
DCStartd::vacateClaim( const char* name_vacate )
{
setCmdStr( "vacateClaim" );
bool result;
ReliSock reli_sock;
reli_sock.timeout(20); // years of research... :)
if( ! reli_sock.connect(_addr) ) {
std::string err = "DCStartd::vacateClaim: ";
err += "Failed to connect to startd (";
err += _addr;
err += ')';
newError( CA_CONNECT_FAILED, err.c_str() );
return false;
}
int cmd = VACATE_CLAIM;
result = startCommand( cmd, (Sock*)&reli_sock );
if( ! result ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::vacateClaim: Failed to send command PCKPT_JOB to the startd" );
return false;
}
if( ! reli_sock.code((unsigned char *)name_vacate) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::vacateClaim: Failed to send Name to the startd" );
return false;
}
if( ! reli_sock.end_of_message() ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::vacateClaim: Failed to send EOM to the startd" );
return false;
}
return true;
}
void pairSaveWindow::startStopPressed()
{
bool start = (_ui->btn_startStop->text() == START_RECORDING);
if( start )
{
if( _dataRecorded )
{
if( QMessageBox::warning( this, "Warning", "Old data will be "
"overwritten!\nContinue?",
QMessageBox::StandardButtons(
QMessageBox::Yes | QMessageBox::No ),
QMessageBox::StandardButton::No )
== QMessageBox::StandardButton::No )
{
return;
}
}
_fileStream.open( _fileName.toStdString().c_str(), std::ios_base::out );
if( !_fileStream.is_open() )
{
_ui->lbl_status->setText( "ERROR!" );
_ui->lbl_status->setStyleSheet( STYLE_ERROR );
emit newError( this->windowTitle() + ": unable to open file!" );
return;
}
_fileStream.close();
_ui->lbl_status->setText( RECORDING );
_ui->lbl_status->setStyleSheet( STYLE_OK );
_ui->btn_startStop->setText( STOP_RECORDING );
}
else
{
_ui->btn_startStop->setText( START_RECORDING );
_ui->lbl_status->setText( PAUSING );
_ui->lbl_status->setStyleSheet( STYLE_ERROR );
}
_ui->btn_selectFile->setEnabled( !start );
_ui->cob_delimiter->setEnabled( !start );
_ui->cob_x->setEnabled( !start );
_ui->cob_y->setEnabled( !start );
_intervalCounter = 0;
_recording = start;
emit changeWindowState( this->windowTitle(), start );
}
bool
DCStartd::checkClaimId( void )
{
if( claim_id ) {
return true;
}
std::string err_msg;
if( _cmd_str ) {
err_msg += _cmd_str;
err_msg += ": ";
}
err_msg += "called with no ClaimId";
newError( CA_INVALID_REQUEST, err_msg.c_str() );
return false;
}
inline void Logger::handleNewError(const MoleQueue::LogEntry &error)
{
if (m_printErrors) {
qDebug() << "Error occurred:"
<< "Message: " << error.message()
<< "MoleQueueId: (" << error.moleQueueId() << ")";
}
++m_newErrorCount;
emit newError(error);
if (!m_silenceNewErrors && m_newErrorCount == 1)
emit firstNewErrorOccurred();
}
bool
DCStartd::checkVacateType( VacateType t )
{
std::string err_msg;
switch( t ) {
case VACATE_GRACEFUL:
case VACATE_FAST:
break;
default:
formatstr(err_msg, "Invalid VacateType (%d)", (int)t);
newError( CA_INVALID_REQUEST, err_msg.c_str() );
return false;
}
return true;
}
error* newErrorVA(int errV,const char* func,char* where, char* text,error* linkTo, error* addErr,...) {
char logTXTA[TXT_SZ],logTXT[TXT_SZ];
va_list args;
int sz;
sprintf(logTXTA,"%s%s",func,where);
va_start(args,addErr);
sz=vsnprintf(logTXT, TXT_SZ,text,args);
va_end(args);
if (sz<=0) {
sprintf(logTXT,"PROBLEM IN ERROR TEXT");
}
if (sz==TXT_SZ) {
logTXT[TXT_SZ-1]='\0';
}
return newError(errV,logTXTA,logTXT,linkTo,addErr);
}
void Error::execute(QScriptContextPrivate *context)
{
#ifndef Q_SCRIPT_NO_EVENT_NOTIFY
engine()->notifyFunctionEntry(context);
#endif
QString message = QString();
if (context->argumentCount() > 0)
message = context->argument(0).toString();
QScriptValueImpl result;
newError(&result, publicPrototype, message);
setDebugInformation(&result, context);
context->setReturnValue(result);
#ifndef Q_SCRIPT_NO_EVENT_NOTIFY
engine()->notifyFunctionExit(context);
#endif
}
bool
DCCollector::sendUDPUpdate( int cmd, ClassAd* ad1, ClassAd* ad2, bool nonblocking )
{
// with UDP it's pretty straight forward. We always want to
// use Daemon::startCommand() so we get all the security stuff
// in every update. In fact, we want to recreate the SafeSock
// itself each time, since it doesn't seem to work if we reuse
// the SafeSock object from one update to the next...
dprintf( D_FULLDEBUG,
"Attempting to send update via UDP to collector %s\n",
update_destination );
bool raw_protocol = false;
if( cmd == UPDATE_COLLECTOR_AD || cmd == INVALIDATE_COLLECTOR_ADS ) {
// we *never* want to do security negotiation with the
// developer collector.
raw_protocol = true;
}
if(nonblocking) {
UpdateData *ud = new UpdateData(cmd, Sock::safe_sock, ad1, ad2, this);
if (this->pending_update_list.size() == 1)
{
startCommand_nonblocking(cmd, Sock::safe_sock, 20, NULL, UpdateData::startUpdateCallback, ud, NULL, raw_protocol );
}
return true;
}
Sock *ssock = startCommand(cmd, Sock::safe_sock, 20, NULL, NULL, raw_protocol);
if(!ssock) {
newError( CA_COMMUNICATION_ERROR,
"Failed to send UDP update command to collector" );
return false;
}
bool success = finishUpdate( this, ssock, ad1, ad2 );
delete ssock;
return success;
}
void pairSaveWindow::doUpdate()
{
if( _recording && _intervalCounter%_ui->spb_ticks->value() == 0 )
{
_fileStream.open( _fileName.toStdString().c_str(), std::ios_base::app );
if( !_fileStream.is_open() )
{
_ui->lbl_status->setText( "ERROR!" );
_ui->lbl_status->setStyleSheet( STYLE_ERROR );
emit newError( this->windowTitle() + ": unable to open file!" );
return;
}
_fileStream << _x << getDelimiter().toStdString() << _y << std::endl;
_fileStream.close();
_dataRecorded = true;
_savedCounter++;
_ui->lbl_numSaved->setText( QString::number( _savedCounter ) );
_intervalCounter = 0;
}
_intervalCounter++;
}
void Error::newError(QScriptValueImpl *result, const QString &message)
{
newError(result, publicPrototype, message);
}
void Error::newSyntaxError(QScriptValueImpl *result, const QString &message)
{
newError(result, syntaxErrorPrototype, message);
}
bool LDLMainModel::load(const char *filename)
{
FILE *file;
LDLError *error;
setFilename(filename);
lDrawDir(); // Initializes sm_lDrawIni
if (sm_lDrawIni)
{
LDrawIniComputeRealDirs(sm_lDrawIni, 1, 0, filename);
}
if (!strlen(lDrawDir()))
{
error = newError(LDLEGeneral,
TCLocalStrings::get(_UC("LDLMainModelNoLDrawDir")));
error->setLevel(LDLACriticalError);
sendAlert(error);
error->release();
return false;
}
file = fopen(filename, "rb");
m_mainModel = this;
if (file)
{
bool retValue;
if (m_mainFlags.processLDConfig)
{
processLDConfig();
}
retValue = LDLModel::load(file);
if (sm_lDrawIni)
{
// If bool isn't 1 byte, then the filename case callback won't
// work, so doesn't get used. Check to see if this will be a
// problem.
if (sizeof(bool) != sizeof(char) && fileCaseCallback)
{
char *tmpStr;
size_t len = strlen(lDrawDir());
bool failed = false;
struct stat statData;
tmpStr = new char[len + 10];
sprintf(tmpStr, "%s/P", lDrawDir());
if (stat(tmpStr, &statData) != 0)
{
// Check to see if we can access the P directory inside the
// LDraw directory. If not, then we have a problem that
// needs to be reported to the user.
failed = true;
}
if (!failed)
{
sprintf(tmpStr, "%s/PARTS", lDrawDir());
if (stat(tmpStr, &statData) != 0)
{
// Check to see if we can access the PARTS directory
// inside the LDraw directory. If not, then we have a
// problem that needs to be reported to the user.
failed = true;
}
}
delete tmpStr;
if (failed)
{
// Either P or PARTS was inaccessible, so let the user
// know that they need to rename the directories to be in
// upper case.
reportError(LDLEGeneral,
TCLocalStrings::get(_UC("LDLMainModelFileCase")));
}
}
}
// The ancestor map has done its job; may as well free up the memory it
// was using.
m_ancestorMap.clear();
return retValue;
}
else
{
error = newError(LDLEFileNotFound,
TCLocalStrings::get(_UC("LDLMainModelNoMainModel")));
error->setLevel(LDLACriticalError);
sendAlert(error);
error->release();
return false;
}
}
int
DCStartd::delegateX509Proxy( const char* proxy, time_t expiration_time, time_t *result_expiration_time )
{
dprintf( D_FULLDEBUG, "Entering DCStartd::delegateX509Proxy()\n" );
setCmdStr( "delegateX509Proxy" );
if( ! claim_id ) {
newError( CA_INVALID_REQUEST,
"DCStartd::delegateX509Proxy: Called with NULL claim_id" );
return CONDOR_ERROR;
}
// if this claim is associated with a security session
ClaimIdParser cidp(claim_id);
//
// 1) begin the DELEGATE_GSI_CRED_STARTD command
//
ReliSock* tmp = (ReliSock*)startCommand( DELEGATE_GSI_CRED_STARTD,
Stream::reli_sock,
20, NULL, NULL, false,
cidp.secSessionId() );
if( ! tmp ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::delegateX509Proxy: Failed to send command DELEGATE_GSI_CRED_STARTD to the startd" );
return CONDOR_ERROR;
}
//
// 2) get reply from startd - OK means continue, NOT_OK means
// don't bother (the startd doesn't require a delegated
// proxy
//
tmp->decode();
int reply;
if( !tmp->code(reply) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::delegateX509Proxy: failed to receive reply from startd (1)" );
delete tmp;
return CONDOR_ERROR;
}
if ( !tmp->end_of_message() ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::delegateX509Proxy: end of message error from startd (1)" );
delete tmp;
return CONDOR_ERROR;
}
if( reply == NOT_OK ) {
delete tmp;
return NOT_OK;
}
//
// 3) send over the claim id and delegate (or copy) the given proxy
//
tmp->encode();
int use_delegation =
param_boolean( "DELEGATE_JOB_GSI_CREDENTIALS", true ) ? 1 : 0;
if( !tmp->code( claim_id ) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::delegateX509Proxy: Failed to send claim id to the startd" );
delete tmp;
return CONDOR_ERROR;
}
if ( !tmp->code( use_delegation ) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::delegateX509Proxy: Failed to send use_delegation flag to the startd" );
delete tmp;
return CONDOR_ERROR;
}
int rv;
filesize_t dont_care;
if( use_delegation ) {
rv = tmp->put_x509_delegation( &dont_care, proxy, expiration_time, result_expiration_time );
}
else {
dprintf( D_FULLDEBUG,
"DELEGATE_JOB_GSI_CREDENTIALS is False; using direct copy\n");
if( ! tmp->get_encryption() ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::delegateX509Proxy: Cannot copy: channel does not have encryption enabled" );
delete tmp;
return CONDOR_ERROR;
}
rv = tmp->put_file( &dont_care, proxy );
}
if( rv == -1 ) {
newError( CA_FAILURE,
"DCStartd::delegateX509Proxy: Failed to delegate proxy" );
delete tmp;
return CONDOR_ERROR;
}
if ( !tmp->end_of_message() ) {
newError( CA_FAILURE,
"DCStartd::delegateX509Proxy: end of message error to startd" );
delete tmp;
return CONDOR_ERROR;
}
// command successfully sent; now get the reply
tmp->decode();
if( !tmp->code(reply) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::delegateX509Proxy: failed to receive reply from startd (2)" );
delete tmp;
return CONDOR_ERROR;
}
if ( !tmp->end_of_message() ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::delegateX509Proxy: end of message error from startd (2)" );
delete tmp;
return CONDOR_ERROR;
}
delete tmp;
dprintf( D_FULLDEBUG,
"DCStartd::delegateX509Proxy: successfully sent command, reply is: %d\n",
reply );
return reply;
}
agi_error agi::error( const string& msg, const string& file,
const string& function, int line)
{
agi_error newError(*this, msg, file, function, line);
return newError;
}
void Error::newURIError(QScriptValueImpl *result, const QString &message)
{
newError(result, uriErrorPrototype, message);
}
int
DCStartd::activateClaim( ClassAd* job_ad, int starter_version,
ReliSock** claim_sock_ptr )
{
int reply;
dprintf( D_FULLDEBUG, "Entering DCStartd::activateClaim()\n" );
setCmdStr( "activateClaim" );
if( claim_sock_ptr ) {
// our caller wants a pointer to the socket we used to
// successfully activate the claim. right now, set it to
// NULL to signify error, and if everything works out,
// we'll give them a pointer to the real object.
*claim_sock_ptr = NULL;
}
if( ! claim_id ) {
newError( CA_INVALID_REQUEST,
"DCStartd::activateClaim: called with NULL claim_id, failing" );
return CONDOR_ERROR;
}
// if this claim is associated with a security session
ClaimIdParser cidp(claim_id);
char const *sec_session = cidp.secSessionId();
Sock* tmp;
tmp = startCommand( ACTIVATE_CLAIM, Stream::reli_sock, 20, NULL, NULL, false, sec_session );
if( ! tmp ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::activateClaim: Failed to send command ACTIVATE_CLAIM to the startd" );
return CONDOR_ERROR;
}
if( ! tmp->put_secret(claim_id) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::activateClaim: Failed to send ClaimId to the startd" );
delete tmp;
return CONDOR_ERROR;
}
if( ! tmp->code(starter_version) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::activateClaim: Failed to send starter_version to the startd" );
delete tmp;
return CONDOR_ERROR;
}
if( ! putClassAd(tmp, *job_ad) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::activateClaim: Failed to send job ClassAd to the startd" );
delete tmp;
return CONDOR_ERROR;
}
if( ! tmp->end_of_message() ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::activateClaim: Failed to send EOM to the startd" );
delete tmp;
return CONDOR_ERROR;
}
// Now, try to get the reply
tmp->decode();
if( !tmp->code(reply) || !tmp->end_of_message()) {
std::string err = "DCStartd::activateClaim: ";
err += "Failed to receive reply from ";
err += _addr ? _addr : "NULL";
newError( CA_COMMUNICATION_ERROR, err.c_str() );
delete tmp;
return CONDOR_ERROR;
}
dprintf( D_FULLDEBUG, "DCStartd::activateClaim: "
"successfully sent command, reply is: %d\n", reply );
if( reply == OK && claim_sock_ptr ) {
*claim_sock_ptr = (ReliSock*)tmp;
} else {
// in any other case, we're going to leak this ReliSock
// object if we don't delete it here...
delete tmp;
}
return reply;
}
bool
DCStartd::deactivateClaim( bool graceful, bool *claim_is_closing )
{
dprintf( D_FULLDEBUG, "Entering DCStartd::deactivateClaim(%s)\n",
graceful ? "graceful" : "forceful" );
if( claim_is_closing ) {
*claim_is_closing = false;
}
setCmdStr( "deactivateClaim" );
if( ! checkClaimId() ) {
return false;
}
if( ! checkAddr() ) {
return false;
}
// if this claim is associated with a security session
ClaimIdParser cidp(claim_id);
char const *sec_session = cidp.secSessionId();
if (IsDebugLevel(D_COMMAND)) {
int cmd = graceful ? DEACTIVATE_CLAIM : DEACTIVATE_CLAIM_FORCIBLY;
dprintf (D_COMMAND, "DCStartd::deactivateClaim(%s,...) making connection to %s\n", getCommandStringSafe(cmd), _addr ? _addr : "NULL");
}
bool result;
ReliSock reli_sock;
reli_sock.timeout(20); // years of research... :)
if( ! reli_sock.connect(_addr) ) {
std::string err = "DCStartd::deactivateClaim: ";
err += "Failed to connect to startd (";
err += _addr ? _addr : "NULL";
err += ')';
newError( CA_CONNECT_FAILED, err.c_str() );
return false;
}
int cmd;
if( graceful ) {
cmd = DEACTIVATE_CLAIM;
} else {
cmd = DEACTIVATE_CLAIM_FORCIBLY;
}
result = startCommand( cmd, (Sock*)&reli_sock, 20, NULL, NULL, false, sec_session );
if( ! result ) {
std::string err = "DCStartd::deactivateClaim: ";
err += "Failed to send command ";
if( graceful ) {
err += "DEACTIVATE_CLAIM";
} else {
err += "DEACTIVATE_CLAIM_FORCIBLY";
}
err += " to the startd";
newError( CA_COMMUNICATION_ERROR, err.c_str() );
return false;
}
// Now, send the ClaimId
if( ! reli_sock.put_secret(claim_id) ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::deactivateClaim: Failed to send ClaimId to the startd" );
return false;
}
if( ! reli_sock.end_of_message() ) {
newError( CA_COMMUNICATION_ERROR,
"DCStartd::deactivateClaim: Failed to send EOM to the startd" );
return false;
}
reli_sock.decode();
ClassAd response_ad;
if( !getClassAd(&reli_sock, response_ad) || !reli_sock.end_of_message() ) {
dprintf( D_FULLDEBUG, "DCStartd::deactivateClaim: failed to read response ad.\n");
// The response ad is not critical and is expected to be missing
// if the startd is from before 7.0.5.
}
else {
bool start = true;
response_ad.LookupBool(ATTR_START,start);
if( claim_is_closing ) {
*claim_is_closing = !start;
}
}
// we're done
dprintf( D_FULLDEBUG, "DCStartd::deactivateClaim: "
"successfully sent command\n" );
return true;
}
bool
DCCollector::sendUpdate( int cmd, ClassAd* ad1, ClassAd* ad2, bool nonblocking )
{
if( ! _is_configured ) {
// nothing to do, treat it as success...
return true;
}
if(!use_nonblocking_update || !daemonCore) {
// Either caller OR config may turn off nonblocking updates.
// In other words, both must be true to enable nonblocking.
// Also, must have DaemonCore intialized.
nonblocking = false;
}
// Add start time & seq # to the ads before we publish 'em
if ( ad1 ) {
ad1->Assign(ATTR_DAEMON_START_TIME,(long)startTime);
}
if ( ad2 ) {
ad2->Assign(ATTR_DAEMON_START_TIME,(long)startTime);
}
if ( ad1 ) {
unsigned seq = adSeqMan->getSequence( ad1 );
ad1->Assign(ATTR_UPDATE_SEQUENCE_NUMBER,seq);
}
if ( ad2 ) {
unsigned seq = adSeqMan->getSequence( ad2 );
ad2->Assign(ATTR_UPDATE_SEQUENCE_NUMBER,seq);
}
// Prior to 7.2.0, the negotiator depended on the startd
// supplying matching MyAddress in public and private ads.
if ( ad1 && ad2 ) {
ad2->CopyAttribute(ATTR_MY_ADDRESS,ad1);
}
// My initial plan was to publish these for schedd, however they will provide
// potentially useful context for performance/health assessment of any daemon
if (ad1) {
ad1->Assign(ATTR_DETECTED_CPUS, param_integer("DETECTED_CORES", 0));
ad1->Assign(ATTR_DETECTED_MEMORY, param_integer("DETECTED_MEMORY", 0));
}
if (ad2) {
ad2->Assign(ATTR_DETECTED_CPUS, param_integer("DETECTED_CORES", 0));
ad2->Assign(ATTR_DETECTED_MEMORY, param_integer("DETECTED_MEMORY", 0));
}
// We never want to try sending an update to port 0. If we're
// about to try that, and we're trying to talk to a local
// collector, we should try re-reading the address file and
// re-setting our port.
if( _port == 0 ) {
dprintf( D_HOSTNAME, "About to update collector with port 0, "
"attempting to re-read address file\n" );
if( readAddressFile(_subsys) ) {
_port = string_to_port( _addr );
parseTCPInfo(); // update use_tcp
dprintf( D_HOSTNAME, "Using port %d based on address \"%s\"\n",
_port, _addr );
}
}
if( _port <= 0 ) {
// If it's still 0, we've got to give up and fail.
std::string err_msg;
formatstr(err_msg, "Can't send update: invalid collector port (%d)",
_port );
newError( CA_COMMUNICATION_ERROR, err_msg.c_str() );
return false;
}
//
// We don't want the collector to send TCP updates to itself, since
// this could cause it to deadlock. Since the only ad a collector
// will ever advertise is its own, only check for *_COLLECTOR_ADS.
//
if( cmd == UPDATE_COLLECTOR_AD || cmd == INVALIDATE_COLLECTOR_ADS ) {
if( daemonCore ) {
const char * myOwnSinful = daemonCore->InfoCommandSinfulString();
if( myOwnSinful == NULL ) {
dprintf( D_ALWAYS | D_FAILURE, "Unable to determine my own address, will not update or invalidate collector ad to avoid potential deadlock.\n" );
return false;
}
if( strcmp( myOwnSinful, _addr ) == 0 ) {
EXCEPT( "Collector attempted to send itself an update.\n" );
}
}
}
if( use_tcp ) {
return sendTCPUpdate( cmd, ad1, ad2, nonblocking );
}
return sendUDPUpdate( cmd, ad1, ad2, nonblocking );
}
void Error::newReferenceError(QScriptValueImpl *result, const QString &message)
{
newError(result, referenceErrorPrototype, message);
}
