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;
}
/****** 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;
}
}
}
static sge_callback_result
analyze_jatask_event(sge_evc_class_t *evc, object_description *object_base,sge_object_type type,
sge_event_action action, lListElem *event, void *clientdata)
{
char buffer[1024];
dstring buffer_wrapper;
sge_dstring_init(&buffer_wrapper, buffer, sizeof(buffer));
if (lGetPosViaElem(event, ET_type, SGE_NO_ABORT) >= 0) {
u_long32 type = lGetUlong(event, ET_type);
if (type == sgeE_JATASK_MOD) {
lList *jat = lGetList(event,ET_new_version);
lListElem *ep = lFirst(jat);
u_long job_status = lGetUlong(ep, JAT_status);
int task_running = (job_status==JRUNNING || job_status==JTRANSFERING);
if (task_running) {
}
}
if (type == sgeE_JOB_FINAL_USAGE) {
}
if (type == sgeE_JOB_ADD) {
/* lList *jat = lGetList(event,ET_new_version);
u_long job_id = lGetUlong(event, ET_intkey);
u_long task_id = lGetUlong(event, ET_intkey2);
lListElem *ep = lFirst(jat); */
}
if (type == sgeE_JOB_DEL) {
qevent_trigger_scripts(QEVENT_JB_END, qevent_get_option_struct(), event);
}
if (type == sgeE_JATASK_DEL) {
qevent_trigger_scripts(QEVENT_JB_TASK_END,qevent_get_option_struct() , event);
}
}
/* create a callback error to test error handling */
if(type == SGE_TYPE_GLOBAL_CONFIG) {
return SGE_EMA_FAILURE;
}
return SGE_EMA_OK;
}
/****** cull/tree/lGetNumberOfNodes() *****************************************
* NAME
* lGetNumberOfNodes() -- Number of elements and subelements
*
* SYNOPSIS
* int lGetNumberOfNodes(const lListElem *ep, const lList *lp, int nm)
*
* FUNCTION
* Returns the number of elements and subelements in the sublist 'nm'
* of the element 'ep' (lp = NULL) or returns the sum of all elements
* and subelements within the list 'lp' (ep = NULL)
*
* INPUTS
* const lListElem *ep - element
* const lList *lp - list
* int nm - field name id within element
*
* RESULT
* int - number of elements
*******************************************************************************/
int lGetNumberOfNodes(const lListElem *ep, const lList *lp, int nm)
{
int n = 0;
DENTER(CULL_LAYER, "lGetNumberOfNodes");
if (ep) {
int pos;
n = 1;
if ((pos = lGetPosViaElem(ep, nm, SGE_NO_ABORT)) >= 0 && mt_get_type(ep->descr[pos].mt) == lListT) {
if ((lp = lGetPosList(ep, pos)))
n += lGetNumberOfNodes(NULL, lp, nm);
}
DEXIT;
return n;
} else {
for_each(ep, lp) {
n += lGetNumberOfNodes(ep, NULL, nm);
}
DEXIT;
return n;
}
static sge_callback_result
print_jatask_event(sge_evc_class_t *evc, object_description *object_base, sge_object_type type,
sge_event_action action, lListElem *event, void *clientdata)
{
char buffer[1024];
dstring buffer_wrapper;
DENTER(TOP_LAYER, "print_jatask_event");
sge_dstring_init(&buffer_wrapper, buffer, sizeof(buffer));
DPRINTF(("%s\n", event_text(event, &buffer_wrapper)));
if (lGetPosViaElem(event, ET_type, SGE_NO_ABORT) >= 0) {
u_long32 type = lGetUlong(event, ET_type);
u_long32 timestamp = lGetUlong(event, ET_timestamp);
if (type == sgeE_JATASK_MOD) {
lList *jat = lGetList(event,ET_new_version);
u_long job_id = lGetUlong(event, ET_intkey);
u_long task_id = lGetUlong(event, ET_intkey2);
lListElem *ep = lFirst(jat);
u_long job_status = lGetUlong(ep, JAT_status);
int task_running = (job_status==JRUNNING || job_status==JTRANSFERING);
if (task_running) {
fprintf(stdout,"JOB_START (%ld.%ld:ECL_TIME="sge_U32CFormat")\n", job_id ,task_id,sge_u32c(timestamp));
fflush(stdout);
Global_jobs_running++;
}
}
if (type == sgeE_JOB_FINAL_USAGE) {
/* lList *jat = lGetList(event,ET_new_version); */
u_long job_id = lGetUlong(event, ET_intkey);
u_long task_id = lGetUlong(event, ET_intkey2);
/* lWriteElemTo(event, stdout); */
fprintf(stdout,"JOB_FINISH (%ld.%ld:ECL_TIME="sge_U32CFormat")\n", job_id, task_id,sge_u32c(timestamp));
Global_jobs_running--;
fflush(stdout);
}
if (type == sgeE_JOB_ADD) {
lList *jat = lGetList(event,ET_new_version);
u_long job_id = lGetUlong(event, ET_intkey);
u_long task_id = lGetUlong(event, ET_intkey2);
lListElem *ep = lFirst(jat);
const char* job_project = lGetString(ep, JB_project);
if (job_project == NULL) {
job_project = "NONE";
}
fprintf(stdout,"JOB_ADD (%ld.%ld:ECL_TIME="sge_U32CFormat":project=%s)\n", job_id, task_id, sge_u32c(timestamp),job_project);
Global_jobs_registered++;
fflush(stdout);
}
if (type == sgeE_JOB_DEL) {
u_long job_id = lGetUlong(event, ET_intkey);
u_long task_id = lGetUlong(event, ET_intkey2);
fprintf(stdout,"JOB_DEL (%ld.%ld:ECL_TIME="sge_U32CFormat")\n", job_id, task_id,sge_u32c(timestamp));
Global_jobs_registered--;
fflush(stdout);
}
}
/* create a callback error to test error handling */
if(type == SGE_TYPE_GLOBAL_CONFIG) {
DEXIT;
return SGE_EMA_FAILURE;
}
DEXIT;
return SGE_EMA_OK;
}
/* ------------------------------------------------------------
sge_add_manop() - adds an manop list to the global manager/operator
list
if the invoking process is the qmaster
the added manop list is spooled in the MANAGER_FILE/OPERATOR_FILE
*/
int sge_add_manop(
sge_gdi_ctx_class_t *ctx,
lListElem *ep,
lList **alpp,
char *ruser,
char *rhost,
u_long32 target /* may be SGE_UM_LIST or SGE_UO_LIST */
) {
const char *manop_name;
const char *object_name;
lList **lpp = NULL;
lListElem *added;
int pos;
int key;
lDescr *descr = NULL;
ev_event eve = sgeE_EVENTSIZE;
DENTER(TOP_LAYER, "sge_add_manop");
if ( !ep || !ruser || !rhost ) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_NULLPTRPASSED_S, SGE_FUNC));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DEXIT;
return 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;
descr = UM_Type;
eve = sgeE_MANAGER_ADD;
break;
case SGE_UO_LIST:
lpp = object_type_get_master_list(SGE_TYPE_OPERATOR);
object_name = MSG_OBJ_OPERATOR;
key = UO_name;
descr = UO_Type;
eve = sgeE_OPERATOR_ADD;
break;
default :
DPRINTF(("unknown target passed to %s\n", SGE_FUNC));
DEXIT;
return STATUS_EUNKNOWN;
}
/* ep is no acl 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);
DEXIT;
return STATUS_EUNKNOWN;
}
manop_name = lGetPosString(ep, pos);
if (!manop_name) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_NULLPTRPASSED_S, SGE_FUNC));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DEXIT;
return STATUS_EUNKNOWN;
}
if (lGetElemStr(*lpp, key, manop_name)) {
ERROR((SGE_EVENT, MSG_SGETEXT_ALREADYEXISTS_SS, object_name, manop_name));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DEXIT;
return STATUS_EEXIST;
}
/* update in interal lists */
added = lAddElemStr(lpp, key, manop_name, descr);
/* update on file */
if(!sge_event_spool(ctx, alpp, 0, eve,
0, 0, manop_name, NULL, NULL,
added, 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);
/* remove element from list */
lRemoveElem(*lpp, &added);
DEXIT;
return STATUS_EDISK;
}
INFO((SGE_EVENT, MSG_SGETEXT_ADDEDTOLIST_SSSS,
ruser, rhost, manop_name, object_name));
answer_list_add(alpp, SGE_EVENT, STATUS_OK, ANSWER_QUALITY_INFO);
DEXIT;
return STATUS_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);
}
/****** 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);
}
}
}
/****** qmaster/ckpt/sge_del_ckpt() *******************************************
*
* NAME
* sge_del_ckpt -- delete ckpt object in Master_Ckpt_List
*
* SYNOPSIS
* int sge_del_ckpt(lListElem *ep, lList **alpp, char *ruser, char *rhost);
*
* FUNCTION
* This function will be called from the framework which will
* add/modify/delete generic gdi objects.
* The purpose of this function is it to delete ckpt objects.
*
*
* INPUTS
* ep - element which should be deleted
* alpp - reference to an answer list.
* ruser - username of person who invoked this gdi request
* rhost - hostname of the host where someone initiated an gdi call
*
* RESULT
* [alpp] - error messages will be added to this list
* 0 - success
* STATUS_EUNKNOWN - an error occured
******************************************************************************/
int sge_del_ckpt(sge_gdi_ctx_class_t *ctx, lListElem *ep, lList **alpp, char *ruser, char *rhost)
{
lListElem *found;
int pos;
const char *ckpt_name;
lList **lpp = object_type_get_master_list(SGE_TYPE_CKPT);
DENTER(TOP_LAYER, "sge_del_ckpt");
if ( !ep || !ruser || !rhost ) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_NULLPTRPASSED_S, SGE_FUNC));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DEXIT;
return STATUS_EUNKNOWN;
}
/* ep is no ckpt element, if ep has no CK_name */
if ((pos = lGetPosViaElem(ep, CK_name, SGE_NO_ABORT)) < 0) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_MISSINGCULLFIELD_SS,
lNm2Str(CK_name), SGE_FUNC));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DEXIT;
return STATUS_EUNKNOWN;
}
ckpt_name = lGetPosString(ep, pos);
if (!ckpt_name) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_NULLPTRPASSED_S, SGE_FUNC));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DEXIT;
return STATUS_EUNKNOWN;
}
found = ckpt_list_locate(*lpp, ckpt_name);
if (!found) {
ERROR((SGE_EVENT, MSG_SGETEXT_DOESNOTEXIST_SS, MSG_OBJ_CKPT, ckpt_name));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DEXIT;
return STATUS_EEXIST;
}
/*
* Try to find references in other objects
*/
{
lList *local_answer_list = NULL;
if (ckpt_is_referenced(found, &local_answer_list, *(object_type_get_master_list(SGE_TYPE_JOB)),
*(object_type_get_master_list(SGE_TYPE_CQUEUE)))) {
lListElem *answer = lFirst(local_answer_list);
ERROR((SGE_EVENT, "denied: %s", lGetString(answer, AN_text)));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN,
ANSWER_QUALITY_ERROR);
lFreeList(&local_answer_list);
DEXIT;
return STATUS_EUNKNOWN;
}
}
/* remove ckpt file 1st */
if (!sge_event_spool(ctx, alpp, 0, sgeE_CKPT_DEL, 0, 0, ckpt_name, NULL, NULL,
NULL, NULL, NULL, true, true)) {
ERROR((SGE_EVENT, MSG_CANTSPOOL_SS, MSG_OBJ_CKPT, ckpt_name));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DEXIT;
return STATUS_EDISK;
}
/* now we can remove the element */
lRemoveElem(*lpp, &found);
INFO((SGE_EVENT, MSG_SGETEXT_REMOVEDFROMLIST_SSSS,
ruser, rhost, ckpt_name, MSG_OBJ_CKPT));
answer_list_add(alpp, SGE_EVENT, STATUS_OK, ANSWER_QUALITY_INFO);
DEXIT;
return STATUS_OK;
}
/****** qmaster/ckpt/ckpt_mod() ***********************************************
* NAME
* ckpt_mod -- add/modify ckpt object in Master_Ckpt_List
*
* SYNOPSIS
* int ckpt_mod (lList **alpp, lListElem *new_ckpt, lListElem *ckpt,
* int add, char *ruser, char *rhost, gdi_object_t *object,
* int sub_command);
*
* FUNCTION
* This function will be called from the framework which will
* add/modify/delete generic gdi objects.
* The purpose of this function is it to add new ckpt
* objects or modify existing checkpointing interfaces.
*
*
* INPUTS
* alpp - reference to an answer list.
* new_ckpt - if a new ckpt object will be created by this
* function, than new_ckpt is new uninitialized
* CULL object
* if this function was called due to a modify request
* than new_ckpt will contain the old data
* (see add parameter)
* ckpt - a reduced ckpt object which contains all
* necessary information to create a new object
* or modify parts of an existing one
* add - 1 if a new element should be added to the master list
* 0 to modify an existing object
* ruser - username of person who invoked this gdi request
* rhost - hostname of the host where someone initiated an gdi call
* object - structure of the gdi framework which contains
* additional information to perform the request
* (function pointers, names, CULL-types)
* 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
*
* RESULT
* [alpp] - error messages will be added to this list
* 0 - success
* STATUS_EUNKNOWN - an error occured
******************************************************************************/
int ckpt_mod(sge_gdi_ctx_class_t *ctx,
lList **alpp, lListElem *new_ckpt, lListElem *ckpt, int add,
const char *ruser, const char *rhost, gdi_object_t *object,
int sub_command, monitoring_t *monitor)
{
const char *ckpt_name;
DENTER(TOP_LAYER, "ckpt_mod");
/* ---- CK_name */
if (lGetPosViaElem(ckpt, CK_name, SGE_NO_ABORT) >= 0) {
if (add) {
if (attr_mod_str(alpp, ckpt, new_ckpt, CK_name, SGE_ATTR_CKPT_NAME)) {
goto ERROR;
}
}
ckpt_name = lGetString(new_ckpt, CK_name);
if (add && verify_str_key(
alpp, ckpt_name, MAX_VERIFY_STRING, SGE_ATTR_CKPT_NAME, KEY_TABLE) != STATUS_OK) {
DEXIT;
return STATUS_EUNKNOWN;
}
} else {
ERROR((SGE_EVENT, MSG_SGETEXT_MISSINGCULLFIELD_SS,
lNm2Str(CK_name), SGE_FUNC));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
goto ERROR;
}
/* ---- CK_interface */
attr_mod_str(alpp, ckpt, new_ckpt, CK_interface, SGE_ATTR_INTERFACE);
/* ---- CK_ckpt_command */
attr_mod_str(alpp, ckpt, new_ckpt, CK_ckpt_command, SGE_ATTR_CKPT_COMMAND);
/* ---- CK_migr_command */
attr_mod_str(alpp, ckpt, new_ckpt, CK_migr_command, SGE_ATTR_MIGR_COMMAND);
/* ---- CK_rest_command */
attr_mod_str(alpp, ckpt, new_ckpt, CK_rest_command,
SGE_ATTR_RESTART_COMMAND);
/* ---- CK_ckpt_dir */
attr_mod_str(alpp, ckpt, new_ckpt, CK_ckpt_dir, SGE_ATTR_CKPT_DIR);
/* ---- CK_when */
if (lGetPosViaElem(ckpt, CK_when, SGE_NO_ABORT) >= 0) {
int new_flags, flags;
new_flags = sge_parse_checkpoint_attr(lGetString(new_ckpt, CK_when));
flags = sge_parse_checkpoint_attr(lGetString(ckpt, CK_when));
if (SGE_GDI_IS_SUBCOMMAND_SET(sub_command, SGE_GDI_APPEND)
|| SGE_GDI_IS_SUBCOMMAND_SET(sub_command, SGE_GDI_CHANGE)) {
new_flags |= flags;
} else if (SGE_GDI_IS_SUBCOMMAND_SET(sub_command, SGE_GDI_REMOVE)) {
new_flags &= (~flags);
} else {
new_flags = flags;
}
if (is_checkpoint_when_valid(new_flags)) {
lSetString(new_ckpt, CK_when, get_checkpoint_when(new_flags));
} else {
ERROR((SGE_EVENT, MSG_CKPT_INVALIDWHENATTRIBUTE_S, ckpt_name));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
goto ERROR;
}
}
/* ---- CK_signal */
attr_mod_str(alpp, ckpt, new_ckpt, CK_signal, SGE_ATTR_SIGNAL);
/* ---- CK_clean_command */
attr_mod_str(alpp, ckpt, new_ckpt, CK_clean_command, SGE_ATTR_CLEAN_COMMAND);
/* ---- CK_job_pid */
attr_mod_ulong(ckpt, new_ckpt, CK_job_pid, "job_pid");
/* validate ckpt data */
if (ckpt_validate(new_ckpt, alpp) != STATUS_OK) {
goto ERROR;
}
DEXIT;
return 0;
ERROR:
DEXIT;
return STATUS_EUNKNOWN;
}
/****** 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;
}
static bool
hgroup_mod_hostlist(lListElem *hgroup, lList **answer_list,
lListElem *reduced_elem, int sub_command,
lList **add_hosts, lList **rem_hosts,
lList **occupant_groups)
{
bool ret = true;
DENTER(TOP_LAYER, "hgroup_mod_hostlist");
if (hgroup != NULL && reduced_elem != NULL) {
int pos = lGetPosViaElem(reduced_elem, HGRP_host_list, SGE_NO_ABORT);
if (pos >= 0) {
lList *list = lGetPosList(reduced_elem, pos);
lList *old_href_list = lCopyList("", lGetList(hgroup, HGRP_host_list));
lList *master_list = *(hgroup_list_get_master_list());
lList *href_list = NULL;
lList *add_groups = NULL;
lList *rem_groups = NULL;
if (ret) {
ret &= href_list_resolve_hostnames(list, answer_list, true);
}
if (ret) {
attr_mod_sub_list(answer_list, hgroup, HGRP_host_list, HR_name,
reduced_elem, sub_command, SGE_ATTR_HOSTLIST,
SGE_OBJ_HGROUP, 0);
href_list = lGetList(hgroup, HGRP_host_list);
}
if (ret) {
ret &= href_list_find_diff(href_list, answer_list, old_href_list,
add_hosts, rem_hosts, &add_groups,
&rem_groups);
}
if (ret && add_groups != NULL) {
ret &= hgroup_list_exists(master_list, answer_list, add_groups);
}
if (ret) {
ret &= href_list_find_effective_diff(answer_list, add_groups,
rem_groups, master_list,
add_hosts, rem_hosts);
}
if (ret) {
ret &= href_list_resolve_hostnames(*add_hosts, answer_list, false);
}
/*
* Try to find cycles in the definition
*/
if (ret) {
ret &= hgroup_find_all_referencees(hgroup, answer_list,
master_list, occupant_groups);
ret &= href_list_add(occupant_groups, answer_list,
lGetHost(hgroup, HGRP_name));
if (ret) {
if (*occupant_groups != NULL && add_groups != NULL) {
lListElem *add_group = NULL;
for_each(add_group, add_groups) {
const char *name = lGetHost(add_group, HR_name);
if (href_list_has_member(*occupant_groups, name)) {
break;
}
}
if (add_group == NULL) {
/*
* No cycle found => success
*/
;
} else {
SGE_ADD_MSG_ID(sprintf(SGE_EVENT, MSG_HGROUP_CYCLEINDEF_SS,
lGetHost(add_group, HR_name),
lGetHost(hgroup, HGRP_name)));
answer_list_add(answer_list, SGE_EVENT, STATUS_ESYNTAX,
ANSWER_QUALITY_ERROR);
ret = false;
}
}
}
}
/****** sge_order/sge_create_cull_order_pos() **********************************
* NAME
* sge_create_cull_order_pos() -- generates a cull order position struct
*
* SYNOPSIS
* void sge_create_cull_order_pos(order_pos_t **cull_order_pos, lListElem
* *jep, lListElem *jatp, lListElem *joker, lListElem *joker_task)
*
* FUNCTION
* generates a cull order position struct
*
* INPUTS
* order_pos_t **cull_order_pos - struct to init. if not NULL, the old struct will be freed
* lListElem *jep - job structure
* lListElem *jatp - ja task structure
* lListElem *joker - job order structure
* lListElem *joker_task - ja task order structure
*
* NOTES
* MT-NOTE: sge_create_cull_order_pos() is MT safe
*
*******************************************************************************/
void
sge_create_cull_order_pos(order_pos_t **cull_order_pos, lListElem *jep, lListElem *jatp,
lListElem *joker, lListElem *joker_task)
{
ja_task_pos_t *ja_pos;
ja_task_pos_t *order_ja_pos;
job_pos_t *job_pos;
job_pos_t *order_job_pos;
if (*cull_order_pos != NULL) {
sge_free(&cull_order_pos);
}
*cull_order_pos = malloc(sizeof(order_pos_t));
ja_pos = &((*cull_order_pos)->ja_task);
order_ja_pos = &((*cull_order_pos)->order_ja_task);
job_pos = &((*cull_order_pos)->job);
order_job_pos = &((*cull_order_pos)->order_job);
if (jep != NULL) {
job_pos->JB_version_pos = lGetPosViaElem(jep,JB_version, SGE_NO_ABORT);
job_pos->JB_nppri_pos = lGetPosViaElem(jep,JB_nppri, SGE_NO_ABORT);
job_pos->JB_nurg_pos = lGetPosViaElem(jep,JB_nurg, SGE_NO_ABORT);
job_pos->JB_urg_pos = lGetPosViaElem(jep,JB_urg, SGE_NO_ABORT);
job_pos->JB_rrcontr_pos = lGetPosViaElem(jep,JB_rrcontr, SGE_NO_ABORT);
job_pos->JB_dlcontr_pos = lGetPosViaElem(jep,JB_dlcontr, SGE_NO_ABORT);
job_pos->JB_wtcontr_pos = lGetPosViaElem(jep,JB_wtcontr, SGE_NO_ABORT);
/*
DPRINTF(("job prio pos: %d %d %d %d %d %d %d\n", job_pos->JB_version_pos, job_pos->JB_nppri_pos, job_pos->JB_nurg_pos,
job_pos->JB_urg_pos, job_pos->JB_rrcontr_pos, job_pos->JB_dlcontr_pos,
job_pos->JB_wtcontr_pos));#
*/
}
if (jatp != NULL) {
ja_pos->JAT_status_pos = lGetPosViaElem(jatp,JAT_status, SGE_NO_ABORT);
ja_pos->JAT_tix_pos = lGetPosViaElem(jatp,JAT_tix, SGE_NO_ABORT);
ja_pos->JAT_oticket_pos = lGetPosViaElem(jatp,JAT_oticket, SGE_NO_ABORT);
ja_pos->JAT_fticket_pos = lGetPosViaElem(jatp,JAT_fticket, SGE_NO_ABORT);
ja_pos->JAT_sticket_pos = lGetPosViaElem(jatp,JAT_sticket, SGE_NO_ABORT);
ja_pos->JAT_share_pos = lGetPosViaElem(jatp,JAT_share, SGE_NO_ABORT);
ja_pos->JAT_prio_pos = lGetPosViaElem(jatp,JAT_prio, SGE_NO_ABORT);
ja_pos->JAT_ntix_pos = lGetPosViaElem(jatp,JAT_ntix, SGE_NO_ABORT);
/*
DPRINTF(("ja task prio pos: %d %d %d %d %d %d %d %d\n", ja_pos->JAT_status_pos, ja_pos->JAT_tix_pos, ja_pos->JAT_oticket_pos,
ja_pos->JAT_fticket_pos, ja_pos->JAT_sticket_pos,
ja_pos->JAT_share_pos, ja_pos->JAT_prio_pos, ja_pos->JAT_ntix_pos));
*/
}
if (joker != NULL) {
order_job_pos->JB_version_pos = -1;
order_job_pos->JB_nppri_pos = lGetPosViaElem(joker,JB_nppri, SGE_NO_ABORT);
order_job_pos->JB_nurg_pos = lGetPosViaElem(joker,JB_nurg, SGE_NO_ABORT);
order_job_pos->JB_urg_pos = lGetPosViaElem(joker,JB_urg, SGE_NO_ABORT);
order_job_pos->JB_rrcontr_pos = lGetPosViaElem(joker,JB_rrcontr, SGE_NO_ABORT);
order_job_pos->JB_dlcontr_pos = lGetPosViaElem(joker,JB_dlcontr, SGE_NO_ABORT);
order_job_pos->JB_wtcontr_pos = lGetPosViaElem(joker,JB_wtcontr, SGE_NO_ABORT);
/*
DPRINTF(("job order pos: %d %d %d %d %d %d %d\n", order_job_pos->JB_version_pos, order_job_pos->JB_nppri_pos, order_job_pos->JB_nurg_pos,
order_job_pos->JB_urg_pos, order_job_pos->JB_rrcontr_pos, order_job_pos->JB_dlcontr_pos,
order_job_pos->JB_wtcontr_pos));
*/
}
if (joker_task != NULL) {
order_ja_pos->JAT_status_pos = -1;
order_ja_pos->JAT_tix_pos = -1;
order_ja_pos->JAT_oticket_pos = lGetPosViaElem(joker_task,JAT_oticket, SGE_NO_ABORT);
order_ja_pos->JAT_fticket_pos = lGetPosViaElem(joker_task,JAT_fticket, SGE_NO_ABORT);
order_ja_pos->JAT_sticket_pos = lGetPosViaElem(joker_task,JAT_sticket, SGE_NO_ABORT);
order_ja_pos->JAT_share_pos = lGetPosViaElem(joker_task,JAT_share, SGE_NO_ABORT);
order_ja_pos->JAT_prio_pos = lGetPosViaElem(joker_task,JAT_prio, SGE_NO_ABORT);
order_ja_pos->JAT_ntix_pos = lGetPosViaElem(joker_task,JAT_ntix, SGE_NO_ABORT);
/*
DPRINTF(("ja task order pos: %d %d %d %d %d %d %d %d\n", order_ja_pos->JAT_status_pos, order_ja_pos->JAT_tix_pos, order_ja_pos->JAT_oticket_pos,
order_ja_pos->JAT_fticket_pos, order_ja_pos->JAT_sticket_pos,
order_ja_pos->JAT_share_pos, order_ja_pos->JAT_prio_pos, order_ja_pos->JAT_ntix_pos));
*/
}
}
