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;
}
static lList *test_create_rqs(void)
{
lList* rqs_list = lCreateList("my_rqs", RQS_Type);
lListElem* rqs;
lList* rule_list;
lListElem* rule;
lListElem* filter;
lListElem* limit;
lList * limit_list;
rqs = lCreateElem(RQS_Type);
lSetString(rqs, RQS_name, "Test_Name1");
lSetBool(rqs, RQS_enabled, true);
rule_list = lCreateList("Rule_List", RQR_Type);
rule = lCreateElem(RQR_Type);
filter = lCreateElem(RQRF_Type);
lSetBool(filter, RQRF_expand, true);
lAddSubStr(filter, ST_name, "rqs_user", RQRF_scope, ST_Type);
lSetObject(rule, RQR_filter_users, filter);
limit_list = lCreateList("limit_list", RQRL_Type);
limit = lCreateElem(RQRL_Type);
lSetString(limit, RQRL_name, "slots");
lSetString(limit, RQRL_value, "2*$num_proc");
lAppendElem(limit_list, limit);
lSetList(rule, RQR_limit, limit_list);
lAppendElem(rule_list, rule);
lSetList(rqs, RQS_rule, rule_list);
lAppendElem(rqs_list, rqs);
return rqs_list;
}
/****** test_category/test_create_pe() *****************************************
* NAME
* test_create_pe() -- adds a pe object to the job
*
* SYNOPSIS
* void test_create_pe(const char *peStr, lListElem *job_elem)
*
* INPUTS
* const char *peStr - string representation of the pe object
* lListElem *job_elem - job object
*
* NOTES
* MT-NOTE: test_create_pe() is MT safe
*
*******************************************************************************/
static void test_create_pe(const char *peStr, lListElem *job_elem)
{
lList *range= NULL;
char *pe_cp = strdup(peStr);
char *iter_dash = NULL;
char *pe_str;
for (pe_str = strtok_r(pe_cp, " ", &iter_dash); pe_str; pe_str= strtok_r(NULL, " ", &iter_dash)) {
lSetString(job_elem, JB_pe, pe_str);
pe_str= strtok_r(NULL, " ", &iter_dash);
range_list_parse_from_string(&range, NULL, pe_str, false, false, INF_ALLOWED);
if (range != NULL) {
lSetList(job_elem, JB_pe_range, range);
}
else {
lSetString(job_elem, JB_pe, NULL);
printf("error generating pe object: %s\n", peStr);
}
}
if (pe_cp != NULL) {
sge_free(&pe_cp);
}
}
void getenv_and_set(lListElem *ep, char *variable)
{
const char *env_value = NULL;
char *new_env_value = NULL;
char *a = NULL;
char *b = NULL;
int i, nchars;
int newline_chars = 0;
env_value = sge_getenv(variable);
if (env_value == NULL) {
lSetString(ep, VA_value, NULL);
return;
}
/*
* Any work to do? Check for any newline
* character.
*/
a = strchr(env_value, '\n');
if (a == NULL) {
/*
* Nothing to do. Just leave it alone.
*/
lSetString(ep, VA_value, env_value);
return;
}
/*
* This is a multi-line environment variable. Allocate
* new string and copy over, but without newline chars.
*/
nchars = strlen(env_value);
a = (char *)env_value;
newline_chars = 0;
for (i = 0; i < nchars; i++) {
if (*a == '\n') {
newline_chars++;
}
a++;
}
new_env_value = sge_malloc(nchars - newline_chars + 1);
a = new_env_value;
b = (char *)env_value;
for (i = 0; i < nchars; i++) {
if (*b != '\n') {
*a = *b;
a++;
}
b++;
}
*a = '\0';
lSetString(ep, VA_value, new_env_value);
sge_free(&new_env_value);
return;
}
lList *buildRequestList(int n)
{
lList *requestlist = NULL;
lListElem *request;
requestlist = lCreateList("requestlist", JobRequestT);
request = lCreateElem(JobRequestT);
lSetString(request, R_name, "ARCH");
lSetString(request, R_operator, "==");
lSetString(request, R_value, "irix");
lAppendElem(requestlist, request);
if (n) {
request = lCreateElem(JobRequestT);
lSetString(request, R_name, "editor");
lSetString(request, R_operator, "==");
lSetString(request, R_value, "vi");
lAppendElem(requestlist, request);
}
request = lCreateElem(JobRequestT);
lSetString(request, R_name, "GROUP");
lSetString(request, R_operator, "==");
lSetString(request, R_value, "graphic");
lAppendElem(requestlist, request);
return requestlist;
}
bool
binding_parse_from_string(lListElem *this_elem, lList **answer_list, dstring *string)
{
bool ret = true;
DENTER(BINDING_LAYER, "binding_parse_from_string");
if (this_elem != NULL && string != NULL) {
int amount = 0;
int stepsize = 0;
int firstsocket = 0;
int firstcore = 0;
binding_type_t type = BINDING_TYPE_NONE;
dstring strategy = DSTRING_INIT;
dstring socketcorelist = DSTRING_INIT;
dstring error = DSTRING_INIT;
if (parse_binding_parameter_string(sge_dstring_get_string(string),
&type, &strategy, &amount, &stepsize, &firstsocket, &firstcore,
&socketcorelist, &error) != true) {
dstring parse_binding_error = DSTRING_INIT;
sge_dstring_append_dstring(&parse_binding_error, &error);
answer_list_add_sprintf(answer_list, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
MSG_PARSE_XOPTIONWRONGARGUMENT_SS, "-binding",
sge_dstring_get_string(&parse_binding_error));
sge_dstring_free(&parse_binding_error);
ret = false;
} else {
lSetString(this_elem, BN_strategy, sge_dstring_get_string(&strategy));
lSetUlong(this_elem, BN_type, type);
lSetUlong(this_elem, BN_parameter_socket_offset, (firstsocket >= 0) ? firstsocket : 0);
lSetUlong(this_elem, BN_parameter_core_offset, (firstcore >= 0) ? firstcore : 0);
lSetUlong(this_elem, BN_parameter_n, (amount >= 0) ? amount : 0);
lSetUlong(this_elem, BN_parameter_striding_step_size, (stepsize >= 0) ? stepsize : 0);
if (strstr(sge_dstring_get_string(&strategy), "explicit") != NULL) {
lSetString(this_elem, BN_parameter_explicit, sge_dstring_get_string(&socketcorelist));
}
}
sge_dstring_free(&strategy);
sge_dstring_free(&socketcorelist);
sge_dstring_free(&error);
}
DRETURN(ret);
}
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);
}
}
/****** execd/loadsensor/sge_ls_set_pid() *************************************
* NAME
* sge_ls_set_pid -- set pid in loadsensor element
*
* SYNOPSIS
* static void sge_ls_set_pid(lListElem *this_ls, pid_t pid)
*
* FUNCTION
* Set the pid entry in a CULL element of the type LS_Type.
*
* INPUTS
* this_ls - pointer to a CULL element of type LS_Type
* pid - pid of the loadsensor process or -1
*
* RESULT
* [this_ls] - LS_pid entry of the CULL element will be modified
******************************************************************************/
static void sge_ls_set_pid(lListElem *this_ls, pid_t pid)
{
char pid_buffer[256];
sprintf(pid_buffer, pid_t_fmt, pid);
lSetString(this_ls, LS_pid, pid_buffer);
}
lList *buildComplexNameListB(void)
{
lList *complexnamelist = NULL;
lListElem *complexname;
complexnamelist = lCreateList("complexnamelistB", ComplexNameT);
complexname = lCreateElem(ComplexNameT);
lSetString(complexname, N_complexname, "default");
lAppendElem(complexnamelist, complexname);
complexname = lCreateElem(ComplexNameT);
lSetString(complexname, N_complexname, "hardware");
lAppendElem(complexnamelist, complexname);
return complexnamelist;
}
/****** sgeobj/var/var_list_set_sharedlib_path() ******************************
* NAME
* var_list_set_sharedlib_path -- set shared lib path
*
* SYNOPSIS
* void var_list_set_sharedlib_path(lList **varl);
*
* FUNCTION
* Sets or replaces the shared lib path in the list of variables.
* The SGE shared lib path is always set to the beginning of the
* resulting shared lib path
* (security, see var_get_sharedlib_path_name())
*
* INPUTS
* lList **varl - list of nment variables
*
* SEE ALSO
* sgeobj/var/var_get_sharedlib_path_name()
* sgeobj/var/var_list_set_string()
* sgeobj/var/var_list_set_int()
* sgeobj/var/var_list_set_sge_u32()
******************************************************************************/
void var_list_set_sharedlib_path(lList **varl)
{
char *sharedlib_path;
char *sge_sharedlib_path;
const char *sge_root = sge_get_root_dir(0, NULL, 0, 1);
const char *sharedlib_path_name = var_get_sharedlib_path_name();
lListElem *sharedlib_elem = NULL;
DENTER(TOP_LAYER, "set_sharedlib_path");
/* this is the SGE sharedlib path */
sge_sharedlib_path = sge_malloc(strlen(sge_root) +
strlen("/lib/") + strlen(sge_get_arch()) + 1);
sprintf(sge_sharedlib_path, "%s/lib/%s", sge_root, sge_get_arch());
/* if already in environment: extend by SGE sharedlib path, else set */
sharedlib_elem = lGetElemStr(*varl, VA_variable, sharedlib_path_name);
if(sharedlib_elem != NULL) {
const char *old_value = lGetString(sharedlib_elem, VA_value);
if(old_value && strlen(old_value) > 0) {
DPRINTF(("sharedlib path %s already set:\n", sharedlib_path_name));
sharedlib_path = sge_malloc(strlen(old_value) + 1 +
strlen(sge_sharedlib_path) + 1);
strcpy(sharedlib_path, sge_sharedlib_path);
strcat(sharedlib_path, ":");
strcat(sharedlib_path, old_value);
lSetString(sharedlib_elem, VA_value, sharedlib_path);
sge_free(&sharedlib_path);
} else {
DPRINTF(("overwriting empty sharedlib path %s\n",
sharedlib_path_name));
lSetString(sharedlib_elem, VA_value, sge_sharedlib_path);
}
} else {
DPRINTF(("creating new sharedlib path %s\n", sharedlib_path_name));
sharedlib_elem = lAddElemStr(varl, VA_variable,
sharedlib_path_name, VA_Type);
lSetString(sharedlib_elem, VA_value, sge_sharedlib_path);
}
sge_free(&sge_sharedlib_path);
DEXIT;
}
/****** test_category/test_create_access() *************************************
* NAME
* test_create_access() -- creates an access list from AccessList
*
* SYNOPSIS
* lList* test_create_access()
*
* RESULT
* lList* - NULL or valid acces list
*
* NOTES
* MT-NOTE: test_create_access() is not MT safe
*
*******************************************************************************/
static lList *test_create_access(void)
{
lList *access_list = NULL;
access_list = lCreateList("access", US_Type);
if (access_list != NULL) {
int i;
for (i = 0; AccessList[i] != NULL; i++) {
char *access_cp = NULL;
char *access_str = NULL;
char *iter_dash = NULL;
access_cp = strdup(AccessList[i]);
for (access_str = strtok_r(access_cp, " ", &iter_dash); access_str; access_str = strtok_r(NULL, " ", &iter_dash)) {
lListElem *acc_elem = NULL;
acc_elem = lCreateElem(US_Type);
if (acc_elem != NULL) {
lList *users = lCreateList("user", UE_Type);
lSetString(acc_elem, US_name, access_str);
lSetList(acc_elem, US_entries, users);
lSetBool(acc_elem, US_consider_with_categories, true);
lAppendElem(access_list, acc_elem);
for (access_str = strtok_r(NULL, " ", &iter_dash); access_str; access_str = strtok_r(NULL, " ", &iter_dash)) {
lListElem *user = lCreateElem(UE_Type);
lSetString(user, UE_name, access_str);
lAppendElem(users, user);
}
}
}
if (access_cp != NULL) {
sge_free(&access_cp);
}
}
}
return access_list;
}
lList *readComplexFile(
char *complexname
) {
FILE *calf; /* complex attribute list file */
char name[MAX_STRINGLENGTH];
char value[MAX_STRINGLENGTH];
char listname[MAX_STRINGLENGTH];
char filename[MAX_STRINGLENGTH];
char *s;
int result;
lList *calp = NULL; /* complex attribute list ptr */
lListElem *calep; /* complex attribute list element pointer */
strcpy(filename, DATA_DIR);
strcat(filename, complexname);
strcat(filename, ".cplx");
if (!(calf = fopen(filename, "r"))) {
printf("readComplexFile(): unable to read from file: %s\n", filename);
exit(-1);
}
while ((result = fscanf(calf, "%s %s", name, value)) != EOF) {
if (result != 2) {
printf("readComplexFile: wrong format in complexfile %s\n",
filename);
exit(-1);
}
if (!calp) {
s = strrchr(filename, '/');
sprintf(listname, "ComplexAttributes_from_%s",
s ? s + 1 : filename);
calp = lCreateList(filename, ComplexAttributeT);
}
calep = lCreateElem(ComplexAttributeT);
lSetString(calep, A_name, name);
lSetString(calep, A_value, value);
lAppendElem(calp, calep);
}
/* lWriteList(calp); */
return calp;
}
lListElem* xml_getHead(const char *name, lList *list, lList *attributes) {
lListElem *xml_head = NULL;
xml_head = lCreateElem(XMLH_Type);
if (xml_head) {
lSetString(xml_head, XMLH_Version, "<?xml version='1.0'?>");
lSetString(xml_head, XMLH_Name, name);
lSetList(xml_head, XMLH_Attribute, attributes);
lSetList(xml_head, XMLH_Element, list);
xml_addAttribute(xml_head, "xmlns:xsd", "http://gridengine.sunsource.net/source/browse/*checkout*/gridengine/source/dist/util/resources/schemas/qstat/qstat.xsd?revision=1.11");
/* we do not support stylesheets yet */
/* xml_addStylesheet(xml_head, "xmlns:xsl", "http://www.w3.org/1999/XSL/Transform", "1.0");*/
}
return xml_head;
}
lList *buildComplexList(void)
{
lList *complexlist = NULL;
lListElem *complex;
/* It is better to test every list for its existence (list != NULL) */
complexlist = lCreateList("complexlist", ComplexT);
complex = lCreateElem(ComplexT);
lSetString(complex, C_name, "default");
lSetList(complex, C_attribute, readComplexFile("default"));
lAppendElem(complexlist, complex);
complex = lCreateElem(ComplexT);
lSetString(complex, C_name, "software");
lSetList(complex, C_attribute, readComplexFile("software"));
lAppendElem(complexlist, complex);
return complexlist;
}
/****** test_category/test_create_request() ************************************
* NAME
* test_create_request() -- creats a request list from the request string
*
* SYNOPSIS
* lList* test_create_request(const char *requestStr, int count)
*
* INPUTS
* const char *requestStr - request string
* int count - how many times the request string should be used
* (multiplyer, needs to between 1 and ...)
*
* RESULT
* lList* - NULL or request list
*
* NOTES
* MT-NOTE: test_create_request() is MT safe
*
*******************************************************************************/
static lList *test_create_request(const char *requestStr, int count)
{
lList *requests = NULL;
char *request_cp = NULL;
char *iter_dash = NULL;
requests = lCreateList("requests", CE_Type);
if (requests != NULL) {
int i;
for (i = 0; i < count; i++) {
char *request_str;
request_cp = strdup(requestStr);
for (request_str = strtok_r(request_cp, " ", &iter_dash); request_str; request_str = strtok_r(NULL, " ", &iter_dash)) {
lListElem *request = NULL;
request = lCreateElem(CE_Type);
if (request != NULL) {
lSetString(request, CE_name, request_str);
lSetString(request, CE_stringval, strtok_r(NULL, " ", &iter_dash));
}
else {
lFreeList(&requests);
goto end;
}
lAppendElem(requests, request);
}
if (request_cp != NULL) {
sge_free(&request_cp);
}
}
}
end:
if (request_cp != NULL) {
sge_free(&request_cp);
}
return requests;
}
/*-------------------------------------------------------------------------*/
static Boolean qmonCalendarGetAsk(
lListElem *calp
) {
String cal_name = NULL;
String year_calendar = NULL;
String week_calendar = NULL;
DENTER(GUI_LAYER, "qmonCalendarGetAsk");
if (!calp) {
DEXIT;
return False;
}
cal_name = XmtInputFieldGetString(cal_name_w);
if (!cal_name || cal_name[0] == '\0') {
qmonMessageShow(cal_ask_layout, True, "Calendar name required !");
DEXIT;
return False;
}
lSetString(calp, CAL_name, cal_name);
year_calendar = XmtInputFieldGetString(cal_year_w);
if (year_calendar && year_calendar[0] != '\0') {
year_calendar = qmon_trim(year_calendar);
lSetString(calp, CAL_year_calendar, year_calendar);
} else {
lSetString(calp, CAL_year_calendar, "NONE");
}
week_calendar = XmtInputFieldGetString(cal_week_w);
if (week_calendar && week_calendar[0] != '\0') {
week_calendar = qmon_trim(week_calendar);
lSetString(calp, CAL_week_calendar, week_calendar);
} else {
lSetString(calp, CAL_week_calendar, "NONE");
}
DEXIT;
return True;
}
/******* execd/loadsensor/sge_ls_create_ls() **********************************
* NAME
* sge_ls_create_ls -- creates a new CULL loadsensor element
*
* SYNOPSIS
* static lListElem* sge_ls_create_ls(const char *qualified_hostname,
* char *name, const char *scriptfile)
*
* FUNCTION
* The function creates a new CULL element of type LS_Type and
* returns a pointer to this object. The loadsensor will be
* started immediately.
* If it cannot be started then, LS_has_to_restart is set to
* true so that it will be attempted to be restarted in the next load interval
*
* INPUTS
* qualified_hostname - qualified host name
* name - pseudo name of the ls
* "extern" for user defined loadsensors
* "intern" for qidle and qloadsensor
* scriptfile - absolute path to the ls scriptfile
*
* RESULT
* new CULL element of type LS_Type will be returned
* and a new loadsensor process will be created by this function
******************************************************************************/
static lListElem *sge_ls_create_ls(const char *qualified_hostname, char *name, const char *scriptfile)
{
lListElem *new_ls = NULL; /* LS_Type */
SGE_STRUCT_STAT st;
DENTER(TOP_LAYER, "sge_ls_create_ls");
if (scriptfile != NULL) {
if (SGE_STAT(scriptfile, &st) != 0) {
if (strcmp(name, "extern") == 0) {
WARNING((SGE_EVENT, MSG_LS_NOMODTIME_SS, scriptfile,
strerror(errno)));
}
DRETURN(NULL);
}
new_ls = lCreateElem(LS_Type);
if (new_ls) {
/* initialize all attributes */
lSetString(new_ls, LS_name, name);
lSetString(new_ls, LS_command, scriptfile);
sge_ls_set_pid(new_ls, -1);
lSetRef(new_ls, LS_in, NULL);
lSetRef(new_ls, LS_out, NULL);
lSetRef(new_ls, LS_err, NULL);
lSetBool(new_ls, LS_has_to_restart, false);
lSetUlong(new_ls, LS_tag, 0);
lSetList(new_ls, LS_incomplete, lCreateList("", LR_Type));
lSetList(new_ls, LS_complete, lCreateList("", LR_Type));
lSetUlong(new_ls, LS_last_mod, st.st_mtime);
/* start loadsensor, if couldn't set the restart flag so that we
* restart it in the next load interval
*/
if (sge_ls_start_ls(qualified_hostname, new_ls) != LS_OK) {
lSetBool(new_ls, LS_has_to_restart, true);
}
}
}
DRETURN(new_ls);
}
/****** 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);
}
/****** 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;
}
lList *buildQueueList(void)
{
lList *queuelist = NULL;
lListElem *element;
queuelist = lCreateList("queuelist", QueueT);
element = lCreateElem(QueueT);
lSetString(element, Q_name, "balin.q");
lSetList(element, Q_complexname, buildComplexNameListA());
lAppendElem(queuelist, element);
element = lCreateElem(QueueT);
lSetString(element, Q_name, "durin.q");
lSetList(element, Q_complexname, buildComplexNameListB());
lAppendElem(queuelist, element);
element = lCreateElem(QueueT);
lSetString(element, Q_name, "gloin.q");
lSetList(element, Q_complexname, buildComplexNameListC());
lAppendElem(queuelist, element);
return queuelist;
}
static int test_normal_utilization(void)
{
/*
* 8-| -------- ----
* |
* 4-| ----
* |
* 0----------------------------------->
* | | | |
* 800 1000
*/
int ret = 0;
static u_long32 qeti_expected_result[] = {
1200,
1100,
1000,
800
};
test_array_t test_array[] = {
{1000, 100, 4},
{1200, 150, 0},
{700, 150, 8},
{0, 0, 0}
};
lListElem *cr = lCreateElem(RUE_Type);
lSetString(cr, RUE_name, "slots");
printf("\n - test simple reservation - \n\n");
printf("adding a 200s now assignment of 8 starting at 800\n");
utilization_add(cr, 800, 200, 8, 100, 1, PE_TAG, "pe_slots", "STARTING", false, false);
printf("adding a 100s now assignment of 4 starting at 1000\n");
utilization_add(cr, 1000, 100, 4, 101, 1, PE_TAG, "pe_slots", "STARTING", false, false);
printf("adding a 100s reservation of 8 starting at 1100\n");
utilization_add(cr, 1100, 100, 8, 102, 1, PE_TAG, "pe_slots", "RESERVING", false, false);
ret += do_utilization_test(cr, test_array);
ret += do_qeti_test(cr, qeti_expected_result);
lFreeElem(&cr);
return ret;
}
/****** sgeobj/var/var_list_set_string() **************************************
* NAME
* var_list_set_string -- add/change an variable
*
* SYNOPSIS
* void var_list_set_string(lList **varl,
* const char *name,
* const char *value);
*
* FUNCTION
* If the variable <name> does not already exist in <varl>,
* it is created and initialized with <value>.
* Otherwise, its value is overwritten with <value>
*
* INPUTS
* lList **varl - VA_Type list
* const char *name - the name of the variable
* const char *value - the (new) value of the variable
*
* SEE ALSO
* sgeobj/var/var_list_set_int()
* sgeobj/var/var_list_set_sge_u32()
* sgeobj/var/var_list_set_sharedlib_path()
******************************************************************************/
void var_list_set_string(lList **varl, const char *name, const char *value)
{
lListElem *elem;
DENTER(TOP_LAYER, "var_list_set_string");
if (varl == NULL || name == NULL || value == NULL) {
DEXIT;
return;
}
elem = lGetElemStr(*varl, VA_variable, name);
if (elem == NULL) {
elem = lAddElemStr(varl, VA_variable, name, VA_Type);
}
lSetString(elem, VA_value, value);
DEXIT;
}
int pack_ack(sge_pack_buffer *pb, u_long32 type, u_long32 id, u_long32 id2, const char *str)
{
int ret;
lListElem *ack = lCreateElem(ACK_Type);
DENTER(TOP_LAYER, "pack_ack");
lSetUlong(ack, ACK_type, type);
lSetUlong(ack, ACK_id, id);
lSetUlong(ack, ACK_id2, id2);
lSetString(ack, ACK_str, str);
ret = cull_pack_elem(pb, ack);
lFreeElem(&ack);
DRETURN(ret);
}
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;
}
/****** spool/spool_create_context() ************************************
* NAME
* spool_create_context() -- create a new spooing context
*
* SYNOPSIS
* lListElem *
* spool_create_context(lList **answer_list, const char *name);
*
* FUNCTION
* Create a new spooling context.
*
* INPUTS
* lList **answer_list - to return error messages
* const char *name - name of the context
*
* RESULT
* lListElem* - the new spooling context
*
* EXAMPLE
* lListElem *context;
*
* context = spool_create_context(answer_list, "my spooling context");
* ...
*
*
* NOTES
* Usually, a service function creating a spooling context
* for a certain storage system will be called, e.g.
* spool_classic_create_context().
*
* SEE ALSO
* spool/--Spooling
* spool/spool_free_context()
* spool/classic/spool_classic_create_context()
*******************************************************************************/
lListElem *
spool_create_context(lList **answer_list, const char *name)
{
lListElem *ep = NULL;
DENTER(TOP_LAYER, "spool_create_context");
PROF_START_MEASUREMENT(SGE_PROF_SPOOLING);
if (name == NULL) {
answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN,
ANSWER_QUALITY_ERROR, MSG_SPOOL_CONTEXTNEEDSNAME);
} else {
ep = lCreateElem(SPC_Type);
lSetString(ep, SPC_name, name);
}
PROF_STOP_MEASUREMENT(SGE_PROF_SPOOLING);
DRETURN(ep);
}
lList *buildJobList(int num)
{
lList *joblist = NULL;
lListElem *job;
int n;
char name[20];
joblist = lCreateList("joblist", JobT);
for (n = 0; n < num; n++) {
sprintf(name, "Job%d", n);
job = lCreateElem(JobT);
lSetUlong(job, J_id, n);
lSetString(job, J_name, name);
lSetList(job, J_hardrequest, buildRequestList(n));
lAppendElem(joblist, job);
}
return joblist;
}
/****** sge_orders/sge_create_orders() *****************************************
* NAME
* sge_create_orders() -- Create a new order-list or add orders to an existing one
*
* SYNOPSIS
* lList* sge_create_orders(lList *or_list, u_long32 type, lListElem *job,
* lListElem *ja_task, lList *granted, bool update_execd)
*
* FUNCTION
* - If the or_list is NULL, a new one will be generated
*
* - in case of a clear_pri order, teh ja_task is improtant. If NULL is put
* in for ja_task, only the pendin tasks of the spedified job are set to NULL.
* If a ja_task is put in, all tasks of the job are set to NULL
*
* INPUTS
* lList *or_list - the order list
* u_long32 type - order type
* lListElem *job - job
* lListElem *ja_task - ja_task ref or NULL(there is only one case, where it can be NULL)
* lList *granted - granted queue list
* bool update_execd - should the execd get new ticket values?
*
* RESULT
* lList* - returns the orderlist
*
* NOTES
* MT-NOTE: sge_create_orders() is MT safe
*
* SEE ALSO
* ???/???
*******************************************************************************/
lList
*sge_create_orders(lList *or_list, u_long32 type, lListElem *job, lListElem *ja_task,
lList *granted , bool update_execd)
{
lList *ql = NULL;
lListElem *gel, *ep, *ep2;
u_long32 qslots;
DENTER(TOP_LAYER, "sge_create_orders");
if (!job) {
lFreeList(&or_list);
DEXIT;
return or_list;
}
/* create orders list if not existent */
if (!or_list) {
or_list = lCreateList("orderlist", OR_Type);
}
/* build sublist of granted */
if (update_execd) {
for_each(gel, granted) {
qslots = lGetUlong(gel, JG_slots);
if (qslots) { /* ignore Qs with slots==0 */
ep2=lCreateElem(OQ_Type);
lSetUlong(ep2, OQ_slots, qslots);
lSetString(ep2, OQ_dest_queue, lGetString(gel, JG_qname));
lSetUlong(ep2, OQ_dest_version, lGetUlong(gel, JG_qversion));
lSetDouble(ep2, OQ_ticket, lGetDouble(gel, JG_ticket));
lSetDouble(ep2, OQ_oticket, lGetDouble(gel, JG_oticket));
lSetDouble(ep2, OQ_fticket, lGetDouble(gel, JG_fticket));
lSetDouble(ep2, OQ_sticket, lGetDouble(gel, JG_sticket));
if (!ql)
ql=lCreateList("orderlist",OQ_Type);
lAppendElem(ql, ep2);
}
}
}
/****** test_category/test_create_queue() **************************************
* NAME
* test_create_queue() -- creates a request queue list from the queue string
*
* SYNOPSIS
* lList* test_create_queue(const char *queueStr, int count)
*
* INPUTS
* const char *queueStr - the queue string used as a bases
* int count - how many times the request string should be used
* (multiplyer, needs to between 1 and ...)
*
* RESULT
* lList* - NULL or valid queue request list
*
* NOTES
* MT-NOTE: test_create_queue() is MT safe
*
*******************************************************************************/
static lList *test_create_queue(const char *queueStr, int count)
{
lList *queues = NULL;
char *queue_cp = NULL;
char *iter_dash = NULL;
queues = lCreateList("queues", QR_Type);
if (queues != NULL) {
int i;
for (i = 0; i < count; i++) {
char *queues_str;
queue_cp = strdup(queueStr);
for (queues_str = strtok_r(queue_cp, " ", &iter_dash); queues_str; queues_str = strtok_r(NULL, " ", &iter_dash)) {
lListElem *queue = NULL;
queue = lCreateElem(QR_Type);
if (queue != NULL) {
lSetString(queue, QR_name, queues_str);
}
else {
lFreeList(&queues);
goto end;
}
lAppendElem(queues, queue);
}
if (queue_cp != NULL) {
sge_free(&queue_cp);
}
}
}
end:
if (queue_cp != NULL) {
sge_free(&queue_cp);
}
return queues;
}
/* ----------------------------------------
add a string value to the load report list lpp
*/
int sge_add_str2load_report(lList **lpp, const char *name, const char *value, const char *host)
{
lListElem *ep = NULL, *search_ep = NULL;
const void *iterator = NULL;
DENTER(BASIS_LAYER, "sge_add_str2load_report");
if (lpp == NULL || name == NULL || value == NULL || host == NULL) {
DRETURN(-1);
}
if (*lpp != NULL) {
search_ep = lGetElemHostFirst(*lpp, LR_host, host, &iterator);
while (search_ep != NULL) {
DPRINTF(("---> %s\n", lGetString(search_ep, LR_name)));
if (strcmp(lGetString(search_ep, LR_name), name) == 0) {
ep = search_ep;
break;
}
search_ep = lGetElemHostNext(*lpp, LR_host, host, &iterator);
}
}
if (ep == NULL) {
DPRINTF(("adding new load variable %s for host %s\n", name, host));
ep = lAddElemStr(lpp, LR_name, name, LR_Type);
lSetHost(ep, LR_host, host);
lSetUlong(ep, LR_global, (u_long32)(strcmp(host, SGE_GLOBAL_NAME) == 0 ? 1 : 0));
lSetUlong(ep, LR_static, sge_is_static_load_value(name));
}
lSetString(ep, LR_value, value);
DPRINTF(("load value %s for host %s: %s\n", name, host, value));
DRETURN(0);
}
/*-------------------------------------------------------------------------*/
static void qmonManopFillList(void)
{
lList *lp, *cl;
lListElem *ep;
DENTER(GUI_LAYER, "qmonManopFillList");
/* manager list */
lp = qmonMirrorList(SGE_UM_LIST);
lPSortList(lp, "%I+", UM_name);
UpdateXmListFromCull(manager_list, XmFONTLIST_DEFAULT_TAG, lp, UM_name);
/* operator list */
lp = qmonMirrorList(SGE_UO_LIST);
lPSortList(lp, "%I+", UO_name);
UpdateXmListFromCull(operator_list, XmFONTLIST_DEFAULT_TAG, lp, UO_name);
/* userset list */
updateUsersetList();
/* user list */
lp = qmonMirrorList(SGE_UU_LIST);
lPSortList(lp, "%I+", UU_name);
/*
** set UU_default_project to NONE
*/
cl = lCopyList("cl", lp);
for_each (ep, cl) {
if (ep && !lGetString(ep, UU_default_project))
lSetString(ep, UU_default_project, "NONE");
}
qmonSetNxN(user_matrix, cl, 3, UU_name, UU_default_project, UU_delete_time);
lFreeList(&cl);
DEXIT;
}
