static void schedd_mes_find_others(lListElem *tmp_sme, lList *job_list, int ignore_category)
{
if (tmp_sme && job_list) {
lListElem *message_elem = NULL; /* MES_Type */
lRef category = NULL; /* Category pointer (void*) */
lList *jid_cat_list = NULL; /* ULNG */
lList *message_list = lGetList(tmp_sme, SME_message_list);
/*
* Here we have a list of message elements where each
* MES_job_number_list contains only one id.
* We have to find the other jobs (jids) which have the same category.
*/
for_each(message_elem, message_list) {
lList *jid_list = lGetList(message_elem, MES_job_number_list);
u_long32 jid;
lRef jid_category;
jid = lGetUlong(lFirst(jid_list), ULNG_value);
jid_category = schedd_mes_get_category(jid, job_list);
/*
* Initialize jid_cat_list if not initialized
* or if category differs from the last run
*/
if (category != jid_category || ignore_category) {
jid_cat_list = schedd_mes_get_same_category_jids(jid_category,
job_list,
ignore_category);
category = jid_category;
lSetList(message_elem, MES_job_number_list, jid_cat_list);
} else {
lSetList(message_elem, MES_job_number_list,
lCopyList("", jid_cat_list));
}
}
void xml_addAttribute(lListElem *xml_elem, const char *name, const char *value) {
lListElem *attr_elem = lCreateElem(XMLA_Type);
lList *attr_list = NULL;
dstring mod_value = DSTRING_INIT;
bool is_mod_value;
DENTER(CULL_LAYER, "xml_addAttribute");
is_mod_value = escape_string(value, &mod_value);
if (attr_elem) {
lSetString(attr_elem, XMLA_Name, name);
lSetString(attr_elem, XMLA_Value, (is_mod_value?sge_dstring_get_string(&mod_value):""));
if (lGetPosViaElem(xml_elem, XMLH_Attribute, SGE_NO_ABORT) != -1) {
attr_list = lGetList(xml_elem, XMLH_Attribute);
if (!attr_list)
lSetList(xml_elem, XMLH_Attribute, (attr_list = lCreateList("Attributes", XMLA_Type)));
}
else if (lGetPosViaElem(xml_elem, XMLE_Attribute, SGE_NO_ABORT) != -1) {
attr_list = lGetList(xml_elem, XMLE_Attribute);
if (!attr_list)
lSetList(xml_elem, XMLE_Attribute, (attr_list = lCreateList("Attributes", XMLA_Type)));
}
else {
sge_dstring_free(&mod_value);
CRITICAL((SGE_EVENT, "xml_addAttribute() called on wrong cull structure"));
DEXIT;
abort();
}
lAppendElem(attr_list, attr_elem);
}
sge_dstring_free(&mod_value);
DEXIT;
return;
}
static lList *test_create_rqs(void)
{
lList* rqs_list = lCreateList("my_rqs", RQS_Type);
lListElem* rqs;
lList* rule_list;
lListElem* rule;
lListElem* filter;
lListElem* limit;
lList * limit_list;
rqs = lCreateElem(RQS_Type);
lSetString(rqs, RQS_name, "Test_Name1");
lSetBool(rqs, RQS_enabled, true);
rule_list = lCreateList("Rule_List", RQR_Type);
rule = lCreateElem(RQR_Type);
filter = lCreateElem(RQRF_Type);
lSetBool(filter, RQRF_expand, true);
lAddSubStr(filter, ST_name, "rqs_user", RQRF_scope, ST_Type);
lSetObject(rule, RQR_filter_users, filter);
limit_list = lCreateList("limit_list", RQRL_Type);
limit = lCreateElem(RQRL_Type);
lSetString(limit, RQRL_name, "slots");
lSetString(limit, RQRL_value, "2*$num_proc");
lAppendElem(limit_list, limit);
lSetList(rule, RQR_limit, limit_list);
lAppendElem(rule_list, rule);
lSetList(rqs, RQS_rule, rule_list);
lAppendElem(rqs_list, rqs);
return rqs_list;
}
int main(int argc, char **argv) {
/* lListElem *rep, *nxt_rep, *jep, *aep, *jrep, *idep; */
int ret = 0;
lListElem *aep, *idep;
lList *jlp = NULL, *alp = NULL, *pcmdline = NULL, *ref_list = NULL, *user_list=NULL;
u_long32 force = 0;
int wait;
unsigned long status = 0;
bool have_master_privileges;
cl_com_handle_t* handle = NULL;
sge_gdi_ctx_class_t *ctx = NULL;
DENTER_MAIN(TOP_LAYER, "qdel");
log_state_set_log_gui(1);
if (sge_gdi2_setup(&ctx, QDEL, MAIN_THREAD, &alp) != AE_OK) {
answer_list_output(&alp);
goto error_exit;
}
if (!sge_parse_cmdline_qdel(++argv, environ, &pcmdline, &alp)) {
/*
** high level parsing error! show answer list
*/
answer_list_output(&alp);
lFreeList(&pcmdline);
goto error_exit;
}
if (!sge_parse_qdel(&pcmdline, &ref_list, &force, &user_list, &alp)) {
/*
** low level parsing error! show answer list
*/
answer_list_output(&alp);
lFreeList(&pcmdline);
goto error_exit;
}
DPRINTF(("force = "sge_u32"\n", force));
if (user_list) {
lListElem *id;
if (lGetNumberOfElem(ref_list) == 0){
id = lAddElemStr(&ref_list, ID_str, "0", ID_Type);
lSetList(id, ID_user_list, user_list);
} else {
for_each(id, ref_list){
lSetList(id, ID_user_list, user_list);
}
}
}
/****** test_category/test_create_pe() *****************************************
* NAME
* test_create_pe() -- adds a pe object to the job
*
* SYNOPSIS
* void test_create_pe(const char *peStr, lListElem *job_elem)
*
* INPUTS
* const char *peStr - string representation of the pe object
* lListElem *job_elem - job object
*
* NOTES
* MT-NOTE: test_create_pe() is MT safe
*
*******************************************************************************/
static void test_create_pe(const char *peStr, lListElem *job_elem)
{
lList *range= NULL;
char *pe_cp = strdup(peStr);
char *iter_dash = NULL;
char *pe_str;
for (pe_str = strtok_r(pe_cp, " ", &iter_dash); pe_str; pe_str= strtok_r(NULL, " ", &iter_dash)) {
lSetString(job_elem, JB_pe, pe_str);
pe_str= strtok_r(NULL, " ", &iter_dash);
range_list_parse_from_string(&range, NULL, pe_str, false, false, INF_ALLOWED);
if (range != NULL) {
lSetList(job_elem, JB_pe_range, range);
}
else {
lSetString(job_elem, JB_pe, NULL);
printf("error generating pe object: %s\n", peStr);
}
}
if (pe_cp != NULL) {
sge_free(&pe_cp);
}
}
/****** 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;
}
lListElem* xml_getHead(const char *name, lList *list, lList *attributes) {
lListElem *xml_head = NULL;
xml_head = lCreateElem(XMLH_Type);
if (xml_head) {
lSetString(xml_head, XMLH_Version, "<?xml version='1.0'?>");
lSetString(xml_head, XMLH_Name, name);
lSetList(xml_head, XMLH_Attribute, attributes);
lSetList(xml_head, XMLH_Element, list);
xml_addAttribute(xml_head, "xmlns:xsd", "http://gridengine.sunsource.net/source/browse/*checkout*/gridengine/source/dist/util/resources/schemas/qstat/qstat.xsd?revision=1.11");
/* we do not support stylesheets yet */
/* xml_addStylesheet(xml_head, "xmlns:xsl", "http://www.w3.org/1999/XSL/Transform", "1.0");*/
}
return xml_head;
}
lList *buildComplexList(void)
{
lList *complexlist = NULL;
lListElem *complex;
/* It is better to test every list for its existence (list != NULL) */
complexlist = lCreateList("complexlist", ComplexT);
complex = lCreateElem(ComplexT);
lSetString(complex, C_name, "default");
lSetList(complex, C_attribute, readComplexFile("default"));
lAppendElem(complexlist, complex);
complex = lCreateElem(ComplexT);
lSetString(complex, C_name, "software");
lSetList(complex, C_attribute, readComplexFile("software"));
lAppendElem(complexlist, complex);
return complexlist;
}
/******* 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);
}
void xml_addStylesheet(lListElem *xml_head, const char* name, const char *url, const char *version) {
lListElem *stylesheet_elem = lCreateElem(XMLS_Type);
lList *stylesheet_list = NULL;
if (stylesheet_elem) {
lSetString(stylesheet_elem, XMLS_Name, name);
lSetString(stylesheet_elem, XMLS_Value, url);
lSetString(stylesheet_elem, XMLS_Version, version);
stylesheet_list = lGetList(xml_head, XMLH_Stylesheet);
if (!stylesheet_list)
lSetList(xml_head, XMLH_Stylesheet, (stylesheet_list = lCreateList("Stylesheet", XMLS_Type)));
lAppendElem(stylesheet_list, stylesheet_elem);
}
}
lList *buildQueueList(void)
{
lList *queuelist = NULL;
lListElem *element;
queuelist = lCreateList("queuelist", QueueT);
element = lCreateElem(QueueT);
lSetString(element, Q_name, "balin.q");
lSetList(element, Q_complexname, buildComplexNameListA());
lAppendElem(queuelist, element);
element = lCreateElem(QueueT);
lSetString(element, Q_name, "durin.q");
lSetList(element, Q_complexname, buildComplexNameListB());
lAppendElem(queuelist, element);
element = lCreateElem(QueueT);
lSetString(element, Q_name, "gloin.q");
lSetList(element, Q_complexname, buildComplexNameListC());
lAppendElem(queuelist, element);
return queuelist;
}
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);
}
}
}
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;
}
/****** test_category/test_create_access() *************************************
* NAME
* test_create_access() -- creates an access list from AccessList
*
* SYNOPSIS
* lList* test_create_access()
*
* RESULT
* lList* - NULL or valid acces list
*
* NOTES
* MT-NOTE: test_create_access() is not MT safe
*
*******************************************************************************/
static lList *test_create_access(void)
{
lList *access_list = NULL;
access_list = lCreateList("access", US_Type);
if (access_list != NULL) {
int i;
for (i = 0; AccessList[i] != NULL; i++) {
char *access_cp = NULL;
char *access_str = NULL;
char *iter_dash = NULL;
access_cp = strdup(AccessList[i]);
for (access_str = strtok_r(access_cp, " ", &iter_dash); access_str; access_str = strtok_r(NULL, " ", &iter_dash)) {
lListElem *acc_elem = NULL;
acc_elem = lCreateElem(US_Type);
if (acc_elem != NULL) {
lList *users = lCreateList("user", UE_Type);
lSetString(acc_elem, US_name, access_str);
lSetList(acc_elem, US_entries, users);
lSetBool(acc_elem, US_consider_with_categories, true);
lAppendElem(access_list, acc_elem);
for (access_str = strtok_r(NULL, " ", &iter_dash); access_str; access_str = strtok_r(NULL, " ", &iter_dash)) {
lListElem *user = lCreateElem(UE_Type);
lSetString(user, UE_name, access_str);
lAppendElem(users, user);
}
}
}
if (access_cp != NULL) {
sge_free(&access_cp);
}
}
}
return access_list;
}
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;
}
/*-------------------------------------------------------------------------*/
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);
}
int main(int argc, char *argv[])
{
int pos_tests_failed = 0;
int neg_tests_failed = 0;
int i = 0;
lList *answer_list = NULL;
filter_test_t positiv_test[] = {
{"num_proc", 4},
{"$num_proc", 4},
{"$num_proc*2", 8},
{"$num_proc*0.5", 2.0},
{"num_proc*2", 8},
{"num_proc+1", 5},
{"$num_proc-2", 2},
{"$num_proc+0.1", 4.1},
{"1+$num_proc+0.1", 5.1},
{NULL, 0}
};
filter_test_t negativ_test[] = {
{"2*num_proc", 0},
{"2,0+num_proc", 0},
{"none", 0},
{NULL, 0}
};
lList *centry_list;
lList *host_centry_list;
lListElem *centry;
lListElem *host;
DENTER_MAIN(TOP_LAYER, "test_sge_load_formula");
lInit(nmv);
/* set up centry */
centry_list = lCreateList("", CE_Type);
centry = lCreateElem(CE_Type);
lSetString(centry, CE_name, "num_proc");
lSetString(centry, CE_stringval, "4");
lSetDouble(centry, CE_doubleval, 4);
lAppendElem(centry_list, centry);
/* set up host */
host_centry_list = lCreateList("", CE_Type);
lAppendElem(host_centry_list, lCopyElem(centry));
host = lCreateElem(EH_Type);
lSetList(host, EH_consumable_config_list, host_centry_list);
for (i=0; ; i++){
double val;
if (positiv_test[i].formula == NULL) {
break;
}
if (!validate_load_formula(positiv_test[i].formula, &answer_list, centry_list, "load_formula")) {
answer_list_output(&answer_list);
pos_tests_failed++;
}
val = scaled_mixed_load(positiv_test[i].formula, NULL, host, centry_list);
if (val != positiv_test[i].value) {
printf("got %f, but expected %f(%g,%g)\n", val, positiv_test[i].value, val, positiv_test[i].value);
pos_tests_failed++;
}
}
for (i=0; ; i++){
if (negativ_test[i].formula == NULL) {
break;
}
if (validate_load_formula(negativ_test[i].formula, &answer_list, centry_list, "load_formula") == true) {
printf("load_formula \"%s\" returned no error\n", negativ_test[i].formula);
neg_tests_failed++;
}
lFreeList(&answer_list);
}
lFreeList(¢ry_list);
lFreeElem(&host);
printf("\n");
printf("%d positiv test(s) failed\n", pos_tests_failed);
printf("%d negativ test(s) failed\n", neg_tests_failed);
DRETURN(pos_tests_failed + neg_tests_failed);
}
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;
}
/****** Eventmirror/pe_task/pe_task_update_master_list() ***********************
* NAME
* pe_task_update_master_list() -- update parallel tasks of an array task
*
* SYNOPSIS
* bool
* pe_task_update_master_list(sge_object_type type, sge_event_action action,
* lListElem *event, void *clientdata)
*
* FUNCTION
* Update the list of parallel tasks of an array task
* based on an event.
* The function is called from the event mirroring interface.
*
* The scaled usage list of a parallel task is not updated
* by this function, as this data is maintained by a
* separate event.
*
* INPUTS
* sge_object_type type - event type
* sge_event_action action - action to perform
* lListElem *event - the raw event
* void *clientdata - client data
*
* RESULT
* bool - true, if update is successfull, else false
*
* NOTES
* The function should only be called from the event mirror interface.
*
* SEE ALSO
* Eventmirror/--Eventmirror
* Eventmirror/sge_mirror_update_master_list()
*******************************************************************************/
sge_callback_result
pe_task_update_master_list(sge_evc_class_t *evc, object_description *object_base, sge_object_type type,
sge_event_action action, lListElem *event, void *clientdata)
{
u_long32 job_id;
lListElem *job = NULL;
const char *pe_task_id = NULL;
lListElem *pe_task = NULL;
u_long32 ja_task_id;
lListElem *ja_task = NULL;
lList *pe_task_list = NULL;
const lDescr *pe_task_descr = NULL;
lList *usage = NULL;
char id_buffer[MAX_STRING_SIZE];
dstring id_dstring;
DENTER(TOP_LAYER, "pe_task_update_master_list");
sge_dstring_init(&id_dstring, id_buffer, MAX_STRING_SIZE);
job_id = lGetUlong(event, ET_intkey);
ja_task_id = lGetUlong(event, ET_intkey2);
pe_task_id = lGetString(event, ET_strkey);
job = job_list_locate(*sge_master_list(object_base, SGE_TYPE_JOB), job_id);
if (job == NULL) {
ERROR((SGE_EVENT, MSG_JOB_CANTFINDJOBFORUPDATEIN_SS,
job_get_id_string(job_id, 0, NULL, &id_dstring), SGE_FUNC));
DEXIT;
return SGE_EMA_FAILURE;
}
ja_task = job_search_task(job, NULL, ja_task_id);
if (ja_task == NULL) {
ERROR((SGE_EVENT, MSG_JOB_CANTFINDJATASKFORUPDATEIN_SS,
job_get_id_string(job_id, ja_task_id, NULL, &id_dstring), SGE_FUNC));
DEXIT;
return SGE_EMA_FAILURE;
}
pe_task = ja_task_search_pe_task(ja_task, pe_task_id);
pe_task_list = lGetList(ja_task, JAT_task_list);
pe_task_descr = lGetListDescr(lGetList(event, ET_new_version));
if (action == SGE_EMA_MOD) {
/* modify event for pe_task.
* we may not update
* - PET_scaled_usage - it is maintained by JOB_USAGE events
*/
if (pe_task == NULL) {
ERROR((SGE_EVENT, MSG_JOB_CANTFINDPETASKFORUPDATEIN_SS,
job_get_id_string(job_id, ja_task_id, pe_task_id, &id_dstring), SGE_FUNC));
DEXIT;
return SGE_EMA_FAILURE;
}
lXchgList(pe_task, PET_scaled_usage, &usage);
}
if (sge_mirror_update_master_list(&pe_task_list, pe_task_descr, pe_task,
job_get_id_string(job_id, ja_task_id,
pe_task_id, &id_dstring),
action, event) != SGE_EM_OK) {
lFreeList(&usage);
DEXIT;
return SGE_EMA_FAILURE;
}
/* restore pe_task list after modify event */
if (action == SGE_EMA_MOD) {
pe_task = ja_task_search_pe_task(ja_task, pe_task_id);
if (pe_task == NULL) {
ERROR((SGE_EVENT, MSG_JOB_CANTFINDPETASKFORUPDATEIN_SS,
job_get_id_string(job_id, ja_task_id, pe_task_id, &id_dstring), SGE_FUNC));
lFreeList(&usage);
DEXIT;
return SGE_EMA_FAILURE;
}
lXchgList(pe_task, PET_scaled_usage, &usage);
lFreeList(&usage);
}
/* first petask add event could have created new pe_task list for job */
if (lGetList(ja_task, JAT_task_list) == NULL && pe_task_list != NULL) {
lSetList(ja_task, JAT_task_list, pe_task_list);
}
DEXIT;
return SGE_EMA_OK;
}
/*-------------------------------------------------------------------------*/
static void qmonUsersetOk(Widget w, XtPointer cld, XtPointer cad)
{
String usetname = NULL;
XmString xusetname = NULL;
lList *lp = NULL;
lList *ul = NULL;
lList *alp = NULL;
lListElem *up = NULL;
lEnumeration *what = NULL;
Boolean status = False;
int usettype = 0;
DENTER(GUI_LAYER, "qmonUsersetOk");
/*
** get the dialog data and
*/
usetname = XmtInputFieldGetString(uset_name);
usettype = XmtChooserGetState(uset_type);
/*
** usetname required, show warning dialog
*/
if (usetname && usetname[0] != '\0') {
ul = XmStringToCull(uset_user_list, UE_Type, UE_name, ALL_ITEMS);
/*
** do gdi stuff here
*/
if (add_mode) {
lAddElemStr(&lp, US_name, usetname, US_Type);
}
else {
up = lCopyElem(lGetElemStr(qmonMirrorList(SGE_US_LIST),
US_name, usetname));
lp = lCreateList("userset", US_Type);
lAppendElem(lp, up);
}
lSetList(lFirst(lp), US_entries, ul);
lSetUlong(lFirst(lp), US_type, usettype);
what = lWhat("%T(ALL)", US_Type);
if (add_mode) {
alp = qmonAddList(SGE_US_LIST,
qmonMirrorListRef(SGE_US_LIST),
US_name, &lp, NULL, what);
}
else {
alp = qmonModList(SGE_US_LIST,
qmonMirrorListRef(SGE_US_LIST),
US_name, &lp, NULL, what);
}
if (!qmonMessageBox(w, alp, 0))
status = True;
updateUsersetList();
xusetname = XmtCreateXmString(usetname);
XmListSelectItem(userset_names, xusetname, True);
XmStringFree(xusetname);
lFreeWhat(&what);
lFreeList(&lp);
lFreeList(&alp);
}
else {
qmonMessageShow(w, True, "Userset List Name required !");
}
if (status)
XtUnmanageChild(userset_ask_layout);
DEXIT;
}
/****** execd/loadsensor/read_ls() ********************************************
* NAME
* read_ls -- read sensor output and add it to load report
*
* SYNOPSIS
* static int read_ls(void)
*
* FUNCTION
* This function loops over all loadsensor elements in
* the ls_list (LS_Type). It tries to read from the
* output stream (LS_out). The output will be parsed
* and stored in the LS_incomplete entry (LR_Type).
*
* If the protocol part of the loadsensor is correct
* then the entries of LS_incomplete will be moved
* LS_complete.
*
* The last complete set of load values (LS_complete)
* will be added to the load report.
*
* INPUTS
* this_ls - pointer to a CULL element of type LS_Type
*
* RESULT
* [this_ls] LS_incomplete and LS_complete will be modified.
******************************************************************************/
static int read_ls(void)
{
char input[10000];
char host[1000];
char name[1000];
char value[1000];
lListElem *ls_elem;
bool flag = true;
DENTER(TOP_LAYER, "read_ls");
for_each(ls_elem, ls_list) {
FILE *file = lGetRef(ls_elem, LS_out);
if (sge_ls_get_pid(ls_elem) == -1) {
continue;
}
DPRINTF(("receiving from %s\n", lGetString(ls_elem, LS_command)));
while (flag) {
if (fscanf(file, "%[^\n]\n", input) != 1) {
break;
}
#ifdef INTERIX
if (input[strlen(input)-1] == '\r') {
input[strlen(input)-1] = '\0';
}
#endif
DPRINTF(("received: >>%s<<\n", input));
if (!strcmp(input, "begin") || !strcmp(input, "start")) {
/* remove last possibly incomplete load report */
lSetList(ls_elem, LS_incomplete, lCreateList("", LR_Type));
continue;
}
if (!strcmp(input, "end")) {
/* replace old load report by new one */
lList *tmp_list = NULL;
lXchgList(ls_elem, LS_incomplete, &tmp_list);
lXchgList(ls_elem, LS_complete, &tmp_list);
lFreeList(&tmp_list);
/* request next load report from ls */
ls_send_command(ls_elem, "\n");
break;
}
/* add a newline for pattern matching in sscanf */
strcat(input, "\n");
if (sscanf(input, "%[^:]:%[^:]:%[^\n]", host, name, value) != 3) {
DPRINTF(("format error in line: \"%100s\"\n", input));
ERROR((SGE_EVENT, MSG_LS_FORMAT_ERROR_SS, lGetString(ls_elem, LS_command), input));
} else {
#ifdef INTERIX
char error_buffer[4 * MAX_STRING_SIZE] = "";
if (wl_handle_ls_results(name, value, host, error_buffer))
#endif
{
lList *tmp_list = lGetList(ls_elem, LS_incomplete);
sge_add_str2load_report(&tmp_list, name, value, host);
}
#ifdef INTERIX
if (error_buffer[0] != '\0') {
ERROR((SGE_EVENT, error_buffer));
}
#endif
}
}
}
/****** test_category/test_create_job() ****************************************
* NAME
* test_create_job() -- creates a job object
*
* SYNOPSIS
* lListElem* test_create_job(data_entry_t *test, int count)
*
* FUNCTION
* ???
*
* INPUTS
* data_entry_t *test - string representation of a job
* int count - multiplier for the requests
*
* RESULT
* lListElem* - NULL or valid job object
*
* NOTES
* MT-NOTE: test_create_job() is MT safe
*
*******************************************************************************/
static lListElem *test_create_job(data_entry_t *test, int count)
{
lListElem *job = NULL;
job = lCreateElem(JB_Type);
if (job != NULL) {
lSetUlong(job, JB_type, test->type);
if (test->project != NULL) {
lSetString(job, JB_project, test->project);
}
if (test->owner != NULL) {
lSetString(job, JB_owner, test->owner);
}
if (test->group != NULL) {
lSetString(job, JB_group, test->group);
}
if (test->checkpointing != NULL) {
lSetString(job, JB_checkpoint_name, test->checkpointing);
}
if (test->hard_resource_list != NULL) {
lList *requests = test_create_request(test->hard_resource_list, count);
if (requests != NULL) {
lSetList(job, JB_hard_resource_list, requests);
}
else {
lFreeElem(&job);
goto end;
}
}
if (test->soft_resource_list != NULL) {
lList *requests = test_create_request(test->soft_resource_list, count);
if (requests != NULL) {
lSetList(job, JB_soft_resource_list, requests);
}
else {
lFreeElem(&job);
goto end;
}
}
if (test->hard_queue_list != NULL) {
lList *queues = test_create_queue(test->hard_queue_list, count);
if (queues != NULL) {
lSetList(job, JB_hard_queue_list, queues);
}
else {
lFreeElem(&job);
goto end;
}
}
if (test->hard_master_queue_list != NULL) {
lList *queues = test_create_queue(test->hard_master_queue_list, count);
if (queues != NULL) {
lSetList(job, JB_master_hard_queue_list, queues);
}
else {
lFreeElem(&job);
goto end;
}
}
if (test->pe != NULL) {
test_create_pe(test->pe, job);
}
}
end:
return job;
}
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);
}
}
/****** 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);
}