/****** qmaster/threads/sge_scheduler_main() **********************************
* NAME
* sge_scheduler_main() -- main function of the scheduler thread
*
* SYNOPSIS
* void * sge_scheduler_main(void *arg)
*
* FUNCTION
* Main function of the scheduler thread,
*
* INPUTS
* void *arg - pointer to the thread function (type cl_thread_settings_t*)
*
* RESULT
* void * - always NULL
*
* NOTES
* MT-NOTE: sge_scheduler_main() is MT safe
*
* MT-NOTE: this is a thread function. Do NOT use this function
* MT-NOTE: in any other way!
*
* SEE ALSO
* qmaster/threads/sge_scheduler_initialize()
* qmaster/threads/sge_scheduler_cleanup_thread()
* qmaster/threads/sge_scheduler_terminate()
* qmaster/threads/sge_scheduler_main()
*******************************************************************************/
void *
sge_scheduler_main(void *arg)
{
time_t next_prof_output = 0;
monitoring_t monitor;
sge_gdi_ctx_class_t *ctx = NULL;
sge_evc_class_t *evc = NULL;
lList *alp = NULL;
sge_where_what_t where_what;
cl_thread_settings_t *thread_config = (cl_thread_settings_t*)arg;
bool do_shutdown = false;
bool do_endlessly = true;
bool local_ret = true;
DENTER(TOP_LAYER, "sge_scheduler_main");
memset(&where_what, 0, sizeof(where_what));
/*
* startup
*/
if (local_ret) {
/* initialize commlib thread */
cl_thread_func_startup(thread_config);
/* initialize monitoring */
sge_monitor_init(&monitor, thread_config->thread_name, SCH_EXT, SCT_WARNING, SCT_ERROR);
sge_qmaster_thread_init(&ctx, SCHEDD, SCHEDD_THREAD, true);
/* register at profiling module */
set_thread_name(pthread_self(), "Scheduler Thread");
conf_update_thread_profiling("Scheduler Thread");
DPRINTF((SFN" started\n", thread_config->thread_name));
/* initialize schedd_runnlog logging */
schedd_set_schedd_log_file(ctx);
}
/* set profiling parameters */
prof_set_level_name(SGE_PROF_EVENTMASTER, NULL, NULL);
prof_set_level_name(SGE_PROF_SPOOLING, NULL, NULL);
prof_set_level_name(SGE_PROF_CUSTOM0, "scheduler", NULL);
prof_set_level_name(SGE_PROF_CUSTOM1, "pending ticket calculation", NULL);
prof_set_level_name(SGE_PROF_CUSTOM3, "job sorting", NULL);
prof_set_level_name(SGE_PROF_CUSTOM4, "job dispatching", NULL);
prof_set_level_name(SGE_PROF_CUSTOM5, "send orders", NULL);
prof_set_level_name(SGE_PROF_CUSTOM6, "scheduler event loop", NULL);
prof_set_level_name(SGE_PROF_CUSTOM7, "copy lists", NULL);
prof_set_level_name(SGE_PROF_SCHEDLIB4, NULL, NULL);
/* set-up needed for 'schedule' file */
serf_init(schedd_serf_record_func, schedd_serf_newline);
schedd_set_serf_log_file(ctx);
/*
* prepare event client/mirror mechanism
*/
if (local_ret) {
local_ret = sge_gdi2_evc_setup(&evc, ctx, EV_ID_SCHEDD, &alp, "scheduler");
DPRINTF(("prepared event client/mirror mechanism\n"));
}
/*
* register as event mirror
*/
if (local_ret) {
sge_mirror_initialize(evc, EV_ID_SCHEDD, "scheduler",
false, &event_update_func, &sge_mod_event_client,
&sge_add_event_client, &sge_remove_event_client,
&sge_handle_event_ack);
evc->ec_register(evc, false, NULL, &monitor);
evc->ec_set_busy_handling(evc, EV_BUSY_UNTIL_RELEASED);
DPRINTF(("registered at event mirror\n"));
}
/*
* subscribe necessary data
*/
if (local_ret) {
ensure_valid_what_and_where(&where_what);
subscribe_scheduler(evc, &where_what);
DPRINTF(("subscribed necessary data from event master\n"));
}
/*
* schedulers main loop
*/
if (local_ret) {
while (do_endlessly) {
bool handled_events = false;
lList *event_list = NULL;
int execute = 0;
double prof_copy = 0.0;
double prof_total = 0.0;
double prof_init = 0.0;
double prof_free = 0.0;
double prof_run = 0.0;
lList *orders = NULL;
if (sconf_get_profiling()) {
prof_start(SGE_PROF_OTHER, NULL);
prof_start(SGE_PROF_PACKING, NULL);
prof_start(SGE_PROF_EVENTCLIENT, NULL);
prof_start(SGE_PROF_MIRROR, NULL);
prof_start(SGE_PROF_GDI, NULL);
prof_start(SGE_PROF_HT_RESIZE, NULL);
prof_start(SGE_PROF_CUSTOM0, NULL);
prof_start(SGE_PROF_CUSTOM1, NULL);
prof_start(SGE_PROF_CUSTOM3, NULL);
prof_start(SGE_PROF_CUSTOM4, NULL);
prof_start(SGE_PROF_CUSTOM5, NULL);
prof_start(SGE_PROF_CUSTOM6, NULL);
prof_start(SGE_PROF_CUSTOM7, NULL);
prof_start(SGE_PROF_SCHEDLIB4, NULL);
} else {
prof_stop(SGE_PROF_OTHER, NULL);
prof_stop(SGE_PROF_PACKING, NULL);
prof_stop(SGE_PROF_EVENTCLIENT, NULL);
prof_stop(SGE_PROF_MIRROR, NULL);
prof_stop(SGE_PROF_GDI, NULL);
prof_stop(SGE_PROF_HT_RESIZE, NULL);
prof_stop(SGE_PROF_CUSTOM0, NULL);
prof_stop(SGE_PROF_CUSTOM1, NULL);
prof_stop(SGE_PROF_CUSTOM3, NULL);
prof_stop(SGE_PROF_CUSTOM4, NULL);
prof_stop(SGE_PROF_CUSTOM5, NULL);
prof_stop(SGE_PROF_CUSTOM6, NULL);
prof_stop(SGE_PROF_CUSTOM7, NULL);
prof_stop(SGE_PROF_SCHEDLIB4, NULL);
}
/*
* Wait for new events
*/
MONITOR_IDLE_TIME(sge_scheduler_wait_for_event(evc, &event_list), (&monitor), mconf_get_monitor_time(),
mconf_is_monitor_message());
/* If we lost connection we have to register again */
if (evc->ec_need_new_registration(evc)) {
lFreeList(&event_list);
if (evc->ec_register(evc, false, NULL, &monitor) == true) {
DPRINTF(("re-registered at event master!\n"));
}
}
if (event_list != NULL) {
/* check for shutdown */
do_shutdown = (lGetElemUlong(event_list, ET_type, sgeE_SHUTDOWN) != NULL) ? true : false;
/* update mirror and free data */
if (do_shutdown == false && sge_mirror_process_event_list(evc, event_list) == SGE_EM_OK) {
handled_events = true;
DPRINTF(("events handled\n"));
} else {
DPRINTF(("events contain shutdown event - ignoring events\n"));
}
lFreeList(&event_list);
}
/* if we actually got events, start the scheduling run and further event processing */
if (handled_events == true) {
lList *answer_list = NULL;
scheduler_all_data_t copy;
lList *master_cqueue_list = *(object_type_get_master_list(SGE_TYPE_CQUEUE));
lList *master_job_list = *object_type_get_master_list(SGE_TYPE_JOB);
lList *master_userset_list = *object_type_get_master_list(SGE_TYPE_USERSET);
lList *master_project_list = *object_type_get_master_list(SGE_TYPE_PROJECT);
lList *master_exechost_list= *object_type_get_master_list(SGE_TYPE_EXECHOST);
lList *master_rqs_list= *object_type_get_master_list(SGE_TYPE_RQS);
lList *master_centry_list = *object_type_get_master_list(SGE_TYPE_CENTRY);
lList *master_ckpt_list = *object_type_get_master_list(SGE_TYPE_CKPT);
lList *master_user_list = *object_type_get_master_list(SGE_TYPE_USER);
lList *master_ar_list = *object_type_get_master_list(SGE_TYPE_AR);
lList *master_pe_list = *object_type_get_master_list(SGE_TYPE_PE);
lList *master_hgrp_list = *object_type_get_master_list(SGE_TYPE_HGROUP);
lList *master_sharetree_list = *object_type_get_master_list(SGE_TYPE_SHARETREE);
/* delay scheduling for test purposes, see issue GE-3306 */
if (SGE_TEST_DELAY_SCHEDULING > 0) {
sleep(SGE_TEST_DELAY_SCHEDULING);
}
PROF_START_MEASUREMENT(SGE_PROF_CUSTOM6);
PROF_START_MEASUREMENT(SGE_PROF_CUSTOM7);
if (__CONDITION(INFOPRINT)) {
dstring ds;
char buffer[128];
sge_dstring_init(&ds, buffer, sizeof(buffer));
DPRINTF(("================[SCHEDULING-EPOCH %s]==================\n",
sge_at_time(0, &ds)));
sge_dstring_free(&ds);
}
/*
* If there were new events then
* copy/filter data necessary for the scheduler run
* and run the scheduler method
*/
memset(©, 0, sizeof(copy));
copy.dept_list = lSelect("", master_userset_list, where_what.where_dept, where_what.what_acldept);
copy.acl_list = lSelect("", master_userset_list, where_what.where_acl, where_what.what_acldept);
DPRINTF(("RAW CQ:%d, J:%d, H:%d, C:%d, A:%d, D:%d, P:%d, CKPT:%d,"
" US:%d, PR:%d, RQS:%d, AR:%d, S:nd:%d/lf:%d\n",
lGetNumberOfElem(master_cqueue_list),
lGetNumberOfElem(master_job_list),
lGetNumberOfElem(master_exechost_list),
lGetNumberOfElem(master_centry_list),
lGetNumberOfElem(copy.acl_list),
lGetNumberOfElem(copy.dept_list),
lGetNumberOfElem(master_project_list),
lGetNumberOfElem(master_ckpt_list),
lGetNumberOfElem(master_user_list),
lGetNumberOfElem(master_project_list),
lGetNumberOfElem(master_rqs_list),
lGetNumberOfElem(master_ar_list),
lGetNumberOfNodes(NULL, master_sharetree_list, STN_children),
lGetNumberOfLeafs(NULL, master_sharetree_list, STN_children)
));
sge_rebuild_job_category(master_job_list, master_userset_list,
master_project_list, master_rqs_list);
PROF_STOP_MEASUREMENT(SGE_PROF_CUSTOM7);
prof_init = prof_get_measurement_wallclock(SGE_PROF_CUSTOM7, true, NULL);
PROF_START_MEASUREMENT(SGE_PROF_CUSTOM7);
sge_before_dispatch(evc);
/* prepare data for the scheduler itself */
copy.host_list = lCopyList("", master_exechost_list);
/*
* Within the scheduler we do only need QIs
*/
{
lListElem *cqueue = NULL;
lEnumeration *what_queue3 = NULL;
for_each(cqueue, master_cqueue_list) {
lList *qinstance_list = lGetList(cqueue, CQ_qinstances);
lList *t;
if (!qinstance_list) {
continue;
}
/* all_queue_list contains all queue instances with state and full queue name only */
if (!what_queue3) {
what_queue3 = lWhat("%T(%I%I)", lGetListDescr(qinstance_list), QU_full_name, QU_state);
}
t = lSelect("t", qinstance_list, NULL, what_queue3);
if (t) {
if (copy.all_queue_list == NULL) {
copy.all_queue_list = lCreateList("all", lGetListDescr(t));
}
lAppendList(copy.all_queue_list, t);
lFreeList (&t);
}
t = lSelect("t", qinstance_list, where_what.where_queue, where_what.what_queue2);
if (t) {
if (copy.queue_list == NULL) {
copy.queue_list = lCreateList("enabled", lGetListDescr(t));
}
lAppendList(copy.queue_list, t);
lFreeList (&t);
}
t = lSelect("t", qinstance_list, where_what.where_queue2, where_what.what_queue2);
if (t) {
if (copy.dis_queue_list == NULL) {
copy.dis_queue_list = lCreateList("disabled", lGetListDescr(t));
}
lAppendList(copy.dis_queue_list, t);
lFreeList (&t);
}
}
if (what_queue3) {
lFreeWhat(&what_queue3);
}
}
if (sconf_is_job_category_filtering()) {
copy.job_list = sge_category_job_copy(copy.queue_list, &orders, evc->monitor_next_run);
} else {
copy.job_list = lCopyList("", master_job_list);
}
/* no need to copy these lists, they are read only used */
copy.centry_list = master_centry_list;
copy.ckpt_list = master_ckpt_list;
copy.hgrp_list = master_hgrp_list;
/* these lists need to be copied because they are modified during scheduling run */
copy.share_tree = lCopyList("", master_sharetree_list);
copy.pe_list = lCopyList("", master_pe_list);
copy.user_list = lCopyList("", master_user_list);
copy.project_list = lCopyList("", master_project_list);
copy.rqs_list = lCopyList("", master_rqs_list);
copy.ar_list = lCopyList("", master_ar_list);
/* report number of reduced and raw (in brackets) lists */
DPRINTF(("Q:%d, AQ:%d J:%d(%d), H:%d(%d), C:%d, A:%d, D:%d, P:%d, CKPT:%d,"
" US:%d, PR:%d, RQS:%d, AR:%d, S:nd:%d/lf:%d \n",
lGetNumberOfElem(copy.queue_list),
lGetNumberOfElem(copy.all_queue_list),
lGetNumberOfElem(copy.job_list),
lGetNumberOfElem(master_job_list),
lGetNumberOfElem(copy.host_list),
lGetNumberOfElem(master_exechost_list),
lGetNumberOfElem(copy.centry_list),
lGetNumberOfElem(copy.acl_list),
lGetNumberOfElem(copy.dept_list),
lGetNumberOfElem(copy.pe_list),
lGetNumberOfElem(copy.ckpt_list),
lGetNumberOfElem(copy.user_list),
lGetNumberOfElem(copy.project_list),
lGetNumberOfElem(copy.rqs_list),
lGetNumberOfElem(copy.ar_list),
lGetNumberOfNodes(NULL, copy.share_tree, STN_children),
lGetNumberOfLeafs(NULL, copy.share_tree, STN_children)
));
if (getenv("SGE_ND")) {
printf("Q:%d, AQ:%d J:%d(%d), H:%d(%d), C:%d, A:%d, D:%d, "
"P:%d, CKPT:%d, US:%d, PR:%d, RQS:%d, AR:%d, S:nd:%d/lf:%d \n",
lGetNumberOfElem(copy.queue_list),
lGetNumberOfElem(copy.all_queue_list),
lGetNumberOfElem(copy.job_list),
lGetNumberOfElem(master_job_list),
lGetNumberOfElem(copy.host_list),
lGetNumberOfElem(master_exechost_list),
lGetNumberOfElem(copy.centry_list),
lGetNumberOfElem(copy.acl_list),
lGetNumberOfElem(copy.dept_list),
lGetNumberOfElem(copy.pe_list),
lGetNumberOfElem(copy.ckpt_list),
lGetNumberOfElem(copy.user_list),
lGetNumberOfElem(copy.project_list),
lGetNumberOfElem(copy.rqs_list),
lGetNumberOfElem(copy.ar_list),
lGetNumberOfNodes(NULL, copy.share_tree, STN_children),
lGetNumberOfLeafs(NULL, copy.share_tree, STN_children)
);
} else {
schedd_log("-------------START-SCHEDULER-RUN-------------", NULL, evc->monitor_next_run);
}
PROF_STOP_MEASUREMENT(SGE_PROF_CUSTOM7);
prof_copy = prof_get_measurement_wallclock(SGE_PROF_CUSTOM7, true, NULL);
PROF_START_MEASUREMENT(SGE_PROF_CUSTOM7);
scheduler_method(evc, &answer_list, ©, &orders);
answer_list_output(&answer_list);
PROF_STOP_MEASUREMENT(SGE_PROF_CUSTOM7);
prof_run = prof_get_measurement_wallclock(SGE_PROF_CUSTOM7, true, NULL);
PROF_START_MEASUREMENT(SGE_PROF_CUSTOM7);
/* .. which gets deleted after using */
lFreeList(&(copy.host_list));
lFreeList(&(copy.queue_list));
lFreeList(&(copy.dis_queue_list));
lFreeList(&(copy.all_queue_list));
lFreeList(&(copy.job_list));
lFreeList(&(copy.acl_list));
lFreeList(&(copy.dept_list));
lFreeList(&(copy.pe_list));
lFreeList(&(copy.share_tree));
lFreeList(&(copy.user_list));
lFreeList(&(copy.project_list));
lFreeList(&(copy.rqs_list));
lFreeList(&(copy.ar_list));
PROF_STOP_MEASUREMENT(SGE_PROF_CUSTOM7);
prof_free = prof_get_measurement_wallclock(SGE_PROF_CUSTOM7, true, NULL);
/*
* need to sync with event master thread
* if schedd configuration changed then settings in evm can be adjusted
*/
if (sconf_is_new_config()) {
/* set scheduler interval / event delivery interval */
u_long32 interval = sconf_get_schedule_interval();
if (evc->ec_get_edtime(evc) != interval) {
evc->ec_set_edtime(evc, interval);
}
/* set job / ja_task event flushing */
set_job_flushing(evc);
/* no need to ec_commit here - we do it when resetting the busy state */
/* now we handled the new schedd config - no need to do it twice */
sconf_reset_new_config();
}
/* block till master handled all GDI orders */
sge_schedd_block_until_orders_processed(evc->get_gdi_ctx(evc), NULL);
schedd_order_destroy();
/*
* Stop profiling for "schedd run total" and the subcategories
*/
PROF_STOP_MEASUREMENT(SGE_PROF_CUSTOM6);
prof_total = prof_get_measurement_wallclock(SGE_PROF_CUSTOM6, true, NULL);
if (prof_is_active(SGE_PROF_CUSTOM6)) {
PROFILING((SGE_EVENT, "PROF: schedd run took: %.3f s (init: %.3f s, copy: %.3f s, "
"run:%.3f, free: %.3f s, jobs: %d, categories: %d/%d)",
prof_total, prof_init, prof_copy, prof_run, prof_free,
lGetNumberOfElem(*object_type_get_master_list(SGE_TYPE_JOB)), sge_category_count(),
sge_cs_category_count() ));
}
if (getenv("SGE_ND") != NULL) {
printf("--------------STOP-SCHEDULER-RUN-------------\n");
} else {
schedd_log("--------------STOP-SCHEDULER-RUN-------------", NULL, evc->monitor_next_run);
}
thread_output_profiling("scheduler thread profiling summary:\n", &next_prof_output);
sge_monitor_output(&monitor);
}
/* reset the busy state */
evc->ec_set_busy(evc, 0);
evc->ec_commit(evc, NULL);
/* stop logging into schedd_runlog (enabled via -tsm) */
evc->monitor_next_run = false;
/*
* pthread cancelation point
*
* sge_scheduler_cleanup_thread() is the last function which should
* be called so it is pushed first
*/
pthread_cleanup_push(sge_scheduler_cleanup_thread, (void *) &ctx);
pthread_cleanup_push((void (*)(void *))sge_scheduler_cleanup_monitor,
(void *)&monitor);
pthread_cleanup_push((void (*)(void *))sge_scheduler_cleanup_event_client,
(void *)evc);
cl_thread_func_testcancel(thread_config);
pthread_cleanup_pop(execute);
pthread_cleanup_pop(execute);
pthread_cleanup_pop(execute);
DPRINTF(("passed cancelation point\n"));
}
/****** sge_var/var_list_parse_from_string() *******************************
* NAME
* var_list_parse_from_string() -- parse vars from string list
*
* SYNOPSIS
* int var_list_parse_from_string(lList **lpp,
* const char *variable_str,
* int check_environment)
*
* FUNCTION
* Parse a list of variables ("lpp") from a comma separated
* string list ("variable_str"). The boolean "check_environment"
* defined wether the current value of a variable is taken from
* the environment of the calling process.
*
* INPUTS
* lList **lpp - VA_Type list
* const char *variable_str - source string
* int check_environment - boolean
*
* RESULT
* int - error state
* 0 - OK
* >0 - Error
*
* NOTES
* MT-NOTE: var_list_parse_from_string() is MT safe
*******************************************************************************/
int var_list_parse_from_string(lList **lpp, const char *variable_str,
int check_environment)
{
char *variable;
char *val_str;
int var_len;
char **str_str;
char **pstr;
lListElem *ep;
char *va_string;
DENTER(TOP_LAYER, "var_list_parse_from_string");
if (!lpp) {
DEXIT;
return 1;
}
va_string = sge_strdup(NULL, variable_str);
if (!va_string) {
*lpp = NULL;
DEXIT;
return 2;
}
str_str = string_list(va_string, ",", NULL);
if (!str_str || !*str_str) {
*lpp = NULL;
sge_free(&va_string);
DEXIT;
return 3;
}
if (!*lpp) {
*lpp = lCreateList("variable list", VA_Type);
if (!*lpp) {
sge_free(&va_string);
sge_free(&str_str);
DEXIT;
return 4;
}
}
for (pstr = str_str; *pstr; pstr++) {
struct saved_vars_s *context;
ep = lCreateElem(VA_Type);
/* SGE_ASSERT(ep); */
lAppendElem(*lpp, ep);
context = NULL;
variable = sge_strtok_r(*pstr, "=", &context);
SGE_ASSERT((variable));
var_len=strlen(variable);
lSetString(ep, VA_variable, variable);
val_str=*pstr;
/*
* The character at the end of the first token must be either '=' or '\0'.
* If it's a '=' then we treat the following string as the value
* If it's a '\0' and check_environment is set, then we get the value from
* the environment variable value.
* If it's a '\0' and check_environment is not set, then we set the value
* to NULL.
*/
if (val_str[var_len] == '=') {
lSetString(ep, VA_value, &val_str[var_len+1]);
} else if (check_environment) {
lSetString(ep, VA_value, sge_getenv(variable));
} else {
lSetString(ep, VA_value, NULL);
}
sge_free_saved_vars(context);
}
sge_free(&va_string);
sge_free(&str_str);
DRETURN(0);
}
/*-------------------------------------------------------------------------*/
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;
}
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);
}
}
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);
}
/****** execd/sge_execd_register_at_qmaster() **********************************
* NAME
* sge_execd_register_at_qmaster() -- modify execd list at qmaster site
*
* SYNOPSIS
* int sge_execd_register_at_qmaster(void)
*
* FUNCTION
* add local execd name to SGE_EH_LIST in order to register at
* qmaster
*
* INPUTS
* void - no input
*
* RESULT
* int - 0 = success / 1 = error
*
* NOTES
* MT-NOTE: sge_execd_register_at_qmaster() is not MT safe
*
*******************************************************************************/
int sge_execd_register_at_qmaster(sge_gdi_ctx_class_t *ctx, bool is_restart) {
int return_value = 0;
static int sge_last_register_error_flag = 0;
lList *alp = NULL;
/*
* If it is a reconnect (is_restart == true) the act_qmaster file must be
* re-read in order to update ctx qmaster cache when master migrates.
*/
const char *master_host = ctx->get_master(ctx, is_restart);
DENTER(TOP_LAYER, "sge_execd_register_at_qmaster");
/* We will not try to make a gdi request when qmaster is not alive. The
* gdi will return with timeout after one minute. If qmaster is not alive
* we will not try a gdi request!
*/
if (master_host != NULL && ctx->is_alive(ctx) == CL_RETVAL_OK) {
lList *hlp = lCreateList("exechost starting", EH_Type);
lListElem *hep = lCreateElem(EH_Type);
lSetUlong(hep, EH_featureset_id, feature_get_active_featureset_id());
lAppendElem(hlp, hep);
/* register at qmaster */
DPRINTF(("***** Register at qmaster *****\n"));
if (!is_restart) {
/*
* This is a regular startup.
*/
alp = ctx->gdi(ctx, SGE_EH_LIST, SGE_GDI_ADD, &hlp, NULL, NULL);
} else {
/*
* Indicate this is a restart to qmaster.
* This is used for the initial_state of queue_configuration implementation.
*/
alp = ctx->gdi(ctx, SGE_EH_LIST, SGE_GDI_ADD | SGE_GDI_EXECD_RESTART,
&hlp, NULL, NULL);
}
lFreeList(&hlp);
} else {
DPRINTF(("***** Register at qmaster - qmaster not alive! *****\n"));
}
if (alp == NULL) {
if (sge_last_register_error_flag == 0) {
WARNING((SGE_EVENT, MSG_COM_CANTREGISTER_SS, master_host?master_host:"", MSG_COM_ERROR));
sge_last_register_error_flag = 1;
}
return_value = 1;
} else {
lListElem *aep = lFirst(alp);
if (lGetUlong(aep, AN_status) != STATUS_OK) {
if (sge_last_register_error_flag == 0) {
WARNING((SGE_EVENT, MSG_COM_CANTREGISTER_SS, master_host?master_host:"", lGetString(aep, AN_text)));
sge_last_register_error_flag = 1;
}
return_value = 1;
}
}
if (return_value == 0) {
sge_last_register_error_flag = 0;
INFO((SGE_EVENT, MSG_EXECD_REGISTERED_AT_QMASTER_S, master_host?master_host:""));
last_qmaster_registration_time = sge_get_gmt();
}
lFreeList(&alp);
DRETURN(return_value);
}
/****** cull/db/lJoinSublist() ************************************************
* NAME
* lJoinSublist() -- Join a list with one of its sublists
*
* SYNOPSIS
* lList* lJoinSublist(const char *name,
* int nm0,
* const lList *lp,
* const lCondition *cp0,
* const lEnumeration *enp0,
* const lDescr *sldp,
* const lCondition *cp1,
* const lEnumeration *enp1)
*
* FUNCTION
* Joins a list and one of its sublists together. The other
* parameters are equal to them from lJoin(). In the enumeration
* 'enp0' the sublist field neither may be selected nor 'enp0'
* may be NULL.
*
* INPUTS
* const char *name - new list name
* int nm0 -
* const lList *lp - list
* const lCondition *cp0 - selects rows within 'lp'
* const lEnumeration *enp0 - selects columns within 'lp'
* const lDescr *sldp - sublist descriptor pointer
* const lCondition *cp1 - selects rows within 'sldp'
* const lEnumeration *enp1 - selects columns within 'enp1'
*
* RESULT
* lList* - Joined list
******************************************************************************/
lList *lJoinSublist(const char *name, int nm0, const lList *lp,
const lCondition *cp0, const lEnumeration *enp0,
const lDescr *sldp, const lCondition *cp1,
const lEnumeration *enp1)
{
lList *dlp, *tlp, *joinedlist, *sublist;
lListElem *ep;
lDescr *dp;
const lDescr *tdp;
int i, pos;
DENTER(CULL_LAYER, "lJoinSublist");
/* check different pointers */
if (!name || !lp || !enp0 || !sldp || !enp1) {
LERROR(LENULLARGS);
DEXIT;
return NULL;
}
/* make sure that nm0 is a sublist field of lp */
if (!(tdp = lGetListDescr(lp))) {
LERROR(LEDESCRNULL);
DEXIT;
return NULL;
}
if ((pos = lGetPosInDescr(tdp, nm0)) < 0) {
LERROR(LENAMENOT);
DEXIT;
return NULL;
}
if (mt_get_type(tdp[pos].mt) != lListT) {
LERROR(LEINCTYPE);
DEXIT;
return NULL;
}
/* is nm0 enumerated in enp0 ? */
if (enp0[0].pos == WHAT_ALL) {
LERROR(LEFALSEFIELD);
DEXIT;
return NULL;
}
for (i = 0; enp0[i].nm != NoName; i++)
if (enp0[i].nm == nm0) {
LERROR(LEFALSEFIELD);
DEXIT;
return NULL;
}
/* create destination list */
if (!(dp = lJoinDescr(lGetListDescr(lp), sldp, enp0, enp1))) {
LERROR(LEJOINDESCR);
DEXIT;
return NULL;
}
if (!(dlp = lCreateList(name, dp))) {
sge_free(&dp);
LERROR(LECREATELIST);
DEXIT;
return NULL;
}
/* free dp it has been copied in lCreateList */
sge_free(&dp);
/* create a temporary list to be used by lJoin */
if (!(tlp = lCreateList("lJoinSublist: tlp", lGetListDescr(lp)))) {
lFreeList(&dlp);
LERROR(LECREATELIST);
DEXIT;
return NULL;
}
for_each_where(ep, lp, cp0) {
/* is there a sublist for the join */
if ((sublist = lGetList(ep, nm0)) != NULL) {
/* put each element in the tlp to be used by lJoin */
if (lAppendElem(tlp, lCopyElem(ep)) == -1) {
lFreeList(&tlp);
lFreeList(&dlp);
LERROR(LEAPPENDELEM);
DEXIT;
return NULL;
}
/* join the tlp with one element together with its sublist */
joinedlist = lJoin("lJoinSublist: joinedlist", nm0, tlp, NULL, enp0,
NoName, sublist, cp1, enp1);
if (!joinedlist) {
lFreeList(&tlp);
lFreeList(&dlp);
LERROR(LEJOIN);
DEXIT;
return NULL;
}
/* joinedlist is freed in lAddList */
if (joinedlist && lAddList(dlp, &joinedlist) == -1) {
LERROR(LEADDLIST);
lFreeList(&tlp);
lFreeList(&dlp);
DEXIT;
return NULL;
}
/* dechain the only element from tlp and free it (copy) */
lRemoveElem(tlp, &(tlp->first));
}
}
/* temporary list has to be freed */
lFreeList(&tlp);
/* RETURN AN EMPTY LIST OR NULL THAT'S THE QUESTION */
if (lGetNumberOfElem(dlp) == 0) {
lFreeList(&dlp);
}
DEXIT;
return dlp;
}
int main(int argc, char *argv[])
{
lListElem *queue, *copy;
lList *queue_list;
lList *answer_list = NULL;
const lDescr *descr;
spooling_field *fields;
const char *filepath;
int i;
int width;
char format[100];
lInit(nmv);
queue = queue_create_template();
lSetString(queue, QU_terminate_method, "/tmp/myterminate_method.sh");
lAddSubStr(queue, CE_name, "foo", QU_suspend_thresholds, CE_Type);
lAddSubStr(queue, CE_name, "bar", QU_suspend_thresholds, CE_Type);
copy = lCreateElem(QU_Type);
queue_list = lCreateList("queue_list", QU_Type);
lAppendElem(queue_list, queue);
lAppendElem(queue_list, copy);
descr = lGetElemDescr(queue);
fields = spool_get_fields_to_spool(&answer_list, QU_Type, &spool_config_instr);
printf("\nthe following fields are spooled:");
for(i = 0; fields[i].nm != NoName; i++) {
printf(" %s", lNm2Str(fields[i].nm));
}
printf("\n");
spool_flatfile_align_object(&answer_list, fields);
width = fields[0].width;
printf("alignment for attribute names is %d\n", width);
spool_flatfile_align_list(&answer_list, queue_list, fields);
printf("field widths for list output is as follows:\n");
sprintf(format, "%%%ds: %%d\n", width);
for(i = 0; fields[i].nm != NoName; i++) {
printf(format, lNm2Str(fields[i].nm), fields[i].width);
}
filepath = spool_flatfile_write_object(&answer_list, queue,
NULL,
&spool_flatfile_instr_config,
SP_DEST_STDOUT, SP_FORM_ASCII, NULL);
if(filepath != NULL) {
printf("\ndata successfully written to stdout\n");
FREE(filepath);
} else {
answer_list_print_err_warn(&answer_list, NULL, NULL);
}
printf("\n");
filepath = spool_flatfile_write_object(&answer_list, queue,
NULL,
&spool_flatfile_instr_config,
SP_DEST_TMP, SP_FORM_ASCII, NULL);
if(filepath != NULL) {
printf("temporary file %s successfully written\n", filepath);
sge_unlink(NULL, filepath);
FREE(filepath);
} else {
answer_list_print_err_warn(&answer_list, NULL, NULL);
}
filepath = spool_flatfile_write_object(&answer_list, queue,
NULL,
&spool_flatfile_instr_config,
SP_DEST_SPOOL, SP_FORM_ASCII,
"test_sge_spooling_flatfile.dat");
if(filepath != NULL) {
lListElem *reread_queue;
printf("spool file %s successfully written\n", filepath);
/* reread queue from file */
reread_queue = spool_flatfile_read_object(&answer_list, QU_Type, NULL, NULL,
&spool_flatfile_instr_config,
SP_FORM_ASCII, NULL,
"test_sge_spooling_flatfile.dat");
if(reread_queue == NULL) {
answer_list_print_err_warn(&answer_list, NULL, NULL);
} else {
lWriteElemTo(reread_queue, stdout);
lFreeElem(&reread_queue);
}
sge_unlink(NULL, filepath);
FREE(filepath);
} else {
answer_list_print_err_warn(&answer_list, NULL, NULL);
}
filepath = spool_flatfile_write_list(&answer_list, queue_list,
NULL,
&spool_flatfile_instr_config_list,
SP_DEST_STDOUT, SP_FORM_ASCII,
NULL);
if(filepath != NULL) {
printf("\ndata successfully written to stdout\n");
FREE(filepath);
} else {
answer_list_print_err_warn(&answer_list, NULL, NULL);
}
filepath = spool_flatfile_write_list(&answer_list, queue_list,
NULL,
&spool_flatfile_instr_config_list,
SP_DEST_SPOOL, SP_FORM_ASCII,
"test_sge_spooling_flatfile.dat");
if(filepath != NULL) {
lList *reread_list;
printf("spool file %s successfully written\n", filepath);
reread_list = spool_flatfile_read_list(&answer_list, QU_Type, NULL, NULL, &spool_flatfile_instr_config_list, SP_FORM_ASCII, NULL, "test_sge_spooling_flatfile.dat");
if (reread_list == NULL) {
answer_list_print_err_warn(&answer_list, NULL, NULL);
} else {
lWriteListTo(reread_list, stdout);
lFreeList(&reread_list);
}
/* sge_unlink(NULL, filepath); */
FREE(filepath);
} else {
answer_list_print_err_warn(&answer_list, NULL, NULL);
}
/* test reading object */
/* test nonexisting filename */
/* test behaviour with NULL-pointer passed */
printf("\n\ntesting error handling, the next calls have to fail\n");
spool_flatfile_align_object(&answer_list, NULL);
spool_flatfile_align_list(&answer_list, NULL, fields);
spool_flatfile_align_list(&answer_list, queue_list, NULL);
answer_list_print_err_warn(&answer_list, NULL, NULL);
/* cleanup */
lFreeList(&queue_list);
fields = spool_free_spooling_fields(fields);
fprintf(stdout, "file handle stdout still alive\n");
fprintf(stderr, "file handle stderr still alive\n");
return EXIT_SUCCESS;
}
/****** cull/dump_scan/lUndumpList() ******************************************
* NAME
* lUndumpList() -- Reads a by lDumpList dumped dump
*
* SYNOPSIS
* lList* lUndumpList(FILE *fp, const char *name, const lDescr *dp)
*
* FUNCTION
* Reads a by lDumpList dumped dump into the memory.
*
* INPUTS
* FILE *fp - file pointer
* const char *name - new name of list or NULL if the old name in the
* dumpfile should be used as listname
* const lDescr *dp - new list descriptor or NULL if the old list
* descriptor should be used as list descriptor
*
* RESULT
* lList* - Read list
*
* NOTES
* Actually a type/name matching is only performed for the list
* itself and not for its sublists.
* If an implementation of changed sublist descriptors is desired
* we can probably use the following syntax for lUndumpList.
* lList* lUndumpList(fp, name, formatstring, ...)
* with formatstring like "%T(%I -> %T(%I->%T))" and the varargs
* list: ".....", lDescr1, fieldname1, lDescr2, fieldname2, lDescr3
* or write a wrapper around lUndumpList which parses this format and
* hands over the varargs list to lUndumpList
******************************************************************************/
lList *lUndumpList(FILE *fp, const char *name, const lDescr *dp)
{
lList *lp = NULL;
lListElem *fep, *ep;
lDescr *fdp = NULL;
int i, j, nelem, n, k;
int *found;
char *oldname;
DENTER(CULL_LAYER, "lUndumpList");
if (!fp) {
LERROR(LEFILENULL);
DRETURN(NULL);
}
/* read bra */
if (fGetBra(fp)) {
printf("bra is missing\n");
LERROR(LESYNTAX);
DRETURN(NULL);
}
/* read listname */
if (fGetString(fp, &oldname)) {
printf("fGetString failed\n");
LERROR(LEFIELDREAD);
DRETURN(NULL);
}
/* read number of elems */
if (fGetInt(fp, &nelem)) {
printf("fGetInt failed\n");
LERROR(LEFIELDREAD);
DRETURN(NULL);
}
/* read Descriptor from file */
if (!(fdp = lUndumpDescr(fp))) {
LERROR(LEFGETDESCR);
DRETURN(NULL);
}
if (!dp) /* dp is NULL, use lDescr from dumpfile */
dp = fdp;
/* use old name (from file) if name is NULL */
if (!(lp = lCreateList((name) ? name : oldname, dp))) {
FREE(fdp);
LERROR(LECREATELIST);
DRETURN(NULL);
}
free(oldname); /* fGetString strdup's */
if ((n = lCountDescr(dp)) <= 0) {
LERROR(LECOUNTDESCR);
FREE(fdp);
lFreeList(&lp);
DRETURN(NULL);
}
if (!(found = (int *) malloc(sizeof(int) * n))) {
LERROR(LEMALLOC);
FREE(fdp);
lFreeList(&lp);
DRETURN(NULL);
}
/* Initialize found array */
for (i = 0; i < n; i++)
found[i] = -1;
/* Here warnings are displayed if there are additional or missing fields */
for (j = 0; fdp[j].nm != NoName; j++) {
for (i = 0; i < n; i++) {
if (dp[i].nm == fdp[j].nm &&
dp[i].mt == fdp[j].mt) {
if (found[i] != -1)
DPRINTF(("lUndumpList: field %s found twice\n",
lNm2Str(dp[i].nm)));
found[i] = j;
break;
}
}
if (i == n)
DPRINTF(("lUndumpList: field %s not needed\n", lNm2Str(fdp[j].nm)));
}
for (i = 0; i < n; i++)
if (found[i] == -1)
DPRINTF(("lUndumpList: field %s not found\n", lNm2Str(dp[i].nm)));
/* LOOP OVER THE LIST ELEMENTS */
for (k = 0; k < nelem; k++) {
if (!(fep = lUndumpElemFp(fp, fdp))) {
LERROR(LEUNDUMPELEM);
lFreeList(&lp);
FREE(found);
FREE(fdp);
DRETURN(NULL);
}
if (!(ep = lCreateElem(dp))) {
lFreeList(&lp);
FREE(found);
FREE(fdp);
LERROR(LECREATEELEM);
DRETURN(NULL);
}
for (i = 0; i < n; i++) {
if (found[i] == -1) {
continue;
} else if (lCopySwitchPack(fep, ep, found[i], i, true, NULL, NULL) == -1) {
lFreeList(&lp);
lFreeElem(&ep);
FREE(found);
FREE(fdp);
LERROR(LECOPYSWITCH);
DRETURN(NULL);
}
}
lFreeElem(&fep);
if (lAppendElem(lp, ep) == -1) {
lFreeList(&lp);
lFreeElem(&ep);
FREE(found);
FREE(fdp);
LERROR(LEAPPENDELEM);
DRETURN(NULL);
}
}
/* read ket */
if (fGetKet(fp)) {
lFreeList(&lp);
printf("ket is missing\n");
LERROR(LESYNTAX);
}
FREE(found);
FREE(fdp);
DRETURN(lp);
}
/****** qquota_output/qquota_output() ********************************************
* NAME
* qquota_output() -- qquota output function
*
* SYNOPSIS
* bool qquota_output(void *ctx, lList *host_list, lList *resource_match_list,
* lList *user_list, lList *pe_list, lList *project_list, lList
* *cqueue_list, lList **alpp, report_handler_t* report_handler)
*
* FUNCTION
* print resource quota rule and the limit
*
* INPUTS
* void *ctx - gdi handler
* lList *host_list - selected hosts
* lList *resource_match_list - selected resources
* lList *user_list - selected users
* lList *pe_list - selecte pes
* lList *project_list - selected projects
* lList *cqueue_list - selected cluster queues
* lList **alpp - answer list
* report_handler_t* report_handler - report handler for xml output
*
* RESULT
* bool - true on success
* false on error
*
* NOTES
* MT-NOTE: qquota_output() is MT safe
*
*******************************************************************************/
bool qquota_output(sge_gdi_ctx_class_t *ctx, lList *host_list, lList *resource_match_list, lList *user_list,
lList *pe_list, lList *project_list, lList *cqueue_list, lList **alpp,
report_handler_t* report_handler)
{
lList *rqs_list = NULL;
lList *centry_list = NULL;
lList *userset_list = NULL;
lList *hgroup_list = NULL;
lList *exechost_list = NULL;
lListElem* global_host = NULL;
lListElem* exec_host = NULL;
lList* printed_rules = NULL; /* Hash list of already printed resource quota rules (possible with -u user1,user2,user3...) */
bool ret = true;
int xml_ret = 0;
qquota_filter_t qquota_filter = { "*",
"*",
"*",
"*",
"*" };
dstring rule_name = DSTRING_INIT;
DENTER(TOP_LAYER, "qquota_output");
/* If no user is requested on command line we set the current user as default */
qquota_filter.user = ctx->get_username(ctx);
ret = get_all_lists(ctx, &rqs_list, ¢ry_list, &userset_list, &hgroup_list, &exechost_list, host_list, alpp);
if (ret == true) {
lListElem *rqs = NULL;
printed_rules = lCreateList("rule_hash", ST_Type);
global_host = host_list_locate(exechost_list, SGE_GLOBAL_NAME);
if (report_handler != NULL) {
xml_ret = report_handler->report_started(report_handler, alpp);
if (xml_ret != QQUOTA_SUCCESS) {
ret = false;
goto qquota_output_error;
}
}
for_each(rqs, rqs_list) {
lListElem *rule = NULL;
int rule_count = 1;
if (lGetBool(rqs, RQS_enabled) == false) {
continue;
}
for_each(rule, lGetList(rqs, RQS_rule)) {
lListElem *user_ep = lFirst(user_list);
lListElem *project_ep = lFirst(project_list);
lListElem *pe_ep = lFirst(pe_list);
lListElem *queue_ep = lFirst(cqueue_list);
lListElem *host_ep = lFirst(host_list);
do {
if (user_ep != NULL) {
qquota_filter.user = lGetString(user_ep, ST_name);
}
do {
if (project_ep != NULL) {
qquota_filter.project = lGetString(project_ep, ST_name);
}
do {
if (pe_ep != NULL) {
qquota_filter.pe = lGetString(pe_ep, ST_name);
}
do {
if (queue_ep != NULL) {
qquota_filter.queue = lGetString(queue_ep, ST_name);
}
do {
if (host_ep != NULL) {
qquota_filter.host = lGetString(host_ep, ST_name);
}
if (rqs_is_matching_rule(rule, qquota_filter.user, NULL, qquota_filter.project,
qquota_filter.pe, qquota_filter.host,
qquota_filter.queue, userset_list, hgroup_list)) {
lListElem *limit = NULL;
for_each(limit, lGetList(rule, RQR_limit)) {
const char *limit_name = lGetString(limit, RQRL_name);
lList *rue_list = lGetList(limit, RQRL_usage);
lListElem *raw_centry = centry_list_locate(centry_list, limit_name);
lListElem *rue_elem = NULL;
if (raw_centry == NULL) {
/* undefined centries can be ignored */
DPRINTF(("centry %s not defined -> IGNORING\n", limit_name));
continue;
}
if ((resource_match_list != NULL) &&
((centry_list_locate(resource_match_list, limit_name) == NULL) &&
(centry_list_locate(resource_match_list, lGetString(raw_centry, CE_shortcut)) == NULL))) {
DPRINTF(("centry %s was not requested on CLI -> IGNORING\n", limit_name));
continue;
}
if (lGetString(rule, RQR_name)) {
sge_dstring_sprintf(&rule_name, "%s/%s", lGetString(rqs, RQS_name), lGetString(rule, RQR_name));
} else {
sge_dstring_sprintf(&rule_name, "%s/%d", lGetString(rqs, RQS_name), rule_count);
}
if (lGetUlong(raw_centry, CE_consumable)) {
/* for consumables we need to walk through the utilization and search for matching values */
DPRINTF(("found centry %s - consumable\n", limit_name));
for_each(rue_elem, rue_list) {
u_long32 dominant = 0;
const char *rue_name = lGetString(rue_elem, RUE_name);
char *cp = NULL;
stringT user, project, pe, queue, host;
dstring limit_str = DSTRING_INIT;
dstring value_str = DSTRING_INIT;
qquota_filter_t qf = { NULL, NULL, NULL, NULL, NULL };
/* check user name */
cp = qquota_get_next_filter(user, rue_name);
/* usergroups have the same beginning character @ as host groups */
if (is_hgroup_name(qquota_filter.user)) {
lListElem *ugroup = NULL;
if ((ugroup = userset_list_locate(userset_list, &qquota_filter.user[1])) != NULL) {
if (sge_contained_in_access_list(user, NULL, ugroup, NULL) == 0) {
continue;
}
}
} else {
if ((strcmp(user, "-") != 0) && (strcmp(qquota_filter.user, "*") != 0)
&& (fnmatch(qquota_filter.user, user, 0) != 0)) {
continue;
}
}
/* check project */
cp = qquota_get_next_filter(project, cp);
if ((strcmp(project, "-") != 0) && (strcmp(qquota_filter.project, "*") != 0)
&& (fnmatch(qquota_filter.project, project, 0) != 0)) {
continue;
}
/* check parallel environment */
cp = qquota_get_next_filter(pe, cp);
if ((strcmp(pe, "-") != 0) && (strcmp(qquota_filter.pe, "*") != 0) &&
(fnmatch(qquota_filter.pe, pe, 0) != 0) ) {
continue;
}
/* check cluster queue */
cp = qquota_get_next_filter(queue, cp);
if ((strcmp(queue, "-") != 0) && (strcmp(qquota_filter.queue, "*") != 0) &&
(fnmatch(qquota_filter.queue, queue, 0) != 0)) {
continue;
}
/* check host name */
cp = qquota_get_next_filter(host, cp);
if (is_hgroup_name(qquota_filter.host)) {
lListElem *hgroup = NULL;
if ((hgroup = hgroup_list_locate(hgroup_list, qquota_filter.host)) != NULL) {
lList *host_list = NULL;
hgroup_find_all_references(hgroup, NULL, hgroup_list, &host_list, NULL);
if (host_list == NULL && lGetElemHost(host_list, HR_name, host) == NULL) {
lFreeList(&host_list);
continue;
}
lFreeList(&host_list);
}
} else {
if ((strcmp(host, "-") != 0) && (strcmp(qquota_filter.host, "*") != 0) &&
(fnmatch(qquota_filter.host, host, 0) != 0) ) {
continue;
}
}
if (lGetBool(limit, RQRL_dynamic)) {
exec_host = host_list_locate(exechost_list, host);
sge_dstring_sprintf(&limit_str, "%d", (int)scaled_mixed_load(lGetString(limit, RQRL_value),
global_host, exec_host, centry_list));
} else {
lSetDouble(raw_centry, CE_pj_doubleval, lGetDouble(limit, RQRL_dvalue));
sge_get_dominant_stringval(raw_centry, &dominant, &limit_str);
}
lSetDouble(raw_centry,CE_pj_doubleval, lGetDouble(rue_elem, RUE_utilized_now));
sge_get_dominant_stringval(raw_centry, &dominant, &value_str);
qf.user = user;
qf.project = project;
qf.pe = pe;
qf.queue = queue;
qf.host = host;
ret = qquota_print_out_rule(rule, rule_name, limit_name,
sge_dstring_get_string(&value_str), sge_dstring_get_string(&limit_str),
qf, raw_centry, report_handler, printed_rules, alpp);
sge_dstring_free(&limit_str);
sge_dstring_free(&value_str);
}
} else {
/* static values */
qquota_filter_t qf = { NULL, NULL, NULL, NULL, NULL };
DPRINTF(("found centry %s - static value\n", limit_name));
ret = qquota_print_out_rule(rule, rule_name, limit_name,
NULL, lGetString(limit, RQRL_value),
qf, raw_centry, report_handler, printed_rules, alpp);
}
}
}
} while ((host_ep = lNext(host_ep)));
} while ((queue_ep = lNext(queue_ep)));
} while ((pe_ep = lNext(pe_ep)));
} while ((project_ep = lNext(project_ep)));
/*-------------------------------------------------------------------------*/
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;
}
static void do_test(bool unique_hash, bool non_unique_hash,
int num_objects, int num_names)
{
lList *lp = NULL;
lList *copy;
lListElem *ep;
clock_t now, start;
struct tms tms_buffer;
#ifdef MALLINFO
struct mallinfo meminfo;
#endif
int i;
#ifdef HASH_STATISTICS
cull_htable cht;
dstring stat_dstring = DSTRING_INIT;
#endif
/* measurement data */
double prof_create, /* create objects */
prof_copy, /* copy list including all hashtables */
prof_rau, /* random access by unique attrib */
prof_inu, /* iterate by non unique attrib */
prof_curo, /* change unique attrib of random object */
prof_cnuro, /* change non unique attrib of random object */
prof_dru, /* delete random object by unique attribute */
prof_dinu; /* delete by iterating over non unique attrib */
int objs_dru, /* objects deleted by random unique */
objs_dinu; /* objects deleted by iterate non unique */
/* create list and hash tables */
lp = lCreateList("test list ", DESCR);
if (unique_hash) {
cull_hash_new(lp, NM_ULONG, true);
}
if (non_unique_hash) {
cull_hash_new(lp, NM_STRING, false);
}
#ifdef HASH_STATISTICS
cht = lp->descr[1].ht;
printf("%s\n", cull_hash_statistics(cht, &stat_dstring));
#endif
start = times(&tms_buffer);
/* TEST: build objects */
for (i = 0; i < num_objects; i++) {
ep = lAddElemUlong(&lp, NM_ULONG, i, DESCR);
lSetString(ep, NM_STRING, names[rand() % num_names]);
}
/* measure time */
now = times(&tms_buffer);
prof_create = (now - start) * 1.0 / clk_tck;
#ifdef HASH_STATISTICS
printf("%s\n", cull_hash_statistics(cht, &stat_dstring));
#endif
/* measure memory usage */
#ifdef MALLINFO
meminfo = mallinfo();
#endif
/* TEST: copy list */
start = times(&tms_buffer);
copy = lCopyList("copy", lp);
/* measure time */
now = times(&tms_buffer);
prof_copy = (now - start) * 1.0 / clk_tck;
lFreeList(©);
/* TEST: random access by unique attrib */
start = times(&tms_buffer);
for (i = 0; i < num_objects; i++) {
ep = lGetElemUlong(lp, NM_ULONG, rand() % num_objects);
}
/* measure time */
now = times(&tms_buffer);
prof_rau = (now - start) * 1.0 / clk_tck;
start = now;
/* TEST: iterate by non unique attrib */
for (i = 0; i < num_names; i++) {
const void *iterator = NULL;
lListElem *next_ep;
next_ep = lGetElemStrFirst(lp, NM_STRING, names[i], &iterator);
while ((ep = next_ep) != NULL) {
next_ep = lGetElemStrNext(lp, NM_STRING, names[i], &iterator);
}
}
/* measure time */
now = times(&tms_buffer);
prof_inu = (now - start) * 1.0 / clk_tck;
start = now;
/* TEST: change unique attribute of random object */
/* measure time */
for (i = 0; i < num_objects; i++) {
/* object to access */
int unique = rand() % num_objects;
/* new value to set, make sure we stay unique */
int newval = unique + num_objects;
/* search object */
ep = lGetElemUlong(lp, NM_ULONG, unique);
/* set a new value */
lSetUlong(ep, NM_ULONG, newval);
/* restore old value */
lSetUlong(ep, NM_ULONG, unique);
}
now = times(&tms_buffer);
prof_curo = (now - start) * 1.0 / clk_tck;
start = now;
/* TEST: change non unique attribute of random object */
for (i = 0; i < num_objects; i++) {
/* search object */
ep = lGetElemUlong(lp, NM_ULONG, rand() % num_objects);
/* set a new value */
lSetString(ep, NM_STRING, names[rand() % num_names]);
}
/* measure time */
now = times(&tms_buffer);
prof_cnuro = (now - start) * 1.0 / clk_tck;
start = now;
/* TEST: delete random object */
objs_dru = 0;
for (i = 0; i < num_objects / 2; i++) {
/* search object */
ep = lGetElemUlong(lp, NM_ULONG, rand() % num_objects);
/* if same rand showed up earlier, object does no longer exist! */
if (ep != NULL) {
lRemoveElem(lp, &ep);
objs_dru++;
}
}
/* measure time */
now = times(&tms_buffer);
prof_dru = (now - start) * 1.0 / clk_tck;
start = now;
/* TEST: delete all objects having the same non unique attribute */
objs_dinu = 0;
for (i = 0; i < num_names; i++) {
const void *iterator = NULL;
lListElem *next_ep;
next_ep = lGetElemStrFirst(lp, NM_STRING, names[i], &iterator);
while ((ep = next_ep) != NULL) {
next_ep = lGetElemStrNext(lp, NM_STRING, names[i], &iterator);
lRemoveElem(lp, &ep);
objs_dinu++;
}
}
/* measure time */
now = times(&tms_buffer);
prof_dinu = (now - start) * 1.0 / clk_tck;
start = now;
printf(DATA_FORMAT,
unique_hash ? " * " : " ",
non_unique_hash ? " * " : " ",
prof_create,
prof_copy,
prof_rau, prof_inu,
prof_curo, prof_cnuro,
prof_dru, objs_dru, prof_dinu, objs_dinu,
#ifdef MALLINFO
(meminfo.usmblks + meminfo.uordblks) / 1024
#else
0L
#endif
);
#ifdef HASH_STATISTICS
printf("%s\n", cull_hash_statistics(cht, &stat_dstring));
sge_dstring_free(&stat_dstring);
#endif
lFreeList(&lp);
}
int main(int argc, char *argv[])
{
lList *queuelist = NULL, *joblist = NULL;
enum {
MATCH_REQUEST,
LOOP_JOBS_QUEUES
/* SUBWHERE */
};
int scene, fulfilled, numdiddeldum;
lList *erglist = NULL;
lListElem *job, *queue;
lCondition *where = NULL;
lEnumeration *w0, *w1, *nothing, *all;
lList *queuecomplexes = NULL, *attributes = NULL;
lListElem *attribute, *request;
const char *operator;
DENTER_MAIN(TOP_LAYER, "example2");
if (argc != 3)
usage();
sscanf(argv[1], "%d", &scene);
sscanf(argv[2], "%d", &numdiddeldum);
/* neccessary for comfortable output */
lInit(nmv);
queuelist = buildQueueList();
printf("\n\nQUEUELIST\n\n");
lWriteList(queuelist);
COMPLEXLIST = buildComplexList();
printf("\n\nCOMPLEXLIST\n\n");
lWriteList(COMPLEXLIST);
joblist = buildJobList(numdiddeldum);
printf("\n\nJOBLIST\n\n");
lWriteList(joblist);
printf("\n******** BEGIN PROCESSING *********\n\n");
switch (scene) {
case MATCH_REQUEST:
/*
find for each job in the joblist all queues that
suffer the request of this job
( implemented with quick list functions )
*/
for_each(job, joblist) {
printf("\n-------------------------------"
"-------------------------------\n");
printf("*** job %s may get started in the following queues ***\n\n",
lGetString(job, J_name));
for_each(queue, queuelist) {
if (matchRequest(lGetList(queue, Q_complexname),
lGetList(job, J_hardrequest))) {
if (!erglist)
if (!(erglist = lCreateList("erglist", QueueT))) {
printf("case MATCH_REQUEST: lCreateList"
" failure\n");
exit(-1);
}
lAppendElem(erglist, lCopyElem(queue));
}
}
printf("\n\n**** ERGLIST ****\n\n");
if (erglist) {
lWriteList(erglist);
lFreeList(&erglist);
erglist = NULL;
}
}
break;
case LOOP_JOBS_QUEUES:
/*
find for each job in the joblist all queues that
suffer the request of this job
( implemented with mighty database-like functions )
*/
for_each(job, joblist) {
printf("\n--------------------------------------------------------------\n");
printf("*** job %s may get started in the following queues ***\n\n",
lGetString(job, J_name));
for_each(queue, queuelist) {
/*
build a list of the complexes of the queue
therefore: build a subset of the complex list
with the queues complex name list as a selector
join the complex name list of the queue
( join field: N_complexname)
with the global complex list
( join field: C_name )
select nothing from the queue's complex name list (w0)
and only the attributes of the global complex list (w1)
every valid combination is needed, so the
where parameter is NULL for both lists
*/
w0 = lWhat("%T(NONE)", ComplexNameT); /* NIX */
w1 = lWhat("%T(%I)", ComplexT, C_attribute);
queuecomplexes = lJoin("queuecomplexes",
N_complexname, lGetList(queue, Q_complexname), NULL, w0,
C_name, COMPLEXLIST, NULL, w1);
lFreeWhat(&w0);
lFreeWhat(&w1);
/*
try to find a hard request of this job
that is not fulfilled by the queue's complexes
*/
fulfilled = 1;
for_each(request, lGetList(job, J_hardrequest)) {
/*
build a flat complex attribute list with only
these attributes of the request
this produces a attribute list of all complexes
*/
nothing = lWhat("%T(NONE)", lGetListDescr(queuecomplexes));
all = lWhat("%T(ALL)", ComplexAttributeT);
where = lWhere("%T( %I == %s )", ComplexAttributeT,
A_name,
lGetString(request, R_name));
attributes = lJoinSublist("attributelist",
C_attribute, queuecomplexes, NULL, nothing,
ComplexAttributeT, where, all);
lFreeWhere(&where);
lFreeWhat(¬hing);
lFreeWhat(&all);
/*
if we get an empty list then the queue has
no complex fulfilling the request of this job
*/
/*
right now the lJoinSublist function returns
an empty list (no elements) if there was no sublist
*/
if (lGetNumberOfElem(attributes) == 0) {
fulfilled = 0;
break; /* leave request loop */
}
/*
if there are attributes the values of at least one
complex of the queue must fulfill the request
*/
for_each(attribute, attributes) {
operator = lGetString(request, R_operator);
if (strcmp(operator, "==") == 0) {
fulfilled = (!strcmp(
lGetString(attribute, A_value),
lGetString(request, R_value)));
}
else if (strcmp(operator, "!=") == 0) {
fulfilled = (strcmp(
lGetString(attribute, A_value),
lGetString(request, R_value)));
} /* else if .. ( for all operators ) */
if (fulfilled)
break; /* leave attribute loop */
}
/****** 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
}
}
}
/****** cull/db/lJoin() *******************************************************
* NAME
* lJoin() -- Joins two lists together
*
* SYNOPSIS
* lList* lJoin(const char *name, int nm0, const lList *lp0,
* const lCondition *cp0, const lEnumeration *enp0,
* int nm1, const lList *lp1, const lCondition *cp1,
* const lEnumeration *enp1)
*
* FUNCTION
* Returns a new list joining together the lists 'lp0' and 'lp1'
* For the join only these 'lines' described in condition 'cp0'
* and 'cp1' are used.
* The new list gets only these members described in 'enp0' and
* 'enp1'. NULL means every member of this list.
* The list gets 'name' as listname.
*
* INPUTS
* const char *name - name of new list
* int nm0 -
* const lList *lp0 - first list
* const lCondition *cp0 - selects rows of first list
* const lEnumeration *enp0 - selects column of first list
* int nm1 -
* const lList *lp1 - second list
* const lCondition *cp1 - selects rows of second list
* const lEnumeration *enp1 - selects column of seconf list
*
* RESULT
* lList* - Joined list
******************************************************************************/
lList *lJoin(const char *name, int nm0, const lList *lp0,
const lCondition *cp0, const lEnumeration *enp0, int nm1,
const lList *lp1, const lCondition *cp1, const lEnumeration *enp1)
{
lListElem *ep0, *ep1;
lListElem *ep;
lList *dlp = NULL;
lDescr *dp;
int lp0_pos = 0, lp1_pos = 0;
int i, j;
int needed;
DENTER(CULL_LAYER, "lJoin");
if (!lp0 || !lp1 || !name || !enp0 || !enp1) {
LERROR(LENULLARGS);
DEXIT;
return NULL;
}
if (nm1 != NoName) {
if ((lp0_pos = lGetPosInDescr(lGetListDescr(lp0), nm0)) < 0) {
LERROR(LENAMENOT);
DEXIT;
return NULL;
}
if ((lp1_pos = lGetPosInDescr(lGetListDescr(lp1), nm1)) < 0) {
LERROR(LENAMENOT);
DEXIT;
return NULL;
}
if (mt_get_type(lp0->descr[lp0_pos].mt) != mt_get_type(lp1->descr[lp1_pos].mt) ||
mt_get_type(lp0->descr[lp0_pos].mt) == lListT) {
LERROR(LEDIFFDESCR);
DEXIT;
return NULL;
}
}
/* the real join ?! */
if (!(dp = lJoinDescr(lGetListDescr(lp0), lGetListDescr(lp1), enp0, enp1))) {
LERROR(LEJOINDESCR);
DEXIT;
return NULL;
}
if (!(dlp = lCreateList(name, dp))) {
LERROR(LECREATELIST);
sge_free(&dp);
DEXIT;
return NULL;
}
/* free dp it has been copied by lCreateList */
sge_free(&dp);
for (i = 0, ep0 = lp0->first; i < lp0->nelem; i++, ep0 = ep0->next) {
if (!lCompare(ep0, cp0))
continue;
for (j = 0, ep1 = lp1->first; j < lp1->nelem; j++, ep1 = ep1->next) {
if (!lCompare(ep1, cp1))
continue;
if (nm1 != NoName) { /* in this case take it always */
/* This is a comparison of the join fields nm0 , nm1 */
switch (mt_get_type(lp0->descr[lp0_pos].mt)) {
case lIntT:
needed = (ep0->cont[lp0_pos].i == ep1->cont[lp1_pos].i);
break;
case lUlongT:
needed = (ep0->cont[lp0_pos].ul == ep1->cont[lp1_pos].ul);
break;
case lStringT:
needed = !strcmp(ep0->cont[lp0_pos].str, ep1->cont[lp1_pos].str);
break;
case lHostT:
needed = !strcmp(ep0->cont[lp0_pos].str, ep1->cont[lp1_pos].str);
break;
case lLongT:
needed = (ep0->cont[lp0_pos].l == ep1->cont[lp1_pos].l);
break;
case lFloatT:
needed = (ep0->cont[lp0_pos].fl == ep1->cont[lp1_pos].fl);
break;
case lDoubleT:
needed = (ep0->cont[lp0_pos].db == ep1->cont[lp1_pos].db);
break;
case lCharT:
needed = (ep0->cont[lp0_pos].c == ep1->cont[lp1_pos].c);
break;
case lBoolT:
needed = (ep0->cont[lp0_pos].b == ep1->cont[lp1_pos].b);
break;
case lRefT:
needed = (ep0->cont[lp0_pos].ref == ep1->cont[lp1_pos].ref);
break;
default:
unknownType("lJoin");
DEXIT;
return NULL;
}
if (!needed)
continue;
}
if (!(ep = lJoinCopyElem(dlp->descr, ep0, enp0, ep1, enp1))) {
LERROR(LEJOINCOPYELEM);
lFreeList(&dlp);
DEXIT;
return NULL;
}
else {
if (lAppendElem(dlp, ep) == -1) {
LERROR(LEAPPENDELEM);
lFreeList(&dlp);
DEXIT;
return NULL;
}
}
}
}
/* RETURN AN EMPTY LIST OR NULL THAT'S THE QUESTION */
if (lGetNumberOfElem(dlp) == 0) {
lFreeList(&dlp);
}
DEXIT;
return dlp;
}
/* if the scaled usage list does not yet exist, it is created and returned */
lList *scale_usage(
lList *scaling, /* HS_Type */
lList *prev_usage, /* HS_Type */
lList *scaled_usage /* UA_Type */
) {
lListElem *sep, *ep, *prev;
if (!scaling) {
return NULL;
}
if (scaled_usage == NULL) {
scaled_usage = lCreateList("usage", UA_Type);
}
for_each (ep, scaled_usage) {
if ((sep=lGetElemStr(scaling, HS_name, lGetString(ep, UA_name)))) {
lSetDouble(ep, UA_value, lGetDouble(ep, UA_value) * lGetDouble(sep, HS_value));
}
}
if ((prev = lGetElemStr(prev_usage, UA_name, USAGE_ATTR_CPU)) != NULL) {
if ((ep=lGetElemStr(scaled_usage, UA_name, USAGE_ATTR_CPU))) {
lAddDouble(ep, UA_value, lGetDouble(prev, UA_value));
} else {
lAppendElem(scaled_usage, lCopyElem(prev));
}
}
if ((prev = lGetElemStr(prev_usage, UA_name, USAGE_ATTR_IO)) != NULL) {
if ((ep=lGetElemStr(scaled_usage, UA_name, USAGE_ATTR_IO))) {
lAddDouble(ep, UA_value, lGetDouble(prev, UA_value));
} else {
lAppendElem(scaled_usage, lCopyElem(prev));
}
}
if ((prev = lGetElemStr(prev_usage, UA_name, USAGE_ATTR_IOW)) != NULL) {
if ((ep=lGetElemStr(scaled_usage, UA_name, USAGE_ATTR_IOW))) {
lAddDouble(ep, UA_value, lGetDouble(prev, UA_value));
} else {
lAppendElem(scaled_usage, lCopyElem(prev));
}
}
if ((prev = lGetElemStr(prev_usage, UA_name, USAGE_ATTR_VMEM)) != NULL) {
if ((ep=lGetElemStr(scaled_usage, UA_name, USAGE_ATTR_VMEM))) {
lAddDouble(ep, UA_value, lGetDouble(prev, UA_value));
} else {
lAppendElem(scaled_usage, lCopyElem(prev));
}
}
if ((prev = lGetElemStr(prev_usage, UA_name, USAGE_ATTR_MAXVMEM)) != NULL) {
if ((ep=lGetElemStr(scaled_usage, UA_name, USAGE_ATTR_MAXVMEM))) {
lAddDouble(ep, UA_value, lGetDouble(prev, UA_value));
} else {
lAppendElem(scaled_usage, lCopyElem(prev));
}
}
if ((prev = lGetElemStr(prev_usage, UA_name, USAGE_ATTR_MEM)) != NULL) {
if ((ep=lGetElemStr(scaled_usage, UA_name, USAGE_ATTR_MEM))) {
lAddDouble(ep, UA_value, lGetDouble(prev, UA_value));
} else {
lAppendElem(scaled_usage, lCopyElem(prev));
}
}
return scaled_usage;
}
/************************************************************
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;
}
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;
}
/*-------------------------------------------------------------------------*/
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;
}
int main(int argc, char **argv) {
lList *pcmdline = NULL;
lList *alp = NULL;
sge_gdi_ctx_class_t *ctx = NULL;
lList *ar_lp = NULL;
lListElem *ar = NULL;
DENTER_MAIN(TOP_LAYER, "qrsub");
/* Set up the program information name */
sge_setup_sig_handlers(QRSUB);
log_state_set_log_gui(1);
if (sge_gdi2_setup(&ctx, QRSUB, MAIN_THREAD, &alp) != AE_OK) {
answer_list_output(&alp);
goto error_exit;
}
/*
** stage 1 of commandline parsing
*/
{
dstring file = DSTRING_INIT;
const char *user = ctx->get_username(ctx);
const char *cell_root = ctx->get_cell_root(ctx);
/* arguments from SGE_ROOT/common/sge_ar_request file */
get_root_file_path(&file, cell_root, SGE_COMMON_DEF_AR_REQ_FILE);
if ((alp = parse_script_file(QRSUB, sge_dstring_get_string(&file), "", &pcmdline, environ,
FLG_HIGHER_PRIOR | FLG_IGN_NO_FILE)) == NULL) {
/* arguments from $HOME/.sge_ar_request file */
if (get_user_home_file_path(&file, SGE_HOME_DEF_AR_REQ_FILE, user, &alp)) {
lFreeList(&alp);
alp = parse_script_file(QRSUB, sge_dstring_get_string(&file), "", &pcmdline, environ,
FLG_HIGHER_PRIOR | FLG_IGN_NO_FILE);
}
}
sge_dstring_free(&file);
if (alp) {
answer_list_output(&alp);
lFreeList(&pcmdline);
goto error_exit;
}
}
alp = cull_parse_cmdline(QRSUB, argv+1, environ, &pcmdline, FLG_USE_PSEUDOS);
if (answer_list_print_err_warn(&alp, NULL, "qrsub: ", MSG_WARNING) > 0) {
lFreeList(&pcmdline);
goto error_exit;
}
if (!pcmdline) {
/* no command line option is present: print help to stderr */
sge_usage(QRSUB, stderr);
fprintf(stderr, "%s\n", MSG_PARSE_NOOPTIONARGUMENT);
goto error_exit;
}
/*
** stage 2 of command line parsing
*/
ar = lCreateElem(AR_Type);
if (!sge_parse_qrsub(ctx, pcmdline, &alp, &ar)) {
answer_list_output(&alp);
lFreeList(&pcmdline);
goto error_exit;
}
ar_lp = lCreateList(NULL, AR_Type);
lAppendElem(ar_lp, ar);
alp = ctx->gdi(ctx, SGE_AR_LIST, SGE_GDI_ADD | SGE_GDI_RETURN_NEW_VERSION, &ar_lp, NULL, NULL);
lFreeList(&ar_lp);
answer_list_on_error_print_or_exit(&alp, stdout);
if (answer_list_has_error(&alp)) {
sge_gdi2_shutdown((void**)&ctx);
sge_prof_cleanup();
if (answer_list_has_status(&alp, STATUS_NOTOK_DOAGAIN)) {
DRETURN(25);
} else {
DRETURN(1);
}
}
sge_gdi2_shutdown((void**)&ctx);
sge_prof_cleanup();
DRETURN(0);
error_exit:
sge_gdi2_shutdown((void**)&ctx);
sge_prof_cleanup();
SGE_EXIT((void**)&ctx, 1);
DRETURN(1);
}
/*-------------------------------------------------------------------------*/
int main(int argc, char **argv)
{
int ret;
int my_pid;
int ret_val;
int printed_points = 0;
int max_enroll_tries;
static char tmp_err_file_name[SGE_PATH_MAX];
time_t next_prof_output = 0;
int execd_exit_state = 0;
lList **master_job_list = NULL;
sge_gdi_ctx_class_t *ctx = NULL;
lList *alp = NULL;
DENTER_MAIN(TOP_LAYER, "execd");
#if defined(LINUX)
gen_procList ();
#endif
prof_mt_init();
set_thread_name(pthread_self(),"Execd Thread");
prof_set_level_name(SGE_PROF_CUSTOM1, "Execd Thread", NULL);
prof_set_level_name(SGE_PROF_CUSTOM2, "Execd Dispatch", NULL);
#ifdef __SGE_COMPILE_WITH_GETTEXT__
/* init language output for gettext() , it will use the right language */
sge_init_language_func((gettext_func_type) gettext,
(setlocale_func_type) setlocale,
(bindtextdomain_func_type) bindtextdomain,
(textdomain_func_type) textdomain);
sge_init_language(NULL,NULL);
#endif /* __SGE_COMPILE_WITH_GETTEXT__ */
/* This needs a better solution */
umask(022);
/* Initialize path for temporary logging until we chdir to spool */
my_pid = getpid();
sprintf(tmp_err_file_name,"%s."sge_U32CFormat"", TMP_ERR_FILE_EXECD, sge_u32c(my_pid));
log_state_set_log_file(tmp_err_file_name);
/* exit func for SGE_EXIT() */
sge_sig_handler_in_main_loop = 0;
sge_setup_sig_handlers(EXECD);
if (sge_setup2(&ctx, EXECD, MAIN_THREAD, &alp, false) != AE_OK) {
answer_list_output(&alp);
SGE_EXIT((void**)&ctx, 1);
}
ctx->set_exit_func(ctx, execd_exit_func);
#if defined(SOLARIS)
/* Init shared SMF libs if necessary */
if (sge_smf_used() == 1 && sge_smf_init_libs() != 0) {
SGE_EXIT((void**)&ctx, 1);
}
#endif
/* prepare daemonize */
if (!getenv("SGE_ND")) {
sge_daemonize_prepare(ctx);
}
if ((ret=sge_occupy_first_three())>=0) {
CRITICAL((SGE_EVENT, MSG_FILE_REDIRECTFD_I, ret));
SGE_EXIT((void**)&ctx, 1);
}
lInit(nmv);
/* unset XAUTHORITY if set */
if (getenv("XAUTHORITY") != NULL) {
sge_unsetenv("XAUTHORITY");
}
parse_cmdline_execd(argv);
/* exit if we can't get communication handle (bind port) */
max_enroll_tries = 30;
while (cl_com_get_handle(prognames[EXECD],1) == NULL) {
ctx->prepare_enroll(ctx);
max_enroll_tries--;
if (max_enroll_tries <= 0 || shut_me_down) {
/* exit after 30 seconds */
if (printed_points != 0) {
printf("\n");
}
CRITICAL((SGE_EVENT, MSG_COM_ERROR));
SGE_EXIT((void**)&ctx, 1);
}
if (cl_com_get_handle(prognames[EXECD],1) == NULL) {
/* sleep when prepare_enroll() failed */
sleep(1);
if (max_enroll_tries < 27) {
printf(".");
printed_points++;
fflush(stdout);
}
}
}
if (printed_points != 0) {
printf("\n");
}
/*
* now the commlib up and running. Set execd application status function
* ( commlib callback function for qping status information response
* messages (SIRM) )
*/
ret_val = cl_com_set_status_func(sge_execd_application_status);
if (ret_val != CL_RETVAL_OK) {
ERROR((SGE_EVENT, cl_get_error_text(ret_val)) );
}
/* test connection */
{
cl_com_SIRM_t* status = NULL;
ret_val = cl_commlib_get_endpoint_status(ctx->get_com_handle(ctx),
(char *)ctx->get_master(ctx, true),
(char*)prognames[QMASTER], 1, &status);
if (ret_val != CL_RETVAL_OK) {
ERROR((SGE_EVENT, cl_get_error_text(ret_val)));
ERROR((SGE_EVENT, MSG_CONF_NOCONFBG));
}
cl_com_free_sirm_message(&status);
}
/* finalize daeamonize */
if (!getenv("SGE_ND")) {
sge_daemonize_finalize(ctx);
}
/* daemonizes if qmaster is unreachable */
sge_setup_sge_execd(ctx, tmp_err_file_name);
/* are we using qidle or not */
sge_ls_qidle(mconf_get_use_qidle());
sge_ls_gnu_ls(1);
DPRINTF(("use_qidle: %d\n", mconf_get_use_qidle()));
/* test load sensor (internal or external) */
{
lList *report_list = sge_build_load_report(ctx->get_qualified_hostname(ctx), ctx->get_binary_path(ctx));
lFreeList(&report_list);
}
/* here we have to wait for qmaster registration */
while (sge_execd_register_at_qmaster(ctx, false) != 0) {
if (sge_get_com_error_flag(EXECD, SGE_COM_ACCESS_DENIED, true)) {
/* This is no error */
DPRINTF(("***** got SGE_COM_ACCESS_DENIED from qmaster *****\n"));
}
if (sge_get_com_error_flag(EXECD, SGE_COM_ENDPOINT_NOT_UNIQUE, false)) {
execd_exit_state = SGE_COM_ENDPOINT_NOT_UNIQUE;
break;
}
if (shut_me_down != 0) {
break;
}
sleep(30);
}
/*
* Terminate on SIGTERM or hard communication error
*/
if (execd_exit_state != 0 || shut_me_down != 0) {
sge_shutdown((void**)&ctx, execd_exit_state);
DRETURN(execd_exit_state);
}
/*
* We write pid file when we are connected to qmaster. Otherwise an old
* execd might overwrite our pidfile.
*/
sge_write_pid(EXECD_PID_FILE);
/*
* At this point we are sure we are the only sge_execd and we are connected
* to the current qmaster. First we have to report any reaped children
* that might exist.
*/
starting_up();
/*
* Log a warning message if execd hasn't been started by a superuser
*/
if (!sge_is_start_user_superuser()) {
WARNING((SGE_EVENT, MSG_SWITCH_USER_NOT_ROOT));
}
#ifdef COMPILE_DC
if (ptf_init()) {
CRITICAL((SGE_EVENT, MSG_EXECD_NOSTARTPTF));
SGE_EXIT((void**)&ctx, 1);
}
INFO((SGE_EVENT, MSG_EXECD_STARTPDCANDPTF));
#endif
master_job_list = object_type_get_master_list(SGE_TYPE_JOB);
*master_job_list = lCreateList("Master_Job_List", JB_Type);
job_list_read_from_disk(master_job_list, "Master_Job_List",
0, SPOOL_WITHIN_EXECD,
job_initialize_job);
/* clean up jobs hanging around (look in active_dir) */
clean_up_old_jobs(ctx, 1);
execd_trash_load_report();
sge_set_flush_lr_flag(true);
sge_sig_handler_in_main_loop = 1;
if (thread_prof_active_by_id(pthread_self())) {
prof_start(SGE_PROF_CUSTOM1, NULL);
prof_start(SGE_PROF_CUSTOM2, NULL);
prof_start(SGE_PROF_GDI_REQUEST, NULL);
} else {
prof_stop(SGE_PROF_CUSTOM1, NULL);
prof_stop(SGE_PROF_CUSTOM2, NULL);
prof_stop(SGE_PROF_GDI_REQUEST, NULL);
}
PROF_START_MEASUREMENT(SGE_PROF_CUSTOM1);
/* Start dispatching */
execd_exit_state = sge_execd_process_messages(ctx);
/*
* This code is only reached when dispatcher terminates and execd goes down.
*/
/* log if we received SIGPIPE signal */
if (sge_sig_handler_sigpipe_received) {
sge_sig_handler_sigpipe_received = 0;
INFO((SGE_EVENT, "SIGPIPE received\n"));
}
#if defined(LINUX)
free_procList();
#endif
lFreeList(master_job_list);
PROF_STOP_MEASUREMENT(SGE_PROF_CUSTOM1);
if (prof_is_active(SGE_PROF_ALL)) {
time_t now = (time_t)sge_get_gmt();
if (now > next_prof_output) {
prof_output_info(SGE_PROF_ALL, false, "profiling summary:\n");
prof_reset(SGE_PROF_ALL,NULL);
next_prof_output = now + 60;
}
}
sge_prof_cleanup();
sge_shutdown((void**)&ctx, execd_exit_state);
DRETURN(execd_exit_state);
}
