bool
cqueue_verify_priority(lListElem *cqueue, lList **answer_list,
lListElem *attr_elem)
{
bool ret = true;
DENTER(CQUEUE_VERIFY_LAYER, "cqueue_verify_priority");
if (cqueue != NULL && attr_elem != NULL) {
const char *priority_string = lGetString(attr_elem, ASTR_value);
if (priority_string != NULL) {
const int priority = atoi(priority_string);
if (priority == 0 && priority_string[0] != '0') {
answer_list_add(answer_list, MSG_CQUEUE_WRONGCHARINPRIO,
STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
ret = false;
} else if (priority < -20 || priority > 20 ) {
answer_list_add(answer_list, MSG_CQUEUE_PRIORITYNOTINRANGE,
STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
ret = false;
}
}
}
DEXIT;
return ret;
}
/****** sgeobj/href/href_list_add() *******************************************
* NAME
* href_list_add() -- Add host or hostgroup reference.
*
* SYNOPSIS
* bool
* href_list_add(lList **this_list, lList **answer_list,
* const char *host_or_group)
*
* FUNCTION
* Add a host or hostgroup given by 'host_or_group' into the list
* 'this_list'. If the function is successfull then the function
* returns 'true' otherwise it will add an entry into 'answer_list'
* and return with 'false'. If 'this_list' does not exist than it
* will be created.
*
* INPUTS
* lList **this_list - HR_Type list
* lList **answer_list - AN_Type list
* const char *host_or_group - host or group name
*
* RESULT
* bool - error state
* true - Success
* false - Error
*******************************************************************************/
bool
href_list_add(lList **this_list, lList **answer_list, const char *host_or_group)
{
bool ret = true;
DENTER(HOSTREF_LAYER, "href_list_add");
if (this_list != NULL && host_or_group != NULL) {
if (!href_list_has_member(*this_list, host_or_group)) {
lListElem *h_or_g; /* HR_Type */
h_or_g = lAddElemHost(this_list, HR_name, host_or_group, HR_Type);
if (h_or_g == NULL) {
answer_list_add(answer_list, MSG_SGETEXT_NOMEM,
STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
ret = false;
}
}
} else {
SGE_ADD_MSG_ID(sprintf(SGE_EVENT, MSG_INAVLID_PARAMETER_IN_S, SGE_FUNC));
answer_list_add(answer_list, SGE_EVENT,
STATUS_ERROR1, ANSWER_QUALITY_ERROR);
ret = false;
}
DEXIT;
return ret;
}
bool cuser_provide_modify_context(sge_gdi_ctx_class_t *ctx, lListElem **this_elem, lList **answer_list)
{
bool ret = false;
int status = 0;
uid_t uid = ctx->get_uid(ctx);
gid_t gid = ctx->get_gid(ctx);
DENTER(TOP_LAYER, "cuser_provide_modify_context");
if (this_elem != NULL && *this_elem) {
char *filename = write_ume(2, 1, *this_elem);
status = sge_edit(filename, uid, gid);
if (status >= 0) {
lListElem *cuser;
cuser = cull_read_in_ume(NULL, filename, 1, 0, 0, NULL);
if (cuser != NULL) {
lFreeElem(this_elem);
*this_elem = cuser;
ret = true;
} else {
answer_list_add(answer_list, MSG_FILE_ERRORREADINGINFILE,
STATUS_ERROR1, ANSWER_QUALITY_ERROR);
}
} else {
answer_list_add(answer_list, MSG_PARSE_EDITFAILED,
STATUS_ERROR1, ANSWER_QUALITY_ERROR);
}
unlink(filename);
}
DRETURN(ret);
}
/************************************************************
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;
}
bool
cqueue_verify_subordinate_list(lListElem *cqueue, lList **answer_list,
lListElem *attr_elem)
{
bool ret = true;
DENTER(CQUEUE_VERIFY_LAYER, "cqueue_verify_subordinate_list");
if (cqueue != NULL && attr_elem != NULL) {
const lList *master_list =
*(object_type_get_master_list(SGE_TYPE_CQUEUE));
const char *cqueue_name = lGetString(cqueue, CQ_name);
lList *so_list = lGetList(attr_elem, ASOLIST_value);
lListElem *so;
for_each(so, so_list) {
const char *so_name = lGetString(so, SO_name);
/*
* Check for recursions to ourself
*/
if (strcmp(cqueue_name, so_name) != 0) {
const lListElem *cqueue = NULL;
/*
* Check if cqueue exists
*/
cqueue = cqueue_list_locate(master_list, so_name);
if (cqueue != NULL) {
/*
* Success
*/
;
} else {
ERROR((SGE_EVENT, MSG_CQUEUE_UNKNOWNSUB_SS,
so_name, cqueue_name));
answer_list_add(answer_list, SGE_EVENT,
STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
ret = false;
}
} else {
ERROR((SGE_EVENT, MSG_CQUEUE_SUBITSELF_S, cqueue_name));
answer_list_add(answer_list, SGE_EVENT,
STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
ret = false;
}
}
}
DEXIT;
return ret;
}
/************************************************************
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 */
/************************************************************************
id_sharetree - set the sharetree node id
************************************************************************/
bool id_sharetree(lList **alpp, lListElem *ep, int id, int *ret_id)
{
lListElem *cep = NULL;
int my_id = id;
DENTER(TOP_LAYER, "id_sharetree");
if (ep == NULL) {
answer_list_add(alpp, MSG_OBJ_NOSTREEELEM, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(false);
}
lSetUlong(ep, STN_id, my_id++);
/* handle the children */
for_each(cep, lGetList(ep, STN_children)) {
if (false == id_sharetree(NULL, cep, my_id, &my_id)) {
DRETURN(false);
}
}
if (ret_id) {
*ret_id = my_id;
}
DRETURN(true);
}
bool
cqueue_verify_shell_start_mode(lListElem *cqueue, lList **answer_list,
lListElem *attr_elem)
{
bool ret = true;
DENTER(CQUEUE_VERIFY_LAYER, "cqueue_verify_shell_start_mode");
if (cqueue != NULL && attr_elem != NULL) {
const char *names[] = {
"unix_behavior", "posix_compliant", "script_from_stdin",
NULL
};
const char *name = lGetString(attr_elem, ASTR_value);
bool found = false;
int i = 0;
while (names[i] != NULL) {
if (!strcasecmp(name, names[i])) {
found = true;
}
i++;
}
if (!found) {
sprintf(SGE_EVENT, MSG_CQUEUE_UNKNOWNSTARTMODE_S, name);
answer_list_add(answer_list, SGE_EVENT,
STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
ret = false;
}
}
DEXIT;
return ret;
}
bool cuser_modify_from_file(sge_gdi_ctx_class_t *ctx, lList **answer_list, const char *filename)
{
bool ret = true;
DENTER(TOP_LAYER, "cuser_modify_from_file");
if (filename != NULL) {
lListElem *cuser;
cuser = cull_read_in_ume(NULL, filename, 1, 0, 0, NULL);
if (cuser == NULL) {
sprintf(SGE_EVENT, MSG_CUSER_FILENOTCORRECT_S, filename);
answer_list_add(answer_list, SGE_EVENT,
STATUS_ERROR1, ANSWER_QUALITY_ERROR);
ret = false;
}
if (ret) {
ret &= cuser_add_del_mod_via_gdi(ctx, cuser, answer_list, SGE_GDI_MOD);
}
if (cuser != NULL) {
lFreeElem(&cuser);
}
}
DRETURN(ret);
}
bool
cqueue_verify_initial_state(lListElem *cqueue, lList **answer_list,
lListElem *attr_elem)
{
bool ret = true;
DENTER(CQUEUE_VERIFY_LAYER, "cqueue_verify_initial_state");
if (cqueue != NULL && attr_elem != NULL) {
const char *names[] = {"default", "enabled", "disabled", NULL};
const char *name = lGetString(attr_elem, ASTR_value);
bool found = false;
int i = 0;
while (names[i] != NULL) {
if (!strcasecmp(name, names[i])) {
found = true;
}
i++;
}
if (!found) {
sprintf(SGE_EVENT, MSG_CQUEUE_UNKNOWNINITSTATE_S, name);
answer_list_add(answer_list, SGE_EVENT,
STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
ret = false;
}
}
DEXIT;
return ret;
}
bool cuser_modify(sge_gdi_ctx_class_t *ctx, lList **answer_list, const char *name)
{
bool ret = true;
DENTER(TOP_LAYER, "cuser_modify");
if (name != NULL) {
lListElem *cuser = cuser_get_via_gdi(ctx, answer_list, name);
if (cuser == NULL) {
sprintf(SGE_EVENT, MSG_CUSER_DOESNOTEXIST_S, name);
answer_list_add(answer_list, SGE_EVENT,
STATUS_ERROR1, ANSWER_QUALITY_ERROR);
ret = false;
}
if (ret) {
ret &= cuser_provide_modify_context(ctx, &cuser, answer_list);
}
if (ret) {
ret &= cuser_add_del_mod_via_gdi(ctx, cuser, answer_list, SGE_GDI_MOD);
}
if (cuser) {
lFreeElem(&cuser);
}
}
DRETURN(ret);
}
/****** qmaster/threads/sge_scheduler_terminate() ****************************
* NAME
* sge_scheduler_terminate() -- terminate the scheduler
*
* SYNOPSIS
* void sge_scheduler_terminate(sge_gdi_ctx_class_t *ctx)
*
* FUNCTION
* Terminates the scheduler if it was started previousely. This
* function will return only when it is sure that the pthread canceled.
*
* 'Master_Scheduler' is accessed by this function.
*
* INPUTS
* sge_gdi_ctx_class_t *ctx - context object
* lList **answer_list - answer list
*
* RESULT
* void - None
*
* NOTES
* MT-NOTE: sge_scheduler_terminate() is MT safe
*
* SEE ALSO
* qmaster/threads/sge_scheduler_initialize()
* qmaster/threads/sge_scheduler_cleanup_thread()
* qmaster/threads/sge_scheduler_terminate()
* qmaster/threads/sge_scheduler_main()
*******************************************************************************/
void
sge_scheduler_terminate(sge_gdi_ctx_class_t *ctx, lList **answer_list)
{
DENTER(TOP_LAYER, "sge_scheduler_terminate");
sge_mutex_lock("master scheduler struct", SGE_FUNC, __LINE__, &(Master_Scheduler.mutex));
if (Master_Scheduler.is_running) {
pthread_t thread_id;
cl_thread_settings_t* thread = NULL;
/*
* store thread id to use it later on
*/
thread = cl_thread_list_get_first_thread(Main_Control.scheduler_thread_pool);
thread_id = *(thread->thread_pointer);
/*
* send cancel signal
*/
pthread_cancel(thread_id);
/*
* wakeup scheduler thread which might be blocked by wait for events
*/
pthread_cond_signal(&Scheduler_Control.cond_var);
/*
* cl_thread deletion and cl_thread_pool deletion will be done at
* schedulers cancelation point in sge_scheduler_cleanup_thread() ...
* ... therefore we have nothing more to do.
*/
;
sge_mutex_unlock("master scheduler struct", SGE_FUNC, __LINE__, &(Master_Scheduler.mutex));
INFO((SGE_EVENT, MSG_THREAD_XTERMINATED_S, threadnames[SCHEDD_THREAD]));
answer_list_add(answer_list, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_INFO);
} else {
sge_mutex_unlock("master scheduler struct", SGE_FUNC, __LINE__, &(Master_Scheduler.mutex));
ERROR((SGE_EVENT, MSG_THREAD_XNOTRUNNING_S, threadnames[SCHEDD_THREAD]));
answer_list_add(answer_list, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
}
DRETURN_VOID;
}
/****** 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 bool
cqueue_add_qinstances(sge_gdi_ctx_class_t *ctx, lListElem *cqueue, lList **answer_list, lList *add_hosts, monitoring_t *monitor)
{
bool ret = true;
DENTER(TOP_LAYER, "cqueue_add_qinstances");
if (cqueue != NULL && add_hosts != NULL) {
lListElem *href = NULL;
for_each(href, add_hosts) {
const char *hostname = lGetHost(href, HR_name);
lList *list = lGetList(cqueue, CQ_qinstances);
lListElem* qinstance = lGetElemHost(list, QU_qhostname, hostname);
if (qinstance != NULL) {
if (qinstance_state_is_orphaned(qinstance)) {
sge_qmaster_qinstance_state_set_orphaned(qinstance, false);
lSetUlong(qinstance, QU_tag, SGE_QI_TAG_MOD);
} else {
/*
* We might already have this QI if it is in orphaned state.
* If this is not true, than there is a bug!
*/
ERROR((SGE_EVENT, MSG_QINSTANCE_QIALREADYHERE_S, hostname));
answer_list_add(answer_list, SGE_EVENT, STATUS_ESYNTAX,
ANSWER_QUALITY_ERROR);
}
} else {
bool is_ambiguous = false;
if (list == NULL) {
list = lCreateList("", QU_Type);
lSetList(cqueue, CQ_qinstances, list);
}
qinstance = qinstance_create(ctx,
cqueue, answer_list,
hostname, &is_ambiguous, monitor);
if (is_ambiguous) {
DPRINTF(("qinstance %s has ambiguous conf\n", hostname));
}
lSetUlong(qinstance, QU_tag, SGE_QI_TAG_ADD);
lAppendElem(list, qinstance);
}
}
}
/****** sge_userset/userset_list_validate_access() *****************************
* NAME
* userset_list_validate_access() -- all user sets names in list must exist
*
* SYNOPSIS
* int userset_list_validate_access(lList *acl_list, int nm, lList **alpp)
*
* FUNCTION
* All the user set names in the acl_list must be defined in the qmaster
* user set lists. The user set is diferentiated from user names by @ sign
*
* INPUTS
* lList *acl_list - the acl list to check
* int nm - field name
* lList **alpp - answer list pointer
*
* RESULT
* int - STATUS_OK if no error, STATUS_EUNKNOWN otherwise
*
* NOTES
* MT-NOTE: userset_list_validate_access() is not MT safe
*
*******************************************************************************/
int userset_list_validate_access(lList *acl_list, int nm, lList **alpp)
{
lListElem *usp;
char *user;
DENTER(TOP_LAYER, "userset_list_validate_access");
for_each (usp, acl_list) {
user = (char *) lGetString(usp, nm);
if (is_hgroup_name(user) == true){
user++; /* jump ower the @ sign */
if (!lGetElemStr(*object_type_get_master_list(SGE_TYPE_USERSET), US_name, user)) {
ERROR((SGE_EVENT, MSG_CQUEUE_UNKNOWNUSERSET_S, user ? user : "******"));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
}
}
/****** sgeobj/userset/userset_list_validate_acl_list() ***********************
* NAME
* userset_list_validate_acl_list() -- validate an acl list
*
* SYNOPSIS
* int
* userset_list_validate_acl_list(lList *acl_list, lList **alpp)
*
* FUNCTION
* Checks if all entries of an acl list (e.g. user list of a pe)
* are contained in the master userset list.
*
* INPUTS
* lList *acl_list - the acl list to check
* lList **alpp - answer list pointer
*
* RESULT
* int - STATUS_OK, if everything is OK
*******************************************************************************/
int
userset_list_validate_acl_list(lList *acl_list, lList **alpp)
{
lListElem *usp;
DENTER(TOP_LAYER, "userset_list_validate_acl_list");
for_each (usp, acl_list) {
if (!lGetElemStr(*object_type_get_master_list(SGE_TYPE_USERSET), US_name, lGetString(usp, US_name))) {
ERROR((SGE_EVENT, MSG_CQUEUE_UNKNOWNUSERSET_S,
lGetString(usp, US_name) ? lGetString(usp, US_name) : "<NULL>"));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
}
DRETURN(STATUS_OK);
}
void sge_error_to_answer_list(sge_error_class_t *eh, lList **alpp, bool clear_errors) {
sge_error_iterator_class_t *iter = NULL;
if (eh == NULL || alpp == NULL) {
return;
}
iter = eh->iterator(eh);
while (iter && iter->next(iter)) {
answer_list_add(alpp,
iter->get_message(iter),
iter->get_type(iter),
(answer_quality_t)iter->get_quality(iter));
}
if (clear_errors) {
sge_error_class_clear(eh);
}
sge_error_iterator_class_destroy(&iter);
}
bool cuser_show(sge_gdi_ctx_class_t *ctx, lList **answer_list, const char *name)
{
bool ret = true;
DENTER(TOP_LAYER, "cuser_show");
if (name != NULL) {
lListElem *cuser = cuser_get_via_gdi(ctx, answer_list, name);
if (cuser != NULL) {
write_ume(0, 0, cuser);
lFreeElem(&cuser);
} else {
sprintf(SGE_EVENT, MSG_CUSER_DOESNOTEXIST_S, name);
answer_list_add(answer_list, SGE_EVENT,
STATUS_ERROR1, ANSWER_QUALITY_ERROR);
ret = false;
}
}
DRETURN(ret);
}
/****** sge_gdi_packet/sge_gdi_packet_verify_version() ************************
* NAME
* sge_gdi_packet_verify_version() -- verify packet version
*
* SYNOPSIS
* bool sge_gdi_packet_verify_version(sge_gdi_packet_class_t *packet,
* lList **alpp)
*
* FUNCTION
* This function is the replacement for the function
* verify_request_version() which was part of the source code
* before the packet structure was introduced.
*
* It compares the version information of the provided "packet"
* with the compiledin version number GRM_GDI_VERSION.
*
* If both versions are not the same then it tries to find
* if the client which provided us with this packet structure
* has a higer version number or the binary executing
* this function. In both cases the answer_list will
* be filled with an appropriate message.
*
* INPUTS
* sge_gdi_packet_class_t *packet - packet
* lList **alpp - answer list
*
* RESULT
* bool - error state
* true - same version
* false - differnet version numbers
*
* NOTES
* MT-NOTE: sge_gdi_packet_verify_version() is not MT safe
******************************************************************************/
bool
sge_gdi_packet_verify_version(sge_gdi_packet_class_t * packet, lList **alpp)
{
bool ret = true;
u_long32 version = packet->version;
DENTER(TOP_LAYER, "sge_gdi_packet_verify_version");
if (version != GRM_GDI_VERSION)
{
char *client_version = NULL;
dstring ds;
char buffer[256];
const vdict_t *vp;
const vdict_t *vdict = GRM_GDI_VERSION_ARRAY;
sge_dstring_init(&ds, buffer, sizeof(buffer));
for (vp = &vdict[0]; vp->version; vp++) {
if (version == vp->version) {
client_version = vp->release;
}
}
if (client_version) {
WARNING((SGE_EVENT, MSG_GDI_WRONG_GDI_SSISS, packet->host,
packet->commproc, (int)(packet->id), client_version,
feature_get_product_name(FS_VERSION, &ds)));
} else {
WARNING((SGE_EVENT, MSG_GDI_WRONG_GDI_SSIUS, packet->host,
packet->commproc, (int)(packet->id), sge_u32c(version),
feature_get_product_name(FS_VERSION, &ds)));
}
answer_list_add(alpp, SGE_EVENT, STATUS_EVERSION, ANSWER_QUALITY_ERROR);
ret = false;
}
DRETURN(ret);
}
int schedd_log(const char *logstr, lList **monitor_alpp, bool monitor_next_run)
{
DENTER(TOP_LAYER, "schedd_log");
if (monitor_alpp != NULL) {
/* add to answer list for verification (-w v) */
answer_list_add(monitor_alpp, logstr, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR);
}
if (monitor_next_run) {
/* do logging (-tsm) */
time_t now;
FILE *fp = NULL;
char *time_str = NULL;
char str[128];
now = (time_t)sge_get_gmt();
time_str = ctime_r(&now, str);
if (time_str[strlen(time_str) - 1] == '\n') {
time_str[strlen(time_str) - 1] = '|';
}
fp = fopen(schedd_log_file, "a");
if (!fp) {
DPRINTF(("could not open schedd_log_file "SFQ"\n", schedd_log_file));
DRETURN(-1);
}
fprintf(fp, "%s", time_str);
fprintf(fp, "%s\n", logstr);
FCLOSE(fp);
}
DRETURN(0);
FCLOSE_ERROR:
DPRINTF((MSG_FILE_NOCLOSE_SS, schedd_log_file, strerror(errno)));
DRETURN(-1);
}
/****** sge/opt/get_cwd_defaults_file_path() ***********************************
* NAME
* get_cwd_defaults_file_path() -- find cwd default file path
*
* SYNOPSIS
* char *get_cwd_defaults_file_path ()
*
* FUNCTION
* This function returns the path of the defaults file in the current working
* directory
*
* INPUTS
* lList* - answer list, AN_Type or NULL if everything ok
* possible errors:
* STATUS_ENOSUCHUSER - could not retrieve passwd info on me.user_name
* STATUS_EDISK - home directory for user is missing or cwd
* cannot be read or file could not be opened
* (is just a warning)
* STATUS_EEXIST - (parse_script_file), (is just a warning)
* STATUS_EUNKNOWN - (parse_script_file), error opening or
* reading from existing file, (is just a warning)
* plus all other error stati returned by
* parse_script_file, see there
* char * - cwd defaults file name with absolute path
*
* MT-NOTE: get_cwd_defaults_file_path() is MT safe
*******************************************************************************/
static char *get_cwd_defaults_file_path(lList **answer_list)
{
char cwd[SGE_PATH_MAX + 1];
char str[MAX_STRING_SIZE];
char *file = NULL;
DENTER (TOP_LAYER, "get_cwd_defaults_file_name");
if (!getcwd(cwd, sizeof(cwd))) {
snprintf(str, sizeof(str), SFNMAX, MSG_FILE_CANTREADCURRENTWORKINGDIR);
answer_list_add(answer_list, str, STATUS_EDISK, ANSWER_QUALITY_ERROR);
}
file = sge_malloc(strlen(cwd) + strlen(SGE_HOME_DEF_REQ_FILE) + 2);
strcpy(file, cwd);
if (*file && (file[strlen(file) - 1] != '/')) {
strcat(file, "/");
}
strcat(file, SGE_HOME_DEF_REQ_FILE);
DRETURN(file);
}
bool
cqueue_verify_calendar(lListElem *cqueue, lList **answer_list,
lListElem *attr_elem)
{
bool ret = true;
DENTER(CQUEUE_VERIFY_LAYER, "cqueue_verify_calendar");
if (cqueue != NULL && attr_elem != NULL) {
const char *name = lGetString(attr_elem, ASTR_value);
if (name != NULL && strcasecmp("none", name)) {
lListElem *calendar = calendar_list_locate(*object_type_get_master_list(SGE_TYPE_CALENDAR), name);
if (calendar == NULL) {
sprintf(SGE_EVENT, MSG_CQUEUE_UNKNOWNCALENDAR_S, name);
answer_list_add(answer_list, SGE_EVENT,
STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
ret = false;
}
}
}
DEXIT;
return ret;
}
/****** sgeobj/host/host_is_referenced() **************************************
* NAME
* host_is_referenced() -- Is a given host referenced in other objects?
*
* SYNOPSIS
* bool host_is_referenced(const lListElem *host,
* lList **answer_list,
* const lList *queue_list
* const lList *hgrp_list)
*
* FUNCTION
* This function returns true if the given "host" is referenced
* in a cqueue contained in "queue_list" or in a host group.
* If this is the case than a corresponding message will be added
* to the "answer_list".
*
* INPUTS
* const lListElem *host - EH_Type, AH_Type or SH_Type object
* lList **answer_list - AN_Type list
* const lList *queue_list - CQ_Type list
* const lList *hgrp_list - HGRP_Type list (Master list)
*
* RESULT
* int - true (1) or false (0)
******************************************************************************/
bool host_is_referenced(const lListElem *host,
lList **answer_list,
const lList *queue_list,
const lList *hgrp_list)
{
bool ret = false;
if (host != NULL) {
lListElem *cqueue = NULL;
lListElem *queue = NULL;
const char *hostname = NULL;
int nm = NoName;
if (object_has_type(host, EH_Type)) {
nm = object_get_primary_key(EH_Type);
} else if (object_has_type(host, AH_Type)) {
nm = object_get_primary_key(AH_Type);
} else if (object_has_type(host, SH_Type)) {
nm = object_get_primary_key(SH_Type);
}
hostname = lGetHost(host, nm);
/* look at all the queue instances and figure out, if one still references
the host we are looking for */
for_each(cqueue, queue_list) {
queue = lGetSubHost(cqueue, QU_qhostname, hostname, CQ_qinstances);
if (queue != NULL) {
const char *queuename = lGetString(cqueue, CQ_name);
sprintf(SGE_EVENT, MSG_HOSTREFINQUEUE_SS, hostname, queuename);
answer_list_add(answer_list, SGE_EVENT, STATUS_EUNKNOWN,
ANSWER_QUALITY_ERROR);
ret = true;
break;
}
}
bool
cqueue_verify_shell(lListElem *cqueue, lList **answer_list,
lListElem *attr_elem)
{
bool ret = true;
bool path_found = true;
const char *name = lGetString(attr_elem, ASTR_value);
DENTER(CQUEUE_VERIFY_LAYER, "cqueue_verify_shell");
/* Check also if it is an absolute valid path */
path_found = path_verify(name, answer_list, "shell", true);
if (!path_found) {
sprintf(SGE_EVENT, MSG_CQUEUE_UNKNOWNSHELL_S, name);
answer_list_add(answer_list, SGE_EVENT,
STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
ret = false;
}
DEXIT;
return ret;
}
bool switch_list_showq_parse_from_cmdline_tacc(lList **ppcmdline,
lList **answer_list,
char **argv)
{
char **sp;
char **rp;
stringT str;
DENTER(TOP_LAYER, "sge_parse_cmdline_qstat");
rp = argv;
while(*(sp=rp)) {
/* --help */
if ((rp = parse_noopt(sp, "--help", NULL, ppcmdline, answer_list)) != sp)
continue;
if ((rp = parse_noopt(sp, "-u", NULL, ppcmdline, answer_list)) != sp)
continue;
if ((rp = parse_noopt(sp, "-l", NULL, ppcmdline, answer_list)) != sp)
continue;
if ((rp = parse_noopt(sp, "-cb", NULL, ppcmdline, answer_list)) != sp)
continue;
if ((rp = parse_until_next_opt(sp, "-U", NULL, ppcmdline, answer_list)) != sp)
continue;
if ((rp = parse_until_next_opt(sp, "-sfa", NULL, ppcmdline, answer_list)) != sp)
continue;
if ((rp = parse_until_next_opt(sp, "-sfw", NULL, ppcmdline, answer_list)) != sp)
continue;
/* oops */
sprintf(str, MSG_ANSWER_INVALIDOPTIONARGX_S, *sp);
showq_usage(stderr);
answer_list_add(answer_list, str, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR);
DRETURN(true);
}
DRETURN(false);
}
/****** sge_utility/verify_str_key() *******************************************
* NAME
* verify_str_key() -- Generic function for verifying object names
*
* SYNOPSIS
* an_status_t verify_str_key(lList **alpp, const char *str, size_t
* str_length, const char *name, int table)
*
* FUNCTION
* Verifies object names. The follwing verification tables are
* used
*
* QSUB_TABLE job account strings
* (see qsub(1) -A for characters not allowed)
* QSUB_TABLE job name
* (see qsub(1) -N for characters not allowed)
* KEY_TABLE parallel environemnt names
* (see sge_pe(5))
* KEY_TABLE calendar names
* (see calendar_conf(5))
* KEY_TABLE cluster queue names
* (see queue_conf(5))
* KEY_TABLE project names
* (see project(5))
* KEY_TABLE userset names
* (see access_list(5))
* KEY_TABLE department names
* (see access_list(5))
* KEY_TABLE checkpoint interface name
* (see checkpoint(5))
* KEY_TABLE user name
* (see user(5))
* KEY_TABLE hostgroup names
* (see hostgroup(5))
*
* KEY_TABLE event client name (internal purposes only)
* KEY_TABLE JAPI session key (internal purposes only)
*
* Note, there is test_sge_utility
*
* INPUTS
* lList **alpp - answer list
* const char *str - string to be verified
* size_t str_length - length of the string to be verified
* const char *name - verbal description of the object
* int table - verification table to be used
*
* RESULT
* an_status_t - STATUS_OK upon success
*
* NOTES
* MT-NOTE: verify_str_key() is MT safe
*
* SEE ALSO
* There is a module test (test_sge_utility) for verify_str_key().
*******************************************************************************/
an_status_t verify_str_key(
lList **alpp, const char *str, size_t str_length, const char *name, int table)
{
static const char *begin_strings[2][3];
static const char *mid_strings[2][20];
static char begin_chars[2][3] =
{ { '.', '#', 0 },
{ 0, 0, 0 } };
static const char mid_characters[2][20] =
{ { '\n', '\t', '\r', ' ', '/', ':', '\'', '\"', '\\', '[', ']', '{', '}', '|', '(', ')', '@', '%', ',', 0}, /* KEY_TABLE */
{ '\n', '\t', '\r', '/', ':', '@', '\\', '*', '?', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} }; /* QSUB_TABLE */
static const char* keyword[] = { "NONE", "ALL", "TEMPLATE", NULL };
static const char* keyword_strings[4];
static int initialized = 0;
char forbidden_char;
const char* forbidden_string;
int i;
table = table -1;
if (!initialized) {
begin_strings[0][0] = MSG_GDI_KEYSTR_DOT;
begin_strings[0][1] = MSG_GDI_KEYSTR_HASH;
begin_strings[0][2] = NULL;
begin_strings[1][0] = NULL;
begin_strings[1][1] = NULL;
begin_strings[1][2] = NULL;
mid_strings[0][0] = MSG_GDI_KEYSTR_RETURN;
mid_strings[0][1] = MSG_GDI_KEYSTR_TABULATOR;
mid_strings[0][2] = MSG_GDI_KEYSTR_CARRIAGERET;
mid_strings[0][3] = MSG_GDI_KEYSTR_SPACE;
mid_strings[0][4] = MSG_GDI_KEYSTR_SLASH;
mid_strings[0][5] = MSG_GDI_KEYSTR_COLON;
mid_strings[0][6] = MSG_GDI_KEYSTR_QUOTE;
mid_strings[0][7] = MSG_GDI_KEYSTR_DBLQUOTE;
mid_strings[0][8] = MSG_GDI_KEYSTR_BACKSLASH;
mid_strings[0][9] = MSG_GDI_KEYSTR_BRACKETS;
mid_strings[0][10] = MSG_GDI_KEYSTR_BRACKETS;
mid_strings[0][11] = MSG_GDI_KEYSTR_BRACES;
mid_strings[0][12] = MSG_GDI_KEYSTR_BRACES;
mid_strings[0][13] = MSG_GDI_KEYSTR_PIPE;
mid_strings[0][14] = MSG_GDI_KEYSTR_PARENTHESIS;
mid_strings[0][15] = MSG_GDI_KEYSTR_PARENTHESIS;
mid_strings[0][16] = MSG_GDI_KEYSTR_AT;
mid_strings[0][17] = MSG_GDI_KEYSTR_PERCENT;
mid_strings[0][18] = MSG_GDI_KEYSTR_COMMA;
mid_strings[0][19] = NULL;
mid_strings[1][0] = MSG_GDI_KEYSTR_RETURN;
mid_strings[1][1] = MSG_GDI_KEYSTR_TABULATOR;
mid_strings[1][2] = MSG_GDI_KEYSTR_CARRIAGERET;
mid_strings[1][3] = MSG_GDI_KEYSTR_SLASH;
mid_strings[1][4] = MSG_GDI_KEYSTR_COLON;
mid_strings[1][5] = MSG_GDI_KEYSTR_AT;
mid_strings[1][6] = MSG_GDI_KEYSTR_BACKSLASH;
mid_strings[1][7] = MSG_GDI_KEYSTR_ASTERISK;
mid_strings[1][8] = MSG_GDI_KEYSTR_QUESTIONMARK;
mid_strings[1][9] = NULL;
keyword_strings[0] = MSG_GDI_KEYSTR_KEYWORD;
keyword_strings[1] = MSG_GDI_KEYSTR_KEYWORD;
keyword_strings[2] = MSG_GDI_KEYSTR_KEYWORD;
keyword_strings[3] = NULL;
initialized = 1;
}
if (str == NULL) {
SGE_ADD_MSG_ID(sprintf(SGE_EVENT, MSG_GDI_KEYSTR_NULL_S, name));
answer_list_add(alpp, SGE_EVENT, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
return STATUS_EUNKNOWN;
}
/* check string length first, if too long -> error */
if (strlen(str) > str_length) {
SGE_ADD_MSG_ID(sprintf(SGE_EVENT, MSG_GDI_KEYSTR_LENGTH_U, sge_u32c(str_length)));
answer_list_add(alpp, SGE_EVENT, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
return STATUS_EUNKNOWN;
}
/* check first character */
i = -1;
while ((forbidden_char = begin_chars[table][++i])) {
if (str[0] == forbidden_char) {
if (isprint((int) forbidden_char)) {
SGE_ADD_MSG_ID(sprintf(SGE_EVENT, MSG_GDI_KEYSTR_FIRSTCHAR_SC,
begin_strings[table][i], begin_chars[table][i]));
} else {
SGE_ADD_MSG_ID(sprintf(SGE_EVENT, MSG_GDI_KEYSTR_FIRSTCHAR_S,
begin_strings[table][i]));
}
answer_list_add(alpp, SGE_EVENT, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
return STATUS_EUNKNOWN;
}
}
/* check all characters in str */
i = -1;
while ((forbidden_char = mid_characters[table][++i])) {
if (strchr(str, forbidden_char)) {
if (isprint((int) forbidden_char)) {
SGE_ADD_MSG_ID(sprintf(SGE_EVENT, MSG_GDI_KEYSTR_MIDCHAR_SC,
mid_strings[table][i], mid_characters[table][i]));
} else {
SGE_ADD_MSG_ID(sprintf(SGE_EVENT, MSG_GDI_KEYSTR_MIDCHAR_S,
mid_strings[table][i]));
}
answer_list_add(alpp, SGE_EVENT, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
return STATUS_EUNKNOWN;
}
}
/* reject invalid keywords */
i = -1;
while ((forbidden_string = keyword[++i])) {
if (!strcasecmp(str, forbidden_string)) {
SGE_ADD_MSG_ID(sprintf(SGE_EVENT, MSG_GDI_KEYSTR_KEYWORD_SS,
keyword_strings[i],
forbidden_string));
answer_list_add(alpp, SGE_EVENT, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
return STATUS_EUNKNOWN;
}
}
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);
}
/****** sge/opt/append_opts_from_default_files() *******************************
* NAME
* append_opts_from_default_files() -- parse default files
*
* SYNOPSIS
* void append_opts_from_default_files(lList **pcmdline,
* lList **answer_list
* char **envp,
* char *def_files)
*
* FUNCTION
* This function reads the defaults files pointed to by def_files[] if they
* exist and parses them into an options list.
*
* INPUTS
* lList **pcmdline - pointer to SPA_Type list, if list is NULL, it is
* created if the files contain any options
* lList* - answer list, AN_Type or NULL if everything ok
* possible errors:
* STATUS_ENOSUCHUSER - could not retrieve passwd info on me.user_name
* STATUS_EDISK - home directory for user is missing or cwd
* cannot be read or file could not be opened
* (is just a warning)
* STATUS_EEXIST - (parse_script_file), (is just a warning)
* STATUS_EUNKNOWN - (parse_script_file), error opening or
* reading from existing file, (is just a warning)
* plus all other error stati returned by
* parse_script_file, see there
* char **envp - environment pointer
* char **def_files - paths to default files
*
*******************************************************************************/
static void append_opts_from_default_files(u_long32 prog_number,
lList **pcmdline,
lList **answer_list,
char **envp,
char **def_files)
{
lList *alp;
lListElem *aep;
char **pstr;
char **ppstr;
SGE_STRUCT_STAT buf;
int do_exit = 0;
DENTER(TOP_LAYER, "append_opts_from_default_files");
for (pstr = def_files; *pstr; pstr++) {
int already_read;
if (SGE_STAT(*pstr, &buf)<0) {
DPRINTF(("-- defaults file %s does not exist\n", *pstr));
continue;
}
already_read = 0;
for (ppstr = def_files; *ppstr != *pstr; ppstr++) {
if (!sge_filecmp(*ppstr, *pstr)) {
DPRINTF(("-- skipping %s as defaults file - already read as %s\n",
*pstr, *ppstr));
already_read = 1;
break;
}
}
if (already_read) {
continue;
}
DPRINTF(("-- defaults file: %s\n", *pstr));
alp = parse_script_file(prog_number, *pstr, "", pcmdline, envp,
FLG_HIGHER_PRIOR | FLG_USE_NO_PSEUDOS);
for_each(aep, alp) {
u_long32 status;
answer_quality_t quality;
status = lGetUlong(aep, AN_status);
quality = (answer_quality_t)lGetUlong(aep, AN_quality);
if (quality == ANSWER_QUALITY_ERROR) {
DPRINTF(("%s", lGetString(aep, AN_text)));
if (status == STATUS_EDISK) {
/*
** we turn this error into a warning here
*/
quality = ANSWER_QUALITY_WARNING;
} else {
do_exit = 1;
}
} else {
DPRINTF(("Warning: Error: %s\n", lGetString(aep, AN_text)));
}
answer_list_add(answer_list, lGetString(aep, AN_text), status,
quality);
}
lFreeList(&alp);
if (do_exit) {
for (pstr = def_files; *pstr; pstr++) {
sge_free(pstr);
}
DRETURN_VOID;
}
}
/* ------------------------------------------------------------
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;
}
/****** gdi/request_internal/sge_gdi_packet_pack_task() **********************
* NAME
* sge_gdi_packet_pack_task() -- pack a single GDI task
*
* SYNOPSIS
* bool
* sge_gdi_packet_pack_task(sge_gdi_packet_class_t * packet,
* sge_gdi_task_class_t * task,
* lList **answer_list,
* sge_pack_buffer *pb)
*
* FUNCTION
* This functions packs all data representing one GDI request
* of a mutli GDI request (represented by "packet" and "task")
* into "pb". Errors will be reported with a corresponding
* "answer_list" message and a negative return value.
*
* "pb" has to be initialized before this function is called.
* init_packbuffer() or a similar function has do be used to
* initialize this "pb". The function sge_gdi_packet_get_pb_size()
* might be used to calculate the maximum size as if the buffer
* would be needed to pack all tasks of a multi GDI request.
* Using this size as initial size for the "pb"
* will prevent continuous reallocation of memory in this
* function.
*
* INPUTS
* sge_gdi_packet_class_t * packet - GDI packet
* sge_gdi_task_class_t * task - GDI task
* lList **answer_list - answer_list
* sge_pack_buffer *pb - packing buffer
*
* RESULT
* bool - error state
* true - success
* false - failure
*
* NOTES
* MT-NOTE: sge_gdi_packet_pack_task() is MT safe
*
* SEE ALSO
* gdi/request_internal/sge_gdi_packet_get_pb_size()
* gdi/request_internal/sge_gdi_packet_pack()
*******************************************************************************/
bool
sge_gdi_packet_pack_task(sge_gdi_packet_class_t *packet,
sge_gdi_task_class_t *task, lList **answer_list,
sge_pack_buffer *pb)
{
bool ret = true;
int pack_ret = PACK_SUCCESS;
DENTER(TOP_LAYER, "sge_gdi_packet_pack_task");
if ((task != NULL) && (packet != NULL)
&& (packet->is_intern_request == false)) {
sge_pack_gdi_info(task->command);
/* ===> pack the prefix */
pack_ret = packint(pb, task->command);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = packint(pb, task->target);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = packint(pb, packet->version);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
/*
* if the lSelect call was postponed then it will be done here.
* here we are able to pack the result list directly into the packbuffer.
* additionally it is necessary to add an answer to the answer list.
* (which will be packed below).
*/
if (task->do_select_pack_simultaneous) {
lSelectHashPack("", task->data_list, task->condition,
task->enumeration, false, pb);
lFreeWhat(&(task->enumeration));
lFreeWhere(&(task->condition));
task->data_list = NULL;
/* DIRTY HACK: The "ok" message should be removed from the answer list
* 05/21/2007 qualitiy was ANSWER_QUALITY_INFO but this results in "ok"
* messages on qconf side */
answer_list_add(&(task->answer_list), MSG_GDI_OKNL, STATUS_OK,
ANSWER_QUALITY_END);
} else {
/* ===> pack the list */
pack_ret = cull_pack_list(pb, task->data_list);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
}
/* ===> pack the suffix */
pack_ret = cull_pack_list(pb, task->answer_list);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = cull_pack_cond(pb, task->condition);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = cull_pack_enum(pb, task->enumeration);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = packstr(pb, packet->auth_info);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = packint(pb, task->id);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = packint(pb, packet->id);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = packint(pb, (task->next != NULL) ? 1 : 0);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
}
DRETURN(ret);
error_with_mapping:
ret = sge_gdi_map_pack_errors(pack_ret, answer_list);
DRETURN(ret);
}
