/****** sgeobj/var/var_list_split_prefix_vars() *******************************
* NAME
* var_list_split_prefix_vars() -- split a list of variables
*
* SYNOPSIS
* void var_list_split_prefix_vars(lList **varl,
* lList **pefix_vars,
* const char *prefix)
*
* FUNCTION
* Move all variable elements form "varl" to "pefix_vars" which
* begin with "prefix". *pefix_vars will be created if is does not
* exist.
*
* INPUTS
* lList **varl - VA_Type list
* lList **pefix_vars - pointer to VA_Type list
* const char *prefix - string (e.g. VAR_PREFIX)
*
* RESULT
* void - None
*
* SEE ALSO
* sgeobj/var/var_list_remove_prefix_vars()
******************************************************************************/
void var_list_split_prefix_vars(lList **varl,
lList **pefix_vars,
const char *prefix)
{
int prefix_len = strlen(prefix);
lListElem *var_elem = NULL;
lListElem *next_var_elem = NULL;
DENTER(TOP_LAYER, "var_list_remove_prefix_vars");
next_var_elem = lFirst(*varl);
while((var_elem = next_var_elem)) {
const char *prefix_name = lGetString(var_elem, VA_variable);
next_var_elem = lNext(var_elem);
if (!strncmp(prefix_name, prefix, prefix_len)) {
lListElem *dechained_elem = lDechainElem(*varl, var_elem);
if (*pefix_vars == NULL) {
*pefix_vars = lCreateList("", VA_Type);
}
lAppendElem(*pefix_vars, dechained_elem);
}
}
DEXIT;
return;
}
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;
}
static int do_qeti_test(lListElem *cr, u_long32 *qeti_expected_result)
{
lList *cr_list;
sge_qeti_t *iter;
u_long32 pe_time;
int ret = 0;
int i = 0;
/* sge_qeti_allocate() */
cr_list = lCreateList("", RUE_Type);
lAppendElem(cr_list, cr);
iter = sge_qeti_allocate2(cr_list);
/* sge_qeti_first() */
for (pe_time = sge_qeti_first(iter), i=0; pe_time; pe_time = sge_qeti_next(iter), i++) {
if (qeti_expected_result == NULL) {
printf("failed: qeti returned "sge_U32CFormat", expected no iteration\n", sge_u32c(pe_time));
ret++;
} else if (qeti_expected_result[i] != pe_time) {
printf("failed: qeti returned "sge_U32CFormat", expected "sge_U32CFormat"\n", sge_u32c(pe_time), sge_u32c(qeti_expected_result[i]));
ret++;
} else {
printf("success: QETI returned "sge_U32CFormat"\n", sge_u32c(pe_time));
}
}
lDechainElem(cr_list, cr);
sge_qeti_release(&iter);
lFreeList(&cr_list);
return ret;
}
/****** 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;
}
/****** sgeobj/var/var_list_add_as_set() ***************************************
* NAME
* var_list_add_as_set() -- Concatenate two lists as sets
*
* SYNOPSIS
* int var_list_add_as_set(lList *lp0, lList *lp1)
*
* FUNCTION
* Concatenate two lists of equal type throwing away the second list.
* Elements in the second list will replace elements with the same key in the
* the first list. If the first list contains duplicate element keys, only
* the first element with a given key will be replaced by an element from the
* second list with the same key.
*
* INPUTS
* lList *lp0 - first list
* lList *lp1 - second list
*
* RESULT
* int - error state
* 0 - OK
* -1 - Error
******************************************************************************/
int var_list_add_as_set(lList *lp0, lList *lp1)
{
lListElem *ep0, *ep1;
const lDescr *dp0, *dp1;
const char *name, *value;
DENTER(CULL_LAYER, "var_list_add_as_set");
if (lp1 == NULL || lp0 == NULL) {
DRETURN(-1);
}
/* Check if the two lists are equal */
dp0 = lGetListDescr(lp0);
dp1 = lGetListDescr(lp1);
if (lCompListDescr(dp0, dp1) != 0) {
DRETURN(-1);
}
while (lp1->first != NULL) {
/* Get the first element from the second list */
if ((ep1 = lDechainElem(lp1, lp1->first)) == NULL) {
DRETURN(-1);
}
/* Get it's name, and use the name to look for a matching element in the
* first list. */
name = lGetString(ep1, VA_variable);
ep0 = lGetElemStr(lp0, VA_variable, name);
/* If there is a matching element in the first list, set it's value to the
* value of the element from the second list. */
if (ep0 != NULL) {
value = lGetString(ep1, VA_value);
lSetString(ep0, VA_value, value);
lFreeElem(&ep1);
}
/* If there is no matching element, add the element from the second list
* to the first list. */
else {
if (lAppendElem(lp0, ep1) == -1) {
DRETURN(-1);
}
}
}
/* The second list is no longer needed. */
lFreeList(&lp1);
DRETURN(0);
}
/****** 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;
}
/****** 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;
}
/****** sge_manop_qmaster/sge_del_manop() **************************************
* NAME
* sge_del_manop() -- delete manager or operator
*
* SYNOPSIS
* int
* sge_del_manop(sge_gdi_ctx_class_t *ctx, lListElem *ep, lList **alpp,
* char *ruser, char *rhost, u_long32 target)
*
* FUNCTION
* Deletes a manager or an operator from the corresponding master list.
*
* INPUTS
* sge_gdi_ctx_class_t *ctx - gdi context
* lListElem *ep - the manager/operator to delete
* lList **alpp - answer list to return messages
* char *ruser - user having triggered the action
* char *rhost - host from which the action has been triggered
* u_long32 target - SGE_UM_LIST or SGE_UO_LIST
*
* RESULT
* int - STATUS_OK or STATUS_* error code
*
* NOTES
* MT-NOTE: sge_del_manop() is MT safe - if we hold the global lock.
*******************************************************************************/
int sge_del_manop(sge_gdi_ctx_class_t *ctx, lListElem *ep, lList **alpp, char *ruser, char *rhost, u_long32 target)
{
lListElem *found;
int pos;
const char *manop_name;
const char *object_name;
lList **lpp = NULL;
int key = NoName;
ev_event eve = sgeE_EVENTSIZE;
DENTER(TOP_LAYER, "sge_del_manop");
if (ep == NULL || ruser == NULL || rhost == NULL) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_NULLPTRPASSED_S, SGE_FUNC));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
switch (target) {
case SGE_UM_LIST:
lpp = object_type_get_master_list(SGE_TYPE_MANAGER);
object_name = MSG_OBJ_MANAGER;
key = UM_name;
eve = sgeE_MANAGER_DEL;
break;
case SGE_UO_LIST:
lpp = object_type_get_master_list(SGE_TYPE_OPERATOR);
object_name = MSG_OBJ_OPERATOR;
key = UO_name;
eve = sgeE_OPERATOR_DEL;
break;
default :
DPRINTF(("unknown target passed to %s\n", SGE_FUNC));
DRETURN(STATUS_EUNKNOWN);
}
/* ep is no manop element, if ep has no UM_name/UO_name */
if ((pos = lGetPosViaElem(ep, key, SGE_NO_ABORT)) < 0) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_MISSINGCULLFIELD_SS, lNm2Str(key), SGE_FUNC));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
manop_name = lGetPosString(ep, pos);
if (manop_name == NULL) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_NULLPTRPASSED_S, SGE_FUNC));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
/* prevent removing of root from man/op-list */
if (strcmp(manop_name, "root") == 0) {
ERROR((SGE_EVENT, MSG_SGETEXT_MAY_NOT_REMOVE_USER_FROM_LIST_SS, "root", object_name));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
/* prevent removing the admin user from man/op-list */
if (strcmp(manop_name, ctx->get_admin_user(ctx)) == 0) {
ERROR((SGE_EVENT, MSG_SGETEXT_MAY_NOT_REMOVE_USER_FROM_LIST_SS,
ctx->get_admin_user(ctx), object_name));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
found = lGetElemStr(*lpp, key, manop_name);
if (!found) {
ERROR((SGE_EVENT, MSG_SGETEXT_DOESNOTEXIST_SS, object_name, manop_name));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
lDechainElem(*lpp, found);
/* update on file */
if (!sge_event_spool(ctx, alpp, 0, eve,
0, 0, manop_name, NULL, NULL,
NULL, NULL, NULL, true, true)) {
ERROR((SGE_EVENT, MSG_CANTSPOOL_SS, object_name, manop_name));
answer_list_add(alpp, SGE_EVENT, STATUS_EDISK, ANSWER_QUALITY_ERROR);
/* chain in again */
lAppendElem(*lpp, found);
DRETURN(STATUS_EDISK);
}
lFreeElem(&found);
INFO((SGE_EVENT, MSG_SGETEXT_REMOVEDFROMLIST_SSSS, ruser, rhost, manop_name, object_name));
answer_list_add(alpp, SGE_EVENT, STATUS_OK, ANSWER_QUALITY_INFO);
DRETURN(STATUS_OK);
}
