/****** 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/href/href_list_compare() ***************************************
* NAME
* href_list_compare() -- Finds additional entries in list
*
* SYNOPSIS
* bool
* href_list_compare(const lList *this_list, lList **answer_list,
* const lList *list, lList **add_hosts,
* lList **add_groups, lList **equity_hosts,
* lList **equity_groups)
*
* FUNCTION
* This function will find differences between two hostref lists
* given by 'this_list' and 'list'. Hosts and hostgroups which are
* only in 'this_list' can be found in 'add_hosts' and 'add_groups'.
* References which are contained in both lists can be found in
* 'equity_hosts' and 'equity_groups' after a call to this function.
*
* If the calling function is not interested in one ore more of the
* result lists than NULL should be used as parameter. The calling
* function is responsible to free all result lists.
*
* If the callee is also interested in the references which are
* only part of 'list' than this function can not be used.
* href_list_find_diff() should be used in this case.
*
* INPUTS
* const lList *this_list - HR_Type list to comapre
* lList **answer_list - AN_Type list
* const lList *list - 2nd HR_Type list to be compared
* lList **add_hosts - HR_Type list
* lList **add_groups - HR_Type list
* lList **equity_hosts - HR_Type list
* lList **equity_groups - HR_Type list
*
* RESULT
* bool - error state
* true - Success
* false - Error
*
* SEE ALSO
* sgeobj/href/href_list_find_diff()
*******************************************************************************/
bool
href_list_compare(const lList *this_list, lList **answer_list,
const lList *list, lList **add_hosts,
lList **add_groups, lList **equity_hosts,
lList **equity_groups)
{
bool ret = true;
lListElem *this_elem; /* HR_Type */
DENTER(HOSTREF_LAYER, "href_list_compare");
for_each(this_elem, this_list) {
const char *host_or_group = lGetHost(this_elem, HR_name);
if (!href_list_has_member(list, host_or_group)) {
if (is_hgroup_name(host_or_group)) {
if (add_groups != NULL) {
ret = href_list_add(add_groups, answer_list, host_or_group);
}
} else if (add_hosts != NULL) {
ret = href_list_add(add_hosts, answer_list, host_or_group);
}
} else {
if (is_hgroup_name(host_or_group)) {
if (equity_groups != NULL) {
ret = href_list_add(equity_groups, answer_list, host_or_group);
}
} else if (equity_hosts != NULL) {
ret = href_list_add(equity_hosts, answer_list, host_or_group);
}
}
if (!ret) {
break;
}
}
DRETURN(ret);
}
/****** sge_userset/userset_list_validate_access() *****************************
* NAME
* userset_list_validate_access() -- all user sets names in list must exist
*
* SYNOPSIS
* int userset_list_validate_access(lList *acl_list, int nm, lList **alpp)
*
* FUNCTION
* All the user set names in the acl_list must be defined in the qmaster
* user set lists. The user set is diferentiated from user names by @ sign
*
* INPUTS
* lList *acl_list - the acl list to check
* int nm - field name
* lList **alpp - answer list pointer
*
* RESULT
* int - STATUS_OK if no error, STATUS_EUNKNOWN otherwise
*
* NOTES
* MT-NOTE: userset_list_validate_access() is not MT safe
*
*******************************************************************************/
int userset_list_validate_access(lList *acl_list, int nm, lList **alpp)
{
lListElem *usp;
char *user;
DENTER(TOP_LAYER, "userset_list_validate_access");
for_each (usp, acl_list) {
user = (char *) lGetString(usp, nm);
if (is_hgroup_name(user) == true){
user++; /* jump ower the @ sign */
if (!lGetElemStr(*object_type_get_master_list(SGE_TYPE_USERSET), US_name, user)) {
ERROR((SGE_EVENT, MSG_CQUEUE_UNKNOWNUSERSET_S, user ? user : "******"));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
}
}
/****** uti/hostname/sge_hostcpy() ********************************************
* NAME
* sge_hostcpy() -- strcpy() for hostnames.
*
* SYNOPSIS
* void sge_hostcpy(char *dst, const char *raw)
*
* FUNCTION
* strcpy() for hostnames. Honours some configuration values:
* - Domain name may be ignored
* - Domain name may be replaced by a 'default domain'
* - Hostnames may be used as they are.
* - straight strcpy() for hostgroup names
*
* INPUTS
* char *dst - possibly modified hostname
* const char *raw - hostname
*
* SEE ALSO
* uti/hostname/sge_hostcmp()
* uti/hostname/sge_hostmatch()
*
* NOTES:
* MT-NOTE: sge_hostcpy() is MT safe
******************************************************************************/
void sge_hostcpy(char *dst, const char *raw)
{
bool ignore_fqdn = bootstrap_get_ignore_fqdn();
bool is_hgrp = is_hgroup_name(raw);
const char *default_domain;
if (dst == NULL || raw == NULL) {
return;
}
if (is_hgrp) {
/* hostgroup name: not in FQDN format, copy the entire string*/
sge_strlcpy(dst, raw, CL_MAXHOSTLEN);
return;
}
if (ignore_fqdn) {
char *s = NULL;
/* standard: simply ignore FQDN */
sge_strlcpy(dst, raw, CL_MAXHOSTLEN);
if ((s = strchr(dst, '.'))) {
*s = '\0';
}
return;
}
if ((default_domain = bootstrap_get_default_domain()) != NULL &&
SGE_STRCASECMP(default_domain, "none") != 0) {
/* exotic: honour FQDN but use default_domain */
if (!strchr(raw, '.')) {
snprintf(dst, CL_MAXHOSTLEN, "%s.%s", raw, default_domain);
} else {
sge_strlcpy(dst, raw, CL_MAXHOSTLEN);
}
} else {
/* hardcore: honour FQDN, don't use default_domain */
sge_strlcpy(dst, raw, CL_MAXHOSTLEN);
}
return;
}
bool sge_parse_qrsub(sge_gdi_ctx_class_t *ctx, lList *pcmdline, lList **alpp, lListElem **ar)
{
lListElem *ep = NULL, *next_ep = NULL;
lList *lp = NULL;
DENTER(TOP_LAYER, "sge_parse_qrsub");
/* -help print this help */
if ((ep = lGetElemStr(pcmdline, SPA_switch, "-help"))) {
lRemoveElem(pcmdline, &ep);
sge_usage(QRSUB, stdout);
DEXIT;
SGE_EXIT((void **)&ctx, 0);
}
/* -a date_time start time in [[CC]YY]MMDDhhmm[.SS] SGE_ULONG */
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-a"))) {
lSetUlong(*ar, AR_start_time, lGetUlong(ep, SPA_argval_lUlongT));
lRemoveElem(pcmdline, &ep);
}
/* -e date_time end time in [[CC]YY]MMDDhhmm[.SS] SGE_ULONG*/
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-e"))) {
lSetUlong(*ar, AR_end_time, lGetUlong(ep, SPA_argval_lUlongT));
lRemoveElem(pcmdline, &ep);
}
/* -d time duration in TIME format SGE_ULONG */
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-d"))) {
lSetUlong(*ar, AR_duration, lGetUlong(ep, SPA_argval_lUlongT));
lRemoveElem(pcmdline, &ep);
}
/* -w e/v validate availability of AR request, default e SGE_ULONG */
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-w"))) {
lSetUlong(*ar, AR_verify, lGetInt(ep, SPA_argval_lIntT));
lRemoveElem(pcmdline, &ep);
}
/* -N name AR name SGE_STRING */
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-N"))) {
lSetString(*ar, AR_name, lGetString(ep, SPA_argval_lStringT));
lRemoveElem(pcmdline, &ep);
}
/* -A account_string AR name in accounting record SGE_STRING */
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-A"))) {
lSetString(*ar, AR_account, lGetString(ep, SPA_argval_lStringT));
lRemoveElem(pcmdline, &ep);
}
/* -l resource_list request the given resources SGE_LIST */
parse_list_simple(pcmdline, "-l", *ar, AR_resource_list, 0, 0, FLG_LIST_APPEND);
centry_list_remove_duplicates(lGetList(*ar, AR_resource_list));
/* -u wc_user access list SGE_LIST */
/* -u ! wc_user TBD: Think about eval_expression support in compare allowed and excluded lists */
parse_list_simple(pcmdline, "-u", *ar, AR_acl_list, ARA_name, 0, FLG_LIST_MERGE);
/* -u ! list separation */
lp = lGetList(*ar, AR_acl_list);
next_ep = lFirst(lp);
while ((ep = next_ep)) {
bool is_xacl = false;
const char *name = lGetString(ep, ARA_name);
next_ep = lNext(ep);
if (name[0] == '!') { /* move this element to xacl_list */
is_xacl = true;
name++;
}
if (!is_hgroup_name(name)) {
struct passwd *pw;
struct passwd pw_struct;
char *buffer;
int size;
stringT group;
size = get_pw_buffer_size();
buffer = sge_malloc(size);
pw = sge_getpwnam_r(name, &pw_struct, buffer, size);
if (pw == NULL) {
answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_USER_XISNOKNOWNUSER_S, name);
FREE(buffer);
DRETURN(false);
}
sge_gid2group(pw->pw_gid, group, MAX_STRING_SIZE, MAX_NIS_RETRIES);
lSetString(ep, ARA_group, group);
FREE(buffer);
}
if (is_xacl) {
lListElem *new_ep = lAddSubStr(*ar, ARA_name, name, AR_xacl_list, ARA_Type);
lSetString(new_ep, ARA_group, lGetString(ep, ARA_group));
lRemoveElem(lp, &ep);
}
}
/* -q wc_queue_list reserve in queue(s) SGE_LIST */
parse_list_simple(pcmdline, "-q", *ar, AR_queue_list, 0, 0, FLG_LIST_APPEND);
/* -pe pe_name slot_range reserve slot range for parallel jobs */
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-pe"))) {
lSetString(*ar, AR_pe, lGetString(ep, SPA_argval_lStringT)); /* SGE_STRING, */
lSwapList(*ar, AR_pe_range, ep, SPA_argval_lListT); /* SGE_LIST */
lRemoveElem(pcmdline, &ep);
}
/* AR_master_queue_list -masterq wc_queue_list, SGE_LIST bind master task to queue(s) */
parse_list_simple(pcmdline, "-masterq", *ar, AR_master_queue_list, 0, 0, FLG_LIST_APPEND);
/* -ckpt ckpt-name reserve in queue with ckpt method SGE_STRING */
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-ckpt"))) {
lSetString(*ar, AR_checkpoint_name, lGetString(ep, SPA_argval_lStringT));
lRemoveElem(pcmdline, &ep);
}
/* -m b/e/a/n define mail notification events SGE_ULONG */
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-m"))) {
u_long32 ul;
u_long32 old_mail_opts;
ul = lGetInt(ep, SPA_argval_lIntT);
if ((ul & NO_MAIL)) {
lSetUlong(*ar, AR_mail_options, 0);
} else {
old_mail_opts = lGetUlong(*ar, AR_mail_options);
lSetUlong(*ar, AR_mail_options, ul | old_mail_opts);
}
lRemoveElem(pcmdline, &ep);
}
/* -M user[@host],... notify these e-mail addresses SGE_LIST*/
parse_list_simple(pcmdline, "-M", *ar, AR_mail_list, MR_host, MR_user, FLG_LIST_MERGE);
/* -he yes/no hard error handling SGE_ULONG */
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-he"))) {
lSetUlong(*ar, AR_error_handling, lGetUlong(ep, SPA_argval_lUlongT));
lRemoveElem(pcmdline, &ep);
}
/* -now reserve in queues with qtype interactive SGE_ULONG */
while ((ep = lGetElemStr(pcmdline, SPA_switch, "-now"))) {
u_long32 ar_now = lGetUlong(*ar, AR_type);
if(lGetInt(ep, SPA_argval_lIntT)) {
JOB_TYPE_SET_IMMEDIATE(ar_now);
} else {
JOB_TYPE_CLEAR_IMMEDIATE(ar_now);
}
lSetUlong(*ar, AR_type, ar_now);
lRemoveElem(pcmdline, &ep);
}
/* Remove the script elements. They are not stored in the ar structure */
if ((ep = lGetElemStr(pcmdline, SPA_switch, STR_PSEUDO_SCRIPT))) {
lRemoveElem(pcmdline, &ep);
}
if ((ep = lGetElemStr(pcmdline, SPA_switch, STR_PSEUDO_SCRIPTLEN))) {
lRemoveElem(pcmdline, &ep);
}
if ((ep = lGetElemStr(pcmdline, SPA_switch, STR_PSEUDO_SCRIPTPTR))) {
lRemoveElem(pcmdline, &ep);
}
ep = lFirst(pcmdline);
if(ep) {
const char *option = lGetString(ep,SPA_switch);
/* as jobarg are stored no switch values, need to be filtered */
if(sge_strnullcmp(option, "jobarg") != 0) {
answer_list_add_sprintf(alpp, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
MSG_PARSE_INVALIDOPTIONARGUMENTX_S,
lGetString(ep,SPA_switch));
} else {
answer_list_add_sprintf(alpp, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
MSG_PARSE_INVALIDOPTIONARGUMENT);
}
DRETURN(false);
}
if (lGetUlong(*ar, AR_start_time) == 0 && lGetUlong(*ar, AR_end_time) != 0 && lGetUlong(*ar, AR_duration) != 0) {
lSetUlong(*ar, AR_start_time, lGetUlong(*ar, AR_end_time) - lGetUlong(*ar, AR_duration));
} else if (lGetUlong(*ar, AR_start_time) != 0 && lGetUlong(*ar, AR_end_time) == 0 && lGetUlong(*ar, AR_duration) != 0) {
lSetUlong(*ar, AR_end_time, duration_add_offset(lGetUlong(*ar, AR_start_time), lGetUlong(*ar, AR_duration)));
lSetUlong(*ar, AR_duration, lGetUlong(*ar, AR_end_time) - lGetUlong(*ar, AR_start_time));
} else if (lGetUlong(*ar, AR_start_time) != 0 && lGetUlong(*ar, AR_end_time) != 0 && lGetUlong(*ar, AR_duration) == 0) {
lSetUlong(*ar, AR_duration, lGetUlong(*ar, AR_end_time) - lGetUlong(*ar, AR_start_time));
}
DRETURN(true);
}
/****** 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)));
