/****** 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;
}
}
}
/****** cull/list/lWriteListXMLTo() **********************************************
* NAME
* lWriteListXMLTo() -- Write a list to a file stream
*
* SYNOPSIS
* void lWriteListXMLTo(const lList *lp, FILE *fp)
*
* FUNCTION
* Write a list to a file stream in XML format
*
* INPUTS
* const lList *lp - list
* int nesting_level - current nesting level
* FILE *fp - file stream
*
* NOTE:
* MT-NOTE: is thread save, works only on the objects which are passed in
*
*******************************************************************************/
static void lWriteListXML_(const lList *lp, int nesting_level, FILE *fp, int ignore_cull_name)
{
lListElem *ep;
char indent[128];
int i;
bool is_XML_elem = false;
dstring attr = DSTRING_INIT;
bool is_attr = false;
DENTER(CULL_LAYER, "lWriteListXML_");
if (!lp) {
LERROR(LELISTNULL);
DEXIT;
return;
}
{
int max = nesting_level * 2;
if (max > 128)
max = 128;
for (i = 0; i < max; i++)
indent[i] = ' ';
indent[i] = '\0';
}
for_each(ep, lp) {
is_XML_elem = false;
is_attr = false;
if (lGetPosViaElem(ep, XMLE_Attribute, SGE_NO_ABORT) != -1) {
sge_dstring_clear(&attr);
is_attr = lAttributesToString_(lGetList(ep, XMLE_Attribute), &attr);
is_XML_elem = true;
}
if (is_XML_elem && (lGetBool(ep, XMLE_Print))) {
lListElem *elem = lGetObject(ep, XMLE_Element);
if (!fp) {
if (lGetString(elem, XMLA_Value) != NULL) {
DPRINTF(("%s<%s%s>", indent, lGetString(elem, XMLA_Name), (is_attr?sge_dstring_get_string(&attr):"")));
DPRINTF(("%s", lGetString(elem, XMLA_Value)));
lWriteListXML_(lGetList(ep, XMLE_List), nesting_level+1, fp, ignore_cull_name);
DPRINTF(("</%s>\n", lGetString(elem, XMLA_Name)));
}
else {
DPRINTF(("%s<%s%s>\n", indent, lGetString(elem, XMLA_Name), (is_attr?sge_dstring_get_string(&attr):"")));
lWriteListXML_(lGetList(ep, XMLE_List), nesting_level+1, fp, ignore_cull_name);
DPRINTF(("%s</%s>\n", indent,lGetString(elem, XMLA_Name)));
}
}
else {
if (lGetString(elem, XMLA_Value) != NULL) {
fprintf(fp, "%s<%s%s>", indent, lGetString(elem, XMLA_Name), (is_attr?sge_dstring_get_string(&attr):""));
fprintf(fp, "%s", lGetString(elem, XMLA_Value));
lWriteListXML_(lGetList(ep, XMLE_List), nesting_level+1, fp, ignore_cull_name);
fprintf(fp, "</%s>\n", lGetString(elem, XMLA_Name));
}
else {
fprintf(fp, "%s<%s%s>\n", indent, lGetString(elem, XMLA_Name), (is_attr?sge_dstring_get_string(&attr):""));
lWriteListXML_(lGetList(ep, XMLE_List), nesting_level+1, fp, ignore_cull_name);
fprintf(fp, "%s</%s>\n", indent, lGetString(elem, XMLA_Name));
}
}
}
else {
const char* listName = lGetListName(lp);
if (strcmp (listName, "No list name specified") == 0) {
listName = "element";
}
if (!fp) {
DPRINTF(("%s<%s%s>\n", indent, listName, ((is_attr)?sge_dstring_get_string(&attr):"")));
lWriteElemXML_(ep, nesting_level+1, NULL, ignore_cull_name);
DPRINTF(("%s</%s>\n", indent, listName));
}
else {
fprintf(fp, "%s<%s%s>\n", indent, listName, ((is_attr)?sge_dstring_get_string(&attr):""));
lWriteElemXML_(ep, nesting_level+1, fp, ignore_cull_name);
fprintf(fp, "%s</%s>\n", indent, listName);
}
}
}
/****** category/sge_build_job_category_dstring() ******************************
* NAME
* sge_build_job_category_dstring() -- build the category string
*
* SYNOPSIS
* void sge_build_job_category_dstring(dstring *category_str, lListElem
* *job, lList *acl_list)
*
* FUNCTION
* The following parameter are put into the category:
* hard_queue_list
* master_hard_queue_list
* hard_resource_list
* soft_resource_list
* checkpoint_name
* type
*
* owner/group: -U user_lists
* Omitted, if user_lists/xuser_lists were not used in
* host_conf(5), sge_pe(5) and queue_conf(5). In sge_conf(5)
* user_lists/xuser_lists still can be used, as it causes
* jobs already be rejected at submit time.
*
* project: -P user_lists
* Omitted, if projects/xprojects were not used in
* host_conf(5), sge_pe(5) and queue_conf(5). In sge_conf(5)
* projects/xprojects still can be used, as it cuases
* jobs already be rejected at submit time.
*
* pe
*
* INPUTS
* dstring *category_str - target string, contains the category or nothing
* lListElem *job - the job for the category creating
* lList *acl_list - global access list
*
* NOTES
* MT-NOTE: sge_build_job_category_dstring() is MT safe as long as the caller is
*
*******************************************************************************/
void sge_build_job_category_dstring(dstring *category_str, lListElem *job, lList *acl_list, const lList *prj_list, bool *did_project, const lList *rqs_list)
{
const char *owner = NULL;
const char *group = NULL;
DENTER(TOP_LAYER, "sge_build_job_category_dstring");
DTRACE;
#if 0
sge_mutex_lock("cull_order_mutex", SGE_FUNC, __LINE__, &Category_Control.cull_order_mutex);
if (Category_Control.cull_order_pos.JB_hard_queue_list_pos == -1) {
Category_Control.cull_order_pos.JB_checkpoint_name_pos = lGetPosViaElem(job, JB_checkpoint_name, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_soft_resource_list_pos = lGetPosViaElem(job, JB_soft_resource_list, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_master_hard_queue_list_pos = lGetPosViaElem(job, JB_master_hard_queue_list, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_hard_queue_list_pos = lGetPosViaElem(job, JB_hard_queue_list, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_owner_pos = lGetPosViaElem(job, JB_owner, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_group_pos = lGetPosViaElem(job, JB_group, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_hard_resource_list_pos = lGetPosViaElem(job, JB_hard_resource_list, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_type_pos = lGetPosViaElem(job, JB_type, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_project_pos = lGetPosViaElem(job, JB_project, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_ar_pos = lGetPosViaElem(job, JB_ar, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_pe_pos = lGetPosViaElem(job, JB_pe, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_range_pos = lGetPosViaElem(job, JB_pe_range, SGE_NO_ABORT);
}
sge_mutex_unlock("cull_order_mutex", SGE_FUNC, __LINE__, &Category_Control.cull_order_mutex);
#endif
DTRACE;
/*
** owner -> acl
*/
owner = lGetPosString(job, lGetPosViaElem(job, JB_owner, SGE_NO_ABORT));
DTRACE;
group = lGetPosString(job, lGetPosViaElem(job, JB_group, SGE_NO_ABORT));
DTRACE;
sge_unparse_acl_dstring(category_str, owner, group, acl_list, "-U");
DTRACE;
/*
** -u if referenced in resource quota sets
*/
/* RD TODO: A possible performance enhancement is to split user and group inside category.
Some users are only referenced by the unix group. Their jobs could be grouped
together by referencing only the group in the category string
*/
if (sge_user_is_referenced_in_rqs(rqs_list, lGetString(job, JB_owner), lGetString(job, JB_group), acl_list)) {
if (sge_dstring_strlen(category_str) > 0) {
sge_dstring_append(category_str, " ");
}
sge_dstring_append(category_str, "-u ");
sge_dstring_append(category_str, lGetString(job, JB_owner));
}
DTRACE;
/*
** -hard -q qlist
*/
sge_unparse_queue_list_dstring(category_str, job, lGetPosViaElem(job, JB_hard_queue_list, SGE_NO_ABORT), "-q");
DTRACE;
/*
** -masterq qlist
*/
sge_unparse_queue_list_dstring(category_str, job, lGetPosViaElem(job, JB_master_hard_queue_list, SGE_NO_ABORT), "-masterq");
DTRACE;
/*
** -l rlist (hard resource list)
*/
sge_unparse_resource_list_dstring(category_str, job, lGetPosViaElem(job, JB_hard_resource_list, SGE_NO_ABORT), "-l");
DTRACE;
/*
** -soft -l rlist
*/
sge_unparse_resource_list_dstring(category_str, job, lGetPosViaElem(job, JB_soft_resource_list, SGE_NO_ABORT), "-soft -l");
DTRACE;
/*
** -pe pe_name pe_range
*/
sge_unparse_pe_dstring(category_str, job, lGetPosViaElem(job, JB_pe, SGE_NO_ABORT),
lGetPosViaElem(job, JB_pe_range, SGE_NO_ABORT), "-pe");
DTRACE;
/*
** -ckpt ckpt_name
*/
sge_unparse_string_option_dstring(category_str, job, lGetPosViaElem(job, JB_checkpoint_name, SGE_NO_ABORT), "-ckpt");
DTRACE;
/*
** interactive jobs
*/
if (JOB_TYPE_IS_IMMEDIATE(lGetPosUlong(job, lGetPosViaElem(job, JB_type, SGE_NO_ABORT)))) {
if (sge_dstring_strlen(category_str) > 0) {
sge_dstring_append(category_str, " -I y");
}
else {
sge_dstring_append(category_str, "-I y");
}
}
DTRACE;
/*
** project
*/
{
const char *project = lGetPosString(job, lGetPosViaElem(job, JB_project, SGE_NO_ABORT));
const lListElem *prj;
if (project && (prj=lGetElemStr(prj_list, PR_name, project)) && lGetBool(prj, PR_consider_with_categories)) {
if (did_project)
*did_project = true;
sge_unparse_string_option_dstring(category_str, job, lGetPosViaElem(job, JB_project, SGE_NO_ABORT), "-P");
} else
if (did_project)
*did_project = false;
}
DTRACE;
/*
** -ar ar_id
*/
sge_unparse_ulong_option_dstring(category_str, job, lGetPosViaElem(job, JB_ar, SGE_NO_ABORT), "-ar");
DRETURN_VOID;
}
lList *cull_unparse_job_parameter(
sge_gdi_ctx_class_t *ctx,
lList **pcmdline,
lListElem *job,
int flags
) {
const char *cp;
u_long32 ul;
lList *answer = NULL;
char str[1024 + 1];
lList *lp;
int ret;
lListElem *ep_opt;
const char *username = ctx->get_username(ctx);
const char *qualified_hostname = ctx->get_qualified_hostname(ctx);
DENTER(TOP_LAYER, "cull_unparse_job_parameter");
/*
** -a
** problem with submission time, but that is not a good
** default option anyway, is not unparsed
*/
/*
** -A
*/
if (sge_unparse_account_string(job, pcmdline, &answer) != 0) {
DEXIT;
return answer;
}
/*
** -c
*/
if (sge_unparse_checkpoint_option(job, pcmdline, &answer) != 0) {
DEXIT;
return answer;
}
/*
* -ckpt
*/
if (sge_unparse_string_option(job, JB_checkpoint_name, "-ckpt",
pcmdline, &answer) != 0) {
DEXIT;
return answer;
}
/*
** -cwd
*/
if (lGetString(job, JB_cwd)) {
ep_opt = sge_add_noarg(pcmdline, cwd_OPT, "-cwd", NULL);
}
/*
* -P
*/
if (sge_unparse_string_option(job, JB_project, "-P",
pcmdline, &answer) != 0) {
DEXIT;
return answer;
}
#if 0
/*
** -C
*/
if (sge_unparse_string_option(job, JB_directive_prefix, "-C",
pcmdline, &answer) != 0) {
DEXIT;
return answer;
}
#endif
/*
** -e
*/
if (sge_unparse_path_list(job, JB_stderr_path_list, "-e", pcmdline,
&answer) != 0) {
DEXIT;
return answer;
}
/*
** -h, here only user hold supported at the moment
*/
if ((ul = lGetUlong(lFirst(lGetList(job, JB_ja_tasks)), JAT_hold))) {
ep_opt = sge_add_noarg(pcmdline, h_OPT, "-h", NULL);
}
/*
** -hold_jid
*/
if ((lp = lGetList(job, JB_jid_request_list))) {
int fields[] = { JRE_job_name, 0 };
const char *delis[] = {NULL, ",", NULL};
ret = uni_print_list(NULL, str, sizeof(str) - 1, lp, fields, delis, 0);
if (ret) {
DPRINTF(("Error %d formatting jid_request_list as -hold_jid\n", ret));
sprintf(str, MSG_LIST_ERRORFORMATINGJIDPREDECESSORLISTASHOLDJID);
answer_list_add(&answer, str, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
return answer;
}
ep_opt = sge_add_arg(pcmdline, hold_jid_OPT, lListT, "-hold_jid", str);
lSetList(ep_opt, SPA_argval_lListT, lCopyList("hold_jid list", lp));
}
/*
** -hold_jid_ad
*/
if ((lp = lGetList(job, JB_ja_ad_request_list))) {
int fields[] = { JRE_job_name, 0 };
const char *delis[] = {NULL, ",", NULL};
ret = uni_print_list(NULL, str, sizeof(str) - 1, lp, fields, delis, 0);
if (ret) {
DPRINTF(("Error %d formatting ja_ad_request_list as -hold_jid_ad\n", ret));
sprintf(str, MSG_LIST_ERRORFORMATINGJIDPREDECESSORLISTASHOLDJIDAD);
answer_list_add(&answer, str, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
return answer;
}
ep_opt = sge_add_arg(pcmdline, hold_jid_ad_OPT, lListT, "-hold_jid_ad", str);
lSetList(ep_opt, SPA_argval_lListT, lCopyList("hold_jid_ad list", lp));
}
/*
** -i
*/
if (sge_unparse_path_list(job, JB_stdin_path_list, "-i", pcmdline,
&answer) != 0) {
DEXIT;
return answer;
}
/*
** -j
*/
if ((ul = lGetBool(job, JB_merge_stderr))) {
ep_opt = sge_add_arg(pcmdline, j_OPT, lIntT, "-j", "y");
lSetInt(ep_opt, SPA_argval_lIntT, true);
}
/*
** -jid
*/
if ((lp = lGetList(job, JB_job_identifier_list))) {
int fields[] = { JRE_job_number, 0};
const char *delis[] = {"", ",", NULL};
ret = uni_print_list(NULL, str, sizeof(str) - 1, lp, fields, delis,
0);
if (ret) {
DPRINTF(("Error %d formatting job_identifier_list as -jid\n", ret));
sprintf(str, MSG_LIST_ERRORFORMATINGJOBIDENTIFIERLISTASJID);
answer_list_add(&answer, str, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
return answer;
}
ep_opt = sge_add_arg(pcmdline, jid_OPT, lListT, "-jid", str);
lSetList(ep_opt, SPA_argval_lListT, lCopyList("jid list", lp));
}
/*
** -js
*/
if ((ul = lGetUlong(job, JB_jobshare)) != 0) {
sprintf(str, sge_u32, ul);
ep_opt = sge_add_arg(pcmdline, js_OPT, lUlongT, "-js", str);
lSetUlong(ep_opt, SPA_argval_lUlongT, ul);
}
/*
** -lj is in parsing but can't be unparsed here
*/
/*
** -l
*/
if (sge_unparse_resource_list(job, JB_hard_resource_list,
pcmdline, &answer) != 0) {
DEXIT;
return answer;
}
if (sge_unparse_resource_list(job, JB_soft_resource_list,
pcmdline, &answer) != 0) {
DEXIT;
return answer;
}
/*
** -m
*/
if ((ul = lGetUlong(job, JB_mail_options))) {
cp = sge_unparse_mail_options(ul);
if (!cp) {
DPRINTF(("Error unparsing mail options\n"));
sprintf(str, MSG_PARSE_ERRORUNPARSINGMAILOPTIONS);
answer_list_add(&answer, str, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
return answer;
}
ep_opt = sge_add_arg(pcmdline, m_OPT, lIntT, "-m", cp);
lSetInt(ep_opt, SPA_argval_lIntT, ul);
}
/*
** -M obviously a problem!!!
** not unparsed at the moment
** does it make sense as a default, after all?
*/
if ((lp = lGetList(job, JB_mail_list))) {
lList *lp_new = NULL;
lListElem *ep_new = NULL;
lListElem *ep = NULL;
const char *host;
const char *user;
/*
** or rather take all if there are more than one elements?
*/
for_each(ep, lp) {
user = lGetString(ep, MR_user);
host = lGetHost(ep, MR_host);
if (sge_strnullcmp(user, username) ||
sge_hostcmp(host, qualified_hostname)) {
lp_new = lCreateList("mail list", MR_Type);
ep_new = lAddElemStr(&lp_new, MR_user, user, MR_Type);
lSetHost(ep_new, MR_host, host);
}
}
/****** sge_select_queue/get_queue_resource() ***************************************
* NAME
* get_queue_resource() -- extracts attribut information from the queue
*
* SYNOPSIS
* static lListElem* get_queue_resource(lListElem *queue, lList *centry_list, const char *attrname)
*
* FUNCTION
* All fixed queue attributes are directly coded into the queue structure. These have to extraced
* and formed into a CE structure. That is, what this function does. It takes a name for an attribut
* and returns a full CE structure, if the attribut is set in the queue. Otherwise it returns NULL.
*
* INPUTS
* lListElem *queue_elem -
* lListElm *queue -
* const char *attrname - name of the attribute.
* RESULT
* bool -
*
*
*******************************************************************************/
bool get_queue_resource(lListElem *queue_elem, const lListElem *queue, const char *attrname){
double dval=0.0;
const char *value=NULL;
char as_str[100];
int type, field;
DENTER(BASIS_LAYER, "get_queue_resource");
if(!queue_elem){
/* error */
DRETURN(false);
}
if (get_rsrc(attrname, true, &field, NULL, NULL, &type)!=0) {
DPRINTF(("is not a system queue attribute: %s\n", attrname));
DRETURN(false);
}
/* read stuff from queue and set to new elements */
switch(type) {
case TYPE_INT:
dval = (double)lGetUlong(queue, field);
snprintf(as_str, 100, sge_u32, lGetUlong(queue, field));
break;
case TYPE_TIM:
case TYPE_MEM:
case TYPE_DOUBLE:
if ((value = lGetString(queue, field))) {
parse_ulong_val(&dval, NULL, type, value, NULL, 0);
}
break;
case TYPE_BOO:
dval = (double)lGetBool(queue, field);
snprintf(as_str, 100, "%d", (int)lGetBool(queue, field));
break;
case TYPE_STR:
case TYPE_CSTR:
case TYPE_RESTR:
value = lGetString(queue, field);
break;
case TYPE_HOST:
value = lGetHost(queue, field);
break;
}
if (!is_attr_prior2(queue_elem, dval, CE_doubleval, CE_dominant)){
lSetUlong(queue_elem,CE_dominant , DOMINANT_LAYER_QUEUE|DOMINANT_TYPE_FIXED);
lSetDouble(queue_elem,CE_doubleval , dval);
if(value){
lSetString(queue_elem, CE_stringval, value);
}
else{
lSetString(queue_elem,CE_stringval , as_str);
}
}
DRETURN(true);
}
/****** sge_select_queue/get_attribute() ***************************************
* NAME
* get_attribute() -- looks for an attribut, but only for one level (for host, global, or queue)
*
* SYNOPSIS
* static lListElem* get_attribute(const char *attrname, lList *config_attr,
* lList *actual_attr, lList *load_attr, lList *centry_list, lListElem
* *queue, lListElem *rep, u_long32 layer, double lc_factor, dstring *reason)
*
* FUNCTION
* Extracts the attribut specified with 'attrname' and finds the
* more important one, if it is defined multiple times on the same
* level. It only cares about one level.
* If the attribute is a consumable, one can specify a point in time and a duration.
* This will get the caller the min amount of that resource during the time frame.
*
* INPUTS
* const char *attrname - attribute name one is looking for
* lList *config_attr - user defined attributes (CE_Type)
* lList *actual_attr - current usage of consumables (RUE_Type)
* lList *load_attr - load attributes
* lList *centry_list - the system wide attribute configuration
* lListElem *queue - the current queue, or null, if one works on hosts
* u_long32 layer - the current layer
* double lc_factor - the load correction value
* dstring *reason - space for error messages or NULL
* bool zero_utilization - ???
* u_long32 start_time - begin of the time interval, one asks for the resource
* u_long32 duration - the duration the interval
*
* RESULT
* static lListElem* - the element one was looking for or NULL
*
*******************************************************************************/
lListElem* get_attribute(const char *attrname, lList *config_attr, lList *actual_attr, lList *load_attr,
const lList *centry_list, lListElem *queue, u_long32 layer, double lc_factor, dstring *reason,
bool zero_utilization, u_long32 start_time, u_long32 duration)
{
lListElem *actual_el=NULL;
lListElem *load_el=NULL;
lListElem *cplx_el=NULL;
DENTER(BASIS_LAYER, "get_attribute");
/* resource_attr is a complex_entry (CE_Type) */
if (config_attr) {
lListElem *temp = lGetElemStr(config_attr, CE_name, attrname);
if (temp){
cplx_el = lCopyElem(lGetElemStr(centry_list, CE_name, attrname));
if(!cplx_el){
/* error */
DRETURN(NULL);
}
lSetUlong(cplx_el, CE_dominant, layer | DOMINANT_TYPE_FIXED);
lSetUlong(cplx_el, CE_pj_dominant, DOMINANT_TYPE_VALUE); /* default, no value set */
lSetDouble(cplx_el, CE_doubleval, lGetDouble(temp,CE_doubleval) );
lSetString(cplx_el, CE_stringval, lGetString(temp,CE_stringval) );
}
}
if (cplx_el && lGetUlong(cplx_el, CE_consumable) != CONSUMABLE_NO) {
lSetUlong(cplx_el, CE_pj_dominant, layer | DOMINANT_TYPE_CONSUMABLE);
lSetUlong(cplx_el, CE_dominant, DOMINANT_TYPE_VALUE);
/* treat also consumables as fixed attributes when assuming an empty queuing system */
if (sconf_get_qs_state() == QS_STATE_FULL) {
if (actual_attr && (actual_el = lGetElemStr(actual_attr, RUE_name, attrname))){
dstring ds;
char as_str[20];
double utilized = zero_utilization ? 0 : utilization_max(actual_el, start_time, duration, false);
switch (lGetUlong(cplx_el, CE_relop)) {
case CMPLXGE_OP:
case CMPLXGT_OP:
lSetDouble(cplx_el, CE_pj_doubleval, utilized);
break;
case CMPLXEQ_OP:
case CMPLXLT_OP:
case CMPLXLE_OP:
case CMPLXNE_OP:
default:
lSetDouble(cplx_el, CE_pj_doubleval, lGetDouble(cplx_el, CE_doubleval) - utilized);
break;
}
sge_dstring_init(&ds, as_str, sizeof(as_str));
sge_dstring_sprintf(&ds, "%8.3f", (float)lGetDouble(cplx_el, CE_pj_doubleval));
lSetString(cplx_el,CE_pj_stringval, as_str);
} else{
sge_dstring_sprintf(reason, MSG_ATTRIB_ACTUALELEMENTTOATTRIBXMISSING_S, attrname);
lFreeElem(&cplx_el);
DRETURN(NULL);
}
} else{
lSetDouble(cplx_el, CE_pj_doubleval, lGetDouble(cplx_el, CE_doubleval));
lSetString(cplx_el,CE_pj_stringval, lGetString(cplx_el, CE_stringval));
}
}
/** check for a load value */
if (load_attr &&
(load_el = lGetElemStr(load_attr, HL_name, attrname)) &&
(sconf_get_qs_state()==QS_STATE_FULL || lGetBool(load_el, HL_static)) &&
(!is_attr_prior(cplx_el, cplx_el)))
{
lListElem *ep_nproc=NULL;
int nproc=1;
if (!cplx_el){
cplx_el = lCopyElem(lGetElemStr(centry_list, CE_name, attrname));
if (!cplx_el){
/* error */
DRETURN(NULL);
}
lSetUlong(cplx_el, CE_dominant, DOMINANT_TYPE_VALUE);
lSetUlong(cplx_el, CE_pj_dominant, DOMINANT_TYPE_VALUE);
}
if ((ep_nproc = lGetElemStr(load_attr, HL_name, LOAD_ATTR_NUM_PROC))) {
const char *cp = lGetString(ep_nproc, HL_value);
if (cp)
nproc = MAX(1, atoi(lGetString(ep_nproc, HL_value)));
}
{
const char *load_value=NULL;
u_long32 type;
double dval;
load_value = lGetString(load_el, HL_value);
/* are we working on string values? if though, than it is easy */
if ( (type = lGetUlong(cplx_el, CE_valtype)) == TYPE_STR || type == TYPE_CSTR || type == TYPE_HOST || type == TYPE_RESTR) {
lSetString(cplx_el, CE_stringval, load_value);
lSetUlong(cplx_el, CE_dominant, layer | DOMINANT_TYPE_LOAD);
} else { /* working on numerical values */
lListElem *job_load;
char err_str[256];
char sval[100];
u_long32 dom_type = DOMINANT_TYPE_LOAD;
lList *load_adjustments = sconf_get_job_load_adjustments();
job_load=lGetElemStr(load_adjustments, CE_name, attrname);
if (parse_ulong_val(&dval, NULL, type, load_value, NULL, 0)) {
sge_strlcpy(sval, load_value, 100);
/* --------------------------------
look for 'name' in our load_adjustments list
*/
if (job_load) {
const char *s;
double load_correction;
s = lGetString(job_load, CE_stringval);
if (!parse_ulong_val(&load_correction, NULL, type, s, err_str, 255)) {
ERROR((SGE_EVENT, MSG_SCHEDD_LOADADJUSTMENTSVALUEXNOTNUMERIC_S , attrname));
} else if (lc_factor) {
double old_dval;
u_long32 relop;
if (!strncmp(attrname, "np_", 3) && nproc != 1 ) {
DPRINTF(("fillComplexFromHost: dividing lc_factor for \"%s\" with value %f by %d to %f\n",
attrname, lc_factor, nproc, lc_factor / nproc));
lc_factor /= nproc;
}
load_correction *= lc_factor;
/* it depends on relop in complex config whether load_correction is pos/neg */
if ( (relop = lGetUlong(cplx_el, CE_relop)) == CMPLXGE_OP || relop == CMPLXGT_OP){
old_dval = dval;
dval += load_correction;
}
else{
old_dval = dval;
dval -= load_correction;
}
sprintf(sval, "%8.3f", dval);
DPRINTF(("%s: uc: %f c(%f): %f\n", attrname, old_dval, lc_factor, dval));
dom_type = DOMINANT_TYPE_CLOAD;
}
}
/* we can have a user, who wants to override the incomming load value. This is no
problem for consumables, but for fixed values. A custom fixed value is a per
slot value (stored in CE_doubleval) and a load value is a per job value (stored
in CE_pj_doubleval).
This code changes a fixed custom value from a per slot to a per job value!!
*/
if ( !(lGetUlong(cplx_el, CE_dominant) == DOMINANT_TYPE_VALUE) &&
(lGetUlong(cplx_el, CE_pj_dominant) == DOMINANT_TYPE_VALUE)){
lSetDouble(cplx_el, CE_pj_doubleval, lGetDouble(cplx_el, CE_doubleval));
lSetString(cplx_el, CE_pj_stringval, lGetString(cplx_el, CE_stringval));
lSetUlong(cplx_el, CE_dominant, DOMINANT_TYPE_VALUE);
lSetUlong(cplx_el, CE_pj_dominant, layer | DOMINANT_TYPE_FIXED);
}
if (!is_attr_prior2(cplx_el, dval, CE_pj_doubleval, CE_pj_dominant)){
lSetString(cplx_el, CE_pj_stringval, load_value);
lSetUlong(cplx_el, CE_pj_dominant, layer | dom_type);
lSetDouble(cplx_el, CE_pj_doubleval, dval );
}
} /* end numerical load value */
lFreeList(&load_adjustments);
}/* end block */
}
}
/* we are working on queue level, so we have to check for queue resource values */
if (queue){
bool created=false;
if(!cplx_el){
cplx_el = lCopyElem(lGetElemStr(centry_list, CE_name, attrname));
if(!cplx_el){
/* error */
DRETURN(NULL);
}
lSetUlong(cplx_el, CE_dominant, DOMINANT_TYPE_VALUE);
lSetUlong(cplx_el, CE_pj_dominant, DOMINANT_TYPE_VALUE);
created = true;
}
if (!get_queue_resource(cplx_el, queue, attrname) && created) {
lFreeElem(&cplx_el);
}
}
DRETURN(cplx_el);
}
/****** qquota_output/qquota_output() ********************************************
* NAME
* qquota_output() -- qquota output function
*
* SYNOPSIS
* bool qquota_output(void *ctx, lList *host_list, lList *resource_match_list,
* lList *user_list, lList *pe_list, lList *project_list, lList
* *cqueue_list, lList **alpp, report_handler_t* report_handler)
*
* FUNCTION
* print resource quota rule and the limit
*
* INPUTS
* void *ctx - gdi handler
* lList *host_list - selected hosts
* lList *resource_match_list - selected resources
* lList *user_list - selected users
* lList *pe_list - selecte pes
* lList *project_list - selected projects
* lList *cqueue_list - selected cluster queues
* lList **alpp - answer list
* report_handler_t* report_handler - report handler for xml output
*
* RESULT
* bool - true on success
* false on error
*
* NOTES
* MT-NOTE: qquota_output() is MT safe
*
*******************************************************************************/
bool qquota_output(sge_gdi_ctx_class_t *ctx, lList *host_list, lList *resource_match_list, lList *user_list,
lList *pe_list, lList *project_list, lList *cqueue_list, lList **alpp,
report_handler_t* report_handler)
{
lList *rqs_list = NULL;
lList *centry_list = NULL;
lList *userset_list = NULL;
lList *hgroup_list = NULL;
lList *exechost_list = NULL;
lListElem* global_host = NULL;
lListElem* exec_host = NULL;
lList* printed_rules = NULL; /* Hash list of already printed resource quota rules (possible with -u user1,user2,user3...) */
bool ret = true;
int xml_ret = 0;
qquota_filter_t qquota_filter = { "*",
"*",
"*",
"*",
"*" };
dstring rule_name = DSTRING_INIT;
DENTER(TOP_LAYER, "qquota_output");
/* If no user is requested on command line we set the current user as default */
qquota_filter.user = ctx->get_username(ctx);
ret = get_all_lists(ctx, &rqs_list, ¢ry_list, &userset_list, &hgroup_list, &exechost_list, host_list, alpp);
if (ret == true) {
lListElem *rqs = NULL;
printed_rules = lCreateList("rule_hash", ST_Type);
global_host = host_list_locate(exechost_list, SGE_GLOBAL_NAME);
if (report_handler != NULL) {
xml_ret = report_handler->report_started(report_handler, alpp);
if (xml_ret != QQUOTA_SUCCESS) {
ret = false;
goto qquota_output_error;
}
}
for_each(rqs, rqs_list) {
lListElem *rule = NULL;
int rule_count = 1;
if (lGetBool(rqs, RQS_enabled) == false) {
continue;
}
for_each(rule, lGetList(rqs, RQS_rule)) {
lListElem *user_ep = lFirst(user_list);
lListElem *project_ep = lFirst(project_list);
lListElem *pe_ep = lFirst(pe_list);
lListElem *queue_ep = lFirst(cqueue_list);
lListElem *host_ep = lFirst(host_list);
do {
if (user_ep != NULL) {
qquota_filter.user = lGetString(user_ep, ST_name);
}
do {
if (project_ep != NULL) {
qquota_filter.project = lGetString(project_ep, ST_name);
}
do {
if (pe_ep != NULL) {
qquota_filter.pe = lGetString(pe_ep, ST_name);
}
do {
if (queue_ep != NULL) {
qquota_filter.queue = lGetString(queue_ep, ST_name);
}
do {
if (host_ep != NULL) {
qquota_filter.host = lGetString(host_ep, ST_name);
}
if (rqs_is_matching_rule(rule, qquota_filter.user, NULL, qquota_filter.project,
qquota_filter.pe, qquota_filter.host,
qquota_filter.queue, userset_list, hgroup_list)) {
lListElem *limit = NULL;
for_each(limit, lGetList(rule, RQR_limit)) {
const char *limit_name = lGetString(limit, RQRL_name);
lList *rue_list = lGetList(limit, RQRL_usage);
lListElem *raw_centry = centry_list_locate(centry_list, limit_name);
lListElem *rue_elem = NULL;
if (raw_centry == NULL) {
/* undefined centries can be ignored */
DPRINTF(("centry %s not defined -> IGNORING\n", limit_name));
continue;
}
if ((resource_match_list != NULL) &&
((centry_list_locate(resource_match_list, limit_name) == NULL) &&
(centry_list_locate(resource_match_list, lGetString(raw_centry, CE_shortcut)) == NULL))) {
DPRINTF(("centry %s was not requested on CLI -> IGNORING\n", limit_name));
continue;
}
if (lGetString(rule, RQR_name)) {
sge_dstring_sprintf(&rule_name, "%s/%s", lGetString(rqs, RQS_name), lGetString(rule, RQR_name));
} else {
sge_dstring_sprintf(&rule_name, "%s/%d", lGetString(rqs, RQS_name), rule_count);
}
if (lGetUlong(raw_centry, CE_consumable)) {
/* for consumables we need to walk through the utilization and search for matching values */
DPRINTF(("found centry %s - consumable\n", limit_name));
for_each(rue_elem, rue_list) {
u_long32 dominant = 0;
const char *rue_name = lGetString(rue_elem, RUE_name);
char *cp = NULL;
stringT user, project, pe, queue, host;
dstring limit_str = DSTRING_INIT;
dstring value_str = DSTRING_INIT;
qquota_filter_t qf = { NULL, NULL, NULL, NULL, NULL };
/* check user name */
cp = qquota_get_next_filter(user, rue_name);
/* usergroups have the same beginning character @ as host groups */
if (is_hgroup_name(qquota_filter.user)) {
lListElem *ugroup = NULL;
if ((ugroup = userset_list_locate(userset_list, &qquota_filter.user[1])) != NULL) {
if (sge_contained_in_access_list(user, NULL, ugroup, NULL) == 0) {
continue;
}
}
} else {
if ((strcmp(user, "-") != 0) && (strcmp(qquota_filter.user, "*") != 0)
&& (fnmatch(qquota_filter.user, user, 0) != 0)) {
continue;
}
}
/* check project */
cp = qquota_get_next_filter(project, cp);
if ((strcmp(project, "-") != 0) && (strcmp(qquota_filter.project, "*") != 0)
&& (fnmatch(qquota_filter.project, project, 0) != 0)) {
continue;
}
/* check parallel environment */
cp = qquota_get_next_filter(pe, cp);
if ((strcmp(pe, "-") != 0) && (strcmp(qquota_filter.pe, "*") != 0) &&
(fnmatch(qquota_filter.pe, pe, 0) != 0) ) {
continue;
}
/* check cluster queue */
cp = qquota_get_next_filter(queue, cp);
if ((strcmp(queue, "-") != 0) && (strcmp(qquota_filter.queue, "*") != 0) &&
(fnmatch(qquota_filter.queue, queue, 0) != 0)) {
continue;
}
/* check host name */
cp = qquota_get_next_filter(host, cp);
if (is_hgroup_name(qquota_filter.host)) {
lListElem *hgroup = NULL;
if ((hgroup = hgroup_list_locate(hgroup_list, qquota_filter.host)) != NULL) {
lList *host_list = NULL;
hgroup_find_all_references(hgroup, NULL, hgroup_list, &host_list, NULL);
if (host_list == NULL && lGetElemHost(host_list, HR_name, host) == NULL) {
lFreeList(&host_list);
continue;
}
lFreeList(&host_list);
}
} else {
if ((strcmp(host, "-") != 0) && (strcmp(qquota_filter.host, "*") != 0) &&
(fnmatch(qquota_filter.host, host, 0) != 0) ) {
continue;
}
}
if (lGetBool(limit, RQRL_dynamic)) {
exec_host = host_list_locate(exechost_list, host);
sge_dstring_sprintf(&limit_str, "%d", (int)scaled_mixed_load(lGetString(limit, RQRL_value),
global_host, exec_host, centry_list));
} else {
lSetDouble(raw_centry, CE_pj_doubleval, lGetDouble(limit, RQRL_dvalue));
sge_get_dominant_stringval(raw_centry, &dominant, &limit_str);
}
lSetDouble(raw_centry,CE_pj_doubleval, lGetDouble(rue_elem, RUE_utilized_now));
sge_get_dominant_stringval(raw_centry, &dominant, &value_str);
qf.user = user;
qf.project = project;
qf.pe = pe;
qf.queue = queue;
qf.host = host;
ret = qquota_print_out_rule(rule, rule_name, limit_name,
sge_dstring_get_string(&value_str), sge_dstring_get_string(&limit_str),
qf, raw_centry, report_handler, printed_rules, alpp);
sge_dstring_free(&limit_str);
sge_dstring_free(&value_str);
}
} else {
/* static values */
qquota_filter_t qf = { NULL, NULL, NULL, NULL, NULL };
DPRINTF(("found centry %s - static value\n", limit_name));
ret = qquota_print_out_rule(rule, rule_name, limit_name,
NULL, lGetString(limit, RQRL_value),
qf, raw_centry, report_handler, printed_rules, alpp);
}
}
}
} while ((host_ep = lNext(host_ep)));
} while ((queue_ep = lNext(queue_ep)));
} while ((pe_ep = lNext(pe_ep)));
} while ((project_ep = lNext(project_ep)));
