void reply_free(
struct batch_reply *prep)
{
struct brp_status *pstat;
struct brp_status *pstatx;
struct brp_select *psel;
struct brp_select *pselx;
if (prep->brp_choice == BATCH_REPLY_CHOICE_Text)
{
if (prep->brp_un.brp_txt.brp_str)
{
(void)free(prep->brp_un.brp_txt.brp_str);
prep->brp_un.brp_txt.brp_str = NULL;
prep->brp_un.brp_txt.brp_txtlen = 0;
}
}
else if (prep->brp_choice == BATCH_REPLY_CHOICE_Select)
{
psel = prep->brp_un.brp_select;
while (psel)
{
pselx = psel->brp_next;
(void)free(psel);
psel = pselx;
}
}
else if (prep->brp_choice == BATCH_REPLY_CHOICE_Status)
{
pstat = (struct brp_status *)GET_NEXT(prep->brp_un.brp_status);
while (pstat)
{
pstatx = (struct brp_status *)GET_NEXT(pstat->brp_stlink);
free_attrlist(&pstat->brp_attr);
(void)free(pstat);
pstat = pstatx;
}
}
else if (prep->brp_choice == BATCH_REPLY_CHOICE_RescQuery)
{
(void)free(prep->brp_un.brp_rescq.brq_avail);
(void)free(prep->brp_un.brp_rescq.brq_alloc);
(void)free(prep->brp_un.brp_rescq.brq_resvd);
(void)free(prep->brp_un.brp_rescq.brq_down);
}
prep->brp_choice = BATCH_REPLY_CHOICE_NULL;
return;
} /* END reply_free() */
static void freebr_manage(
struct rq_manage *pmgr)
{
free_attrlist(&pmgr->rq_attr);
return;
} /* END freebr_manage() */
END_TEST
START_TEST(test_two)
{
svrattrl *attrl = attrlist_create("Fred","Wilma",20);
svrattrl *attrl2 = attrlist_create("Barney","Betty",20);
fail_unless(strcmp(attrl->al_name,"Fred") == 0);
fail_unless(strcmp(attrl->al_resc,"Wilma") == 0);
fail_unless(attrl->al_nameln == 5);
fail_unless(attrl->al_rescln == 6);
fail_unless(!is_link_initialized((list_link *)attrl));
append_link((tlist_head *)attrl,(list_link *)attrl2,(void *)attrl2);
fail_unless(is_link_initialized((list_link *)attrl));
attrl2->al_atopl.op = UNSET;
attrl_fixlink((tlist_head *)attrl);
fail_unless(attrl2->al_atopl.op == SET);
free_attrlist((tlist_head *)attrl);
}
static char *resc_to_string(
job *pjob, /* I (optional - if specified, report total job resources) */
int aindex, /* I which pbs_attribute to convert */
char *buf, /* O the buffer into which to convert */
int buflen) /* I the length of the above buffer */
{
int need;
svrattrl *patlist;
tlist_head svlist;
pbs_attribute *pattr;
int isfirst = 1;
CLEAR_HEAD(svlist);
*buf = '\0';
pattr = &pjob->ji_wattr[aindex];
/* pack the list of resources into svlist */
if (aindex == JOB_ATR_resource)
{
if (encode_resc(pattr, &svlist, (char *)"x", NULL, ATR_ENCODE_CLIENT, ATR_DFLAG_ACCESS) <= 0)
{
return(buf);
}
}
else if (aindex == JOB_ATR_resc_used)
{
encode_used(pjob, ATR_DFLAG_RDACC, &svlist);
}
else
{
return(buf);
}
/* unpack svlist into a comma-delimited string */
patlist = (svrattrl *)GET_NEXT(svlist);
while (patlist != NULL)
{
need = strlen(patlist->al_resc) + strlen(patlist->al_value) + 3;
if (need >= buflen)
{
patlist = (svrattrl *)GET_NEXT(patlist->al_link);
continue;
}
if (LOGLEVEL >= 7)
{
fprintf(stderr, "Epilog: %s=%s\n",
patlist->al_resc,
patlist->al_value);
}
if (isfirst == 1)
{
isfirst = 0;
}
else
{
strcat(buf, ",");
buflen--;
}
strcat(buf, patlist->al_resc);
strcat(buf, "=");
strcat(buf, patlist->al_value);
buflen -= need;
patlist = (svrattrl *)GET_NEXT(patlist->al_link);
} /* END while (patlist != NULL) */
free_attrlist(&svlist);
return(buf);
} /* END resc_to_string() */
/**
* @brief
* it is a wrapper function of free_attrlist()
*
* @param[in] pmgr - request manage structure.
*/
static void
freebr_manage(struct rq_manage *pmgr)
{
free_attrlist(&pmgr->rq_attr);
}
void
free_br(struct batch_request *preq)
{
delete_link(&preq->rq_link);
reply_free(&preq->rq_reply);
if (preq->rq_parentbr) {
/*
* have a parent who has the original info, so we cannot
* free any data malloc-ed outside of the basic structure;
* decrement the reference count in the parent and when it
* goes to zero, reply_send() it
*/
if (preq->rq_parentbr->rq_refct > 0) {
if (--preq->rq_parentbr->rq_refct == 0)
reply_send(preq->rq_parentbr);
}
if (preq->rppcmd_msgid)
free(preq->rppcmd_msgid);
(void)free(preq);
return;
}
/*
* IMPORTANT - free any data that is malloc-ed outside of the
* basic batch_request structure below here so it is not freed
* when a copy of the structure (for a Array subjob) is freed
*/
if (preq->rq_extend)
(void)free(preq->rq_extend);
switch (preq->rq_type) {
case PBS_BATCH_QueueJob:
free_attrlist(&preq->rq_ind.rq_queuejob.rq_attr);
break;
case PBS_BATCH_JobCred:
if (preq->rq_ind.rq_jobcred.rq_data)
(void)free(preq->rq_ind.rq_jobcred.rq_data);
break;
case PBS_BATCH_UserCred:
if (preq->rq_ind.rq_usercred.rq_data)
(void)free(preq->rq_ind.rq_usercred.rq_data);
break;
case PBS_BATCH_GSS_Context:
if (preq->rq_ind.rq_gssdata.rq_data)
free(preq->rq_ind.rq_gssdata.rq_data);
break;
case PBS_BATCH_jobscript:
if (preq->rq_ind.rq_jobfile.rq_data)
(void)free(preq->rq_ind.rq_jobfile.rq_data);
break;
case PBS_BATCH_CopyHookFile:
if (preq->rq_ind.rq_hookfile.rq_data)
(void)free(preq->rq_ind.rq_hookfile.rq_data);
break;
case PBS_BATCH_HoldJob:
freebr_manage(&preq->rq_ind.rq_hold.rq_orig);
break;
case PBS_BATCH_MessJob:
if (preq->rq_ind.rq_message.rq_text)
(void)free(preq->rq_ind.rq_message.rq_text);
break;
case PBS_BATCH_RelnodesJob:
if (preq->rq_ind.rq_relnodes.rq_node_list)
(void)free(preq->rq_ind.rq_relnodes.rq_node_list);
break;
case PBS_BATCH_PySpawn:
arrayfree(preq->rq_ind.rq_py_spawn.rq_argv);
arrayfree(preq->rq_ind.rq_py_spawn.rq_envp);
break;
case PBS_BATCH_ModifyJob:
case PBS_BATCH_ModifyResv:
freebr_manage(&preq->rq_ind.rq_modify);
break;
case PBS_BATCH_RunJob:
case PBS_BATCH_AsyrunJob:
case PBS_BATCH_StageIn:
case PBS_BATCH_ConfirmResv:
if (preq->rq_ind.rq_run.rq_destin)
(void)free(preq->rq_ind.rq_run.rq_destin);
break;
case PBS_BATCH_StatusJob:
case PBS_BATCH_StatusQue:
case PBS_BATCH_StatusNode:
case PBS_BATCH_StatusSvr:
case PBS_BATCH_StatusSched:
case PBS_BATCH_StatusHook:
case PBS_BATCH_StatusRsc:
case PBS_BATCH_StatusResv:
if (preq->rq_ind.rq_status.rq_id)
free(preq->rq_ind.rq_status.rq_id);
free_attrlist(&preq->rq_ind.rq_status.rq_attr);
break;
case PBS_BATCH_CopyFiles:
case PBS_BATCH_DelFiles:
freebr_cpyfile(&preq->rq_ind.rq_cpyfile);
break;
case PBS_BATCH_CopyFiles_Cred:
case PBS_BATCH_DelFiles_Cred:
freebr_cpyfile_cred(&preq->rq_ind.rq_cpyfile_cred);
break;
case PBS_BATCH_MvJobFile:
if (preq->rq_ind.rq_jobfile.rq_data)
free(preq->rq_ind.rq_jobfile.rq_data);
break;
#ifndef PBS_MOM /* Server Only */
case PBS_BATCH_SubmitResv:
free_attrlist(&preq->rq_ind.rq_queuejob.rq_attr);
break;
case PBS_BATCH_Manager:
freebr_manage(&preq->rq_ind.rq_manager);
break;
case PBS_BATCH_ReleaseJob:
freebr_manage(&preq->rq_ind.rq_release);
break;
case PBS_BATCH_Rescq:
case PBS_BATCH_ReserveResc:
case PBS_BATCH_ReleaseResc:
free_rescrq(&preq->rq_ind.rq_rescq);
break;
case PBS_BATCH_DefSchReply:
free(preq->rq_ind.rq_defrpy.rq_id);
free(preq->rq_ind.rq_defrpy.rq_txt);
break;
case PBS_BATCH_SelectJobs:
case PBS_BATCH_SelStat:
free_attrlist(&preq->rq_ind.rq_select.rq_selattr);
free_attrlist(&preq->rq_ind.rq_select.rq_rtnattr);
break;
#endif /* PBS_MOM */
}
if (preq->rppcmd_msgid)
free(preq->rppcmd_msgid);
(void)free(preq);
}
/**
* @brief
* create_subjob - create a Subjob from the parent Array Job
* Certain attributes are changed or left out
* @param[in] parent - pointer to parent Job
* @param[in] newjid - new job id
* @param[in] rc - return code
* @return pointer to new job
* @retval NULL - error
*/
job *
create_subjob(job *parent, char *newjid, int *rc)
{
pbs_list_head attrl;
int i;
int j;
int indx;
char *index;
attribute_def *pdef;
attribute *ppar;
attribute *psub;
svrattrl *psatl;
job *subj;
long eligibletime;
long time_msec;
#ifdef WIN32
struct _timeb tval;
#else
struct timeval tval;
#endif
if ((parent->ji_qs.ji_svrflags & JOB_SVFLG_ArrayJob) == 0) {
*rc = PBSE_IVALREQ;
return NULL; /* parent not an array job */
}
/* find and copy the index */
if ((index = get_index_from_jid(newjid)) == NULL) {
*rc = PBSE_IVALREQ;
return NULL;
}
if ((indx = subjob_index_to_offset(parent, index)) == -1) {
*rc = PBSE_UNKJOBID;
return NULL;
}
if (parent->ji_ajtrk->tkm_tbl[indx].trk_status != JOB_STATE_QUEUED) {
*rc = PBSE_BADSTATE;
return NULL;
}
/*
* allocate and clear basic structure
* cannot copy job attributes because cannot share strings and other
* malloc-ed data, so copy ji_qs as a whole and then copy the
* non-saved items before ji_qs.
*/
subj = job_alloc();
subj->ji_qs = parent->ji_qs; /* copy the fixed save area */
#ifdef PBS_CRED_GRIDPROXY
subj->ji_gsscontext = parent->ji_gsscontext;
#endif
subj->ji_qhdr = parent->ji_qhdr;
subj->ji_resvp = parent->ji_resvp;
subj->ji_myResv = parent->ji_myResv;
subj->ji_parentaj = parent;
strcpy(subj->ji_qs.ji_jobid, newjid); /* replace job id */
*subj->ji_qs.ji_fileprefix = '\0';
subj->ji_subjindx = indx;
/*
* now that is all done, copy the required attributes by
* encoding and then decoding into the new array. Then add the
* subjob specific attributes.
*/
resc_access_perm = ATR_DFLAG_ACCESS;
CLEAR_HEAD(attrl);
for (i = 0; attrs_to_copy[i] != JOB_ATR_LAST; i++) {
j = (int)attrs_to_copy[i];
ppar = &parent->ji_wattr[j];
psub = &subj->ji_wattr[j];
pdef = &job_attr_def[j];
if (pdef->at_encode(ppar, &attrl, pdef->at_name, NULL,
ATR_ENCODE_MOM, &psatl) > 0) {
for (psatl = (svrattrl *)GET_NEXT(attrl); psatl;
psatl = ((svrattrl *)GET_NEXT(psatl->al_link))) {
pdef->at_decode(psub, psatl->al_name, psatl->al_resc,
psatl->al_value);
}
/* carry forward the default bit if set */
psub->at_flags |= (ppar->at_flags & ATR_VFLAG_DEFLT);
free_attrlist(&attrl);
}
}
psub = &subj->ji_wattr[(int)JOB_ATR_array_id];
job_attr_def[(int)JOB_ATR_array_id].at_decode(psub, NULL, NULL,
parent->ji_qs.ji_jobid);
psub = &subj->ji_wattr[(int)JOB_ATR_array_index];
job_attr_def[(int)JOB_ATR_array_index].at_decode(psub, NULL, NULL, index);
/* Lastly, set or clear a few flags and link in the structure */
subj->ji_qs.ji_svrflags &= ~JOB_SVFLG_ArrayJob;
subj->ji_qs.ji_svrflags |= JOB_SVFLG_SubJob;
subj->ji_modified = 1; /* ** will likely take this out ** */
subj->ji_qs.ji_substate = JOB_SUBSTATE_TRANSICM;
(void)svr_setjobstate(subj, JOB_STATE_QUEUED, JOB_SUBSTATE_QUEUED);
subj->ji_wattr[(int)JOB_ATR_state].at_flags |= ATR_VFLAG_SET;
subj->ji_wattr[(int)JOB_ATR_substate].at_flags |= ATR_VFLAG_SET;
/* subjob needs to borrow eligible time from parent job array.
* expecting only to accrue eligible_time and nothing else.
*/
if (server.sv_attr[(int)SRV_ATR_EligibleTimeEnable].at_val.at_long == 1) {
eligibletime = parent->ji_wattr[(int)JOB_ATR_eligible_time].at_val.at_long;
if (parent->ji_wattr[(int)JOB_ATR_accrue_type].at_val.at_long == JOB_ELIGIBLE)
eligibletime += subj->ji_wattr[(int)JOB_ATR_sample_starttime].at_val.at_long - parent->ji_wattr[(int)JOB_ATR_sample_starttime].at_val.at_long;
subj->ji_wattr[(int)JOB_ATR_eligible_time].at_val.at_long = eligibletime;
subj->ji_wattr[(int)JOB_ATR_eligible_time].at_flags |= ATR_VFLAG_MODIFY | ATR_VFLAG_MODCACHE;
}
#ifdef WIN32
_ftime_s(&tval);
time_msec = (tval.time * 1000L) + tval.millitm;
#else
gettimeofday(&tval, NULL);
time_msec = (tval.tv_sec * 1000L) + (tval.tv_usec/1000L);
#endif
/* set the queue rank attribute */
subj->ji_wattr[(int)JOB_ATR_qrank].at_val.at_long = time_msec;
subj->ji_wattr[(int)JOB_ATR_qrank].at_flags |= ATR_VFLAG_SET|ATR_VFLAG_MODCACHE;
if (svr_enquejob(subj) != 0) {
job_purge(subj);
*rc = PBSE_IVALREQ;
return NULL;
}
*rc = PBSE_NONE;
return subj;
}
void free_br(
struct batch_request *preq)
{
if (preq->rq_id != NULL)
{
remove_batch_request(preq->rq_id);
free(preq->rq_id);
preq->rq_id = NULL;
}
reply_free(&preq->rq_reply);
if (preq->rq_extend)
{
free(preq->rq_extend);
preq->rq_extend = NULL;
}
switch (preq->rq_type)
{
case PBS_BATCH_QueueJob:
free_attrlist(&preq->rq_ind.rq_queuejob.rq_attr);
break;
case PBS_BATCH_JobCred:
if (preq->rq_ind.rq_jobcred.rq_data)
{
free(preq->rq_ind.rq_jobcred.rq_data);
preq->rq_ind.rq_jobcred.rq_data = NULL;
}
break;
case PBS_BATCH_MvJobFile:
case PBS_BATCH_jobscript:
if (preq->rq_ind.rq_jobfile.rq_data)
{
free(preq->rq_ind.rq_jobfile.rq_data);
preq->rq_ind.rq_jobfile.rq_data = NULL;
}
break;
case PBS_BATCH_HoldJob:
freebr_manage(&preq->rq_ind.rq_hold.rq_orig);
break;
case PBS_BATCH_CheckpointJob:
freebr_manage(&preq->rq_ind.rq_manager);
break;
case PBS_BATCH_MessJob:
if (preq->rq_ind.rq_message.rq_text)
{
free(preq->rq_ind.rq_message.rq_text);
preq->rq_ind.rq_message.rq_text = NULL;
}
break;
case PBS_BATCH_ModifyJob:
case PBS_BATCH_AsyModifyJob:
freebr_manage(&preq->rq_ind.rq_modify);
break;
case PBS_BATCH_StatusJob:
case PBS_BATCH_StatusQue:
case PBS_BATCH_StatusNode:
case PBS_BATCH_StatusSvr:
/* DIAGTODO: handle PBS_BATCH_StatusDiag */
free_attrlist(&preq->rq_ind.rq_status.rq_attr);
break;
case PBS_BATCH_JobObit:
free_attrlist(&preq->rq_ind.rq_jobobit.rq_attr);
break;
case PBS_BATCH_CopyFiles:
case PBS_BATCH_DelFiles:
freebr_cpyfile(&preq->rq_ind.rq_cpyfile);
break;
case PBS_BATCH_Manager:
freebr_manage(&preq->rq_ind.rq_manager);
break;
case PBS_BATCH_ReleaseJob:
freebr_manage(&preq->rq_ind.rq_release);
break;
case PBS_BATCH_Rescq:
free_rescrq(&preq->rq_ind.rq_rescq);
break;
case PBS_BATCH_SelectJobs:
case PBS_BATCH_SelStat:
free_attrlist(&preq->rq_ind.rq_select);
break;
case PBS_BATCH_RunJob:
case PBS_BATCH_AsyrunJob:
if (preq->rq_ind.rq_run.rq_destin)
{
free(preq->rq_ind.rq_run.rq_destin);
preq->rq_ind.rq_run.rq_destin = NULL;
}
break;
default:
/* NO-OP */
break;
} /* END switch (preq->rq_type) */
free(preq);
return;
} /* END free_br() */
void free_br(
struct batch_request *preq)
{
delete_link(&preq->rq_link);
reply_free(&preq->rq_reply);
if (preq->rq_extend)
free(preq->rq_extend);
switch (preq->rq_type)
{
case PBS_BATCH_QueueJob:
free_attrlist(&preq->rq_ind.rq_queuejob.rq_attr);
break;
case PBS_BATCH_JobCred:
if (preq->rq_ind.rq_jobcred.rq_data)
free(preq->rq_ind.rq_jobcred.rq_data);
break;
case PBS_BATCH_MvJobFile:
case PBS_BATCH_jobscript:
if (preq->rq_ind.rq_jobfile.rq_data)
free(preq->rq_ind.rq_jobfile.rq_data);
break;
case PBS_BATCH_HoldJob:
freebr_manage(&preq->rq_ind.rq_hold.rq_orig);
break;
case PBS_BATCH_CheckpointJob:
freebr_manage(&preq->rq_ind.rq_manager);
break;
case PBS_BATCH_MessJob:
if (preq->rq_ind.rq_message.rq_text)
free(preq->rq_ind.rq_message.rq_text);
break;
case PBS_BATCH_ModifyJob:
case PBS_BATCH_AsyModifyJob:
freebr_manage(&preq->rq_ind.rq_modify);
break;
case PBS_BATCH_StatusJob:
case PBS_BATCH_StatusQue:
case PBS_BATCH_StatusNode:
case PBS_BATCH_StatusSvr:
/* DIAGTODO: handle PBS_BATCH_StatusDiag */
free_attrlist(&preq->rq_ind.rq_status.rq_attr);
break;
case PBS_BATCH_JobObit:
free_attrlist(&preq->rq_ind.rq_jobobit.rq_attr);
break;
case PBS_BATCH_CopyFiles:
case PBS_BATCH_DelFiles:
freebr_cpyfile(&preq->rq_ind.rq_cpyfile);
break;
#ifndef PBS_MOM /* Server Only */
case PBS_BATCH_Manager:
freebr_manage(&preq->rq_ind.rq_manager);
break;
case PBS_BATCH_ReleaseJob:
freebr_manage(&preq->rq_ind.rq_release);
break;
case PBS_BATCH_Rescq:
free_rescrq(&preq->rq_ind.rq_rescq);
break;
case PBS_BATCH_SelectJobs:
case PBS_BATCH_SelStat:
free_attrlist(&preq->rq_ind.rq_select);
break;
case PBS_BATCH_RunJob:
case PBS_BATCH_AsyrunJob:
if (preq->rq_ind.rq_run.rq_destin)
free(preq->rq_ind.rq_run.rq_destin);
break;
#endif /* !PBS_MOM */
default:
/* NO-OP */
break;
} /* END switch (preq->rq_type) */
free(preq);
return;
} /* END free_br() */
/**
* @brief
* Send execution job on connected rpp stream.
*
* @param[in] jobp - pointer to the job being sent
* @param[in] hostaddr - the address of host to send job to, host byte order
* @param[in] port - the destination port, host byte order
* @param[in] request - The batch request associated with this send job call
*
* @return int
* @retval 2 : success
* @retval -1 : failure (pbs_errno set to error number)
*
*/
int
send_job_exec(job *jobp, pbs_net_t hostaddr, int port, struct batch_request *request)
{
pbs_list_head attrl;
attribute *pattr;
mominfo_t *pmom = NULL;
int stream = -1;
int encode_type;
char *destin = jobp->ji_qs.ji_destin;
int i;
size_t credlen = 0;
char *credbuf = NULL;
char job_id[PBS_MAXSVRJOBID + 1];
struct attropl *pqjatr; /* list (single) of attropl for quejob */
int rc;
int rpp = 1;
char *jobid = NULL;
char *script = NULL;
char *msgid = NULL;
char *dup_msgid = NULL;
struct work_task *ptask = NULL;
/* if job has a script read it from database */
if (jobp->ji_qs.ji_svrflags & JOB_SVFLG_SCRIPT) {
/*
* copy the job script from database to a temp file
* PBSD_jscript works with a file
* delete it at the end of the send
*/
if ((script = svr_load_jobscript(jobp)) == NULL) {
pbs_errno = PBSE_SYSTEM;
snprintf(log_buffer, sizeof(log_buffer),
"Failed to load job script for job %s",
jobp->ji_qs.ji_jobid);
log_err(pbs_errno, "send_job", log_buffer);
goto send_err;
}
}
stream = svr_connect(hostaddr, port, NULL, ToServerDIS, rpp);
if (stream < 0) {
log_event(PBSEVENT_ERROR, PBS_EVENTCLASS_REQUEST, LOG_WARNING, "", "Could not connect to Mom");
goto send_err;
}
pmom = tfind2((unsigned long) jobp->ji_qs.ji_un.ji_exect.ji_momaddr,
jobp->ji_qs.ji_un.ji_exect.ji_momport,
&ipaddrs);
if (!pmom || (((mom_svrinfo_t *)(pmom->mi_data))->msr_state & INUSE_DOWN))
goto send_err;
CLEAR_HEAD(attrl);
resc_access_perm = ATR_DFLAG_MOM;
encode_type = ATR_ENCODE_MOM;
pattr = jobp->ji_wattr;
for (i = 0; i < (int) JOB_ATR_LAST; i++) {
if ((job_attr_def + i)->at_flags & resc_access_perm) {
(void)(job_attr_def + i)->at_encode(pattr + i, &attrl,
(job_attr_def + i)->at_name, (char *) 0, encode_type,
NULL);
}
}
attrl_fixlink(&attrl);
/* save the job id for when after we purge the job */
/* read any credential file */
(void)get_credential(pmom->mi_host, jobp, PBS_GC_BATREQ, &credbuf, &credlen);
(void) strcpy(job_id, jobp->ji_qs.ji_jobid);
pbs_errno = 0;
pqjatr = &((svrattrl *) GET_NEXT(attrl))->al_atopl;
jobid = PBSD_queuejob(stream, jobp->ji_qs.ji_jobid, destin, pqjatr, (char *) 0, rpp, &msgid);
free_attrlist(&attrl);
if (jobid == NULL)
goto send_err;
rpp_add_close_func(stream, process_DreplyRPP); /* register a close handler */
/* adding msgid to deferred list, dont free msgid */
if ((ptask = add_mom_deferred_list(stream, pmom, post_sendmom, msgid, request, jobp)) == NULL)
goto send_err;
/* add to pjob->svrtask list so its automatically cleared when job is purged */
append_link(&jobp->ji_svrtask, &ptask->wt_linkobj, ptask);
/* we cannot use the same msgid, since it is not part of the preq,
* make a dup of it, and we can freely free it
*/
if ((dup_msgid = strdup(msgid)) == NULL)
goto send_err;
/*
* henceforth use the same msgid, since we mean to say all this is
* part of a single logical request to the mom
* and we will be hanging off one request to be answered to finally
*/
if (jobp->ji_qs.ji_svrflags & JOB_SVFLG_SCRIPT) {
if (PBSD_jscript_direct(stream, script, rpp, &dup_msgid) != 0)
goto send_err;
}
free(script);
script = NULL;
if (credlen > 0) {
rc = PBSD_jcred(stream, jobp->ji_extended.ji_ext.ji_credtype, credbuf, credlen, rpp, &dup_msgid);
if (credbuf)
free(credbuf);
if (rc != 0)
goto send_err;
}
if ((jobp->ji_qs.ji_svrflags & JOB_SVFLG_HASRUN)
&& (hostaddr != pbs_server_addr)) {
if ((move_job_file(stream, jobp, StdOut, rpp, &dup_msgid) != 0) ||
(move_job_file(stream, jobp, StdErr, rpp, &dup_msgid) != 0) ||
(move_job_file(stream, jobp, Chkpt, rpp, &dup_msgid) != 0))
goto send_err;
}
if (PBSD_commit(stream, job_id, rpp, &dup_msgid) != 0)
goto send_err;
free(dup_msgid); /* free this as it is not part of any work task */
return 2;
send_err:
if (dup_msgid)
free(dup_msgid);
if (script)
free(script);
if (ptask) {
if (ptask->wt_event2)
free(ptask->wt_event2);
delete_task(ptask);
}
sprintf(log_buffer, "send of job to %s failed error = %d", destin, pbs_errno);
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, LOG_INFO, jobp->ji_qs.ji_jobid, log_buffer);
return (-1);
}
void free_br(
batch_request *preq)
{
if (preq == NULL)
return;
delete_link(&preq->rq_link);
reply_free(&preq->rq_reply);
if (preq->rq_extend)
free(preq->rq_extend);
switch (preq->rq_type)
{
case PBS_BATCH_QueueJob:
free_attrlist(&preq->rq_ind.rq_queuejob.rq_attr);
break;
case PBS_BATCH_JobCred:
if (preq->rq_ind.rq_jobcred.rq_data)
free(preq->rq_ind.rq_jobcred.rq_data);
break;
case PBS_BATCH_MvJobFile:
case PBS_BATCH_jobscript:
if (preq->rq_ind.rq_jobfile.rq_data)
free(preq->rq_ind.rq_jobfile.rq_data);
break;
case PBS_BATCH_HoldJob:
freebr_manage(&preq->rq_ind.rq_hold.rq_orig);
break;
case PBS_BATCH_CheckpointJob:
freebr_manage(&preq->rq_ind.rq_manager);
break;
case PBS_BATCH_MessJob:
if (preq->rq_ind.rq_message.rq_text)
free(preq->rq_ind.rq_message.rq_text);
break;
case PBS_BATCH_ModifyJob:
case PBS_BATCH_AsyModifyJob:
freebr_manage(&preq->rq_ind.rq_modify);
break;
case PBS_BATCH_StatusJob:
case PBS_BATCH_StatusQue:
case PBS_BATCH_StatusNode:
case PBS_BATCH_StatusSvr:
/* DIAGTODO: handle PBS_BATCH_StatusDiag */
free_attrlist(&preq->rq_ind.rq_status.rq_attr);
break;
case PBS_BATCH_JobObit:
free_attrlist(&preq->rq_ind.rq_jobobit.rq_attr);
break;
case PBS_BATCH_CopyFiles:
case PBS_BATCH_DelFiles:
freebr_cpyfile(&preq->rq_ind.rq_cpyfile);
break;
default:
/* NO-OP */
break;
} /* END switch (preq->rq_type) */
free(preq);
return;
} /* END free_br() */
