/****** cull/dump_scan/lDumpDescr() ****************************************
* NAME
* lDumpDescr() -- Write a descriptor (for debugging purpose)
*
* SYNOPSIS
* int lDumpDescr(FILE *fp, const lDescr *dp, int indent)
*
* FUNCTION
* Write a descriptor (for debugging purpose)
*
* INPUTS
* FILE *fp - file pointer
* const lDescr *dp - descriptor
* int indent -
*
* RESULT
* int - error state
* 0 - OK
* -1 - Error
******************************************************************************/
int lDumpDescr(FILE *fp, const lDescr *dp, int indent)
{
int i, ret = ~EOF;
char space[256];
DENTER(CULL_LAYER, "lDumpDescr");
space[0] = '\0';
for (i = 0; i < indent; i++)
strcat(space, INDENT_STRING);
if (!fp) {
LERROR(LEFILENULL);
DEXIT;
return -1;
}
ret = fprintf(fp, "%s{ /* DESCR BEGIN */\n", space);
if (!dp) {
LERROR(LEDESCRNULL);
DEXIT;
return -1;
}
ret = fprintf(fp, "%s/* NUMBER OF DESCR FIELDS */ %d\n", space,
lCountDescr(dp));
for (i = 0; mt_get_type(dp[i].mt) != lEndT && ret != EOF; i++) {
ret = fprintf(fp, "%s/* %-20.20s */ { %d, %d }\n", space,
lNm2Str(dp[i].nm), dp[i].nm, dp[i].mt);
}
ret = fprintf(fp, "%s} /* DESCR END */\n", space);
DEXIT;
return (ret == EOF) ? -1 : 0;
}
int main(int argc, char *argv[])
{
lListElem *queue, *copy;
const lDescr *descr;
spooling_field *fields;
dstring queue_str = DSTRING_INIT;
dstring copy_str = DSTRING_INIT;
lList *answer_list;
int i;
lInit(nmv);
descr = QU_Type;
copy = lCreateElem(descr);
/* lWriteElemTo(queue, stdout); */
for(i = 0; mt_get_type(descr[i].mt) != lEndT; i++) {
int nm;
const char *name;
const char *value, *reread_value;
nm = descr[i].nm;
name = lNm2Str(nm);
value = object_append_field_to_dstring(queue, &answer_list,
&queue_str, nm, '\0');
reread_value = NULL;
if(value != NULL) {
if(!object_parse_field_from_string(copy, &answer_list, nm, value)) {
fprintf(stderr, "setting value for field %s failed\n", name);
} else {
reread_value = object_append_field_to_dstring(copy, &answer_list,
©_str, nm, '\0');
}
}
#if 1
printf("%s\t%s\t%s\n", name,
value == NULL ? "<null>" : value,
reread_value == NULL ? "<null>" : reread_value);
#endif
if(sge_strnullcmp(value, reread_value) != 0) {
fprintf(stderr, "regression test for object_[gs]et_field_contents failed for attribute "SFQ": "SFQ" != "SFQ"\n",
name,
value != NULL ? value : "<null>",
reread_value != NULL ? reread_value : "<null>");
}
}
fields = spool_get_fields_to_spool(&answer_list, QU_Type, &spool_config_instr);
printf("\nthe following fields will be spooled:");
for(i = 0; fields[i].nm != NoName; i++) {
printf(" %s", lNm2Str(fields[i].nm));
}
printf("\n");
fields = spool_free_spooling_fields(fields);
/* cleanup */
lFreeElem(&queue);
lFreeElem(©);
sge_dstring_free(&queue_str);
sge_dstring_free(©_str);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
lListElem *queue, *copy;
lList *queue_list;
lList *answer_list = NULL;
const lDescr *descr;
spooling_field *fields;
const char *filepath;
int i;
int width;
char format[100];
lInit(nmv);
queue = queue_create_template();
lSetString(queue, QU_terminate_method, "/tmp/myterminate_method.sh");
lAddSubStr(queue, CE_name, "foo", QU_suspend_thresholds, CE_Type);
lAddSubStr(queue, CE_name, "bar", QU_suspend_thresholds, CE_Type);
copy = lCreateElem(QU_Type);
queue_list = lCreateList("queue_list", QU_Type);
lAppendElem(queue_list, queue);
lAppendElem(queue_list, copy);
descr = lGetElemDescr(queue);
fields = spool_get_fields_to_spool(&answer_list, QU_Type, &spool_config_instr);
printf("\nthe following fields are spooled:");
for(i = 0; fields[i].nm != NoName; i++) {
printf(" %s", lNm2Str(fields[i].nm));
}
printf("\n");
spool_flatfile_align_object(&answer_list, fields);
width = fields[0].width;
printf("alignment for attribute names is %d\n", width);
spool_flatfile_align_list(&answer_list, queue_list, fields);
printf("field widths for list output is as follows:\n");
sprintf(format, "%%%ds: %%d\n", width);
for(i = 0; fields[i].nm != NoName; i++) {
printf(format, lNm2Str(fields[i].nm), fields[i].width);
}
filepath = spool_flatfile_write_object(&answer_list, queue,
NULL,
&spool_flatfile_instr_config,
SP_DEST_STDOUT, SP_FORM_ASCII, NULL);
if(filepath != NULL) {
printf("\ndata successfully written to stdout\n");
FREE(filepath);
} else {
answer_list_print_err_warn(&answer_list, NULL, NULL);
}
printf("\n");
filepath = spool_flatfile_write_object(&answer_list, queue,
NULL,
&spool_flatfile_instr_config,
SP_DEST_TMP, SP_FORM_ASCII, NULL);
if(filepath != NULL) {
printf("temporary file %s successfully written\n", filepath);
sge_unlink(NULL, filepath);
FREE(filepath);
} else {
answer_list_print_err_warn(&answer_list, NULL, NULL);
}
filepath = spool_flatfile_write_object(&answer_list, queue,
NULL,
&spool_flatfile_instr_config,
SP_DEST_SPOOL, SP_FORM_ASCII,
"test_sge_spooling_flatfile.dat");
if(filepath != NULL) {
lListElem *reread_queue;
printf("spool file %s successfully written\n", filepath);
/* reread queue from file */
reread_queue = spool_flatfile_read_object(&answer_list, QU_Type, NULL, NULL,
&spool_flatfile_instr_config,
SP_FORM_ASCII, NULL,
"test_sge_spooling_flatfile.dat");
if(reread_queue == NULL) {
answer_list_print_err_warn(&answer_list, NULL, NULL);
} else {
lWriteElemTo(reread_queue, stdout);
lFreeElem(&reread_queue);
}
sge_unlink(NULL, filepath);
FREE(filepath);
} else {
answer_list_print_err_warn(&answer_list, NULL, NULL);
}
filepath = spool_flatfile_write_list(&answer_list, queue_list,
NULL,
&spool_flatfile_instr_config_list,
SP_DEST_STDOUT, SP_FORM_ASCII,
NULL);
if(filepath != NULL) {
printf("\ndata successfully written to stdout\n");
FREE(filepath);
} else {
answer_list_print_err_warn(&answer_list, NULL, NULL);
}
filepath = spool_flatfile_write_list(&answer_list, queue_list,
NULL,
&spool_flatfile_instr_config_list,
SP_DEST_SPOOL, SP_FORM_ASCII,
"test_sge_spooling_flatfile.dat");
if(filepath != NULL) {
lList *reread_list;
printf("spool file %s successfully written\n", filepath);
reread_list = spool_flatfile_read_list(&answer_list, QU_Type, NULL, NULL, &spool_flatfile_instr_config_list, SP_FORM_ASCII, NULL, "test_sge_spooling_flatfile.dat");
if (reread_list == NULL) {
answer_list_print_err_warn(&answer_list, NULL, NULL);
} else {
lWriteListTo(reread_list, stdout);
lFreeList(&reread_list);
}
/* sge_unlink(NULL, filepath); */
FREE(filepath);
} else {
answer_list_print_err_warn(&answer_list, NULL, NULL);
}
/* test reading object */
/* test nonexisting filename */
/* test behaviour with NULL-pointer passed */
printf("\n\ntesting error handling, the next calls have to fail\n");
spool_flatfile_align_object(&answer_list, NULL);
spool_flatfile_align_list(&answer_list, NULL, fields);
spool_flatfile_align_list(&answer_list, queue_list, NULL);
answer_list_print_err_warn(&answer_list, NULL, NULL);
/* cleanup */
lFreeList(&queue_list);
fields = spool_free_spooling_fields(fields);
fprintf(stdout, "file handle stdout still alive\n");
fprintf(stderr, "file handle stderr still alive\n");
return EXIT_SUCCESS;
}
/* ------------------------------------------------------------
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);
}
static spooling_field *
_spool_get_fields_to_spool(lList **answer_list, const lDescr *descr,
const spool_instr *instr)
{
spooling_field *fields;
int i, j, size;
int strip = 0;
DENTER(TOP_LAYER, "_spool_get_fields_to_spool");
/* we don't check descr and instr, as we know they are ok
* (it's a static function)
*/
/* count fields to spool */
for (i = 0, size = 0; mt_get_type(descr[i].mt) != lEndT; i++) {
if ((descr[i].mt & instr->selection) != 0) {
size++;
}
}
/* allocate memory */
fields = (spooling_field *)malloc((size + 1) * sizeof(spooling_field));
if (fields == NULL) {
answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN,
ANSWER_QUALITY_ERROR,
MSG_UNABLETOALLOCATEBYTES_DS,
(size * 1) * sizeof(spooling_field), SGE_FUNC);
DRETURN(NULL);
}
/* initialize fields */
for (i = 0; i < size; i++) {
fields[i].nm = NoName;
fields[i].width = 0;
fields[i].name = NULL;
fields[i].sub_fields = NULL;
fields[i].clientdata = NULL;
fields[i].read_func = NULL;
fields[i].write_func = NULL;
}
/* do we have to strip field prefixes, e.g. "QU_" from field names? */
if (instr->copy_field_names && instr->strip_field_prefix) {
dstring buffer = DSTRING_INIT;
const char *prefix = object_get_name_prefix(descr, &buffer);
strip = sge_strlen(prefix);
sge_dstring_free(&buffer);
}
/* copy field info */
for (i = 0, j = 0; mt_get_type(descr[i].mt) != lEndT; i++) {
if ((descr[i].mt & instr->selection) != 0) {
spooling_field *sub_fields = NULL;
DPRINTF(("field "SFQ" will be spooled\n", lNm2Str(descr[i].nm)));
fields[j].nm = descr[i].nm;
if (instr->copy_field_names) {
const char *name;
name = lNm2Str(descr[i].nm);
if(name == NULL || strlen(name) <= strip) {
answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN,
ANSWER_QUALITY_ERROR,
MSG_NONAMEFORATTRIBUTE_D,
descr[i].nm);
fields = spool_free_spooling_fields(fields);
DEXIT;
return NULL;
}
fields[j].name = strdup(name + strip);
}
if (mt_get_type(descr[i].mt) == lListT) {
const lDescr *sub_descr;
if (instr->sub_instr == NULL) {
answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN,
ANSWER_QUALITY_ERROR,
MSG_DONTKNOWHOWTOSPOOLSUBLIST_SS,
lNm2Str(descr[i].nm), SGE_FUNC);
fields = spool_free_spooling_fields(fields);
DEXIT;
return NULL;
}
sub_descr = object_get_subtype(descr[i].nm);
if (sub_descr == NULL) {
answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN,
ANSWER_QUALITY_ERROR,
MSG_UNKNOWNOBJECTTYPEFOR_SS,
lNm2Str(descr[i].nm), SGE_FUNC);
fields = spool_free_spooling_fields(fields);
DEXIT;
return NULL;
}
/* recursive spooling, e.g. sharetree */
if (instr->sub_instr == instr && descr == sub_descr) {
sub_fields = fields;
DPRINTF(("recursive structure detected for field %s\n",
lNm2Str(descr[i].nm)));
} else {
sub_fields = _spool_get_fields_to_spool(answer_list, sub_descr,
instr->sub_instr);
}
}
fields[j++].sub_fields = sub_fields;
}
}
/* end of field array */
fields[j].nm = NoName;
DEXIT;
return fields;
}
/****** 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;
}
/****** cull/dump_scan/lUndumpList() ******************************************
* NAME
* lUndumpList() -- Reads a by lDumpList dumped dump
*
* SYNOPSIS
* lList* lUndumpList(FILE *fp, const char *name, const lDescr *dp)
*
* FUNCTION
* Reads a by lDumpList dumped dump into the memory.
*
* INPUTS
* FILE *fp - file pointer
* const char *name - new name of list or NULL if the old name in the
* dumpfile should be used as listname
* const lDescr *dp - new list descriptor or NULL if the old list
* descriptor should be used as list descriptor
*
* RESULT
* lList* - Read list
*
* NOTES
* Actually a type/name matching is only performed for the list
* itself and not for its sublists.
* If an implementation of changed sublist descriptors is desired
* we can probably use the following syntax for lUndumpList.
* lList* lUndumpList(fp, name, formatstring, ...)
* with formatstring like "%T(%I -> %T(%I->%T))" and the varargs
* list: ".....", lDescr1, fieldname1, lDescr2, fieldname2, lDescr3
* or write a wrapper around lUndumpList which parses this format and
* hands over the varargs list to lUndumpList
******************************************************************************/
lList *lUndumpList(FILE *fp, const char *name, const lDescr *dp)
{
lList *lp = NULL;
lListElem *fep, *ep;
lDescr *fdp = NULL;
int i, j, nelem, n, k;
int *found;
char *oldname;
DENTER(CULL_LAYER, "lUndumpList");
if (!fp) {
LERROR(LEFILENULL);
DRETURN(NULL);
}
/* read bra */
if (fGetBra(fp)) {
printf("bra is missing\n");
LERROR(LESYNTAX);
DRETURN(NULL);
}
/* read listname */
if (fGetString(fp, &oldname)) {
printf("fGetString failed\n");
LERROR(LEFIELDREAD);
DRETURN(NULL);
}
/* read number of elems */
if (fGetInt(fp, &nelem)) {
printf("fGetInt failed\n");
LERROR(LEFIELDREAD);
DRETURN(NULL);
}
/* read Descriptor from file */
if (!(fdp = lUndumpDescr(fp))) {
LERROR(LEFGETDESCR);
DRETURN(NULL);
}
if (!dp) /* dp is NULL, use lDescr from dumpfile */
dp = fdp;
/* use old name (from file) if name is NULL */
if (!(lp = lCreateList((name) ? name : oldname, dp))) {
FREE(fdp);
LERROR(LECREATELIST);
DRETURN(NULL);
}
free(oldname); /* fGetString strdup's */
if ((n = lCountDescr(dp)) <= 0) {
LERROR(LECOUNTDESCR);
FREE(fdp);
lFreeList(&lp);
DRETURN(NULL);
}
if (!(found = (int *) malloc(sizeof(int) * n))) {
LERROR(LEMALLOC);
FREE(fdp);
lFreeList(&lp);
DRETURN(NULL);
}
/* Initialize found array */
for (i = 0; i < n; i++)
found[i] = -1;
/* Here warnings are displayed if there are additional or missing fields */
for (j = 0; fdp[j].nm != NoName; j++) {
for (i = 0; i < n; i++) {
if (dp[i].nm == fdp[j].nm &&
dp[i].mt == fdp[j].mt) {
if (found[i] != -1)
DPRINTF(("lUndumpList: field %s found twice\n",
lNm2Str(dp[i].nm)));
found[i] = j;
break;
}
}
if (i == n)
DPRINTF(("lUndumpList: field %s not needed\n", lNm2Str(fdp[j].nm)));
}
for (i = 0; i < n; i++)
if (found[i] == -1)
DPRINTF(("lUndumpList: field %s not found\n", lNm2Str(dp[i].nm)));
/* LOOP OVER THE LIST ELEMENTS */
for (k = 0; k < nelem; k++) {
if (!(fep = lUndumpElemFp(fp, fdp))) {
LERROR(LEUNDUMPELEM);
lFreeList(&lp);
FREE(found);
FREE(fdp);
DRETURN(NULL);
}
if (!(ep = lCreateElem(dp))) {
lFreeList(&lp);
FREE(found);
FREE(fdp);
LERROR(LECREATEELEM);
DRETURN(NULL);
}
for (i = 0; i < n; i++) {
if (found[i] == -1) {
continue;
} else if (lCopySwitchPack(fep, ep, found[i], i, true, NULL, NULL) == -1) {
lFreeList(&lp);
lFreeElem(&ep);
FREE(found);
FREE(fdp);
LERROR(LECOPYSWITCH);
DRETURN(NULL);
}
}
lFreeElem(&fep);
if (lAppendElem(lp, ep) == -1) {
lFreeList(&lp);
lFreeElem(&ep);
FREE(found);
FREE(fdp);
LERROR(LEAPPENDELEM);
DRETURN(NULL);
}
}
/* read ket */
if (fGetKet(fp)) {
lFreeList(&lp);
printf("ket is missing\n");
LERROR(LESYNTAX);
}
FREE(found);
FREE(fdp);
DRETURN(lp);
}
/****** cull/dump_scan/lDumpElemFp() ******************************************
* NAME
* lDumpElemFp() -- Dump a given element into FILE stream
*
* SYNOPSIS
* int lDumpElemFp(FILE *fp, const lListElem *ep, int indent)
*
* FUNCTION
* Dump a given element into FILE stream
*
* INPUTS
* FILE *fp - file stream
* const lListElem *ep - element
* int indent -
*
* RESULT
* int - error state
* 0 - OK
* -1 - Error
*
* NOTES
* MT-NOTE: lDumpElemFp() is not MT safe
******************************************************************************/
int lDumpElemFp(FILE *fp, const lListElem *ep, int indent)
{
int i, ret = ~EOF;
lList *tlp;
lListElem *tep;
char space[256];
const char *str;
dstring dstr = DSTRING_INIT;
DENTER(CULL_LAYER, "lDumpElemFp");
space[0] = '\0';
for (i = 0; i < indent; i++)
strcat(space, INDENT_STRING);
if (!fp) {
LERROR(LEFILENULL);
DEXIT;
return -1;
}
if (!ep) {
LERROR(LEELEMNULL);
DEXIT;
return -1;
}
ret = fprintf(fp, "%s{ \n", space);
for (i = 0, ret = 0; ep->descr[i].nm != NoName && ret != EOF; i++) {
char *tok = NULL;
switch (mt_get_type(ep->descr[i].mt)) {
case lIntT:
ret = fprintf(fp, "%s/* %-20.20s */ %d\n",
space, lNm2Str(ep->descr[i].nm), lGetPosInt(ep, i));
break;
case lUlongT:
ret = fprintf(fp, "%s/* %-20.20s */ " sge_u32 "\n",
space, lNm2Str(ep->descr[i].nm), lGetPosUlong(ep, i));
break;
case lStringT:
str = lGetPosString(ep, i);
/* quote " inside str */
if ((tok = sge_strtok(str, "\"")) != NULL) {
sge_dstring_append(&dstr, tok);
while ((tok=sge_strtok(NULL, "\"")) != NULL) {
sge_dstring_append(&dstr, "\\\"");
sge_dstring_append(&dstr, tok);
}
}
str = sge_dstring_get_string(&dstr);
ret = fprintf(fp, "%s/* %-20.20s */ \"%s\"\n",
space, lNm2Str(ep->descr[i].nm), str != NULL ? str : "");
sge_dstring_clear(&dstr);
break;
case lHostT:
str = lGetPosHost(ep, i);
ret = fprintf(fp, "%s/* %-20.20s */ \"%s\"\n",
space, lNm2Str(ep->descr[i].nm), str != NULL ? str : "");
break;
case lFloatT:
ret = fprintf(fp, "%s/* %-20.20s */ %f\n",
space, lNm2Str(ep->descr[i].nm), lGetPosFloat(ep, i));
break;
case lDoubleT:
ret = fprintf(fp, "%s/* %-20.20s */ %f\n",
space, lNm2Str(ep->descr[i].nm), lGetPosDouble(ep, i));
break;
case lLongT:
ret = fprintf(fp, "%s/* %-20.20s */%ld \n",
space, lNm2Str(ep->descr[i].nm), lGetPosLong(ep, i));
break;
case lCharT:
ret = fprintf(fp, "%s/* %-20.20s */ %c\n",
space, lNm2Str(ep->descr[i].nm), lGetPosChar(ep, i));
break;
case lBoolT:
ret = fprintf(fp, "%s/* %-20.20s */ %d\n",
space, lNm2Str(ep->descr[i].nm), lGetPosBool(ep, i));
break;
case lRefT:
ret = fprintf(fp, "%s/* %-20.20s */ %ld\n",
space, lNm2Str(ep->descr[i].nm), (long)lGetPosRef(ep, i));
break;
case lObjectT:
if ((tep = lGetPosObject(ep, i)) == NULL)
ret = fprintf(fp, "%s/* %-20.20s */ none\n",
space, lNm2Str(ep->descr[i].nm));
else {
ret = fprintf(fp, "%s/* %-20.20s */ object\n",
space, lNm2Str(ep->descr[i].nm));
if (ret != EOF)
ret = lDumpObject(fp, tep, indent + 1);
}
break;
case lListT:
if ((tlp = lGetPosList(ep, i)) == NULL)
ret = fprintf(fp, "%s/* %-20.20s */ empty\n",
space, lNm2Str(ep->descr[i].nm));
else {
ret = fprintf(fp, "%s/* %-20.20s */ full\n",
space, lNm2Str(ep->descr[i].nm));
if (ret != EOF)
ret = lDumpList(fp, tlp, indent + 1);
}
break;
}
}
sge_dstring_free(&dstr);
ret = fprintf(fp, "%s}\n", space);
DEXIT;
return (ret == EOF) ? -1 : 0;
}
/****** qmaster/sge_mod_configuration() ****************************************
* NAME
* sge_mod_configuration() -- modify cluster configuration
*
* SYNOPSIS
* int sge_mod_configuration(lListElem *aConf, lList **anAnswer, char *aUser,
* char *aHost)
*
* FUNCTION
* Modify cluster configuration. 'confp' is a pointer to a 'CONF_Type' list
* element and does contain the modified configuration entry. Adding a new
* configuration entry is also viewed as a modification.
*
* INPUTS
* lListElem *aConf - CONF_Type element containing the modified conf
* lList **anAnswer - answer list
* char *aUser - target user
* char *aHost - target host
*
* RESULT
* int - 0 success
* -1 error
*
* NOTES
* MT-NOTE: sge_mod_configuration() is MT safe
*
*******************************************************************************/
int sge_mod_configuration(sge_gdi_ctx_class_t *ctx, lListElem *aConf, lList **anAnswer, char *aUser, char *aHost)
{
lListElem *old_conf;
const char *tmp_name = NULL;
char unique_name[CL_MAXHOSTLEN];
int ret = -1;
const char *cell_root = ctx->get_cell_root(ctx);
const char *qualified_hostname = ctx->get_qualified_hostname(ctx);
u_long32 progid = ctx->get_who(ctx);
DENTER(TOP_LAYER, "sge_mod_configuration");
if (!aConf || !aUser || !aHost) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_NULLPTRPASSED_S, SGE_FUNC));
answer_list_add(anAnswer, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
if ((tmp_name = lGetHost(aConf, CONF_name)) == NULL) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_MISSINGCULLFIELD_SS, lNm2Str(CONF_name), SGE_FUNC));
answer_list_add(anAnswer, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
if ((ret = sge_resolve_hostname(tmp_name, unique_name, EH_name, sizeof(unique_name)))
!= CL_RETVAL_OK) {
DPRINTF(("%s: error %s resolving host %s\n", SGE_FUNC, cl_get_error_text(ret), tmp_name));
ERROR((SGE_EVENT, MSG_SGETEXT_CANTRESOLVEHOST_S, tmp_name));
answer_list_add(anAnswer, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
if ((ret = check_config(anAnswer, aConf))) {
DRETURN(ret);
}
if ((old_conf = sge_get_configuration_for_host(unique_name)) != NULL) {
int ret = -1;
ret = do_mod_config(ctx, unique_name, old_conf, aConf, anAnswer);
lFreeElem(&old_conf);
if (ret == 0) {
INFO((SGE_EVENT, MSG_SGETEXT_MODIFIEDINLIST_SSSS, aUser, aHost, unique_name, MSG_OBJ_CONF));
answer_list_add(anAnswer, SGE_EVENT, STATUS_OK, ANSWER_QUALITY_INFO);
} else {
DRETURN(STATUS_EUNKNOWN);
}
} else {
do_add_config(ctx, unique_name, aConf, anAnswer);
INFO((SGE_EVENT, MSG_SGETEXT_ADDEDTOLIST_SSSS, aUser, aHost, unique_name, MSG_OBJ_CONF));
answer_list_add(anAnswer, SGE_EVENT, STATUS_OK, ANSWER_QUALITY_INFO);
}
if (strcmp(SGE_GLOBAL_NAME, unique_name) == 0) {
sge_add_event(0, sgeE_GLOBAL_CONFIG, 0, 0, NULL, NULL, NULL, NULL);
}
/*
** is the configuration change relevant for the qmaster itsself?
** if so, initialise conf struct anew
*/
if (strcmp(unique_name, SGE_GLOBAL_NAME) == 0 || sge_hostcmp(unique_name, qualified_hostname) == 0) {
lListElem *local = NULL;
lListElem *global = NULL;
lList *answer_list = NULL;
char* qmaster_params = NULL;
int accounting_flush_time = mconf_get_accounting_flush_time();
if ((local = sge_get_configuration_for_host(qualified_hostname)) == NULL) {
WARNING((SGE_EVENT, MSG_CONF_NOLOCAL_S, qualified_hostname));
}
if ((global = sge_get_configuration_for_host(SGE_GLOBAL_NAME)) == NULL) {
ERROR((SGE_EVENT, SFNMAX, MSG_CONF_NOGLOBAL));
}
if (merge_configuration(&answer_list, progid, cell_root, global, local, NULL) != 0) {
ERROR((SGE_EVENT, MSG_CONF_CANTMERGECONFIGURATIONFORHOST_S, qualified_hostname));
}
answer_list_output(&answer_list);
/* Restart the accounting flush event if needed. */
if ((accounting_flush_time == 0) &&
(mconf_get_accounting_flush_time() != 0)) {
te_event_t ev = te_new_event(time(NULL), TYPE_ACCOUNTING_TRIGGER, ONE_TIME_EVENT, 1, 0, NULL);
te_add_event(ev);
te_free_event(&ev);
}
lFreeElem(&local);
lFreeElem(&global);
sge_show_conf();
/* 'max_unheard' may have changed */
cl_commlib_set_connection_param(cl_com_get_handle("qmaster", 1), HEARD_FROM_TIMEOUT, mconf_get_max_unheard());
/* fetching qmaster_params and begin to parse */
qmaster_params = mconf_get_qmaster_params();
/* updating the commlib paramterlist and gdi_timeout with new or changed parameters */
cl_com_update_parameter_list(qmaster_params);
sge_free(&qmaster_params);
}
/* invalidate configuration cache */
mconf_set_new_config(true);
DRETURN(STATUS_OK);
}
/*
* Delete configuration 'confp' from cluster configuration.
*
* TODO: A fix for IZ issue #79 is needed. For this to be done it may be
* necessary to introduce something like 'protected' configuration entries.
*/
int
sge_del_configuration(sge_gdi_ctx_class_t *ctx,
lListElem *aConf, lList **anAnswer,
char *aUser, char *aHost)
{
const char *tmp_name = NULL;
char unique_name[CL_MAXHOSTLEN];
int ret = -1;
DENTER(TOP_LAYER, "sge_del_configuration");
if (!aConf || !aUser || !aHost) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_NULLPTRPASSED_S, SGE_FUNC));
answer_list_add(anAnswer, SGE_EVENT,
STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
if ((tmp_name = lGetHost(aConf, CONF_name)) == NULL) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_MISSINGCULLFIELD_SS,
lNm2Str(CONF_name), SGE_FUNC));
answer_list_add(anAnswer, SGE_EVENT,
STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
/*
* Due to CR 6319231 IZ 1760:
* try to resolve the hostname
* if it is not resolveable then
* ignore this and use the hostname stored in the configuration obj
* or use the given name if no object can be found
*/
ret = sge_resolve_hostname(tmp_name, unique_name, EH_name, sizeof(unique_name));
if (ret != CL_RETVAL_OK) {
lListElem *conf_obj = NULL;
DPRINTF(("%s: error %s resolving host %s\n", SGE_FUNC,
cl_get_error_text(ret), tmp_name));
conf_obj = sge_get_configuration_for_host(tmp_name);
if (conf_obj != NULL) {
DPRINTF(("using hostname stored in configuration object\n"));
strcpy(unique_name, lGetHost(conf_obj, CONF_name));
lFreeElem(&conf_obj);
} else {
ERROR((SGE_EVENT, MSG_SGETEXT_CANT_DEL_CONFIG2_S, tmp_name));
answer_list_add(anAnswer, SGE_EVENT,
STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
}
/* Do not allow to delete global configuration */
if (!strcasecmp(SGE_GLOBAL_NAME, unique_name)) {
ERROR((SGE_EVENT, MSG_SGETEXT_CANT_DEL_CONFIG_S, unique_name));
answer_list_add(anAnswer, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
sge_event_spool(ctx, anAnswer, 0, sgeE_CONFIG_DEL, 0, 0, unique_name, NULL, NULL, NULL, NULL, NULL, true, true);
remove_conf_by_name(unique_name);
INFO((SGE_EVENT, MSG_SGETEXT_REMOVEDFROMLIST_SSSS, aUser, aHost, unique_name, MSG_OBJ_CONF ));
answer_list_add(anAnswer, SGE_EVENT, STATUS_OK, ANSWER_QUALITY_INFO);
update_reschedule_unknown_timout_values(unique_name);
/* invalidate cached configuration values */
mconf_set_new_config(true);
DRETURN(STATUS_OK);
}
