END_TEST
START_TEST(send_job_over_network_test)
{
bool timeout = false;
char *jobid = strdup("1.napali");
char *destin = strdup("bob");
bool attempt_to_queue = true;
bool c = true;
tlist_head h;
int my_err;
int mom_err;
CLEAR_HEAD(h);
fail_unless(send_job_over_network(strdup("2.napali"), 5, destin, h, attempt_to_queue, c, timeout, "script", true, false, 10, strdup("/out"), strdup("/err"), strdup("/chkpt"), MOVE_TYPE_Exec, &my_err,&mom_err) == LOCUTION_FAIL);
CLEAR_HEAD(h);
fail_unless(send_job_over_network(jobid, 5, destin, h, attempt_to_queue, c, timeout, "script", true, false, 10, strdup("/out"), strdup("/err"), strdup("/chkpt"), MOVE_TYPE_Exec, &my_err,&mom_err) == PBSE_NONE);
fail_unless(attempt_to_queue == false);
fprintf(stderr,"%p %s\n",(void *)destin,destin);
CLEAR_HEAD(h);
rdycommit_fail = true;
fail_unless(send_job_over_network(jobid, 5, destin, h, attempt_to_queue, c, timeout, "script", true, false, 10, strdup("/out"), strdup("/err"), strdup("/chkpt"), MOVE_TYPE_Exec, &my_err,&mom_err) == LOCUTION_RETRY);
rdycommit_fail = false;
}
END_TEST
START_TEST(add_node_attribute_to_list_test)
{
char line[1024];
char *ptr;
tlist_head th;
int ret;
svrattrl *sattr;
CLEAR_HEAD(th);
// this should work and create the attribute np with the value of 100
snprintf(line, sizeof(line), "100");
ptr = line;
ret = add_node_attribute_to_list(strdup("np"), &ptr, &th, 1);
fail_unless(ret == PBSE_NONE);
sattr = (svrattrl *)GET_NEXT(th);
fail_unless(strcmp(sattr->al_name, "np") == 0);
fail_unless(strcmp(sattr->al_value, "100") == 0);
attrlist_free();
attrname.clear();
attrval.clear();
CLEAR_HEAD(th);
// this is invalid syntax
snprintf(line, sizeof(line), "100=");
ptr = line;
fail_unless(add_node_attribute_to_list(strdup("np"), &ptr, &th, 1) != PBSE_NONE);
CLEAR_HEAD(th);
// run over the two special cases
snprintf(line, sizeof(line), "100");
ptr = line;
fail_unless(add_node_attribute_to_list(strdup("TTL"), &ptr, &th, 1) == PBSE_NONE);
sattr = (svrattrl *)GET_NEXT(th);
fail_unless(strcmp(sattr->al_name, "TTL") == 0);
fail_unless(strcmp(sattr->al_value, "100") == 0);
attrlist_free();
attrname.clear();
attrval.clear();
CLEAR_HEAD(th);
snprintf(line, sizeof(line), "bob,tom");
ptr = line;
fail_unless(add_node_attribute_to_list(strdup("acl"), &ptr, &th, 1) == PBSE_NONE);
sattr = (svrattrl *)GET_NEXT(th);
fail_unless(strcmp(sattr->al_name, "acl") == 0);
fail_unless(strcmp(sattr->al_value, "bob,tom") == 0);
attrlist_free();
attrname.clear();
attrval.clear();
}
/**
* @brief
* status_sched - Build the status reply for single scheduler
*
* @param[in] psched - ptr to sched receiving status query
* @param[in] preq - ptr to the decoded request
* @param[out] pstathd - head of list to append status to
*
* @return int
* @retval 0 : success
* @retval !0 : PBSE error code
*/
static int
status_sched(pbs_sched *psched, struct batch_request *preq, pbs_list_head *pstathd)
{
int rc = 0;
struct brp_status *pstat;
svrattrl *pal;
pstat = (struct brp_status *)malloc(sizeof(struct brp_status));
if (pstat == NULL)
return (PBSE_SYSTEM);
pstat->brp_objtype = MGR_OBJ_SCHED;
(void)strncpy(pstat->brp_objname, psched->sc_name, (PBS_MAXSVRJOBID > PBS_MAXDEST ?
PBS_MAXSVRJOBID : PBS_MAXDEST) -1);
pstat->brp_objname[(PBS_MAXSVRJOBID > PBS_MAXDEST ? PBS_MAXSVRJOBID : PBS_MAXDEST) - 1] = '\0';
CLEAR_LINK(pstat->brp_stlink);
CLEAR_HEAD(pstat->brp_attr);
append_link(pstathd, &pstat->brp_stlink, pstat);
bad = 0;
pal = (svrattrl *)GET_NEXT(preq->rq_ind.rq_status.rq_attr);
if (status_attrib(pal, sched_attr_def, psched->sch_attr, SCHED_ATR_LAST,
preq->rq_perm, &pstat->brp_attr, &bad))
reply_badattr(PBSE_NOATTR, bad, pal, preq);
return (rc);
}
void clear_attr(
pbs_attribute *pattr, /* O */
attribute_def *pdef) /* I */
{
#ifndef NDEBUG
if (pdef == NULL)
{
fprintf(stderr, "Assertion failed, bad pdef in clear_attr\n");
abort();
}
#endif /* NDEBUG */
memset(pattr, 0, sizeof(pbs_attribute));
pattr->at_type = pdef->at_type;
if ((pattr->at_type == ATR_TYPE_RESC) ||
(pattr->at_type == ATR_TYPE_LIST))
{
CLEAR_HEAD(pattr->at_val.at_list);
}
return;
}
END_TEST
START_TEST(tm_spawn_request_test)
{
struct tcp_chan test_chan;
struct job test_job;
struct hnodent test_hnodent;
char *test_cookie = strdup("cookie");
int reply = 0;
int ret = 0;
int result = 0;
memset(&test_chan, 0, sizeof(test_chan));
memset(&test_job, 0, sizeof(test_job));
memset(&test_hnodent, 0, sizeof(test_hnodent));
test_job.ji_vnods = (vnodent *)calloc(3, sizeof(vnodent));
CLEAR_HEAD(test_job.ji_tasks);
result = tm_spawn_request(&test_chan,
&test_job,
0,
0,
(char *)test_cookie,
&reply,
&ret,
0,
&test_hnodent,
0);
fail_unless(result == TM_DONE, "tm_spawn_request fail: %d", result);
}
int status_job(
job *pjob, /* ptr to job to status */
struct batch_request *preq,
svrattrl *pal, /* specific attributes to status */
tlist_head *pstathd, /* RETURN: head of list to append status to */
int *bad) /* RETURN: index of first bad pbs_attribute */
{
struct brp_status *pstat;
int IsOwner = 0;
long query_others = 0;
/* see if the client is authorized to status this job */
if (svr_authorize_jobreq(preq, pjob) == 0)
IsOwner = 1;
get_svr_attr_l(SRV_ATR_query_others, &query_others);
if (!query_others)
{
if (IsOwner == 0)
{
return(PBSE_PERM);
}
}
/* allocate reply structure and fill in header portion */
if ((pstat = calloc(1, sizeof(struct brp_status))) == NULL)
{
return(PBSE_SYSTEM);
}
CLEAR_LINK(pstat->brp_stlink);
pstat->brp_objtype = MGR_OBJ_JOB;
strcpy(pstat->brp_objname, pjob->ji_qs.ji_jobid);
CLEAR_HEAD(pstat->brp_attr);
append_link(pstathd, &pstat->brp_stlink, pstat);
/* add attributes to the status reply */
*bad = 0;
if (status_attrib(
pal,
job_attr_def,
pjob->ji_wattr,
JOB_ATR_LAST,
preq->rq_perm,
&pstat->brp_attr,
bad,
IsOwner))
{
return(PBSE_NOATTR);
}
return (0);
} /* END status_job() */
int
decode_unkn(struct attribute *patr, char *name, char *rescn, char *value)
{
svrattrl *entry;
size_t valln;
if (patr == NULL)
return (PBSE_INTERNAL);
if (!(patr->at_flags & ATR_VFLAG_SET))
CLEAR_HEAD(patr->at_val.at_list);
if (name == NULL)
return (PBSE_INTERNAL);
if (value == NULL)
valln = 0;
else
valln = strlen(value) + 1;
entry = attrlist_create(name, rescn, valln);
if (entry == NULL)
return (PBSE_SYSTEM);
if (valln)
memcpy(entry->al_value, value, valln);
append_link(&patr->at_val.at_list, &entry->al_link, entry);
patr->at_flags |= ATR_VFLAG_SET | ATR_VFLAG_MODIFY | ATR_VFLAG_MODCACHE;
return (0);
}
END_TEST
START_TEST(clear_depend_test)
{
struct depend pd;
i = 1;
clear_depend(&pd, 0, 0);
fail_unless(pd.dp_type == 0, "type not set");
fail_unless(pd.dp_numexp == 0, "attr not set correctly");
fail_unless(pd.dp_numreg == 0, "attr not set correctly");
fail_unless(pd.dp_released == 0, "attr not set correctly");
i = 1;
memset(&pd, 0, sizeof(pd));
CLEAR_HEAD(pd.dp_jobs);
make_dependjob(&pd, job1, host);
make_dependjob(&pd, job2, host);
clear_depend(&pd, 0, 1);
fail_unless(pd.dp_type == 0, "type not set");
fail_unless(pd.dp_numexp == 0, "attr not set correctly");
fail_unless(pd.dp_numreg == 0, "attr not set correctly");
fail_unless(pd.dp_released == 0, "attr not set correctly");
}
END_TEST
START_TEST(record_node_property_list_test)
{
tlist_head th;
std::string props("bigmem fast");
std::string empty;
attrname.clear();
attrval.clear();
CLEAR_HEAD(th);
// empty list should do nothing
fail_unless(record_node_property_list(empty, &th) == PBSE_NONE);
fail_unless(attrname.size() == 0);
fail_unless(attrval.size() == 0);
attrlist_free();
attrname.clear();
attrval.clear();
/* fail_unless(record_node_property_list(props, &th) == PBSE_NONE);
fail_unless(attrname == ATTR_NODE_properties);
fail_unless(attrval == props);
attrlist_free();
attrname.clear();
attrval.clear();*/
}
job *job_alloc(void)
{
job *pj;
pj = (job *)calloc(1, sizeof(job));
if (pj == NULL)
{
log_err(errno, "job_alloc", (char *)"no memory");
return(NULL);
}
pj->ji_qs.qs_version = PBS_QS_VERSION;
CLEAR_LINK(pj->ji_alljobs);
CLEAR_LINK(pj->ji_jobque);
CLEAR_HEAD(pj->ji_tasks);
pj->ji_taskid = TM_NULL_TASK + 1;
pj->ji_obit = TM_NULL_EVENT;
pj->ji_nodekill = TM_ERROR_NODE;
pj->ji_momhandle = -1; /* mark mom connection invalid */
/* set the working attributes to "unspecified" */
job_init_wattr(pj);
return(pj);
} /* END job_alloc() */
pbs_queue *
que_alloc(char *name)
{
int i;
pbs_queue *pq;
pq = (pbs_queue *)malloc(sizeof(pbs_queue));
if (pq == (pbs_queue *)0) {
log_err(errno, "que_alloc", "no memory");
return ((pbs_queue *)0);
}
(void)memset((char *)pq, (int)0, (size_t)sizeof(pbs_queue));
pq->qu_qs.qu_type = QTYPE_Unset;
CLEAR_HEAD(pq->qu_jobs);
CLEAR_LINK(pq->qu_link);
strncpy(pq->qu_qs.qu_name, name, PBS_MAXQUEUENAME);
append_link(&svr_queues, &pq->qu_link, pq);
server.sv_qs.sv_numque++;
/* set the working attributes to "unspecified" */
for (i=0; i<(int)QA_ATR_LAST; i++) {
clear_attr(&pq->qu_attr[i], &que_attr_def[i]);
}
return (pq);
}
void
req_stat_svr(struct batch_request *preq)
{
svrattrl *pal;
struct batch_reply *preply;
struct brp_status *pstat;
/* update count and state counts from sv_numjobs and sv_jobstates */
server.sv_attr[(int)SRV_ATR_TotalJobs].at_val.at_long = server.sv_qs.sv_numjobs;
server.sv_attr[(int)SRV_ATR_TotalJobs].at_flags |= ATR_VFLAG_SET|ATR_VFLAG_MODCACHE;
update_state_ct(&server.sv_attr[(int)SRV_ATR_JobsByState],
server.sv_jobstates,
server.sv_jobstbuf);
update_license_ct(&server.sv_attr[(int)SRV_ATR_license_count],
server.sv_license_ct_buf);
/* allocate a reply structure and a status sub-structure */
preply = &preq->rq_reply;
preply->brp_choice = BATCH_REPLY_CHOICE_Status;
CLEAR_HEAD(preply->brp_un.brp_status);
pstat = (struct brp_status *)malloc(sizeof(struct brp_status));
if (pstat == NULL) {
reply_free(preply);
req_reject(PBSE_SYSTEM, 0, preq);
return;
}
CLEAR_LINK(pstat->brp_stlink);
(void)strcpy(pstat->brp_objname, server_name);
pstat->brp_objtype = MGR_OBJ_SERVER;
CLEAR_HEAD(pstat->brp_attr);
append_link(&preply->brp_un.brp_status, &pstat->brp_stlink, pstat);
/* add attributes to the status reply */
bad = 0;
pal = (svrattrl *)GET_NEXT(preq->rq_ind.rq_status.rq_attr);
if (status_attrib(pal, svr_attr_def, server.sv_attr, SRV_ATR_LAST,
preq->rq_perm, &pstat->brp_attr, &bad))
reply_badattr(PBSE_NOATTR, bad, pal, preq);
else
(void)reply_send(preq);
}
int add_encoded_attributes(
xmlNodePtr *attr_node, /* M attribute node */
pbs_attribute *pattr) /* M ptr to pbs_attribute value array */
{
tlist_head lhead;
int i;
int resc_access_perm = ATR_DFLAG_ACCESS;
svrattrl *pal;
int rc = PBSE_NONE;
xmlNodePtr attributeNode = *attr_node;
char buf[BUFSIZE];
xmlNodePtr pal_xmlNode;
CLEAR_HEAD(lhead);
xmlNodePtr resource_list_head_node = NULL;
xmlNodePtr resource_used_head_node = NULL;
for (i = 0; ((i < JOB_ATR_LAST) && (rc >= 0)); i++)
{
if (job_attr_def[i].at_type != ATR_TYPE_ACL)
if ((pattr + i)->at_flags & ATR_VFLAG_SET)
{
rc = job_attr_def[i].at_encode(
pattr + i,
&lhead,
job_attr_def[i].at_name,
NULL,
ATR_ENCODE_SAVE,
resc_access_perm);
(pattr + i)->at_flags &= ~ATR_VFLAG_MODIFY;
if (rc < 0)
return -1;
while ((pal = (svrattrl *)GET_NEXT(lhead)) != NULL)
{
if (!strcmp(ATTR_l, pal->al_atopl.name))
pal_xmlNode = add_resouce_list_attribute(ATTR_l, attr_node, &resource_list_head_node, pal);
else if (!strcmp(ATTR_used, pal->al_atopl.name))
pal_xmlNode = add_resouce_list_attribute(ATTR_used, attr_node, &resource_used_head_node, pal);
else
pal_xmlNode = xmlNewChild(attributeNode, NULL, (xmlChar *)pal->al_atopl.name, (xmlChar *)pal->al_atopl.value);
if (pal_xmlNode)
{
snprintf(buf, sizeof(buf), "%u", (unsigned int)pal->al_flags);
xmlSetProp(pal_xmlNode, (const xmlChar *)AL_FLAGS_ATTR, (const xmlChar *)buf);
}
delete_link(&pal->al_link);
free(pal);
if (!pal_xmlNode)
rc = -1;
}
}
}
return (0);
} /* END add_encoded_attributes */
END_TEST
START_TEST(del_depend_test)
{
struct depend *pdep = calloc(1, sizeof(struct depend));
CLEAR_HEAD(pdep->dp_jobs);
CLEAR_HEAD(pdep->dp_link);
make_dependjob(pdep, job1, host);
make_dependjob(pdep, job2, host);
del_depend(pdep);
}
void initialize_depend_attr(
pbs_attribute *pattr)
{
memset(pattr, 0, sizeof(pbs_attribute));
CLEAR_HEAD(pattr->at_val.at_list);
} /* END initialize_depend_attr() */
void
req_stat_que(struct batch_request *preq)
{
char *name;
pbs_queue *pque;
struct batch_reply *preply;
int rc = 0;
int type = 0;
/*
* first, validate the name of the requested object, either
* a queue, or null for all queues
*/
name = preq->rq_ind.rq_status.rq_id;
if ((*name == '\0') || (*name =='@'))
type = 1;
else {
pque = find_queuebyname(name);
#ifdef NAS /* localmod 075 */
if (pque == NULL)
pque = find_resvqueuebyname(name);
#endif /* localmod 075 */
if (pque == NULL) {
req_reject(PBSE_UNKQUE, 0, preq);
return;
}
}
preply = &preq->rq_reply;
preply->brp_choice = BATCH_REPLY_CHOICE_Status;
CLEAR_HEAD(preply->brp_un.brp_status);
if (type == 0) { /* get status of the one named queue */
rc = status_que(pque, preq, &preply->brp_un.brp_status);
} else { /* get status of queues */
pque = (pbs_queue *)GET_NEXT(svr_queues);
while (pque) {
rc = status_que(pque, preq, &preply->brp_un.brp_status);
if (rc != 0) {
if (rc == PBSE_PERM)
rc = 0;
else
break;
}
pque = (pbs_queue *)GET_NEXT(pque->qu_link);
}
}
if (rc) {
(void)reply_free(preply);
req_reject(rc, bad, preq);
} else {
(void)reply_send(preq);
}
}
int release_array_range(
job_array *pa,
struct batch_request *preq,
char *range_str)
{
tlist_head tl;
int i;
int rc;
array_request_node *rn;
array_request_node *to_free;
char *range = strchr(range_str,'=');
if (range == NULL)
return(PBSE_IVALREQ);
range++; /* move past the '=' */
CLEAR_HEAD(tl);
if (parse_array_request(range,&tl) > 0)
{
/* don't hold the jobs if range error */
return(PBSE_IVALREQ);
}
/* hold just that range from the array */
rn = (array_request_node*)GET_NEXT(tl);
while (rn != NULL)
{
for (i = rn->start; i <= rn->end; i++)
{
if (pa->jobs[i] == NULL)
continue;
/* don't stomp on other memory */
if (i >= pa->ai_qs.array_size)
continue;
if ((rc = release_job(preq,pa->jobs[i])))
return(rc);
}
/* release mem */
to_free = rn;
rn = (array_request_node*)GET_NEXT(rn->request_tokens_link);
free(to_free);
}
return(0);
} /* END release_array_range() */
/*
* hold_array_range()
*
* holds just a specified range from an array
* @param pa - the array to be acted on
* @param range_str - string specifying the range
*/
int hold_array_range(
job_array *pa, /* O */
char *range_str, /* I */
attribute *temphold) /* I */
{
tlist_head tl;
int i;
array_request_node *rn;
array_request_node *to_free;
char *range = strchr(range_str,'=');
if (range == NULL)
return(PBSE_IVALREQ);
range++; /* move past the '=' */
CLEAR_HEAD(tl);
if (parse_array_request(range,&tl) > 0)
{
/* don't hold the jobs if range error */
return(PBSE_IVALREQ);
}
else
{
/* hold just that range from the array */
rn = (array_request_node*)GET_NEXT(tl);
while (rn != NULL)
{
for (i = rn->start; i <= rn->end; i++)
{
if (pa->jobs[i] == NULL)
continue;
/* don't stomp on other memory */
if (i >= pa->ai_qs.array_size)
continue;
hold_job(temphold,pa->jobs[i]);
}
/* release mem */
to_free = rn;
rn = (array_request_node*)GET_NEXT(rn->request_tokens_link);
free(to_free);
}
}
return(0);
} /* END hold_array_range() */
void
req_stat_resv(struct batch_request * preq)
{
char *name;
struct batch_reply *preply;
resc_resv *presv = NULL;
int rc = 0;
int type = 0;
/*
* first, validate the name sent in the request.
* This is either the ID of a specific reservation
* or a '\0' or "@..." for all reservations.
*/
name = preq->rq_ind.rq_status.rq_id;
if ((*name == '\0') || (*name =='@'))
type = 1;
else {
presv = find_resv(name);
if (presv == NULL) {
req_reject(PBSE_UNKRESVID, 0, preq);
return;
}
}
preply = &preq->rq_reply;
preply->brp_choice = BATCH_REPLY_CHOICE_Status;
CLEAR_HEAD(preply->brp_un.brp_status);
if (type == 0) {
/* get status of the specifically named reservation */
rc = status_resv(presv, preq, &preply->brp_un.brp_status);
} else {
/* get status of all the reservations */
presv = (resc_resv *)GET_NEXT(svr_allresvs);
while (presv) {
rc = status_resv(presv, preq, &preply->brp_un.brp_status);
if (rc == PBSE_PERM)
rc = 0;
if (rc)
break;
presv = (resc_resv *)GET_NEXT(presv->ri_allresvs);
}
}
if (rc == 0)
(void)reply_send(preq);
else
req_reject(rc, bad, preq);
}
void clear_attr(pbs_attribute *pattr, attribute_def *pdef)
{
memset(pattr, 0, sizeof(pbs_attribute));
pattr->at_type = pdef->at_type;
if ((pattr->at_type == ATR_TYPE_RESC) ||
(pattr->at_type == ATR_TYPE_LIST))
{
CLEAR_HEAD(pattr->at_val.at_list);
}
}
int
decode_DIS_QueueJob(int sock, struct batch_request *preq)
{
int rc;
CLEAR_HEAD(preq->rq_ind.rq_queuejob.rq_attr);
rc = disrfst(sock, PBS_MAXSVRJOBID+1, preq->rq_ind.rq_queuejob.rq_jid);
if (rc) return rc;
rc = disrfst(sock, PBS_MAXSVRJOBID+1, preq->rq_ind.rq_queuejob.rq_destin);
if (rc) return rc;
return (decode_DIS_svrattrl(sock, &preq->rq_ind.rq_queuejob.rq_attr));
}
END_TEST
START_TEST(pbs_task_create_test)
{
job *pjob = (job *)calloc(1, sizeof(job));
/* Check ranning into reserved task IDs */
pjob->ji_taskid = TM_ADOPTED_TASKID_BASE + 1;
CLEAR_HEAD(pjob->ji_tasks);
fail_unless(pbs_task_create(pjob, TM_NULL_TASK) == NULL, "Reserved task");
/* Success */
pjob->ji_taskid = TM_NULL_TASK;
fail_unless(pbs_task_create(pjob, TM_NULL_TASK) != NULL);
}
int
decode_DIS_Status(int sock, struct batch_request *preq)
{
int rc;
CLEAR_HEAD(preq->rq_ind.rq_status.rq_attr);
rc = disrfst(sock,
(PBS_MAXSVRJOBID > PBS_MAXDEST ? PBS_MAXSVRJOBID : PBS_MAXDEST) + 1,
preq->rq_ind.rq_status.rq_id);
if (rc) return rc;
rc = decode_DIS_svrattrl(sock, &preq->rq_ind.rq_status.rq_attr);
return rc;
}
END_TEST
START_TEST(set_array_depend_holds_test)
{
batch_request *preq = (batch_request *)calloc(1, sizeof(batch_request));
job_array *pa = (job_array *)calloc(1, sizeof(job_array));
strcpy(preq->rq_ind.rq_register.rq_child, job1);
strcpy(preq->rq_ind.rq_register.rq_svr, host);
CLEAR_HEAD(pa->ai_qs.deps);
fail_unless(register_array_depend(pa, preq, JOB_DEPEND_TYPE_AFTEROKARRAY, 10) == PBSE_NONE);
pa->ai_qs.num_successful = 12;
fail_unless(set_array_depend_holds(pa) == true);
}
int
shutdown_preempt_chkpt(job *pjob)
{
struct batch_request *phold;
attribute temp;
void (*func)(struct work_task *);
long *hold_val = NULL;
long old_hold = 0;
phold = alloc_br(PBS_BATCH_HoldJob);
if (phold == NULL)
return (PBSE_SYSTEM);
temp.at_flags = ATR_VFLAG_SET;
temp.at_type = job_attr_def[(int)JOB_ATR_hold].at_type;
temp.at_user_encoded = NULL;
temp.at_priv_encoded = NULL;
temp.at_val.at_long = HOLD_s;
phold->rq_perm = ATR_DFLAG_MGRD | ATR_DFLAG_MGWR;
(void)strcpy(phold->rq_ind.rq_hold.rq_orig.rq_objname, pjob->ji_qs.ji_jobid);
CLEAR_HEAD(phold->rq_ind.rq_hold.rq_orig.rq_attr);
if (job_attr_def[(int)JOB_ATR_hold].at_encode(&temp,
&phold->rq_ind.rq_hold.rq_orig.rq_attr,
job_attr_def[(int)JOB_ATR_hold].at_name,
NULL,
ATR_ENCODE_CLIENT, NULL) < 0)
return (PBSE_SYSTEM);
phold->rq_extra = pjob;
func = post_chkpt;
if (relay_to_mom(pjob, phold, func) == 0) {
if (pjob->ji_qs.ji_state == JOB_STATE_TRANSIT)
svr_setjobstate(pjob, JOB_STATE_RUNNING, JOB_SUBSTATE_RUNNING);
pjob->ji_qs.ji_svrflags |= (JOB_SVFLG_HASRUN | JOB_SVFLG_CHKPT | JOB_SVFLG_HASHOLD);
pjob->ji_modified = 1;
(void)job_save(pjob, SAVEJOB_QUICK);
return (0);
} else {
*hold_val = old_hold; /* reset to the old value */
return (-1);
}
}
END_TEST
START_TEST(dup_depend_test)
{
struct depend pdep;
pbs_attribute pattr;
initialize_depend_attr(&pattr);
memset(&pdep, 0, sizeof(pdep));
CLEAR_HEAD(pdep.dp_jobs);
make_dependjob(&pdep, job1, host);
make_dependjob(&pdep, job2, host);
fail_unless(dup_depend(&pattr, &pdep) == PBSE_NONE, "didn't work");
}
job *svr_find_job(char *jobid, int get_subjob)
{
job *pjob = (job *)calloc(1, sizeof(job));
strcpy(pjob->ji_qs.ji_jobid, jobid);
CLEAR_HEAD(pjob->ji_wattr[JOB_ATR_depend].at_val.at_list);
if (!strcmp(jobid, "1.napali"))
{
return(pjob);
}
else if (!strcmp(jobid, "2.napali"))
{
pjob->ji_qs.ji_state = JOB_STATE_COMPLETE;
return(pjob);
}
else
return(NULL);
}
END_TEST
START_TEST(register_sync_test)
{
struct depend pdep;
memset(&pdep, 0, sizeof(pdep));
CLEAR_HEAD(pdep.dp_jobs);
fail_unless(register_sync(&pdep, job1, host, 1) == PBSE_NONE, "didn't register");
fail_unless(register_sync(&pdep, job1, host, 1) == PBSE_NONE, "second register");
pdep.dp_numexp = -10;
fail_unless(register_sync(&pdep, job2, host, 1) == PBSE_IVALREQ, "too many registered");
}
static int
status_que(pbs_queue *pque, struct batch_request *preq, pbs_list_head *pstathd)
{
struct brp_status *pstat;
svrattrl *pal;
if ((preq->rq_perm & ATR_DFLAG_RDACC) == 0)
return (PBSE_PERM);
/* ok going to do status, update count and state counts from qu_qs */
if (!svr_chk_history_conf()) {
pque->qu_attr[(int)QA_ATR_TotalJobs].at_val.at_long = pque->qu_numjobs;
} else {
pque->qu_attr[(int)QA_ATR_TotalJobs].at_val.at_long = pque->qu_numjobs -
(pque->qu_njstate[JOB_STATE_MOVED] + pque->qu_njstate[JOB_STATE_FINISHED]);
}
pque->qu_attr[(int)QA_ATR_TotalJobs].at_flags |= ATR_VFLAG_SET|ATR_VFLAG_MODCACHE;
update_state_ct(&pque->qu_attr[(int)QA_ATR_JobsByState],
pque->qu_njstate,
pque->qu_jobstbuf);
/* allocate status sub-structure and fill in header portion */
pstat = (struct brp_status *)malloc(sizeof(struct brp_status));
if (pstat == NULL)
return (PBSE_SYSTEM);
pstat->brp_objtype = MGR_OBJ_QUEUE;
(void)strcpy(pstat->brp_objname, pque->qu_qs.qu_name);
CLEAR_LINK(pstat->brp_stlink);
CLEAR_HEAD(pstat->brp_attr);
append_link(pstathd, &pstat->brp_stlink, pstat);
/* add attributes to the status reply */
bad = 0;
pal = (svrattrl *)GET_NEXT(preq->rq_ind.rq_status.rq_attr);
if (status_attrib(pal, que_attr_def, pque->qu_attr, QA_ATR_LAST,
preq->rq_perm, &pstat->brp_attr, &bad))
return (PBSE_NOATTR);
return (0);
}
job *job_alloc(void)
{
job *pj;
pj = (job *)calloc(1, sizeof(job));
if (pj == NULL)
{
log_err(errno, "job_alloc", "no memory");
return(NULL);
}
pj->ji_qs.qs_version = PBS_QS_VERSION;
CLEAR_LINK(pj->ji_alljobs);
CLEAR_LINK(pj->ji_jobque);
CLEAR_HEAD(pj->ji_tasks);
pj->ji_taskid = TM_NULL_TASK + 1;
pj->ji_numnodes = 0;
pj->ji_numvnod = 0;
pj->ji_hosts = NULL;
pj->ji_vnods = NULL;
pj->ji_resources = NULL;
pj->ji_obit = TM_NULL_EVENT;
pj->ji_preq = NULL;
pj->ji_nodekill = TM_ERROR_NODE;
pj->ji_flags = 0;
pj->ji_globid = NULL;
pj->ji_stdout = 0;
pj->ji_stderr = 0;
pj->ji_qs.ji_un.ji_momt.ji_exitstat = 0;
pj->ji_job_is_being_rerun = 0;
pj->ji_momhandle = -1; /* mark mom connection invalid */
/* set the working attributes to "unspecified" */
job_init_wattr(pj);
return(pj);
} /* END job_alloc() */
