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;
}
/****** 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;
}
/****** Eventmirror/pe_task/pe_task_update_master_list() ***********************
* NAME
* pe_task_update_master_list() -- update parallel tasks of an array task
*
* SYNOPSIS
* bool
* pe_task_update_master_list(sge_object_type type, sge_event_action action,
* lListElem *event, void *clientdata)
*
* FUNCTION
* Update the list of parallel tasks of an array task
* based on an event.
* The function is called from the event mirroring interface.
*
* The scaled usage list of a parallel task is not updated
* by this function, as this data is maintained by a
* separate event.
*
* INPUTS
* sge_object_type type - event type
* sge_event_action action - action to perform
* lListElem *event - the raw event
* void *clientdata - client data
*
* RESULT
* bool - true, if update is successfull, else false
*
* NOTES
* The function should only be called from the event mirror interface.
*
* SEE ALSO
* Eventmirror/--Eventmirror
* Eventmirror/sge_mirror_update_master_list()
*******************************************************************************/
sge_callback_result
pe_task_update_master_list(sge_evc_class_t *evc, object_description *object_base, sge_object_type type,
sge_event_action action, lListElem *event, void *clientdata)
{
u_long32 job_id;
lListElem *job = NULL;
const char *pe_task_id = NULL;
lListElem *pe_task = NULL;
u_long32 ja_task_id;
lListElem *ja_task = NULL;
lList *pe_task_list = NULL;
const lDescr *pe_task_descr = NULL;
lList *usage = NULL;
char id_buffer[MAX_STRING_SIZE];
dstring id_dstring;
DENTER(TOP_LAYER, "pe_task_update_master_list");
sge_dstring_init(&id_dstring, id_buffer, MAX_STRING_SIZE);
job_id = lGetUlong(event, ET_intkey);
ja_task_id = lGetUlong(event, ET_intkey2);
pe_task_id = lGetString(event, ET_strkey);
job = job_list_locate(*sge_master_list(object_base, SGE_TYPE_JOB), job_id);
if (job == NULL) {
ERROR((SGE_EVENT, MSG_JOB_CANTFINDJOBFORUPDATEIN_SS,
job_get_id_string(job_id, 0, NULL, &id_dstring), SGE_FUNC));
DEXIT;
return SGE_EMA_FAILURE;
}
ja_task = job_search_task(job, NULL, ja_task_id);
if (ja_task == NULL) {
ERROR((SGE_EVENT, MSG_JOB_CANTFINDJATASKFORUPDATEIN_SS,
job_get_id_string(job_id, ja_task_id, NULL, &id_dstring), SGE_FUNC));
DEXIT;
return SGE_EMA_FAILURE;
}
pe_task = ja_task_search_pe_task(ja_task, pe_task_id);
pe_task_list = lGetList(ja_task, JAT_task_list);
pe_task_descr = lGetListDescr(lGetList(event, ET_new_version));
if (action == SGE_EMA_MOD) {
/* modify event for pe_task.
* we may not update
* - PET_scaled_usage - it is maintained by JOB_USAGE events
*/
if (pe_task == NULL) {
ERROR((SGE_EVENT, MSG_JOB_CANTFINDPETASKFORUPDATEIN_SS,
job_get_id_string(job_id, ja_task_id, pe_task_id, &id_dstring), SGE_FUNC));
DEXIT;
return SGE_EMA_FAILURE;
}
lXchgList(pe_task, PET_scaled_usage, &usage);
}
if (sge_mirror_update_master_list(&pe_task_list, pe_task_descr, pe_task,
job_get_id_string(job_id, ja_task_id,
pe_task_id, &id_dstring),
action, event) != SGE_EM_OK) {
lFreeList(&usage);
DEXIT;
return SGE_EMA_FAILURE;
}
/* restore pe_task list after modify event */
if (action == SGE_EMA_MOD) {
pe_task = ja_task_search_pe_task(ja_task, pe_task_id);
if (pe_task == NULL) {
ERROR((SGE_EVENT, MSG_JOB_CANTFINDPETASKFORUPDATEIN_SS,
job_get_id_string(job_id, ja_task_id, pe_task_id, &id_dstring), SGE_FUNC));
lFreeList(&usage);
DEXIT;
return SGE_EMA_FAILURE;
}
lXchgList(pe_task, PET_scaled_usage, &usage);
lFreeList(&usage);
}
/* first petask add event could have created new pe_task list for job */
if (lGetList(ja_task, JAT_task_list) == NULL && pe_task_list != NULL) {
lSetList(ja_task, JAT_task_list, pe_task_list);
}
DEXIT;
return SGE_EMA_OK;
}
/****** Eventmirror/job/job_update_master_list() *****************************
* NAME
* job_update_master_list() -- update the master list of jobs
*
* SYNOPSIS
* bool job_update_master_list(sge_object_type type,
* sge_event_action action,
* lListElem *event, void *clientdata)
*
* FUNCTION
* Update the global master list of jobs
* based on an event.
* The function is called from the event mirroring interface.
*
* A jobs array tasks are not updated by this function,
* as they are maintained by separate events.
* In addition, some scheduler specific attributes, that
* are only used in scheduler, are not updated.
*
* INPUTS
* sge_object_type type - event type
* sge_event_action action - action to perform
* lListElem *event - the raw event
* void *clientdata - client data
*
* RESULT
* bool - true, if update is successfull, else false
*
* NOTES
* The function should only be called from the event mirror interface.
*
* SEE ALSO
* Eventmirror/--Eventmirror
* Eventmirror/sge_mirror_update_master_list()
* Eventmirror/job/job_update_master_list_usage()
*******************************************************************************/
sge_callback_result
job_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;
const lDescr *list_descr;
u_long32 job_id;
lListElem *job = NULL;
lList *ja_tasks = NULL;
char id_buffer[MAX_STRING_SIZE];
dstring id_dstring;
DENTER(TOP_LAYER, "job_update_master_list");
sge_dstring_init(&id_dstring, id_buffer, MAX_STRING_SIZE);
list = sge_master_list(object_base, SGE_TYPE_JOB);
list_descr = lGetListDescr(lGetList(event, ET_new_version));
job_id = lGetUlong(event, ET_intkey);
job = job_list_locate(*list, job_id);
if (action == SGE_EMA_MOD) {
u_long32 event_type = lGetUlong(event, ET_type);
if (job == NULL) {
ERROR((SGE_EVENT, MSG_JOB_CANTFINDJOBFORUPDATEIN_SS,
job_get_id_string(job_id, 0, NULL, &id_dstring), "job_update_master_list"));
DRETURN(SGE_EMA_FAILURE);
}
if (event_type == sgeE_JOB_USAGE || event_type == sgeE_JOB_FINAL_USAGE ) {
/* special handling needed for JOB_USAGE and JOB_FINAL_USAGE events.
* they are sent for jobs, ja_tasks and pe_tasks and only contain
* the usage list.
* Preferable would probably be to send MOD events for the different
* object types.
*/
bool ret = job_update_master_list_usage(*list, event);
DRETURN(ret?SGE_EMA_OK:SGE_EMA_FAILURE);
} else {
/* this is the true modify event.
* we may not update several fields:
* - JB_ja_tasks is the task list - it is maintained by JATASK events
* - JB_host and JB_category are scheduler internal attributes
* they may not be overwritten.
* Better would be to move them from JB_Type to some scheduler specific
* object.
*/
lListElem *modified_job;
modified_job = lFirst(lGetList(event, ET_new_version));
if(job != NULL && modified_job != NULL) {
/* we want to preserve the old ja_tasks, since job update events to not contain them */
lXchgList(job, JB_ja_tasks, &ja_tasks);
lSetHost(modified_job, JB_host, lGetHost(job, JB_host));
lSetRef(modified_job, JB_category, lGetRef(job, JB_category));
}
}
}
if (sge_mirror_update_master_list(list, list_descr, job, job_get_id_string(job_id, 0, NULL, &id_dstring), action, event) != SGE_EM_OK) {
lFreeList(&ja_tasks);
DRETURN(SGE_EMA_FAILURE);
}
/* restore ja_task list after modify event */
if (action == SGE_EMA_MOD && ja_tasks != NULL) {
/* we have to search the replaced job */
job = job_list_locate(*list, job_id);
if(job == NULL) {
ERROR((SGE_EVENT, MSG_JOB_CANTFINDJOBFORUPDATEIN_SS,
job_get_id_string(job_id, 0, NULL, &id_dstring), "job_update_master_list"));
lFreeList(&ja_tasks);
DRETURN(SGE_EMA_FAILURE);
}
lXchgList(job, JB_ja_tasks, &ja_tasks);
lFreeList(&ja_tasks);
}
DRETURN(SGE_EMA_OK);
}
