/*___INFO__MARK_BEGIN__*/
/*************************************************************************
*
* The Contents of this file are made available subject to the terms of
* the Sun Industry Standards Source License Version 1.2
*
* Sun Microsystems Inc., March, 2001
*
*
* Sun Industry Standards Source License Version 1.2
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.2 (the "License"); You may not use this file
* except in compliance with the License. You may obtain a copy of the
* License at http://gridengine.sunsource.net/Gridengine_SISSL_license.html
*
* Software provided under this License is provided on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
*
* Copyright: 2001 by Sun Microsystems, Inc.
*
* All Rights Reserved.
*
************************************************************************/
/*___INFO__MARK_END__*/
/*
This is the module for handling the SGE sharetree
We save the sharetree to <spool>/qmaster/sharetree
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <limits.h>
#include "sge.h"
#include "sgermon.h"
#include "sge_usage.h"
#include "sge_sharetree.h"
#include "sge_sharetree_qmaster.h"
#include "sge_userprj_qmaster.h"
#include "cull_parse_util.h"
#include "sge_event_master.h"
#include "sge_log.h"
#include "sge_answer.h"
#include "sge_userprj.h"
#include "sge_persistence_qmaster.h"
#include "spool/sge_spooling.h"
#include "msg_common.h"
#include "msg_qmaster.h"
/************************************************************
sge_add_sharetree - Master code
Add the sharetree
************************************************************/
int sge_add_sharetree(
sge_gdi_ctx_class_t *ctx,
lListElem *ep,
lList **lpp, /* list to change */
lList **alpp,
char *ruser,
char *rhost
) {
int ret;
DENTER(TOP_LAYER, "sge_add_sharetree");
ret = sge_mod_sharetree(ctx, ep, lpp, alpp, ruser, rhost);
DEXIT;
return ret;
}
/************************************************************
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;
}
/************************************************************
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;
}
/********************************************************
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)) {
lSetUlong(node, STN_type, STT_PROJECT);
}
if (project) {
/* project set means this is a project sub-tree */
/* check for sub-projects */
if (prj_list_locate(project_list, name)) {
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;
}
/* leaf nodes of project sub-trees must be users */
if (!user_list_locate(user_list, name) &&
strcmp(name, "default")) {
ERROR((SGE_EVENT, MSG_SGETEXT_UNKNOWN_SHARE_TREE_REF_TO_SS, MSG_OBJ_USER, name));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DEXIT;
return -1;
}
/* make sure this user is in the project sub-tree once */
if (lGetElemStr(*found, STN_name, name)) {
ERROR((SGE_EVENT, MSG_STREE_USERTWICEINPRJSUBTREE_SS, name, lGetString(project, PR_name)));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DEXIT;
return -1;
}
#if 0 /* commented out because user may have access based on group ID */
/* make sure this user has access to the project */
if (strcmp(name, "default") &&
!sge_has_access_(name, NULL, lGetList(project, PR_acl),
lGetList(project, PR_xacl), *object_type_get_master_list(SGE_TYPE_USERSET))) {
ERROR((SGE_EVENT, MSG_STREE_USERTNOACCESS2PRJ_SS, name, lGetString(project, PR_name)));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DEXIT;
return -1;
}
#endif
} else {
const char *objname = MSG_OBJ_USER;
/* non project sub-tree leaf nodes must be a user or a project */
if (user_list_locate(user_list, name) == NULL &&
strcmp(name, "default") != 0) {
objname=MSG_JOB_PROJECT;
if (prj_list_locate(project_list, name) == NULL) {
ERROR((SGE_EVENT, MSG_SGETEXT_UNKNOWN_SHARE_TREE_REF_TO_SS,
MSG_OBJ_USERPRJ, name));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DEXIT;
return -1;
}
}
/* make sure this user or project is in the non�project sub-tree
portion of the share tree only once */
if (lGetElemStr(*found, STN_name, name)) {
ERROR((SGE_EVENT, MSG_STREE_USERPRJTWICE_SS, objname, name));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DEXIT;
return -1;
}
}
/* register that this was found */
lAddElemStr(found, STN_name, name, STN_Type);
}
DEXIT;
return 0;
}
/* ----------------------------------------------
dst is the share tree to be updated
src is a reduced share tree with at least
STN_name
STN_version
STN_m_share
STN_last_actual_proportion
STN_adjusted_current_proportion
*/
int update_sharetree(
lList **alpp,
lList *dst,
lList *src
) {
static int depth = 0;
lListElem *dnode, *snode;
#ifdef notdef
const char *d_name;
#endif
const char *s_name;
DENTER(TOP_LAYER, "update_sharetree");
dnode = lFirst(dst);
snode = lFirst(src);
if ((dnode!=NULL) != (snode!=NULL)) {
ERROR((SGE_EVENT, MSG_STREE_QMASTERSORCETREE_SS,
snode?"":MSG_STREE_NOPLUSSPACE, dnode?"":MSG_STREE_NOPLUSSPACE));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
depth = 0;
DEXIT;
return -1;
}
/* root node ? */
if (depth++ == 0) {
int dv, sv;
/* ensure STN_version of both root nodes are identically */
if (dnode && (dv=lGetUlong(dnode, STN_version)) !=
(sv=lGetUlong(snode, STN_version))) {
ERROR((SGE_EVENT, MSG_STREE_VERSIONMISMATCH_II, dv, sv));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
depth = 0;
DEXIT;
return -1;
}
}
/* seek matching node for each of the masters node on that level */
#ifdef notdef
for_each (dnode, dst) {
d_name = lGetString(dnode, STN_name);
if (!(snode = lGetElemStr(src, STN_name, d_name))) {
#endif
for_each (snode, src) {
s_name = lGetString(snode, STN_name);
if (!(dnode = lGetElemStr(dst, STN_name, s_name))) {
ERROR((SGE_EVENT, MSG_STREE_MISSINGNODE_S, s_name));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
depth = 0;
DEXIT;
return -1;
}
/* update fields */
lSetDouble(dnode, STN_m_share, lGetDouble(snode, STN_m_share));
lSetDouble(dnode, STN_last_actual_proportion,
lGetDouble(snode, STN_last_actual_proportion));
lSetDouble(dnode, STN_adjusted_current_proportion,
lGetDouble(snode, STN_adjusted_current_proportion));
lSetUlong(dnode, STN_job_ref_count, lGetUlong(snode, STN_job_ref_count));
/* enter recursion */
if (update_sharetree(alpp, lGetList(dnode, STN_children),
lGetList(snode, STN_children))) {
DEXIT;
return -1;
}
}
depth--;
DEXIT;
return 0;
}
/* seek user/prj node (depends on node_type STT_USER|STT_PROJECT) in actual share tree */
lListElem *getNode(
lList *share_tree,
const char *name,
int node_type,
int recurse
) {
lListElem *tmp, *node;
DENTER(TOP_LAYER, "getNode");
if (!share_tree || !lFirst(share_tree)) {
DEXIT;
return NULL;
}
#ifdef notdef
if ( !recurse && lGetUlong(lFirst(share_tree), STN_type)!=node_type ) {
DEXIT;
return NULL;
}
#endif
for_each (node, share_tree) {
if (!strcmp(name, lGetString(node, STN_name))) {
DEXIT;
return node;
}
if ((tmp=getNode(lGetList(node, STN_children), name, node_type, 1))) {
DEXIT;
return tmp;
}
}
DEXIT;
return NULL;
}