/****** 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;
}
/****** cull/db/lSplit() ******************************************************
* NAME
* lSplit() -- Splits a list into two list
*
* SYNOPSIS
* int lSplit(lList **slp, lList **ulp, const char *ulp_name,
* const lCondition *cp)
*
* FUNCTION
* Unchains the list elements from the list 'slp' NOT fullfilling
* the condition 'cp' and returns a list containing the
* unchained elements in 'ulp'
*
* INPUTS
* lList **slp - source list pointer
* lList **ulp - unchained list pointer
* const char *ulp_name - 'ulp' list name
* const lCondition *cp - selects rows within 'slp'
*
* RESULT
* int - error status
* 0 - OK
* -1 - Error
******************************************************************************/
int lSplit(lList **slp, lList **ulp, const char *ulp_name,
const lCondition *cp)
{
lListElem *ep, *next;
int has_been_allocated = 0;
DENTER(TOP_LAYER, "lSplit");
/*
iterate through the source list call lCompare and chain all elems
that don't fullfill the condition into a new list.
*/
if (!slp) {
DEXIT;
return -1;
}
for (ep = lFirst(*slp); ep; ep = next) {
next = ep->next; /* this is important, cause the elem is dechained */
if (!lCompare(ep, cp)) {
if (ulp && !*ulp) {
*ulp = lCreateList(ulp_name ? ulp_name : "ulp", (*slp)->descr);
if (!*ulp) {
DEXIT;
return -1;
}
has_been_allocated = 1;
}
if (ulp) {
ep = lDechainElem(*slp, ep);
lAppendElem(*ulp, ep);
} else {
lRemoveElem(*slp, &ep);
}
}
}
/* if no elements remain, free the list and return NULL */
if (*slp && lGetNumberOfElem(*slp) == 0) {
lFreeList(slp);
}
if (has_been_allocated && *ulp && lGetNumberOfElem(*ulp) == 0) {
lFreeList(ulp);
}
DEXIT;
return 0;
}
int sge_read_sched_configuration(sge_gdi_ctx_class_t *ctx, lListElem *aSpoolContext, lList **anAnswer)
{
lList *sched_conf = NULL;
bool job_spooling = ctx->get_job_spooling(ctx);
DENTER(TOP_LAYER, "sge_read_sched_configuration");
spool_read_list(anAnswer, aSpoolContext, &sched_conf, SGE_TYPE_SCHEDD_CONF);
if (lGetNumberOfElem(sched_conf) == 0)
{
lListElem *ep = sconf_create_default();
if (sched_conf == NULL) {
sched_conf = lCreateList("schedd_config_list", SC_Type);
}
lAppendElem(sched_conf, ep);
spool_write_object(anAnswer, spool_get_default_context(), ep, "schedd_conf", SGE_TYPE_SCHEDD_CONF, job_spooling);
}
if (!sconf_set_config(&sched_conf, anAnswer))
{
lFreeList(&sched_conf);
DEXIT;
return -1;
}
check_reprioritize_interval(ctx, anAnswer, "local" , "local");
DEXIT;
return 0;
}
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);
}
}
}
/*-------------------------------------------------------------------------*/
int sge_send_all_reports(sge_gdi_ctx_class_t *ctx, u_long32 now, int which,
report_source *report_sources)
{
int ret = 0;
unsigned long connect_time = 0;
DENTER(TOP_LAYER, "sge_send_all_reports");
/*
* Send reports only if there is not a communication error.
* Don't reset stored communication errors.
*/
cl_commlib_get_connect_time(ctx->get_com_handle(ctx),
(char *)ctx->get_master(ctx, true), (char*)prognames[QMASTER], 1,
&connect_time);
if (get_last_qmaster_register_time() >= connect_time && connect_time != 0) {
if (sge_get_com_error_flag(EXECD, SGE_COM_WAS_COMMUNICATION_ERROR, false) == false) {
const char *master_host = NULL;
lList *report_list = NULL;
int i = 0;
master_host = ctx->get_master(ctx, false);
DPRINTF(("SENDING LOAD AND REPORTS\n"));
report_list = lCreateList("report list", REP_Type);
for (i = 0; report_sources[i].type; i++) {
if (!which || which == report_sources[i].type) {
DPRINTF(("%s\n", report_types[report_sources[i].type - 1]));
report_sources[i].func(ctx, report_list, now, &(report_sources[i].next_send));
}
}
/* send load report asynchron to qmaster */
if (lGetNumberOfElem(report_list) > 0) {
/* wrap around */
if (++sge_execd_report_seqno == 10000) {
sge_execd_report_seqno = 0;
}
report_list_send(ctx, report_list, master_host, prognames[QMASTER], 1, 0);
}
lFreeList(&report_list);
}
} else {
ret = 1;
}
DRETURN(ret);
}
int schedd_log_list(lList **monitor_alpp, bool monitor_next_run, const char *logstr, lList *lp, int nm) {
int fields[] = { 0, 0 };
const char *delis[] = {NULL, " ", NULL};
lList *lp_part = NULL;
lListElem *ep = NULL;
DENTER(TOP_LAYER, "schedd_log_list");
#ifndef WIN32NATIVE
if (monitor_alpp == NULL && !monitor_next_run) {
DRETURN(0);
}
fields[0] = nm;
for_each(ep, lp) {
if (!lp_part) {
lp_part = lCreateList("partial list", lGetListDescr(lp));
}
lAppendElem(lp_part, lCopyElem(ep));
if ((lGetNumberOfElem(lp_part) == NUM_ITEMS_ON_LINE) || !lNext(ep)) {
char log_string[2048];
sge_strlcpy(log_string, logstr, sizeof(log_string));
#ifndef WIN32NATIVE
uni_print_list(NULL,
log_string + strlen(log_string),
sizeof(log_string) - strlen(log_string) - 1,
lp_part,
fields, delis, 0);
#endif
schedd_log(log_string, monitor_alpp, monitor_next_run);
lFreeList(&lp_part);
lp_part = NULL;
}
}
#else
DPRINTF(("schedd_log_list does nothing for QMonNT !!!\n"));
#endif
DEXIT;
return 0;
}
/****** cull/dump_scan/lDumpList() ********************************************
* NAME
* lDumpList() -- Writes a list to a FILE stream
*
* SYNOPSIS
* int lDumpList(FILE *fp, const lList *lp, int indent)
*
* FUNCTION
* Writes a list to a FILE stream.
*
* INPUTS
* FILE *fp - file stream
* const lList *lp - list
* int indent -
*
* RESULT
* int - error state
* 0 - OK
* -1 - Error
*
* NOTES
* MT-NOTE: lDumpList() is not MT safe
*******************************************************************************/
int lDumpList(FILE *fp, const lList *lp, int indent)
{
lListElem *ep;
int i, ret = ~EOF;
char space[256];
DENTER(CULL_LAYER, "lDumpList");
space[0] = '\0';
for (i = 0; i < indent; i++)
strcat(space, INDENT_STRING);
if (!fp) {
LERROR(LEFILENULL);
DEXIT;
return -1;
}
if (!lp) {
LERROR(LELISTNULL);
DEXIT;
return -1;
}
ret = fprintf(fp, "%s{ /* LIST BEGIN */\n", space);
ret = fprintf(fp, "%s/* LISTNAME */ \"%s\"\n", space,
lGetListName(lp));
ret = fprintf(fp, "%s/* NUMBER OF ELEMENTS */ %d\n", space,
lGetNumberOfElem(lp));
ret = lDumpDescr(fp, lGetListDescr(lp), indent);
for (ep = lFirst(lp); ep && ret != EOF; ep = lNext(ep))
ret = lDumpElemFp(fp, ep, indent);
ret = fprintf(fp, "%s} /* LIST END */\n", space);
DEXIT;
return (ret == EOF) ? -1 : 0;
}
/****** 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_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;
}
/* - -- -- -- -- -- -- -- -- -- -- -- -- -- -
user_args - a cull list(UE_Type) of users
acl_args - a cull list(US_Type) of acl
returns
0 on success
-1 on error
*/
int sge_client_add_user(
sge_gdi_ctx_class_t *ctx,
lList **alpp,
lList *user_args,
lList *acl_args
) {
lListElem *userarg, *aclarg;
lList *acl=NULL, *answers=NULL;
const char *acl_name, *user_name;
lCondition *where;
lEnumeration *what;
u_long32 status;
int already;
DENTER(TOP_LAYER, "sge_client_add_user");
what = lWhat("%T(ALL)", US_Type);
for_each(aclarg,acl_args) {
acl_name = lGetString(aclarg, US_name);
where = lWhere("%T(%I==%s)", US_Type, US_name, acl_name);
for_each(userarg, user_args) {
already = 0;
user_name=lGetString(userarg, UE_name);
/* get old acl */
answers = ctx->gdi(ctx, SGE_US_LIST, SGE_GDI_GET, &acl, where, what, false);
lFreeList(&answers);
if (acl && lGetNumberOfElem(acl) > 0) {
if (!lGetSubStr(lFirst(acl), UE_name, user_name, US_entries)) {
lAddSubStr(lFirst(acl), UE_name, user_name, US_entries, UE_Type);
/* mod the acl */
answers = ctx->gdi(ctx, SGE_US_LIST, SGE_GDI_MOD, &acl,
NULL, NULL, false);
} else {
already = 1;
}
} else {
/* build new list */
lAddElemStr(&acl, US_name, acl_name, US_Type);
lAddSubStr(lFirst(acl), UE_name, user_name, US_entries, UE_Type);
/* add the acl */
answers = ctx->gdi(ctx, SGE_US_LIST, SGE_GDI_ADD, &acl,
NULL, NULL, false);
}
if (already) {
status = STATUS_EEXIST;
SGE_ADD_MSG_ID( sprintf(SGE_EVENT, MSG_GDI_USERINACL_SS, user_name, acl_name));
}
else {
if ((status = lGetUlong(lFirst(answers), AN_status))!=STATUS_OK) {
const char *cp;
cp = lGetString(lFirst(answers), AN_text);
if (cp) {
sprintf(SGE_EVENT, "%s", cp);
}
else {
SGE_ADD_MSG_ID( sprintf(SGE_EVENT, MSG_GDI_CANTADDTOACL_SS, user_name, acl_name));
}
} else {
sprintf(SGE_EVENT, MSG_GDI_ADDTOACL_SS, user_name, acl_name);
}
lFreeList(&answers);
}
answer_list_add(alpp, SGE_EVENT, status,
((status == STATUS_OK) ? ANSWER_QUALITY_INFO : ANSWER_QUALITY_ERROR));
lFreeList(&acl);
}
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 */
}
void *
sge_event_master_main(void *arg)
{
bool do_endlessly = true;
cl_thread_settings_t *thread_config = (cl_thread_settings_t*)arg;
sge_gdi_ctx_class_t *ctx = NULL;
monitoring_t monitor;
monitoring_t *monitorp = &monitor;
lListElem *report = NULL;
lList *report_list = NULL;
time_t next_prof_output = 0;
DENTER(TOP_LAYER, "sge_event_master_main");
DPRINTF(("started"));
cl_thread_func_startup(thread_config);
sge_monitor_init(&monitor, thread_config->thread_name, EDT_EXT, EMT_WARNING, EMT_ERROR);
sge_qmaster_thread_init(&ctx, QMASTER, DELIVERER_THREAD, true);
/* register at profiling module */
set_thread_name(pthread_self(), "Deliver Thread");
conf_update_thread_profiling("Deliver Thread");
report_list = lCreateListHash("report list", REP_Type, false);
report = lCreateElem(REP_Type);
lSetUlong(report, REP_type, NUM_REP_REPORT_EVENTS);
lSetHost(report, REP_host, ctx->get_qualified_hostname(ctx));
lAppendElem(report_list, report);
while (do_endlessly) {
int execute = 0;
thread_start_stop_profiling();
/*
* did a new event arrive which has a flush time of 0 seconds?
*/
MONITOR_IDLE_TIME(sge_event_master_wait_next(), (&monitor), mconf_get_monitor_time(),
mconf_is_monitor_message());
MONITOR_MESSAGES((monitorp));
MONITOR_EDT_COUNT((&monitor));
MONITOR_CLIENT_COUNT((&monitor), lGetNumberOfElem(Event_Master_Control.clients));
sge_event_master_process_requests(&monitor);
sge_event_master_send_events(ctx, report, report_list, &monitor);
sge_monitor_output(&monitor);
thread_output_profiling("event master thread profiling summary:\n",
&next_prof_output);
/* pthread cancelation point */
pthread_cleanup_push((void (*)(void *))sge_event_master_cleanup_monitor,
(void *)&monitor);
pthread_cleanup_push((void (*)(void *))sge_event_master_cleanup_report_list,
(void *)&report_list);
cl_thread_func_testcancel(thread_config);
pthread_cleanup_pop(execute);
pthread_cleanup_pop(execute);
if (sge_thread_has_shutdown_started()) {
DPRINTF(("waiting for termination\n"));
sleep(1);
}
}
/*
* Don't add cleanup code here. It will never be executed. Instead register
* a cleanup function with pthread_cleanup_push()/pthread_cleanup_pop() before
* and after the call of cl_thread_func_testcancel()
*/
DRETURN(NULL);
}
/*-------------------------------------------------------------------------*/
static void qmonUserAskForProject(Widget w, XtPointer cld, XtPointer cad)
{
XbaeMatrixLabelActivateCallbackStruct *cbs =
(XbaeMatrixLabelActivateCallbackStruct *) cad;
Boolean status = False;
lList *pl = NULL;
lListElem *cep = NULL;
int n, i;
StringConst *strs = NULL;
static char buf[BUFSIZ];
lList *lp = NULL;
lList *alp = NULL;
lListElem *ep;
static lEnumeration *what = NULL;
DENTER(GUI_LAYER, "qmonUserAskForProject");
if (!what) {
what = lWhat("%T(%I %I)", UU_Type, UU_name, UU_default_project);
}
if (cbs->column != 1) {
DEXIT;
return;
}
qmonMirrorMultiAnswer(PROJECT_T, &alp);
if (alp) {
qmonMessageBox(w, alp, 0);
lFreeList(&alp);
DEXIT;
return;
}
pl = qmonMirrorList(SGE_PR_LIST);
lPSortList(pl, "%I+", PR_name);
n = lGetNumberOfElem(pl);
if (n>0) {
strs = (StringConst*)XtMalloc(sizeof(String)*(n+1));
strs[0] = "NONE";
for (cep=lFirst(pl), i=0; i<n; cep=lNext(cep), i++) {
/*
** we get only references don't free, the strings
*/
strs[i+1] = lGetString(cep, PR_name);
}
strcpy(buf, "");
/* FIX_CONST_GUI */
status = XmtAskForItem(w, NULL, "@{Select a project}",
"@{Available projects}", (String*)strs, n+1,
False, buf, BUFSIZ, NULL);
if (status) {
int rows, i;
rows = XbaeMatrixNumRows(user_matrix);
for (i=0; i<rows; i++) {
String s = XbaeMatrixGetCell(user_matrix, i, 0);
if (XbaeMatrixIsRowSelected(user_matrix, i) && s &&
strcmp(s, "")) {
ep = lAddElemStr(&lp, UU_name, s, UU_Type);
lSetString(ep, UU_default_project, buf);
}
}
XbaeMatrixDeselectAll(user_matrix);
/*
** send to master as modify request
*/
for_each (ep, lp) {
if (ep && lGetString(ep, UU_default_project) &&
!strcasecmp(lGetString(ep, UU_default_project), "NONE"))
lSetString(ep, UU_default_project, NULL);
}
if (lp) {
alp = qmonModList(SGE_UU_LIST,
qmonMirrorListRef(SGE_UU_LIST),
UU_name, &lp, NULL, what);
qmonMessageBox(w, alp, 0);
updateManopList();
lFreeList(&alp);
lFreeList(&lp);
}
}
/*
** don't free referenced strings, they are in the pl list
*/
XtFree((char*)strs);
}
int main(int argc, char **argv) {
int ret = STATUS_OK;
lList *alp = NULL;
lList *request_list = NULL;
lList *cmdline = NULL;
lListElem *aep;
int all_jobs = 0;
int all_users = 0;
u_long32 gdi_cmd = SGE_GDI_MOD;
int tmp_ret;
int me_who;
sge_gdi_ctx_class_t *ctx = NULL;
DENTER_MAIN(TOP_LAYER, "qalter");
prof_mt_init();
/*
** get command name: qalter or qresub
*/
if (!strcmp(sge_basename(argv[0], '/'), "qresub")) {
DPRINTF(("QRESUB\n"));
me_who = QRESUB;
} else if (!strcmp(sge_basename(argv[0], '/'), "qhold")) {
DPRINTF(("QHOLD\n"));
me_who = QHOLD;
} else if (!strcmp(sge_basename(argv[0], '/'), "qrls")) {
DPRINTF(("QRLS\n"));
me_who = QRLS;
} else {
DPRINTF(("QALTER\n"));
me_who = QALTER;
}
log_state_set_log_gui(1);
sge_setup_sig_handlers(me_who);
if (sge_gdi2_setup(&ctx, me_who, MAIN_THREAD, &alp) != AE_OK) {
answer_list_output(&alp);
SGE_EXIT((void**)&ctx, 1);
}
/*
** begin to work
*/
opt_list_append_opts_from_qalter_cmdline(me_who, &cmdline, &alp, argv + 1, environ);
tmp_ret = answer_list_print_err_warn(&alp, MSG_QALTER, MSG_QALTER, MSG_QALTERWARNING);
if (tmp_ret > 0) {
SGE_EXIT((void**)&ctx, tmp_ret);
}
/* handling the case that no command line parameter was specified */
if ((me_who == QHOLD || me_who == QRLS) && lGetNumberOfElem(cmdline) == 1) {
/* -h option is set implicitly for QHOLD and QRLS */
sge_usage(me_who, stderr);
fprintf(stderr, "%s\n", MSG_PARSE_NOOPTIONARGUMENT);
SGE_EXIT((void**)&ctx, 1);
} else if ((me_who == QRESUB || me_who == QALTER) && lGetNumberOfElem(cmdline) == 0) {
/* qresub and qalter have nothing set */
sge_usage(me_who, stderr);
fprintf(stderr, "%s\n", MSG_PARSE_NOOPTIONARGUMENT);
SGE_EXIT((void**)&ctx, 1);
} else if (opt_list_has_X(cmdline, "-help")) {
/* -help was specified */
sge_usage(me_who, stdout);
SGE_EXIT((void**)&ctx, 0);
}
alp = qalter_parse_job_parameter(me_who, cmdline, &request_list, &all_jobs,
&all_users);
DPRINTF(("all_jobs = %d, all_user = %d\n", all_jobs, all_users));
if (request_list && verify) {
/*
got a request list containing one element
for each job to be modified
save jobid all fields contain the same fields
so we may use show_job() with the first job
in our list
The jobid's in our request list get printed before
show_job()
*/
cull_show_job(lFirst(request_list), FLG_QALTER, false);
sge_prof_cleanup();
SGE_EXIT((void**)&ctx, 0);
}
tmp_ret = answer_list_print_err_warn(&alp, NULL, NULL, MSG_WARNING);
if (tmp_ret > 0) {
SGE_EXIT((void**)&ctx, tmp_ret);
}
if ((me_who == QALTER) ||
(me_who == QHOLD) ||
(me_who == QRLS)
) {
DPRINTF(("QALTER\n"));
gdi_cmd = SGE_GDI_MOD;
} else if (me_who == QRESUB){
DPRINTF(("QRESUB\n"));
gdi_cmd = SGE_GDI_COPY;
} else {
printf("unknown binary name.\n");
SGE_EXIT((void**)&ctx, 1);
}
if (all_jobs)
gdi_cmd |= SGE_GDI_ALL_JOBS;
if (all_users)
gdi_cmd |= SGE_GDI_ALL_USERS;
alp = ctx->gdi(ctx, SGE_JB_LIST, gdi_cmd, &request_list, NULL, NULL);
for_each (aep, alp) {
printf("%s\n", lGetString(aep, AN_text));
if (ret == STATUS_OK) {
ret = lGetUlong(aep, AN_status);
}
}
static bool
sge_parse_qrstat(sge_gdi_ctx_class_t *ctx, lList **answer_list,
qrstat_env_t *qrstat_env, lList **cmdline)
{
bool ret = true;
DENTER(TOP_LAYER, "sge_parse_qrstat");
qrstat_env->is_summary = true;
while (lGetNumberOfElem(*cmdline)) {
u_long32 value;
/* -help */
if (opt_list_has_X(*cmdline, "-help")) {
sge_usage(QRSTAT, stdout);
DEXIT;
SGE_EXIT((void**)&ctx, 0);
}
/* -u */
while (parse_multi_stringlist(cmdline, "-u", answer_list,
&(qrstat_env->user_list), ST_Type, ST_name)) {
continue;
}
/* -explain */
while (parse_flag(cmdline, "-explain", answer_list, &value)) {
qrstat_filter_add_core_attributes(qrstat_env);
qrstat_filter_add_explain_attributes(qrstat_env);
qrstat_env->is_explain = (value > 0) ? true : false;
continue;
}
/* -xml */
while (parse_flag(cmdline, "-xml", answer_list, &value)) {
qrstat_filter_add_core_attributes(qrstat_env);
qrstat_filter_add_xml_attributes(qrstat_env);
qrstat_env->is_xml = (value > 0) ? true : false;
continue;
}
/* -ar */
while (parse_u_longlist(cmdline, "-ar", answer_list, &(qrstat_env->ar_id_list))) {
qrstat_filter_add_core_attributes(qrstat_env);
qrstat_filter_add_ar_attributes(qrstat_env);
qrstat_filter_add_ar_where(qrstat_env);
qrstat_env->is_summary = false;
continue;
}
if (lGetNumberOfElem(*cmdline)) {
sge_usage(QRSTAT, stdout);
answer_list_add(answer_list, MSG_PARSE_TOOMANYOPTIONS,
STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR);
ret = false;
break;
}
}
if (qrstat_env->is_summary) {
char user[128] = "";
if (sge_uid2user(geteuid(), user, sizeof(user), MAX_NIS_RETRIES)) {
answer_list_add_sprintf(answer_list, STATUS_ESEMANTIC,
ANSWER_QUALITY_CRITICAL,
MSG_SYSTEM_RESOLVEUSER_U, (u_long32)geteuid());
ret = false;
} else {
str_list_transform_user_list(&(qrstat_env->user_list), answer_list, user);
qrstat_filter_add_core_attributes(qrstat_env);
qrstat_filter_add_u_where(qrstat_env);
}
}
DRETURN(ret);
}
/****** sge_c_report() *******************************************************
* NAME
* sge_c_report() -- process execd load report
*
* SYNOPSIS
* void sge_c_report(char *rhost, char *commproc, int id, lList *report_list)
*
* FUNCTION
*
* INPUTS
* char *rhost
* char *commproc
* int id
* lList *report_list
*
* RESULT
* void - nothing
*
* NOTES
* MT-NOTE: sge_c_report() is MT safe
*
******************************************************************************/
void sge_c_report(sge_gdi_ctx_class_t *ctx, char *rhost, char *commproc, int id, lList *report_list, monitoring_t *monitor)
{
lListElem *hep = NULL;
u_long32 rep_type;
lListElem *report;
int ret = 0;
u_long32 this_seqno, last_seqno;
u_long32 rversion;
sge_pack_buffer pb;
bool is_pb_used = false;
bool send_tag_new_conf = false;
DENTER(TOP_LAYER, "sge_c_report");
if (lGetNumberOfElem(report_list) == 0) {
DPRINTF(("received empty report\n"));
if (rhost != NULL) {
WARNING((SGE_EVENT, MSG_QMASTER_RECEIVED_EMPTY_LOAD_REPORT_S, rhost));
} else {
WARNING((SGE_EVENT, MSG_QMASTER_RECEIVED_EMPTY_LOAD_REPORT_S, "unknown"));
}
DRETURN_VOID;
}
/* accept reports only from execd's */
if (strcmp(prognames[EXECD], commproc)) {
ERROR((SGE_EVENT, MSG_GOTSTATUSREPORTOFUNKNOWNCOMMPROC_S, commproc));
DRETURN_VOID;
}
/* do not process load reports from old execution daemons */
rversion = lGetUlong(lFirst(report_list), REP_version);
if (verify_request_version(NULL, rversion, rhost, commproc, id)) {
DRETURN_VOID;
}
this_seqno = lGetUlong(lFirst(report_list), REP_seqno);
/* need exec host for all types of reports */
if (!(hep = host_list_locate(*object_type_get_master_list(SGE_TYPE_EXECHOST), rhost))) {
ERROR((SGE_EVENT, MSG_GOTSTATUSREPORTOFUNKNOWNEXECHOST_S, rhost));
DRETURN_VOID;
}
/* prevent old reports being proceeded
frequent loggings of outdated reports can be an indication
of too high message traffic arriving at qmaster */
last_seqno = lGetUlong(hep, EH_report_seqno);
if ((this_seqno < last_seqno && (last_seqno - this_seqno) <= 9000) &&
!(last_seqno > 9990 && this_seqno < 10)) {
/* this must be an old report, log and then ignore it */
INFO((SGE_EVENT, MSG_QMASTER_RECEIVED_OLD_LOAD_REPORT_UUS,
sge_u32c(this_seqno), sge_u32c(last_seqno), rhost));
DRETURN_VOID;
}
lSetUlong(hep, EH_report_seqno, this_seqno);
/* RU: */
/* tag all reschedule_unknown list entries we hope to
hear about in that job report */
update_reschedule_unknown_list(ctx, hep);
/*
** process the reports one after the other
** usually there will be a load report
** and a configuration version report
*/
for_each(report, report_list) {
rep_type = lGetUlong(report, REP_type);
switch (rep_type) {
case NUM_REP_REPORT_LOAD:
case NUM_REP_FULL_REPORT_LOAD:
MONITOR_ELOAD(monitor);
/* Now handle execds load reports */
if (lGetUlong(hep, EH_lt_heard_from) == 0 && rep_type != NUM_REP_FULL_REPORT_LOAD) {
host_notify_about_full_load_report(ctx, hep);
} else {
if (!is_pb_used) {
is_pb_used = true;
init_packbuffer(&pb, 1024, 0);
}
sge_update_load_values(ctx, rhost, lGetList(report, REP_list));
if (mconf_get_simulate_execds()) {
lList *master_exechost_list = *object_type_get_master_list(SGE_TYPE_EXECHOST);
lListElem *shep;
lListElem *simhostElem=NULL;
for_each(shep, master_exechost_list) {
simhostElem = lGetSubStr(shep, CE_name, "load_report_host", EH_consumable_config_list);
if (simhostElem != NULL) {
const char *real_host = lGetString(simhostElem, CE_stringval);
if (real_host != NULL && sge_hostcmp(real_host, rhost) == 0) {
const char* sim_host = lGetHost(shep, EH_name);
lListElem *clp = NULL;
DPRINTF(("Copy load values of %s to simulated host %s\n",
rhost, sim_host));
for_each(clp, lGetList(report, REP_list)) {
if (strcmp(lGetHost(clp, LR_host), SGE_GLOBAL_NAME) != 0) {
lSetHost(clp, LR_host, sim_host);
}
}
sge_update_load_values(ctx, sim_host, lGetList(report, REP_list));
}
}
}
}
pack_ack(&pb, ACK_LOAD_REPORT, this_seqno, 0, NULL);
}
break;
case NUM_REP_REPORT_CONF:
MONITOR_ECONF(monitor);
if (sge_compare_configuration(hep, lGetList(report, REP_list)) != 0) {
DPRINTF(("%s: configuration on host %s is not up to date\n", SGE_FUNC, rhost));
send_tag_new_conf = true;
}
break;
case NUM_REP_REPORT_PROCESSORS:
/*
** save number of processors
*/
MONITOR_EPROC(monitor);
ret = update_license_data(ctx, hep, lGetList(report, REP_list));
if (ret) {
ERROR((SGE_EVENT, MSG_LICENCE_ERRORXUPDATINGLICENSEDATA_I, ret));
}
break;
case NUM_REP_REPORT_JOB:
MONITOR_EJOB(monitor);
if (!is_pb_used) {
is_pb_used = true;
init_packbuffer(&pb, 1024, 0);
}
process_job_report(ctx, report, hep, rhost, commproc, &pb, monitor);
break;
default:
DPRINTF(("received invalid report type %ld\n", (long) rep_type));
}
/****** 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;
}
/****** 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;
}
/*-------------------------------------------------------------------------*/
static void set_StringList(
Widget w,
XtPointer address,
XrmQuark type,
Cardinal size
) {
lList *lp = NULL;
Widget parent;
/*
* Here special Qmon Quarks are used. Does it work ?
*/
if (type != QmonQUS_Type && type != QmonQMR_Type &&
type != QmonQPR_Type && type != QmonQSTR_Type &&
type != QmonQSTU_Type && type != QmonQHR_Type) {
XmtWarningMsg("XmtDialogSetDialogValues", "XbaeMatrix",
"Type Mismatch: Widget '%s':\n\tCan't set widget values"
" from a resource of type '%s'",
XtName(w), XrmQuarkToString(type));
return;
}
if (size == sizeof(lList*))
lp = *(lList**) address;
else
return;
/* if our parent is a layout widget disable/reenable it */
parent = XtParent(w);
while (parent && !XtIsSubclass(parent, xmtLayoutWidgetClass))
parent = XtParent(parent);
XmtLayoutDisableLayout(parent);
if (type == QmonQUS_Type) {
UpdateXmListFromCull(w, XmFONTLIST_DEFAULT_TAG, lp, US_name);
}
if (type == QmonQPR_Type) {
UpdateXmListFromCull(w, XmFONTLIST_DEFAULT_TAG, lp, PR_name);
}
if (type == QmonQHR_Type) {
UpdateXmListFromCull(w, XmFONTLIST_DEFAULT_TAG, lp, HR_name);
}
if (type == QmonQMR_Type) {
String *str_table = NULL;
Cardinal itemCount;
StringConst str1, str2;
int size, i;
char buf[BUFSIZ];
lListElem *ep = NULL;
XtVaGetValues(w, XmNitemCount, &itemCount, NULL);
if (!lp) {
if (itemCount)
XmListDeleteAllItems(w);
return;
}
if ((size = lGetNumberOfElem(lp)) <=0) {
return;
}
if (!(str_table = (String *)XtMalloc(sizeof(String)*size))) {
return;
}
for (ep=lFirst(lp), i=0; ep; ep=lNext(ep), i++) {
str1 = (StringConst)lGetString(ep, MR_user);
str2 = (StringConst)lGetHost(ep, MR_host);
if (str1) {
if (!str2)
sge_strlcpy(buf, str1, BUFSIZ);
else
snprintf(buf, BUFSIZ, "%s@%s", str1, str2);
str_table[i] = XtNewString(buf);
}
else
str_table[i] = NULL;
}
UpdateXmList(w, str_table, size, XmFONTLIST_DEFAULT_TAG);
StringTableFree(str_table, size);
}
if (type == QmonQSTR_Type) {
UpdateXmListFromCull(w, XmFONTLIST_DEFAULT_TAG, lp, ST_name);
}
if (type == QmonQSTU_Type) {
UpdateXmListFromCull(w, XmFONTLIST_DEFAULT_TAG, lp, STU_name);
}
XmtLayoutEnableLayout(parent);
}
