/**** **** sge_get_dirents **** **** Returns the entries of the specified directory **** (without . and ..) as lList of type ST_Type. **** The lList has to be freed from the caller. **** On any error, NULL is returned. ****/ lList *sge_get_dirents(const char *path) { lList *entries = NULL; DIR *cwd; SGE_STRUCT_DIRENT *dent; char dirent[SGE_PATH_MAX*2]; DENTER(TOP_LAYER, "sge_get_dirents"); cwd = opendir(path); if (cwd == (DIR *) 0) { ERROR((SGE_EVENT, MSG_FILE_CANTOPENDIRECTORYX_SS, path, strerror(errno))); return (NULL); } while (SGE_READDIR_R(cwd, (SGE_STRUCT_DIRENT *)dirent, &dent)==0 && dent!=NULL) { if (!dent->d_name) continue; if (!dent->d_name[0]) continue; if (strcmp(dent->d_name, "..") == 0 || strcmp(dent->d_name, ".") == 0) continue; lAddElemStr(&entries, ST_name, dent->d_name, ST_Type); } closedir(cwd); DRETURN(entries); }
/****** test_category/test_create_project() ************************************* * NAME * test_create_project() -- creates an project list with the passed project name * * SYNOPSIS * lList* test_create_project(const char *project) * * RESULT * lList* - NULL or valid project list * * NOTES * MT-NOTE: test_create_project() is not MT safe * *******************************************************************************/ static lList *test_create_project(const char *project) { lList *project_list = NULL; lListElem *prj; prj = lAddElemStr(&project_list, PR_name, project, PR_Type); lSetBool(prj, PR_consider_with_categories, true); return project_list; }
/****** sgeobj/usage/usage_list_set_double_usage() ****************************** * NAME * usage_list_set_double_usage() -- create/update a usage record * * SYNOPSIS * void * usage_list_set_double_usage(lList *usage_list, const char *name, * double value) * * FUNCTION * Updates the value of a usage record. If no usage record exists with the * given name in usage_list, a new record is created. * * INPUTS * lList *usage_list - list containing the usage record to update * const char *name - name of the usage record to update * double value - the new value * * NOTES * MT-NOTE: usage_list_set_double_usage() is MT safe * * SEE ALSO * sgeobj/usage/usage_list_set_ulong_usage() * sgeobj/usage/usage_list_get_ulong_usage() * sgeobj/usage/usage_list_get_double_usage() *******************************************************************************/ void usage_list_set_double_usage(lList *usage_list, const char *name, double value) { lListElem *ep = lGetElemStr(usage_list, UA_name, name); if (ep == NULL) { ep = lAddElemStr(&usage_list, UA_name, name, UA_Type); } lSetDouble(ep, UA_value, value); }
int main(int argc, char **argv) { /* lListElem *rep, *nxt_rep, *jep, *aep, *jrep, *idep; */ int ret = 0; lListElem *aep, *idep; lList *jlp = NULL, *alp = NULL, *pcmdline = NULL, *ref_list = NULL, *user_list=NULL; u_long32 force = 0; int wait; unsigned long status = 0; bool have_master_privileges; cl_com_handle_t* handle = NULL; sge_gdi_ctx_class_t *ctx = NULL; DENTER_MAIN(TOP_LAYER, "qdel"); log_state_set_log_gui(1); if (sge_gdi2_setup(&ctx, QDEL, MAIN_THREAD, &alp) != AE_OK) { answer_list_output(&alp); goto error_exit; } if (!sge_parse_cmdline_qdel(++argv, environ, &pcmdline, &alp)) { /* ** high level parsing error! show answer list */ answer_list_output(&alp); lFreeList(&pcmdline); goto error_exit; } if (!sge_parse_qdel(&pcmdline, &ref_list, &force, &user_list, &alp)) { /* ** low level parsing error! show answer list */ answer_list_output(&alp); lFreeList(&pcmdline); goto error_exit; } DPRINTF(("force = "sge_u32"\n", force)); if (user_list) { lListElem *id; if (lGetNumberOfElem(ref_list) == 0){ id = lAddElemStr(&ref_list, ID_str, "0", ID_Type); lSetList(id, ID_user_list, user_list); } else { for_each(id, ref_list){ lSetList(id, ID_user_list, user_list); } } }
/****** sgeobj/suser/suser_list_add() ***************************************** * NAME * suser_list_add() -- Add a new entry (uniq) entry into a list * * SYNOPSIS * lListElem* suser_list_add(lList **suser_list, lList **answer_list, * const char *suser_name) * * FUNCTION * This function creates a new CULL element for the user "susername" * into the "suser_list". The newly created element will be returned. * If an element for this user already exists than this element will * be returned. * * INPUTS * lList **suser_list - SU_Type list * lList **answer_list - AN_Type list * const char *suser_name - username * * RESULT * lListElem* - SU_Type element or NULL * * SEE ALSO * sgeobj/suser/SU_Type * sgeobj/suser/Master_SUser_List ******************************************************************************/ lListElem *suser_list_add(lList **suser_list, lList **answer_list, const char *suser_name) { lListElem *ret = NULL; if (suser_list != NULL) { ret = suser_list_find(*suser_list, suser_name); if (ret == NULL) { ret = lAddElemStr(suser_list, SU_name, suser_name, SU_Type); } } return ret; }
/****** sgeobj/var/var_list_set_string() ************************************** * NAME * var_list_set_string -- add/change an variable * * SYNOPSIS * void var_list_set_string(lList **varl, * const char *name, * const char *value); * * FUNCTION * If the variable <name> does not already exist in <varl>, * it is created and initialized with <value>. * Otherwise, its value is overwritten with <value> * * INPUTS * lList **varl - VA_Type list * const char *name - the name of the variable * const char *value - the (new) value of the variable * * SEE ALSO * sgeobj/var/var_list_set_int() * sgeobj/var/var_list_set_sge_u32() * sgeobj/var/var_list_set_sharedlib_path() ******************************************************************************/ void var_list_set_string(lList **varl, const char *name, const char *value) { lListElem *elem; DENTER(TOP_LAYER, "var_list_set_string"); if (varl == NULL || name == NULL || value == NULL) { DEXIT; return; } elem = lGetElemStr(*varl, VA_variable, name); if (elem == NULL) { elem = lAddElemStr(varl, VA_variable, name, VA_Type); } lSetString(elem, VA_value, value); DEXIT; }
/****** sgeobj/var/var_list_set_sharedlib_path() ****************************** * NAME * var_list_set_sharedlib_path -- set shared lib path * * SYNOPSIS * void var_list_set_sharedlib_path(lList **varl); * * FUNCTION * Sets or replaces the shared lib path in the list of variables. * The SGE shared lib path is always set to the beginning of the * resulting shared lib path * (security, see var_get_sharedlib_path_name()) * * INPUTS * lList **varl - list of nment variables * * SEE ALSO * sgeobj/var/var_get_sharedlib_path_name() * sgeobj/var/var_list_set_string() * sgeobj/var/var_list_set_int() * sgeobj/var/var_list_set_sge_u32() ******************************************************************************/ void var_list_set_sharedlib_path(lList **varl) { char *sharedlib_path; char *sge_sharedlib_path; const char *sge_root = sge_get_root_dir(0, NULL, 0, 1); const char *sharedlib_path_name = var_get_sharedlib_path_name(); lListElem *sharedlib_elem = NULL; DENTER(TOP_LAYER, "set_sharedlib_path"); /* this is the SGE sharedlib path */ sge_sharedlib_path = sge_malloc(strlen(sge_root) + strlen("/lib/") + strlen(sge_get_arch()) + 1); sprintf(sge_sharedlib_path, "%s/lib/%s", sge_root, sge_get_arch()); /* if already in environment: extend by SGE sharedlib path, else set */ sharedlib_elem = lGetElemStr(*varl, VA_variable, sharedlib_path_name); if(sharedlib_elem != NULL) { const char *old_value = lGetString(sharedlib_elem, VA_value); if(old_value && strlen(old_value) > 0) { DPRINTF(("sharedlib path %s already set:\n", sharedlib_path_name)); sharedlib_path = sge_malloc(strlen(old_value) + 1 + strlen(sge_sharedlib_path) + 1); strcpy(sharedlib_path, sge_sharedlib_path); strcat(sharedlib_path, ":"); strcat(sharedlib_path, old_value); lSetString(sharedlib_elem, VA_value, sharedlib_path); sge_free(&sharedlib_path); } else { DPRINTF(("overwriting empty sharedlib path %s\n", sharedlib_path_name)); lSetString(sharedlib_elem, VA_value, sge_sharedlib_path); } } else { DPRINTF(("creating new sharedlib path %s\n", sharedlib_path_name)); sharedlib_elem = lAddElemStr(varl, VA_variable, sharedlib_path_name, VA_Type); lSetString(sharedlib_elem, VA_value, sge_sharedlib_path); } sge_free(&sge_sharedlib_path); DEXIT; }
/* ---------------------------------------- add a string value to the load report list lpp */ int sge_add_str2load_report(lList **lpp, const char *name, const char *value, const char *host) { lListElem *ep = NULL, *search_ep = NULL; const void *iterator = NULL; DENTER(BASIS_LAYER, "sge_add_str2load_report"); if (lpp == NULL || name == NULL || value == NULL || host == NULL) { DRETURN(-1); } if (*lpp != NULL) { search_ep = lGetElemHostFirst(*lpp, LR_host, host, &iterator); while (search_ep != NULL) { DPRINTF(("---> %s\n", lGetString(search_ep, LR_name))); if (strcmp(lGetString(search_ep, LR_name), name) == 0) { ep = search_ep; break; } search_ep = lGetElemHostNext(*lpp, LR_host, host, &iterator); } } if (ep == NULL) { DPRINTF(("adding new load variable %s for host %s\n", name, host)); ep = lAddElemStr(lpp, LR_name, name, LR_Type); lSetHost(ep, LR_host, host); lSetUlong(ep, LR_global, (u_long32)(strcmp(host, SGE_GLOBAL_NAME) == 0 ? 1 : 0)); lSetUlong(ep, LR_static, sge_is_static_load_value(name)); } lSetString(ep, LR_value, value); DPRINTF(("load value %s for host %s: %s\n", name, host, value)); DRETURN(0); }
/* ------------------------------------------------------------ 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/sge/sge_qexecve() ************************************************ * NAME * sge_qexecve() -- start a task in a tightly integrated par. job * * SYNOPSIS * sge_tid_t sge_qexecve(const char *hostname, const char *queuename, * const char *cwd, const lList *environment * const lList *path_aliases) * * FUNCTION * Starts a task in a tightly integrated job. * Builds a job object describing the task, * connects to the commd on the targeted execution host, * deliveres the job object and waits for an answer. * The answer from the execution daemon on the execution host * contains a task id that is returned to the caller of the function. * * INPUTS * const char *hostname - name of the host on which to start the task * const lList *environment - list containing environment variable * settings for the task that override the * default environment * const lList *path_aliases - optional a path alias list * * RESULT * sge_tid_t - the task id, if the task can be executed, * a value <= 0 indicates an error. * * NOTES * MT-NOTE: sge_qexecve() is not MT safe ******************************************************************************/ sge_tid_t sge_qexecve(sge_gdi_ctx_class_t *ctx, const char *hostname, const char *queuename, const char *cwd, const lList *environment, const lList *path_aliases) { char myname[256]; const char *s; int ret, uid; sge_tid_t tid = NULL; lListElem *petrep; lListElem *rt; sge_pack_buffer pb; u_long32 jobid, jataskid; u_long32 dummymid = 0; const char *env_var_name = "SGE_TASK_ID"; DENTER(TOP_LAYER, "sge_qexecve"); if (hostname == NULL) { sprintf(lasterror, MSG_GDI_INVALIDPARAMETER_SS, "sge_qexecve", "hostname"); DRETURN(NULL); } /* resolve user */ if (sge_uid2user((uid=getuid()), myname, sizeof(myname)-1, MAX_NIS_RETRIES)) { sprintf(lasterror, MSG_GDI_RESOLVINGUIDTOUSERNAMEFAILED_IS , uid, strerror(errno)); DRETURN(NULL); } if ((s=getenv("JOB_ID")) == NULL) { sprintf(lasterror, MSG_GDI_MISSINGINENVIRONMENT_S, "JOB_ID"); DRETURN(NULL); } if (sscanf(s, sge_u32, &jobid) != 1) { sprintf(lasterror, MSG_GDI_STRINGISINVALID_SS, s, "JOB_ID"); DRETURN(NULL); } if ((s=getenv(env_var_name)) != NULL) { if (strcmp(s, "undefined") == 0) { jataskid = 1; } else { if (sscanf(s, sge_u32, &jataskid) != 1) { sprintf(lasterror, MSG_GDI_STRINGISINVALID_SS, s, env_var_name); DRETURN(NULL); } } } else { sprintf(lasterror, MSG_GDI_MISSINGINENVIRONMENT_S, env_var_name); DRETURN(NULL); } /* ---- build up pe task request structure (see gdilib/sge_petaskL.h) */ petrep = lCreateElem(PETR_Type); lSetUlong(petrep, PETR_jobid, jobid); lSetUlong(petrep, PETR_jataskid, jataskid); lSetString(petrep, PETR_owner, myname); lSetUlong(petrep, PETR_submission_time, sge_get_gmt()); if (cwd != NULL) { lSetString(petrep, PETR_cwd, cwd); } if (environment != NULL) { lSetList(petrep, PETR_environment, lCopyList("environment", environment)); } if (path_aliases != NULL) { lSetList(petrep, PETR_path_aliases, lCopyList("path_aliases", path_aliases)); } if (queuename != NULL) { lSetString(petrep, PETR_queuename, queuename); } if (init_packbuffer(&pb, 1024, 0) != PACK_SUCCESS) { lFreeElem(&petrep); sprintf(lasterror, SFNMAX, MSG_GDI_OUTOFMEMORY); DRETURN(NULL); } pack_job_delivery(&pb, petrep); ret = gdi2_send_message_pb(ctx, 1, prognames[EXECD], 1, hostname, TAG_JOB_EXECUTION, &pb, &dummymid); clear_packbuffer(&pb); lFreeElem(&petrep); if (ret != CL_RETVAL_OK) { sprintf(lasterror, MSG_GDI_SENDTASKTOEXECDFAILED_SS, hostname, cl_get_error_text(ret)); DRETURN(NULL); } /* add list into our remote task list */ rt = lAddElemStr(&remote_task_list, RT_tid, "none", RT_Type); lSetHost(rt, RT_hostname, hostname); lSetUlong(rt, RT_state, RT_STATE_WAIT4ACK); rcv_from_execd(ctx, OPT_SYNCHRON, TAG_JOB_EXECUTION); tid = (sge_tid_t) lGetString(rt, RT_tid); if (strcmp(tid, "none") == 0) { tid = NULL; sprintf(lasterror, MSG_GDI_EXECDONHOSTDIDNTACCEPTTASK_S, hostname); } /* now close message to execd */ cl_commlib_shutdown_handle(cl_com_get_handle("execd_handle", 0), false); DRETURN(tid); }
lList *cull_unparse_job_parameter( sge_gdi_ctx_class_t *ctx, lList **pcmdline, lListElem *job, int flags ) { const char *cp; u_long32 ul; lList *answer = NULL; char str[1024 + 1]; lList *lp; int ret; lListElem *ep_opt; const char *username = ctx->get_username(ctx); const char *qualified_hostname = ctx->get_qualified_hostname(ctx); DENTER(TOP_LAYER, "cull_unparse_job_parameter"); /* ** -a ** problem with submission time, but that is not a good ** default option anyway, is not unparsed */ /* ** -A */ if (sge_unparse_account_string(job, pcmdline, &answer) != 0) { DEXIT; return answer; } /* ** -c */ if (sge_unparse_checkpoint_option(job, pcmdline, &answer) != 0) { DEXIT; return answer; } /* * -ckpt */ if (sge_unparse_string_option(job, JB_checkpoint_name, "-ckpt", pcmdline, &answer) != 0) { DEXIT; return answer; } /* ** -cwd */ if (lGetString(job, JB_cwd)) { ep_opt = sge_add_noarg(pcmdline, cwd_OPT, "-cwd", NULL); } /* * -P */ if (sge_unparse_string_option(job, JB_project, "-P", pcmdline, &answer) != 0) { DEXIT; return answer; } #if 0 /* ** -C */ if (sge_unparse_string_option(job, JB_directive_prefix, "-C", pcmdline, &answer) != 0) { DEXIT; return answer; } #endif /* ** -e */ if (sge_unparse_path_list(job, JB_stderr_path_list, "-e", pcmdline, &answer) != 0) { DEXIT; return answer; } /* ** -h, here only user hold supported at the moment */ if ((ul = lGetUlong(lFirst(lGetList(job, JB_ja_tasks)), JAT_hold))) { ep_opt = sge_add_noarg(pcmdline, h_OPT, "-h", NULL); } /* ** -hold_jid */ if ((lp = lGetList(job, JB_jid_request_list))) { int fields[] = { JRE_job_name, 0 }; const char *delis[] = {NULL, ",", NULL}; ret = uni_print_list(NULL, str, sizeof(str) - 1, lp, fields, delis, 0); if (ret) { DPRINTF(("Error %d formatting jid_request_list as -hold_jid\n", ret)); sprintf(str, MSG_LIST_ERRORFORMATINGJIDPREDECESSORLISTASHOLDJID); answer_list_add(&answer, str, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR); return answer; } ep_opt = sge_add_arg(pcmdline, hold_jid_OPT, lListT, "-hold_jid", str); lSetList(ep_opt, SPA_argval_lListT, lCopyList("hold_jid list", lp)); } /* ** -hold_jid_ad */ if ((lp = lGetList(job, JB_ja_ad_request_list))) { int fields[] = { JRE_job_name, 0 }; const char *delis[] = {NULL, ",", NULL}; ret = uni_print_list(NULL, str, sizeof(str) - 1, lp, fields, delis, 0); if (ret) { DPRINTF(("Error %d formatting ja_ad_request_list as -hold_jid_ad\n", ret)); sprintf(str, MSG_LIST_ERRORFORMATINGJIDPREDECESSORLISTASHOLDJIDAD); answer_list_add(&answer, str, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR); return answer; } ep_opt = sge_add_arg(pcmdline, hold_jid_ad_OPT, lListT, "-hold_jid_ad", str); lSetList(ep_opt, SPA_argval_lListT, lCopyList("hold_jid_ad list", lp)); } /* ** -i */ if (sge_unparse_path_list(job, JB_stdin_path_list, "-i", pcmdline, &answer) != 0) { DEXIT; return answer; } /* ** -j */ if ((ul = lGetBool(job, JB_merge_stderr))) { ep_opt = sge_add_arg(pcmdline, j_OPT, lIntT, "-j", "y"); lSetInt(ep_opt, SPA_argval_lIntT, true); } /* ** -jid */ if ((lp = lGetList(job, JB_job_identifier_list))) { int fields[] = { JRE_job_number, 0}; const char *delis[] = {"", ",", NULL}; ret = uni_print_list(NULL, str, sizeof(str) - 1, lp, fields, delis, 0); if (ret) { DPRINTF(("Error %d formatting job_identifier_list as -jid\n", ret)); sprintf(str, MSG_LIST_ERRORFORMATINGJOBIDENTIFIERLISTASJID); answer_list_add(&answer, str, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR); return answer; } ep_opt = sge_add_arg(pcmdline, jid_OPT, lListT, "-jid", str); lSetList(ep_opt, SPA_argval_lListT, lCopyList("jid list", lp)); } /* ** -js */ if ((ul = lGetUlong(job, JB_jobshare)) != 0) { sprintf(str, sge_u32, ul); ep_opt = sge_add_arg(pcmdline, js_OPT, lUlongT, "-js", str); lSetUlong(ep_opt, SPA_argval_lUlongT, ul); } /* ** -lj is in parsing but can't be unparsed here */ /* ** -l */ if (sge_unparse_resource_list(job, JB_hard_resource_list, pcmdline, &answer) != 0) { DEXIT; return answer; } if (sge_unparse_resource_list(job, JB_soft_resource_list, pcmdline, &answer) != 0) { DEXIT; return answer; } /* ** -m */ if ((ul = lGetUlong(job, JB_mail_options))) { cp = sge_unparse_mail_options(ul); if (!cp) { DPRINTF(("Error unparsing mail options\n")); sprintf(str, MSG_PARSE_ERRORUNPARSINGMAILOPTIONS); answer_list_add(&answer, str, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR); return answer; } ep_opt = sge_add_arg(pcmdline, m_OPT, lIntT, "-m", cp); lSetInt(ep_opt, SPA_argval_lIntT, ul); } /* ** -M obviously a problem!!! ** not unparsed at the moment ** does it make sense as a default, after all? */ if ((lp = lGetList(job, JB_mail_list))) { lList *lp_new = NULL; lListElem *ep_new = NULL; lListElem *ep = NULL; const char *host; const char *user; /* ** or rather take all if there are more than one elements? */ for_each(ep, lp) { user = lGetString(ep, MR_user); host = lGetHost(ep, MR_host); if (sge_strnullcmp(user, username) || sge_hostcmp(host, qualified_hostname)) { lp_new = lCreateList("mail list", MR_Type); ep_new = lAddElemStr(&lp_new, MR_user, user, MR_Type); lSetHost(ep_new, MR_host, host); } }
/******************************************************** ensure - all nodes have a unique path in share tree - a project is not referenced more than once in share tree - a user appears only once in a project sub-tree - a user appears only once outside of a project sub-tree - a user does not appear as a non-leaf node - all leaf nodes in a project sub-tree reference a known user object or the reserved name "default" - there are no sub-projects within a project sub-tree - all leaf nodes not in a project sub-tree reference a known user or project object - all user leaf nodes in a project sub-tree have access to the project ********************************************************/ int check_sharetree( lList **alpp, lListElem *node, lList *user_list, lList *project_list, lListElem *project, lList **found /* tmp list that contains one entry for each found u/p */ ) { lList *children; lListElem *child, *remaining; lList *save_found = NULL; const char *name = lGetString(node, STN_name); lListElem *pep; DENTER(TOP_LAYER, "check_sharetree"); /* Check for dangling or circular references. */ if (name == NULL) { ERROR((SGE_EVENT, MSG_STREE_NOVALIDNODEREF_U, sge_u32c(lGetUlong(node, STN_id)))); answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR); DEXIT; return -1; } if ((children=lGetList(node, STN_children))) { /* not a leaf node */ /* check if this is a project node */ if ((pep=prj_list_locate(project_list, name))) { /* check for sub-projects (not allowed) */ if (project) { ERROR((SGE_EVENT, MSG_STREE_PRJINPTJSUBTREE_SS, name, lGetString(project, PR_name))); answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR); DEXIT; return -1; } /* check for projects appearing more than once */ if (lGetElemStr(*found, STN_name, name)) { ERROR((SGE_EVENT, MSG_STREE_PRJTWICE_S, name)); answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR); DEXIT; return -1; } /* register that this project was found */ lAddElemStr(found, STN_name, name, STN_Type); /* set up for project sub-tree recursion */ project = pep; save_found = *found; *found = NULL; /* check for user appearing as non-leaf node */ } else if (user_list_locate(user_list, name)) { ERROR((SGE_EVENT, MSG_STREE_USERNONLEAF_S, name)); answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR); DEXIT; return -1; } for_each(child, children) { /* ensure pathes are identically inside share tree */ for (remaining=lNext(child); remaining; remaining=lNext(remaining)) { const char *cn = lGetString(child, STN_name); const char *rn = lGetString(remaining, STN_name); if (cn == NULL || rn == NULL) { ERROR((SGE_EVENT, MSG_GDI_KEYSTR_NULL_S, "STN_name")); answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR); /* restore old found list */ if (save_found) { lFreeList(found); *found = save_found; } DEXIT; return -1; } if (!strcmp(cn, rn)) { ERROR((SGE_EVENT, MSG_SGETEXT_FOUND_UP_TWICE_SS, cn, lGetString(node, STN_name))); answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR); /* restore old found list */ if (save_found) { lFreeList(found); *found = save_found; } DEXIT; return -1; } } if (check_sharetree(alpp, child, user_list, project_list, project, found)) { /* restore old found list */ if (save_found) { lFreeList(found); *found = save_found; } DEXIT; return -1; } } /* restore old found list */ if (save_found) { lFreeList(found); *found = save_found; } } else { /* a leaf node */ /* check if this is a project node */ if (prj_list_locate(project_list, name)) {
/* - -- -- -- -- -- -- -- -- -- -- -- -- -- - user_args - a cull list(UE_Type) of users acl_args - a cull list(US_Type) of acl returns 0 on success -1 on error */ int sge_client_add_user( sge_gdi_ctx_class_t *ctx, lList **alpp, lList *user_args, lList *acl_args ) { lListElem *userarg, *aclarg; lList *acl=NULL, *answers=NULL; const char *acl_name, *user_name; lCondition *where; lEnumeration *what; u_long32 status; int already; DENTER(TOP_LAYER, "sge_client_add_user"); what = lWhat("%T(ALL)", US_Type); for_each(aclarg,acl_args) { acl_name = lGetString(aclarg, US_name); where = lWhere("%T(%I==%s)", US_Type, US_name, acl_name); for_each(userarg, user_args) { already = 0; user_name=lGetString(userarg, UE_name); /* get old acl */ answers = ctx->gdi(ctx, SGE_US_LIST, SGE_GDI_GET, &acl, where, what, false); lFreeList(&answers); if (acl && lGetNumberOfElem(acl) > 0) { if (!lGetSubStr(lFirst(acl), UE_name, user_name, US_entries)) { lAddSubStr(lFirst(acl), UE_name, user_name, US_entries, UE_Type); /* mod the acl */ answers = ctx->gdi(ctx, SGE_US_LIST, SGE_GDI_MOD, &acl, NULL, NULL, false); } else { already = 1; } } else { /* build new list */ lAddElemStr(&acl, US_name, acl_name, US_Type); lAddSubStr(lFirst(acl), UE_name, user_name, US_entries, UE_Type); /* add the acl */ answers = ctx->gdi(ctx, SGE_US_LIST, SGE_GDI_ADD, &acl, NULL, NULL, false); } if (already) { status = STATUS_EEXIST; SGE_ADD_MSG_ID( sprintf(SGE_EVENT, MSG_GDI_USERINACL_SS, user_name, acl_name)); } else { if ((status = lGetUlong(lFirst(answers), AN_status))!=STATUS_OK) { const char *cp; cp = lGetString(lFirst(answers), AN_text); if (cp) { sprintf(SGE_EVENT, "%s", cp); } else { SGE_ADD_MSG_ID( sprintf(SGE_EVENT, MSG_GDI_CANTADDTOACL_SS, user_name, acl_name)); } } else { sprintf(SGE_EVENT, MSG_GDI_ADDTOACL_SS, user_name, acl_name); } lFreeList(&answers); } answer_list_add(alpp, SGE_EVENT, status, ((status == STATUS_OK) ? ANSWER_QUALITY_INFO : ANSWER_QUALITY_ERROR)); lFreeList(&acl); }
/*-------------------------------------------------------------------------*/ static void qmonUserAskForProject(Widget w, XtPointer cld, XtPointer cad) { XbaeMatrixLabelActivateCallbackStruct *cbs = (XbaeMatrixLabelActivateCallbackStruct *) cad; Boolean status = False; lList *pl = NULL; lListElem *cep = NULL; int n, i; StringConst *strs = NULL; static char buf[BUFSIZ]; lList *lp = NULL; lList *alp = NULL; lListElem *ep; static lEnumeration *what = NULL; DENTER(GUI_LAYER, "qmonUserAskForProject"); if (!what) { what = lWhat("%T(%I %I)", UU_Type, UU_name, UU_default_project); } if (cbs->column != 1) { DEXIT; return; } qmonMirrorMultiAnswer(PROJECT_T, &alp); if (alp) { qmonMessageBox(w, alp, 0); lFreeList(&alp); DEXIT; return; } pl = qmonMirrorList(SGE_PR_LIST); lPSortList(pl, "%I+", PR_name); n = lGetNumberOfElem(pl); if (n>0) { strs = (StringConst*)XtMalloc(sizeof(String)*(n+1)); strs[0] = "NONE"; for (cep=lFirst(pl), i=0; i<n; cep=lNext(cep), i++) { /* ** we get only references don't free, the strings */ strs[i+1] = lGetString(cep, PR_name); } strcpy(buf, ""); /* FIX_CONST_GUI */ status = XmtAskForItem(w, NULL, "@{Select a project}", "@{Available projects}", (String*)strs, n+1, False, buf, BUFSIZ, NULL); if (status) { int rows, i; rows = XbaeMatrixNumRows(user_matrix); for (i=0; i<rows; i++) { String s = XbaeMatrixGetCell(user_matrix, i, 0); if (XbaeMatrixIsRowSelected(user_matrix, i) && s && strcmp(s, "")) { ep = lAddElemStr(&lp, UU_name, s, UU_Type); lSetString(ep, UU_default_project, buf); } } XbaeMatrixDeselectAll(user_matrix); /* ** send to master as modify request */ for_each (ep, lp) { if (ep && lGetString(ep, UU_default_project) && !strcasecmp(lGetString(ep, UU_default_project), "NONE")) lSetString(ep, UU_default_project, NULL); } if (lp) { alp = qmonModList(SGE_UU_LIST, qmonMirrorListRef(SGE_UU_LIST), UU_name, &lp, NULL, what); qmonMessageBox(w, alp, 0); updateManopList(); lFreeList(&alp); lFreeList(&lp); } } /* ** don't free referenced strings, they are in the pl list */ XtFree((char*)strs); }
/*-------------------------------------------------------------------------*/ static void qmonUsersetOk(Widget w, XtPointer cld, XtPointer cad) { String usetname = NULL; XmString xusetname = NULL; lList *lp = NULL; lList *ul = NULL; lList *alp = NULL; lListElem *up = NULL; lEnumeration *what = NULL; Boolean status = False; int usettype = 0; DENTER(GUI_LAYER, "qmonUsersetOk"); /* ** get the dialog data and */ usetname = XmtInputFieldGetString(uset_name); usettype = XmtChooserGetState(uset_type); /* ** usetname required, show warning dialog */ if (usetname && usetname[0] != '\0') { ul = XmStringToCull(uset_user_list, UE_Type, UE_name, ALL_ITEMS); /* ** do gdi stuff here */ if (add_mode) { lAddElemStr(&lp, US_name, usetname, US_Type); } else { up = lCopyElem(lGetElemStr(qmonMirrorList(SGE_US_LIST), US_name, usetname)); lp = lCreateList("userset", US_Type); lAppendElem(lp, up); } lSetList(lFirst(lp), US_entries, ul); lSetUlong(lFirst(lp), US_type, usettype); what = lWhat("%T(ALL)", US_Type); if (add_mode) { alp = qmonAddList(SGE_US_LIST, qmonMirrorListRef(SGE_US_LIST), US_name, &lp, NULL, what); } else { alp = qmonModList(SGE_US_LIST, qmonMirrorListRef(SGE_US_LIST), US_name, &lp, NULL, what); } if (!qmonMessageBox(w, alp, 0)) status = True; updateUsersetList(); xusetname = XmtCreateXmString(usetname); XmListSelectItem(userset_names, xusetname, True); XmStringFree(xusetname); lFreeWhat(&what); lFreeList(&lp); lFreeList(&alp); } else { qmonMessageShow(w, True, "Userset List Name required !"); } if (status) XtUnmanageChild(userset_ask_layout); DEXIT; }
/*-------------------------------------------------------------------------*/ static void qmonManopDelete(Widget w, XtPointer cld, XtPointer cad) { int type = dialog_mode; lList *lp = NULL; lList *alp = NULL; lEnumeration *what = NULL; lDescr *dp; int nm; int rows, i; DENTER(GUI_LAYER, "qmonManopDelete"); switch (type) { case SGE_UM_LIST: lp = XmStringToCull(manager_list, UM_Type, UM_name, SELECTED_ITEMS); dp = UM_Type; nm = UM_name; break; case SGE_UO_LIST: lp = XmStringToCull(operator_list, UO_Type, UO_name, SELECTED_ITEMS); dp = UO_Type; nm = UO_name; break; case SGE_UU_LIST: rows = XbaeMatrixNumRows(user_matrix); for (i=0; i<rows; i++) { String s = XbaeMatrixGetCell(user_matrix, i, 0); if (XbaeMatrixIsRowSelected(user_matrix, i) && s && strcmp(s, "")) lAddElemStr(&lp, UU_name, s, UU_Type); } XbaeMatrixDeselectAll(user_matrix); dp = UU_Type; nm = UU_name; break; case SGE_US_LIST: qmonUsersetDelete(w, NULL, NULL); DEXIT; return; default: DEXIT; return; } if (lp) { what = lWhat("%T(ALL)", dp); alp = qmonDelList(type, qmonMirrorListRef(type), nm, &lp, NULL, what); qmonMessageBox(w, alp, 0); updateManopList(); lFreeList(&alp); lFreeList(&lp); lFreeWhat(&what); } DEXIT; }