static void
AbortTransactionBlock(void)
{
TransactionState s = CurrentTransactionState;
/*
* check the current transaction state
*/
if (s->blockState == TBLOCK_INPROGRESS)
{
/*
* here we were inside a transaction block something screwed up
* inside the system so we enter the abort state, do the abort
* processing and then return. We remain in the abort state until
* we see an END TRANSACTION command.
*/
s->blockState = TBLOCK_ABORT;
AbortTransaction();
return;
}
/*
* here, the user issued ABORT when not inside a transaction. Issue a
* WARNING and go to abort state. The upcoming call to
* CommitTransactionCommand() will then put us back into the default
* state.
*/
ereport(WARNING,
(errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
errmsg("there is no transaction in progress")));
AbortTransaction();
s->blockState = TBLOCK_ENDABORT;
}
void
U2FTokenManager::Register(PWebAuthnTransactionParent* aTransactionParent,
const uint64_t& aTransactionId,
const WebAuthnMakeCredentialInfo& aTransactionInfo)
{
MOZ_LOG(gU2FTokenManagerLog, LogLevel::Debug, ("U2FAuthRegister"));
ClearTransaction();
mTransactionParent = aTransactionParent;
mTokenManagerImpl = GetTokenManagerImpl();
if (!mTokenManagerImpl) {
AbortTransaction(aTransactionId, NS_ERROR_DOM_NOT_ALLOWED_ERR);
return;
}
// Check if all the supplied parameters are syntactically well-formed and
// of the correct length. If not, return an error code equivalent to
// UnknownError and terminate the operation.
if ((aTransactionInfo.RpIdHash().Length() != SHA256_LENGTH) ||
(aTransactionInfo.ClientDataHash().Length() != SHA256_LENGTH)) {
AbortTransaction(aTransactionId, NS_ERROR_DOM_UNKNOWN_ERR);
return;
}
uint64_t tid = mLastTransactionId = aTransactionId;
mozilla::TimeStamp startTime = mozilla::TimeStamp::Now();
mTokenManagerImpl->Register(aTransactionInfo.ExcludeList(),
aTransactionInfo.AuthenticatorSelection(),
aTransactionInfo.RpIdHash(),
aTransactionInfo.ClientDataHash(),
aTransactionInfo.TimeoutMS())
->Then(GetCurrentThreadSerialEventTarget(), __func__,
[tid, startTime](U2FRegisterResult&& aResult) {
U2FTokenManager* mgr = U2FTokenManager::Get();
mgr->MaybeConfirmRegister(tid, aResult);
Telemetry::ScalarAdd(
Telemetry::ScalarID::SECURITY_WEBAUTHN_USED,
NS_LITERAL_STRING("U2FRegisterFinish"), 1);
Telemetry::AccumulateTimeDelta(
Telemetry::WEBAUTHN_CREATE_CREDENTIAL_MS,
startTime);
},
[tid](nsresult rv) {
MOZ_ASSERT(NS_FAILED(rv));
U2FTokenManager* mgr = U2FTokenManager::Get();
mgr->MaybeAbortRegister(tid, rv);
Telemetry::ScalarAdd(
Telemetry::ScalarID::SECURITY_WEBAUTHN_USED,
NS_LITERAL_STRING("U2FRegisterAbort"), 1);
})
->Track(mRegisterPromise);
}
void
U2FTokenManager::Sign(PWebAuthnTransactionParent* aTransactionParent,
const uint64_t& aTransactionId,
const WebAuthnGetAssertionInfo& aTransactionInfo)
{
MOZ_LOG(gU2FTokenManagerLog, LogLevel::Debug, ("U2FAuthSign"));
ClearTransaction();
mTransactionParent = aTransactionParent;
mTokenManagerImpl = GetTokenManagerImpl();
if (!mTokenManagerImpl) {
AbortTransaction(aTransactionId, NS_ERROR_DOM_NOT_ALLOWED_ERR);
return;
}
if ((aTransactionInfo.RpIdHash().Length() != SHA256_LENGTH) ||
(aTransactionInfo.ClientDataHash().Length() != SHA256_LENGTH)) {
AbortTransaction(aTransactionId, NS_ERROR_DOM_UNKNOWN_ERR);
return;
}
// Show a prompt that lets the user cancel the ongoing transaction.
NS_ConvertUTF16toUTF8 origin(aTransactionInfo.Origin());
SendPromptNotification(kSignPromptNotifcation,
aTransactionId,
origin.get());
uint64_t tid = mLastTransactionId = aTransactionId;
mozilla::TimeStamp startTime = mozilla::TimeStamp::Now();
mTokenManagerImpl
->Sign(aTransactionInfo)
->Then(GetCurrentThreadSerialEventTarget(), __func__,
[tid, startTime](WebAuthnGetAssertionResult&& aResult) {
U2FTokenManager* mgr = U2FTokenManager::Get();
mgr->MaybeConfirmSign(tid, aResult);
Telemetry::ScalarAdd(
Telemetry::ScalarID::SECURITY_WEBAUTHN_USED,
NS_LITERAL_STRING("U2FSignFinish"), 1);
Telemetry::AccumulateTimeDelta(
Telemetry::WEBAUTHN_GET_ASSERTION_MS,
startTime);
},
[tid](nsresult rv) {
MOZ_ASSERT(NS_FAILED(rv));
U2FTokenManager* mgr = U2FTokenManager::Get();
mgr->MaybeAbortSign(tid, rv);
Telemetry::ScalarAdd(
Telemetry::ScalarID::SECURITY_WEBAUTHN_USED,
NS_LITERAL_STRING("U2FSignAbort"), 1);
})
->Track(mSignPromise);
}
DBCursorPriv *DBPrivOpenCursor(DBPriv *db)
{
DBCursorPriv *cursor = NULL;
DBTxn *txn;
int rc;
MDB_cursor *mc;
rc = GetWriteTransaction(db, &txn);
if (rc == MDB_SUCCESS)
{
assert(!txn->cursor_open);
rc = mdb_cursor_open(txn->txn, db->dbi, &mc);
if (rc == MDB_SUCCESS)
{
cursor = xcalloc(1, sizeof(DBCursorPriv));
cursor->db = db;
cursor->mc = mc;
txn->cursor_open = true;
}
else
{
Log(LOG_LEVEL_ERR, "Could not open cursor: %s", mdb_strerror(rc));
AbortTransaction(db);
}
/* txn remains with cursor */
}
return cursor;
}
/*
* AbortOutOfAnyTransaction
*
* This routine is provided for error recovery purposes. It aborts any
* active transaction or transaction block, leaving the system in a known
* idle state.
*/
void
AbortOutOfAnyTransaction(void)
{
TransactionState s = CurrentTransactionState;
/*
* Get out of any low-level transaction
*/
switch (s->state)
{
case TRANS_START:
case TRANS_INPROGRESS:
case TRANS_COMMIT:
/* In a transaction, so clean up */
AbortTransaction();
CleanupTransaction();
break;
case TRANS_ABORT:
/* AbortTransaction already done, still need Cleanup */
CleanupTransaction();
break;
case TRANS_DEFAULT:
/* Not in a transaction, do nothing */
break;
}
/*
* Now reset the high-level state
*/
s->blockState = TBLOCK_DEFAULT;
}
bool DBPrivRead(DBPriv *db, const void *key, int key_size, void *dest, int dest_size)
{
MDB_val mkey, data;
DBTxn *txn;
int rc;
bool ret = false;
rc = GetReadTransaction(db, &txn);
if (rc == MDB_SUCCESS)
{
assert(!txn->cursor_open);
mkey.mv_data = (void *)key;
mkey.mv_size = key_size;
rc = mdb_get(txn->txn, db->dbi, &mkey, &data);
if (rc == MDB_SUCCESS)
{
if (dest_size > data.mv_size)
{
dest_size = data.mv_size;
}
memcpy(dest, data.mv_data, dest_size);
ret = true;
}
else if (rc != MDB_NOTFOUND)
{
Log(LOG_LEVEL_ERR, "Could not read database entry: %s", mdb_strerror(rc));
AbortTransaction(db);
}
}
return ret;
}
void
U2FTokenManager::MaybeAbortSign(const uint64_t& aTransactionId,
const nsresult& aError)
{
MOZ_ASSERT(mLastTransactionId == aTransactionId);
mSignPromise.Complete();
AbortTransaction(aTransactionId, aError);
}
void
U2FTokenManager::Register(PWebAuthnTransactionParent* aTransactionParent,
const uint64_t& aTransactionId,
const WebAuthnMakeCredentialInfo& aTransactionInfo)
{
MOZ_LOG(gU2FTokenManagerLog, LogLevel::Debug, ("U2FAuthRegister"));
ClearTransaction();
mTransactionParent = aTransactionParent;
mTokenManagerImpl = GetTokenManagerImpl();
if (!mTokenManagerImpl) {
AbortTransaction(aTransactionId, NS_ERROR_DOM_NOT_ALLOWED_ERR);
return;
}
// Check if all the supplied parameters are syntactically well-formed and
// of the correct length. If not, return an error code equivalent to
// UnknownError and terminate the operation.
if ((aTransactionInfo.RpIdHash().Length() != SHA256_LENGTH) ||
(aTransactionInfo.ClientDataHash().Length() != SHA256_LENGTH)) {
AbortTransaction(aTransactionId, NS_ERROR_DOM_UNKNOWN_ERR);
return;
}
mLastTransactionId = aTransactionId;
// If the RP request direct attestation, ask the user for permission and
// store the transaction info until the user proceeds or cancels.
// Might be overriden by a pref for testing purposes.
if (aTransactionInfo.RequestDirectAttestation() &&
!U2FPrefManager::Get()->GetAllowDirectAttestationForTesting()) {
NS_ConvertUTF16toUTF8 origin(aTransactionInfo.Origin());
SendPromptNotification(kRegisterDirectPromptNotifcation,
aTransactionId,
origin.get());
MOZ_ASSERT(mPendingRegisterInfo.isNothing());
mPendingRegisterInfo = Some(aTransactionInfo);
} else {
DoRegister(aTransactionInfo);
}
}
/*
* UserAbortTransactionBlock
*/
void
UserAbortTransactionBlock(void)
{
TransactionState s = CurrentTransactionState;
/*
* if the transaction has already been automatically aborted with an
* error, and the user subsequently types 'abort', allow it. (the
* behavior is the same as if they had typed 'end'.)
*/
if (s->blockState == TBLOCK_ABORT)
{
s->blockState = TBLOCK_ENDABORT;
return;
}
if (s->blockState == TBLOCK_INPROGRESS)
{
/*
* here we were inside a transaction block and we got an abort
* command from the user, so we move to the abort state, do the
* abort processing and then change to the ENDABORT state so we
* will end up in the default state after the upcoming
* CommitTransactionCommand().
*/
s->blockState = TBLOCK_ABORT;
AbortTransaction();
s->blockState = TBLOCK_ENDABORT;
return;
}
/*
* here, the user issued ABORT when not inside a transaction. Issue a
* WARNING and go to abort state. The upcoming call to
* CommitTransactionCommand() will then put us back into the default
* state.
*/
ereport(WARNING,
(errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
errmsg("there is no transaction in progress")));
AbortTransaction();
s->blockState = TBLOCK_ENDABORT;
}
///////////////////////////////////////////////////////////////////////////////
/// \brief
/// Initialize the repository manager.
///
void MgRepositoryManager::Initialize(bool transacted)
{
AbortTransaction();
m_transacted = transacted;
if (m_transacted)
{
CreateTransaction();
}
}
MgRepositoryManager::~MgRepositoryManager()
{
try
{
AbortTransaction();
}
catch (...)
{
assert(false);
}
}
void DBPrivCloseDB(DBPriv *db)
{
/* Abort LMDB transaction of the current thread. There should only be some
* transaction open when the signal handler or atexit() hook is called. */
AbortTransaction(db);
if (db->env)
{
mdb_env_close(db->env);
}
pthread_key_delete(db->txn_key);
free(db);
}
void
U2FTokenManager::RunCancel(uint64_t aTransactionId)
{
mozilla::ipc::AssertIsOnBackgroundThread();
if (mLastTransactionId != aTransactionId) {
return;
}
// Cancel the request.
mTokenManagerImpl->Cancel();
// Reject the promise.
AbortTransaction(aTransactionId, NS_ERROR_DOM_ABORT_ERR);
}
/*
* EndTransactionBlock
*/
void
EndTransactionBlock(void)
{
TransactionState s = CurrentTransactionState;
/*
* check the current transaction state
*/
if (s->blockState == TBLOCK_INPROGRESS)
{
/*
* here we are in a transaction block which should commit when we
* get to the upcoming CommitTransactionCommand() so we set the
* state to "END". CommitTransactionCommand() will recognize this
* and commit the transaction and return us to the default state
*/
s->blockState = TBLOCK_END;
return;
}
if (s->blockState == TBLOCK_ABORT)
{
/*
* here, we are in a transaction block which aborted and since the
* AbortTransaction() was already done, we do whatever is needed
* and change to the special "END ABORT" state. The upcoming
* CommitTransactionCommand() will recognise this and then put us
* back in the default state.
*/
s->blockState = TBLOCK_ENDABORT;
return;
}
/*
* here, the user issued COMMIT when not inside a transaction. Issue a
* WARNING and go to abort state. The upcoming call to
* CommitTransactionCommand() will then put us back into the default
* state.
*/
ereport(WARNING,
(errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
errmsg("there is no transaction in progress")));
AbortTransaction();
s->blockState = TBLOCK_ENDABORT;
}
void
U2FTokenManager::Register(PWebAuthnTransactionParent* aTransactionParent,
const uint64_t& aTransactionId,
const WebAuthnMakeCredentialInfo& aTransactionInfo)
{
MOZ_LOG(gU2FTokenManagerLog, LogLevel::Debug, ("U2FAuthRegister"));
ClearTransaction();
mTransactionParent = aTransactionParent;
mTokenManagerImpl = GetTokenManagerImpl();
if (!mTokenManagerImpl) {
AbortTransaction(aTransactionId, NS_ERROR_DOM_NOT_ALLOWED_ERR);
return;
}
mLastTransactionId = aTransactionId;
// Determine whether direct attestation was requested.
bool directAttestationRequested = false;
if (aTransactionInfo.Extra().type() == WebAuthnMaybeMakeCredentialExtraInfo::TWebAuthnMakeCredentialExtraInfo) {
const auto& extra = aTransactionInfo.Extra().get_WebAuthnMakeCredentialExtraInfo();
directAttestationRequested = extra.RequestDirectAttestation();
}
// Start a register request immediately if direct attestation
// wasn't requested or the test pref is set.
if (!directAttestationRequested ||
U2FPrefManager::Get()->GetAllowDirectAttestationForTesting()) {
// Force "none" attestation when "direct" attestation wasn't requested.
DoRegister(aTransactionInfo, !directAttestationRequested);
return;
}
// If the RP request direct attestation, ask the user for permission and
// store the transaction info until the user proceeds or cancels.
NS_ConvertUTF16toUTF8 origin(aTransactionInfo.Origin());
SendPromptNotification(kRegisterDirectPromptNotifcation,
aTransactionId,
origin.get());
MOZ_ASSERT(mPendingRegisterInfo.isNothing());
mPendingRegisterInfo = Some(aTransactionInfo);
}
bool DBPrivWrite(DBPriv *db, const void *key, int key_size, const void *value, int value_size)
{
MDB_val mkey, data;
DBTxn *txn;
int rc = GetWriteTransaction(db, &txn);
if (rc == MDB_SUCCESS)
{
assert(!txn->cursor_open);
mkey.mv_data = (void *)key;
mkey.mv_size = key_size;
data.mv_data = (void *)value;
data.mv_size = value_size;
rc = mdb_put(txn->txn, db->dbi, &mkey, &data, 0);
if (rc != MDB_SUCCESS)
{
Log(LOG_LEVEL_ERR, "Could not write database entry: %s", mdb_strerror(rc));
AbortTransaction(db);
}
}
return rc == MDB_SUCCESS;
}
bool DBPrivHasKey(DBPriv *db, const void *key, int key_size)
{
MDB_val mkey, data;
DBTxn *txn;
int rc;
// FIXME: distinguish between "entry not found" and "error occurred"
rc = GetReadTransaction(db, &txn);
if (rc == MDB_SUCCESS)
{
assert(!txn->cursor_open);
mkey.mv_data = (void *)key;
mkey.mv_size = key_size;
rc = mdb_get(txn->txn, db->dbi, &mkey, &data);
if (rc && rc != MDB_NOTFOUND)
{
Log(LOG_LEVEL_ERR, "Could not read database entry: %s", mdb_strerror(rc));
AbortTransaction(db);
}
}
return rc == MDB_SUCCESS;
}
bool DBPrivDelete(DBPriv *db, const void *key, int key_size)
{
MDB_val mkey;
DBTxn *txn;
int rc = GetWriteTransaction(db, &txn);
if (rc == MDB_SUCCESS)
{
assert(!txn->cursor_open);
mkey.mv_data = (void *)key;
mkey.mv_size = key_size;
rc = mdb_del(txn->txn, db->dbi, &mkey, NULL);
if (rc == MDB_NOTFOUND)
{
Log(LOG_LEVEL_DEBUG, "Entry not found: %s", mdb_strerror(rc));
}
else if (rc != MDB_SUCCESS)
{
Log(LOG_LEVEL_ERR, "Could not delete: %s", mdb_strerror(rc));
AbortTransaction(db);
}
}
return rc == MDB_SUCCESS;
}
int DBPrivGetValueSize(DBPriv *db, const void *key, int key_size)
{
MDB_val mkey, data;
DBTxn *txn;
int rc;
data.mv_size = 0;
rc = GetReadTransaction(db, &txn);
if (rc == MDB_SUCCESS)
{
assert(!txn->cursor_open);
mkey.mv_data = (void *)key;
mkey.mv_size = key_size;
rc = mdb_get(txn->txn, db->dbi, &mkey, &data);
if (rc && rc != MDB_NOTFOUND)
{
Log(LOG_LEVEL_ERR, "Could not read database entry: %s", mdb_strerror(rc));
AbortTransaction(db);
}
}
return data.mv_size;
}
/*
* AbortCurrentTransaction
*/
void
AbortCurrentTransaction(void)
{
TransactionState s = CurrentTransactionState;
switch (s->blockState)
{
/*
* if we aren't in a transaction block, we just do the basic
* abort & cleanup transaction.
*/
case TBLOCK_DEFAULT:
AbortTransaction();
CleanupTransaction();
break;
/*
* If we are in the TBLOCK_BEGIN it means something screwed up
* right after reading "BEGIN TRANSACTION" so we enter the
* abort state. Eventually an "END TRANSACTION" will fix
* things.
*/
case TBLOCK_BEGIN:
s->blockState = TBLOCK_ABORT;
AbortTransaction();
/* CleanupTransaction happens when we exit TBLOCK_ABORT */
break;
/*
* This is the case when are somewhere in a transaction block
* which aborted so we abort the transaction and set the ABORT
* state. Eventually an "END TRANSACTION" will fix things and
* restore us to a normal state.
*/
case TBLOCK_INPROGRESS:
s->blockState = TBLOCK_ABORT;
AbortTransaction();
/* CleanupTransaction happens when we exit TBLOCK_ABORT */
break;
/*
* Here, the system was fouled up just after the user wanted
* to end the transaction block so we abort the transaction
* and put us back into the default state.
*/
case TBLOCK_END:
s->blockState = TBLOCK_DEFAULT;
AbortTransaction();
CleanupTransaction();
break;
/*
* Here, we are already in an aborted transaction state and
* are waiting for an "END TRANSACTION" to come along and lo
* and behold, we abort again! So we just remain in the abort
* state.
*/
case TBLOCK_ABORT:
break;
/*
* Here we were in an aborted transaction block which just
* processed the "END TRANSACTION" command but somehow aborted
* again.. since we must have done the abort processing, we
* clean up and return to the default state.
*/
case TBLOCK_ENDABORT:
CleanupTransaction();
s->blockState = TBLOCK_DEFAULT;
break;
}
}
void
doContactSchedd()
{
if (command_queue.IsEmpty()) {
daemonCore->Reset_Timer( contactScheddTid, contact_schedd_interval ); // Come back in a min
return;
}
dprintf(D_FULLDEBUG,"in doContactSchedd\n");
SchedDRequest * current_command = NULL;
int error=FALSE;
std::string error_msg;
CondorError errstack;
bool do_reschedule = false;
int failure_line_num = 0;
int failure_errno = 0;
// Try connecting to schedd
DCSchedd dc_schedd ( ScheddAddr, ScheddPool );
if (dc_schedd.error() || !dc_schedd.locate()) {
sprintf( error_msg, "Error locating schedd %s", ScheddAddr );
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
// If you can't connect return "Failure" on every job request
command_queue.Rewind();
while (command_queue.Next(current_command)) {
if (current_command->status != SchedDRequest::SDCS_NEW)
continue;
if (current_command->command == SchedDRequest::SDC_STATUS_CONSTRAINED) {
const char * result[] = {
GAHP_RESULT_FAILURE,
error_msg.c_str(),
"0"};
enqueue_result (current_command->request_id, result, 3);
} else if (current_command->command == SchedDRequest::SDC_SUBMIT_JOB) {
const char * result[] = {
GAHP_RESULT_FAILURE,
NULL,
error_msg.c_str() };
enqueue_result (current_command->request_id, result, 3);
} else if (current_command->command == SchedDRequest::SDC_UPDATE_LEASE) {
const char * result[] = {
GAHP_RESULT_FAILURE,
error_msg.c_str(),
NULL };
enqueue_result (current_command->request_id, result, 3);
} else {
const char * result[] = {
GAHP_RESULT_FAILURE,
error_msg.c_str() };
enqueue_result (current_command->request_id, result, 2);
}
current_command->status = SchedDRequest::SDCS_COMPLETED;
}
}
SchedDRequest::schedd_command_type commands [] = {
SchedDRequest::SDC_REMOVE_JOB,
SchedDRequest::SDC_HOLD_JOB,
SchedDRequest::SDC_RELEASE_JOB };
const char * command_titles [] = {
"REMOVE_JOB", "HOLD_JOB", "RELEASE_JOB" };
// REMOVE
// HOLD
// RELEASE
int i=0;
while (i<3) {
StringList id_list;
SimpleList <SchedDRequest*> this_batch;
SchedDRequest::schedd_command_type this_command = commands[i];
const char * this_action = command_titles[i];
const char * this_reason = NULL;
dprintf (D_FULLDEBUG, "Processing %s requests\n", this_action);
error = FALSE;
// Create a batch of commands with the same command type AND the same reason
command_queue.Rewind();
while (command_queue.Next(current_command)) {
if (current_command->status != SchedDRequest::SDCS_NEW)
continue;
if (current_command->command != this_command)
continue;
if ((this_reason != NULL) && (strcmp (current_command->reason, this_reason) != 0))
continue;
if (this_reason == NULL)
this_reason = current_command->reason;
char job_id_buff[30];
sprintf (job_id_buff, "%d.%d",
current_command->cluster_id,
current_command->proc_id);
id_list.append (job_id_buff);
this_batch.Append (current_command);
}
// If we haven't found any....
if (id_list.isEmpty()) {
i++;
continue; // ... then try the next command
}
// Perform the appropriate command on the current batch
ClassAd * result_ad= NULL;
if (this_command == SchedDRequest::SDC_REMOVE_JOB) {
errstack.clear();
result_ad=
dc_schedd.removeJobs (
&id_list,
this_reason,
&errstack);
} else if (this_command == SchedDRequest::SDC_HOLD_JOB) {
errstack.clear();
result_ad=
dc_schedd.holdJobs (
&id_list,
this_reason,
NULL,
&errstack);
} else if (this_command == SchedDRequest::SDC_RELEASE_JOB) {
errstack.clear();
result_ad=
dc_schedd.releaseJobs (
&id_list,
this_reason,
&errstack);
} else {
EXCEPT( "Unexpected command type %d in doContactSchedd",
this_command );
}
// Analyze the result ad
if (!result_ad) {
error = TRUE;
sprintf( error_msg, "Error connecting to schedd %s %s: %s",
ScheddAddr, dc_schedd.addr(), errstack.getFullText() );
}
else {
result_ad->dPrint (D_FULLDEBUG);
if ( this_command == SchedDRequest::SDC_RELEASE_JOB ) {
do_reschedule = true;
}
}
// Go through the batch again, and create responses for each request
this_batch.Rewind();
while (this_batch.Next(current_command)) {
// Check the result
char job_id_buff[30];
if (result_ad && (error == FALSE)) {
sprintf (job_id_buff, "job_%d_%d",
current_command->cluster_id,
current_command->proc_id);
int remove_result;
if (result_ad->LookupInteger (job_id_buff, remove_result)) {
switch (remove_result) {
case AR_ERROR:
error = TRUE;
error_msg = "General Error";
break;
case AR_SUCCESS:
error = FALSE;
break;
case AR_NOT_FOUND:
error = TRUE;
error_msg = "Job not found";
break;
case AR_BAD_STATUS:
error = TRUE;
error_msg = "Bad job status";
break;
case AR_ALREADY_DONE:
error = TRUE;
error_msg = "Already done";
break;
case AR_PERMISSION_DENIED:
error = TRUE;
error_msg = "Permission denied";
break;
default:
error = TRUE;
error_msg = "Unknown Result";
} // hctiws
} else {
error_msg = "Unable to get result";
} // fi lookup result for job
} // fi error == FALSE
if (error) {
dprintf (D_ALWAYS, "Error (operation: %s) %d.%d: %s\n",
this_action,
current_command->cluster_id,
current_command->proc_id,
error_msg.c_str());
const char * result[2];
result[0] = GAHP_RESULT_FAILURE;
result[1] = error_msg.c_str();
enqueue_result (current_command->request_id, result, 2);
} else {
dprintf (D_ALWAYS, "Succeess (operation: %s) %d.%d\n",
this_action,
current_command->cluster_id,
current_command->proc_id);
const char * result[2];
result[0] = GAHP_RESULT_SUCCESS;
result[1] = NULL;
enqueue_result (current_command->request_id, result, 2);
} // fi error
// Mark the status
current_command->status = SchedDRequest::SDCS_COMPLETED;
} // elihw this_batch
if ( result_ad ) {
delete result_ad;
}
}
dprintf (D_FULLDEBUG, "Processing JOB_STAGE_IN requests\n");
// JOB_STAGE_IN
int MAX_BATCH_SIZE=1; // This should be a config param
SimpleList <SchedDRequest*> stage_in_batch;
do {
stage_in_batch.Clear();
command_queue.Rewind();
while (command_queue.Next(current_command)) {
if (current_command->status != SchedDRequest::SDCS_NEW)
continue;
if (current_command->command != SchedDRequest::SDC_JOB_STAGE_IN)
continue;
dprintf (D_ALWAYS, "Adding %d.%d to STAGE_IN batch\n",
current_command->cluster_id,
current_command->proc_id);
stage_in_batch.Append (current_command);
if (stage_in_batch.Number() >= MAX_BATCH_SIZE)
break;
}
if (stage_in_batch.Number() > 0) {
ClassAd ** array = new ClassAd*[stage_in_batch.Number()];
i=0;
stage_in_batch.Rewind();
while (stage_in_batch.Next(current_command)) {
array[i++] = current_command->classad;
}
error = FALSE;
errstack.clear();
if (!dc_schedd.spoolJobFiles( stage_in_batch.Number(),
array,
&errstack )) {
error = TRUE;
sprintf( error_msg, "Error sending files to schedd %s: %s", ScheddAddr, errstack.getFullText() );
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
}
delete [] array;
stage_in_batch.Rewind();
while (stage_in_batch.Next(current_command)) {
current_command->status = SchedDRequest::SDCS_COMPLETED;
if (error) {
const char * result[] = {
GAHP_RESULT_FAILURE,
error_msg.c_str() };
enqueue_result (current_command->request_id, result, 2);
} else {
const char * result[] = {
GAHP_RESULT_SUCCESS,
NULL };
enqueue_result (current_command->request_id, result, 2);
}
} // elihw (command_queue)
} // fi has STAGE_IN requests
} while (stage_in_batch.Number() > 0);
dprintf (D_FULLDEBUG, "Processing JOB_STAGE_OUT requests\n");
// JOB_STAGE_OUT
SimpleList <SchedDRequest*> stage_out_batch;
command_queue.Rewind();
while (command_queue.Next(current_command)) {
if (current_command->status != SchedDRequest::SDCS_NEW)
continue;
if (current_command->command != SchedDRequest::SDC_JOB_STAGE_OUT)
continue;
stage_out_batch.Append (current_command);
}
if (stage_out_batch.Number() > 0) {
std::string constraint = "";
stage_out_batch.Rewind();
int jobsexpected = stage_out_batch.Number();
while (stage_out_batch.Next(current_command)) {
sprintf_cat( constraint, "(ClusterId==%d&&ProcId==%d)||",
current_command->cluster_id,
current_command->proc_id );
}
constraint += "False";
error = FALSE;
errstack.clear();
int jobssent;
if (!dc_schedd.receiveJobSandbox( constraint.c_str(),
&errstack, &jobssent )) {
error = TRUE;
sprintf( error_msg, "Error receiving files from schedd %s: %s",
ScheddAddr, errstack.getFullText() );
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
}
if(error == FALSE && jobssent != jobsexpected) {
error = TRUE;
sprintf( error_msg, "Schedd %s didn't send expected files",
ScheddAddr );
dprintf (D_ALWAYS, "Transfered files for %d jobs but got files for %d jobs. (Schedd %s with contraint %s\n", jobsexpected, jobssent, ScheddAddr, constraint.c_str());
}
stage_out_batch.Rewind();
while (stage_out_batch.Next(current_command)) {
current_command->status = SchedDRequest::SDCS_COMPLETED;
if (error) {
const char * result[] = {
GAHP_RESULT_FAILURE,
error_msg.c_str() };
enqueue_result (current_command->request_id, result, 2);
} else {
const char * result[] = {
GAHP_RESULT_SUCCESS,
NULL };
enqueue_result (current_command->request_id, result, 2);
}
} // elihw (command_queue)
} // fi has STAGE_OUT requests
dprintf (D_FULLDEBUG, "Processing JOB_REFRESH_PROXY requests\n");
CondorVersionInfo ver_info(dc_schedd.version());
bool delegate_credential;
if ( ver_info.built_since_version(6,7,19) &&
param_boolean( "DELEGATE_JOB_GSI_CREDENTIALS", true ) ) {
delegate_credential = true;
} else {
delegate_credential = false;
}
// JOB_REFRESH_PROXY
command_queue.Rewind();
while (command_queue.Next(current_command)) {
if (current_command->status != SchedDRequest::SDCS_NEW)
continue;
if (current_command->command != SchedDRequest::SDC_JOB_REFRESH_PROXY)
continue;
time_t expiration_time = GetDesiredDelegatedJobCredentialExpiration(current_command->classad);
time_t result_expiration_time = 0;
bool result;
errstack.clear();
if ( delegate_credential ) {
result = dc_schedd.delegateGSIcredential(
current_command->cluster_id,
current_command->proc_id,
current_command->proxy_file,
expiration_time,
&result_expiration_time,
&errstack );
// Currently, we do not propagate the actual resulting
// expiration time back to the gridmanager. We
// probably should.
} else {
result = dc_schedd.updateGSIcredential(
current_command->cluster_id,
current_command->proc_id,
current_command->proxy_file,
&errstack );
}
current_command->status = SchedDRequest::SDCS_COMPLETED;
if (result == false) {
sprintf( error_msg, "Error refreshing proxy to schedd %s: %s",
ScheddAddr, errstack.getFullText() );
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
const char * result_to_queue[] = {
GAHP_RESULT_FAILURE,
error_msg.c_str() };
enqueue_result (current_command->request_id, result_to_queue, 2);
} else {
const char * result_to_queue[] = {
GAHP_RESULT_SUCCESS,
NULL };
enqueue_result (current_command->request_id, result_to_queue, 2);
}
}
// Now do all the QMGMT transactions
error = FALSE;
// Try connecting to the queue
Qmgr_connection * qmgr_connection;
if ((qmgr_connection = ConnectQ(dc_schedd.addr(), QMGMT_TIMEOUT, false, NULL, NULL, dc_schedd.version() )) == NULL) {
error = TRUE;
sprintf( error_msg, "Error connecting to schedd %s", ScheddAddr );
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
} else {
errno = 0;
AbortTransaction(); // Just so we can call BeginTransaction() in the loop
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
}
dprintf (D_FULLDEBUG, "Processing UPDATE_CONSTRAINED/UDATE_JOB requests\n");
// UPDATE_CONSTRAINED
// UDATE_JOB
command_queue.Rewind();
while (command_queue.Next(current_command)) {
if (current_command->status != SchedDRequest::SDCS_NEW)
continue;
if ((current_command->command != SchedDRequest::SDC_UPDATE_CONSTRAINED) &&
(current_command->command != SchedDRequest::SDC_UPDATE_JOB))
continue;
if (qmgr_connection == NULL)
goto update_report_result;
error = FALSE;
errno = 0;
BeginTransaction();
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
current_command->classad->ResetExpr();
ExprTree *tree;
const char *lhstr, *rhstr;
while( current_command->classad->NextExpr(lhstr, tree) ) {
rhstr = ExprTreeToString( tree );
if( !lhstr || !rhstr) {
sprintf( error_msg, "ERROR: ClassAd problem in Updating by constraint %s",
current_command->constraint );
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
error = TRUE;
} else {
if (current_command->command == SchedDRequest::SDC_UPDATE_CONSTRAINED) {
if( SetAttributeByConstraint(current_command->constraint,
lhstr,
rhstr) == -1 ) {
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
sprintf( error_msg, "ERROR: Failed (errno=%d) to SetAttributeByConstraint %s=%s for constraint %s",
errno, lhstr, rhstr, current_command->constraint );
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
error = TRUE;
}
} else if (current_command->command == SchedDRequest::SDC_UPDATE_JOB) {
if( SetAttribute(current_command->cluster_id,
current_command->proc_id,
lhstr,
rhstr) == -1 ) {
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
sprintf( error_msg, "ERROR: Failed to SetAttribute() %s=%s for job %d.%d",
lhstr, rhstr, current_command->cluster_id, current_command->proc_id);
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
error = TRUE;
}
}
}
if (error)
break;
} // elihw classad
update_report_result:
if (error) {
const char * result[] = {
GAHP_RESULT_FAILURE,
error_msg.c_str() };
//RemoteCommitTransaction();
enqueue_result (current_command->request_id, result, 2);
current_command->status = SchedDRequest::SDCS_COMPLETED;
if ( qmgr_connection != NULL ) {
errno = 0;
AbortTransaction();
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
}
} else {
if ( RemoteCommitTransaction() < 0 ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
const char * result[] = {
GAHP_RESULT_SUCCESS,
NULL };
enqueue_result (current_command->request_id, result, 2);
current_command->status = SchedDRequest::SDCS_COMPLETED;
} // fi
} // elihw
dprintf (D_FULLDEBUG, "Processing UPDATE_LEASE requests\n");
// UPDATE_LEASE
command_queue.Rewind();
while (command_queue.Next(current_command)) {
error = FALSE;
if (current_command->status != SchedDRequest::SDCS_NEW)
continue;
if (current_command->command != SchedDRequest::SDC_UPDATE_LEASE)
continue;
std::string success_job_ids="";
if (qmgr_connection == NULL) {
sprintf( error_msg, "Error connecting to schedd %s", ScheddAddr );
error = TRUE;
} else {
error = FALSE;
errno = 0;
BeginTransaction();
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
for (i=0; i<current_command->num_jobs; i++) {
time_t time_now = time(NULL);
int duration =
current_command->expirations[i].expiration - time_now;
dprintf (D_FULLDEBUG,
"Job %d.%d SetTimerAttribute=%d\n",
current_command->expirations[i].cluster,
current_command->expirations[i].proc,
duration);
if (SetTimerAttribute (current_command->expirations[i].cluster,
current_command->expirations[i].proc,
ATTR_TIMER_REMOVE_CHECK,
duration) < 0) {
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
dprintf (D_ALWAYS,
"Unable to SetTimerAttribute(%d, %d), errno=%d\n",
current_command->expirations[i].cluster,
current_command->expirations[i].proc,
errno);
} else {
// Append job id to the result line
if (success_job_ids.length() > 0)
success_job_ids += ",";
sprintf_cat( success_job_ids,
"%d.%d",
current_command->expirations[i].cluster,
current_command->expirations[i].proc);
}
} //rof jobs for request
} // fi error
if (error) {
const char * result[] = {
GAHP_RESULT_FAILURE,
error_msg.c_str(),
NULL
};
//RemoteCommitTransaction();
enqueue_result (current_command->request_id, result, 3);
current_command->status = SchedDRequest::SDCS_COMPLETED;
if ( qmgr_connection != NULL ) {
errno = 0;
AbortTransaction();
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
}
} else {
if ( RemoteCommitTransaction() < 0 ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
const char * result[] = {
GAHP_RESULT_SUCCESS,
NULL,
success_job_ids.length()?success_job_ids.c_str():NULL
};
enqueue_result (current_command->request_id, result, 3);
current_command->status = SchedDRequest::SDCS_COMPLETED;
} // fi
} // elihw UPDATE_LEASE requests
dprintf (D_FULLDEBUG, "Processing SUBMIT_JOB requests\n");
// SUBMIT_JOB
command_queue.Rewind();
while (command_queue.Next(current_command)) {
if (current_command->status != SchedDRequest::SDCS_NEW)
continue;
if (current_command->command != SchedDRequest::SDC_SUBMIT_JOB)
continue;
int ClusterId = -1;
int ProcId = -1;
if (qmgr_connection == NULL) {
error = TRUE;
goto submit_report_result;
}
errno = 0;
BeginTransaction();
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
error = FALSE;
if ((ClusterId = NewCluster()) >= 0) {
ProcId = NewProc (ClusterId);
}
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
if ( ClusterId < 0 ) {
error = TRUE;
error_msg = "Unable to create a new job cluster";
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
} else if ( ProcId < 0 ) {
error = TRUE;
error_msg = "Unable to create a new job proc";
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
}
if ( ClusterId == -2 || ProcId == -2 ) {
error = TRUE;
error_msg =
"Number of submitted jobs would exceed MAX_JOBS_SUBMITTED\n";
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
}
// Adjust the argument/environment syntax based on the version
// of the schedd we are talking to.
if( error == FALSE) {
CondorVersionInfo version_info(dc_schedd.version());
ArgList arglist;
MyString arg_error_msg;
Env env_obj;
MyString env_error_msg;
if(!arglist.AppendArgsFromClassAd(current_command->classad,&arg_error_msg) ||
! arglist.InsertArgsIntoClassAd(current_command->classad,&version_info,&arg_error_msg))
{
sprintf( error_msg,
"ERROR: ClassAd problem in converting arguments to syntax "
"for schedd (version=%s): %s\n",
dc_schedd.version() ? dc_schedd.version() : "NULL",
arg_error_msg.Value());
dprintf( D_ALWAYS,"%s\n", error_msg.c_str() );
error = TRUE;
}
if(!env_obj.MergeFrom(current_command->classad,&env_error_msg) ||
!env_obj.InsertEnvIntoClassAd(current_command->classad,&env_error_msg,NULL,&version_info))
{
sprintf( error_msg,
"ERROR: Failed to convert environment to target syntax"
" for schedd (version %s): %s\n",
dc_schedd.version() ? dc_schedd.version() : "NULL",
env_error_msg.Value());
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
error = TRUE;
}
}
if( error == FALSE ) {
// See the comment in the function body of ExpandInputFileList
// for an explanation of what is going on here.
MyString transfer_input_error_msg;
if( !FileTransfer::ExpandInputFileList( current_command->classad, transfer_input_error_msg ) ) {
dprintf( D_ALWAYS, "%s\n", transfer_input_error_msg.Value() );
error = TRUE;
}
}
if ( error == FALSE ) {
current_command->classad->Assign(ATTR_CLUSTER_ID, ClusterId);
current_command->classad->Assign(ATTR_PROC_ID, ProcId);
// Special case for the job lease
int expire_time;
if ( current_command->classad->LookupInteger( ATTR_TIMER_REMOVE_CHECK, expire_time ) ) {
if ( SetTimerAttribute( ClusterId, ProcId,
ATTR_TIMER_REMOVE_CHECK,
expire_time - time(NULL) ) == -1 ) {
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
sprintf( error_msg, "ERROR: Failed to SetTimerAttribute %s=%ld for job %d.%d",
ATTR_TIMER_REMOVE_CHECK, expire_time - time(NULL), ClusterId, ProcId );
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
error = TRUE;
goto submit_report_result;
}
current_command->classad->Delete( ATTR_TIMER_REMOVE_CHECK );
}
// Set all the classad attribute on the remote classad
current_command->classad->ResetExpr();
ExprTree *tree;
const char *lhstr, *rhstr;
while( current_command->classad->NextExpr(lhstr, tree) ) {
rhstr = ExprTreeToString( tree );
if( !lhstr || !rhstr) {
sprintf( error_msg, "ERROR: ClassAd problem in Updating by constraint %s",
current_command->constraint );
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
error = TRUE;
} else if( SetAttribute (ClusterId, ProcId,
lhstr,
rhstr) == -1 ) {
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
sprintf( error_msg, "ERROR: Failed to SetAttribute %s=%s for job %d.%d",
lhstr, rhstr, ClusterId, ProcId );
dprintf( D_ALWAYS, "%s\n", error_msg.c_str() );
error = TRUE;
}
if (error) break;
} // elihw classad
} // fi error==FALSE
submit_report_result:
char job_id_buff[30];
sprintf (job_id_buff, "%d.%d", ClusterId, ProcId);
if (error) {
const char * result[] = {
GAHP_RESULT_FAILURE,
job_id_buff,
error_msg.c_str() };
enqueue_result (current_command->request_id, result, 3);
if ( qmgr_connection != NULL ) {
errno = 0;
AbortTransaction();
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
}
current_command->status = SchedDRequest::SDCS_COMPLETED;
} else {
if ( RemoteCommitTransaction() < 0 ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
const char * result[] = {
GAHP_RESULT_SUCCESS,
job_id_buff,
NULL };
enqueue_result (current_command->request_id, result, 3);
current_command->status = SchedDRequest::SDCS_COMPLETED;
}
} // elihw
dprintf (D_FULLDEBUG, "Processing STATUS_CONSTRAINED requests\n");
// STATUS_CONSTRAINED
command_queue.Rewind();
while (command_queue.Next(current_command)) {
if (current_command->status != SchedDRequest::SDCS_NEW)
continue;
if (current_command->command != SchedDRequest::SDC_STATUS_CONSTRAINED)
continue;
if (qmgr_connection != NULL) {
SimpleList <MyString *> matching_ads;
error = FALSE;
ClassAd *next_ad;
ClassAdList adlist;
// Only use GetAllJobsByConstraint if remote schedd is
// 6.9.5 or newer. Previous versions either did not
// support this call, or they closed the Qmgmt connection
// as a side-effect of this call.
if( ver_info.built_since_version(6,9,5) ) {
dprintf( D_FULLDEBUG, "Calling GetAllJobsByConstraint(%s)\n",
current_command->constraint );
// NOTE: this could be made more efficient if we knew
// the list of attributes to query. For lack of that,
// we just get all attributes.
GetAllJobsByConstraint( current_command->constraint, "", adlist);
}
else {
// This is the old latency-prone method.
dprintf( D_FULLDEBUG, "Calling GetNextJobByConstraint(%s)\n",
current_command->constraint );
next_ad = GetNextJobByConstraint( current_command->constraint, 1 );
while( next_ad != NULL ) {
adlist.Insert( next_ad );
next_ad = GetNextJobByConstraint( current_command->constraint, 0 );
}
}
// NOTE: ClassAdList will deallocate the ClassAds in it
adlist.Rewind();
while( (next_ad=adlist.Next()) ) {
MyString * da_buffer = new MyString(); // Use a ptr to avoid excessive copying
if ( useXMLClassads ) {
ClassAdXMLUnparser unparser;
unparser.SetUseCompactSpacing(true);
unparser.Unparse (next_ad, *da_buffer);
} else {
NewClassAdUnparser unparser;
unparser.SetUseCompactSpacing(true);
unparser.Unparse (next_ad, *da_buffer);
}
matching_ads.Append (da_buffer);
}
if ( errno == ETIMEDOUT ) {
failure_line_num = __LINE__;
failure_errno = errno;
goto contact_schedd_disconnect;
}
// now output this list of classads into a result
const char ** result = new const char* [matching_ads.Length() + 3];
std::string _ad_count;
sprintf( _ad_count, "%d", matching_ads.Length() );
int count=0;
result[count++] = GAHP_RESULT_SUCCESS;
result[count++] = NULL;
result[count++] = _ad_count.c_str();
MyString *next_string;
matching_ads.Rewind();
while (matching_ads.Next(next_string)) {
result[count++] = next_string->Value();
}
enqueue_result (current_command->request_id, result, count);
current_command->status = SchedDRequest::SDCS_COMPLETED;
// Cleanup
matching_ads.Rewind();
while (matching_ads.Next(next_string)) {
delete next_string;
}
//CommitTransaction();
delete [] result;
}
else {
const char * result[] = {
GAHP_RESULT_FAILURE,
error_msg.c_str(),
"0" };
//RemoteCommitTransaction();
enqueue_result (current_command->request_id, result, 3);
current_command->status = SchedDRequest::SDCS_COMPLETED;
}
} //elihw
contact_schedd_disconnect:
if ( qmgr_connection != NULL ) {
DisconnectQ (qmgr_connection, FALSE);
}
if ( failure_line_num ) {
// We had an error talking to the schedd. Take all of our
// incomplete commands and mark them as failed.
// TODO Consider retrying these commands, rather than
// immediately marking them as failed.
if ( failure_errno == ETIMEDOUT ) {
dprintf( D_ALWAYS, "Timed out talking to schedd at line %d in "
"doContactSchedd()\n", failure_line_num );
sprintf( error_msg, "Timed out talking to schedd" );
} else {
dprintf( D_ALWAYS, "Error talking to schedd at line %d in "
"doContactSchedd(), errno=%d (%s)\n", failure_line_num,
failure_errno, strerror(failure_errno) );
sprintf( error_msg, "Error talking to schedd" );
}
command_queue.Rewind();
while (command_queue.Next(current_command)) {
if ( current_command->status != SchedDRequest::SDCS_NEW ) {
continue;
}
switch( current_command->command ) {
case SchedDRequest::SDC_UPDATE_JOB:
case SchedDRequest::SDC_UPDATE_CONSTRAINED:
{
const char *result[2] = { GAHP_RESULT_FAILURE, error_msg.c_str() };
enqueue_result (current_command->request_id, result, 2);
current_command->status = SchedDRequest::SDCS_COMPLETED;
}
break;
case SchedDRequest::SDC_UPDATE_LEASE:
{
const char *result[3] = { GAHP_RESULT_FAILURE, error_msg.c_str(), NULL };
enqueue_result (current_command->request_id, result, 3);
current_command->status = SchedDRequest::SDCS_COMPLETED;
}
break;
case SchedDRequest::SDC_SUBMIT_JOB:
{
const char *result[3] = { GAHP_RESULT_FAILURE, "-1.-1", error_msg.c_str() };
enqueue_result (current_command->request_id, result, 3);
current_command->status = SchedDRequest::SDCS_COMPLETED;
}
break;
case SchedDRequest::SDC_STATUS_CONSTRAINED:
{
const char *result[3] = { GAHP_RESULT_FAILURE, error_msg.c_str(), "0" };
enqueue_result (current_command->request_id, result, 3);
current_command->status = SchedDRequest::SDCS_COMPLETED;
}
break;
default:
// Do nothing
;
}
}
}
if ( do_reschedule ) {
dc_schedd.reschedule();
}
// Write all of our results to our parent.
flush_results();
dprintf (D_FULLDEBUG, "Finishing doContactSchedd()\n");
// Clean up the list
command_queue.Rewind();
while (command_queue.Next(current_command)) {
if (current_command->status == SchedDRequest::SDCS_COMPLETED) {
command_queue.DeleteCurrent();
delete current_command;
}
}
// Come back soon..
// QUESTION: Should this always be a fixed time period?
daemonCore->Reset_Timer( contactScheddTid, contact_schedd_interval );
}
int
do_Q_request(ReliSock *syscall_sock,bool &may_fork)
{
int request_num = -1;
int rval;
syscall_sock->decode();
assert( syscall_sock->code(request_num) );
dprintf(D_SYSCALLS, "Got request #%d\n", request_num);
switch( request_num ) {
case CONDOR_InitializeConnection:
{
// dprintf( D_ALWAYS, "InitializeConnection()\n" );
bool authenticated = true;
// Authenticate socket, if not already done by daemonCore
if( !syscall_sock->triedAuthentication() ) {
if( IsDebugLevel(D_SECURITY) ) {
MyString methods;
SecMan::getAuthenticationMethods( WRITE, &methods );
dprintf(D_SECURITY,"Calling authenticate(%s) in qmgmt_receivers\n", methods.Value());
}
CondorError errstack;
if( ! SecMan::authenticate_sock(syscall_sock, WRITE, &errstack) ) {
// Failed to authenticate
dprintf( D_ALWAYS, "SCHEDD: authentication failed: %s\n",
errstack.getFullText().c_str() );
authenticated = false;
}
}
if ( authenticated ) {
InitializeConnection( syscall_sock->getOwner(),
syscall_sock->getDomain() );
} else {
InitializeConnection( NULL, NULL );
}
return 0;
}
case CONDOR_InitializeReadOnlyConnection:
{
// dprintf( D_ALWAYS, "InitializeReadOnlyConnection()\n" );
// Since InitializeConnection() does nothing, and we need
// to record the fact that this is a read-only connection,
// but we have to do it in the socket (since we don't have
// any other persistent data structure, and it's probably
// the right place anyway), set the FQU.
//
// We need to record if this is a read-only connection so that
// we can avoid expanding $$ in GetJobAd; simply checking if the
// connection is authenticated isn't sufficient, because the
// security session cache means that read-only connection could
// be authenticated by a previous authenticated connection from
// the same address (when using host-based security) less than
// the expiration period ago.
syscall_sock->setFullyQualifiedUser( "read-only" );
// same as InitializeConnection but no authenticate()
InitializeConnection( NULL, NULL );
may_fork = true;
return 0;
}
case CONDOR_SetEffectiveOwner:
{
MyString owner;
int terrno;
assert( syscall_sock->get(owner) );
assert( syscall_sock->end_of_message() );
rval = QmgmtSetEffectiveOwner( owner.Value() );
terrno = errno;
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
assert( syscall_sock->end_of_message() );
char const *fqu = syscall_sock->getFullyQualifiedUser();
dprintf(D_SYSCALLS, "\tSetEffectiveOwner\n");
dprintf(D_SYSCALLS, "\tauthenticated user = '******'\n", fqu ? fqu : "");
dprintf(D_SYSCALLS, "\trequested owner = '%s'\n", owner.Value());
dprintf(D_SYSCALLS, "\trval %d, errno %d\n", rval, terrno);
return 0;
}
case CONDOR_NewCluster:
{
int terrno;
assert( syscall_sock->end_of_message() );;
errno = 0;
rval = NewCluster( );
terrno = errno;
dprintf(D_SYSCALLS,
"\tNewCluster: rval = %d, errno = %d\n",rval,terrno );
if ( rval > 0 ) {
dprintf( D_AUDIT, *syscall_sock,
"Submitting new job %d.0\n", rval );
}
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
assert( syscall_sock->end_of_message() );;
dprintf(D_FULLDEBUG,"schedd: NewCluster rval %d errno %d\n",rval,terrno);
return 0;
}
case CONDOR_NewProc:
{
int cluster_id = -1;
int terrno;
assert( syscall_sock->code(cluster_id) );
dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id );
assert( syscall_sock->end_of_message() );;
errno = 0;
rval = NewProc( cluster_id );
terrno = errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
if ( rval > 0 ) {
dprintf( D_AUDIT, *syscall_sock,
"Submitting new job %d.%d\n", cluster_id, rval );
}
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
assert( syscall_sock->end_of_message() );;
dprintf(D_FULLDEBUG,"schedd: NewProc rval %d errno %d\n",rval,terrno);
return 0;
}
case CONDOR_DestroyProc:
{
int cluster_id = -1;
int proc_id = -1;
int terrno;
assert( syscall_sock->code(cluster_id) );
dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id );
assert( syscall_sock->code(proc_id) );
dprintf( D_SYSCALLS, " proc_id = %d\n", proc_id );
assert( syscall_sock->end_of_message() );;
errno = 0;
rval = DestroyProc( cluster_id, proc_id );
terrno = errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
assert( syscall_sock->end_of_message() );;
dprintf(D_FULLDEBUG,"schedd: DestroyProc cluster %d proc %d rval %d errno %d\n",cluster_id,proc_id,rval,terrno);
return 0;
}
case CONDOR_DestroyCluster:
{
int cluster_id = -1;
int terrno;
assert( syscall_sock->code(cluster_id) );
dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id );
assert( syscall_sock->end_of_message() );;
errno = 0;
rval = DestroyCluster( cluster_id );
terrno = errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
assert( syscall_sock->end_of_message() );;
return 0;
}
#if 0
case CONDOR_DestroyClusterByConstraint:
{
char *constraint=NULL;
int terrno;
assert( syscall_sock->code(constraint) );
assert( syscall_sock->end_of_message() );;
errno = 0;
rval = DestroyClusterByConstraint( constraint );
terrno = errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
free( (char *)constraint );
assert( syscall_sock->end_of_message() );;
return 0;
}
#endif
case CONDOR_SetAttributeByConstraint:
case CONDOR_SetAttributeByConstraint2:
{
char *attr_name=NULL;
char *attr_value=NULL;
char *constraint=NULL;
int terrno;
SetAttributeFlags_t flags = 0;
assert( syscall_sock->code(constraint) );
dprintf( D_SYSCALLS, " constraint = %s\n",constraint);
assert( syscall_sock->code(attr_value) );
assert( syscall_sock->code(attr_name) );
if( request_num == CONDOR_SetAttributeByConstraint2 ) {
assert( syscall_sock->code( flags ) );
}
assert( syscall_sock->end_of_message() );;
if (strcmp (attr_name, ATTR_MYPROXY_PASSWORD) == 0) {
errno = 0;
dprintf( D_SYSCALLS, "SetAttributeByConstraint (MyProxyPassword) not supported...\n");
rval = 0;
terrno = errno;
} else {
errno = 0;
rval = SetAttributeByConstraint( constraint, attr_name, attr_value, flags );
terrno = errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
if ( rval == 0 ) {
dprintf( D_AUDIT, *syscall_sock,
"Set Attribute By Constraint %s, "
"%s = %s\n",
constraint, attr_name, attr_value);
}
}
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
free( (char *)constraint );
free( (char *)attr_value );
free( (char *)attr_name );
assert( syscall_sock->end_of_message() );;
return 0;
}
case CONDOR_SetAttribute:
case CONDOR_SetAttribute2:
{
int cluster_id = -1;
int proc_id = -1;
char *attr_name=NULL;
char *attr_value=NULL;
int terrno;
SetAttributeFlags_t flags = 0;
const char *users_username;
const char *condor_username;
assert( syscall_sock->code(cluster_id) );
dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id );
assert( syscall_sock->code(proc_id) );
dprintf( D_SYSCALLS, " proc_id = %d\n", proc_id );
assert( syscall_sock->code(attr_value) );
assert( syscall_sock->code(attr_name) );
if( request_num == CONDOR_SetAttribute2 ) {
assert( syscall_sock->code( flags ) );
}
users_username = syscall_sock->getOwner();
condor_username = get_condor_username();
if (attr_name) dprintf(D_SYSCALLS,"\tattr_name = %s\n",attr_name);
if (attr_value) dprintf(D_SYSCALLS,"\tattr_value = %s\n",attr_value);
assert( syscall_sock->end_of_message() );;
// ckireyev:
// We do NOT want to include MyProxy password in the ClassAd (since it's a secret)
// I'm not sure if this is the best place to do this, but....
if (attr_name && attr_value && strcmp (attr_name, ATTR_MYPROXY_PASSWORD) == 0) {
errno = 0;
dprintf( D_SYSCALLS, "Got MyProxyPassword, stashing...\n");
rval = SetMyProxyPassword (cluster_id, proc_id, attr_value);
terrno = errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
}
else {
errno = 0;
rval = SetAttribute( cluster_id, proc_id, attr_name, attr_value, flags );
terrno = errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
// If we're modifying a previously-submitted job AND either
// the client's username is not HTCondor's (i.e. not a
// daemon) OR the client says we should log...
if( (cluster_id != active_cluster_num) && (rval == 0) &&
( strcmp(users_username, condor_username) || (flags & SHOULDLOG) ) ) {
dprintf( D_AUDIT, *syscall_sock,
"Set Attribute for job %d.%d, "
"%s = %s\n",
cluster_id, proc_id, attr_name, attr_value);
}
}
free( (char *)attr_value );
free( (char *)attr_name );
if( flags & SetAttribute_NoAck ) {
if( rval < 0 ) {
return -1;
}
}
else {
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
assert( syscall_sock->end_of_message() );
}
return 0;
}
case CONDOR_SetTimerAttribute:
{
int cluster_id = -1;
int proc_id = -1;
char *attr_name=NULL;
int duration = 0;
int terrno;
assert( syscall_sock->code(cluster_id) );
dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id );
assert( syscall_sock->code(proc_id) );
dprintf( D_SYSCALLS, " proc_id = %d\n", proc_id );
assert( syscall_sock->code(attr_name) );
if (attr_name) dprintf(D_SYSCALLS,"\tattr_name = %s\n",attr_name);
assert( syscall_sock->code(duration) );
dprintf(D_SYSCALLS,"\tduration = %d\n",duration);
assert( syscall_sock->end_of_message() );;
errno = 0;
rval = SetTimerAttribute( cluster_id, proc_id, attr_name, duration );
terrno = errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
dprintf( D_AUDIT, *syscall_sock,
"Set Timer Attribute for job %d.%d, "
"attr_name = %s, duration = %d\n",
cluster_id, proc_id, attr_name, duration);
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
free( (char *)attr_name );
assert( syscall_sock->end_of_message() );;
return 0;
}
case CONDOR_BeginTransaction:
{
int terrno;
assert( syscall_sock->end_of_message() );;
errno = 0;
rval = 0; // BeginTransaction returns void (sigh), so always success
BeginTransaction( );
terrno = errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
assert( syscall_sock->end_of_message() );;
return 0;
}
case CONDOR_AbortTransaction:
{
int terrno;
assert( syscall_sock->end_of_message() );;
errno = 0;
rval = 0; // AbortTransaction returns void (sigh), so always success
AbortTransaction( );
terrno = errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
assert( syscall_sock->end_of_message() );;
return 0;
}
case CONDOR_CommitTransactionNoFlags:
case CONDOR_CommitTransaction:
{
int terrno;
int flags;
if( request_num == CONDOR_CommitTransaction ) {
assert( syscall_sock->code(flags) );
}
else {
flags = 0;
}
assert( syscall_sock->end_of_message() );;
errno = 0;
CondorError errstack;
rval = CheckTransaction( flags, & errstack );
terrno = errno;
dprintf( D_SYSCALLS, "\tflags = %d, rval = %d, errno = %d\n", flags, rval, terrno );
if( rval >= 0 ) {
errno = 0;
CommitTransaction( flags );
// CommitTransaction() never returns on failure
rval = 0;
terrno = errno;
dprintf( D_SYSCALLS, "\tflags = %d, rval = %d, errno = %d\n", flags, rval, terrno );
}
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
const CondorVersionInfo *vers = syscall_sock->get_peer_version();
if (vers && vers->built_since_version(8, 3, 4))
{
// Send a classad, for less backwards-incompatibility.
int code = 1;
const char * reason = "QMGMT rejected job submission.";
if( errstack.subsys() ) {
code = 2;
reason = errstack.message();
}
ClassAd reply;
reply.Assign( "ErrorCode", code );
reply.Assign( "ErrorReason", reason );
assert( putClassAd( syscall_sock, reply ) );
}
}
assert( syscall_sock->end_of_message() );;
return 0;
}
case CONDOR_GetAttributeFloat:
{
int cluster_id = -1;
int proc_id = -1;
char *attr_name=NULL;
float value = 0.0;
int terrno;
assert( syscall_sock->code(cluster_id) );
dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id );
assert( syscall_sock->code(proc_id) );
dprintf( D_SYSCALLS, " proc_id = %d\n", proc_id );
assert( syscall_sock->code(attr_name) );
assert( syscall_sock->end_of_message() );;
errno = 0;
if( QmgmtMayAccessAttribute( attr_name ) ) {
rval = GetAttributeFloat( cluster_id, proc_id, attr_name, &value );
}
else {
rval = -1;
}
terrno = errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
if( rval >= 0 ) {
assert( syscall_sock->code(value) );
}
free( (char *)attr_name );
assert( syscall_sock->end_of_message() );;
return 0;
}
case CONDOR_GetAttributeInt:
{
int cluster_id = -1;
int proc_id = -1;
char *attr_name=NULL;
int value = 0;
int terrno;
assert( syscall_sock->code(cluster_id) );
dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id );
assert( syscall_sock->code(proc_id) );
dprintf( D_SYSCALLS, " proc_id = %d\n", proc_id );
assert( syscall_sock->code(attr_name) );
dprintf( D_SYSCALLS, " attr_name = %s\n", attr_name );
assert( syscall_sock->end_of_message() );;
errno = 0;
if( QmgmtMayAccessAttribute( attr_name ) ) {
rval = GetAttributeInt( cluster_id, proc_id, attr_name, &value );
}
else {
rval = -1;
}
terrno = errno;
if (rval < 0) {
dprintf( D_SYSCALLS, "GetAttributeInt(%d, %d, %s) not found.\n",
cluster_id, proc_id, attr_name);
} else {
dprintf( D_SYSCALLS, " value: %d\n", value );
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
}
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
if( rval >= 0 ) {
assert( syscall_sock->code(value) );
}
free( (char *)attr_name );
assert( syscall_sock->end_of_message() );;
return 0;
}
case CONDOR_GetAttributeString:
{
int cluster_id = -1;
int proc_id = -1;
char *attr_name=NULL;
char *value = NULL;
int terrno;
assert( syscall_sock->code(cluster_id) );
dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id );
assert( syscall_sock->code(proc_id) );
dprintf( D_SYSCALLS, " proc_id = %d\n", proc_id );
assert( syscall_sock->code(attr_name) );
assert( syscall_sock->end_of_message() );;
errno = 0;
if( QmgmtMayAccessAttribute( attr_name ) ) {
rval = GetAttributeStringNew( cluster_id, proc_id, attr_name, &value );
}
else {
rval = -1;
}
terrno = errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
if( rval >= 0 ) {
assert( syscall_sock->code(value) );
}
free( (char *)value );
free( (char *)attr_name );
assert( syscall_sock->end_of_message() );;
return 0;
}
case CONDOR_GetAttributeExpr:
{
int cluster_id = -1;
int proc_id = -1;
char *attr_name=NULL;
int terrno;
assert( syscall_sock->code(cluster_id) );
dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id );
assert( syscall_sock->code(proc_id) );
dprintf( D_SYSCALLS, " proc_id = %d\n", proc_id );
assert( syscall_sock->code(attr_name) );
assert( syscall_sock->end_of_message() );;
char *value = NULL;
errno = 0;
if( QmgmtMayAccessAttribute( attr_name ) ) {
rval = GetAttributeExprNew( cluster_id, proc_id, attr_name, &value );
}
else {
rval = -1;
}
terrno = errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
if ( !syscall_sock->code(rval) ) {
free(value);
return -1;
}
if( rval < 0 ) {
if ( !syscall_sock->code(terrno) ) {
free(value);
return -1;
}
}
if( rval >= 0 ) {
if ( !syscall_sock->code(value) ) {
free(value);
return -1;
}
}
free( (char *)value );
free( (char *)attr_name );
assert( syscall_sock->end_of_message() );;
return 0;
}
case CONDOR_GetDirtyAttributes:
{
int cluster_id = -1;
int proc_id = -1;
ClassAd updates;
int terrno;
assert( syscall_sock->code(cluster_id) );
dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id );
assert( syscall_sock->code(proc_id) );
dprintf( D_SYSCALLS, " proc_id = %d\n", proc_id );
assert( syscall_sock->end_of_message() );;
errno = 0;
rval = GetDirtyAttributes( cluster_id, proc_id, &updates );
terrno = errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
if ( !syscall_sock->code(rval) ) {
return -1;
}
if( rval < 0 ) {
if ( !syscall_sock->code(terrno) ) {
return -1;
}
}
if( rval >= 0 ) {
assert( putClassAd(syscall_sock, updates) );
}
assert( syscall_sock->end_of_message() );;
return 0;
}
case CONDOR_DeleteAttribute:
{
int cluster_id = -1;
int proc_id = -1;
char *attr_name=NULL;
int terrno;
assert( syscall_sock->code(cluster_id) );
dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id );
assert( syscall_sock->code(proc_id) );
dprintf( D_SYSCALLS, " proc_id = %d\n", proc_id );
assert( syscall_sock->code(attr_name) );
assert( syscall_sock->end_of_message() );;
errno = 0;
rval = DeleteAttribute( cluster_id, proc_id, attr_name );
terrno = errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
free( (char *)attr_name );
assert( syscall_sock->end_of_message() );;
return 0;
}
case CONDOR_GetJobAd:
{
int cluster_id = -1;
int proc_id = -1;
ClassAd *ad = NULL;
int terrno;
bool delete_ad = false;
assert( syscall_sock->code(cluster_id) );
dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id );
assert( syscall_sock->code(proc_id) );
dprintf( D_SYSCALLS, " proc_id = %d\n", proc_id );
assert( syscall_sock->end_of_message() );;
// dprintf( D_ALWAYS, "(%d.%d) isAuthenticated() = %d\n", cluster_id, proc_id, syscall_sock->isAuthenticated() );
// dprintf( D_ALWAYS, "(%d.%d) getOwner() = %s\n", cluster_id, proc_id, syscall_sock->getOwner() );
errno = 0;
// Only fetch the jobad for legal values of cluster/proc
if( cluster_id >= 1 ) {
if( proc_id >= 0 ) {
const char * fqu = syscall_sock->getFullyQualifiedUser();
if( fqu != NULL && strcmp( fqu, "read-only" ) != 0 ) {
// expand $$() macros in the jobad as required by GridManager.
// The GridManager depends on the fact that the following call
// expands $$ and saves the expansions to disk in case of
// restart.
ad = GetJobAd_as_ClassAd( cluster_id, proc_id, true, true );
delete_ad = true;
// note : since we expanded the ad, ad is now a deep
// copy of the ad in memory, so we must delete it below.
} else {
ad = GetJobAd_as_ClassAd( cluster_id, proc_id, false, false );
}
} else if( proc_id == -1 ) {
// allow cluster ad to be queried as required by preen, but
// do NOT ask to expand $$() macros in a cluster ad!
ad = GetJobAd_as_ClassAd( cluster_id, proc_id, false, false );
}
}
terrno = errno;
rval = ad ? 0 : -1;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
if( rval >= 0 ) {
assert( putClassAd(syscall_sock, *ad, PUT_CLASSAD_NO_PRIVATE) );
}
// If we called GetJobAd() with the third bool argument set
// to True (expandedAd), it does a deep copy of the ad in the
// queue in order to expand the $$() attributes. So we must
// delete it.
if (delete_ad) delete ad;
assert( syscall_sock->end_of_message() );;
return 0;
}
case CONDOR_GetJobByConstraint:
{
char *constraint=NULL;
ClassAd *ad;
int terrno;
assert( syscall_sock->code(constraint) );
assert( syscall_sock->end_of_message() );;
errno = 0;
ad = GetJobByConstraint_as_ClassAd( constraint );
terrno = errno;
rval = ad ? 0 : -1;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
if( rval >= 0 ) {
assert( putClassAd(syscall_sock, *ad, PUT_CLASSAD_NO_PRIVATE) );
}
FreeJobAd(ad);
free( (char *)constraint );
assert( syscall_sock->end_of_message() );;
return 0;
}
case CONDOR_GetNextJob:
{
ClassAd *ad;
int initScan = 0;
int terrno;
assert( syscall_sock->code(initScan) );
dprintf( D_SYSCALLS, " initScan = %d\n", initScan );
assert( syscall_sock->end_of_message() );;
errno = 0;
ad = GetNextJob( initScan );
terrno = errno;
rval = ad ? 0 : -1;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
if( rval >= 0 ) {
assert( putClassAd(syscall_sock, *ad, PUT_CLASSAD_NO_PRIVATE) );
}
FreeJobAd(ad);
assert( syscall_sock->end_of_message() );;
return 0;
}
case CONDOR_GetNextJobByConstraint:
{
char *constraint=NULL;
ClassAd *ad;
int initScan = 0;
int terrno;
assert( syscall_sock->code(initScan) );
dprintf( D_SYSCALLS, " initScan = %d\n", initScan );
if ( !(syscall_sock->code(constraint)) ) {
if (constraint != NULL) {
free(constraint);
constraint = NULL;
}
return -1;
}
assert( syscall_sock->end_of_message() );;
errno = 0;
ad = GetNextJobByConstraint( constraint, initScan );
terrno = errno;
rval = ad ? 0 : -1;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
if( rval >= 0 ) {
assert( putClassAd(syscall_sock, *ad, PUT_CLASSAD_NO_PRIVATE) );
}
FreeJobAd(ad);
free( (char *)constraint );
assert( syscall_sock->end_of_message() );;
return 0;
}
case CONDOR_GetNextDirtyJobByConstraint:
{
char *constraint=NULL;
ClassAd *ad;
int initScan = 0;
int terrno;
assert( syscall_sock->code(initScan) );
dprintf( D_SYSCALLS, " initScan = %d\n", initScan );
if ( !(syscall_sock->code(constraint)) ) {
if (constraint != NULL) {
free(constraint);
constraint = NULL;
}
return -1;
}
assert( syscall_sock->end_of_message() );
errno = 0;
ad = GetNextDirtyJobByConstraint( constraint, initScan );
terrno = errno;
rval = ad ? 0 : -1;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
if( rval >= 0 ) {
assert( putClassAd(syscall_sock, *ad, PUT_CLASSAD_NO_PRIVATE) );
}
FreeJobAd(ad);
free( (char *)constraint );
assert( syscall_sock->end_of_message() );
return 0;
}
case CONDOR_SendSpoolFile:
{
char *filename=NULL;
int terrno;
assert( syscall_sock->code(filename) );
assert( syscall_sock->end_of_message() );;
errno = 0;
rval = SendSpoolFile( filename );
terrno = errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
#if 0
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
assert( syscall_sock->end_of_message() );;
#endif
free( (char *)filename );
return 0;
}
case CONDOR_SendSpoolFileIfNeeded:
{
int terrno;
ClassAd ad;
assert( getClassAd(syscall_sock, ad) );
assert( syscall_sock->end_of_message() );;
errno = 0;
rval = SendSpoolFileIfNeeded(ad);
terrno = errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
return 0;
}
case CONDOR_GetAllJobsByConstraint:
{
char *constraint=NULL;
char *projection=NULL;
ClassAd *ad;
int terrno;
int initScan = 1;
classad::References proj;
if ( !(syscall_sock->code(constraint)) ) {
if (constraint != NULL) {
free(constraint);
constraint = NULL;
}
return -1;
}
if ( !(syscall_sock->code(projection)) ) {
if (projection != NULL) {
free(constraint);
free(projection);
projection = NULL;
}
return -1;
}
dprintf( D_SYSCALLS, " constraint = %s\n", constraint );
dprintf( D_SYSCALLS, " projection = %s\n", projection ? projection : "");
assert( syscall_sock->end_of_message() );;
// if there is a projection, convert it into a set of attribute names
if (projection) {
StringTokenIterator list(projection);
const std::string * attr;
while ((attr = list.next_string())) { proj.insert(*attr); }
}
syscall_sock->encode();
do {
errno = 0;
ad = GetNextJobByConstraint( constraint, initScan );
initScan=0; // one first time through, otherwise 0
terrno = errno;
rval = ad ? 0 : -1;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
if( rval >= 0 ) {
assert( putClassAd(syscall_sock, *ad, PUT_CLASSAD_NO_PRIVATE, proj.empty() ? NULL : &proj) );
FreeJobAd(ad);
}
} while (rval >= 0);
assert( syscall_sock->end_of_message() );;
free( (char *)constraint );
free( (char *)projection );
return 0;
}
case CONDOR_CloseSocket:
{
assert( syscall_sock->end_of_message() );;
return -1;
}
} /* End of switch */
return -1;
} /* End of function */
void WinWebAuthnManager::MaybeAbortSign(const uint64_t& aTransactionId,
const nsresult& aError) {
AbortTransaction(aTransactionId, aError);
}
