lListElem *cuser_get_via_gdi(sge_gdi_ctx_class_t *ctx, lList **answer_list, const char *name)
{
lListElem *ret = NULL;
DENTER(TOP_LAYER, "cuser_get_via_gdi");
if (name != NULL) {
lList *gdi_answer_list = NULL;
lEnumeration *what = NULL;
lCondition *where = NULL;
lList *cuser_list = NULL;
what = lWhat("%T(ALL)", CU_Type);
where = lWhere("%T(%I==%s)", CU_Type, CU_name, name);
gdi_answer_list = ctx->gdi(ctx, SGE_USER_MAPPING_LIST, SGE_GDI_GET,
&cuser_list, where, what);
lFreeWhat(&what);
lFreeWhere(&where);
if (!answer_list_has_error(&gdi_answer_list)) {
ret = lFirst(cuser_list);
} else {
answer_list_replace(answer_list, &gdi_answer_list);
}
}
DRETURN(ret);
}
/****** SCHEDD/order_remove_order_and_immediate()*******************************
* NAME
* order_remove_order_and_immediate() -- add a remove order for the job task
*
* SYNOPSIS
* int order_remove_order_and_immediate(lListElem *job, lListElem *ja_task,
order_t *orders)
*
* FUNCTION
* Generates an order of type ORT_remove_immediate_job for the given job
* task. Also removes the ORT_start_job order for this task from the order
* list.
*
* INPUTS
* lListElem *job - The job to remove (JB_Type)
* lListElem *ja_task - The task to remove (JAT_Type)
* order_t *orders - The order structurestructure for this scheduler pass be removed
*
* RESULT
* int - Error code: 0 = OK, 1 = Errors
*
* NOTES
* MT-NOTE: order_remove_order_and_immediate() is MT safe
*
*******************************************************************************/
static void
order_remove_order_and_immediate( lListElem *job, lListElem *ja_task, order_t *orders)
{
/* The possibility exists that this task is part of an array task, that it
* already has earned an order to be scheduled, and that one or more other
* tasks in this same job were not scheduled, resulting in this delete
* order. In this case, we have to remove the schedule order before we add
* the delete order. Otherwise, the qmaster will think we're trying to do
* an ORT_remove_immediate_job on a non-idle task. */
/* Warning: we have a problem, if we send start orders during the dispatch run. We
* might have started a array task of an immediate array job without verifying, that
* the whole job can run
*/
lList *orderList = orders->jobStartOrderList;
lCondition *where = lWhere("%T(%I==%u && %I==%u && %I==%u)", OR_Type,
OR_type, ORT_start_job,
OR_job_number, lGetUlong(job, JB_job_number),
OR_ja_task_number, lGetUlong(ja_task, JAT_task_number));
lListElem *ep = lFindFirst (orderList, where);
DENTER(TOP_LAYER, "order_remove_order_and_immediate");
if (ep != NULL) {
DPRINTF (("Removing job start order for job task "sge_u32"."sge_u32"\n",
lGetUlong(job, JB_job_number),
lGetUlong(ja_task, JAT_task_number)));
lRemoveElem(orderList, &ep);
}
order_remove_immediate(job, ja_task, orders);
lFreeWhere(&where);
DEXIT;
}
/****** gdi/request_internal/sge_gdi_task_free() ******************************
* NAME
* sge_gdi_task_free() -- free a gdi task structure
*
* SYNOPSIS
* static bool
* sge_gdi_task_free(sge_gdi_task_class_t **task)
*
* FUNCTION
* free all elements of the gdi task structure and the structure itself.
*
* INPUTS
* sge_gdi_task_class_t **task - pointer to the task structure pointer
*
* RESULT
* static bool -
* true - success (always)
*
* NOTES
* MT-NOTE: sge_gdi_task_free() is MT safe as long as the structure
* passed to this function is not accessed by more than one
* thread simultaniously.
*
* SEE ALSO
* gdi/request_internal/sge_gdi_task_create()
******************************************************************************/
static bool
sge_gdi_task_free(sge_gdi_task_class_t ** task)
{
bool ret = true;
DENTER(TOP_LAYER, "sge_gdi_task_free");
if (task != NULL && *task != NULL) {
lFreeList(&((*task)->data_list));
lFreeList(&((*task)->answer_list));
lFreeWhat(&((*task)->enumeration));
lFreeWhere(&((*task)->condition));
*task = (sge_gdi_task_class_t *) sge_free((char *) (*task));
}
DRETURN(ret);
}
/****** SCHEDD/remove_immediate_jobs()******************************************
* NAME
* remove_immediate_jobs() -- test for and remove immediate jobs which can't
* be scheduled
*
* SYNOPSIS
* int remove_immediate_jobs(lList *pending_job_list,
lList *running_job_list, order_t *orders)
*
* FUNCTION
* Goes through all jobs in the pending list to see if any are immediate and
* not idle. If any are, they are removed. This is done by generating an
* order of type ORT_remove_immediate_job. If any array jobs are removed,
* the running list is checked for tasks belonging to the job, which are
* also removed. This is done by removing the ORT_start_job orders and
* adding an order of type ORT_remove_immediate_job.
*
* INPUTS
* lList *pending_job_list - The list of pending jobs for this scheduler
* pass (JB_Type)
* lList *running_job_list - The list of running jobs for this scheduler
* pass (JB_Type)
* order_t *orders - The order structure for this scheduler pass
*
* RESULT
* int - Error code: 0 = OK, 1 = Errors -- always returns 0
*
* NOTES
* MT-NOTE: remove_immediate_jobs() is MT safe
*
*******************************************************************************/
int remove_immediate_jobs(lList *pending_job_list, lList *running_job_list, order_t *orders)
{
lListElem *next_job, *job, *ep;
lList* lp;
DENTER (TOP_LAYER, "remove_immediate_jobs");
next_job = lFirst (pending_job_list);
while ((job = next_job)) {
lCondition *where = NULL;
next_job = lNext(job);
/* skip non immediate .. */
if (!JOB_TYPE_IS_IMMEDIATE(lGetUlong(job, JB_type))) {
continue;
}
/* .. and non idle jobs */
if ((lp = lGetList(job, JB_ja_tasks)) &&
(ep = lFirst(lp)) &&
lGetUlong(ep, JAT_status)==JIDLE) {
continue;
}
/* Prepare search condition for running list */
where = lWhere("%T(%I==%u)", JB_Type, JB_job_number, lGetUlong(job, JB_job_number));
/* Remove the job from the pending list */
remove_immediate_job(pending_job_list, job, orders, 0);
/* If the job also exists in the running list, we need to remove it there
* as well since array jobs are all or nothing. */
if ((job = lFindFirst(running_job_list, where)) != NULL) {
remove_immediate_job(running_job_list, job, orders, 1);
}
lFreeWhere(&where);
}
DEXIT;
return 0;
}
/*-------------------------------------------------------------------------*/
void updateQueueList(void)
{
lList *qlp = NULL;
lList *hl = NULL;
lList *rl = NULL;
lList *cl = NULL;
lEnumeration *whatall = NULL;
lCondition *where = NULL;
static Boolean filter_on = False;
DENTER(GUI_LAYER, "updateQueueList");
cl = qmonMirrorList(SGE_CE_LIST);
/*
** copy of host list
*/
hl = lCopyList("HL", qmonMirrorList(SGE_EH_LIST));
/*
**
** select a subset of the whole queue list (->where)
** and get the list sorted
**
*/
#ifdef FIXME
where = lWhere("%T(%I!=%s)", QU_Type, QU_qname, QU_TEMPLATE);
whatall = lWhat("%T(ALL)", QU_Type);
#else
whatall = lWhat("%T(ALL)", CQ_Type);
#endif
qlp = lSelect("SQL", qmonMirrorList(SGE_CQ_LIST), where, whatall);
lFreeWhere(&where);
lFreeWhat(&whatall);
#ifdef FIXME
/*
** additional filtering
*/
rl = qmonQFilterRequest();
if (rl) {
if (!filter_on) {
setButtonLabel(queue_customize, "@{Customize +}");
filter_on = True;
}
match_queue(&qlp, rl, cl, hl);
}
else {
if (filter_on) {
setButtonLabel(queue_customize, "@{Customize}");
filter_on = False;
}
}
/*
** sort the queues according to sequence number and alphabetically
*/
lPSortList(qlp, "%I+ %I+ %I+", QU_seq_no, QU_qhostname, QU_qname);
#endif
/*
** save the queue in hash table
*/
qmonQueueHash(qlp, hl);
qmonQueueSetPos(qlp);
/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
** qlp must not be freed it is referenced in qmonHashQueue
** and freed there
*/
DEXIT;
}
static void qevent_testsuite_mode(sge_evc_class_t *evc)
{
#ifndef QEVENT_SHOW_ALL
u_long32 timestamp;
lCondition *where =NULL;
lEnumeration *what = NULL;
const int job_nm[] = {
JB_job_number,
JB_host,
JB_category,
JB_project,
JB_ja_tasks,
JB_ja_structure,
JB_ja_n_h_ids,
JB_ja_u_h_ids,
JB_ja_s_h_ids,
JB_ja_o_h_ids,
JB_ja_template,
NoName
};
const int jat_nm[] = {
JAT_status,
JAT_task_number,
NoName
};
#endif
DENTER(TOP_LAYER, "qevent_testsuite_mode");
sge_mirror_initialize(evc, EV_ID_ANY, "qevent", true,
NULL, NULL, NULL, NULL, NULL);
#ifdef QEVENT_SHOW_ALL
sge_mirror_subscribe(evc, SGE_TYPE_ALL, print_event, NULL, NULL, NULL, NULL);
#else /* QEVENT_SHOW_ALL */
where = NULL;
what = lIntVector2What(JB_Type, job_nm);
sge_mirror_subscribe(evc, SGE_TYPE_JOB, print_jatask_event, NULL, NULL, where, what);
lFreeWhere(&where);
lFreeWhat(&what);
where = NULL;
what = lIntVector2What(JAT_Type, jat_nm);
sge_mirror_subscribe(evc, SGE_TYPE_JATASK, print_jatask_event, NULL, NULL, where, what);
lFreeWhere(&where);
lFreeWhat(&what);
/* we want a 5 second event delivery interval */
evc->ec_set_edtime(evc, 5);
/* and have our events flushed immediately */
evc->ec_set_flush(evc, sgeE_JATASK_MOD, true, 1);
evc->ec_set_flush(evc, sgeE_JOB_FINAL_USAGE, true, 1);
evc->ec_set_flush(evc, sgeE_JOB_ADD, true, 1);
evc->ec_set_flush(evc, sgeE_JOB_DEL, true, 1);
#endif /* QEVENT_SHOW_ALL */
while (!shut_me_down) {
sge_mirror_error error = sge_mirror_process_events(evc);
if (error == SGE_EM_TIMEOUT && !shut_me_down) {
sleep(10);
continue;
}
#ifndef QEVENT_SHOW_ALL
timestamp = sge_get_gmt();
fprintf(stdout,"ECL_STATE (jobs_running=%ld:jobs_registered=%ld:ECL_TIME="sge_U32CFormat")\n",
Global_jobs_running,Global_jobs_registered,sge_u32c(timestamp));
fflush(stdout);
#endif
}
sge_mirror_shutdown(evc);
DEXIT;
}
int main(int argc, char *argv[])
{
qevent_options enabled_options;
dstring errors = DSTRING_INIT;
int i, gdi_setup;
lList *alp = NULL;
sge_gdi_ctx_class_t *ctx = NULL;
sge_evc_class_t *evc = NULL;
DENTER_MAIN(TOP_LAYER, "qevent");
/* sge_mt_init(); */
/* dump pid to file */
qevent_dump_pid_file();
/* parse command line */
enabled_options.error_message = &errors;
qevent_set_option_struct(&enabled_options);
qevent_parse_command_line(argc, argv, &enabled_options);
/* check if help option is set */
if (enabled_options.help_option) {
qevent_show_usage();
sge_dstring_free(enabled_options.error_message);
SGE_EXIT((void**)&ctx, 0);
}
/* are there command line parsing errors ? */
if (sge_dstring_get_string(enabled_options.error_message)) {
ERROR((SGE_EVENT, "%s", sge_dstring_get_string(enabled_options.error_message) ));
qevent_show_usage();
sge_dstring_free(enabled_options.error_message);
SGE_EXIT((void**)&ctx, 1);
}
log_state_set_log_gui(1);
sge_setup_sig_handlers(QEVENT);
/* setup event client */
gdi_setup = sge_gdi2_setup(&ctx, QEVENT, MAIN_THREAD, &alp);
if (gdi_setup != AE_OK) {
answer_list_output(&alp);
sge_dstring_free(enabled_options.error_message);
SGE_EXIT((void**)&ctx, 1);
}
/* TODO: how is the memory we allocate here released ???, SGE_EXIT doesn't */
if (false == sge_gdi2_evc_setup(&evc, ctx, EV_ID_ANY, &alp, NULL)) {
answer_list_output(&alp);
sge_dstring_free(enabled_options.error_message);
SGE_EXIT((void**)&ctx, 1);
}
/* ok, start over ... */
/* check for testsuite option */
if (enabled_options.testsuite_option) {
/* only for testsuite */
qevent_testsuite_mode(evc);
sge_dstring_free(enabled_options.error_message);
SGE_EXIT((void**)&ctx, 0);
}
/* check for subscribe option */
if (enabled_options.subscribe_option) {
/* only for testsuite */
qevent_subscribe_mode(evc);
sge_dstring_free(enabled_options.error_message);
SGE_EXIT((void**)&ctx, 0);
}
if (enabled_options.trigger_option_count > 0) {
lCondition *where =NULL;
lEnumeration *what = NULL;
sge_mirror_initialize(evc, EV_ID_ANY, "sge_mirror -trigger", true,
NULL, NULL, NULL, NULL, NULL);
evc->ec_set_busy_handling(evc, EV_BUSY_UNTIL_ACK);
/* put out information about -trigger option */
for (i=0;i<enabled_options.trigger_option_count;i++) {
INFO((SGE_EVENT, "trigger script for %s events: %s\n",
qevent_get_event_name((enabled_options.trigger_option_events)[i]),
(enabled_options.trigger_option_scripts)[i]));
switch((enabled_options.trigger_option_events)[i]) {
case QEVENT_JB_END:
/* build mask for the job structure to contain only the needed elements */
where = NULL;
what = lWhat("%T(%I %I %I %I %I %I %I %I)", JB_Type, JB_job_number, JB_ja_tasks,
JB_ja_structure, JB_ja_n_h_ids, JB_ja_u_h_ids,
JB_ja_s_h_ids,JB_ja_o_h_ids, JB_ja_template);
/* register for job events */
sge_mirror_subscribe(evc, SGE_TYPE_JOB, analyze_jatask_event, NULL, NULL, where, what);
evc->ec_set_flush(evc, sgeE_JOB_DEL,true, 1);
/* the mirror interface registers more events, than we need,
thus we free the ones, we do not need */
/* evc->ec_unsubscribe(evc, sgeE_JOB_LIST); */
evc->ec_unsubscribe(evc, sgeE_JOB_MOD);
evc->ec_unsubscribe(evc, sgeE_JOB_MOD_SCHED_PRIORITY);
evc->ec_unsubscribe(evc, sgeE_JOB_USAGE);
evc->ec_unsubscribe(evc, sgeE_JOB_FINAL_USAGE);
/* evc->ec_unsubscribe(evc, sgeE_JOB_ADD); */
/* free the what and where mask */
lFreeWhere(&where);
lFreeWhat(&what);
break;
case QEVENT_JB_TASK_END:
/* build mask for the job structure to contain only the needed elements */
where = NULL;
what = lWhat("%T(%I)", JAT_Type, JAT_status);
/* register for JAT events */
sge_mirror_subscribe(evc, SGE_TYPE_JATASK, analyze_jatask_event, NULL, NULL, where, what);
evc->ec_set_flush(evc, sgeE_JATASK_DEL,true, 1);
/* the mirror interface registers more events, than we need,
thus we free the ones, we do not need */
evc->ec_unsubscribe(evc, sgeE_JATASK_ADD);
evc->ec_unsubscribe(evc, sgeE_JATASK_MOD);
/* free the what and where mask */
lFreeWhere(&where);
lFreeWhat(&what);
break;
}
}
while(!shut_me_down) {
sge_mirror_error error = sge_mirror_process_events(evc);
if (error == SGE_EM_TIMEOUT && !shut_me_down ) {
sleep(10);
continue;
}
}
sge_mirror_shutdown(evc);
sge_dstring_free(enabled_options.error_message);
sge_prof_cleanup();
SGE_EXIT((void**)&ctx, 0);
return 0;
}
ERROR((SGE_EVENT, "no option selected\n" ));
qevent_show_usage();
sge_dstring_free(enabled_options.error_message);
sge_prof_cleanup();
SGE_EXIT((void**)&ctx, 1);
return 1;
}
static sge_gdi_task_class_t *
sge_gdi_task_create(sge_gdi_packet_class_t * packet, lList **answer_list,
u_long32 target, u_long32 command, lList **lp,
lList **a_list, lCondition **condition,
lEnumeration **enumeration, bool do_copy, bool do_verify)
{
sge_gdi_task_class_t *task = NULL;
DENTER(TOP_LAYER, "sge_gdi_task_create");
task = (sge_gdi_task_class_t *) sge_malloc(sizeof(sge_gdi_task_class_t));
if (task != NULL) {
task->id =
((packet->last_task != NULL) ? (packet->last_task->id + 1) : 1);
task->command = command;
task->target = target;
task->next = NULL;
task->do_select_pack_simultaneous = false;
if (do_copy) {
if (enumeration != NULL && *enumeration != NULL) {
task->data_list = (((lp != NULL) && (*lp != NULL)) ?
lSelect("", *lp, NULL, *enumeration) : NULL);
} else {
task->data_list = (((lp != NULL) && (*lp != NULL)) ?
lCopyList("", *lp) : NULL);
}
task->answer_list = (((a_list != NULL) && (*a_list != NULL)) ?
lCopyList("", *a_list) : NULL);
task->condition = (((condition != NULL) && (*condition != NULL)) ?
lCopyWhere(*condition) : NULL);
task->enumeration = (((enumeration != NULL) && (*enumeration != NULL)) ?
lCopyWhat(*enumeration) : NULL);
} else {
if ((lp != NULL) && (*lp != NULL)) {
task->data_list = *lp;
*lp = NULL;
} else {
task->data_list = NULL;
}
if ((a_list != NULL) && (*a_list != NULL)) {
task->answer_list = *a_list;
*a_list = NULL;
} else {
task->answer_list = NULL;
}
if ((condition != NULL) && (*condition != NULL)) {
task->condition = *condition;
*condition = NULL;
} else {
task->condition = NULL;
}
if ((enumeration != NULL) && (*enumeration != NULL)) {
task->enumeration = *enumeration;
*enumeration = NULL;
} else {
task->enumeration = NULL;
}
}
if (do_verify && !sge_gdi_task_verify(task, answer_list)) {
if (do_copy == true) {
lFreeList(&(task->data_list));
lFreeList(&(task->answer_list));
lFreeWhere(&(task->condition));
lFreeWhat(&(task->enumeration));
} else {
task->data_list = NULL;
task->answer_list = NULL;
task->condition = NULL;
task->enumeration = NULL;
}
sge_gdi_task_free(&task);
}
} else {
answer_list_add_sprintf(answer_list, STATUS_EMALLOC,
ANSWER_QUALITY_ERROR, MSG_MEMORY_MALLOCFAILED);
}
DRETURN(task);
}
/****** gdi/request_internal/sge_gdi_packet_pack_task() **********************
* NAME
* sge_gdi_packet_pack_task() -- pack a single GDI task
*
* SYNOPSIS
* bool
* sge_gdi_packet_pack_task(sge_gdi_packet_class_t * packet,
* sge_gdi_task_class_t * task,
* lList **answer_list,
* sge_pack_buffer *pb)
*
* FUNCTION
* This functions packs all data representing one GDI request
* of a mutli GDI request (represented by "packet" and "task")
* into "pb". Errors will be reported with a corresponding
* "answer_list" message and a negative return value.
*
* "pb" has to be initialized before this function is called.
* init_packbuffer() or a similar function has do be used to
* initialize this "pb". The function sge_gdi_packet_get_pb_size()
* might be used to calculate the maximum size as if the buffer
* would be needed to pack all tasks of a multi GDI request.
* Using this size as initial size for the "pb"
* will prevent continuous reallocation of memory in this
* function.
*
* INPUTS
* sge_gdi_packet_class_t * packet - GDI packet
* sge_gdi_task_class_t * task - GDI task
* lList **answer_list - answer_list
* sge_pack_buffer *pb - packing buffer
*
* RESULT
* bool - error state
* true - success
* false - failure
*
* NOTES
* MT-NOTE: sge_gdi_packet_pack_task() is MT safe
*
* SEE ALSO
* gdi/request_internal/sge_gdi_packet_get_pb_size()
* gdi/request_internal/sge_gdi_packet_pack()
*******************************************************************************/
bool
sge_gdi_packet_pack_task(sge_gdi_packet_class_t *packet,
sge_gdi_task_class_t *task, lList **answer_list,
sge_pack_buffer *pb)
{
bool ret = true;
int pack_ret = PACK_SUCCESS;
DENTER(TOP_LAYER, "sge_gdi_packet_pack_task");
if ((task != NULL) && (packet != NULL)
&& (packet->is_intern_request == false)) {
sge_pack_gdi_info(task->command);
/* ===> pack the prefix */
pack_ret = packint(pb, task->command);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = packint(pb, task->target);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = packint(pb, packet->version);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
/*
* if the lSelect call was postponed then it will be done here.
* here we are able to pack the result list directly into the packbuffer.
* additionally it is necessary to add an answer to the answer list.
* (which will be packed below).
*/
if (task->do_select_pack_simultaneous) {
lSelectHashPack("", task->data_list, task->condition,
task->enumeration, false, pb);
lFreeWhat(&(task->enumeration));
lFreeWhere(&(task->condition));
task->data_list = NULL;
/* DIRTY HACK: The "ok" message should be removed from the answer list
* 05/21/2007 qualitiy was ANSWER_QUALITY_INFO but this results in "ok"
* messages on qconf side */
answer_list_add(&(task->answer_list), MSG_GDI_OKNL, STATUS_OK,
ANSWER_QUALITY_END);
} else {
/* ===> pack the list */
pack_ret = cull_pack_list(pb, task->data_list);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
}
/* ===> pack the suffix */
pack_ret = cull_pack_list(pb, task->answer_list);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = cull_pack_cond(pb, task->condition);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = cull_pack_enum(pb, task->enumeration);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = packstr(pb, packet->auth_info);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = packint(pb, task->id);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = packint(pb, packet->id);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = packint(pb, (task->next != NULL) ? 1 : 0);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
}
DRETURN(ret);
error_with_mapping:
ret = sge_gdi_map_pack_errors(pack_ret, answer_list);
DRETURN(ret);
}
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 */
}
