static int forced_jobpurge(
job *pjob,
struct batch_request *preq)
{
long owner_purge = FALSE;
/* check about possibly purging the job */
if (preq->rq_extend != NULL)
{
if (!strncmp(preq->rq_extend, delpurgestr, strlen(delpurgestr)))
{
get_svr_attr_l(SRV_ATR_OwnerPurge, &owner_purge);
if (((preq->rq_perm & (ATR_DFLAG_OPRD | ATR_DFLAG_OPWR | ATR_DFLAG_MGRD | ATR_DFLAG_MGWR)) != 0) ||
((svr_chk_owner(preq, pjob) == 0) && (owner_purge)))
{
force_purge_work(pjob);
return(PURGE_SUCCESS);
}
else
{
/* FAILURE */
req_reject(PBSE_PERM, 0, preq, NULL, NULL);
unlock_ji_mutex(pjob, __func__, "1", LOGLEVEL);
return(-1);
}
}
}
return(PBSE_NONE);
} /* END forced_jobpurge() */
int
svr_authorize_jobreq(struct batch_request *preq, job *pjob)
{
/* Is requestor special privileged? */
if ((preq->rq_perm & (ATR_DFLAG_OPRD | ATR_DFLAG_OPWR |
ATR_DFLAG_MGRD | ATR_DFLAG_MGWR)) != 0)
return (0);
/* if not, see if requestor is the job owner */
else if (svr_chk_owner(preq, pjob) == 0)
return (0);
else
return (-1);
}
int execute_job_delete(
job *pjob, /* M */
char *Msg, /* I */
struct batch_request *preq) /* I */
{
struct work_task *pwtnew;
int rc;
char *sigt = "SIGTERM";
int has_mutex = TRUE;
char log_buf[LOCAL_LOG_BUF_SIZE];
time_t time_now = time(NULL);
long force_cancel = FALSE;
long array_compatible = FALSE;
chk_job_req_permissions(&pjob,preq);
if (pjob == NULL)
{
/* preq is rejected in chk_job_req_permissions here */
return(-1);
}
if (pjob->ji_qs.ji_state == JOB_STATE_TRANSIT)
{
/* see note in req_delete - not sure this is possible still,
* but the deleted code is irrelevant now. I will leave this
* part --dbeer */
unlock_ji_mutex(pjob, __func__, "1", LOGLEVEL);
return(-1);
}
if (pjob->ji_qs.ji_substate == JOB_SUBSTATE_PRERUN ||
pjob->ji_qs.ji_substate == JOB_SUBSTATE_RERUN ||
pjob->ji_qs.ji_substate == JOB_SUBSTATE_RERUN1 ||
pjob->ji_qs.ji_substate == JOB_SUBSTATE_RERUN2 ||
pjob->ji_qs.ji_substate == JOB_SUBSTATE_RERUN3 )
{
/* If JOB_SUBSTATE_PRERUN being sent to MOM, wait till she gets it going */
/* retry in one second */
/* If JOB_SUBSTATE_RERUN, RERUN1, RERUN2 or RERUN3 the
job is being requeued. Wait until finished */
static time_t cycle_check_when = 0;
static char cycle_check_jid[PBS_MAXSVRJOBID + 1];
if (cycle_check_when != 0)
{
if (!strcmp(pjob->ji_qs.ji_jobid, cycle_check_jid) &&
(time_now - cycle_check_when > 10))
{
/* state not updated after 10 seconds */
/* did the mom ever get it? delete it anyways... */
cycle_check_jid[0] = '\0';
cycle_check_when = 0;
goto jump;
}
if (time_now - cycle_check_when > 20)
{
/* give up after 20 seconds */
cycle_check_jid[0] = '\0';
cycle_check_when = 0;
}
} /* END if (cycle_check_when != 0) */
if (cycle_check_when == 0)
{
/* new PRERUN job located */
cycle_check_when = time_now;
strcpy(cycle_check_jid, pjob->ji_qs.ji_jobid);
}
sprintf(log_buf, "job cannot be deleted, state=PRERUN, requeuing delete request");
log_event(PBSEVENT_JOB,PBS_EVENTCLASS_JOB,pjob->ji_qs.ji_jobid,log_buf);
pwtnew = set_task(WORK_Timed,time_now + 1,post_delete_route,preq,FALSE);
unlock_ji_mutex(pjob, __func__, "2", LOGLEVEL);
if (pwtnew == NULL)
{
req_reject(PBSE_SYSTEM, 0, preq, NULL, NULL);
return(-1);
}
else
{
return(ROUTE_DELETE);
}
} /* END if (pjob->ji_qs.ji_substate == JOB_SUBSTATE_PRERUN) */
jump:
/*
* Log delete and if requesting client is not job owner, send mail.
*/
sprintf(log_buf, "requestor=%s@%s", preq->rq_user, preq->rq_host);
/* NOTE: should annotate accounting record with extend message (NYI) */
account_record(PBS_ACCT_DEL, pjob, log_buf);
sprintf(log_buf, msg_manager, msg_deletejob, preq->rq_user, preq->rq_host);
log_event(PBSEVENT_JOB,PBS_EVENTCLASS_JOB,pjob->ji_qs.ji_jobid,log_buf);
/* NOTE: should incorporate job delete message */
if (Msg != NULL)
{
/* have text message in request extension, add it */
strcat(log_buf, "\n");
strcat(log_buf, Msg);
}
if ((svr_chk_owner(preq, pjob) != 0) &&
(pjob->ji_has_delete_nanny == FALSE))
{
/* only send email if owner did not delete job and job deleted
has not been previously attempted */
svr_mailowner(pjob, MAIL_DEL, MAIL_FORCE, log_buf);
/*
* If we sent mail and already sent the extra message
* then reset message so we don't trigger a redundant email
* in job_abt()
*/
if (Msg != NULL)
{
Msg = NULL;
}
}
if ((pjob->ji_qs.ji_svrflags & JOB_SVFLG_CHECKPOINT_FILE) != 0)
{
/* job has restart file at mom, change restart comment if failed */
change_restart_comment_if_needed(pjob);
}
if (pjob->ji_qs.ji_state == JOB_STATE_RUNNING)
{
/*
* setup a nanny task to make sure the job is actually deleted (see the
* comments at job_delete_nanny()).
*/
if (pjob->ji_has_delete_nanny == TRUE)
{
unlock_ji_mutex(pjob, __func__, "3", LOGLEVEL);
req_reject(PBSE_IVALREQ, 0, preq, NULL, "job cancel in progress");
return(-1);
}
apply_job_delete_nanny(pjob, time_now + 60);
/*
* Send signal request to MOM. The server will automagically
* pick up and "finish" off the client request when MOM replies.
*/
get_batch_request_id(preq);
if ((rc = issue_signal(&pjob, sigt, post_delete_mom1, strdup(preq->rq_id))))
{
/* cant send to MOM */
req_reject(rc, 0, preq, NULL, NULL);
}
/* normally will ack reply when mom responds */
if (pjob != NULL)
{
sprintf(log_buf, msg_delrunjobsig, sigt);
log_event(PBSEVENT_JOB,PBS_EVENTCLASS_JOB,pjob->ji_qs.ji_jobid,log_buf);
unlock_ji_mutex(pjob, __func__, "4", LOGLEVEL);
}
return(-1);
} /* END if (pjob->ji_qs.ji_state == JOB_STATE_RUNNING) */
/* make a cleanup task if set */
get_svr_attr_l(SRV_ATR_JobForceCancelTime, &force_cancel);
if (force_cancel > 0)
{
char *dup_jobid = strdup(pjob->ji_qs.ji_jobid);
set_task(WORK_Timed, time_now + force_cancel, ensure_deleted, dup_jobid, FALSE);
}
/* if configured, and this job didn't have a slot limit hold, free a job
* held with the slot limit hold */
get_svr_attr_l(SRV_ATR_MoabArrayCompatible, &array_compatible);
if ((array_compatible != FALSE) &&
((pjob->ji_wattr[JOB_ATR_hold].at_val.at_long & HOLD_l) == FALSE))
{
if ((pjob->ji_arraystruct != NULL) &&
(pjob->ji_is_array_template == FALSE))
{
int i;
int newstate;
int newsub;
job *tmp;
job_array *pa = get_jobs_array(&pjob);
if (pjob == NULL)
return(-1);
for (i = 0; i < pa->ai_qs.array_size; i++)
{
if (pa->job_ids[i] == NULL)
continue;
if (!strcmp(pa->job_ids[i], pjob->ji_qs.ji_jobid))
continue;
if ((tmp = svr_find_job(pa->job_ids[i], FALSE)) == NULL)
{
free(pa->job_ids[i]);
pa->job_ids[i] = NULL;
}
else
{
if (tmp->ji_wattr[JOB_ATR_hold].at_val.at_long & HOLD_l)
{
tmp->ji_wattr[JOB_ATR_hold].at_val.at_long &= ~HOLD_l;
if (tmp->ji_wattr[JOB_ATR_hold].at_val.at_long == 0)
{
tmp->ji_wattr[JOB_ATR_hold].at_flags &= ~ATR_VFLAG_SET;
}
svr_evaljobstate(tmp, &newstate, &newsub, 1);
svr_setjobstate(tmp, newstate, newsub, FALSE);
job_save(tmp, SAVEJOB_FULL, 0);
unlock_ji_mutex(tmp, __func__, "5", LOGLEVEL);
break;
}
unlock_ji_mutex(tmp, __func__, "6", LOGLEVEL);
}
}
if (LOGLEVEL >= 7)
{
sprintf(log_buf, "%s: unlocking ai_mutex", __func__);
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, pjob->ji_qs.ji_jobid, log_buf);
}
pthread_mutex_unlock(pa->ai_mutex);
}
} /* END MoabArrayCompatible check */
if ((pjob->ji_qs.ji_svrflags & JOB_SVFLG_CHECKPOINT_FILE) != 0)
{
/* job has restart file at mom, do end job processing */
svr_setjobstate(pjob, JOB_STATE_EXITING, JOB_SUBSTATE_EXITING, FALSE);
/* force new connection */
pjob->ji_momhandle = -1;
if (LOGLEVEL >= 7)
{
sprintf(log_buf, "calling on_job_exit from %s", __func__);
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, pjob->ji_qs.ji_jobid, log_buf);
}
set_task(WORK_Immed, 0, on_job_exit, strdup(pjob->ji_qs.ji_jobid), FALSE);
}
else if ((pjob->ji_qs.ji_svrflags & JOB_SVFLG_StagedIn) != 0)
{
/* job has staged-in file, should remove them */
remove_stagein(&pjob);
if (pjob != NULL)
job_abt(&pjob, Msg);
has_mutex = FALSE;
}
else
{
/*
* the job is not transitting (though it may have been) and
* is not running, so put in into a complete state.
*/
struct pbs_queue *pque;
int KeepSeconds = 0;
svr_setjobstate(pjob, JOB_STATE_COMPLETE, JOB_SUBSTATE_COMPLETE, FALSE);
if ((pque = get_jobs_queue(&pjob)) != NULL)
{
pque->qu_numcompleted++;
unlock_queue(pque, __func__, NULL, LOGLEVEL);
if (LOGLEVEL >= 7)
{
sprintf(log_buf, "calling on_job_exit from %s", __func__);
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, pjob->ji_qs.ji_jobid, log_buf);
}
pthread_mutex_lock(server.sv_attr_mutex);
KeepSeconds = attr_ifelse_long(
&pque->qu_attr[QE_ATR_KeepCompleted],
&server.sv_attr[SRV_ATR_KeepCompleted],
0);
pthread_mutex_unlock(server.sv_attr_mutex);
}
else
KeepSeconds = 0;
if (pjob != NULL)
{
set_task(WORK_Timed, time_now + KeepSeconds, on_job_exit, strdup(pjob->ji_qs.ji_jobid), FALSE);
}
else
has_mutex = FALSE;
} /* END else if ((pjob->ji_qs.ji_svrflags & JOB_SVFLG_CHECKPOINT_FILE) != 0) */
if (has_mutex == TRUE)
unlock_ji_mutex(pjob, __func__, "7", LOGLEVEL);
return(PBSE_NONE);
} /* END execute_job_delete() */
void
req_py_spawn(struct batch_request *preq)
{
int jt; /* job type */
job *pjob;
int rc;
char *jid = preq->rq_ind.rq_py_spawn.rq_jid;
int i, offset;
/*
** Returns job pointer for singleton job or "parent" of
** an array job.
*/
pjob = chk_job_request(jid, preq, &jt);
if (pjob == NULL)
return;
/* see if requestor is the job owner */
if (svr_chk_owner(preq, pjob) != 0) {
req_reject(PBSE_PERM, 0, preq);
return;
}
if (jt == IS_ARRAY_NO) { /* a regular job is okay */
/* the job must be running */
if ((pjob->ji_qs.ji_state != JOB_STATE_RUNNING) ||
(pjob->ji_qs.ji_substate !=
JOB_SUBSTATE_RUNNING)) {
req_reject(PBSE_BADSTATE, 0, preq);
return;
}
}
else if (jt == IS_ARRAY_Single) { /* a single subjob is okay */
offset = subjob_index_to_offset(pjob,
get_index_from_jid(jid));
if (offset == -1) {
req_reject(PBSE_UNKJOBID, 0, preq);
return;
}
i = get_subjob_state(pjob, offset);
if (i == -1) {
req_reject(PBSE_IVALREQ, 0, preq);
return;
}
if (i != JOB_STATE_RUNNING) {
req_reject(PBSE_BADSTATE, 0, preq);
return;
}
if ((pjob = pjob->ji_ajtrk->tkm_tbl[offset].trk_psubjob) == NULL) {
req_reject(PBSE_UNKJOBID, 0, preq);
return;
}
if (pjob->ji_qs.ji_substate != JOB_SUBSTATE_RUNNING) {
req_reject(PBSE_BADSTATE, 0, preq);
return;
}
} else {
reply_text(preq, PBSE_NOSUP,
"not supported for Array Jobs or multiple sub-jobs");
return;
}
/*
** Pass the request on to MOM. If this works, the function
** post_py_spawn_req will be called to handle the reply.
** If it fails, send the reply now.
*/
rc = relay_to_mom(pjob, preq, post_py_spawn_req);
if (rc)
req_reject(rc, 0, preq); /* unable to get to MOM */
}
void
req_register(struct batch_request *preq)
{
int made;
attribute *pattr;
struct depend *pdep;
struct depend_job *pdj;
job *pjob;
char *ps;
struct work_task *ptask;
int rc = 0;
int revtype;
int type;
int savetype = SAVEJOB_FULL;
/* make sure request is from a server */
if (!preq->rq_fromsvr) {
#ifdef NAS /* localmod 109 */
sprintf(log_buffer, "Dependency request not from server");
log_event(PBSEVENT_DEBUG, PBS_EVENTCLASS_JOB, LOG_INFO,
preq->rq_ind.rq_register.rq_parent, log_buffer);
#endif /* localmod 109 */
req_reject(PBSE_IVALREQ, 0, preq);
return;
}
/* find the "parent" job specified in the request */
if ((pjob = find_job(preq->rq_ind.rq_register.rq_parent)) == NULL) {
/*
* job not found... if server is initializing, it may not
* yet recovered, that is not an error.
*/
if (server.sv_attr[(int)SRV_ATR_State].at_val.at_long != SV_STATE_INIT) {
log_event(PBSEVENT_DEBUG, PBS_EVENTCLASS_JOB, LOG_INFO,
preq->rq_ind.rq_register.rq_parent,
msg_unkjobid);
req_reject(PBSE_UNKJOBID, 0, preq);
} else {
reply_ack(preq);
}
return;
}
pattr = &pjob->ji_wattr[(int)JOB_ATR_depend];
type = preq->rq_ind.rq_register.rq_dependtype;
pjob->ji_modified = 1;
/* more of the server:port fix kludge */
ps = strchr(preq->rq_ind.rq_register.rq_child, (int)'@');
if (ps != NULL) {
(void)strcpy(preq->rq_ind.rq_register.rq_svr, ps+1);
*ps = '\0';
} else {
(void)strcpy(preq->rq_ind.rq_register.rq_svr, preq->rq_host);
}
if (pjob->ji_qs.ji_state == JOB_STATE_MOVED) {
snprintf(log_buffer, sizeof(log_buffer), "Parent %s%s", msg_movejob, pjob->ji_qs.ji_destin);
log_event(PBSEVENT_DEBUG|PBSEVENT_SYSTEM|PBSEVENT_ERROR,
PBS_EVENTCLASS_REQUEST, LOG_INFO,
preq->rq_ind.rq_register.rq_child, log_buffer);
req_reject(PBSE_JOB_MOVED, 0, preq);
return;
}
switch (preq->rq_ind.rq_register.rq_op) {
/*
* Register a dependency
*/
case JOB_DEPEND_OP_REGISTER:
switch (type) {
case JOB_DEPEND_TYPE_AFTERSTART:
if (pjob->ji_qs.ji_substate >= JOB_SUBSTATE_RUNNING) {
/* job already running, setup task to send */
/* release back to child and continue with */
/* registration process */
ptask = set_task(WORK_Immed, 0, post_run_depend,
(void *)pjob);
if (ptask)
append_link(&pjob->ji_svrtask,
&ptask->wt_linkobj, ptask);
}
/* fall through to complete registration */
case JOB_DEPEND_TYPE_AFTERANY:
case JOB_DEPEND_TYPE_AFTEROK:
case JOB_DEPEND_TYPE_AFTERNOTOK:
rc = register_dep(pattr, preq, type, &made);
break;
case JOB_DEPEND_TYPE_BEFORESTART:
case JOB_DEPEND_TYPE_BEFOREANY:
case JOB_DEPEND_TYPE_BEFOREOK:
case JOB_DEPEND_TYPE_BEFORENOTOK:
/*
* Check job owner for permission, use the real
* job owner, not the sending server's name.
*/
(void)strcpy(preq->rq_user,
preq->rq_ind.rq_register.rq_owner);
if (svr_chk_owner(preq, pjob)) {
rc = PBSE_PERM; /* not same user */
} else {
/* ok owner, see if job has "on" */
pdep = find_depend(JOB_DEPEND_TYPE_ON, pattr);
if (pdep == 0) {
/* on "on", see if child already registered */
revtype = type ^ (JOB_DEPEND_TYPE_BEFORESTART -
JOB_DEPEND_TYPE_AFTERSTART);
pdep = find_depend(revtype, pattr);
if (pdep == 0) {
/* no "on" and no prior - return error */
rc = PBSE_BADDEPEND;
} else {
pdj = find_dependjob(pdep,
preq->rq_ind.rq_register.rq_child);
if (pdj) {
/* has prior register, update it */
(void)strcpy(pdj->dc_svr,
preq->rq_ind.rq_register.rq_svr);
}
}
} else if ((rc=register_dep(pattr, preq, type, &made)) == 0) {
if (made) { /* first time registered */
if (--pdep->dp_numexp <= 0)
del_depend(pdep);
}
}
}
break;
default:
#ifdef NAS /* localmod 109 */
sprintf(log_buffer, "Unknown dep. op: %d", preq->rq_ind.rq_register.rq_op);
log_event(PBSEVENT_DEBUG, PBS_EVENTCLASS_JOB, LOG_INFO,
preq->rq_ind.rq_register.rq_parent, log_buffer);
#endif /* localmod 109 */
rc = PBSE_IVALREQ;
break;
}
break;
/*
* Release a dependency so job might run
*/
case JOB_DEPEND_OP_RELEASE:
switch (type) {
case JOB_DEPEND_TYPE_BEFORESTART:
case JOB_DEPEND_TYPE_BEFOREANY:
case JOB_DEPEND_TYPE_BEFOREOK:
case JOB_DEPEND_TYPE_BEFORENOTOK:
/* predecessor sent release-reduce "on", */
/* see if this job can now run */
type ^= (JOB_DEPEND_TYPE_BEFORESTART -
JOB_DEPEND_TYPE_AFTERSTART);
if ((pdep = find_depend(type, pattr)) != NULL) {
pdj = find_dependjob(pdep,
preq->rq_ind.rq_register.rq_child);
if (pdj) {
del_depend_job(pdj);
pattr->at_flags |= ATR_VFLAG_MODIFY | ATR_VFLAG_MODCACHE;
savetype = SAVEJOB_FULLFORCE;
(void)sprintf(log_buffer, msg_registerrel,
preq->rq_ind.rq_register.rq_child);
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB,
LOG_INFO,
pjob->ji_qs.ji_jobid, log_buffer);
if (GET_NEXT(pdep->dp_jobs) == 0) {
/* no more dependencies of this type */
del_depend(pdep);
set_depend_hold(pjob, pattr);
}
break;
}
#ifdef NAS /* localmod 109 */
sprintf(log_buffer, "Dep.rls. job not found: %d/%s", type, preq->rq_ind.rq_register.rq_child);
} else {
sprintf(log_buffer, "Dep.rls. type not found: %d", type);
#endif /* localmod 109 */
}
#ifdef NAS /* localmod 109 */
log_event(PBSEVENT_DEBUG, PBS_EVENTCLASS_JOB, LOG_INFO,
preq->rq_ind.rq_register.rq_parent, log_buffer);
#endif /* localmod 109 */
rc = PBSE_IVALREQ;
break;
}
break;
case JOB_DEPEND_OP_READY:
rc = PBSE_NOSYNCMSTR;
break;
case JOB_DEPEND_OP_DELETE:
(void)sprintf(log_buffer, msg_registerdel,
preq->rq_ind.rq_register.rq_child);
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, LOG_INFO,
pjob->ji_qs.ji_jobid, log_buffer);
job_abt(pjob, log_buffer);
break;
case JOB_DEPEND_OP_UNREG:
unregister_dep(pattr, preq);
set_depend_hold(pjob, pattr);
break;
default:
sprintf(log_buffer, msg_illregister,
preq->rq_ind.rq_register.rq_parent);
log_event(PBSEVENT_DEBUG|PBSEVENT_SYSTEM|PBSEVENT_ERROR,
PBS_EVENTCLASS_REQUEST, LOG_INFO,
preq->rq_host, log_buffer);
rc = PBSE_IVALREQ;
break;;
}
if (rc) {
pjob->ji_modified = 0;
req_reject(rc, 0, preq);
} else {
/* If this is an array job, forcibly save it to ensure
* dependencies are recorded.
*/
if (pjob->ji_qs.ji_svrflags & JOB_SVFLG_ArrayJob)
savetype = SAVEJOB_FULLFORCE;
if (pjob->ji_modified)
(void)job_save(pjob, savetype);
reply_ack(preq);
}
return;
}
static int forced_jobpurge(
struct batch_request *preq)
{
job *pjob;
if ((pjob = find_job(preq->rq_ind.rq_delete.rq_objname)) == NULL)
{
log_event(
PBSEVENT_DEBUG,
PBS_EVENTCLASS_JOB,
preq->rq_ind.rq_delete.rq_objname,
pbse_to_txt(PBSE_UNKJOBID));
req_reject(PBSE_UNKJOBID, 0, preq, NULL, NULL);
return(-1);
}
/* check about possibly purging the job */
if (preq->rq_extend != NULL)
{
if (!strncmp(preq->rq_extend, delpurgestr, strlen(delpurgestr)))
{
if (((preq->rq_perm & (ATR_DFLAG_OPRD | ATR_DFLAG_OPWR | ATR_DFLAG_MGRD | ATR_DFLAG_MGWR)) != 0) ||
((svr_chk_owner(preq, pjob) == 0) && (server.sv_attr[SRV_ATR_OwnerPurge].at_val.at_long)))
{
sprintf(log_buffer, "purging job without checking MOM");
log_event(
PBSEVENT_JOB,
PBS_EVENTCLASS_JOB,
pjob->ji_qs.ji_jobid,
log_buffer);
reply_ack(preq);
free_nodes(pjob);
if (pjob->ji_qhdr->qu_qs.qu_type == QTYPE_Execution)
{
set_resc_assigned(pjob, DECR);
}
job_purge(pjob);
return(1);
}
else
{
/* FAILURE */
req_reject(PBSE_PERM, 0, preq, NULL, NULL);
return(-1);
}
}
}
return(0);
} /* END forced_jobpurge() */
void req_deletejob(
struct batch_request *preq) /* I */
{
job *pjob;
struct work_task *pwtold;
struct work_task *pwtnew;
struct work_task *pwtcheck;
int rc;
char *sigt = "SIGTERM";
char *Msg = NULL;
/* check if we are getting a purgecomplete from scheduler */
if ((preq->rq_extend != NULL) &&
!strncmp(preq->rq_extend,PURGECOMP,strlen(PURGECOMP)))
{
/*
* purge_completed_jobs will respond with either an ack or reject
*/
purge_completed_jobs(preq);
return;
}
/* The way this is implemented, if the user enters the command "qdel -p <jobid>",
* they can then delete jobs other than their own since the authorization
* checks are made below in chk_job_request. This should probably be fixed.
*/
if (forced_jobpurge(preq) != 0)
{
return;
}
/* NOTE: should support rq_objname={<JOBID>|ALL|<name:<JOBNAME>} */
/* NYI */
pjob = chk_job_request(preq->rq_ind.rq_delete.rq_objname, preq);
if (pjob == NULL)
{
/* NOTE: chk_job_request() will issue req_reject() */
return;
}
if (preq->rq_extend != NULL)
{
if (strncmp(preq->rq_extend, deldelaystr, strlen(deldelaystr)) &&
strncmp(preq->rq_extend, delasyncstr, strlen(delasyncstr)) &&
strncmp(preq->rq_extend, delpurgestr, strlen(delpurgestr)))
{
/* have text message in request extension, add it */
Msg = preq->rq_extend;
/*
* Message capability is only for operators and managers.
* Check if request is authorized
*/
if ((preq->rq_perm & (ATR_DFLAG_OPRD | ATR_DFLAG_OPWR |
ATR_DFLAG_MGRD | ATR_DFLAG_MGWR)) == 0)
{
req_reject(PBSE_PERM, 0, preq, NULL,
"must have operator or manager privilege to use -m parameter");
return;
}
}
}
if (pjob->ji_qs.ji_state == JOB_STATE_TRANSIT)
{
/*
* Find pid of router from existing work task entry,
* then establish another work task on same child.
* Next, signal the router and wait for its completion;
*/
pwtold = (struct work_task *)GET_NEXT(pjob->ji_svrtask);
while (pwtold != NULL)
{
if ((pwtold->wt_type == WORK_Deferred_Child) ||
(pwtold->wt_type == WORK_Deferred_Cmp))
{
pwtnew = set_task(
pwtold->wt_type,
pwtold->wt_event,
post_delete_route,
preq);
if (pwtnew != NULL)
{
/*
* reset type in case the SIGCHLD came
* in during the set_task; it makes
* sure that next_task() will find the
* new entry.
*/
pwtnew->wt_type = pwtold->wt_type;
pwtnew->wt_aux = pwtold->wt_aux;
kill((pid_t)pwtold->wt_event, SIGTERM);
pjob->ji_qs.ji_substate = JOB_SUBSTATE_ABORT;
return; /* all done for now */
}
else
{
req_reject(PBSE_SYSTEM, 0, preq, NULL, NULL);
return;
}
}
pwtold = (struct work_task *)GET_NEXT(pwtold->wt_linkobj);
}
/* should never get here ... */
log_err(-1, "req_delete", "Did not find work task for router");
req_reject(PBSE_INTERNAL, 0, preq, NULL, NULL);
return;
}
if (pjob->ji_qs.ji_substate == JOB_SUBSTATE_PRERUN ||
pjob->ji_qs.ji_substate == JOB_SUBSTATE_RERUN ||
pjob->ji_qs.ji_substate == JOB_SUBSTATE_RERUN1 ||
pjob->ji_qs.ji_substate == JOB_SUBSTATE_RERUN2 ||
pjob->ji_qs.ji_substate == JOB_SUBSTATE_RERUN3 )
{
/* If JOB_SUBSTATE_PRERUN being sent to MOM, wait till she gets it going */
/* retry in one second */
/* If JOB_SUBSTATE_RERUN, RERUN1, RERUN2 or RERUN3 the
job is being requeued. Wait until finished */
static time_t cycle_check_when = 0;
static char cycle_check_jid[PBS_MAXSVRJOBID + 1];
if (cycle_check_when != 0)
{
if (!strcmp(pjob->ji_qs.ji_jobid, cycle_check_jid) &&
(time_now - cycle_check_when > 10))
{
/* state not updated after 10 seconds */
/* did the mom ever get it? delete it anyways... */
cycle_check_jid[0] = '\0';
cycle_check_when = 0;
goto jump;
}
if (time_now - cycle_check_when > 20)
{
/* give up after 20 seconds */
cycle_check_jid[0] = '\0';
cycle_check_when = 0;
}
} /* END if (cycle_check_when != 0) */
if (cycle_check_when == 0)
{
/* new PRERUN job located */
cycle_check_when = time_now;
strcpy(cycle_check_jid, pjob->ji_qs.ji_jobid);
}
sprintf(log_buffer, "job cannot be deleted, state=PRERUN, requeuing delete request");
log_event(
PBSEVENT_JOB,
PBS_EVENTCLASS_JOB,
pjob->ji_qs.ji_jobid,
log_buffer);
pwtnew = set_task(
WORK_Timed,
time_now + 1,
post_delete_route,
preq);
if (pwtnew == 0)
req_reject(PBSE_SYSTEM, 0, preq, NULL, NULL);
return;
} /* END if (pjob->ji_qs.ji_substate == JOB_SUBSTATE_PRERUN) */
jump:
/*
* Log delete and if requesting client is not job owner, send mail.
*/
sprintf(log_buffer, "requestor=%s@%s",
preq->rq_user,
preq->rq_host);
/* NOTE: should annotate accounting record with extend message (NYI) */
account_record(PBS_ACCT_DEL, pjob, log_buffer);
sprintf(log_buffer, msg_manager,
msg_deletejob,
preq->rq_user,
preq->rq_host);
log_event(
PBSEVENT_JOB,
PBS_EVENTCLASS_JOB,
pjob->ji_qs.ji_jobid,
log_buffer);
/* NOTE: should incorporate job delete message */
if (Msg != NULL)
{
/* have text message in request extension, add it */
strcat(log_buffer, "\n");
strcat(log_buffer, Msg);
}
if ((svr_chk_owner(preq, pjob) != 0) &&
!has_job_delete_nanny(pjob))
{
/* only send email if owner did not delete job and job deleted
has not been previously attempted */
svr_mailowner(pjob, MAIL_DEL, MAIL_FORCE, log_buffer);
/*
* If we sent mail and already sent the extra message
* then reset message so we don't trigger a redundant email
* in job_abt()
*/
if (Msg != NULL)
{
Msg = NULL;
}
}
if ((pjob->ji_qs.ji_svrflags & JOB_SVFLG_CHECKPOINT_FILE) != 0)
{
/* job has restart file at mom, change restart comment if failed */
change_restart_comment_if_needed(pjob);
}
if (pjob->ji_qs.ji_state == JOB_STATE_RUNNING)
{
/*
* setup a nanny task to make sure the job is actually deleted (see the
* comments at job_delete_nanny()).
*/
if (has_job_delete_nanny(pjob))
{
req_reject(PBSE_IVALREQ, 0, preq, NULL, "job cancel in progress");
return;
}
apply_job_delete_nanny(pjob, time_now + 60);
/* check if we are getting a asynchronous delete */
if ((preq->rq_extend != NULL) &&
!strncmp(preq->rq_extend,DELASYNC,strlen(DELASYNC)))
{
struct batch_request *preq_tmp = NULL;
/*
* Respond with an ack now instead of after MOM processing
* Create a new batch request and fill it in. It will be freed by reply_ack
*/
snprintf(log_buffer,sizeof(log_buffer), "Deleting job asynchronously");
log_event(PBSEVENT_JOB,PBS_EVENTCLASS_JOB,pjob->ji_qs.ji_jobid,log_buffer);
preq_tmp = alloc_br(PBS_BATCH_DeleteJob);
preq_tmp->rq_perm = preq->rq_perm;
preq_tmp->rq_ind.rq_manager.rq_cmd = preq->rq_ind.rq_manager.rq_cmd;
preq_tmp->rq_ind.rq_manager.rq_objtype = preq->rq_ind.rq_manager.rq_objtype;
preq_tmp->rq_fromsvr = preq->rq_fromsvr;
preq_tmp->rq_extsz = preq->rq_extsz;
preq_tmp->rq_conn = preq->rq_conn;
memcpy(preq_tmp->rq_ind.rq_manager.rq_objname,
preq->rq_ind.rq_manager.rq_objname, PBS_MAXSVRJOBID + 1);
memcpy(preq_tmp->rq_user, preq->rq_user, PBS_MAXUSER + 1);
memcpy(preq_tmp->rq_host, preq->rq_host, PBS_MAXHOSTNAME + 1);
reply_ack(preq_tmp);
preq->rq_noreply = TRUE; /* set for no more replies */
}
/* make a cleanup task if set */
if ((server.sv_attr[SRV_ATR_JobForceCancelTime].at_flags & ATR_VFLAG_SET) &&
(server.sv_attr[SRV_ATR_JobForceCancelTime].at_val.at_long > 0))
{
pwtcheck = set_task(
WORK_Timed,
time_now + server.sv_attr[SRV_ATR_JobForceCancelTime].at_val.at_long,
ensure_deleted,
preq);
if (pwtcheck != NULL)
append_link(&pjob->ji_svrtask, &pwtcheck->wt_linkobj, pwtcheck);
}
/*
* Send signal request to MOM. The server will automagically
* pick up and "finish" off the client request when MOM replies.
*/
if ((rc = issue_signal(pjob, sigt, post_delete_mom1, preq)))
{
/* cant send to MOM */
req_reject(rc, 0, preq, NULL, NULL);
}
/* normally will ack reply when mom responds */
sprintf(log_buffer, msg_delrunjobsig,
sigt);
LOG_EVENT(
PBSEVENT_JOB,
PBS_EVENTCLASS_JOB,
pjob->ji_qs.ji_jobid,
log_buffer);
return;
} /* END if (pjob->ji_qs.ji_state == JOB_STATE_RUNNING) */
/* make a cleanup task if set */
if ((server.sv_attr[SRV_ATR_JobForceCancelTime].at_flags & ATR_VFLAG_SET) &&
(server.sv_attr[SRV_ATR_JobForceCancelTime].at_val.at_long > 0))
{
pwtcheck = set_task(
WORK_Timed,
time_now + server.sv_attr[SRV_ATR_JobForceCancelTime].at_val.at_long,
ensure_deleted,
preq);
if (pwtcheck != NULL)
append_link(&pjob->ji_svrtask, &pwtcheck->wt_linkobj, pwtcheck);
}
/* if configured, and this job didn't have a slot limit hold, free a job
* held with the slot limit hold */
if ((server.sv_attr[SRV_ATR_MoabArrayCompatible].at_val.at_long != FALSE) &&
((pjob->ji_wattr[JOB_ATR_hold].at_val.at_long & HOLD_l) == FALSE))
{
if ((pjob->ji_arraystruct != NULL) &&
(pjob->ji_is_array_template == FALSE))
{
int i;
int newstate;
int newsub;
job *tmp;
job_array *pa = pjob->ji_arraystruct;
for (i = 0; i < pa->ai_qs.array_size; i++)
{
if (pa->jobs[i] == NULL)
continue;
tmp = (job *)pa->jobs[i];
if (tmp->ji_wattr[JOB_ATR_hold].at_val.at_long & HOLD_l)
{
tmp->ji_wattr[JOB_ATR_hold].at_val.at_long &= ~HOLD_l;
if (tmp->ji_wattr[JOB_ATR_hold].at_val.at_long == 0)
{
tmp->ji_wattr[JOB_ATR_hold].at_flags &= ~ATR_VFLAG_SET;
}
svr_evaljobstate(tmp, &newstate, &newsub, 1);
svr_setjobstate(tmp, newstate, newsub);
job_save(tmp, SAVEJOB_FULL, 0);
break;
}
}
}
} /* END MoabArrayCompatible check */
if ((pjob->ji_qs.ji_svrflags & JOB_SVFLG_CHECKPOINT_FILE) != 0)
{
/* job has restart file at mom, do end job processing */
svr_setjobstate(pjob, JOB_STATE_EXITING, JOB_SUBSTATE_EXITING);
pjob->ji_momhandle = -1;
/* force new connection */
pwtnew = set_task(WORK_Immed, 0, on_job_exit, (void *)pjob);
if (pwtnew)
{
append_link(&pjob->ji_svrtask, &pwtnew->wt_linkobj, pwtnew);
}
}
else if ((pjob->ji_qs.ji_svrflags & JOB_SVFLG_StagedIn) != 0)
{
/* job has staged-in file, should remove them */
remove_stagein(pjob);
job_abt(&pjob, Msg);
}
else
{
/*
* the job is not transitting (though it may have been) and
* is not running, so put in into a complete state.
*/
struct work_task *ptask;
struct pbs_queue *pque;
int KeepSeconds = 0;
svr_setjobstate(pjob, JOB_STATE_COMPLETE, JOB_SUBSTATE_COMPLETE);
if ((pque = pjob->ji_qhdr) && (pque != NULL))
{
pque->qu_numcompleted++;
}
KeepSeconds = attr_ifelse_long(
&pque->qu_attr[QE_ATR_KeepCompleted],
&server.sv_attr[SRV_ATR_KeepCompleted],
0);
ptask = set_task(WORK_Timed, time_now + KeepSeconds, on_job_exit, pjob);
if (ptask != NULL)
{
append_link(&pjob->ji_svrtask, &ptask->wt_linkobj, ptask);
}
} /* END else if ((pjob->ji_qs.ji_svrflags & JOB_SVFLG_CHECKPOINT_FILE) != 0) */
reply_ack(preq);
return;
} /* END req_deletejob() */