sge_callback_result
job_schedd_info_update_master_list(sge_evc_class_t *evc, object_description *object_base, sge_object_type type,
sge_event_action action, lListElem *event, void *clientdata)
{
lList **list = NULL;
const lDescr *list_descr = NULL;
lList *data_list;
lListElem *ep = NULL;
DENTER(TOP_LAYER, "job_schedd_info_update_master_list");
list = sge_master_list(object_base, type);
list_descr = lGetListDescr(lGetList(event, ET_new_version));
/* We always update the whole list (consisting of one list element) */
lFreeList(list);
if((data_list = lGetList(event, ET_new_version)) != NULL) {
if((ep = lFirst(data_list)) != NULL) {
ep = lDechainElem(data_list, ep);
}
}
/* if neccessary, create list and copy schedd info */
if(ep != NULL) {
*list = lCreateList("job schedd info", list_descr);
lAppendElem(*list, ep);
}
DEXIT;
return SGE_EMA_OK;
}
/****** 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;
}
static void schedd_mes_find_others(lListElem *tmp_sme, lList *job_list, int ignore_category)
{
if (tmp_sme && job_list) {
lListElem *message_elem = NULL; /* MES_Type */
lRef category = NULL; /* Category pointer (void*) */
lList *jid_cat_list = NULL; /* ULNG */
lList *message_list = lGetList(tmp_sme, SME_message_list);
/*
* Here we have a list of message elements where each
* MES_job_number_list contains only one id.
* We have to find the other jobs (jids) which have the same category.
*/
for_each(message_elem, message_list) {
lList *jid_list = lGetList(message_elem, MES_job_number_list);
u_long32 jid;
lRef jid_category;
jid = lGetUlong(lFirst(jid_list), ULNG_value);
jid_category = schedd_mes_get_category(jid, job_list);
/*
* Initialize jid_cat_list if not initialized
* or if category differs from the last run
*/
if (category != jid_category || ignore_category) {
jid_cat_list = schedd_mes_get_same_category_jids(jid_category,
job_list,
ignore_category);
category = jid_category;
lSetList(message_elem, MES_job_number_list, jid_cat_list);
} else {
lSetList(message_elem, MES_job_number_list,
lCopyList("", jid_cat_list));
}
}
void xml_addAttribute(lListElem *xml_elem, const char *name, const char *value) {
lListElem *attr_elem = lCreateElem(XMLA_Type);
lList *attr_list = NULL;
dstring mod_value = DSTRING_INIT;
bool is_mod_value;
DENTER(CULL_LAYER, "xml_addAttribute");
is_mod_value = escape_string(value, &mod_value);
if (attr_elem) {
lSetString(attr_elem, XMLA_Name, name);
lSetString(attr_elem, XMLA_Value, (is_mod_value?sge_dstring_get_string(&mod_value):""));
if (lGetPosViaElem(xml_elem, XMLH_Attribute, SGE_NO_ABORT) != -1) {
attr_list = lGetList(xml_elem, XMLH_Attribute);
if (!attr_list)
lSetList(xml_elem, XMLH_Attribute, (attr_list = lCreateList("Attributes", XMLA_Type)));
}
else if (lGetPosViaElem(xml_elem, XMLE_Attribute, SGE_NO_ABORT) != -1) {
attr_list = lGetList(xml_elem, XMLE_Attribute);
if (!attr_list)
lSetList(xml_elem, XMLE_Attribute, (attr_list = lCreateList("Attributes", XMLA_Type)));
}
else {
sge_dstring_free(&mod_value);
CRITICAL((SGE_EVENT, "xml_addAttribute() called on wrong cull structure"));
DEXIT;
abort();
}
lAppendElem(attr_list, attr_elem);
}
sge_dstring_free(&mod_value);
DEXIT;
return;
}
/****** sge_resource_quota_qmaster/rqs_mod() **************************************
* NAME
* rqs_mod() -- gdi callback function for modifing resource quota sets
*
* SYNOPSIS
* int rqs_mod(lList **alpp, lListElem *new_rqs, lListElem *rqs, int add,
* const char *ruser, const char *rhost, gdi_object_t *object, int
* sub_command, monitoring_t *monitor)
*
* FUNCTION
* This function is called from the framework that
* add/modify/delete generic gdi objects.
* The purpose of this function is it to add new rqs
* objects or modify existing resource quota sets.
*
* INPUTS
* lList **alpp - reference to an answer list
* lListElem *new_rqs - if a new rqs object will be created by this
* function, then new_rqs is a newly initialized
* CULL object.
* if this function was called due to a modify request
* than new_rqs will contain the old data
* lListElem *rqs - a reduced rqs object which contains all
* necessary information to create a new object
* or modify parts of an existing one
* int add - 1 if a new element should be added to the master list
* 0 to modify an existing object
* const char *ruser - username who invoked this gdi request
* const char *rhost - hostname of where the gdi request was invoked
* gdi_object_t *object - structure of the gdi framework which contains
* additional information to perform the request
* int sub_command - how should we handle sublist elements
* SGE_GDI_CHANGE - modify sublist elements
* SGE_GDI_APPEND - add elements to a sublist
* SGE_GDI_REMOVE - remove sublist elements
* SGE_GDI_SET - replace the complete sublist
* monitoring_t *monitor - monitoring structure
*
* RESULT
* int - 0 on success
* STATUS_EUNKNOWN if an error occured
*
* NOTES
* MT-NOTE: rqs_mod() is MT safe
*******************************************************************************/
int rqs_mod(sge_gdi_ctx_class_t *ctx,
lList **alpp, lListElem *new_rqs, lListElem *rqs, int add, const char *ruser,
const char *rhost, gdi_object_t *object, int sub_command, monitoring_t *monitor)
{
const char *rqs_name = NULL;
bool rules_changed = false;
bool previous_enabled = (bool)lGetBool(new_rqs, RQS_enabled);
DENTER(TOP_LAYER, "rqs_mod");
/* ---- RQS_name */
if (add) {
if (attr_mod_str(alpp, rqs, new_rqs, RQS_name, object->object_name))
goto ERROR;
}
rqs_name = lGetString(new_rqs, RQS_name);
/* Name has to be a valid name */
if (add && verify_str_key(alpp, rqs_name, MAX_VERIFY_STRING,
MSG_OBJ_RQS, KEY_TABLE) != STATUS_OK) {
goto ERROR;
}
/* ---- RQS_description */
attr_mod_zerostr(rqs, new_rqs, RQS_description, "description");
/* ---- RQS_enabled */
attr_mod_bool(rqs, new_rqs, RQS_enabled, "enabled");
/* ---- RQS_rule */
if (lGetPosViaElem(rqs, RQS_rule, SGE_NO_ABORT)>=0) {
rules_changed = true;
if (SGE_GDI_IS_SUBCOMMAND_SET(sub_command, SGE_GDI_SET_ALL)) {
normalize_sublist(rqs, RQS_rule);
attr_mod_sub_list(alpp, new_rqs, RQS_rule, RQS_name, rqs, sub_command,
SGE_ATTR_RQSRULES, SGE_OBJ_RQS, 0, NULL);
} else {
/* *attr cases */
lList *rule_list = lGetList(rqs, RQS_rule);
lListElem *rule = NULL;
for_each(rule, rule_list) {
lList *new_rule_list = lGetList(new_rqs, RQS_rule);
lListElem *new_rule = NULL;
new_rule = rqs_rule_locate(new_rule_list, lGetString(rule, RQR_name));
if (new_rule != NULL) {
/* ---- RQR_limit */
attr_mod_sub_list(alpp, new_rule, RQR_limit, RQRL_name, rule,
sub_command, SGE_ATTR_RQSRULES, SGE_OBJ_RQS, 0, NULL);
} else {
ERROR((SGE_EVENT, SFNMAX, MSG_RESOURCEQUOTA_NORULEDEFINED));
answer_list_add(alpp, SGE_EVENT, STATUS_ESEMANTIC,
ANSWER_QUALITY_ERROR);
goto ERROR;
}
}
}
/****** qmaster/setup_qmaster/sge_setup_job_resend() ***************************
* NAME
* sge_setup_job_resend() -- Setup job resend events.
*
* SYNOPSIS
* void sge_setup_job_resend(void)
*
* FUNCTION
* Register a job resend event for each job or array task which does have a
* 'JTRANSFERING' status.
*
* INPUTS
* void - none
*
* RESULT
* void - none
*
* NOTES
* MT-NOTE: sge_setup_job_resend() is not MT safe
*
*******************************************************************************/
void sge_setup_job_resend(void)
{
lListElem *job = NULL;
object_description *object_base = object_type_get_object_description();
DENTER(TOP_LAYER, "sge_setup_job_resend");
job = lFirst(*object_base[SGE_TYPE_JOB].list);
while (NULL != job)
{
lListElem *task;
u_long32 job_num;
job_num = lGetUlong(job, JB_job_number);
task = lFirst(lGetList(job, JB_ja_tasks));
while (NULL != task)
{
if (lGetUlong(task, JAT_status) == JTRANSFERING)
{
lListElem *granted_queue, *qinstance, *host;
const char *qname;
u_long32 task_num, when;
te_event_t ev;
task_num = lGetUlong(task, JAT_task_number);
granted_queue = lFirst(lGetList(task, JAT_granted_destin_identifier_list));
qname = lGetString(granted_queue, JG_qname);
qinstance = cqueue_list_locate_qinstance(*object_base[SGE_TYPE_CQUEUE].list, qname);
host = host_list_locate(*object_base[SGE_TYPE_EXECHOST].list, lGetHost(qinstance, QU_qhostname));
when = lGetUlong(task, JAT_start_time);
when += MAX(load_report_interval(host), MAX_JOB_DELIVER_TIME);
ev = te_new_event((time_t)when, TYPE_JOB_RESEND_EVENT, ONE_TIME_EVENT, job_num, task_num, "job-resend_event");
te_add_event(ev);
te_free_event(&ev);
DPRINTF(("Did add job resend for "sge_u32"/"sge_u32" at %d\n", job_num, task_num, when));
}
task = lNext(task);
}
job = lNext(job);
}
DEXIT;
return;
} /* sge_setup_job_resend() */
/************************************************************************
id_sharetree - set the sharetree node id
************************************************************************/
bool id_sharetree(lList **alpp, lListElem *ep, int id, int *ret_id)
{
lListElem *cep = NULL;
int my_id = id;
DENTER(TOP_LAYER, "id_sharetree");
if (ep == NULL) {
answer_list_add(alpp, MSG_OBJ_NOSTREEELEM, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(false);
}
lSetUlong(ep, STN_id, my_id++);
/* handle the children */
for_each(cep, lGetList(ep, STN_children)) {
if (false == id_sharetree(NULL, cep, my_id, &my_id)) {
DRETURN(false);
}
}
if (ret_id) {
*ret_id = my_id;
}
DRETURN(true);
}
/************************************************************************
show_sharetree
display a tree representation of sharetree
************************************************************************/
int show_sharetree(
lListElem *ep,
char *indent
) {
lListElem *cep;
FILE *fp = stdout;
static int level = 0;
int i;
DENTER(TOP_LAYER, "show_sharetree");
if (!ep) {
DEXIT;
return -1;
}
for (i=0;i<level;i++)
fprintf(fp, "%s", indent ? indent : "");
fprintf(fp, "%s="sge_u32"\n", lGetString(ep, STN_name),
lGetUlong(ep, STN_shares));
for_each(cep, lGetList(ep, STN_children)) {
level++;
show_sharetree(cep, " ");
level--;
}
/*-------------------------------------------------------------------------*/
static void qmonUsersetFillConf(
Widget w,
lListElem *ep
) {
lList *ul;
DENTER(GUI_LAYER, "qmonUsersetFillConf");
if (!ep) {
/*
** clear the userset_user_list
*/
XtVaSetValues( userset_user_list,
XmNitems, NULL,
XmNitemCount, 0,
NULL);
DEXIT;
return;
}
userset_type_state = (int)lGetUlong(ep, US_type);
XmtChooserSetState(userset_type, userset_type_state, False);
ul = lGetList(ep, US_entries);
lPSortList(ul, "%I+", UE_name);
UpdateXmListFromCull(userset_user_list, XmFONTLIST_DEFAULT_TAG, ul, UE_name);
DEXIT;
}
bool
spool_set_option(lList **answer_list, lListElem *context, const char *option)
{
bool ret = true;
DENTER(TOP_LAYER, "spool_set_option");
PROF_START_MEASUREMENT(SGE_PROF_SPOOLING);
if (context == NULL) {
answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN,
ANSWER_QUALITY_ERROR, MSG_SPOOL_NOVALIDCONTEXT_S,
SGE_FUNC);
} else {
lListElem *rule;
for_each (rule, lGetList(context, SPC_rules)) {
spooling_option_func func = (spooling_option_func)
lGetRef(rule, SPR_option_func);
if (func != NULL) {
if (!func(answer_list, rule, option)) {
answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN,
ANSWER_QUALITY_ERROR,
MSG_SPOOL_SETOPTIONOFRULEFAILED_SS,
lGetString(rule, SPR_name),
lGetString(context, SPC_name));
ret = false;
break;
}
}
}
}
/****** Eventmirror/schedd_conf/schedd_conf_update_master_list() ***************
* NAME
* schedd_conf_update_master_list() -- update the scheduler configuration
*
* SYNOPSIS
* bool
* schedd_conf_update_master_list(sge_object_type type,
* sge_event_action action,
* lListElem *event, void *clientdata)
*
* FUNCTION
* Update the global master list of scheduler configurations
* based on an event.
* The function is called from the event mirroring interface.
* The list only contains one element that is replaced when a
* modify event arrives.
*
* INPUTS
* sge_object_type type - event type
* sge_event_action action - action to perform
* lListElem *event - the raw event
* void *clientdata - client data
*
* RESULT
* bool - true, if update is successfull, else false
*
* NOTES
* The function should only be called from the event mirror interface.
*
* SEE ALSO
* Eventmirror/--Eventmirror
*******************************************************************************/
sge_callback_result
schedd_conf_update_master_list(sge_evc_class_t *evc, object_description *object_base, sge_object_type type,
sge_event_action action, lListElem *event, void *clientdata)
{
lList *list = NULL;
lList *answer_list = NULL;
lDescr *list_descr;
lList *data_list;
lListElem *ep = NULL;
DENTER(TOP_LAYER, "schedd_conf_update_master_list");
list_descr = SC_Type;
if ((data_list = lGetList(event, ET_new_version)) != NULL) {
if ((ep = lFirst(data_list)) != NULL) {
ep = lDechainElem(data_list, ep);
}
}
/* if neccessary, create list and copy schedd info */
if (ep != NULL) {
list = lCreateList("schedd config", list_descr);
lAppendElem(list, ep);
}
if (!sconf_set_config(&list, &answer_list)) {
lFreeList(&list);
answer_list_output(&answer_list);
}
DEXIT;
return SGE_EMA_OK;
}
int job_initialize_job(lListElem *job)
{
u_long32 job_id;
lListElem *ja_task;
lListElem *pe_task;
DENTER(TOP_LAYER, "job_initialize_job");
job_id = lGetUlong(job, JB_job_number);
for_each (ja_task, lGetList(job, JB_ja_tasks)) {
u_long32 ja_task_id;
ja_task_id = lGetUlong(ja_task, JAT_task_number);
add_job_report(job_id, ja_task_id, NULL, job);
/* add also job reports for tasks */
for_each (pe_task, lGetList(ja_task, JAT_task_list)) {
add_job_report(job_id, ja_task_id, lGetString(pe_task, PET_id), job);
}
static int
calculate_share_percents(lListElem *node, double parent_percent, double sibling_shares)
{
lListElem *child;
double sum_shares=0;
for_each(child, lGetList(node, STN_children)) {
sum_shares += lGetUlong(child, STN_shares);
}
/*
select and suspend jobs in susp_queues
*/
void
suspend_job_in_queues( lList *susp_queues, lList *job_list, order_t *orders)
{
u_long32 now;
int i, found;
lListElem *jep = NULL, *ja_task = NULL;
lListElem *qep;
DENTER(TOP_LAYER, "suspend_job_in_queues");
now = sge_get_gmt();
for_each (qep, susp_queues) {
u_long32 interval;
/* are suspend thresholds enabled? */
parse_ulong_val(NULL, &interval, TYPE_TIM,
lGetString(qep, QU_suspend_interval), NULL, 0);
if (interval == 0
|| !lGetUlong(qep, QU_nsuspend)
|| !lGetList(qep, QU_suspend_thresholds)) {
continue;
}
/* check time stamp */
if (lGetUlong(qep, QU_last_suspend_threshold_ckeck) &&
(lGetUlong(qep, QU_last_suspend_threshold_ckeck) + interval> now)) {
continue;
}
for (i = 0, found = 1;
i < (int) lGetUlong(qep, QU_nsuspend) && found;
i++) {
found = 0;
/* find one running job in suspend queue */
if (select4suspension(job_list, qep, &jep, &ja_task))
break;
/* generate suspend order for found job */
found = 1;
orders->configOrderList = sge_create_orders(orders->configOrderList,
ORT_suspend_on_threshold,
jep, ja_task, NULL, true);
DPRINTF(("++++ suspending job "sge_u32"/"sge_u32" on threshold\n",
lGetUlong(jep, JB_job_number), lGetUlong(ja_task, JAT_task_number)));
/* prevent multiple selection of this job */
lSetUlong(ja_task, JAT_state,
lGetUlong(ja_task, JAT_state) | JSUSPENDED_ON_THRESHOLD);
}
if (i==0 && !found) {
DPRINTF(("found no jobs for sot in queue %s\n", lGetString(qep, QU_full_name)));
}
}
/****** sgeobj/href/href_list_find_references() *******************************
* NAME
* href_list_find_references() -- Find referenced hosts and groups
*
* SYNOPSIS
* bool
* href_list_find_references(const lList *this_list,
* lList **answer_list,
* const lList *master_list,
* lList **referenced_hosts,
* lList **referenced_groups)
*
* FUNCTION
* Finds hosts and hostgroups, which are directy referenced
* in the hostgroups mentioned in 'this_list'. 'master_list' is
* the list of all existing hostgroups. Directly referenced hosts
* and hostgroups will be added to 'used_hosts' and 'used_groups'.
* In case of any errors 'answer_list' will be filled.
*
* INPUTS
* const lList *this_list - HR_Type
* lList **answer_list - AN_Type
* const lList *master_list - HGRP_Type
* lList **used_hosts - HR_Type
* lList **used_groups - HR_Type
*
* RESULT
* bool - error state
* true - Success
* false - Error
*******************************************************************************/
bool
href_list_find_references(const lList *this_list, lList **answer_list,
const lList *master_list, lList **used_hosts,
lList **used_groups)
{
bool ret = true;
DENTER(HOSTREF_LAYER, "href_list_find_references");
if (this_list != NULL && master_list != NULL) {
lListElem *href; /* HR_Type */
/*
* Handle each reference which was given by the calling context
*/
for_each(href, this_list) {
const char *name = lGetHost(href, HR_name);
bool is_group = is_hgroup_name(name);
lListElem *hgroup = NULL; /* HGRP_name */
/*
* Try to locate the concerned hgroup object
* or add host
*/
if (is_group) {
hgroup = hgroup_list_locate(master_list, name);
} else {
if (used_hosts != NULL) {
href_list_add(used_hosts, answer_list, name);
}
}
if (hgroup != NULL) {
lList *href_list2 = lGetList(hgroup, HGRP_host_list);
lListElem *href2; /* HR_Type */
/*
* Add each element contained in the sublist of the hostgroup
* we found previously to one of the result lists.
*/
for_each(href2, href_list2) {
const char *name2 = lGetHost(href2, HR_name);
if (is_hgroup_name(name2)) {
if (used_groups != NULL) {
href_list_add(used_groups, answer_list, name2);
}
} else {
if (used_hosts != NULL) {
href_list_add(used_hosts, answer_list, name2);
}
}
}
}
}
/****** sgeobj/ja_task/ja_task_search_pe_task()*********************************
* NAME
* ja_task_search_pe_task() -- Find a certain PE Task
*
* SYNOPSIS
* lListElem* ja_task_search_pe_task(const lListElem *ja_task,
* const char **pe_task_id)
*
* FUNCTION
* Find a certain PE Task with "pe_task_id" in "ja_task"
*
* INPUTS
* const lListElem *ja_task - JAT_Type element
* const char *pe_task_id - PE task id string (e.g. "1.speedy")
*
* RESULT
* lListElem* - PET_Type
*******************************************************************************/
lListElem *ja_task_search_pe_task(const lListElem *ja_task,
const char *pe_task_id)
{
if(ja_task != NULL) {
lList *pe_tasks = lGetList(ja_task, JAT_task_list);
if(pe_tasks != NULL) {
return lGetElemStr(pe_tasks, PET_id, pe_task_id);
}
}
return NULL;
}
bool
cqueue_verify_subordinate_list(lListElem *cqueue, lList **answer_list,
lListElem *attr_elem)
{
bool ret = true;
DENTER(CQUEUE_VERIFY_LAYER, "cqueue_verify_subordinate_list");
if (cqueue != NULL && attr_elem != NULL) {
const lList *master_list =
*(object_type_get_master_list(SGE_TYPE_CQUEUE));
const char *cqueue_name = lGetString(cqueue, CQ_name);
lList *so_list = lGetList(attr_elem, ASOLIST_value);
lListElem *so;
for_each(so, so_list) {
const char *so_name = lGetString(so, SO_name);
/*
* Check for recursions to ourself
*/
if (strcmp(cqueue_name, so_name) != 0) {
const lListElem *cqueue = NULL;
/*
* Check if cqueue exists
*/
cqueue = cqueue_list_locate(master_list, so_name);
if (cqueue != NULL) {
/*
* Success
*/
;
} else {
ERROR((SGE_EVENT, MSG_CQUEUE_UNKNOWNSUB_SS,
so_name, cqueue_name));
answer_list_add(answer_list, SGE_EVENT,
STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
ret = false;
}
} else {
ERROR((SGE_EVENT, MSG_CQUEUE_SUBITSELF_S, cqueue_name));
answer_list_add(answer_list, SGE_EVENT,
STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
ret = false;
}
}
}
DEXIT;
return ret;
}
/****** sgeobj/report/job_report_init_from_job() *****************************
* NAME
* job_report_init_from_job() -- initialize job report
*
* SYNOPSIS
* void job_report_init_from_job(lListElem *job_report,
* const lListElem *job,
* const lListElem *ja_task,
* const lListElem *pe_task)
*
* FUNCTION
* Initialize "job_report" from the attributes obtained from
* "job", "ja_task" and "pe_task".
*
* INPUTS
* lListElem *job_report - JR_Type object
* const lListElem *job - JB_Type object
* const lListElem *ja_task - JAT_Type object
* const lListElem *pe_task - PET_Type object
******************************************************************************/
void job_report_init_from_job(lListElem *job_report,
const lListElem *job,
const lListElem *ja_task,
const lListElem *pe_task)
{
u_long32 job_id = lGetUlong(job, JB_job_number);
u_long32 ja_task_id = lGetUlong(ja_task, JAT_task_number);
lListElem *queue = NULL; /* QU_Type */
DENTER(TOP_LAYER, "job_report_init_from_job");
lSetUlong(job_report, JR_job_number, job_id);
lSetUlong(job_report, JR_ja_task_number, ja_task_id);
if (pe_task != NULL) {
lSetString(job_report, JR_pe_task_id_str, lGetString(pe_task, PET_id));
queue = lFirst(lGetList(pe_task, PET_granted_destin_identifier_list));
} else {
queue = lFirst(lGetList(ja_task, JAT_granted_destin_identifier_list));
}
if (lGetUlong(ja_task, JAT_status) == JSLAVE){
if (pe_task == NULL) {
lSetUlong(job_report, JR_state, JSLAVE);
} else {
lSetUlong(job_report, JR_state, JWRITTEN);
}
} else {
lSetUlong(job_report, JR_state, JWRITTEN);
}
if (queue != NULL) {
lSetString(job_report, JR_queue_name, lGetString(queue, JG_qname));
}
DEXIT;
}
/****** SCHEDD/remove_immediate_job()*******************************************
* NAME
* remove_immediate_job() -- test for and remove immediate job which can't
* be scheduled
*
* SYNOPSIS
* int remove_immediate_job(lList *job_list, lListElem *job, order_t *orders,
int remove_orders)
*
* FUNCTION
* Removes immediate jobs which cannot be scheduled from the given job list.
* This is done by generating an order of type ORT_remove_immediate_job. If
* remove_orders is set, the ORT_start_job orders are first removed from the
* order list before adding the remove order.
*
* INPUTS
* lList *job_list - The list of jobs from which the job should be
* removed (JB_Type)
* lListElem *job - The job to remove (JB_Type)
* order_t *orders - The order structure for this scheduler pass
* int remove_orders - Whether the ORT_start_job orders should also be
* be removed
*
* NOTES
* MT-NOTE: remove_immediate_job() is MT safe
*
*******************************************************************************/
void
remove_immediate_job(lList *job_list, lListElem *job, order_t *orders, int remove_orders)
{
lListElem *ja_task;
lListElem *range = NULL;
lList *range_list = NULL;
u_long32 ja_task_id;
DENTER (TOP_LAYER, "remove_immediate_job");
for_each (ja_task, lGetList(job, JB_ja_tasks)) {
if (remove_orders) {
order_remove_order_and_immediate(job, ja_task, orders);
}
else {
order_remove_immediate(job, ja_task, orders);
}
}
range_list = lGetList(job, JB_ja_n_h_ids);
for_each(range, range_list) {
for(ja_task_id = lGetUlong(range, RN_min);
ja_task_id <= lGetUlong(range, RN_max);
ja_task_id += lGetUlong(range, RN_step)) {
ja_task = job_get_ja_task_template_pending(job, ja_task_id);
/* No need to remove the orders here because tasks in JB_ja_n_h_ids
* haven't been scheduled, and hence don't have start orders to
* remove. */
order_remove_immediate(job, ja_task, orders);
}
}
lRemoveElem(job_list, &job);
DEXIT;
}
void xml_addStylesheet(lListElem *xml_head, const char* name, const char *url, const char *version) {
lListElem *stylesheet_elem = lCreateElem(XMLS_Type);
lList *stylesheet_list = NULL;
if (stylesheet_elem) {
lSetString(stylesheet_elem, XMLS_Name, name);
lSetString(stylesheet_elem, XMLS_Value, url);
lSetString(stylesheet_elem, XMLS_Version, version);
stylesheet_list = lGetList(xml_head, XMLH_Stylesheet);
if (!stylesheet_list)
lSetList(xml_head, XMLH_Stylesheet, (stylesheet_list = lCreateList("Stylesheet", XMLS_Type)));
lAppendElem(stylesheet_list, stylesheet_elem);
}
}
/****** Eventmirror/sharetree/sharetree_update_master_list() *******************
* NAME
* sharetree_update_master_list() -- update the master sharetree list
*
* SYNOPSIS
* bool
* sharetree_update_master_list(sge_object_type type, sge_event_action action,
* lListElem *event, void *clientdata)
*
* FUNCTION
* Update the global master list for the sharetree
* based on an event.
* The function is called from the event mirroring interface.
* Sharetree events always contain the whole sharetree, that
* replaces an existing sharetree in the master list.
*
* INPUTS
* sge_object_type type - event type
* sge_event_action action - action to perform
* lListElem *event - the raw event
* void *clientdata - client data
*
* RESULT
* bool - true, if update is successfull, else false
*
* NOTES
* The function should only be called from the event mirror interface.
*
* SEE ALSO
* Eventmirror/--Eventmirror
*******************************************************************************/
sge_callback_result
sharetree_update_master_list(sge_evc_class_t *evc, object_description *object_base, sge_object_type type, sge_event_action action,
lListElem *event, void *clientdata)
{
lList **list = NULL;
lList *src = NULL;
DENTER(TOP_LAYER, "sharetree_update_master_list");
/* remove old share tree */
list = sge_master_list(object_base, type); /*<== need update */
lFreeList(list);
if ((src = lGetList(event, ET_new_version))) {
/* install new one */
*list = lCreateList("share tree", lGetElemDescr(lFirst(lGetList(event, ET_new_version))));
lAppendElem(*list, lDechainElem(src, lFirst(src)));
}
DEXIT;
return SGE_EMA_OK;
}
static sge_callback_result
analyze_jatask_event(sge_evc_class_t *evc, object_description *object_base,sge_object_type type,
sge_event_action action, lListElem *event, void *clientdata)
{
char buffer[1024];
dstring buffer_wrapper;
sge_dstring_init(&buffer_wrapper, buffer, sizeof(buffer));
if (lGetPosViaElem(event, ET_type, SGE_NO_ABORT) >= 0) {
u_long32 type = lGetUlong(event, ET_type);
if (type == sgeE_JATASK_MOD) {
lList *jat = lGetList(event,ET_new_version);
lListElem *ep = lFirst(jat);
u_long job_status = lGetUlong(ep, JAT_status);
int task_running = (job_status==JRUNNING || job_status==JTRANSFERING);
if (task_running) {
}
}
if (type == sgeE_JOB_FINAL_USAGE) {
}
if (type == sgeE_JOB_ADD) {
/* lList *jat = lGetList(event,ET_new_version);
u_long job_id = lGetUlong(event, ET_intkey);
u_long task_id = lGetUlong(event, ET_intkey2);
lListElem *ep = lFirst(jat); */
}
if (type == sgeE_JOB_DEL) {
qevent_trigger_scripts(QEVENT_JB_END, qevent_get_option_struct(), event);
}
if (type == sgeE_JATASK_DEL) {
qevent_trigger_scripts(QEVENT_JB_TASK_END,qevent_get_option_struct() , event);
}
}
/* create a callback error to test error handling */
if(type == SGE_TYPE_GLOBAL_CONFIG) {
return SGE_EMA_FAILURE;
}
return SGE_EMA_OK;
}
static bool
cqueue_add_qinstances(sge_gdi_ctx_class_t *ctx, lListElem *cqueue, lList **answer_list, lList *add_hosts, monitoring_t *monitor)
{
bool ret = true;
DENTER(TOP_LAYER, "cqueue_add_qinstances");
if (cqueue != NULL && add_hosts != NULL) {
lListElem *href = NULL;
for_each(href, add_hosts) {
const char *hostname = lGetHost(href, HR_name);
lList *list = lGetList(cqueue, CQ_qinstances);
lListElem* qinstance = lGetElemHost(list, QU_qhostname, hostname);
if (qinstance != NULL) {
if (qinstance_state_is_orphaned(qinstance)) {
sge_qmaster_qinstance_state_set_orphaned(qinstance, false);
lSetUlong(qinstance, QU_tag, SGE_QI_TAG_MOD);
} else {
/*
* We might already have this QI if it is in orphaned state.
* If this is not true, than there is a bug!
*/
ERROR((SGE_EVENT, MSG_QINSTANCE_QIALREADYHERE_S, hostname));
answer_list_add(answer_list, SGE_EVENT, STATUS_ESYNTAX,
ANSWER_QUALITY_ERROR);
}
} else {
bool is_ambiguous = false;
if (list == NULL) {
list = lCreateList("", QU_Type);
lSetList(cqueue, CQ_qinstances, list);
}
qinstance = qinstance_create(ctx,
cqueue, answer_list,
hostname, &is_ambiguous, monitor);
if (is_ambiguous) {
DPRINTF(("qinstance %s has ambiguous conf\n", hostname));
}
lSetUlong(qinstance, QU_tag, SGE_QI_TAG_ADD);
lAppendElem(list, qinstance);
}
}
}
void job_report_init_from_job_with_usage(lListElem *job_report,
lListElem *job,
lListElem *ja_task,
lListElem *pe_task,
u_long32 time_stamp)
{
lListElem *ep;
lListElem *obj;
int nm;
DENTER(TOP_LAYER, "job_report_init_from_job_with_usage");
/*
* initialize the job jeport like any other job report...
*/
job_report_init_from_job(job_report, job, ja_task, pe_task);
/*
* ... and now add the online usage plus some fileds which are needed for the accounting
*/
lSetUlong(job_report, JR_wait_status, SGE_SET_WEXITSTATUS(SGE_WEXITED_BIT, 0));
lSetUlong(job_report, JR_failed, SSTATE_QMASTER_ENFORCED_LIMIT);
if (pe_task == NULL) {
nm = JAT_scaled_usage_list;
obj = ja_task;
} else {
nm = PET_scaled_usage;
obj = pe_task;
lSetString(job_report, JR_pe_task_id_str, lGetString(pe_task, PET_id));
}
ep = lAddSubStr(obj, UA_name, "submission_time", nm, UA_Type);
lSetDouble(ep, UA_value, lGetUlong(job, JB_submission_time));
ep = lAddSubStr(obj, UA_name, "start_time", nm, UA_Type);
lSetDouble(ep, UA_value, lGetUlong(ja_task, JAT_start_time));
ep = lAddSubStr(obj, UA_name, "end_time", nm, UA_Type);
lSetDouble(ep, UA_value, time_stamp);
ep = lAddSubStr(obj, UA_name, "ru_wallclock", nm, UA_Type);
lSetDouble(ep, UA_value, 0.0);
lSetList(job_report, JR_usage, lCopyList("", lGetList(obj, nm)));
DEXIT;
}
/****** 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;
}
bool
cqueue_verify_pe_list(lListElem *cqueue, lList **answer_list,
lListElem *attr_elem)
{
bool ret = true;
DENTER(CQUEUE_VERIFY_LAYER, "cqueue_verify_pe_list");
if (cqueue != NULL && attr_elem != NULL) {
lList *pe_list = lGetList(attr_elem, ASTRLIST_value);
if (pe_list != NULL) {
const lList *master_list = *(object_type_get_master_list(SGE_TYPE_PE));
if (!pe_list_do_all_exist(master_list, answer_list, pe_list, true)) {
ret = false;
}
}
}
DEXIT;
return ret;
}
bool
cqueue_verify_user_list(lListElem *cqueue, lList **answer_list,
lListElem *attr_elem)
{
bool ret = true;
DENTER(CQUEUE_VERIFY_LAYER, "cqueue_verify_user_list");
if (cqueue != NULL && attr_elem != NULL) {
lList *user_list = lGetList(attr_elem, AUSRLIST_value);
if (user_list != NULL) {
if (userset_list_validate_acl_list(user_list,
answer_list) == STATUS_EUNKNOWN) {
ret = false;
}
}
}
DEXIT;
return ret;
}
bool
cqueue_verify_ckpt_list(lListElem *cqueue, lList **answer_list,
lListElem *attr_elem)
{
bool ret = true;
DENTER(CQUEUE_VERIFY_LAYER, "cqueue_verify_ckpt_list");
if (cqueue != NULL && attr_elem != NULL) {
lList *ckpt_list = lGetList(attr_elem, ASTRLIST_value);
if (ckpt_list != NULL) {
const lList *master_list = *(ckpt_list_get_master_list());
if (!ckpt_list_do_all_exist(master_list, answer_list, ckpt_list)) {
ret = false;
}
}
}
DEXIT;
return ret;
}
/****** sgeobj/report/job_report_print_usage() *******************************
* NAME
* job_report_print_usage() -- Print usage contained in job report
*
* SYNOPSIS
* void job_report_print_usage(const lListElem *job_report,
* FILE *fp)
*
* FUNCTION
* Print usage information conatines in "job_report". Print the
* information to the given file stream "fp" or as debug messages.
*
* INPUTS
* const lListElem *job_report - JR_Type element
* FILE *fp - file stream or NULL
******************************************************************************/
void job_report_print_usage(const lListElem *job_report, FILE *fp)
{
lListElem *uep;
DENTER(TOP_LAYER, "job_report_print_usage");
if (!job_report) {
DEXIT;
return;
}
for_each(uep, lGetList(job_report, JR_usage)) {
if (fp) {
fprintf(fp, " \"%s\" = %.99g\n", lGetString(uep, UA_name),
lGetDouble(uep, UA_value));
} else {
DPRINTF((" \"%s\" = %.99g\n", lGetString(uep, UA_name),
lGetDouble(uep, UA_value)));
}
}
DEXIT;
return;
}
static sge_callback_result
print_jatask_event(sge_evc_class_t *evc, object_description *object_base, sge_object_type type,
sge_event_action action, lListElem *event, void *clientdata)
{
char buffer[1024];
dstring buffer_wrapper;
DENTER(TOP_LAYER, "print_jatask_event");
sge_dstring_init(&buffer_wrapper, buffer, sizeof(buffer));
DPRINTF(("%s\n", event_text(event, &buffer_wrapper)));
if (lGetPosViaElem(event, ET_type, SGE_NO_ABORT) >= 0) {
u_long32 type = lGetUlong(event, ET_type);
u_long32 timestamp = lGetUlong(event, ET_timestamp);
if (type == sgeE_JATASK_MOD) {
lList *jat = lGetList(event,ET_new_version);
u_long job_id = lGetUlong(event, ET_intkey);
u_long task_id = lGetUlong(event, ET_intkey2);
lListElem *ep = lFirst(jat);
u_long job_status = lGetUlong(ep, JAT_status);
int task_running = (job_status==JRUNNING || job_status==JTRANSFERING);
if (task_running) {
fprintf(stdout,"JOB_START (%ld.%ld:ECL_TIME="sge_U32CFormat")\n", job_id ,task_id,sge_u32c(timestamp));
fflush(stdout);
Global_jobs_running++;
}
}
if (type == sgeE_JOB_FINAL_USAGE) {
/* lList *jat = lGetList(event,ET_new_version); */
u_long job_id = lGetUlong(event, ET_intkey);
u_long task_id = lGetUlong(event, ET_intkey2);
/* lWriteElemTo(event, stdout); */
fprintf(stdout,"JOB_FINISH (%ld.%ld:ECL_TIME="sge_U32CFormat")\n", job_id, task_id,sge_u32c(timestamp));
Global_jobs_running--;
fflush(stdout);
}
if (type == sgeE_JOB_ADD) {
lList *jat = lGetList(event,ET_new_version);
u_long job_id = lGetUlong(event, ET_intkey);
u_long task_id = lGetUlong(event, ET_intkey2);
lListElem *ep = lFirst(jat);
const char* job_project = lGetString(ep, JB_project);
if (job_project == NULL) {
job_project = "NONE";
}
fprintf(stdout,"JOB_ADD (%ld.%ld:ECL_TIME="sge_U32CFormat":project=%s)\n", job_id, task_id, sge_u32c(timestamp),job_project);
Global_jobs_registered++;
fflush(stdout);
}
if (type == sgeE_JOB_DEL) {
u_long job_id = lGetUlong(event, ET_intkey);
u_long task_id = lGetUlong(event, ET_intkey2);
fprintf(stdout,"JOB_DEL (%ld.%ld:ECL_TIME="sge_U32CFormat")\n", job_id, task_id,sge_u32c(timestamp));
Global_jobs_registered--;
fflush(stdout);
}
}
/* create a callback error to test error handling */
if(type == SGE_TYPE_GLOBAL_CONFIG) {
DEXIT;
return SGE_EMA_FAILURE;
}
DEXIT;
return SGE_EMA_OK;
}
