bool
binding_parse_from_string(lListElem *this_elem, lList **answer_list, dstring *string)
{
bool ret = true;
DENTER(BINDING_LAYER, "binding_parse_from_string");
if (this_elem != NULL && string != NULL) {
int amount = 0;
int stepsize = 0;
int firstsocket = 0;
int firstcore = 0;
binding_type_t type = BINDING_TYPE_NONE;
dstring strategy = DSTRING_INIT;
dstring socketcorelist = DSTRING_INIT;
dstring error = DSTRING_INIT;
if (parse_binding_parameter_string(sge_dstring_get_string(string),
&type, &strategy, &amount, &stepsize, &firstsocket, &firstcore,
&socketcorelist, &error) != true) {
dstring parse_binding_error = DSTRING_INIT;
sge_dstring_append_dstring(&parse_binding_error, &error);
answer_list_add_sprintf(answer_list, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
MSG_PARSE_XOPTIONWRONGARGUMENT_SS, "-binding",
sge_dstring_get_string(&parse_binding_error));
sge_dstring_free(&parse_binding_error);
ret = false;
} else {
lSetString(this_elem, BN_strategy, sge_dstring_get_string(&strategy));
lSetUlong(this_elem, BN_type, type);
lSetUlong(this_elem, BN_parameter_socket_offset, (firstsocket >= 0) ? firstsocket : 0);
lSetUlong(this_elem, BN_parameter_core_offset, (firstcore >= 0) ? firstcore : 0);
lSetUlong(this_elem, BN_parameter_n, (amount >= 0) ? amount : 0);
lSetUlong(this_elem, BN_parameter_striding_step_size, (stepsize >= 0) ? stepsize : 0);
if (strstr(sge_dstring_get_string(&strategy), "explicit") != NULL) {
lSetString(this_elem, BN_parameter_explicit, sge_dstring_get_string(&socketcorelist));
}
}
sge_dstring_free(&strategy);
sge_dstring_free(&socketcorelist);
sge_dstring_free(&error);
}
DRETURN(ret);
}
/************************************************************************
id_sharetree - set the sharetree node id
************************************************************************/
bool id_sharetree(lList **alpp, lListElem *ep, int id, int *ret_id)
{
lListElem *cep = NULL;
int my_id = id;
DENTER(TOP_LAYER, "id_sharetree");
if (ep == NULL) {
answer_list_add(alpp, MSG_OBJ_NOSTREEELEM, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(false);
}
lSetUlong(ep, STN_id, my_id++);
/* handle the children */
for_each(cep, lGetList(ep, STN_children)) {
if (false == id_sharetree(NULL, cep, my_id, &my_id)) {
DRETURN(false);
}
}
if (ret_id) {
*ret_id = my_id;
}
DRETURN(true);
}
/****** sge_orders/sge_add_schedd_info() ***************************************
* NAME
* sge_add_schedd_info() -- retrieves the messages and generates an order out
* of it.
*
* SYNOPSIS
* lList* sge_add_schedd_info(lList *or_list, int *global_mes_count, int
* *job_mes_count)
*
* FUNCTION
* retrieves all messages, puts them into an order package, and frees the
* orginal messages. It also returns the number of global and job messages.
*
* INPUTS
* lList *or_list - int: the order list to which the message order is added
* int *global_mes_count - out: global message count
* int *job_mes_count - out: job message count
*
* RESULT
* lList* - the order list
*
* NOTES
* MT-NOTE: sge_add_schedd_info() is not MT safe
*
*******************************************************************************/
lList *sge_add_schedd_info(lList *or_list, int *global_mes_count, int *job_mes_count)
{
lList *jlist;
lListElem *sme, *ep;
DENTER(TOP_LAYER, "sge_add_schedd_info");
sme = schedd_mes_obtain_package(global_mes_count, job_mes_count);
if (!sme || (lGetNumberOfElem(lGetList(sme, SME_message_list)) < 1
&& lGetNumberOfElem(lGetList(sme, SME_global_message_list)) < 1)) {
DEXIT;
return or_list;
}
/* create orders list if not existent */
if (!or_list) {
or_list = lCreateList("orderlist", OR_Type);
}
/* build order */
ep=lCreateElem(OR_Type);
jlist = lCreateList("", SME_Type);
lAppendElem(jlist, sme);
lSetList(ep, OR_joker, jlist);
lSetUlong(ep, OR_type, ORT_job_schedd_info);
lAppendElem(or_list, ep);
DEXIT;
return or_list;
}
int pack_ack(sge_pack_buffer *pb, u_long32 type, u_long32 id, u_long32 id2, const char *str)
{
int ret;
lListElem *ack = lCreateElem(ACK_Type);
DENTER(TOP_LAYER, "pack_ack");
lSetUlong(ack, ACK_type, type);
lSetUlong(ack, ACK_id, id);
lSetUlong(ack, ACK_id2, id2);
lSetString(ack, ACK_str, str);
ret = cull_pack_elem(pb, ack);
lFreeElem(&ack);
DRETURN(ret);
}
void job_report_init_from_job_with_usage(lListElem *job_report,
lListElem *job,
lListElem *ja_task,
lListElem *pe_task,
u_long32 time_stamp)
{
lListElem *ep;
lListElem *obj;
int nm;
DENTER(TOP_LAYER, "job_report_init_from_job_with_usage");
/*
* initialize the job jeport like any other job report...
*/
job_report_init_from_job(job_report, job, ja_task, pe_task);
/*
* ... and now add the online usage plus some fileds which are needed for the accounting
*/
lSetUlong(job_report, JR_wait_status, SGE_SET_WEXITSTATUS(SGE_WEXITED_BIT, 0));
lSetUlong(job_report, JR_failed, SSTATE_QMASTER_ENFORCED_LIMIT);
if (pe_task == NULL) {
nm = JAT_scaled_usage_list;
obj = ja_task;
} else {
nm = PET_scaled_usage;
obj = pe_task;
lSetString(job_report, JR_pe_task_id_str, lGetString(pe_task, PET_id));
}
ep = lAddSubStr(obj, UA_name, "submission_time", nm, UA_Type);
lSetDouble(ep, UA_value, lGetUlong(job, JB_submission_time));
ep = lAddSubStr(obj, UA_name, "start_time", nm, UA_Type);
lSetDouble(ep, UA_value, lGetUlong(ja_task, JAT_start_time));
ep = lAddSubStr(obj, UA_name, "end_time", nm, UA_Type);
lSetDouble(ep, UA_value, time_stamp);
ep = lAddSubStr(obj, UA_name, "ru_wallclock", nm, UA_Type);
lSetDouble(ep, UA_value, 0.0);
lSetList(job_report, JR_usage, lCopyList("", lGetList(obj, nm)));
DEXIT;
}
static bool
cqueue_add_qinstances(sge_gdi_ctx_class_t *ctx, lListElem *cqueue, lList **answer_list, lList *add_hosts, monitoring_t *monitor)
{
bool ret = true;
DENTER(TOP_LAYER, "cqueue_add_qinstances");
if (cqueue != NULL && add_hosts != NULL) {
lListElem *href = NULL;
for_each(href, add_hosts) {
const char *hostname = lGetHost(href, HR_name);
lList *list = lGetList(cqueue, CQ_qinstances);
lListElem* qinstance = lGetElemHost(list, QU_qhostname, hostname);
if (qinstance != NULL) {
if (qinstance_state_is_orphaned(qinstance)) {
sge_qmaster_qinstance_state_set_orphaned(qinstance, false);
lSetUlong(qinstance, QU_tag, SGE_QI_TAG_MOD);
} else {
/*
* We might already have this QI if it is in orphaned state.
* If this is not true, than there is a bug!
*/
ERROR((SGE_EVENT, MSG_QINSTANCE_QIALREADYHERE_S, hostname));
answer_list_add(answer_list, SGE_EVENT, STATUS_ESYNTAX,
ANSWER_QUALITY_ERROR);
}
} else {
bool is_ambiguous = false;
if (list == NULL) {
list = lCreateList("", QU_Type);
lSetList(cqueue, CQ_qinstances, list);
}
qinstance = qinstance_create(ctx,
cqueue, answer_list,
hostname, &is_ambiguous, monitor);
if (is_ambiguous) {
DPRINTF(("qinstance %s has ambiguous conf\n", hostname));
}
lSetUlong(qinstance, QU_tag, SGE_QI_TAG_ADD);
lAppendElem(list, qinstance);
}
}
}
/****** sgeobj/qinstance/qinstance_list_set_tag() *****************************
* NAME
* qinstance_list_set_tag() -- tag a list of qinstances
*
* SYNOPSIS
* void
* qinstance_list_set_tag(lList *this_list, u_long32 tag_value)
*
* FUNCTION
* Tag a list of qinstances ("this_list") with "tag_value".
*
* INPUTS
* lList *this_list - QU_Type list
* u_long32 tag_value - unsingned long value (not a bitmask)
*
* RESULT
* void - None
*
* NOTES
* MT-NOTE: qinstance_list_set_tag() is MT safe
*******************************************************************************/
void
qinstance_list_set_tag(lList *this_list, u_long32 tag_value)
{
if (this_list != NULL) {
lListElem *qinstance = NULL;
for_each(qinstance, this_list) {
lSetUlong(qinstance, QU_tag, tag_value);
}
/*
select and suspend jobs in susp_queues
*/
void
suspend_job_in_queues( lList *susp_queues, lList *job_list, order_t *orders)
{
u_long32 now;
int i, found;
lListElem *jep = NULL, *ja_task = NULL;
lListElem *qep;
DENTER(TOP_LAYER, "suspend_job_in_queues");
now = sge_get_gmt();
for_each (qep, susp_queues) {
u_long32 interval;
/* are suspend thresholds enabled? */
parse_ulong_val(NULL, &interval, TYPE_TIM,
lGetString(qep, QU_suspend_interval), NULL, 0);
if (interval == 0
|| !lGetUlong(qep, QU_nsuspend)
|| !lGetList(qep, QU_suspend_thresholds)) {
continue;
}
/* check time stamp */
if (lGetUlong(qep, QU_last_suspend_threshold_ckeck) &&
(lGetUlong(qep, QU_last_suspend_threshold_ckeck) + interval> now)) {
continue;
}
for (i = 0, found = 1;
i < (int) lGetUlong(qep, QU_nsuspend) && found;
i++) {
found = 0;
/* find one running job in suspend queue */
if (select4suspension(job_list, qep, &jep, &ja_task))
break;
/* generate suspend order for found job */
found = 1;
orders->configOrderList = sge_create_orders(orders->configOrderList,
ORT_suspend_on_threshold,
jep, ja_task, NULL, true);
DPRINTF(("++++ suspending job "sge_u32"/"sge_u32" on threshold\n",
lGetUlong(jep, JB_job_number), lGetUlong(ja_task, JAT_task_number)));
/* prevent multiple selection of this job */
lSetUlong(ja_task, JAT_state,
lGetUlong(ja_task, JAT_state) | JSUSPENDED_ON_THRESHOLD);
}
if (i==0 && !found) {
DPRINTF(("found no jobs for sot in queue %s\n", lGetString(qep, QU_full_name)));
}
}
/******* execd/loadsensor/sge_ls_create_ls() **********************************
* NAME
* sge_ls_create_ls -- creates a new CULL loadsensor element
*
* SYNOPSIS
* static lListElem* sge_ls_create_ls(const char *qualified_hostname,
* char *name, const char *scriptfile)
*
* FUNCTION
* The function creates a new CULL element of type LS_Type and
* returns a pointer to this object. The loadsensor will be
* started immediately.
* If it cannot be started then, LS_has_to_restart is set to
* true so that it will be attempted to be restarted in the next load interval
*
* INPUTS
* qualified_hostname - qualified host name
* name - pseudo name of the ls
* "extern" for user defined loadsensors
* "intern" for qidle and qloadsensor
* scriptfile - absolute path to the ls scriptfile
*
* RESULT
* new CULL element of type LS_Type will be returned
* and a new loadsensor process will be created by this function
******************************************************************************/
static lListElem *sge_ls_create_ls(const char *qualified_hostname, char *name, const char *scriptfile)
{
lListElem *new_ls = NULL; /* LS_Type */
SGE_STRUCT_STAT st;
DENTER(TOP_LAYER, "sge_ls_create_ls");
if (scriptfile != NULL) {
if (SGE_STAT(scriptfile, &st) != 0) {
if (strcmp(name, "extern") == 0) {
WARNING((SGE_EVENT, MSG_LS_NOMODTIME_SS, scriptfile,
strerror(errno)));
}
DRETURN(NULL);
}
new_ls = lCreateElem(LS_Type);
if (new_ls) {
/* initialize all attributes */
lSetString(new_ls, LS_name, name);
lSetString(new_ls, LS_command, scriptfile);
sge_ls_set_pid(new_ls, -1);
lSetRef(new_ls, LS_in, NULL);
lSetRef(new_ls, LS_out, NULL);
lSetRef(new_ls, LS_err, NULL);
lSetBool(new_ls, LS_has_to_restart, false);
lSetUlong(new_ls, LS_tag, 0);
lSetList(new_ls, LS_incomplete, lCreateList("", LR_Type));
lSetList(new_ls, LS_complete, lCreateList("", LR_Type));
lSetUlong(new_ls, LS_last_mod, st.st_mtime);
/* start loadsensor, if couldn't set the restart flag so that we
* restart it in the next load interval
*/
if (sge_ls_start_ls(qualified_hostname, new_ls) != LS_OK) {
lSetBool(new_ls, LS_has_to_restart, true);
}
}
}
DRETURN(new_ls);
}
/****** sge_orders/sge_create_orders() *****************************************
* NAME
* sge_create_orders() -- Create a new order-list or add orders to an existing one
*
* SYNOPSIS
* lList* sge_create_orders(lList *or_list, u_long32 type, lListElem *job,
* lListElem *ja_task, lList *granted, bool update_execd)
*
* FUNCTION
* - If the or_list is NULL, a new one will be generated
*
* - in case of a clear_pri order, teh ja_task is improtant. If NULL is put
* in for ja_task, only the pendin tasks of the spedified job are set to NULL.
* If a ja_task is put in, all tasks of the job are set to NULL
*
* INPUTS
* lList *or_list - the order list
* u_long32 type - order type
* lListElem *job - job
* lListElem *ja_task - ja_task ref or NULL(there is only one case, where it can be NULL)
* lList *granted - granted queue list
* bool update_execd - should the execd get new ticket values?
*
* RESULT
* lList* - returns the orderlist
*
* NOTES
* MT-NOTE: sge_create_orders() is MT safe
*
* SEE ALSO
* ???/???
*******************************************************************************/
lList
*sge_create_orders(lList *or_list, u_long32 type, lListElem *job, lListElem *ja_task,
lList *granted , bool update_execd)
{
lList *ql = NULL;
lListElem *gel, *ep, *ep2;
u_long32 qslots;
DENTER(TOP_LAYER, "sge_create_orders");
if (!job) {
lFreeList(&or_list);
DEXIT;
return or_list;
}
/* create orders list if not existent */
if (!or_list) {
or_list = lCreateList("orderlist", OR_Type);
}
/* build sublist of granted */
if (update_execd) {
for_each(gel, granted) {
qslots = lGetUlong(gel, JG_slots);
if (qslots) { /* ignore Qs with slots==0 */
ep2=lCreateElem(OQ_Type);
lSetUlong(ep2, OQ_slots, qslots);
lSetString(ep2, OQ_dest_queue, lGetString(gel, JG_qname));
lSetUlong(ep2, OQ_dest_version, lGetUlong(gel, JG_qversion));
lSetDouble(ep2, OQ_ticket, lGetDouble(gel, JG_ticket));
lSetDouble(ep2, OQ_oticket, lGetDouble(gel, JG_oticket));
lSetDouble(ep2, OQ_fticket, lGetDouble(gel, JG_fticket));
lSetDouble(ep2, OQ_sticket, lGetDouble(gel, JG_sticket));
if (!ql)
ql=lCreateList("orderlist",OQ_Type);
lAppendElem(ql, ep2);
}
}
}
/* ----------------------------------------
add a string value to the load report list lpp
*/
int sge_add_str2load_report(lList **lpp, const char *name, const char *value, const char *host)
{
lListElem *ep = NULL, *search_ep = NULL;
const void *iterator = NULL;
DENTER(BASIS_LAYER, "sge_add_str2load_report");
if (lpp == NULL || name == NULL || value == NULL || host == NULL) {
DRETURN(-1);
}
if (*lpp != NULL) {
search_ep = lGetElemHostFirst(*lpp, LR_host, host, &iterator);
while (search_ep != NULL) {
DPRINTF(("---> %s\n", lGetString(search_ep, LR_name)));
if (strcmp(lGetString(search_ep, LR_name), name) == 0) {
ep = search_ep;
break;
}
search_ep = lGetElemHostNext(*lpp, LR_host, host, &iterator);
}
}
if (ep == NULL) {
DPRINTF(("adding new load variable %s for host %s\n", name, host));
ep = lAddElemStr(lpp, LR_name, name, LR_Type);
lSetHost(ep, LR_host, host);
lSetUlong(ep, LR_global, (u_long32)(strcmp(host, SGE_GLOBAL_NAME) == 0 ? 1 : 0));
lSetUlong(ep, LR_static, sge_is_static_load_value(name));
}
lSetString(ep, LR_value, value);
DPRINTF(("load value %s for host %s: %s\n", name, host, value));
DRETURN(0);
}
/****** sgeobj/report/job_report_init_from_job() *****************************
* NAME
* job_report_init_from_job() -- initialize job report
*
* SYNOPSIS
* void job_report_init_from_job(lListElem *job_report,
* const lListElem *job,
* const lListElem *ja_task,
* const lListElem *pe_task)
*
* FUNCTION
* Initialize "job_report" from the attributes obtained from
* "job", "ja_task" and "pe_task".
*
* INPUTS
* lListElem *job_report - JR_Type object
* const lListElem *job - JB_Type object
* const lListElem *ja_task - JAT_Type object
* const lListElem *pe_task - PET_Type object
******************************************************************************/
void job_report_init_from_job(lListElem *job_report,
const lListElem *job,
const lListElem *ja_task,
const lListElem *pe_task)
{
u_long32 job_id = lGetUlong(job, JB_job_number);
u_long32 ja_task_id = lGetUlong(ja_task, JAT_task_number);
lListElem *queue = NULL; /* QU_Type */
DENTER(TOP_LAYER, "job_report_init_from_job");
lSetUlong(job_report, JR_job_number, job_id);
lSetUlong(job_report, JR_ja_task_number, ja_task_id);
if (pe_task != NULL) {
lSetString(job_report, JR_pe_task_id_str, lGetString(pe_task, PET_id));
queue = lFirst(lGetList(pe_task, PET_granted_destin_identifier_list));
} else {
queue = lFirst(lGetList(ja_task, JAT_granted_destin_identifier_list));
}
if (lGetUlong(ja_task, JAT_status) == JSLAVE){
if (pe_task == NULL) {
lSetUlong(job_report, JR_state, JSLAVE);
} else {
lSetUlong(job_report, JR_state, JWRITTEN);
}
} else {
lSetUlong(job_report, JR_state, JWRITTEN);
}
if (queue != NULL) {
lSetString(job_report, JR_queue_name, lGetString(queue, JG_qname));
}
DEXIT;
}
/************************************************************
sge_mod_sched_configuration - Master code
Modify scheduler configuration. We have only one entry in
Master_Sched_Config_List. So we replace it with the new one.
************************************************************/
int sge_mod_sched_configuration(
sge_gdi_ctx_class_t *ctx,
lListElem *confp,
lList **alpp,
char *ruser,
char *rhost
) {
lList *temp_conf_list = NULL;
DENTER(TOP_LAYER, "sge_mod_sched_configuration");
if ( !confp || !ruser || !rhost ) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_NULLPTRPASSED_S, SGE_FUNC));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DEXIT;
return STATUS_EUNKNOWN;
}
temp_conf_list = lCreateList("sched config", SC_Type);
lSetUlong(confp, SC_weight_tickets_override,
sconf_get_weight_tickets_override());
confp = lCopyElem(confp);
lAppendElem(temp_conf_list, confp);
/* just check and log */
if (!sconf_set_config(&temp_conf_list, alpp)) {
lFreeList(&temp_conf_list);
DEXIT;
return STATUS_EUNKNOWN;
}
if (!sge_event_spool(ctx,
alpp, 0, sgeE_SCHED_CONF,
0, 0, "schedd_conf", NULL, NULL,
confp, NULL, NULL, true, true)) {
answer_list_add(alpp, MSG_SCHEDCONF_CANTCREATESCHEDULERCONFIGURATION, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR);
DEXIT;
return -1;
}
check_reprioritize_interval(ctx, alpp, ruser, rhost);
INFO((SGE_EVENT, MSG_SGETEXT_MODIFIEDINLIST_SSSS, ruser, rhost, "scheduler", "scheduler configuration"));
answer_list_add(alpp, SGE_EVENT, STATUS_OK, ANSWER_QUALITY_INFO);
DEXIT;
return STATUS_OK;
} /* sge_mod_sched_configuration */
lList *buildJobList(int num)
{
lList *joblist = NULL;
lListElem *job;
int n;
char name[20];
joblist = lCreateList("joblist", JobT);
for (n = 0; n < num; n++) {
sprintf(name, "Job%d", n);
job = lCreateElem(JobT);
lSetUlong(job, J_id, n);
lSetString(job, J_name, name);
lSetList(job, J_hardrequest, buildRequestList(n));
lAppendElem(joblist, job);
}
return joblist;
}
/*
*
* NOTES
* MT-NOTE: sge_qwaittid() is not MT safe
*
*/
int sge_qwaittid(sge_gdi_ctx_class_t *ctx, sge_tid_t tid, int *status, int options)
{
lListElem *rt = NULL;
int ret, rcv_opt = 0;
DENTER(TOP_LAYER, "sge_qwaittid");
if (!(options&WNOHANG))
rcv_opt |= OPT_SYNCHRON;
if (tid != NULL && !(rt=LOCATE_RTASK(tid))) {
sprintf(lasterror, MSG_GDI_TASKNOTEXIST_S , tid);
DEXIT;
return -1;
}
while ((rt && /* definite one searched */
lGetUlong(rt, RT_state)!=RT_STATE_EXITED && /* not exited */
lGetUlong(rt, RT_state)==RT_STATE_WAIT4ACK) /* waiting for ack */
|| (!rt && /* anybody searched */
!lGetElemUlong(remote_task_list, RT_state, RT_STATE_EXITED) && /* none exited */
lGetElemUlong(remote_task_list, RT_state, RT_STATE_WAIT4ACK))) { /* but one is waiting for ack */
/* wait for incoming messeges about exited tasks */
if ((ret=rcv_from_execd(ctx, rcv_opt, TAG_TASK_EXIT))) {
DEXIT;
return (ret<0)?-1:0;
}
}
if (status)
*status = lGetUlong(rt, RT_status);
lSetUlong(rt, RT_state, RT_STATE_WAITED);
DEXIT;
return 0;
}
lList *cull_unparse_job_parameter(
sge_gdi_ctx_class_t *ctx,
lList **pcmdline,
lListElem *job,
int flags
) {
const char *cp;
u_long32 ul;
lList *answer = NULL;
char str[1024 + 1];
lList *lp;
int ret;
lListElem *ep_opt;
const char *username = ctx->get_username(ctx);
const char *qualified_hostname = ctx->get_qualified_hostname(ctx);
DENTER(TOP_LAYER, "cull_unparse_job_parameter");
/*
** -a
** problem with submission time, but that is not a good
** default option anyway, is not unparsed
*/
/*
** -A
*/
if (sge_unparse_account_string(job, pcmdline, &answer) != 0) {
DEXIT;
return answer;
}
/*
** -c
*/
if (sge_unparse_checkpoint_option(job, pcmdline, &answer) != 0) {
DEXIT;
return answer;
}
/*
* -ckpt
*/
if (sge_unparse_string_option(job, JB_checkpoint_name, "-ckpt",
pcmdline, &answer) != 0) {
DEXIT;
return answer;
}
/*
** -cwd
*/
if (lGetString(job, JB_cwd)) {
ep_opt = sge_add_noarg(pcmdline, cwd_OPT, "-cwd", NULL);
}
/*
* -P
*/
if (sge_unparse_string_option(job, JB_project, "-P",
pcmdline, &answer) != 0) {
DEXIT;
return answer;
}
#if 0
/*
** -C
*/
if (sge_unparse_string_option(job, JB_directive_prefix, "-C",
pcmdline, &answer) != 0) {
DEXIT;
return answer;
}
#endif
/*
** -e
*/
if (sge_unparse_path_list(job, JB_stderr_path_list, "-e", pcmdline,
&answer) != 0) {
DEXIT;
return answer;
}
/*
** -h, here only user hold supported at the moment
*/
if ((ul = lGetUlong(lFirst(lGetList(job, JB_ja_tasks)), JAT_hold))) {
ep_opt = sge_add_noarg(pcmdline, h_OPT, "-h", NULL);
}
/*
** -hold_jid
*/
if ((lp = lGetList(job, JB_jid_request_list))) {
int fields[] = { JRE_job_name, 0 };
const char *delis[] = {NULL, ",", NULL};
ret = uni_print_list(NULL, str, sizeof(str) - 1, lp, fields, delis, 0);
if (ret) {
DPRINTF(("Error %d formatting jid_request_list as -hold_jid\n", ret));
sprintf(str, MSG_LIST_ERRORFORMATINGJIDPREDECESSORLISTASHOLDJID);
answer_list_add(&answer, str, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
return answer;
}
ep_opt = sge_add_arg(pcmdline, hold_jid_OPT, lListT, "-hold_jid", str);
lSetList(ep_opt, SPA_argval_lListT, lCopyList("hold_jid list", lp));
}
/*
** -hold_jid_ad
*/
if ((lp = lGetList(job, JB_ja_ad_request_list))) {
int fields[] = { JRE_job_name, 0 };
const char *delis[] = {NULL, ",", NULL};
ret = uni_print_list(NULL, str, sizeof(str) - 1, lp, fields, delis, 0);
if (ret) {
DPRINTF(("Error %d formatting ja_ad_request_list as -hold_jid_ad\n", ret));
sprintf(str, MSG_LIST_ERRORFORMATINGJIDPREDECESSORLISTASHOLDJIDAD);
answer_list_add(&answer, str, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
return answer;
}
ep_opt = sge_add_arg(pcmdline, hold_jid_ad_OPT, lListT, "-hold_jid_ad", str);
lSetList(ep_opt, SPA_argval_lListT, lCopyList("hold_jid_ad list", lp));
}
/*
** -i
*/
if (sge_unparse_path_list(job, JB_stdin_path_list, "-i", pcmdline,
&answer) != 0) {
DEXIT;
return answer;
}
/*
** -j
*/
if ((ul = lGetBool(job, JB_merge_stderr))) {
ep_opt = sge_add_arg(pcmdline, j_OPT, lIntT, "-j", "y");
lSetInt(ep_opt, SPA_argval_lIntT, true);
}
/*
** -jid
*/
if ((lp = lGetList(job, JB_job_identifier_list))) {
int fields[] = { JRE_job_number, 0};
const char *delis[] = {"", ",", NULL};
ret = uni_print_list(NULL, str, sizeof(str) - 1, lp, fields, delis,
0);
if (ret) {
DPRINTF(("Error %d formatting job_identifier_list as -jid\n", ret));
sprintf(str, MSG_LIST_ERRORFORMATINGJOBIDENTIFIERLISTASJID);
answer_list_add(&answer, str, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
return answer;
}
ep_opt = sge_add_arg(pcmdline, jid_OPT, lListT, "-jid", str);
lSetList(ep_opt, SPA_argval_lListT, lCopyList("jid list", lp));
}
/*
** -js
*/
if ((ul = lGetUlong(job, JB_jobshare)) != 0) {
sprintf(str, sge_u32, ul);
ep_opt = sge_add_arg(pcmdline, js_OPT, lUlongT, "-js", str);
lSetUlong(ep_opt, SPA_argval_lUlongT, ul);
}
/*
** -lj is in parsing but can't be unparsed here
*/
/*
** -l
*/
if (sge_unparse_resource_list(job, JB_hard_resource_list,
pcmdline, &answer) != 0) {
DEXIT;
return answer;
}
if (sge_unparse_resource_list(job, JB_soft_resource_list,
pcmdline, &answer) != 0) {
DEXIT;
return answer;
}
/*
** -m
*/
if ((ul = lGetUlong(job, JB_mail_options))) {
cp = sge_unparse_mail_options(ul);
if (!cp) {
DPRINTF(("Error unparsing mail options\n"));
sprintf(str, MSG_PARSE_ERRORUNPARSINGMAILOPTIONS);
answer_list_add(&answer, str, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
return answer;
}
ep_opt = sge_add_arg(pcmdline, m_OPT, lIntT, "-m", cp);
lSetInt(ep_opt, SPA_argval_lIntT, ul);
}
/*
** -M obviously a problem!!!
** not unparsed at the moment
** does it make sense as a default, after all?
*/
if ((lp = lGetList(job, JB_mail_list))) {
lList *lp_new = NULL;
lListElem *ep_new = NULL;
lListElem *ep = NULL;
const char *host;
const char *user;
/*
** or rather take all if there are more than one elements?
*/
for_each(ep, lp) {
user = lGetString(ep, MR_user);
host = lGetHost(ep, MR_host);
if (sge_strnullcmp(user, username) ||
sge_hostcmp(host, qualified_hostname)) {
lp_new = lCreateList("mail list", MR_Type);
ep_new = lAddElemStr(&lp_new, MR_user, user, MR_Type);
lSetHost(ep_new, MR_host, host);
}
}
bool test_lWhat_lSelect(void)
{
bool ret = true;
lEnumeration *what = lWhat("%T(%I %I -> %T( %I %I -> %T (%I %I %I %I) %I %I) %I -> %T(%I) %I)",
TEST_Type,
TEST_int,
TEST_list, TEST1_Type,
TEST1_int,
TEST1_list, TEST_Type,
TEST_int,
TEST_list,
TEST_object,
TEST_string,
TEST1_object,
TEST1_string,
TEST_object, TEST1_Type,
TEST1_string,
TEST_string);
lListElem *elem;
lListElem *elem1;
lList *list = lCreateList("", TEST_Type);
lList *list1 = NULL;
int i;
elem = lCreateElem(TEST_Type);
lSetInt(elem, TEST_int, 0);
lSetHost(elem, TEST_host, "zero");
lSetString(elem, TEST_string, "zero");
lSetFloat(elem, TEST_float, 0);
lSetDouble(elem, TEST_double, 0);
lSetChar(elem, TEST_char, 'z');
lSetLong(elem, TEST_long, 0);
lSetUlong(elem, TEST_ulong, 0);
lSetBool(elem, TEST_bool, false);
elem1 = lCreateElem(TEST1_Type);
lSetInt(elem1, TEST1_int, 1);
lSetHost(elem1, TEST1_host, "one");
lSetString(elem1, TEST1_string, "one");
lSetFloat(elem1, TEST1_float, 1);
lSetDouble(elem1, TEST1_double, 1);
lSetChar(elem1, TEST1_char, 'o');
lSetLong(elem1, TEST1_long, 1);
lSetUlong(elem1, TEST1_ulong, 1);
lSetBool(elem1, TEST1_bool, true);
for (i = 0; i < 5; i++) {
lList *tmp_list = lCreateList("", TEST1_Type);
lListElem *tmp_elem = lCopyElem(elem);
int j;
for (j = 0; j < 5; j++) {
lList *tmp_list1 = lCreateList("", TEST_Type);
lListElem *tmp_elem1 = lCopyElem(elem);
int k;
for (k = 0; k < 5; k++) {
lList *tmp_list2 = lCreateList("", TEST1_Type);
lListElem *tmp_elem2 = lCopyElem(elem);
lSetList(tmp_elem2, TEST_list, tmp_list2);
lAppendElem(tmp_list1, tmp_elem2);
}
lSetList(tmp_elem1, TEST_list, tmp_list1);
lAppendElem(tmp_list, tmp_elem1);
}
lSetList(tmp_elem, TEST_list, tmp_list);
lAppendElem(list, tmp_elem);
}
list1 = lSelect("", list, NULL, what);
/* EB: Replace this function */
#if 0
lWriteListTo(list1, stderr);
#endif
lFreeWhat(&what);
lFreeElem(&elem);
lFreeElem(&elem1);
lFreeList(&list);
lFreeList(&list1);
return ret;
}
/****** sge_select_queue/get_queue_resource() ***************************************
* NAME
* get_queue_resource() -- extracts attribut information from the queue
*
* SYNOPSIS
* static lListElem* get_queue_resource(lListElem *queue, lList *centry_list, const char *attrname)
*
* FUNCTION
* All fixed queue attributes are directly coded into the queue structure. These have to extraced
* and formed into a CE structure. That is, what this function does. It takes a name for an attribut
* and returns a full CE structure, if the attribut is set in the queue. Otherwise it returns NULL.
*
* INPUTS
* lListElem *queue_elem -
* lListElm *queue -
* const char *attrname - name of the attribute.
* RESULT
* bool -
*
*
*******************************************************************************/
bool get_queue_resource(lListElem *queue_elem, const lListElem *queue, const char *attrname){
double dval=0.0;
const char *value=NULL;
char as_str[100];
int type, field;
DENTER(BASIS_LAYER, "get_queue_resource");
if(!queue_elem){
/* error */
DRETURN(false);
}
if (get_rsrc(attrname, true, &field, NULL, NULL, &type)!=0) {
DPRINTF(("is not a system queue attribute: %s\n", attrname));
DRETURN(false);
}
/* read stuff from queue and set to new elements */
switch(type) {
case TYPE_INT:
dval = (double)lGetUlong(queue, field);
snprintf(as_str, 100, sge_u32, lGetUlong(queue, field));
break;
case TYPE_TIM:
case TYPE_MEM:
case TYPE_DOUBLE:
if ((value = lGetString(queue, field))) {
parse_ulong_val(&dval, NULL, type, value, NULL, 0);
}
break;
case TYPE_BOO:
dval = (double)lGetBool(queue, field);
snprintf(as_str, 100, "%d", (int)lGetBool(queue, field));
break;
case TYPE_STR:
case TYPE_CSTR:
case TYPE_RESTR:
value = lGetString(queue, field);
break;
case TYPE_HOST:
value = lGetHost(queue, field);
break;
}
if (!is_attr_prior2(queue_elem, dval, CE_doubleval, CE_dominant)){
lSetUlong(queue_elem,CE_dominant , DOMINANT_LAYER_QUEUE|DOMINANT_TYPE_FIXED);
lSetDouble(queue_elem,CE_doubleval , dval);
if(value){
lSetString(queue_elem, CE_stringval, value);
}
else{
lSetString(queue_elem,CE_stringval , as_str);
}
}
DRETURN(true);
}
bool sge_parse_qrsub(sge_gdi_ctx_class_t *ctx, lList *pcmdline, lList **alpp, lListElem **ar)
{
lListElem *ep = NULL, *next_ep = NULL;
lList *lp = NULL;
DENTER(TOP_LAYER, "sge_parse_qrsub");
/* -help print this help */
if ((ep = lGetElemStr(pcmdline, SPA_switch, "-help"))) {
lRemoveElem(pcmdline, &ep);
sge_usage(QRSUB, stdout);
DEXIT;
SGE_EXIT((void **)&ctx, 0);
}
/* -a date_time start time in [[CC]YY]MMDDhhmm[.SS] SGE_ULONG */
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-a"))) {
lSetUlong(*ar, AR_start_time, lGetUlong(ep, SPA_argval_lUlongT));
lRemoveElem(pcmdline, &ep);
}
/* -e date_time end time in [[CC]YY]MMDDhhmm[.SS] SGE_ULONG*/
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-e"))) {
lSetUlong(*ar, AR_end_time, lGetUlong(ep, SPA_argval_lUlongT));
lRemoveElem(pcmdline, &ep);
}
/* -d time duration in TIME format SGE_ULONG */
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-d"))) {
lSetUlong(*ar, AR_duration, lGetUlong(ep, SPA_argval_lUlongT));
lRemoveElem(pcmdline, &ep);
}
/* -w e/v validate availability of AR request, default e SGE_ULONG */
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-w"))) {
lSetUlong(*ar, AR_verify, lGetInt(ep, SPA_argval_lIntT));
lRemoveElem(pcmdline, &ep);
}
/* -N name AR name SGE_STRING */
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-N"))) {
lSetString(*ar, AR_name, lGetString(ep, SPA_argval_lStringT));
lRemoveElem(pcmdline, &ep);
}
/* -A account_string AR name in accounting record SGE_STRING */
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-A"))) {
lSetString(*ar, AR_account, lGetString(ep, SPA_argval_lStringT));
lRemoveElem(pcmdline, &ep);
}
/* -l resource_list request the given resources SGE_LIST */
parse_list_simple(pcmdline, "-l", *ar, AR_resource_list, 0, 0, FLG_LIST_APPEND);
centry_list_remove_duplicates(lGetList(*ar, AR_resource_list));
/* -u wc_user access list SGE_LIST */
/* -u ! wc_user TBD: Think about eval_expression support in compare allowed and excluded lists */
parse_list_simple(pcmdline, "-u", *ar, AR_acl_list, ARA_name, 0, FLG_LIST_MERGE);
/* -u ! list separation */
lp = lGetList(*ar, AR_acl_list);
next_ep = lFirst(lp);
while ((ep = next_ep)) {
bool is_xacl = false;
const char *name = lGetString(ep, ARA_name);
next_ep = lNext(ep);
if (name[0] == '!') { /* move this element to xacl_list */
is_xacl = true;
name++;
}
if (!is_hgroup_name(name)) {
struct passwd *pw;
struct passwd pw_struct;
char *buffer;
int size;
stringT group;
size = get_pw_buffer_size();
buffer = sge_malloc(size);
pw = sge_getpwnam_r(name, &pw_struct, buffer, size);
if (pw == NULL) {
answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_USER_XISNOKNOWNUSER_S, name);
FREE(buffer);
DRETURN(false);
}
sge_gid2group(pw->pw_gid, group, MAX_STRING_SIZE, MAX_NIS_RETRIES);
lSetString(ep, ARA_group, group);
FREE(buffer);
}
if (is_xacl) {
lListElem *new_ep = lAddSubStr(*ar, ARA_name, name, AR_xacl_list, ARA_Type);
lSetString(new_ep, ARA_group, lGetString(ep, ARA_group));
lRemoveElem(lp, &ep);
}
}
/* -q wc_queue_list reserve in queue(s) SGE_LIST */
parse_list_simple(pcmdline, "-q", *ar, AR_queue_list, 0, 0, FLG_LIST_APPEND);
/* -pe pe_name slot_range reserve slot range for parallel jobs */
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-pe"))) {
lSetString(*ar, AR_pe, lGetString(ep, SPA_argval_lStringT)); /* SGE_STRING, */
lSwapList(*ar, AR_pe_range, ep, SPA_argval_lListT); /* SGE_LIST */
lRemoveElem(pcmdline, &ep);
}
/* AR_master_queue_list -masterq wc_queue_list, SGE_LIST bind master task to queue(s) */
parse_list_simple(pcmdline, "-masterq", *ar, AR_master_queue_list, 0, 0, FLG_LIST_APPEND);
/* -ckpt ckpt-name reserve in queue with ckpt method SGE_STRING */
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-ckpt"))) {
lSetString(*ar, AR_checkpoint_name, lGetString(ep, SPA_argval_lStringT));
lRemoveElem(pcmdline, &ep);
}
/* -m b/e/a/n define mail notification events SGE_ULONG */
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-m"))) {
u_long32 ul;
u_long32 old_mail_opts;
ul = lGetInt(ep, SPA_argval_lIntT);
if ((ul & NO_MAIL)) {
lSetUlong(*ar, AR_mail_options, 0);
} else {
old_mail_opts = lGetUlong(*ar, AR_mail_options);
lSetUlong(*ar, AR_mail_options, ul | old_mail_opts);
}
lRemoveElem(pcmdline, &ep);
}
/* -M user[@host],... notify these e-mail addresses SGE_LIST*/
parse_list_simple(pcmdline, "-M", *ar, AR_mail_list, MR_host, MR_user, FLG_LIST_MERGE);
/* -he yes/no hard error handling SGE_ULONG */
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-he"))) {
lSetUlong(*ar, AR_error_handling, lGetUlong(ep, SPA_argval_lUlongT));
lRemoveElem(pcmdline, &ep);
}
/* -now reserve in queues with qtype interactive SGE_ULONG */
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-now"))) {
u_long32 ar_now = lGetUlong(*ar, AR_type);
if(lGetInt(ep, SPA_argval_lIntT)) {
JOB_TYPE_SET_IMMEDIATE(ar_now);
} else {
JOB_TYPE_CLEAR_IMMEDIATE(ar_now);
}
lSetUlong(*ar, AR_type, ar_now);
lRemoveElem(pcmdline, &ep);
}
/* Remove the script elements. They are not stored in the ar structure */
if ((ep = lGetElemStr(pcmdline, SPA_switch, STR_PSEUDO_SCRIPT))) {
lRemoveElem(pcmdline, &ep);
}
if ((ep = lGetElemStr(pcmdline, SPA_switch, STR_PSEUDO_SCRIPTLEN))) {
lRemoveElem(pcmdline, &ep);
}
if ((ep = lGetElemStr(pcmdline, SPA_switch, STR_PSEUDO_SCRIPTPTR))) {
lRemoveElem(pcmdline, &ep);
}
ep = lFirst(pcmdline);
if(ep) {
const char *option = lGetString(ep,SPA_switch);
/* as jobarg are stored no switch values, need to be filtered */
if(sge_strnullcmp(option, "jobarg") != 0) {
answer_list_add_sprintf(alpp, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
MSG_PARSE_INVALIDOPTIONARGUMENTX_S,
lGetString(ep,SPA_switch));
} else {
answer_list_add_sprintf(alpp, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
MSG_PARSE_INVALIDOPTIONARGUMENT);
}
DRETURN(false);
}
if (lGetUlong(*ar, AR_start_time) == 0 && lGetUlong(*ar, AR_end_time) != 0 && lGetUlong(*ar, AR_duration) != 0) {
lSetUlong(*ar, AR_start_time, lGetUlong(*ar, AR_end_time) - lGetUlong(*ar, AR_duration));
} else if (lGetUlong(*ar, AR_start_time) != 0 && lGetUlong(*ar, AR_end_time) == 0 && lGetUlong(*ar, AR_duration) != 0) {
lSetUlong(*ar, AR_end_time, duration_add_offset(lGetUlong(*ar, AR_start_time), lGetUlong(*ar, AR_duration)));
lSetUlong(*ar, AR_duration, lGetUlong(*ar, AR_end_time) - lGetUlong(*ar, AR_start_time));
} else if (lGetUlong(*ar, AR_start_time) != 0 && lGetUlong(*ar, AR_end_time) != 0 && lGetUlong(*ar, AR_duration) == 0) {
lSetUlong(*ar, AR_duration, lGetUlong(*ar, AR_end_time) - lGetUlong(*ar, AR_start_time));
}
DRETURN(true);
}
/****** sge_c_report() *******************************************************
* NAME
* sge_c_report() -- process execd load report
*
* SYNOPSIS
* void sge_c_report(char *rhost, char *commproc, int id, lList *report_list)
*
* FUNCTION
*
* INPUTS
* char *rhost
* char *commproc
* int id
* lList *report_list
*
* RESULT
* void - nothing
*
* NOTES
* MT-NOTE: sge_c_report() is MT safe
*
******************************************************************************/
void sge_c_report(sge_gdi_ctx_class_t *ctx, char *rhost, char *commproc, int id, lList *report_list, monitoring_t *monitor)
{
lListElem *hep = NULL;
u_long32 rep_type;
lListElem *report;
int ret = 0;
u_long32 this_seqno, last_seqno;
u_long32 rversion;
sge_pack_buffer pb;
bool is_pb_used = false;
bool send_tag_new_conf = false;
DENTER(TOP_LAYER, "sge_c_report");
if (lGetNumberOfElem(report_list) == 0) {
DPRINTF(("received empty report\n"));
if (rhost != NULL) {
WARNING((SGE_EVENT, MSG_QMASTER_RECEIVED_EMPTY_LOAD_REPORT_S, rhost));
} else {
WARNING((SGE_EVENT, MSG_QMASTER_RECEIVED_EMPTY_LOAD_REPORT_S, "unknown"));
}
DRETURN_VOID;
}
/* accept reports only from execd's */
if (strcmp(prognames[EXECD], commproc)) {
ERROR((SGE_EVENT, MSG_GOTSTATUSREPORTOFUNKNOWNCOMMPROC_S, commproc));
DRETURN_VOID;
}
/* do not process load reports from old execution daemons */
rversion = lGetUlong(lFirst(report_list), REP_version);
if (verify_request_version(NULL, rversion, rhost, commproc, id)) {
DRETURN_VOID;
}
this_seqno = lGetUlong(lFirst(report_list), REP_seqno);
/* need exec host for all types of reports */
if (!(hep = host_list_locate(*object_type_get_master_list(SGE_TYPE_EXECHOST), rhost))) {
ERROR((SGE_EVENT, MSG_GOTSTATUSREPORTOFUNKNOWNEXECHOST_S, rhost));
DRETURN_VOID;
}
/* prevent old reports being proceeded
frequent loggings of outdated reports can be an indication
of too high message traffic arriving at qmaster */
last_seqno = lGetUlong(hep, EH_report_seqno);
if ((this_seqno < last_seqno && (last_seqno - this_seqno) <= 9000) &&
!(last_seqno > 9990 && this_seqno < 10)) {
/* this must be an old report, log and then ignore it */
INFO((SGE_EVENT, MSG_QMASTER_RECEIVED_OLD_LOAD_REPORT_UUS,
sge_u32c(this_seqno), sge_u32c(last_seqno), rhost));
DRETURN_VOID;
}
lSetUlong(hep, EH_report_seqno, this_seqno);
/* RU: */
/* tag all reschedule_unknown list entries we hope to
hear about in that job report */
update_reschedule_unknown_list(ctx, hep);
/*
** process the reports one after the other
** usually there will be a load report
** and a configuration version report
*/
for_each(report, report_list) {
rep_type = lGetUlong(report, REP_type);
switch (rep_type) {
case NUM_REP_REPORT_LOAD:
case NUM_REP_FULL_REPORT_LOAD:
MONITOR_ELOAD(monitor);
/* Now handle execds load reports */
if (lGetUlong(hep, EH_lt_heard_from) == 0 && rep_type != NUM_REP_FULL_REPORT_LOAD) {
host_notify_about_full_load_report(ctx, hep);
} else {
if (!is_pb_used) {
is_pb_used = true;
init_packbuffer(&pb, 1024, 0);
}
sge_update_load_values(ctx, rhost, lGetList(report, REP_list));
if (mconf_get_simulate_execds()) {
lList *master_exechost_list = *object_type_get_master_list(SGE_TYPE_EXECHOST);
lListElem *shep;
lListElem *simhostElem=NULL;
for_each(shep, master_exechost_list) {
simhostElem = lGetSubStr(shep, CE_name, "load_report_host", EH_consumable_config_list);
if (simhostElem != NULL) {
const char *real_host = lGetString(simhostElem, CE_stringval);
if (real_host != NULL && sge_hostcmp(real_host, rhost) == 0) {
const char* sim_host = lGetHost(shep, EH_name);
lListElem *clp = NULL;
DPRINTF(("Copy load values of %s to simulated host %s\n",
rhost, sim_host));
for_each(clp, lGetList(report, REP_list)) {
if (strcmp(lGetHost(clp, LR_host), SGE_GLOBAL_NAME) != 0) {
lSetHost(clp, LR_host, sim_host);
}
}
sge_update_load_values(ctx, sim_host, lGetList(report, REP_list));
}
}
}
}
pack_ack(&pb, ACK_LOAD_REPORT, this_seqno, 0, NULL);
}
break;
case NUM_REP_REPORT_CONF:
MONITOR_ECONF(monitor);
if (sge_compare_configuration(hep, lGetList(report, REP_list)) != 0) {
DPRINTF(("%s: configuration on host %s is not up to date\n", SGE_FUNC, rhost));
send_tag_new_conf = true;
}
break;
case NUM_REP_REPORT_PROCESSORS:
/*
** save number of processors
*/
MONITOR_EPROC(monitor);
ret = update_license_data(ctx, hep, lGetList(report, REP_list));
if (ret) {
ERROR((SGE_EVENT, MSG_LICENCE_ERRORXUPDATINGLICENSEDATA_I, ret));
}
break;
case NUM_REP_REPORT_JOB:
MONITOR_EJOB(monitor);
if (!is_pb_used) {
is_pb_used = true;
init_packbuffer(&pb, 1024, 0);
}
process_job_report(ctx, report, hep, rhost, commproc, &pb, monitor);
break;
default:
DPRINTF(("received invalid report type %ld\n", (long) rep_type));
}
/* return
0 reaped a task cleanly
1 no message (asynchronuous mode)
-1 got an error
NOTES
MT-NOTE: rcv_from_execd() is not MT safe
*/
static int rcv_from_execd(sge_gdi_ctx_class_t *ctx, int options, int tag)
{
int ret;
char *msg = NULL;
u_long32 msg_len = 0;
sge_pack_buffer pb;
u_short from_id;
char host[1024];
lListElem *rt_rcv;
u_long32 exit_status=0;
sge_tid_t tid = NULL;
DENTER(TOP_LAYER, "rcv_from_execd");
host[0] = '\0';
from_id = 1;
do {
/* FIX_CONST */
ret = gdi2_receive_message(ctx, (char*)prognames[EXECD], &from_id, host, &tag,
&msg, &msg_len, (options & OPT_SYNCHRON) ? 1:0);
if (ret != CL_RETVAL_OK && ret != CL_RETVAL_SYNC_RECEIVE_TIMEOUT) {
sprintf(lasterror, MSG_GDI_MESSAGERECEIVEFAILED_SI , cl_get_error_text(ret), ret);
DEXIT;
return -1;
}
} while (options&OPT_SYNCHRON && ret == CL_RETVAL_SYNC_RECEIVE_TIMEOUT);
if (ret==CL_RETVAL_SYNC_RECEIVE_TIMEOUT) {
DEXIT;
return 1;
}
ret = init_packbuffer_from_buffer(&pb, msg, msg_len);
if(ret != PACK_SUCCESS) {
sprintf(lasterror, MSG_GDI_ERRORUNPACKINGGDIREQUEST_S, cull_pack_strerror(ret));
DEXIT;
return -1;
}
switch (tag) {
case TAG_TASK_EXIT:
unpackstr(&pb, &tid);
unpackint(&pb, &exit_status);
break;
case TAG_JOB_EXECUTION:
unpackstr(&pb, &tid);
break;
default:
break;
}
clear_packbuffer(&pb);
switch (tag) {
case TAG_TASK_EXIT:
/* change state in exited task */
if (!(rt_rcv = lGetElemStr(remote_task_list, RT_tid,
tid))) {
sprintf(lasterror, MSG_GDI_TASKNOTFOUND_S, tid);
sge_free(&tid);
DEXIT;
return -1;
}
lSetUlong(rt_rcv, RT_status, exit_status);
lSetUlong(rt_rcv, RT_state, RT_STATE_EXITED);
break;
case TAG_JOB_EXECUTION:
/* search task without taskid */
if (!(rt_rcv = lGetElemStr(remote_task_list, RT_tid, "none"))) {
sprintf(lasterror, MSG_GDI_TASKNOTFOUNDNOIDGIVEN_S , tid);
DEXIT;
return -1;
}
lSetString(rt_rcv, RT_tid, tid);
break;
default:
break;
}
sge_free(&tid);
DEXIT;
return 0;
}
/****** sge_select_queue/is_attr_prior() ***************************************
* NAME
* is_attr_prior() -- compares two attribut instances with each other
*
* SYNOPSIS
* static bool is_attr_prior(lListElem *upper_el, lListElem *lower_el)
*
* FUNCTION
* checks if the first given attribut instance has a higher priority than
* second instance.
* if the first is NULL, it returns false
* if the second or the second and first is NULL, it returns true
* if the "==" or "!=" operators are used, it is true
* if both are the same, it may returns false.
* otherwise it computes the minimum or maximum between the values.
*
* INPUTS
* lListElem *upper_el - attribut, which should be overridden by the second one.
* lListElem *lower_el - attribut, which want to override the first one.
*
* RESULT
* static bool - true, when the first attribut has a higher priority.
*
*******************************************************************************/
bool is_attr_prior(lListElem *upper_el, lListElem *lower_el){
u_long32 relop;
bool ret;
double upper_value;
double lower_value;
u_long32 dom;
u_long32 used_dom;
u_long32 used_dom_val;
u_long32 used_dom_str;
u_long32 unused_dom_val;
u_long32 unused_dom_str;
u_long32 unused_dom;
DENTER(BASIS_LAYER, "is_attr_prior");
/* the order is important must not be changed */
if(!upper_el){
DRETURN(false);
}
if(!lower_el){
DRETURN(true);
}
relop = lGetUlong(upper_el, CE_relop);
if ((relop == CMPLXEQ_OP || relop == CMPLXNE_OP)) {
DRETURN(true);
}
/* if both elements are the same, than I can not say which one is more important */
if(upper_el == lower_el) {
DRETURN(false);
}
if ((dom = lGetUlong(upper_el, CE_pj_dominant)) == 0 || (dom & DOMINANT_TYPE_VALUE) ){
used_dom_val = CE_doubleval;
used_dom_str = CE_stringval;
used_dom = CE_dominant;
unused_dom_val = CE_pj_doubleval;
unused_dom_str= CE_pj_stringval;
unused_dom = CE_pj_dominant;
}
else {
used_dom_val = CE_pj_doubleval;
used_dom_str = CE_pj_stringval;
used_dom = CE_pj_dominant;
unused_dom_val = CE_doubleval;
unused_dom_str = CE_stringval;
unused_dom = CE_dominant;
}
if ((dom = lGetUlong(lower_el, used_dom)) == 0 || (dom & DOMINANT_TYPE_VALUE) ){
lSetDouble(lower_el, used_dom_val, lGetDouble(lower_el, unused_dom_val));
lSetString(lower_el, used_dom_str, lGetString(lower_el, unused_dom_str));
lSetUlong(lower_el, used_dom, lGetUlong(lower_el, unused_dom));
lSetUlong(lower_el, unused_dom, DOMINANT_TYPE_VALUE);
}
upper_value = lGetDouble(upper_el, used_dom_val);
lower_value = lGetDouble(lower_el, used_dom_val);
if (relop == CMPLXGE_OP || relop == CMPLXGT_OP ){
ret = upper_value >= lower_value ? true : false;
} else {
ret = upper_value <= lower_value ? true : false;
}
DRETURN(ret);
}
/****** gdi/sge/sge_qexecve() ************************************************
* NAME
* sge_qexecve() -- start a task in a tightly integrated par. job
*
* SYNOPSIS
* sge_tid_t sge_qexecve(const char *hostname, const char *queuename,
* const char *cwd, const lList *environment
* const lList *path_aliases)
*
* FUNCTION
* Starts a task in a tightly integrated job.
* Builds a job object describing the task,
* connects to the commd on the targeted execution host,
* deliveres the job object and waits for an answer.
* The answer from the execution daemon on the execution host
* contains a task id that is returned to the caller of the function.
*
* INPUTS
* const char *hostname - name of the host on which to start the task
* const lList *environment - list containing environment variable
* settings for the task that override the
* default environment
* const lList *path_aliases - optional a path alias list
*
* RESULT
* sge_tid_t - the task id, if the task can be executed,
* a value <= 0 indicates an error.
*
* NOTES
* MT-NOTE: sge_qexecve() is not MT safe
******************************************************************************/
sge_tid_t sge_qexecve(sge_gdi_ctx_class_t *ctx,
const char *hostname, const char *queuename,
const char *cwd, const lList *environment,
const lList *path_aliases)
{
char myname[256];
const char *s;
int ret, uid;
sge_tid_t tid = NULL;
lListElem *petrep;
lListElem *rt;
sge_pack_buffer pb;
u_long32 jobid, jataskid;
u_long32 dummymid = 0;
const char *env_var_name = "SGE_TASK_ID";
DENTER(TOP_LAYER, "sge_qexecve");
if (hostname == NULL) {
sprintf(lasterror, MSG_GDI_INVALIDPARAMETER_SS, "sge_qexecve", "hostname");
DRETURN(NULL);
}
/* resolve user */
if (sge_uid2user((uid=getuid()), myname, sizeof(myname)-1, MAX_NIS_RETRIES)) {
sprintf(lasterror, MSG_GDI_RESOLVINGUIDTOUSERNAMEFAILED_IS ,
uid, strerror(errno));
DRETURN(NULL);
}
if ((s=getenv("JOB_ID")) == NULL) {
sprintf(lasterror, MSG_GDI_MISSINGINENVIRONMENT_S, "JOB_ID");
DRETURN(NULL);
}
if (sscanf(s, sge_u32, &jobid) != 1) {
sprintf(lasterror, MSG_GDI_STRINGISINVALID_SS, s, "JOB_ID");
DRETURN(NULL);
}
if ((s=getenv(env_var_name)) != NULL) {
if (strcmp(s, "undefined") == 0) {
jataskid = 1;
} else {
if (sscanf(s, sge_u32, &jataskid) != 1) {
sprintf(lasterror, MSG_GDI_STRINGISINVALID_SS, s, env_var_name);
DRETURN(NULL);
}
}
} else {
sprintf(lasterror, MSG_GDI_MISSINGINENVIRONMENT_S, env_var_name);
DRETURN(NULL);
}
/* ---- build up pe task request structure (see gdilib/sge_petaskL.h) */
petrep = lCreateElem(PETR_Type);
lSetUlong(petrep, PETR_jobid, jobid);
lSetUlong(petrep, PETR_jataskid, jataskid);
lSetString(petrep, PETR_owner, myname);
lSetUlong(petrep, PETR_submission_time, sge_get_gmt());
if (cwd != NULL) {
lSetString(petrep, PETR_cwd, cwd);
}
if (environment != NULL) {
lSetList(petrep, PETR_environment, lCopyList("environment", environment));
}
if (path_aliases != NULL) {
lSetList(petrep, PETR_path_aliases, lCopyList("path_aliases", path_aliases));
}
if (queuename != NULL) {
lSetString(petrep, PETR_queuename, queuename);
}
if (init_packbuffer(&pb, 1024, 0) != PACK_SUCCESS) {
lFreeElem(&petrep);
sprintf(lasterror, SFNMAX, MSG_GDI_OUTOFMEMORY);
DRETURN(NULL);
}
pack_job_delivery(&pb, petrep);
ret = gdi2_send_message_pb(ctx, 1, prognames[EXECD], 1, hostname,
TAG_JOB_EXECUTION, &pb, &dummymid);
clear_packbuffer(&pb);
lFreeElem(&petrep);
if (ret != CL_RETVAL_OK) {
sprintf(lasterror, MSG_GDI_SENDTASKTOEXECDFAILED_SS, hostname, cl_get_error_text(ret));
DRETURN(NULL);
}
/* add list into our remote task list */
rt = lAddElemStr(&remote_task_list, RT_tid, "none", RT_Type);
lSetHost(rt, RT_hostname, hostname);
lSetUlong(rt, RT_state, RT_STATE_WAIT4ACK);
rcv_from_execd(ctx, OPT_SYNCHRON, TAG_JOB_EXECUTION);
tid = (sge_tid_t) lGetString(rt, RT_tid);
if (strcmp(tid, "none") == 0) {
tid = NULL;
sprintf(lasterror, MSG_GDI_EXECDONHOSTDIDNTACCEPTTASK_S, hostname);
}
/* now close message to execd */
cl_commlib_shutdown_handle(cl_com_get_handle("execd_handle", 0), false);
DRETURN(tid);
}
/************************************************************************
Master routine for job exit
We need a rusage struct filled.
In normal cases this is done by the execd, sending this structure
to notify master about job finish.
In case of an error noticed by the master which needs the job to be
removed we can fill this structure by hand. We need:
rusage->job_number
rusage->qname to clean up the queue (if we didn't find it we nevertheless
clean up the job
for functions regarding rusage see sge_rusage.c
************************************************************************/
void sge_job_exit(sge_gdi_ctx_class_t *ctx, lListElem *jr, lListElem *jep, lListElem *jatep, monitoring_t *monitor)
{
lListElem *queueep = NULL;
const char *err_str = NULL;
const char *qname = NULL;
const char *hostname = MSG_OBJ_UNKNOWNHOST;
u_long32 jobid, jataskid;
lListElem *hep = NULL;
u_long32 timestamp;
object_description *object_base = object_type_get_object_description();
u_long32 failed, general_failure;
lList *saved_gdil;
DENTER(TOP_LAYER, "sge_job_exit");
/* JG: TODO: we'd prefer some more precise timestamp, e.g. from jr */
timestamp = sge_get_gmt();
qname = lGetString(jr, JR_queue_name);
if (qname == NULL) {
qname = (char *)MSG_OBJ_UNKNOWNQ;
}
err_str = lGetString(jr, JR_err_str);
if (err_str == NULL) {
err_str = MSG_UNKNOWNREASON;
}
jobid = lGetUlong(jr, JR_job_number);
jataskid = lGetUlong(jr, JR_ja_task_number);
failed = lGetUlong(jr, JR_failed);
general_failure = lGetUlong(jr, JR_general_failure);
cancel_job_resend(jobid, jataskid);
/* This only has a meaning for Hibernator jobs. The job pid must
* be saved accross restarts, since jobs get their old pid
*/
lSetUlong(jatep, JAT_pvm_ckpt_pid, lGetUlong(jr, JR_job_pid));
DPRINTF(("reaping job "sge_u32"."sge_u32" in queue >%s< job_pid %d\n",
jobid, jataskid, qname, (int) lGetUlong(jatep, JAT_pvm_ckpt_pid)));
queueep = cqueue_list_locate_qinstance(*object_base[SGE_TYPE_CQUEUE].list, qname);
if (queueep == NULL) {
ERROR((SGE_EVENT, MSG_JOB_WRITEJFINISH_S, qname));
}
sge_job_remove_enforce_limit_trigger(jobid, jataskid);
/* retrieve hostname for later use */
if (queueep != NULL) {
hostname = lGetHost(queueep, QU_qhostname);
}
if (failed) { /* a problem occured */
WARNING((SGE_EVENT, MSG_JOB_FAILEDONHOST_UUSSSS, sge_u32c(jobid),
sge_u32c(jataskid),
hostname,
general_failure ? MSG_GENERAL : "",
get_sstate_description(failed), err_str));
} else {
INFO((SGE_EVENT, MSG_JOB_JFINISH_UUS, sge_u32c(jobid), sge_u32c(jataskid), hostname));
}
/*-------------------------------------------------*/
/* test if this job is in state JRUNNING or JTRANSFERING */
if (lGetUlong(jatep, JAT_status) != JRUNNING &&
lGetUlong(jatep, JAT_status) != JTRANSFERING) {
ERROR((SGE_EVENT, MSG_JOB_JEXITNOTRUN_UU, sge_u32c(lGetUlong(jep, JB_job_number)), sge_u32c(jataskid)));
DRETURN_VOID;
}
saved_gdil = lCopyList("cpy", lGetList(jatep, JAT_granted_destin_identifier_list));
/*
* case 1: job being trashed because
* --> failed starting interactive job
* --> job was deleted
* --> a failed batch job that explicitely shall not enter error state
*/
if (((lGetUlong(jatep, JAT_state) & JDELETED) == JDELETED) ||
(failed && !lGetString(jep, JB_exec_file)) ||
(failed && general_failure==GFSTATE_JOB && JOB_TYPE_IS_NO_ERROR(lGetUlong(jep, JB_type)))) {
reporting_create_acct_record(ctx, NULL, jr, jep, jatep, false);
/* JG: TODO: we need more information in the log message */
reporting_create_job_log(NULL, timestamp, JL_DELETED, MSG_EXECD, hostname, jr, jep, jatep, NULL, MSG_LOG_JREMOVED);
sge_commit_job(ctx, jep, jatep, jr, COMMIT_ST_FINISHED_FAILED_EE, COMMIT_DEFAULT | COMMIT_NEVER_RAN, monitor);
if (lGetUlong(jep, JB_ar) != 0 && (lGetUlong(jatep, JAT_state) & JDELETED) == JDELETED) {
/* get AR and remove it if no other jobs are debited */
lList *master_ar_list = *object_base[SGE_TYPE_AR].list;
lListElem *ar = ar_list_locate(master_ar_list, lGetUlong(jep, JB_ar));
if (ar != NULL && lGetUlong(ar, AR_state) == AR_DELETED) {
lListElem *ar_queue;
u_long32 ar_id = lGetUlong(ar, AR_id);
for_each(ar_queue, lGetList(ar, AR_reserved_queues)) {
if (qinstance_slots_used(ar_queue) != 0) {
break;
}
}
if (ar_queue == NULL) {
/* no jobs registered in advance reservation */
dstring buffer = DSTRING_INIT;
sge_dstring_sprintf(&buffer, sge_U32CFormat,
sge_u32c(ar_id));
ar_do_reservation(ar, false);
reporting_create_ar_log_record(NULL, ar, ARL_DELETED,
"AR deleted",
timestamp);
reporting_create_ar_acct_records(NULL, ar, timestamp);
lRemoveElem(master_ar_list, &ar);
sge_event_spool(ctx, NULL, 0, sgeE_AR_DEL,
ar_id, 0, sge_dstring_get_string(&buffer), NULL, NULL,
NULL, NULL, NULL, true, true);
sge_dstring_free(&buffer);
}
}
/************************************************************
sge_mod_sharetree - Master code
Modify a share tree
lListElem *ep, This is the new share tree
lList **lpp, list to change
************************************************************/
int sge_mod_sharetree(sge_gdi_ctx_class_t *ctx,
lListElem *ep, lList **lpp, lList **alpp,
char *ruser, char *rhost )
{
int ret;
int prev_version;
int adding;
lList *found = NULL;
object_description *object_base = object_type_get_object_description();
DENTER(TOP_LAYER, "sge_mod_sharetree");
/* do some checks */
if (!ep || !ruser || !rhost) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_NULLPTRPASSED_S, SGE_FUNC));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DEXIT;
return STATUS_EUNKNOWN;
}
ret = check_sharetree(alpp, ep, *object_base[SGE_TYPE_USER].list,
*object_base[SGE_TYPE_PROJECT].list,
NULL, &found);
lFreeList(&found);
if (ret) {
/* alpp gets filled by check_sharetree() */
DRETURN(STATUS_EUNKNOWN);
}
/* check for presence of sharetree list and create if neccesary */
if (!*lpp) {
prev_version = 0;
*lpp = lCreateList("sharetree list", STN_Type);
adding = 1;
} else if (lGetNumberOfElem(*lpp) == 0) {
prev_version = 0;
adding = 1;
} else {
lListElem *first = lFirst(*lpp);
/* real action: change user or project
We simply replace the old element with the new one. If there is no
old we simle add the new. */
prev_version = lGetUlong(lFirst(*lpp), STN_version);
lRemoveElem(*lpp, &first);
adding = 0;
}
lSetUlong(ep, STN_version, prev_version+1);
id_sharetree(alpp, ep, 0, NULL);
/* now insert new element */
lAppendElem(*lpp, lCopyElem(ep));
/* write sharetree to file */
if (!sge_event_spool(ctx,
alpp, 0, sgeE_NEW_SHARETREE,
0, 0, NULL, NULL, NULL,
ep, NULL, NULL, true, true)) {
/* answer list gets filled in sge_event_spool() */
DEXIT;
return ret;
}
if (adding) {
INFO((SGE_EVENT, MSG_STREE_ADDSTREE_SSII,
ruser, rhost, lGetNumberOfNodes(ep, NULL, STN_children), lGetNumberOfLeafs(ep, NULL, STN_children)));
} else {
INFO((SGE_EVENT, MSG_STREE_MODSTREE_SSII,
ruser, rhost, lGetNumberOfNodes(ep, NULL, STN_children), lGetNumberOfLeafs(ep, NULL, STN_children)));
}
answer_list_add(alpp, SGE_EVENT, STATUS_OK, ANSWER_QUALITY_INFO);
DEXIT;
return STATUS_OK;
}
/*-------------------------------------------------------------------------*/
lList* qmonGetNxN(
Widget w,
lDescr *dp,
int num_fields,
...
) {
lList *lp = NULL;
lListElem *ep;
int i, row;
int max_rows;
va_list ap;
char **col;
int *field;
DENTER(GUI_LAYER, "qmonGetNxN");
field = malloc(num_fields*sizeof(int));
col = malloc(num_fields*sizeof(char *));
if (field == NULL || col == NULL)
abort();
va_start(ap, num_fields);
for(i=0; i<num_fields; i++)
field[i] = va_arg(ap, int);
XtVaGetValues(w, XmNrows, &max_rows, NULL);
for (row=0; row<max_rows; row++)
{
memset(col, 0, num_fields*sizeof(char *));
for(i=0; i<num_fields; i++)
col[i] = XbaeMatrixGetCell(w, row, i);
if (col[0] && col[0][0] != '\0')
{
if (!lp)
lp = lCreateList(XtName(w), dp);
ep = lCreateElem(dp);
lAppendElem(lp, ep);
/*
* retrieve values from columns
*/
for(i=0; i<num_fields; i++)
{
switch(lGetType(lGetListDescr(lp), field[i]))
{
case lStringT:
lSetString(ep, field[i], col[i] ? col[i] : "" );
break;
case lHostT:
lSetHost(ep, field[i], col[i] ? col[i] : "");
break;
case lUlongT:
lSetUlong(ep, field[i], col[i] ? atoi(col[i]) : 0);
break;
case lDoubleT:
lSetDouble(ep, field[i], col[i] ? atof(col[i]) : 0.0);
break;
}
}
}
else
continue;
}
va_end(ap);
free(field);
free(col);
DEXIT;
return lp;
}
/*-------------------------------------------------------------------------*/
static Boolean setCE_TypeValues(
lListElem *ep,
String *ce_entry
) {
int i, type, relop;
u_long32 requestable = REQU_NO;
DENTER(GUI_LAYER, "setCE_TypeValues");
if (!ep) {
DEXIT;
return False;
}
/* name type relation value */
lSetString(ep, CE_name, ce_entry[CE_NAME] ? qmon_trim(ce_entry[CE_NAME]): "");
lSetString(ep, CE_shortcut, ce_entry[CE_SHORTCUT] ? qmon_trim(ce_entry[CE_SHORTCUT]): "" );
type = 0;
for (i=TYPE_FIRST; !type && i<=TYPE_CE_LAST; i++) {
if (!strcasecmp(ce_entry[CE_TYPE], map_type2str(i)))
type = i;
}
if (!type) {
DPRINTF(("setCE_TypeValues: unknown type\n"));
DEXIT;
return False;
}
lSetUlong(ep, CE_valtype, type);
relop = 0;
for (i=CMPLXEQ_OP; !relop && i<=CMPLXEXCL_OP; i++) {
if (!strcmp(ce_entry[CE_RELOP], map_op2str(i)))
relop = i;
}
if (!relop) {
DPRINTF(("invalid relation operator: %s\n", ce_entry[CE_RELOP]));
DEXIT;
return False;
}
lSetUlong(ep, CE_relop, relop);
if (!strcasecmp(ce_entry[CE_REQUEST], "y")
|| !strcasecmp(ce_entry[CE_REQUEST], "yes"))
requestable = REQU_YES;
else if (!strcasecmp(ce_entry[CE_REQUEST], "n")
|| !strcasecmp(ce_entry[CE_REQUEST], "no"))
requestable = REQU_NO;
else if (!strcasecmp(ce_entry[CE_REQUEST], "f")
|| !strcasecmp(ce_entry[CE_REQUEST], "forced")) {
requestable = REQU_FORCED;
}
else {
DPRINTF(("invalid requestable entry: %s\n", ce_entry[CE_REQUEST]));
}
lSetUlong(ep, CE_requestable, requestable);
if (!strcasecmp(ce_entry[CE_CONSUMABLE], "y")
|| !strcasecmp(ce_entry[CE_CONSUMABLE], "yes"))
lSetUlong(ep, CE_consumable, 1);
else if (!strcasecmp(ce_entry[CE_CONSUMABLE], "j")
|| !strcasecmp(ce_entry[CE_CONSUMABLE], "job"))
lSetUlong(ep, CE_consumable, 2);
else if (!strcasecmp(ce_entry[CE_CONSUMABLE], "n")
|| !strcasecmp(ce_entry[CE_CONSUMABLE], "no"))
lSetUlong(ep, CE_consumable, 0);
lSetString(ep, CE_default, ce_entry[CE_DEFAULT] ? qmon_trim(ce_entry[CE_DEFAULT]): "");
lSetString(ep, CE_urgency_weight, ce_entry[CE_URGENCY] ? qmon_trim(ce_entry[CE_URGENCY]): "");
DEXIT;
return True;
}
/*-------------------------------------------------------------------------*/
lList* qmonGet2xN(
Widget w,
lDescr *dp,
int field1,
int field2
) {
lList *lp = NULL;
lListElem *ep;
int row;
int max_rows;
char *col1, *col2;
DENTER(GUI_LAYER, "qmonGet2xN");
XtVaGetValues(w, XmNrows, &max_rows, NULL);
for (row=0; row<max_rows; row++) {
col1 = XbaeMatrixGetCell(w, row, 0);
col2 = XbaeMatrixGetCell(w, row, 1);
if (col1 && col1[0] != '\0') {
if (!lp)
lp = lCreateList(XtName(w), dp);
ep = lCreateElem(dp);
lAppendElem(lp, ep);
/*
** the first field in the column can be host or string
*/
switch(lGetType(lGetListDescr(lp), field1)) {
case lStringT:
lSetString(ep, field1, col1 ? col1 : "");
break;
case lHostT:
lSetHost(ep, field1, col1 ? col1 : "");
break;
}
/*
** the second field can be of different type
*/
switch(lGetType(lGetListDescr(lp), field2)) {
case lStringT:
lSetString(ep, field2, col2 ? col2 : "" );
break;
case lHostT:
lSetHost(ep, field2, col2 ? col2 : "");
break;
case lUlongT:
lSetUlong(ep, field2, col2 ? atoi(col2) : 0);
break;
case lDoubleT:
lSetDouble(ep, field2, col2 ? atof(col2) : 0.0);
break;
}
}
else
continue;
}
DEXIT;
return lp;
}
int do_qhost(void *ctx, lList *host_list, lList *user_list, lList *resource_match_list,
lList *resource_list, u_long32 show, lList **alpp, qhost_report_handler_t* report_handler) {
lList *cl = NULL;
lList *ehl = NULL;
lList *ql = NULL;
lList *jl = NULL;
lList *pel = NULL;
lListElem *ep;
lCondition *where = NULL;
bool have_lists = true;
int print_header = 1;
int ret = QHOST_SUCCESS;
bool show_binding = ((show & QHOST_DISPLAY_BINDING) == QHOST_DISPLAY_BINDING) ? true : false;
#define HEAD_FORMAT_BINDING "%-23s %-13.13s%4.4s %4.4s %4.4s %5.5s %7.7s %7.7s %7.7s %7.7s\n"
#define HEAD_FORMAT "%-23s %-13.13s%4.4s %5.5s %7.7s %7.7s %7.7s %7.7s\n"
DENTER(TOP_LAYER, "do_qhost");
have_lists = get_all_lists(ctx,
alpp,
&ql,
&jl,
&cl,
&ehl,
&pel,
host_list,
user_list,
show);
if (have_lists == false) {
free_all_lists(&ql, &jl, &cl, &ehl, &pel);
DRETURN(QHOST_ERROR);
}
/*
** delete ok message
*/
lFreeList(alpp);
centry_list_init_double(cl);
/*
** handle -l request for host
*/
if (lGetNumberOfElem(resource_match_list)) {
int selected;
lListElem *global = NULL;
if (centry_list_fill_request(resource_match_list, alpp, cl, true, true, false)) {
/* TODO: error message gets written by centry_list_fill_request into SGE_EVENT */
free_all_lists(&ql, &jl, &cl, &ehl, &pel);
DRETURN(QHOST_ERROR);
}
{ /* clean host list */
lListElem *host = NULL;
for_each(host, ehl) {
lSetUlong(host, EH_tagged, 0);
}
}
/* prepare request */
global = lGetElemHost(ehl, EH_name, "global");
selected = sge_select_queue(resource_match_list, NULL, global, ehl, cl,
true, -1, NULL, NULL, NULL);
if (selected) {
for_each(ep, ehl) {
lSetUlong(ep, EH_tagged, 1);
}
} else {
/*-------------------------------------------------------------------------*/
static Boolean qmonSchedGet(lListElem *sep) {
int job_info;
lList *alp = NULL;
String str;
char buf[BUFSIZ];
DENTER(GUI_LAYER, "qmonSchedGet");
if (!sep) {
goto error_exit;
}
/*
** get entries from dialog
*/
XmtDialogGetDialogValues(qmon_sconf, &data);
/**
printf("<-data.algorithm: '%s'\n", data.algorithm ? data.algorithm : "-NA-");
printf("<-data.schedule_interval: '%s'\n", data.schedule_interval ? data.schedule_interval : "-NA-");
printf("<-data.sc_params: '%s'\n", data.sc_params ? data.sc_params : "-NA-");
printf("<-data.maxujobs: '%d'\n", data.maxujobs );
printf("<-data.flush_submit_secs: '%d'\n", data.flush_submit_secs );
printf("<-data.flush_finish_secs: '%d'\n", data.flush_finish_secs );
printf("<-data.max_reservation: '%d'\n", data.max_reservation );
printf("<-data.queue_sort_method: '%d'\n", data.queue_sort_method );
printf("<-data.load_adjustment_decay_time: '%s'\n", data.load_adjustment_decay_time ? data.load_adjustment_decay_time : "-NA-");
printf("<-data.load_formula: '%s'\n", data.load_formula ? data.load_formula : "-NA-");
**/
if (!data.algorithm || data.algorithm[0] == '\0') {
qmonMessageShow(qmon_sconf, True, "@{Algorithm required!}");
goto error_exit;
}
lSetString(sep, SC_algorithm, data.algorithm);
if (!data.schedule_interval || data.schedule_interval[0] == '\0') {
qmonMessageShow(qmon_sconf, True, "@{Schedule Interval required!}");
goto error_exit;
}
lSetString(sep, SC_schedule_interval, data.schedule_interval);
lSetString(sep, SC_params, data.sc_params);
lSetUlong(sep, SC_maxujobs, (u_long32) data.maxujobs);
lSetUlong(sep, SC_flush_submit_sec, (u_long32) data.flush_submit_secs);
lSetUlong(sep, SC_flush_finish_sec, (u_long32) data.flush_finish_secs);
lSetUlong(sep, SC_max_reservation, (u_long32) data.max_reservation);
lSetUlong(sep, SC_queue_sort_method, (u_long32) data.queue_sort_method);
/*
** load adjustments need special treatment
*/
lSetList(sep, SC_job_load_adjustments, data.job_load_adjustments);
data.job_load_adjustments = NULL;
if (!data.load_adjustment_decay_time ||
data.load_adjustment_decay_time[0] == '\0') {
qmonMessageShow(qmon_sconf, True, "@{Load Adjustment Decay Time required!}");
goto error_exit;
}
lSetString(sep, SC_load_adjustment_decay_time,
data.load_adjustment_decay_time);
if (!data.load_formula || data.load_formula[0] == '\0') {
qmonMessageShow(qmon_sconf, True, "@{Load Formula required!}");
goto error_exit;
}
lSetString(sep, SC_load_formula, data.load_formula);
if (!data.reprioritize_interval||
data.reprioritize_interval[0] == '\0') {
qmonMessageShow(qmon_sconf, True, "@{Reprioritize Interval required!}");
goto error_exit;
}
lSetString(sep, SC_reprioritize_interval, data.reprioritize_interval);
if (!data.default_duration||
data.default_duration[0] == '\0') {
qmonMessageShow(qmon_sconf, True, "@{Default duration required!}");
goto error_exit;
}
lSetString(sep, SC_default_duration, data.default_duration);
/*
** schedd_job_info needs some extras
** see comment for schedd_job_info in qmonScheddSet
*/
job_info = XmtChooserGetState(sconf_job_info);
switch (job_info) {
case 0:
lSetString(sep, SC_schedd_job_info, "false");
break;
case 1:
lSetString(sep, SC_schedd_job_info, "true");
break;
case 2:
str = XmtInputFieldGetString(sconf_job_range);
{
lList *range_list = NULL;
range_list_parse_from_string(&range_list, &alp, str,
1, 0, INF_NOT_ALLOWED);
lFreeList(&range_list);
}
if (alp) {
qmonMessageShow(sconf_job_range, True, (StringConst)lGetString(lFirst(alp), AN_text));
lFreeList(&alp);
goto error_exit;
}
if (str && str[0] != '\0') {
strcpy(buf, "job_list ");
strcat(buf, str);
lSetString(sep, SC_schedd_job_info, buf);
}
else {
qmonMessageShow(qmon_sconf, True, "@{Job Range required!}");
goto error_exit;
}
}
/* printf("------> qmonSchedGet\n"); */
/* lWriteElemTo(sep, stdout); */
qmonSchedFreeData();
DRETURN(True);
error_exit:
qmonSchedFreeData();
DRETURN(False);
}
