/************************************************************
sge_del_sharetree - Master code
Delete the sharetree
************************************************************/
int sge_del_sharetree(
sge_gdi_ctx_class_t *ctx,
lList **lpp, /* list to change */
lList **alpp,
char *ruser,
char *rhost
) {
DENTER(TOP_LAYER, "sge_del_sharetree");
if (!*lpp || !lFirst(*lpp)) {
ERROR((SGE_EVENT, MSG_SGETEXT_DOESNOTEXIST_S, MSG_OBJ_SHARETREE));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DEXIT;
return STATUS_EEXIST;
}
sge_event_spool(ctx,
alpp, 0, sgeE_NEW_SHARETREE,
0, 0, NULL, NULL, NULL,
NULL, NULL, NULL, true, true);
lFreeList(lpp);
INFO((SGE_EVENT, MSG_SGETEXT_REMOVEDLIST_SSS, ruser, rhost, MSG_OBJ_SHARETREE));
answer_list_add(alpp, SGE_EVENT, STATUS_OK, ANSWER_QUALITY_INFO);
DEXIT;
return STATUS_OK;
}
/************************************************************
sge_mod_sched_configuration - Master code
Modify scheduler configuration. We have only one entry in
Master_Sched_Config_List. So we replace it with the new one.
************************************************************/
int sge_mod_sched_configuration(
sge_gdi_ctx_class_t *ctx,
lListElem *confp,
lList **alpp,
char *ruser,
char *rhost
) {
lList *temp_conf_list = NULL;
DENTER(TOP_LAYER, "sge_mod_sched_configuration");
if ( !confp || !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;
}
temp_conf_list = lCreateList("sched config", SC_Type);
lSetUlong(confp, SC_weight_tickets_override,
sconf_get_weight_tickets_override());
confp = lCopyElem(confp);
lAppendElem(temp_conf_list, confp);
/* just check and log */
if (!sconf_set_config(&temp_conf_list, alpp)) {
lFreeList(&temp_conf_list);
DEXIT;
return STATUS_EUNKNOWN;
}
if (!sge_event_spool(ctx,
alpp, 0, sgeE_SCHED_CONF,
0, 0, "schedd_conf", NULL, NULL,
confp, NULL, NULL, true, true)) {
answer_list_add(alpp, MSG_SCHEDCONF_CANTCREATESCHEDULERCONFIGURATION, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR);
DEXIT;
return -1;
}
check_reprioritize_interval(ctx, alpp, ruser, rhost);
INFO((SGE_EVENT, MSG_SGETEXT_MODIFIEDINLIST_SSSS, ruser, rhost, "scheduler", "scheduler configuration"));
answer_list_add(alpp, SGE_EVENT, STATUS_OK, ANSWER_QUALITY_INFO);
DEXIT;
return STATUS_OK;
} /* sge_mod_sched_configuration */
/* ------------------------------------------------------------
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);
}
/****** 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;
}
/************************************************************
sge_mod_sharetree - Master code
Modify a share tree
lListElem *ep, This is the new share tree
lList **lpp, list to change
************************************************************/
int sge_mod_sharetree(sge_gdi_ctx_class_t *ctx,
lListElem *ep, lList **lpp, lList **alpp,
char *ruser, char *rhost )
{
int ret;
int prev_version;
int adding;
lList *found = NULL;
object_description *object_base = object_type_get_object_description();
DENTER(TOP_LAYER, "sge_mod_sharetree");
/* do some checks */
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;
}
ret = check_sharetree(alpp, ep, *object_base[SGE_TYPE_USER].list,
*object_base[SGE_TYPE_PROJECT].list,
NULL, &found);
lFreeList(&found);
if (ret) {
/* alpp gets filled by check_sharetree() */
DRETURN(STATUS_EUNKNOWN);
}
/* check for presence of sharetree list and create if neccesary */
if (!*lpp) {
prev_version = 0;
*lpp = lCreateList("sharetree list", STN_Type);
adding = 1;
} else if (lGetNumberOfElem(*lpp) == 0) {
prev_version = 0;
adding = 1;
} else {
lListElem *first = lFirst(*lpp);
/* real action: change user or project
We simply replace the old element with the new one. If there is no
old we simle add the new. */
prev_version = lGetUlong(lFirst(*lpp), STN_version);
lRemoveElem(*lpp, &first);
adding = 0;
}
lSetUlong(ep, STN_version, prev_version+1);
id_sharetree(alpp, ep, 0, NULL);
/* now insert new element */
lAppendElem(*lpp, lCopyElem(ep));
/* write sharetree to file */
if (!sge_event_spool(ctx,
alpp, 0, sgeE_NEW_SHARETREE,
0, 0, NULL, NULL, NULL,
ep, NULL, NULL, true, true)) {
/* answer list gets filled in sge_event_spool() */
DEXIT;
return ret;
}
if (adding) {
INFO((SGE_EVENT, MSG_STREE_ADDSTREE_SSII,
ruser, rhost, lGetNumberOfNodes(ep, NULL, STN_children), lGetNumberOfLeafs(ep, NULL, STN_children)));
} else {
INFO((SGE_EVENT, MSG_STREE_MODSTREE_SSII,
ruser, rhost, lGetNumberOfNodes(ep, NULL, STN_children), lGetNumberOfLeafs(ep, NULL, STN_children)));
}
answer_list_add(alpp, SGE_EVENT, STATUS_OK, ANSWER_QUALITY_INFO);
DEXIT;
return STATUS_OK;
}
/************************************************************************
Master routine for job exit
We need a rusage struct filled.
In normal cases this is done by the execd, sending this structure
to notify master about job finish.
In case of an error noticed by the master which needs the job to be
removed we can fill this structure by hand. We need:
rusage->job_number
rusage->qname to clean up the queue (if we didn't find it we nevertheless
clean up the job
for functions regarding rusage see sge_rusage.c
************************************************************************/
void sge_job_exit(sge_gdi_ctx_class_t *ctx, lListElem *jr, lListElem *jep, lListElem *jatep, monitoring_t *monitor)
{
lListElem *queueep = NULL;
const char *err_str = NULL;
const char *qname = NULL;
const char *hostname = MSG_OBJ_UNKNOWNHOST;
u_long32 jobid, jataskid;
lListElem *hep = NULL;
u_long32 timestamp;
object_description *object_base = object_type_get_object_description();
u_long32 failed, general_failure;
lList *saved_gdil;
DENTER(TOP_LAYER, "sge_job_exit");
/* JG: TODO: we'd prefer some more precise timestamp, e.g. from jr */
timestamp = sge_get_gmt();
qname = lGetString(jr, JR_queue_name);
if (qname == NULL) {
qname = (char *)MSG_OBJ_UNKNOWNQ;
}
err_str = lGetString(jr, JR_err_str);
if (err_str == NULL) {
err_str = MSG_UNKNOWNREASON;
}
jobid = lGetUlong(jr, JR_job_number);
jataskid = lGetUlong(jr, JR_ja_task_number);
failed = lGetUlong(jr, JR_failed);
general_failure = lGetUlong(jr, JR_general_failure);
cancel_job_resend(jobid, jataskid);
/* This only has a meaning for Hibernator jobs. The job pid must
* be saved accross restarts, since jobs get their old pid
*/
lSetUlong(jatep, JAT_pvm_ckpt_pid, lGetUlong(jr, JR_job_pid));
DPRINTF(("reaping job "sge_u32"."sge_u32" in queue >%s< job_pid %d\n",
jobid, jataskid, qname, (int) lGetUlong(jatep, JAT_pvm_ckpt_pid)));
queueep = cqueue_list_locate_qinstance(*object_base[SGE_TYPE_CQUEUE].list, qname);
if (queueep == NULL) {
ERROR((SGE_EVENT, MSG_JOB_WRITEJFINISH_S, qname));
}
sge_job_remove_enforce_limit_trigger(jobid, jataskid);
/* retrieve hostname for later use */
if (queueep != NULL) {
hostname = lGetHost(queueep, QU_qhostname);
}
if (failed) { /* a problem occured */
WARNING((SGE_EVENT, MSG_JOB_FAILEDONHOST_UUSSSS, sge_u32c(jobid),
sge_u32c(jataskid),
hostname,
general_failure ? MSG_GENERAL : "",
get_sstate_description(failed), err_str));
} else {
INFO((SGE_EVENT, MSG_JOB_JFINISH_UUS, sge_u32c(jobid), sge_u32c(jataskid), hostname));
}
/*-------------------------------------------------*/
/* test if this job is in state JRUNNING or JTRANSFERING */
if (lGetUlong(jatep, JAT_status) != JRUNNING &&
lGetUlong(jatep, JAT_status) != JTRANSFERING) {
ERROR((SGE_EVENT, MSG_JOB_JEXITNOTRUN_UU, sge_u32c(lGetUlong(jep, JB_job_number)), sge_u32c(jataskid)));
DRETURN_VOID;
}
saved_gdil = lCopyList("cpy", lGetList(jatep, JAT_granted_destin_identifier_list));
/*
* case 1: job being trashed because
* --> failed starting interactive job
* --> job was deleted
* --> a failed batch job that explicitely shall not enter error state
*/
if (((lGetUlong(jatep, JAT_state) & JDELETED) == JDELETED) ||
(failed && !lGetString(jep, JB_exec_file)) ||
(failed && general_failure==GFSTATE_JOB && JOB_TYPE_IS_NO_ERROR(lGetUlong(jep, JB_type)))) {
reporting_create_acct_record(ctx, NULL, jr, jep, jatep, false);
/* JG: TODO: we need more information in the log message */
reporting_create_job_log(NULL, timestamp, JL_DELETED, MSG_EXECD, hostname, jr, jep, jatep, NULL, MSG_LOG_JREMOVED);
sge_commit_job(ctx, jep, jatep, jr, COMMIT_ST_FINISHED_FAILED_EE, COMMIT_DEFAULT | COMMIT_NEVER_RAN, monitor);
if (lGetUlong(jep, JB_ar) != 0 && (lGetUlong(jatep, JAT_state) & JDELETED) == JDELETED) {
/* get AR and remove it if no other jobs are debited */
lList *master_ar_list = *object_base[SGE_TYPE_AR].list;
lListElem *ar = ar_list_locate(master_ar_list, lGetUlong(jep, JB_ar));
if (ar != NULL && lGetUlong(ar, AR_state) == AR_DELETED) {
lListElem *ar_queue;
u_long32 ar_id = lGetUlong(ar, AR_id);
for_each(ar_queue, lGetList(ar, AR_reserved_queues)) {
if (qinstance_slots_used(ar_queue) != 0) {
break;
}
}
if (ar_queue == NULL) {
/* no jobs registered in advance reservation */
dstring buffer = DSTRING_INIT;
sge_dstring_sprintf(&buffer, sge_U32CFormat,
sge_u32c(ar_id));
ar_do_reservation(ar, false);
reporting_create_ar_log_record(NULL, ar, ARL_DELETED,
"AR deleted",
timestamp);
reporting_create_ar_acct_records(NULL, ar, timestamp);
lRemoveElem(master_ar_list, &ar);
sge_event_spool(ctx, NULL, 0, sgeE_AR_DEL,
ar_id, 0, sge_dstring_get_string(&buffer), NULL, NULL,
NULL, NULL, NULL, true, true);
sge_dstring_free(&buffer);
}
}
/*
* 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);
}
