/*
* Copyright (C) 1994-2021 Altair Engineering, Inc.
* For more information, contact Altair at www.altair.com.
*
* This file is part of both the OpenPBS software ("OpenPBS")
* and the PBS Professional ("PBS Pro") software.
*
* Open Source License Information:
*
* OpenPBS is free software. You can redistribute it and/or modify it under
* the terms of the GNU Affero General Public License as published by the
* Free Software Foundation, either version 3 of the License, or (at your
* option) any later version.
*
* OpenPBS is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
* License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*
* Commercial License Information:
*
* PBS Pro is commercially licensed software that shares a common core with
* the OpenPBS software. For a copy of the commercial license terms and
* conditions, go to: (http://www.pbspro.com/agreement.html) or contact the
* Altair Legal Department.
*
* Altair's dual-license business model allows companies, individuals, and
* organizations to create proprietary derivative works of OpenPBS and
* distribute them - whether embedded or bundled with other software -
* under a commercial license agreement.
*
* Use of Altair's trademarks, including but not limited to "PBS™",
* "OpenPBS®", "PBS Professional®", and "PBS Pro™" and Altair's logos is
* subject to Altair's trademark licensing policies.
*/
/**
* @file pbs_python_svr_internal.c
* @brief
* This are the internal helper functions that depend on a lot of PBS
* Server Data structures.
*
*/
#include /* the master config generated by configure */
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "hook.h"
#include "pbs_nodes.h"
#include "cmds.h"
#include "svrfunc.h"
#include "pbs_ecl.h"
#include "placementsets.h"
#include "pbs_reliable.h"
/* ----- GLOBALS ----- */
/* pipe-separated string lists */
#define runjob_modifiable_jobattrs ATTR_h "|" ATTR_a "|" ATTR_project "|" ATTR_e "|" ATTR_o "|" ATTR_l "|" ATTR_v "|" ATTR_depend "|" ATTR_create_resv_from_job
#define runjob_modifiable_vnattrs ATTR_NODE_state
#define FMT_RUNJOB_ERRMSG "Can only set job's (%s) attribute, or a vnode's (%s) attribute under RUNJOB event - got <%s>"
extern attribute_def que_attr_def[];
extern resource_def *svr_resc_def; /* the resource def structure */
extern int svr_resc_size; /* static + dynamic */
extern int svr_resc_unk; /* the last one */
extern char server_name[];
extern struct python_interpreter_data svr_interp_data;
extern pbs_list_head svr_queues; /* list of queues */
extern pbs_list_head svr_alljobs; /* list of all jobs in server */
extern pbs_list_head svr_allresvs; /* all reservations in server */
extern char *msg_man_set;
extern char *path_hooks_workdir;
/* Global symbols */
extern char *vnode_state_to_str(int state_bit);
extern char *vnode_sharing_to_str(enum vnode_sharing share);
extern char *vnode_ntype_to_str(int vntype);
extern int str_to_vnode_state(char *vnstate);
extern enum vnode_sharing str_to_vnode_sharing(char *vn_str);
extern int str_to_vnode_ntype(char *vntype);
extern u_Long pps_size_to_kbytes(PyObject *l);
extern PyObject *svrattrl_list_to_pyobject(int rq_cmd, pbs_list_head *);
extern PyObject *svrattrl_to_server_attribute(int rq_cmd, svrattrl *);
static PyObject *
_pps_helper_get_resv(resc_resv *presv_o, const char *resvid, char *perf_label);
/* A dictionary for quick access to the pbs.v1 EMBEDDED_EXTENSION_TYPES */
static PyObject *PBS_PythonTypes = NULL; /* A dictionary maintaing name and type */
/*
* BEGIN Quick Access Types Table
* The below code is a convenience scheme, not really needed as they are
* available in the PBS_PythonTypes dict. But, since we do this for every
* aggregate type, comes in handy.
*/
typedef struct _pbs_python_types_entry {
char *t_key; /* The key in EXPORTED TYPES DICTIONARY */
PyObject *t_class; /* The actual type or class */
} pbs_python_types_entry;
#define PP_DESC_IDX 0
#define PP_GENERIC_IDX 1
#define PP_SIZE_IDX 2
#define PP_TIME_IDX 3
#define PP_ACL_IDX 4
#define PP_BOOL_IDX 5
#define PP_JOB_IDX 6
#define PP_QUE_IDX 7
#define PP_SVR_IDX 8
#define PP_RESV_IDX 9
#define PP_EVENT_IDX 10
#define PP_RESC_IDX 11
#define PP_ARST_IDX 12
#define PP_INT_IDX 13
#define PP_STR_IDX 14
#define PP_FLOAT_IDX 15
#define PP_EVENT_ERR_IDX 16
#define PP_UNSET_ATTR_NAME_ERR_IDX 17
#define PP_BADATTR_VTYPE_ERR_IDX 18
#define PP_BADATTR_VALUE_ERR_IDX 19
#define PP_UNSET_RESC_NAME_ERR_IDX 20
#define PP_BAD_RESC_VTYPE_ERR_IDX 21
#define PP_BAD_RESC_VALUE_ERR_IDX 22
#define PP_PBS_ITER_IDX 23
#define PP_VNODE_IDX 24
#define PP_ENTITY_IDX 25
#define PP_ENV_IDX 26
#define PP_MANAGEMENT_IDX 27
#define PP_SERVER_ATTRIBUTE_IDX 28
pbs_python_types_entry pbs_python_types_table[] = {
{PY_TYPE_ATTR_DESCRIPTOR, NULL}, /* 0 Always first */
{PY_TYPE_GENERIC, NULL},
{PY_TYPE_SIZE, NULL},
{PY_TYPE_TIME, NULL},
{PY_TYPE_ACL, NULL},
{PY_TYPE_BOOL, NULL},
{PY_TYPE_JOB, NULL},
{PY_TYPE_QUEUE, NULL},
{PY_TYPE_SERVER, NULL},
{PY_TYPE_RESV, NULL},
{PY_TYPE_EVENT, NULL}, /* 10 */
{PY_TYPE_RESOURCE, NULL},
{PY_TYPE_LIST, NULL},
{PY_TYPE_INT, NULL},
{PY_TYPE_STR, NULL},
{PY_TYPE_FLOAT, NULL}, /* 15 */
{PY_ERROR_EVENT_INCOMPATIBLE, NULL}, /* 16 */
{PY_ERROR_EVENT_UNSET_ATTRIBUTE, NULL}, /* 17 */
{PY_ERROR_BAD_ATTRIBUTE_VALUE_TYPE, NULL}, /* 18 */
{PY_ERROR_BAD_ATTRIBUTE_VALUE, NULL}, /* 19 */
{PY_ERROR_UNSET_RESOURCE, NULL}, /* 20 */
{PY_ERROR_BAD_RESOURCE_VALUE_TYPE, NULL}, /* 21 */
{PY_ERROR_BAD_RESOURCE_VALUE, NULL}, /* 22 */
{PY_TYPE_PBS_ITER, NULL}, /* 23 */
{PY_TYPE_VNODE, NULL}, /* 24 */
{PY_TYPE_ENTITY, NULL}, /* 25 */
{PY_TYPE_ENV, NULL}, /* 26 */
{PY_TYPE_MANAGEMENT, NULL}, /* 27 */
{PY_TYPE_SERVER_ATTRIBUTE, NULL}, /* 28 */
/* ADD ENTRIES ONLY BELOW, OR CHANGE THE PP_XXX_IDX above the table */
{NULL, NULL} /* sentinel */
};
typedef struct _pbs_iter_item {
PyObject *py_iter; /* *the* iterator */
void *data; /* arbitrary pbs data */
int data_index; /* index of data to some table */
pbs_list_link all_iters;
} pbs_iter_item;
static pbs_list_head pbs_iter_list; /* list of PBS iterators */
typedef struct _vnode_set_req {
char vnode_name[PBS_MAXNODENAME + 1];
pbs_list_head rq_attr; /* list of attributes to set */
pbs_list_link all_reqs;
} vnode_set_req;
static pbs_list_head pbs_vnode_set_list; /* list of vnode set requests */
/**
* @brief
* The pbs_resource_value structure holds the cached resource values for
* Python py_resource object.
*
* @param[in] py_resource - the Python pbs_resource object that will later
* be set with values in 'value_list'.
* @param[in] py_resource_str_value - a Python string object representing
* the values in 'value_list'.
* @param[in] attr_def_p - the resource definition for the resource list
* represented by 'py_resource'.
* @param[in] value_list - list of values cached for the 'py_resource' object
* @param[in] all_resc - links various pbs_resource_value structures.
*/
typedef struct _pbs_resource_value {
PyObject *py_resource;
PyObject *py_resource_str_value;
attribute_def *attr_def_p; /* corresponding resource definition */
pbs_list_head value_list; /* resource values to set */
pbs_list_link all_rescs;
} pbs_resource_value;
static pbs_list_head pbs_resource_value_list; /* list of resource */
/* values to instantiate */
static PyObject *PyPbsV1Module_Obj = NULL; /* pbs.v1 module object */
/* an array holding all the vnode attribute descriptors (python pointers) */
static PyObject **py_vnode_attr_types = NULL;
/* an array holding all the resv attribute descriptors (python pointers) */
static PyObject **py_resv_attr_types = NULL;
/* an array holding all the server attribute descriptors (python pointers) */
static PyObject **py_svr_attr_types = NULL;
/* an array holding all the job attribute descriptors (python pointers) */
static PyObject **py_job_attr_types = NULL;
/* an array holding all the queue attribute descriptors (python pointers) */
static PyObject **py_que_attr_types = NULL;
/* an array of python objects holding all the resources (python pointers)*/
static PyObject **py_svr_resc_types = NULL;
/* The function object that instantiates/populates a PBS object using */
static PyObject *py_pbs_statobj = NULL;
/* This is the current hook event object */
static PyObject *py_hook_pbsevent = NULL;
/* This is the cached local/server object */
static PyObject *py_hook_pbsserver = NULL;
/* An array of cached Python queue objects managed by the current server */
static PyObject **py_hook_pbsque = NULL;
static int py_hook_pbsque_max = 0; /* Max # of entries in py_hook_pbsque */
static int hook_pbsevent_accept = TRUE; /* flag to accept/reject event */
static int hook_pbsevent_stop_processing = FALSE; /* flag to stop */
/* processing event */
/* parameters */
static char hook_pbsevent_reject_msg[HOOK_MSG_SIZE];
static int hook_set_mode = C_MODE; /* in C_MODE, can set*/
/* anything */
static int hook_reboot_host = FALSE; /* flag to reboot host or not */
static int hook_reboot_host_cmd[HOOK_BUF_SIZE]; /* cmdline to use */
/* to reboot host */
/* as alternate to */
/* reboot() call */
static int hook_scheduler_restart_cycle = FALSE; /* flag to tell local */
/* server to tell the */
/* scheduler to */
/* restart sched cycle*/
/*
* The following limit and counter declarations are intended
* to reduce the amount of memory consumed by the Python
* interpreter so that the server process does not become
* bloated. Python is able to garbage collect builtin
* types (e.g. string, dict, etc.), but the PBS types are
* not created such that their memory can be released.
*/
/* Max hook events to service before restarting the interpreter */
#define PBS_PYTHON_RESTART_MAX_HOOKS 100
/* Max objects created before restarting the interpreter */
#define PBS_PYTHON_RESTART_MAX_OBJECTS 1000
/* Minimum interval between interpreter restarts */
#define PBS_PYTHON_RESTART_MIN_INTERVAL 30
/* count of Python objects created */
static long object_counter = 0;
typedef struct hook_debug_t {
FILE *input_fp;
char input_file[MAXPATHLEN + 1];
FILE *output_fp;
char output_file[MAXPATHLEN + 1];
FILE *data_fp;
char data_file[MAXPATHLEN + 1];
char objname[HOOK_BUF_SIZE + 1];
} hook_debug_t;
static int use_static_data = 0; /* use static server-related data */
static hook_debug_t hook_debug;
static pbs_list_head *server_data;
typedef struct server_jobs_t {
pbs_list_head *data;
pbs_list_head *ids;
} server_jobs_t;
static server_jobs_t server_jobs;
typedef struct server_queues_t {
pbs_list_head *data;
pbs_list_head *names;
} server_queues_t;
static server_queues_t server_queues;
typedef struct server_resvs_t {
pbs_list_head *data;
pbs_list_head *resvids;
} server_resvs_t;
static server_resvs_t server_resvs;
typedef struct server_vnodes_t {
pbs_list_head *data;
pbs_list_head *names;
} server_vnodes_t;
static server_vnodes_t server_vnodes;
/**
* @brief
* This is a function that logs the contents of the list
* headed by 'phead'.
*
* @param[in] head_str - some string that gets printed spearheading the list.
* @param[in] phead - header of the list to be printed.
*
* @return void
*
*/
void
print_svrattrl_list(char *head_str, pbs_list_head *phead)
{
svrattrl *plist = NULL;
int i;
if ((head_str == NULL) || (phead == NULL)) {
return;
}
if (!will_log_event(PBSEVENT_DEBUG3))
return;
plist = (svrattrl *) GET_NEXT(*phead);
i = 0;
log_event(PBSEVENT_DEBUG3, PBS_EVENTCLASS_HOOK, LOG_INFO, __func__, head_str);
while (plist) {
snprintf(log_buffer, LOG_BUF_SIZE - 1,
#ifdef NAS /* localmod 005 */
"al_name=%s al_resc=%s al_value=%s al_flags=%ld",
plist->al_name, plist->al_resc ? plist->al_resc : "null",
plist->al_value, (long) plist->al_flags);
#else
"al_name=%s al_resc=%s al_value=%s al_flags=%d",
plist->al_name, plist->al_resc ? plist->al_resc : "null",
plist->al_value, plist->al_flags);
#endif /* localmod 005 */
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_event(PBSEVENT_DEBUG3, PBS_EVENTCLASS_HOOK, LOG_INFO, __func__,
log_buffer);
plist = (svrattrl *) GET_NEXT(plist->al_link);
i++;
}
}
/**
* @brief
* This is a stub function that should be implemented to add any additional
* elements to the global namespace dict.
*
* @param[in] globals - python object indicating reference to globals of a module
*
* @return int
* @retval 0 success
* @retval -1 error
*
*/
int
pbs_python_setup_namespace_dict(PyObject *globals)
{
#if 0 /* enable later */
/*
* First, insert our module object pbs.v1 as pbs so the hook scripts
* can access all the globals
*/
/* I believe our design REQUIRES hook write to issue a "import pbs" */
if ((PyDict_SetItemString(globals, "pbs", PyPbsV1Module_Obj) == -1)) {
goto ERROR_EXIT;
}
return 0;
ERROR_EXIT:
pbs_python_write_error_to_log("pbs_python_setup_namespace_dict");
return -1;
#endif
return 0;
}
/**
* @brief
* The C routine that will instantiate a PbsAttributeDescriptor
* class (see src/modules/_base_types.py), which wraps a
* PBS attribute into a descriptor.
*
* @param[in] klass-the class attribute being wrapped into a data descriptor.
* @param[in] name - name of a PBS attribute.
* @param[in] default_value - given to the PBS attribute.
* @param[in] val_klass - the class/object type of the attribute's value.
* @param[in] resc_attr - if the attribute being wrapped is a pbs_resource,
* then this is the name of its parent.
* For example: name="ncpus", resc_attr="Resource_List"
* @param[in] is_entity - if the attribute being wrapped is also an
* entity type.
* For example: name="ncpus", resc_attr="max_run_res",
* is_entity=1.
* @return int
* @retval -1 Failed to create descriptor.
* @retval 0 Successfully created descriptor.
* @retval 1 Descriptor already present.
*
*/
static int
_pps_getset_descriptor_object(PyObject *klass,
const char *name,
PyObject *default_value,
PyObject *val_klass,
const char *resc_attr,
int is_entity)
{
/* this is for constructor call , see _base_types.py */
static char *kwds[] = {"cls", "name", "default_value", "value_type",
"resc_attr", "is_entity"};
PyObject *py_descr_class = NULL;
PyObject *py_descr_args = PyTuple_New(0);
PyObject *py_descr_kwds = NULL;
PyObject *py_attr_descr = NULL;
/* check we creation of tuple failed */
if (!(py_descr_args)) {
goto ERROR_EXIT;
}
/* check whether the attribute descriptor is already present */
if (PyObject_HasAttrString(klass, name)) {
Py_CLEAR(py_descr_args);
return 1;
}
py_descr_class = pbs_python_types_table[PP_DESC_IDX].t_class;
/* good, build the arument list NEW ref
* class, name, default_value, value_class
*/
if (resc_attr) { /* ok we are creating a attribute for a resource */
py_descr_kwds = Py_BuildValue("{s:O, s:s, s:O, s:(O), s:s, s:i}",
kwds[0], klass,
kwds[1], name,
kwds[2], default_value,
kwds[3], val_klass,
kwds[4], resc_attr,
kwds[5], is_entity);
} else {
py_descr_kwds = Py_BuildValue("{s:O, s:s, s:O, s:(O), s:i}",
kwds[0], klass,
kwds[1], name,
kwds[2], default_value,
kwds[3], val_klass,
kwds[5], is_entity);
}
if (!py_descr_kwds) {
goto ERROR_EXIT;
}
py_attr_descr = PyObject_Call(py_descr_class, py_descr_args, py_descr_kwds);
if (!py_attr_descr) {
goto ERROR_EXIT;
}
Py_CLEAR(py_descr_args);
Py_CLEAR(py_descr_kwds);
/* now set the class attribute */
if ((PyObject_SetAttrString(klass, name, py_attr_descr) == -1)) {
goto ERROR_EXIT;
}
/* we don't need the descriptor any more */
Py_CLEAR(py_attr_descr);
return 0;
ERROR_EXIT:
pbs_python_write_error_to_log(__func__);
Py_CLEAR(py_descr_args);
Py_CLEAR(py_descr_kwds);
Py_CLEAR(py_attr_descr);
return -1;
}
/*
* pbs_python_get_python_type:
* This is the bulk where all the magic happens regarding the mapping from
* PBS to python types.
*
* returns:
* - A Borrowed Reference.
*/
/* TODO
* -big assumption, hopefully the DURATION/TIME encoding routine is
* not overloaded.
* -Make sure all types are there
*/
#define TYPE_DURATION(p) (((p) == encode_time))
#define TYPE_SIZE(p) (((p) == ATR_TYPE_SIZE))
#define TYPE_ACL(p) (((p) == ATR_TYPE_ACL))
#define TYPE_BOOL(p) (((p) == ATR_TYPE_BOOL))
#define TYPE_ARST(p) (((p) == ATR_TYPE_ARST))
#define TYPE_RESC(p) (((p) == ATR_TYPE_RESC))
#define TYPE_INT(p) ((((p) == ATR_TYPE_LONG) || \
((p) == ATR_TYPE_SHORT) || \
((p) == ATR_TYPE_CHAR)))
#define TYPE_STR(p) (((p) == ATR_TYPE_STR) || \
((p) == ATR_TYPE_JINFOP))
#define TYPE_FLOAT(p) (((p) == ATR_TYPE_FLOAT))
#define TYPE_ENTITY(p) (((p) == ATR_TYPE_ENTITY))
#define ATTR_IS_RESC(a) (TYPE_RESC((a)->at_type) || \
(TYPE_ENTITY((a)->at_type) && \
((a)->at_decode == decode_entlim_res)))
/*
* TODO
* - It is possible to combine pbs_python_setup_resc_get_value_type
* and pbs_python_setup_attr_get_value_type into a macro.
*/
/*
* NO exception raised
*/
/**
* @brief
* given the resource definition return the corresponding python type.
*
* @param[in] resc_def_p - pointer to resource_def indicating resource list
*
* @return pointer PyObject
* @retval resource table success
* @retval return generic failure
*
*/
static PyObject *
pbs_python_setup_resc_get_value_type(resource_def *resc_def_p)
{
PyObject *py_tmp = NULL; /* return value */
/* check if we are special aka check PBS_PythonTypes first */
py_tmp = PyDict_GetItemString(PBS_PythonTypes, resc_def_p->rs_name);
if (py_tmp)
return py_tmp; /* cool, we are special */
/* careful long is overloadded so duration comes first */
if (TYPE_DURATION(resc_def_p->rs_encode)) /* check for time type */
return pbs_python_types_table[PP_TIME_IDX].t_class;
if (TYPE_SIZE(resc_def_p->rs_type)) /* check for SIZE type */
return pbs_python_types_table[PP_SIZE_IDX].t_class;
if (TYPE_ACL(resc_def_p->rs_type)) /* check for ACL type */
return pbs_python_types_table[PP_ACL_IDX].t_class;
if (TYPE_BOOL(resc_def_p->rs_type)) /* check for BOOL type */
return pbs_python_types_table[PP_BOOL_IDX].t_class;
if (TYPE_ARST(resc_def_p->rs_type)) /* check for list of strings */
return pbs_python_types_table[PP_ARST_IDX].t_class;
if (TYPE_INT(resc_def_p->rs_type)) /* check for int,long,short type */
return pbs_python_types_table[PP_INT_IDX].t_class;
if (TYPE_STR(resc_def_p->rs_type)) /* check for str type */
return pbs_python_types_table[PP_STR_IDX].t_class;
if (TYPE_FLOAT(resc_def_p->rs_type)) /* check for float type */
return pbs_python_types_table[PP_FLOAT_IDX].t_class;
if (TYPE_ENTITY(resc_def_p->rs_type)) /* check for entity type */
return pbs_python_types_table[PP_ENTITY_IDX].t_class;
/* all else fails return generic */
return pbs_python_types_table[PP_GENERIC_IDX].t_class;
}
/**
* @brief
* Given an attribute defintion, return the corresponding Python type.
*
* @param[in] attr_def_p - an attribute_def type.
* @param[in] py_type - a python type in string: "job", "server",
* "queue", "resv", or "vnode".
* @return PyObject *
*/
static PyObject *
pbs_python_setup_attr_get_value_type(attribute_def *attr_def_p, char *py_type)
{
PyObject *py_tmp = NULL; /* return value */
/* check if we are special aka check PBS_PythonTypes first */
if ((strcmp(py_type, PY_TYPE_VNODE) != 0) ||
(strcmp(attr_def_p->at_name, ATTR_p) != 0)) {
/* Only get the type from PBS_PythonTypes if not the vnode's Priority */
/* attribute which is treated as a Python int instead of the */
/* pbs.priority type mapped in PBS_Python_Types. */
py_tmp = PyDict_GetItemString(PBS_PythonTypes, attr_def_p->at_name);
if (py_tmp)
return py_tmp; /* cool, we are special */
}
/* careful long is overloadded so duration comes first */
if (TYPE_DURATION(attr_def_p->at_encode)) /* check for time type */
return pbs_python_types_table[PP_TIME_IDX].t_class;
if (ATTR_IS_RESC(attr_def_p))
return pbs_python_types_table[PP_RESC_IDX].t_class;
if (TYPE_SIZE(attr_def_p->at_type)) /* check for SIZE type */
return pbs_python_types_table[PP_SIZE_IDX].t_class;
if (TYPE_ACL(attr_def_p->at_type)) /* check for ACL type */
return pbs_python_types_table[PP_ACL_IDX].t_class;
if (TYPE_BOOL(attr_def_p->at_type)) /* check for BOOL type */
return pbs_python_types_table[PP_BOOL_IDX].t_class;
if (TYPE_ARST(attr_def_p->at_type)) /* check for list of strings */
return pbs_python_types_table[PP_ARST_IDX].t_class;
if (TYPE_INT(attr_def_p->at_type)) /* check for int,long,short */
return pbs_python_types_table[PP_INT_IDX].t_class;
if (TYPE_STR(attr_def_p->at_type)) /* check for str type */
return pbs_python_types_table[PP_STR_IDX].t_class;
if (TYPE_FLOAT(attr_def_p->at_type)) /* check for float type */
return pbs_python_types_table[PP_FLOAT_IDX].t_class;
if (TYPE_ENTITY(attr_def_p->at_type)) /* check for entity type */
return pbs_python_types_table[PP_ENTITY_IDX].t_class;
/* all else fails return generic */
return pbs_python_types_table[PP_GENERIC_IDX].t_class;
}
/**
* @brief
* pbs_python_free_py_types_array
* This frees up the global arrays
*
* @param[in] py_types_array - address reference to globals
*
* @return Void
*/
void
pbs_python_free_py_types_array(PyObject ***py_types_array)
{
PyObject **py_array_tmp = *py_types_array;
PyObject *py_tmp = NULL;
if (*py_types_array) {
while ((py_tmp = *py_array_tmp)) {
Py_CLEAR(py_tmp);
py_array_tmp++;
}
}
PyMem_Free(*py_types_array);
*py_types_array = NULL; /* since we might be called again */
return;
}
/**
* @brief
* makes a call to given python object klass and maskes default value
*
* @param[in] klass - function
* @param[in] args - arguments for function
*
* @return PyObject *
*
*/
PyObject *
pbs_python_make_default_value(PyObject *klass, PyObject *args)
{
PyObject *py_default_value;
py_default_value = PyObject_Call(klass, args, NULL);
if (!py_default_value) {
goto ERROR_EXIT;
}
return py_default_value;
ERROR_EXIT:
pbs_python_write_error_to_log("could not make default value");
return NULL;
}
/**
* @brief
* Routine that actualizes *all* the attributes for a Python vnode object.
*
* @par Functionality:
* This takes input from node_attr_def[] and svr_resc_defm[] tables.
* Each attribute is setup as a descriptor for finer granularity of
* control.
*
* @return int
* @retval 0 : Successful execution of this function, with internal
* 'py_vnode_attr_types' list populated.
* @retval -1 " On failutre to populate 'py_vnode_attr_types' list.
*/
int
pbs_python_setup_vnode_class_attributes(void)
{
int i = 0;
attribute_def *attr_def_p = NULL; /* convenience pointer */
PyObject *py_pbs_vnode_klass = pbs_python_types_table[PP_VNODE_IDX].t_class;
PyObject *py_value_type = NULL;
PyObject *py_default_value = NULL;
PyObject *py_default_args = NULL;
int num_entry = ND_ATR_LAST + 1; /* 1 for sentinel */
int te;
if (IS_PBS_PYTHON_CMD(pbs_python_daemon_name))
DEBUG3_ARG1("BEGIN setting up all vnode attributes %s", "");
else
DEBUG2_ARG1("BEGIN setting up all vnode attributes %s", "");
py_vnode_attr_types = PyMem_New(PyObject *, num_entry);
if (py_vnode_attr_types == NULL)
goto ERROR_EXIT;
memset(py_vnode_attr_types, 0, sizeof(PyObject *) * num_entry);
/* ok now set all the node_attr_def types known to the server */
attr_def_p = node_attr_def;
for (i = 0; i < ND_ATR_LAST; i++) {
/* get the value type for this attribute */
py_value_type = pbs_python_setup_attr_get_value_type(attr_def_p,
PY_TYPE_VNODE);
/* create a brand new default value from value type */
if (ATTR_IS_RESC(attr_def_p)) {
py_default_args = Py_BuildValue("(s)", attr_def_p->at_name);
if (py_default_args == NULL) {
log_err(-1, attr_def_p->at_name, "could not build args for default value");
continue;
}
py_default_value = pbs_python_make_default_value(py_value_type, py_default_args);
Py_DECREF(py_default_args);
if (py_default_value == NULL) {
log_err(-1, attr_def_p->at_name, "could not set default value");
continue;
}
te = TYPE_ENTITY(attr_def_p->at_type);
} else {
py_default_value = Py_None;
te = 0;
}
if (_pps_getset_descriptor_object(py_pbs_vnode_klass,
attr_def_p->at_name,
py_default_value,
py_value_type, NULL, te) == -1)
goto ERROR_EXIT;
Py_INCREF(py_value_type);
if (py_default_value != Py_None)
Py_CLEAR(py_default_value);
py_vnode_attr_types[i] = py_value_type;
attr_def_p++;
}
if (IS_PBS_PYTHON_CMD(pbs_python_daemon_name))
DEBUG3_ARG1("DONE setting up all vnode attributes, number set <%d>", i);
else
DEBUG2_ARG1("DONE setting up all vnode attributes, number set <%d>", i);
return 0;
ERROR_EXIT:
if (py_default_value != Py_None)
Py_CLEAR(py_default_value);
snprintf(log_buffer, LOG_BUF_SIZE - 1,
"could not set attribute <%s> for vnode python class", attr_def_p->at_name);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(-1, __func__, log_buffer);
return -1;
}
/**
* @brief
* pbs_python_setup_resv_class_attributes
* routine that sets up *all* the attributes for a Python server Object
* mapping directly to PBS Job object (struct job)
*
* @return int
* @retval -1 : failure
* @retval 0 : success
*/
int
pbs_python_setup_resv_class_attributes(void)
{
int i = 0;
attribute_def *attr_def_p = NULL; /* convenience pointer */
PyObject *py_pbs_resv_klass = pbs_python_types_table[PP_RESV_IDX].t_class;
PyObject *py_value_type = NULL;
PyObject *py_default_value = NULL;
PyObject *py_default_args = NULL;
int num_entry = RESV_ATR_LAST + 1; /* 1 for sentinel */
int te;
if (IS_PBS_PYTHON_CMD(pbs_python_daemon_name))
DEBUG3_ARG1("BEGIN setting up all reservation attributes %s", "");
else
DEBUG2_ARG1("BEGIN setting up all reservation attributes %s", "");
py_resv_attr_types = PyMem_New(PyObject *, num_entry);
if (!py_resv_attr_types) {
goto ERROR_EXIT;
}
memset(py_resv_attr_types, 0, sizeof(PyObject *) * num_entry);
/* ok now set all the resv_attr_def types known to the server */
attr_def_p = resv_attr_def;
for (i = 0; i < RESV_ATR_LAST; i++) {
/* get the value type for this attribute */
py_value_type = pbs_python_setup_attr_get_value_type(attr_def_p,
PY_TYPE_RESV);
/* create a brand new default value from value type */
if (ATTR_IS_RESC(attr_def_p)) {
py_default_args = Py_BuildValue("(s)", attr_def_p->at_name);
if (!py_default_args) {
/* TODO, continuing instead of fatal error */
log_err(-1, attr_def_p->at_name, "could not build args for default value");
continue;
}
py_default_value = pbs_python_make_default_value(py_value_type, py_default_args);
Py_DECREF(py_default_args);
if (!py_default_value) {
/* TODO, continuing instead of fatal error */
log_err(-1, attr_def_p->at_name, "could not set default value");
continue;
}
te = TYPE_ENTITY(attr_def_p->at_type);
} else {
py_default_value = Py_None;
te = 0;
}
if (_pps_getset_descriptor_object(py_pbs_resv_klass,
attr_def_p->at_name,
py_default_value,
py_value_type, NULL, te) == -1)
goto ERROR_EXIT;
Py_INCREF(py_value_type);
if (py_default_value != Py_None)
Py_CLEAR(py_default_value);
py_resv_attr_types[i] = py_value_type;
attr_def_p++;
}
if (IS_PBS_PYTHON_CMD(pbs_python_daemon_name))
DEBUG3_ARG1("DONE setting up all reservation attributes, number set <%d>", i);
else
DEBUG2_ARG1("DONE setting up all reservation attributes, number set <%d>", i);
return 0;
ERROR_EXIT:
if (py_default_value != Py_None)
Py_CLEAR(py_default_value);
snprintf(log_buffer, LOG_BUF_SIZE - 1,
"could not set attribute <%s> for reservation python class", attr_def_p->at_name);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(-1, __func__, log_buffer);
return -1;
}
/**
* @brief
* pbs_python_setup_svr_class_attributes
* routine that sets up *all* the attributes for a Python server Object
* mapping directly to PBS Job object (struct job)
*
* @return int
* @retval -1 : failure
* @retval 0 : success
*/
int
pbs_python_setup_server_class_attributes(void)
{
int i = 0;
attribute_def *attr_def_p = NULL; /* convenience pointer */
PyObject *py_pbs_svr_klass = pbs_python_types_table[PP_SVR_IDX].t_class;
PyObject *py_value_type = NULL;
PyObject *py_default_value = NULL;
PyObject *py_default_args = NULL;
int num_entry = SVR_ATR_LAST + 1; /* 1 for sentinel */
int te;
if (IS_PBS_PYTHON_CMD(pbs_python_daemon_name))
DEBUG3_ARG1("BEGIN setting up all server attributes %s", "");
else
DEBUG2_ARG1("BEGIN setting up all server attributes %s", "");
py_svr_attr_types = PyMem_New(PyObject *, num_entry);
if (!py_svr_attr_types) {
goto ERROR_EXIT;
}
memset(py_svr_attr_types, 0, sizeof(PyObject *) * num_entry);
/* ok now set all the svr_attr_def types known to the server */
attr_def_p = svr_attr_def;
for (i = 0; i < SVR_ATR_LAST; i++) {
/* get the value type for this attribute */
py_value_type = pbs_python_setup_attr_get_value_type(attr_def_p,
PY_TYPE_SERVER);
/* create a brand new default value from value type */
if (ATTR_IS_RESC(attr_def_p)) {
py_default_args = Py_BuildValue("(s)", attr_def_p->at_name);
if (!py_default_args) {
/* TODO, continuing instead of fatal error */
log_err(-1, attr_def_p->at_name, "could not build args for default value");
continue;
}
py_default_value = pbs_python_make_default_value(py_value_type, py_default_args);
Py_DECREF(py_default_args);
if (!py_default_value) {
/* TODO, continuing instead of fatal error */
log_err(-1, attr_def_p->at_name, "could not set default value");
continue;
}
te = TYPE_ENTITY(attr_def_p->at_type);
} else {
py_default_value = Py_None;
te = 0;
}
if (_pps_getset_descriptor_object(py_pbs_svr_klass,
attr_def_p->at_name,
py_default_value,
py_value_type, NULL, te) == -1)
goto ERROR_EXIT;
Py_INCREF(py_value_type);
if (py_default_value != Py_None)
Py_CLEAR(py_default_value);
py_svr_attr_types[i] = py_value_type;
attr_def_p++;
}
if (IS_PBS_PYTHON_CMD(pbs_python_daemon_name))
DEBUG3_ARG1("DONE setting up all server attributes, number set <%d>", i);
else
DEBUG2_ARG1("DONE setting up all server attributes, number set <%d>", i);
return 0;
ERROR_EXIT:
if (py_default_value != Py_None)
Py_CLEAR(py_default_value);
snprintf(log_buffer, LOG_BUF_SIZE - 1,
"could not set attribute <%s> for python class", attr_def_p->at_name);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(-1, __func__, log_buffer);
return -1;
}
/**
* @brief
* pbs_python_setup_job_class_attributes
* routine that sets up *all* the attributes for a Python Job Object
* mapping directly to PBS Job object (struct job)
*
* @return int
* @retval -1 : failure
* @retval 0 : success
*/
int
pbs_python_setup_job_class_attributes(void)
{
int i = 0;
attribute_def *attr_def_p = NULL; /* convenience pointer */
PyObject *py_pbs_job_klass = pbs_python_types_table[PP_JOB_IDX].t_class;
PyObject *py_value_type = NULL;
PyObject *py_default_value = NULL;
PyObject *py_default_args = NULL;
int num_entry = JOB_ATR_LAST + 1; /* 1 for sentinel */
int te;
if (IS_PBS_PYTHON_CMD(pbs_python_daemon_name))
DEBUG3_ARG1("BEGIN setting up all job attributes %s", "");
else
DEBUG2_ARG1("BEGIN setting up all job attributes %s", "");
py_job_attr_types = PyMem_New(PyObject *, num_entry);
if (!py_job_attr_types) {
goto ERROR_EXIT;
}
memset(py_job_attr_types, 0, sizeof(PyObject *) * num_entry);
/* ok now set all the job_attr_def types known to the server */
attr_def_p = job_attr_def;
for (i = 0; i < JOB_ATR_LAST; i++) {
/* get the value type for this attribute */
py_value_type = pbs_python_setup_attr_get_value_type(attr_def_p,
PY_TYPE_JOB);
/* create a brand new default value from value type */
if (ATTR_IS_RESC(attr_def_p)) {
py_default_args = Py_BuildValue("(s)", attr_def_p->at_name);
if (!py_default_args) {
/* TODO, continuing instead of fatal error */
log_err(-1, attr_def_p->at_name, "could not build args for default value");
continue;
}
py_default_value = pbs_python_make_default_value(py_value_type, py_default_args);
Py_DECREF(py_default_args);
if (!py_default_value) {
/* TODO, continuing instead of fatal error */
log_err(-1, attr_def_p->at_name, "could not set default value");
continue;
}
te = TYPE_ENTITY(attr_def_p->at_type);
} else {
py_default_value = Py_None;
te = 0;
}
/* default to None */
if (_pps_getset_descriptor_object(py_pbs_job_klass,
attr_def_p->at_name,
py_default_value,
py_value_type, NULL, te) == -1)
goto ERROR_EXIT;
Py_INCREF(py_value_type);
if (py_default_value != Py_None)
Py_CLEAR(py_default_value);
py_job_attr_types[i] = py_value_type;
attr_def_p++;
}
if (IS_PBS_PYTHON_CMD(pbs_python_daemon_name))
DEBUG3_ARG1("DONE setting up all job attributes, number set <%d>", i);
else
DEBUG2_ARG1("DONE setting up all job attributes, number set <%d>", i);
return 0;
ERROR_EXIT:
if (py_default_value != Py_None)
Py_CLEAR(py_default_value);
snprintf(log_buffer, LOG_BUF_SIZE - 1,
"could not set attribute <%s> for python class", attr_def_p->at_name);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(-1, __func__, log_buffer);
return -1;
}
/**
* @brief
* pbs_python_setup_queue_class_attributes
* routine that sets up *all* the attributes for a Python Queue Object
* mapping directly to PBS Queue object (pbs_queue)
*
* @return int
* @retval -1 : failure
* @retval 0 : success
*/
int
pbs_python_setup_queue_class_attributes(void)
{
int i = 0;
attribute_def *attr_def_p = NULL; /* convenience pointer */
PyObject *py_pbs_que_klass = pbs_python_types_table[PP_QUE_IDX].t_class;
PyObject *py_value_type = NULL;
PyObject *py_default_value = NULL;
PyObject *py_default_args = NULL;
int num_entry = QA_ATR_LAST + 1; /* 1 for sentinel */
int te;
if (IS_PBS_PYTHON_CMD(pbs_python_daemon_name))
DEBUG3_ARG1("BEGIN setting up all queue attributes %s", "");
else
DEBUG2_ARG1("BEGIN setting up all queue attributes %s", "");
py_que_attr_types = PyMem_New(PyObject *, num_entry);
if (!py_que_attr_types) {
goto ERROR_EXIT;
}
memset(py_que_attr_types, 0, sizeof(PyObject *) * num_entry);
/* ok now set all the resources known to the server */
attr_def_p = que_attr_def;
for (i = 0; i < QA_ATR_LAST; i++) {
/* get the value type for this attribute */
py_value_type = pbs_python_setup_attr_get_value_type(attr_def_p,
PY_TYPE_QUEUE);
/* create a brand new default value from value type */
if (ATTR_IS_RESC(attr_def_p)) {
py_default_args = Py_BuildValue("(s)", attr_def_p->at_name);
if (!py_default_args) {
/* TODO, continuing instead of fatal error */
log_err(-1, attr_def_p->at_name, "could not build args for default value");
attr_def_p++;
continue;
}
py_default_value = pbs_python_make_default_value(py_value_type, py_default_args);
Py_DECREF(py_default_args);
if (!py_default_value) {
/* TODO, continuing instead of fatal error */
log_err(-1, attr_def_p->at_name, "could not set default value");
attr_def_p++;
continue;
}
te = TYPE_ENTITY(attr_def_p->at_type);
} else {
py_default_value = Py_None;
te = 0;
}
if (_pps_getset_descriptor_object(py_pbs_que_klass,
attr_def_p->at_name,
py_default_value,
py_value_type, NULL, te) == -1)
goto ERROR_EXIT;
Py_INCREF(py_value_type);
if (py_default_value != Py_None)
Py_CLEAR(py_default_value);
py_que_attr_types[i] = py_value_type;
attr_def_p++;
}
if (IS_PBS_PYTHON_CMD(pbs_python_daemon_name))
DEBUG3_ARG1("DONE setting up all queue attributes, number set <%d>", i);
else
DEBUG2_ARG1("DONE setting up all queue attributes, number set <%d>", i);
return 0;
ERROR_EXIT:
if (py_default_value != Py_None)
Py_CLEAR(py_default_value);
snprintf(log_buffer, LOG_BUF_SIZE - 1,
"could not set attribute <%s> for python class", attr_def_p->at_name);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(-1, __func__, log_buffer);
return -1;
}
/**
* @brief
* pbs_python_setup_python_resource_type
* routine that sets up *all* the resources for a Python resource Object
*
* @return int
* @retval -1 : failure
* @retval 0 : success
*/
int
pbs_python_setup_python_resource_type(void)
{
int i = 0, j;
resource_def *resc_def_p = NULL; /* convenience pointer */
PyObject *py_pbs_resc_klass = pbs_python_types_table[PP_RESC_IDX].t_class;
PyObject *py_value_type = NULL;
int num_entry = svr_resc_size + 1; /* 1 for sentinel */
if (IS_PBS_PYTHON_CMD(pbs_python_daemon_name))
DEBUG3_ARG1("BEGIN setting up all resource attributes %s", "");
else
DEBUG2_ARG1("BEGIN setting up all resource attributes %s", "");
py_svr_resc_types = PyMem_New(PyObject *, num_entry);
if (!py_svr_resc_types) {
goto ERROR_EXIT;
}
memset(py_svr_resc_types, 0, sizeof(PyObject *) * num_entry);
/* ok now set all the resources known to the server */
resc_def_p = svr_resc_def;
i = 0;
j = svr_resc_size;
while (j--) {
/* get the value type for this resource */
py_value_type = pbs_python_setup_resc_get_value_type(resc_def_p);
/* default to None */
if (_pps_getset_descriptor_object(py_pbs_resc_klass,
resc_def_p->rs_name,
Py_None,
py_value_type, PY_RESOURCE_GENERIC_VALUE, 0) == -1) {
goto ERROR_EXIT;
}
Py_INCREF(py_value_type);
py_svr_resc_types[i] = py_value_type;
resc_def_p = resc_def_p->rs_next;
i++;
}
if (IS_PBS_PYTHON_CMD(pbs_python_daemon_name))
DEBUG3_ARG1("DONE setting up all resource attributes, number set <%d>", i);
else
DEBUG2_ARG1("DONE setting up all resource attributes, number set <%d>", i);
return 0;
ERROR_EXIT:
snprintf(log_buffer, LOG_BUF_SIZE - 1,
"could not set attribute <%s> for python class", resc_def_p->rs_name);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(-1, __func__, log_buffer);
return -1;
}
/**
* @brief
* pbs_python_clear_types_table clear the python pointers
*
* exceptions:
* None
*/
static void
pbs_python_clear_types_table(void)
{
pbs_python_types_entry *pp_type = pbs_python_types_table;
while (pp_type->t_key) {
Py_CLEAR(pp_type->t_class);
pp_type++;
}
return;
}
/**
* @brief
* pbs_python_types_table setup routine, called at initialization of interp.
*
* @return int
* @retval -1 : failure
* @retval 0 : success
*
* exceptions:
* None
* Assumptions:
* PBS_PythonTypes must be setup.
*/
static int
pbs_python_setup_types_table(void)
{
pbs_python_types_entry *pp_type = pbs_python_types_table;
while (pp_type->t_key) {
pp_type->t_class = PyDict_GetItemString(PBS_PythonTypes, pp_type->t_key);
if (!(pp_type->t_class)) {
snprintf(log_buffer, LOG_BUF_SIZE - 1,
"could not find key <%s> in PBS_PythonTypes",
pp_type->t_key);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(-1, __func__, log_buffer);
goto ERROR_EXIT;
}
/* since we are borrowed incref */
Py_INCREF(pp_type->t_class);
pp_type++;
}
return 0;
ERROR_EXIT:
/* on error, the load_python_type ... calls the unload for globals */
return -1;
}
/**
* @brief
* Unload all the PBS python types initialized, as well as static Python
* objects created during the initial loading of the interpreter.
*
* @param[in/out] interp_data - data representing the interpeter that will
* be filled with new information.
*
* @return none
*
*/
void
pbs_python_unload_python_types(struct python_interpreter_data *interp_data)
{
Py_CLEAR(PyPbsV1Module_Obj);
Py_CLEAR(PBS_PythonTypes);
pbs_python_clear_types_table();
pbs_python_free_py_types_array(&py_svr_resc_types); /* all resources */
pbs_python_free_py_types_array(&py_que_attr_types); /* pbs.queue attrs */
pbs_python_free_py_types_array(&py_job_attr_types); /* pbs.job attrs */
pbs_python_free_py_types_array(&py_svr_attr_types); /* pbs.server attrs */
pbs_python_free_py_types_array(&py_resv_attr_types); /* pbs.resv attrs */
pbs_python_free_py_types_array(&py_vnode_attr_types); /* pbs.vnode attrs */
Py_CLEAR(py_pbs_statobj);
interp_data->pbs_python_types_loaded = 0;
return;
}
/**
* @brief
* This routine is called at the embedded intialization time, to load all
* the Python types into a dictionary. Mapping the name to a python type.
* The dictionary items are:
* Key =
* Value =
*
* NOTES:
* The Dictionary overwrites if a key already exists!
*
* @return int
* @retval -1 : failure
* @retval 0 : success
*
* side effects:
* Any python exception raised is cleared via the call to
* pbs_python_write_error_to_log
*/
int
pbs_python_load_python_types(struct python_interpreter_data *interp_data)
{
PyObject *py_import = NULL; /* new */
PyObject *py_sys_modules = NULL; /* Borrowed ref */
if ((PBS_PythonTypes)) { /* ok already loaded */
return 0;
}
interp_data->pbs_python_types_loaded = 0; /* just to be safe */
if (!(py_import =
PyImport_ImportModuleEx((char *) PBS_PYTHON_V1_MODULE, NULL, NULL,
NULL))) {
goto ERROR_EXIT;
}
/* we don't need it any more, see next for explanation */
Py_CLEAR(py_import);
pbs_python_write_object_to_log(PyImport_GetModuleDict(), "sys.modules=", LOG_DEBUG);
/* At this point the sys.modules loads module from __init__.py of
* PBS_PYTHON_V1_MODULE, which may as a side effect load a bunch of other
* modules. So now we get the actual module from sys.modules
*/
py_sys_modules = PyImport_GetModuleDict(); /* get sys.modules */
if (!(PyPbsV1Module_Obj = PyDict_GetItemString(py_sys_modules, PBS_PYTHON_V1_MODULE))) {
goto ERROR_EXIT;
}
Py_INCREF(PyPbsV1Module_Obj); /* since dict.get returns borrowed ref*/
if (!(PBS_PythonTypes =
PyObject_GetAttrString(PyPbsV1Module_Obj,
PBS_PYTHON_V1_TYPES_DICTIONARY))) {
goto ERROR_EXIT;
}
/* check and make sure it is a mapping */
if (!PyDict_Check(PBS_PythonTypes)) {
log_err(-1, pbs_python_daemon_name,
"FATAL: PBS_PythonTypes object does not support mapping protocol");
goto ERROR_EXIT;
}
if ((pbs_python_setup_types_table() == -1)) {
goto ERROR_EXIT;
}
/* setup all attrs for pbs_resource class */
if ((pbs_python_setup_python_resource_type() == -1))
goto ERROR_EXIT;
/* setup all attrs for queue class */
if ((pbs_python_setup_queue_class_attributes() == -1))
goto ERROR_EXIT;
/* setup all attrs for job class */
if ((pbs_python_setup_job_class_attributes() == -1))
goto ERROR_EXIT;
/* setup all attrs for server class */
if ((pbs_python_setup_server_class_attributes() == -1))
goto ERROR_EXIT;
/* setup all attrs for reservation (resv) class */
if ((pbs_python_setup_resv_class_attributes() == -1))
goto ERROR_EXIT;
/* setup all attrs for vnode class */
if ((pbs_python_setup_vnode_class_attributes() == -1))
goto ERROR_EXIT;
interp_data->pbs_python_types_loaded = 1;
return 0;
ERROR_EXIT:
pbs_python_write_error_to_log(__func__);
Py_CLEAR(py_import); /* just in case */
pbs_python_unload_python_types(interp_data);
return -1;
}
/**
* @brief
* A convenience function where given a Python object 'py_resource'
* representing 'reslist_name', set its 'resc' to 'value'.
*
* @param[in] py_resource - Python resource list object to set
* @param[in] reslist_name - name of resource list
* @param[in] resc - name of resource to set
* @param[in] value - value of resource being set
*
* @return int
* @retval != -1 - success
* @retval -1 - failure
*
*/
static int
set_in_python(PyObject *py_resource,
char *reslist_name, char *resc, char *value)
{
int rc;
int hook_set_mode_orig;
hook_set_mode_orig = hook_set_mode;
/* C_MODE is permissive mode unlike PY_MODE, which would enable */
/* extra checks. PY_MODE is needed only if we're loading data */
/* from outside (i.e. specified by hook writer). Here, */
/* set_in_python() is an internal function that is called when */
/* loading data from PBS data structures. */
hook_set_mode = C_MODE;
rc = pbs_python_object_set_attr_string_value(py_resource, resc, value);
hook_set_mode = hook_set_mode_orig;
if (rc == -1) {
LOG_ERROR_ARG2("%s:failed to set resource <%s>",
reslist_name, resc);
}
return (rc);
}
/** @brief
* Given a list of entity resource values (limits) in 'resc_value_list',
* if py_resource' is not NULL, then set the Python resource object
* represented by 'py_resource' to the values given in 'resc_value_list'.
* Otherwise, if 'py_resource' is NULL, and then return a
* comma-separated string of resource values in 'resc_value_list' into
* 'p_strbuf'.
* @note
* The returned string in 'p_strbuf' is in a privately malloced area, and
* should not be freed outside this function.
*
* @param[in] resc_value_list - list of resource values (=
* al_name al_resc al_value
* --------- -------- ----------
* max_queued_res file [u:alpha=110gb]
* max_queued_res ncpus [u:bayucan=9]
* max_queued_res file [u:fatir=120gb]
* max_queued_res file [u:mega=115gb]
*
* So we store these in an intermediate list (entity_head)
* in a sorted way, so as to group them according to resource names.
* By comparing adjacent entries, we can determine which values
* belong to a particular resource name.
*
* entity_head->
* al_name al_resc al_value
* --------- -------- ----------
* max_queued_res file [u:alpha=110gb]
* max_queued_res file [u:fatir=120gb]
* max_queued_res file [u:omega=115gb]
* max_queued_res ncpus [u:bayucan=9]
*
* And process 'entity_head' in a way that the following is stored in
* 'ret_str_value':
* max_queued_res=file="[u:alpha=110gb],[u:fatir=120gb],[u:omega]",ncpus=[u:bayucan=9]
* <- note: there's an enclosing quote in multi-valued limits
*/
CLEAR_HEAD(entity_head);
/* need to append values in a sorted way */
nlen = 1; /* 1 for \0 */
plist = (svrattrl *) GET_NEXT(*resc_value_list);
while (plist) {
if (add_to_svrattrl_list_sorted(&entity_head,
plist->al_name, plist->al_resc,
plist->al_value, plist->al_op,
plist->al_resc) == -1) {
free_attrlist(&entity_head);
log_err(-1, __func__,
"failed populating entity limits value");
return (-1);
}
nlen += 1 + /* for ',' */
strlen(plist->al_resc) +
1 + /* for '=' */
strlen(plist->al_value) +
3; /* allocate for each possible */
/* '"' and ',' in case we have a */
/* multi-valued resource limit. Ex. */
/* file="[u:alpha=50gb],[u:fap=60gb]" */
plist = (svrattrl *) GET_NEXT(plist->al_link);
}
if (nlen > ret_len) {
nlen += BUF_SIZE; /* malloc a larger size */
tmp_str = (char *) realloc(ret_str_value, nlen);
if (tmp_str == NULL) {
log_err(-1, __func__,
"failed to realloc string buffer!");
return (-1);
}
ret_str_value = tmp_str;
ret_len = nlen;
}
/* at this point, we have enough buffer space in */
/* ret_str_value */
/*
Algorithm:
3 variables are used to keep track of the individual entries
in the sorted 'entity_head' list.
1. cur_resc is the current resource/value line being looked at.
2. bef_resc is the resource/value from the previous line.
3. next_resc is the resource/value on the next line.
Then there's a buffer 'ret_str_value' that accumulates values
associated with a given resource name. and
are those associated with 'cur_resc'.
bef_resc == NULL, next_resc == NULL
-> if returning string value, then
ret_str_value==
else
set .=
bef_resc == NULL, next_resc != cur_resc
-> if returning string value, then
ret_str_value==
else
set .=
bef_resc == NULL, next_resc == cur_resc
-> if returning string value, then
start accumulating values:
ret_str_value="=\""
else
ret_str_value=""
bef_resc == cur_resc, cur_resc != next_resc
-> if returning string value,
terminate the current string value:
ret_str_value += ",\""
else
set .=,
bef_resc == cur_resc, cur_resc == next_resc
-> continue on the string value:
ret_str_value += ","
bef_resc != cur_resc, cur_resc != next_resc
-> if returning string value,
start a new set of resource/value pairs:
ret_str_value += ",="
else
set .=
bef_resc != cur_resc, cur_resc == next_resc
if returning string value,
ret_str_value += "=\""
else
ret_str_value = ""
*/
svrattr_val_tmp = (svrattrl *) GET_NEXT(entity_head);
bef_resc = NULL;
while (svrattr_val_tmp) {
svrattr_val_next =
(svrattrl *) GET_NEXT(svrattr_val_tmp->al_link);
cur_resc = svrattr_val_tmp->al_resc;
if (cur_resc == NULL) {
bef_resc = cur_resc;
svrattr_val_tmp = svrattr_val_next;
continue;
}
if (svrattr_val_next != NULL) {
if (svrattr_val_next->al_resc == NULL) {
bef_resc = cur_resc;
svrattr_val_tmp = svrattr_val_next;
continue;
}
next_resc = svrattr_val_next->al_resc;
} else {
next_resc = NULL;
}
if (bef_resc == NULL) {
if (next_resc == NULL) {
if (py_resource == NULL) {
sprintf(ret_str_value, "%s=%s",
svrattr_val_tmp->al_resc,
svrattr_val_tmp->al_value);
} else {
if (set_in_python(py_resource,
reslist_name,
svrattr_val_tmp->al_resc,
svrattr_val_tmp->al_value) == -1)
rc = -1;
}
if (hook_debug.data_fp != NULL) {
fprintf(hook_debug.data_fp,
"%s.%s[%s]=%s\n",
(char *) hook_debug.objname,
reslist_name,
svrattr_val_tmp->al_resc,
svrattr_val_tmp->al_value);
}
} else {
if (strcmp(cur_resc, next_resc) != 0) {
if (py_resource == NULL) {
sprintf(ret_str_value, "%s=%s",
svrattr_val_tmp->al_resc,
svrattr_val_tmp->al_value);
} else {
if (set_in_python(py_resource,
reslist_name,
svrattr_val_tmp->al_resc,
svrattr_val_tmp->al_value) == -1)
rc = -1;
}
if (hook_debug.data_fp != NULL) {
fprintf(hook_debug.data_fp,
"%s.%s[%s]=%s\n",
(char *) hook_debug.objname,
reslist_name,
svrattr_val_tmp->al_resc,
svrattr_val_tmp->al_value);
}
} else {
if (py_resource == NULL) {
sprintf(ret_str_value,
"%s=\"%s",
svrattr_val_tmp->al_resc,
svrattr_val_tmp->al_value);
} else {
/* use ret_str_value */
/* as value buffer */
strcpy(ret_str_value,
svrattr_val_tmp->al_value);
}
if (hook_debug.data_fp != NULL) {
fprintf(hook_debug.data_fp,
"%s.%s[%s]=%s",
(char *) hook_debug.objname,
reslist_name,
svrattr_val_tmp->al_resc,
svrattr_val_tmp->al_value);
}
}
}
} else {
if (strcmp(bef_resc, cur_resc) == 0) {
strcat(ret_str_value, ",");
strcat(ret_str_value,
svrattr_val_tmp->al_value);
if (hook_debug.data_fp != NULL) {
fprintf(hook_debug.data_fp,
",%s",
svrattr_val_tmp->al_value);
}
if ((next_resc != NULL) &&
(strcmp(cur_resc, next_resc) != 0)) {
if (py_resource == NULL) {
/* terminate entity val */
strcat(ret_str_value, "\"");
} else {
if (set_in_python(py_resource,
reslist_name,
svrattr_val_tmp->al_resc,
ret_str_value) == -1)
rc = -1;
}
if (hook_debug.data_fp != NULL) {
fprintf(hook_debug.data_fp,
"\n");
}
}
} else { /* start new */
if (py_resource == NULL) {
strcat(ret_str_value, ",");
} else {
ret_str_value[0] = '\0';
}
if ((next_resc == NULL) ||
(strcmp(cur_resc, next_resc) != 0)) {
if (py_resource == NULL) {
strcat(ret_str_value,
svrattr_val_tmp->al_resc);
strcat(ret_str_value, "=");
strcat(ret_str_value,
svrattr_val_tmp->al_value);
} else {
if (set_in_python(py_resource,
reslist_name,
svrattr_val_tmp->al_resc,
svrattr_val_tmp->al_value) == -1)
rc = -1;
}
if (hook_debug.data_fp !=
NULL) {
fprintf(hook_debug.data_fp,
"%s.%s[%s]=%s\n",
(char *) hook_debug.objname,
reslist_name,
svrattr_val_tmp->al_resc,
svrattr_val_tmp->al_value);
}
} else { /* cur_resc == next_resc */
if (py_resource == NULL) {
strcat(ret_str_value,
svrattr_val_tmp->al_resc);
strcat(ret_str_value, "=\"");
strcat(ret_str_value,
svrattr_val_tmp->al_value);
} else {
/* using as value string */
strcpy(ret_str_value,
svrattr_val_tmp->al_value);
}
if (hook_debug.data_fp !=
NULL) {
fprintf(hook_debug.data_fp,
"%s.%s[%s]=%s",
(char *) hook_debug.objname,
reslist_name,
svrattr_val_tmp->al_resc,
svrattr_val_tmp->al_value);
}
}
}
}
bef_resc = cur_resc;
svrattr_val_tmp = svrattr_val_next;
}
free_attrlist(&entity_head);
if (py_resource == NULL)
*p_strbuf = ret_str_value;
return (rc);
}
/**
* @brief
* Given a list of resource values in 'resc_value_list', if
* py_resource' is not NULL, then set the Python resource object
* represented by 'py_resource' to the values given in 'resc_value_list'.
* If 'py_resource' is NULL, and then return a comma-separated string
* into 'p_strbuf', which represent the values given in 'resc_value_list'.
* @note
* The returned string in 'p_strbuf' is in a private malloced area that
* should not be freed outside this function.
*
* @param[in] resc_value_list - list of resource values (=al_resc) +
1 + /* for '=' */
strlen(svrattr_val_tmp->al_value) +
1; /* for '\0' */
if (nlen > ret_len) {
nlen += BUF_SIZE; /* malloc a larger size */
tmp_str = (char *) realloc(ret_str_value, nlen);
if (tmp_str == NULL) {
log_err(-1, __func__,
"failed to realloc string buffer!");
return (-1);
}
ret_str_value = tmp_str;
ret_len = nlen;
}
if (*ret_str_value == '\0') {
sprintf(ret_str_value, "%s=%s",
svrattr_val_tmp->al_resc,
svrattr_val_tmp->al_value);
} else {
strcat(ret_str_value, ",");
strcat(ret_str_value, svrattr_val_tmp->al_resc);
strcat(ret_str_value, "=");
strcat(ret_str_value, svrattr_val_tmp->al_value);
}
} else {
if (set_in_python(py_resource,
reslist_name,
svrattr_val_tmp->al_resc,
svrattr_val_tmp->al_value) == -1) {
rc = -1;
}
}
if (hook_debug.data_fp != NULL) {
fprintf(hook_debug.data_fp, "%s.%s[%s]=%s\n",
(char *) hook_debug.objname,
reslist_name, svrattr_val_tmp->al_resc,
svrattr_val_tmp->al_value);
}
svrattr_val_tmp =
(svrattrl *) GET_NEXT(svrattr_val_tmp->al_link);
}
if (py_resource == NULL)
*p_strbuf = ret_str_value;
return (rc);
}
/**
* @brief
* Returns tthe Python string value of 'resc_val' which is of type
* 'pbs_resource_value' representing a pbs_resource object.
*
* @param[in] resc_val a 'pbs_resource_value' input type.
*
* @return PyObject *
* @retval NULL - error getting string value.
* @retval - a Python object representing the
* @retval "=,"=="
* - a concatenation of string values for py_resource.
*
*/
PyObject *
py_resource_string_value(pbs_resource_value *resc_val)
{
char *ret_string = NULL;
if (resc_val == NULL) {
Py_RETURN_NONE;
}
if (TYPE_ENTITY(resc_val->attr_def_p->at_type)) {
set_entity_resource_or_return_value(&(resc_val->value_list),
resc_val->attr_def_p->at_name,
NULL, &ret_string);
} else { /* a regular resource */
set_resource_or_return_value(&(resc_val->value_list),
resc_val->attr_def_p->at_name,
NULL, &ret_string);
}
/* New reference returned below */
return PyUnicode_FromString(ret_string);
}
/*
* ---------- ATTRIBUTE CONVERSION HELPER METHODS ------------
*/
/**
* @brief
*
* Populates a Python instance 'py_instance' with values found in
* an attributes data array.
*
* @param[in] py_instance - a Python object/class to populate
* @param[in] attr_py_array - list of Python types to map attributes with
* @param[in] attr_data_array - array of actual attribute names/resources/values
* @param[in] attr_def_array - array of attribute definitions (ex. job_attr_def)
* @param[in] attr_def_array_size - size of attr_def_array.
* @param[in] perf_label - passed on to hook_perf_stat* call.
* @param[in] perf_action - passed on to hook_perf_stat* call.
*
* @return indication of whether or not 'py_instance' was completely
* populated or not
* @return 0 - completely populated
* @return -1 - incompletely populated
*
* @note
* This function calls a single hook_perf_stat_start()
* that has some malloc-ed data that are freed in the
* hook_perf_stat_stop() call, which is done at the end of
* this function.
* Ensure that after the hook_perf_stat_start(), all
* program execution path lead to hook_perf_stat_stop()
* call.
*/
int
pbs_python_populate_attributes_to_python_class(PyObject *py_instance,
PyObject **attr_py_array,
attribute *attr_data_array,
attribute_def *attr_def_array,
int attr_def_array_size, char *perf_label, char *perf_action)
{
int i = 0; /* index */
int encode_rv = 0; /* at_encode functions return value */
int rc = -1;
int ret_rc = 0;
svrattrl *svrattr_val = NULL; /* tmp pointer */
svrattrl *svrattr_val_tmp = NULL; /* tmp pointer for traversal*/
pbs_list_head pheadp;
attribute *attr_p = NULL;
attribute_def *attr_def_p = NULL;
PyObject *py_attr_resc = NULL; /* for resource types */
char *value_str = NULL;
char *new_value_str = NULL;
pbs_resource_value *resc_val;
hook_perf_stat_start(perf_label, perf_action, 0);
for (i = 0; i < attr_def_array_size; i++) {
attr_p = attr_data_array + i;
attr_def_p = attr_def_array + i;
memset(&pheadp, 0, sizeof(pheadp));
CLEAR_HEAD(pheadp);
svrattr_val = NULL;
encode_rv = attr_def_p->at_encode(attr_p,
/* linked list */ &pheadp,
/* name */ attr_def_p->at_name,
/* resource */ NULL,
/* Encoding type */ ATR_ENCODE_HOOK,
/* returned svrattrl */ &svrattr_val);
if ((encode_rv == 0) && (svrattr_val != NULL)) {
encode_rv = 1;
}
if (encode_rv == 0) {
/* not set or no value */
continue;
} else if (encode_rv >= 1) { /* good, single value */
/* we could be a resource list */
if (ATTR_IS_RESC(attr_def_p)) {
if (!PyObject_HasAttrString(py_instance, attr_def_p->at_name)) {
free_attrlist(&pheadp);
continue;
}
/* NOTE the below is a new reference */
py_attr_resc =
PyObject_GetAttrString(py_instance,
attr_def_p->at_name);
if (py_attr_resc == NULL) {
pbs_python_write_error_to_log(__func__);
free_attrlist(&pheadp);
continue;
}
/* Mark resource currently has no value */
/* loaded, but the value will be set later */
/* as needed, by saving the value in */
/* pbs_resource_value_list */
rc = pbs_python_object_set_attr_integral_value(
py_attr_resc,
PY_RESOURCE_HAS_VALUE, FALSE);
if (rc == -1) {
LOG_ERROR_ARG2("%s:failed to set resource <%s> to False",
attr_def_p->at_name,
PY_RESOURCE_HAS_VALUE);
ret_rc = -1;
} else {
sprintf(log_buffer, "set py_resource %s %s to FALSE",
attr_def_p->at_name,
PY_RESOURCE_HAS_VALUE);
resc_val =
(pbs_resource_value *) malloc(
sizeof(pbs_resource_value));
if (resc_val ==
NULL) {
free_attrlist(&pheadp);
continue;
}
(void) memset((char *) resc_val, (int) 0,
(size_t) sizeof(pbs_resource_value));
CLEAR_LINK(resc_val->all_rescs);
/* no need to incref py_attr_resc */
/* since that's already done */
/* with the PyObject_GetAttrString() */
/* call earlier. */
resc_val->py_resource = py_attr_resc;
resc_val->attr_def_p = attr_def_p;
CLEAR_HEAD(resc_val->value_list);
list_move(&pheadp,
&resc_val->value_list);
append_link(&pbs_resource_value_list,
&resc_val->all_rescs,
(pbs_resource_value *) resc_val);
resc_val->py_resource_str_value =
py_resource_string_value(resc_val);
}
} else { /* attribute */
/* PBS' ATTR_inter/ATTR_block/ATTR_X11_port can either have a boolean-like */
/* value for client (i.e. "True" or "False"), or an int-like */
/* value for others (e.g. "2274" for port number) */
/* Python's version of these attributes are defined as ints, */
/* and are not modifiable in a hook script. So we need to */
/* map the values into something consistent. */
if ((strcmp(attr_def_p->at_name, ATTR_inter) == 0) ||
(strcmp(attr_def_p->at_name, ATTR_block) == 0) ||
(strcmp(attr_def_p->at_name, ATTR_X11_port) == 0)) {
char inter_val[2];
if (strcasecmp(svrattr_val->al_value, ATR_FALSE) == 0) {
strcpy(inter_val, "0");
} else {
strcpy(inter_val, "1");
}
rc = pbs_python_object_set_attr_string_value(py_instance,
attr_def_p->at_name,
inter_val);
if ((rc != -1) && (hook_debug.data_fp != NULL)) {
fprintf(hook_debug.data_fp, "%s.%s=%s\n", (char *) hook_debug.objname,
attr_def_p->at_name, inter_val);
}
} else if ((strcmp(attr_def_p->at_name,
ATTR_NODE_state) == 0) ||
(strcmp(attr_def_p->at_name,
ATTR_NODE_ntype) == 0)) {
/* ignore these attributes, dealt with externally */
free_attrlist(&pheadp);
continue;
} else if ((strcmp(attr_def_p->at_name,
ATTR_NODE_Sharing) == 0)) {
attribute lattr;
char nshare_str[HOOK_BUF_SIZE];
rc = decode_sharing(&lattr, attr_def_p->at_name, 0,
svrattr_val->al_value);
if (rc == 0) {
snprintf(nshare_str, sizeof(nshare_str), "%ld",
lattr.at_val.at_long);
rc = pbs_python_object_set_attr_string_value(py_instance,
attr_def_p->at_name, nshare_str);
if ((rc != -1) && (hook_debug.data_fp != NULL)) {
fprintf(hook_debug.data_fp, "%s.%s=%s\n", (char *) hook_debug.objname,
attr_def_p->at_name, nshare_str);
}
}
} else if (TYPE_ENTITY(attr_def_p->at_type)) {
/* an entity attribute - can have a list of values */
svrattr_val_tmp = svrattr_val;
while (svrattr_val_tmp) {
new_value_str = NULL;
value_str = pbs_python_object_get_attr_string_value(
py_instance, svrattr_val_tmp->al_name);
if (value_str != NULL) {
new_value_str = malloc(strlen(value_str) +
strlen(svrattr_val_tmp->al_value) + 2);
/* +2 for: "," and "\0" */
if (new_value_str == NULL) {
LOG_ERROR_ARG2(
"%s:malloc failed extending entity <%s>",
attr_def_p->at_name,
svrattr_val_tmp->al_name);
ret_rc = -1;
} else {
sprintf(new_value_str, "%s,%s",
value_str, svrattr_val_tmp->al_value);
}
}
rc = pbs_python_object_set_attr_string_value(
py_instance,
attr_def_p->at_name,
new_value_str ? new_value_str : svrattr_val->al_value);
if ((rc != -1) && (hook_debug.data_fp != NULL)) {
fprintf(hook_debug.data_fp, "%s.%s=%s\n", (char *) hook_debug.objname,
attr_def_p->at_name,
new_value_str ? new_value_str : svrattr_val->al_value);
}
if (new_value_str != NULL) {
free(new_value_str);
}
svrattr_val_tmp = (svrattrl *) GET_NEXT(
svrattr_val_tmp->al_link);
} /* while */
} else {
rc = pbs_python_object_set_attr_string_value(py_instance,
attr_def_p->at_name,
svrattr_val->al_value);
if ((rc != -1) && (hook_debug.data_fp != NULL)) {
fprintf(hook_debug.data_fp, "%s.%s=%s\n", (char *) hook_debug.objname,
attr_def_p->at_name, svrattr_val->al_value);
}
}
if (rc == -1) {
LOG_ERROR_ARG2("%s:failed to set attribute <%s>",
"", attr_def_p->at_name);
ret_rc = -1;
}
}
free_attrlist(&pheadp);
} else { /* error */
continue;
}
} /* for */
hook_perf_stat_stop(perf_label, perf_action, 0);
return ret_rc;
}
/**
* @brief
*
* Populates a Python instance 'py_instance' with values found in
* a svrattrl list.
*
* @param[in] py_instance - a Python object/class to populate
* @param[in] svrattrl_list - a pbs_list_head with svrattrl entries whose
* values will be used to populate 'py_instance'
* @param[in] perf_label - data passed on to hook_perf_stat* call
* @param[in] perf_action - dat passed on to hook_perf_stat* call
*
* @return indication of whether or not 'py_instance' was completely
* populated or not
* @return 0 - completely populated
* @return -1 - incompletely populated
*
* @note
* This function calls a single hook_perf_stat_start()
* that has some malloc-ed data that are freed in the
* hook_perf_stat_stop() call, which is done at the end of
* this function.
* Ensure that after the hook_perf_stat_start(), all
* program execution path lead to hook_perf_stat_stop()
* call.
*/
int
pbs_python_populate_python_class_from_svrattrl(PyObject *py_instance, pbs_list_head *svrattrl_list, char *perf_label, char *perf_action)
{
svrattrl *plist = NULL;
int rc = 0;
int ret_rc = 0;
PyObject *py_attr_resc = NULL; /* for resource types */
char *objname = NULL;
if (hook_debug.input_fp != NULL) {
if (PyObject_IsInstance(py_instance,
pbs_python_types_table[PP_JOB_IDX].t_class))
objname = EVENT_JOB_OBJECT;
else if (PyObject_IsInstance(py_instance,
pbs_python_types_table[PP_RESV_IDX].t_class))
objname = EVENT_RESV_OBJECT;
else if (PyObject_IsInstance(py_instance,
pbs_python_types_table[PP_VNODE_IDX].t_class))
objname = EVENT_VNODE_OBJECT;
else
objname = EVENT_OBJECT;
}
print_svrattrl_list("pbs_python_populate_python_class_from_svrattrl==>",
svrattrl_list);
hook_perf_stat_start(perf_label, perf_action, 0);
plist = (svrattrl *) GET_NEXT(*svrattrl_list);
while (plist) {
if (plist->al_resc) {
if (!PyObject_HasAttrString(py_instance, plist->al_name)) {
plist = (svrattrl *) GET_NEXT(plist->al_link);
continue;
}
py_attr_resc = PyObject_GetAttrString(py_instance,
plist->al_name);
if (!py_attr_resc) {
snprintf(log_buffer, LOG_BUF_SIZE - 1,
"Could not find %s", plist->al_name);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
pbs_python_write_error_to_log(log_buffer);
ret_rc = -1;
} else {
rc = pbs_python_object_set_attr_string_value(py_attr_resc,
plist->al_resc, plist->al_value);
Py_DECREF(py_attr_resc);
if (rc == -1) {
LOG_ERROR_ARG2("%s:failed to set resource <%s>",
plist->al_resc, plist->al_name);
ret_rc = -1;
} else if (hook_debug.input_fp != NULL) {
fprintf(hook_debug.input_fp, "%s.%s[%s]=%s\n", objname,
plist->al_name, plist->al_resc, plist->al_value);
}
}
} else {
if (PyObject_IsInstance(py_instance,
pbs_python_types_table[PP_VNODE_IDX].t_class) &&
(strcmp(plist->al_name, VNATTR_HOOK_REQUESTOR) == 0)) {
/* an special value not be Python set */
plist = (svrattrl *) GET_NEXT(plist->al_link);
continue;
}
rc = pbs_python_object_set_attr_string_value(py_instance,
plist->al_name, return_internal_value(plist->al_name, plist->al_value));
if (rc == -1) {
LOG_ERROR_ARG2("%s:failed to set attribute <%s>",
"", plist->al_name);
ret_rc = -1;
} else if (hook_debug.input_fp != NULL)
fprintf(hook_debug.input_fp, "%s.%s=%s\n", objname, plist->al_name, plist->al_value);
}
plist = (svrattrl *) GET_NEXT(plist->al_link);
}
hook_perf_stat_stop(perf_label, perf_action, 0);
return (ret_rc);
}
/**
* @brief
* Returns the # of seconds equivalent to the given 'time_str' which is of
* the form [hh:[mm:]]ss[.ms]
*
* @return long
* @retval -1 or -2 for error, each filling
* a differnt log_buffer message
* @retval time in[hh:[mm:]]ss[.ms] format success
*/
static long
duration_to_secs(char *time_str)
{
char *value_tmp = NULL;
attribute attr;
int rc;
/* The *decode* functions below "munges" the value argument, so will use */
/* a copy */
value_tmp = strdup(time_str);
if (value_tmp == NULL) {
snprintf(log_buffer, LOG_BUF_SIZE - 1, "strdup failed! (errno %d)", errno);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
return -1;
}
clear_attr(&attr, job_attr_def);
/* just a dummy attribute representing "walltime" to get the # of secs */
/* of duration time */
rc = decode_time(&attr, WALLTIME_RESC, NULL, value_tmp);
if (value_tmp) {
free(value_tmp);
}
if (rc != 0) {
snprintf(log_buffer, LOG_BUF_SIZE - 1, "input value %s not of the right format'",
time_str);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
return (-2);
}
return (attr.at_val.at_long);
}
/**
*
* @brief
* Compares 2 pbs variables string lists (i.e. comma-separated lists of
* var=value entries).
*
* @param[in] varl1 - variable string list #1
* @param[in] varl2 - variable string list #2
*
* @return int
* @retval 1 if the variable string lists are the same
* @retval 0 otherwise
*/
int
varlist_same(char *varl1, char *varl2)
{
pbs_list_head list1; /* Caution: list maintained in sorted order */
pbs_list_head list2; /* Caution: list maintained in sorted order */
char *pc, *pc1;
char *env_var;
char *env_val;
char *varl1_dup = NULL;
char *varl2_dup = NULL;
svrattrl *pal1 = NULL;
svrattrl *pal2 = NULL;
int rc;
if ((varl1 == NULL) || (varl2 == NULL))
return 0;
/* quick test */
if (strcmp(varl1, varl2) == 0) {
return 1;
}
varl1_dup = strdup(varl1);
if (varl1_dup == NULL)
return 0;
varl2_dup = strdup(varl2);
if (varl2_dup == NULL) {
free(varl1_dup);
return 0;
}
CLEAR_HEAD(list1);
CLEAR_HEAD(list2);
pc = strtok(varl1_dup, ",");
while (pc != NULL) {
env_var = pc;
env_val = NULL;
pc1 = strchr(pc, '=');
if (pc1) {
*pc1 = '\0';
env_val = pc1 + 1;
}
(void) add_to_svrattrl_list_sorted(&list1, env_var, NULL,
env_val ? env_val : "", 0, NULL);
pc = strtok(NULL, ",");
}
pc = strtok(varl2_dup, ",");
while (pc != NULL) {
env_var = pc;
env_val = NULL;
pc1 = strchr(pc, '=');
if (pc1) {
*pc1 = '\0';
env_val = pc1 + 1;
}
(void) add_to_svrattrl_list_sorted(&list2, env_var, NULL,
env_val ? env_val : "", 0, NULL);
pc = strtok(NULL, ",");
}
/* now compare the 2 sorted lists, which means if the 2 lists are */
/* the same, then there should be a line by line match. */
pal1 = (svrattrl *) GET_NEXT(list1);
pal2 = (svrattrl *) GET_NEXT(list2);
rc = 1;
while ((pal1 != NULL) && (pal2 != NULL)) {
if ((strcmp(pal1->al_name, pal2->al_name) != 0) ||
(strcmp(pal1->al_value, pal2->al_value) != 0)) {
rc = 0;
goto varlist_same_end;
}
pal1 = (svrattrl *) GET_NEXT(pal1->al_link);
pal2 = (struct svrattrl *) GET_NEXT(pal2->al_link);
}
/* in the end, if they both match, both pointers must not be pointing anywhere */
if ((pal1 != NULL) || (pal2 != NULL)) {
rc = 0;
}
varlist_same_end:
free_attrlist(&list1);
free_attrlist(&list2);
free(varl1_dup);
free(varl2_dup);
return (rc);
}
/**
* @brief
* Load the cached values found 'pbs_resource_value_list' into the
* Python resource list type object, py_resource_match.
*
* @param[in] py_resource_match - the Resource list type object.
*
* @return int
* @retval 0 - for success.
* @retval != 0 - if some failure occurred.
*
*/
static int
load_cached_resource_value(PyObject *py_resource_match)
{
pbs_resource_value *resc_val = NULL;
int rc;
resc_val = (pbs_resource_value *) GET_NEXT(pbs_resource_value_list);
while (resc_val != NULL) {
if ((resc_val->py_resource != NULL) &&
(py_resource_match == resc_val->py_resource)) {
break;
}
resc_val = (pbs_resource_value *) GET_NEXT(resc_val->all_rescs);
}
if (resc_val == NULL) {
/* no match */
return (0); /* no cached value found */
}
if (TYPE_ENTITY(resc_val->attr_def_p->at_type)) {
rc = set_entity_resource_or_return_value(
&(resc_val->value_list), resc_val->attr_def_p->at_name,
resc_val->py_resource, NULL);
} else { /* a regular resource */
rc = set_resource_or_return_value(&(resc_val->value_list),
resc_val->attr_def_p->at_name,
resc_val->py_resource, NULL);
}
if (rc == 0) {
hook_set_mode = C_MODE;
rc = pbs_python_object_set_attr_integral_value(
resc_val->py_resource, PY_RESOURCE_HAS_VALUE, TRUE);
hook_set_mode = PY_MODE;
if (rc == -1) {
LOG_ERROR_ARG2("%s:failed to set resource <%s>",
resc_val->attr_def_p->at_name,
PY_RESOURCE_HAS_VALUE);
}
Py_DECREF(resc_val->py_resource);
free_attrlist(&resc_val->value_list);
delete_link(&resc_val->all_rescs);
free(resc_val);
}
return (rc);
}
/**
*
* @brief
* Repopulates the 'svrattrl_list' (pbs_list_head) with values found from
* py_instance's attributes and resources.
*
* @param[in] py_instance - Python object to get input from.
* @param[in/out] svrattrl_list - the list to populate with data, as well
* as the input list containing the
* attribute flags to retain for each attribute
* name.
* @param[in] name_prefix - If not NULL, then the value for attribute
* name in svrattr_list elements is prefixed
* with this string.
* @param[in] append - if set to 0, then 'svrattrl_list' will get
* initialized and populated with
* data(name, resource, value, attribute_flag)
* coming from 'py_instance''s
* attribute name, resource name, value, and
* 'attribute_flag' will retain the previous flag value
* if appearing on the original 'svrattrl_list'.
* - if set to 1, then 'svrattrl_list' will accumulate
* (get appended to) data(name, resource, value,
* attribute_flag) from 'py_instance', with the
* 'attribute_flag' not be taken from the original
* svrattrl_list.
* @note
* 'append' mode to 1 is usually done if calling this function multiple
* times to accumulate the 'svrattrl_list'. For instance, this can be
* useful in periodic hook when trying to get all the vnode values in
* a vnode_list.
*
* @return int
* @retval 0 for success
* @retval != 0 for error
*
*/
int
pbs_python_populate_svrattrl_from_python_class(PyObject *py_instance,
pbs_list_head *svrattrl_list, char *name_prefix, int append)
{
PyObject *py_attr_dict = NULL;
PyObject *py_attr_hookset_dict = NULL;
PyObject *py_resc_hookset_dict = NULL;
PyObject *py_attr_keys = NULL;
PyObject *py_val = NULL;
PyObject *py_keys = NULL;
PyObject *py_keys_dict = NULL;
PyObject *py_keys_dict2 = NULL;
char *name_str_dup = NULL;
char *val_str_dup = NULL;
int num_attrs, i;
pbs_list_head svrattrl_list2;
int rc = -1;
int hook_set_flag = 0;
int has_resv_duration;
char the_resc[HOOK_BUF_SIZE];
static char *the_val = NULL;
static int val_buf_size = HOOK_BUF_SIZE;
PyObject *py_resc = NULL;
long val_sec;
char *objname = NULL;
if (the_val == NULL) {
the_val = (char *) malloc(val_buf_size);
if (the_val == NULL) {
snprintf(log_buffer, LOG_BUF_SIZE - 1, "malloc failure (errno %d)",
errno);
log_err(PBSE_SYSTEM, __func__, log_buffer);
return rc;
}
}
if (hook_debug.output_fp != NULL) {
if (PyObject_IsInstance(py_instance,
pbs_python_types_table[PP_JOB_IDX].t_class))
objname = EVENT_JOB_OBJECT;
else if (PyObject_IsInstance(py_instance,
pbs_python_types_table[PP_RESV_IDX].t_class))
objname = EVENT_RESV_OBJECT;
else if (PyObject_IsInstance(py_instance,
pbs_python_types_table[PP_VNODE_IDX].t_class))
objname = EVENT_VNODE_OBJECT;
else
objname = EVENT_OBJECT;
}
CLEAR_HEAD(svrattrl_list2);
/* py_attr_dict = .attributes[] */
if (!PyObject_HasAttrString(py_instance, PY_ATTRIBUTES)) {
snprintf(log_buffer, LOG_BUF_SIZE - 1, "python object does not have '%s'", PY_ATTRIBUTES);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(PBSE_INTERNAL, __func__, log_buffer);
return rc;
}
py_attr_dict = PyObject_GetAttrString(py_instance, PY_ATTRIBUTES); /* NEW*/
if (!py_attr_dict) {
snprintf(log_buffer, LOG_BUF_SIZE - 1, "Failed to obtain event job's '%s'", PY_ATTRIBUTES);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(PBSE_INTERNAL, __func__, log_buffer);
goto svrattrl_exit;
}
if (!PyDict_Check(py_attr_dict)) {
log_err(PBSE_INTERNAL, __func__, "object's attributes not a dictionary!");
goto svrattrl_exit;
}
/* py_attr_keys = keys of .attributes[] */
py_attr_keys = PyDict_Keys(py_attr_dict); /* NEW ref */
if (!py_attr_keys) {
log_err(PBSE_INTERNAL, __func__,
"Failed to obtain event job's attributes keys");
goto svrattrl_exit;
}
if (!PyList_Check(py_attr_keys)) {
log_err(PBSE_INTERNAL, __func__, "object's attributes keys not a list!");
goto svrattrl_exit;
}
/* Get the attributes that have been set in the hook script */
py_attr_hookset_dict = PyObject_GetAttrString(
py_instance, PY_ATTRIBUTES_HOOK_SET); /* new ref */
if (py_attr_hookset_dict == NULL || !PyDict_Check(py_attr_hookset_dict)) {
LOG_ERROR_ARG2("%s: <%s> does not exist or is not a dict", objname,
PY_ATTRIBUTES_HOOK_SET);
Py_CLEAR(py_attr_hookset_dict); /* don't use if not dict */
}
/* Reservation specific, let's see if our object already contains */
/* a non-NULL, non-None ATTR_resv_duration attribute */
has_resv_duration = 0;
if (PyObject_IsInstance(py_instance,
pbs_python_types_table[PP_RESV_IDX].t_class) &&
PyObject_HasAttrString(py_instance, ATTR_resv_duration)) {
py_val = PyObject_GetAttrString(py_instance, ATTR_resv_duration); /*NEW*/
if (py_val && (py_val != Py_None)) {
has_resv_duration = 1;
}
Py_CLEAR(py_val);
}
num_attrs = PyList_Size(py_attr_keys);
if (!append) {
/* svrattrl_list2 is a copy of the original list */
/* svrattrl_list2 must be freed at the end of this func */
if (copy_svrattrl_list(svrattrl_list, &svrattrl_list2) == -1) {
log_err(errno, __func__, "failed to save svrattrl_list");
goto svrattrl_exit;
}
free_attrlist(svrattrl_list);
}
for (i = 0; i < num_attrs; i++) {
char *name_str = NULL;
resource_def *rescdef = NULL;
name_str_dup = strdup(pbs_python_list_get_item_string_value(py_attr_keys, i));
if (!name_str_dup) {
log_err(errno, __func__, "strdup error");
goto svrattrl_exit;
}
name_str = name_str_dup;
/* these don't have entries in svrattrl */
if (!name_str || (name_str[0] == '\0') ||
(strcmp(name_str, ATTR_queue) == 0) ||
in_string_list(name_str, ',', PY_PYTHON_DEFINED_ATTRIBUTES)) {
if (name_str_dup) {
free(name_str_dup);
name_str_dup = NULL;
}
continue;
}
if (!PyObject_HasAttrString(py_instance, name_str)) {
if (name_str_dup) {
free(name_str_dup);
name_str_dup = NULL;
}
continue;
}
py_val = PyObject_GetAttrString(py_instance, name_str);
/* must be Py_CLEAR(-)ed or
* Py_DECREF()-ed later, so as to not leak memory
*/
if (!py_val || (py_val == Py_None)) {
if (name_str_dup) {
free(name_str_dup);
name_str_dup = NULL;
}
continue;
}
if (PyObject_IsInstance(py_val,
pbs_python_types_table[PP_RESC_IDX].t_class)) { /* a resource */
char *resc, *val;
int k, num_keys;
PyObject *py_class = pbs_python_types_table[PP_RESC_IDX].t_class;
PyObject *py_tmp = NULL;
/* code snippet below mimics what's done in the
* __str__ method of class pbs_resource under
* /pbs/v1/_base_types.py for accessing entries
* in resource list.
*/
if (PyObject_HasAttrString(py_val, PY_RESOURCE_HAS_VALUE)) {
if (pbs_python_object_get_attr_integral_value(py_val, PY_RESOURCE_HAS_VALUE) == 0) { /* no value yet */
if (load_cached_resource_value(py_val) != 0) {
log_err(PBSE_INTERNAL, __func__,
"Failed to to load cached value for resource list");
goto svrattrl_exit;
}
}
}
/* Obtain list of resource names from
* ._attributes dictionary
*/
if (PyObject_HasAttrString(py_class, PY_ATTRIBUTES)) {
py_keys_dict = PyObject_GetAttrString(py_class,
PY_ATTRIBUTES);
}
if (!py_keys_dict || !PyDict_Check(py_keys_dict)) {
log_err(PBSE_INTERNAL, __func__,
"Failed to obtain event job's resource list dictionary");
goto svrattrl_exit;
}
py_tmp = py_keys_dict;
py_keys_dict = PyDict_Copy(py_tmp);
Py_CLEAR(py_tmp);
if (!py_keys_dict) {
log_err(PBSE_INTERNAL, __func__,
"Failed to duplicate resource list dictionary");
goto svrattrl_exit;
}
/* look into ._attributes_unknown
* for custom resource names defined in a hook but
* not yet in resource table.
*/
py_keys_dict2 = PyObject_GetAttrString(
py_val, "_attributes_unknown"); /* new ref */
if (py_keys_dict2) {
/* Merge resource list dictionary with the dictionary of
* unknown resources
*/
if (PyDict_Check(py_keys_dict2)) {
PyDict_Update(py_keys_dict, py_keys_dict2);
}
}
py_keys = PyDict_Keys(py_keys_dict);
if (!py_keys || !PyList_Check(py_keys)) {
log_err(PBSE_INTERNAL, __func__,
"Failed to obtain event job's resource list keys");
goto svrattrl_exit;
}
/* Get the resources that have been set in the hook script */
py_resc_hookset_dict = PyObject_GetAttrString(
py_val, PY_ATTRIBUTES_HOOK_SET); /* new ref */
if (py_resc_hookset_dict != NULL && !PyDict_Check(py_resc_hookset_dict)) {
Py_CLEAR(py_resc_hookset_dict); /* don't use if not dict */
}
num_keys = PyList_Size(py_keys);
for (k = 0; k < num_keys; k++) {
char *tmpstr = NULL;
tmpstr = pbs_python_list_get_item_string_value(py_keys, k);
if (tmpstr == NULL)
continue;
resc = strdup(tmpstr);
if (resc == NULL) {
log_err(errno, __func__, "strdup error");
goto svrattrl_exit;
}
tmpstr = pbs_python_object_get_attr_string_value(py_val, resc);
if (tmpstr == NULL) {
free(resc);
continue;
}
val = strdup(tmpstr);
if (val == NULL) {
log_err(errno, __func__, "strdup error");
free(resc);
goto svrattrl_exit;
}
if ((strcmp(resc, PY_RESOURCE_NAME) == 0) ||
(strcmp(resc, PY_RESOURCE_HAS_VALUE) == 0)) {
free(resc);
free(val);
continue;
}
hook_set_flag = 0;
if (py_resc_hookset_dict != NULL &&
PyDict_GetItemString(py_resc_hookset_dict, resc) != NULL) {
hook_set_flag = 1; /* resource set/unset in hook script */
}
if ((strcmp(resc, WALLTIME_RESC) == 0) && has_resv_duration) {
snprintf(log_buffer, LOG_BUF_SIZE - 1,
"Ignoring reservation resource '%s' since '%s' "
"already specified",
resc, ATTR_resv_duration);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_event(PBSEVENT_DEBUG2, PBS_EVENTCLASS_HOOK, LOG_INFO,
__func__, log_buffer);
free(resc);
free(val);
continue;
}
the_val[0] = '\0';
if (pbs_strcat(&the_val, &val_buf_size, val) == NULL) {
snprintf(log_buffer, LOG_BUF_SIZE - 1, "malloc failure (errno %d)",
errno);
log_err(PBSE_SYSTEM, __func__, log_buffer);
goto svrattrl_exit;
}
strncpy(the_resc, resc, sizeof(the_resc) - 1);
if (IS_PBS_PYTHON_CMD(pbs_python_daemon_name)) {
if ((rescdef = find_resc_def(svr_resc_def, resc)) == NULL) {
/* not a builtin or previously defined resource */
py_resc = PyObject_GetAttrString(py_val, resc); /* NEW */
if (PyBool_Check(py_resc)) {
snprintf(the_resc, sizeof(the_resc), "%s,boolean", resc);
} else if (PyObject_IsInstance(py_resc,
pbs_python_types_table[PP_TIME_IDX].t_class)) {
/* this must appear */
/* before check to */
/* Int instance */
/* for TIME object */
/* is derived from an */
/* int */
snprintf(the_resc, sizeof(the_resc), "%s,long", resc);
if (val != NULL) {
val_sec = duration_to_secs(val);
snprintf(the_val, val_buf_size, "%ld", val_sec);
}
} else if (PyLong_Check(py_resc) || PyLong_Check(py_resc)) {
snprintf(the_resc, sizeof(the_resc), "%s,long", resc);
} else if (PyFloat_Check(py_resc)) {
snprintf(the_resc, sizeof(the_resc), "%s,float", resc);
} else if (PyUnicode_Check(py_resc)) {
/* this check should come first before the test of PP_ARST_IDX instance */
/* for a regular string is also an instance/subset of PP_ARST_IDX type */
snprintf(the_resc, sizeof(the_resc), "%s,string", resc);
} else if (PyObject_IsInstance(py_resc,
pbs_python_types_table[PP_SIZE_IDX].t_class)) {
snprintf(the_resc, sizeof(the_resc), "%s,size", resc);
} else if (PyObject_IsInstance(py_resc,
pbs_python_types_table[PP_ARST_IDX].t_class)) {
snprintf(the_resc, sizeof(the_resc), "%s,string_array", resc);
} else {
snprintf(the_resc, sizeof(the_resc), "%s,string", resc);
}
Py_CLEAR(py_resc);
} else {
if (TYPE_BOOL(rescdef->rs_type)) {
snprintf(the_resc, sizeof(the_resc), "%s,boolean", resc);
} else if (TYPE_INT(rescdef->rs_type)) {
snprintf(the_resc, sizeof(the_resc), "%s,long", resc);
} else if (TYPE_FLOAT(rescdef->rs_type)) {
snprintf(the_resc, sizeof(the_resc), "%s,float", resc);
} else if (TYPE_STR(rescdef->rs_type)) {
/* this check should come first before the test of PP_ARST_IDX instance */
/* for a regular string is also an instance/subset of PP_ARST_IDX type */
snprintf(the_resc, sizeof(the_resc), "%s,string", resc);
} else if (TYPE_SIZE(rescdef->rs_type)) {
snprintf(the_resc, sizeof(the_resc), "%s,size", resc);
} else if (TYPE_ARST(rescdef->rs_type)) {
snprintf(the_resc, sizeof(the_resc), "%s,string_array", resc);
} else if (TYPE_DURATION(rescdef->rs_encode)) {
snprintf(the_resc, sizeof(the_resc), "%s,long", resc);
if (val != NULL) {
val_sec = duration_to_secs(val);
snprintf(the_val, val_buf_size, "%ld", val_sec);
}
} else {
snprintf(the_resc, sizeof(the_resc), "%s,string", resc);
}
}
}
if (add_to_svrattrl_list(svrattrl_list, name_str, the_resc, the_val,
get_svrattrl_flag(name_str, the_resc, the_val,
&svrattrl_list2, hook_set_flag),
name_prefix) == -1) {
snprintf(log_buffer, LOG_BUF_SIZE - 1, "failed to add_to_svrattrl_list(%s,%s,%s",
name_str, resc, (val ? val : ""));
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(errno, __func__, log_buffer);
free(resc);
free(val);
goto svrattrl_exit;
}
if (hook_debug.output_fp != NULL)
fprintf(hook_debug.output_fp, "%s.%s[%s]=%s\n", objname, name_str, the_resc,
return_external_value(name_str, the_val));
free(resc);
free(val);
}
} else {
char *val_str2; /* what gets sent to the server */
char val_buf[40]; /* holds JOB_NAME_UNSET_VALUE and */
char *val_str; /* what gets sent to the server */
/* 'long' value string */
long nsecs;
val_str = pbs_python_object_str(py_val); /* does not return NULL */
val_str2 = val_str;
/* For Job_Name attribute, if it got an "" value (meaning None */
/* was specified in a hook script), then mimic what PBS server */
/* does which is set it to "none". We cannot have a NULL or "" */
/* value for Job_Name as this is used for constructing job */
/* output files and accounting_logs entry and may cause the */
/* server to crash later. */
if ((strcmp(name_str, ATTR_N) == 0) && (val_str[0] == '\0')) {
strcpy(val_buf, JOB_NAME_UNSET_VALUE);
val_str2 = val_buf;
} else if ((strcmp(name_str, ATTR_resv_duration) == 0) &&
(val_str[0] != '\0')) {
nsecs = duration_to_secs(val_str);
if (nsecs < 0) {
log_err(errno, __func__, log_buffer);
goto svrattrl_exit;
}
sprintf(val_buf, "%ld", nsecs);
val_str2 = val_buf;
}
hook_set_flag = 0;
if (py_attr_hookset_dict != NULL &&
PyDict_GetItemString(py_attr_hookset_dict, name_str) != NULL) {
hook_set_flag = 1; /* attribute set/unset in a hook script */
}
if (strcmp(name_str, ATTR_v) == 0) {
svrattrl *svrattrl_e;
/* if there's a change in Variables_List value, */
/* (svrattrl_list2 (orig) vs svrattrl_list (new)), */
/* then flag as hook set */
svrattrl_e = find_svrattrl_list_entry(&svrattrl_list2, ATTR_v, NULL);
if ((svrattrl_e == NULL) ||
!varlist_same(svrattrl_e->al_value, val_str))
hook_set_flag = 1;
}
if (add_to_svrattrl_list(svrattrl_list, name_str, NULL, val_str2,
get_svrattrl_flag(name_str, NULL, val_str,
&svrattrl_list2, hook_set_flag),
name_prefix) == -1) {
snprintf(log_buffer, LOG_BUF_SIZE - 1, "failed to add_to_svrattrl_list(%s,null,%s)",
name_str, val_str);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(errno, __func__, log_buffer);
goto svrattrl_exit;
}
if (hook_debug.output_fp != NULL)
fprintf(hook_debug.output_fp, "%s.%s=%s\n", objname, name_str, return_external_value(name_str, val_str2));
}
/* must be cleared as they take on different values on each iteration */
Py_CLEAR(py_val);
Py_CLEAR(py_keys);
Py_CLEAR(py_keys_dict);
Py_CLEAR(py_keys_dict2);
Py_CLEAR(py_resc_hookset_dict);
free(name_str_dup);
name_str_dup = NULL;
} /* for loop */
rc = 0;
svrattrl_exit:
Py_CLEAR(py_attr_dict);
Py_CLEAR(py_attr_hookset_dict);
Py_CLEAR(py_resc_hookset_dict);
Py_CLEAR(py_attr_keys);
Py_CLEAR(py_val);
Py_CLEAR(py_resc);
Py_CLEAR(py_keys);
Py_CLEAR(py_keys_dict);
Py_CLEAR(py_keys_dict2);
if (name_str_dup) {
free(name_str_dup);
}
if (val_str_dup) {
free(val_str_dup);
}
/* safe to call because start of func clears this list */
free_attrlist(&svrattrl_list2);
return (rc);
}
/**
* @brief
* Causes the 'py_instance' object's attributes to be unsettable.
*
* @param[in] py_instance - PyObject with attributes
*
* @return int
* @retval 0 for success;
* @retval -1 otherwise.
*
*/
int
pbs_python_mark_object_readonly(PyObject *py_instance)
{
PyObject *py_attr_dict = NULL;
PyObject *py_attr_keys = NULL;
PyObject *py_val = NULL;
int num_attrs, i;
int rc = -1;
/* mark the owning object readonly */
rc = pbs_python_object_set_attr_integral_value(py_instance,
PY_READONLY_FLAG, TRUE);
if (rc == -1) {
snprintf(log_buffer, LOG_BUF_SIZE - 1, "Failed set object's '%s' flag", PY_READONLY_FLAG);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(PBSE_INTERNAL, __func__, log_buffer);
return (-1);
}
/* Now mark attached resources read-only */
/* py_attr_dict = .attributes[] */
if (!PyObject_HasAttrString(py_instance, PY_ATTRIBUTES)) {
snprintf(log_buffer, LOG_BUF_SIZE - 1, "encountered an object that has no '%s'",
PY_ATTRIBUTES);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(PBSE_INTERNAL, __func__, log_buffer);
return (-1);
}
py_attr_dict = PyObject_GetAttrString(py_instance, PY_ATTRIBUTES); /* NEW*/
if (!py_attr_dict) {
snprintf(log_buffer, LOG_BUF_SIZE - 1, "failed to obtain object's '%s'", PY_ATTRIBUTES);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(PBSE_INTERNAL, __func__, log_buffer);
return (-1);
}
if (!PyDict_Check(py_attr_dict)) {
snprintf(log_buffer, LOG_BUF_SIZE - 1, "object's '%s' is not a dictionary!",
PY_ATTRIBUTES);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(PBSE_INTERNAL, __func__, log_buffer);
rc = -1;
goto mark_readonly_exit;
}
/* py_attr_keys = keys of .attributes[] */
py_attr_keys = PyDict_Keys(py_attr_dict); /* NEW ref */
if (!py_attr_keys) {
snprintf(log_buffer, LOG_BUF_SIZE - 1, "Failed to obtain object's '%s' keys",
PY_ATTRIBUTES);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(PBSE_INTERNAL, __func__, log_buffer);
rc = -1;
goto mark_readonly_exit;
}
if (!PyList_Check(py_attr_keys)) {
snprintf(log_buffer, LOG_BUF_SIZE - 1, "object's '%s' keys is not a list!", PY_ATTRIBUTES);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(PBSE_INTERNAL, __func__, PY_ATTRIBUTES);
rc = -1;
goto mark_readonly_exit;
}
num_attrs = PyList_Size(py_attr_keys);
for (i = 0; i < num_attrs; i++) {
char *name_str = NULL;
name_str = pbs_python_list_get_item_string_value(py_attr_keys, i);
if (!name_str || (name_str[0] == '\0'))
continue;
if (!PyObject_HasAttrString(py_instance, name_str))
continue;
py_val = PyObject_GetAttrString(py_instance, name_str); /* NEW */
if (!py_val) {
snprintf(log_buffer, LOG_BUF_SIZE - 1, "failed to get attribute '%s' value", name_str);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(PBSE_INTERNAL, __func__, log_buffer);
rc = -1;
goto mark_readonly_exit;
}
if (PyObject_IsInstance(py_val,
pbs_python_types_table[PP_RESC_IDX].t_class)) { /* a resource */
rc = pbs_python_object_set_attr_integral_value(py_val,
PY_READONLY_FLAG, TRUE);
if (rc == -1) {
snprintf(log_buffer, LOG_BUF_SIZE - 1,
"failed to set %s '%s'", name_str, PY_READONLY_FLAG);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(PBSE_INTERNAL, __func__, log_buffer);
goto mark_readonly_exit;
}
}
/* must be cleared as they take on different values on each iteration */
Py_CLEAR(py_val);
} /* for loop */
rc = 0;
mark_readonly_exit:
Py_CLEAR(py_attr_dict);
Py_CLEAR(py_attr_keys);
Py_CLEAR(py_val);
return (rc);
}
/*
* --------------------- MODULE HELPER METHODS ----------------------------
*/
/**
*
* @brief
* Helper method returning PBS Python queue object mapping the given 'pque'
* (a pbs_queue struct) if set; otherwise, look into the list of pbs_queue
* structures managed by the local server, which matches 'que_name'.
*
* @param[in] pque - if set, this is the pbs_queue structure whose values
* will be mapped into a PBS Python queue object.
* @param[in] queue_name - if 'pque' is not set, then create a PBS Python
* queue object mapping a pbs_queue structure in
* the system that matches 'queue_name'.
* @param[in] perf_label - passed on to hook_perf_stat* call.
* @note
* This first returns any cached Python queue object found in
* 'py_hook_pbsque[]' matching 'que_name' or pque's que_name.
* Otherwise, the Python queue object returned is cached in
* 'py_hook_pbsque[]' array.
*
* @return PyObject * pointer to a Python queue object to map the
* queue.
*/
static PyObject *
_pps_helper_get_queue(pbs_queue *pque, const char *que_name, char *perf_label)
{
PyObject *py_que_class = NULL;
PyObject *py_que = NULL;
PyObject *py_qargs = NULL;
pbs_queue *que;
int tmp_rc = -1;
int i;
char perf_action[MAXBUFLEN];
long total_jobs;
attribute *qattr;
if (pque != NULL) {
que = pque;
} else {
if ((que_name == NULL) || (que_name[0] == '\0')) {
log_err(PBSE_INTERNAL, __func__,
"Unable to populate python queue object");
return NULL;
}
que = find_queuebyname((char *) que_name);
}
/* make sure que is not null */
if (!que) {
snprintf(log_buffer, LOG_BUF_SIZE - 1,
"could not find queue '%s'", que_name);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(PBSE_INTERNAL, __func__, log_buffer);
return py_que;
}
if (py_hook_pbsque != NULL) {
for (i = 0; (i < py_hook_pbsque_max) && (py_hook_pbsque[i] != NULL);
i++) {
char *qn;
qn = pbs_python_object_get_attr_string_value(py_hook_pbsque[i],
"name");
if ((qn != NULL) && (qn[0] != '\0') &&
(strcmp(qn, que->qu_qs.qu_name) == 0)) {
Py_INCREF(py_hook_pbsque[i]);
return py_hook_pbsque[i];
}
}
}
/*
* First things first create a Python queue object.
* - Borrowed reference
* - Exception is *NOT* set
*/
py_que_class = pbs_python_types_table[PP_QUE_IDX].t_class;
py_qargs = Py_BuildValue("(s)", que->qu_qs.qu_name); /* NEW ref */
if (!py_qargs) {
log_err(PBSE_INTERNAL, __func__, "could not build args list for queue");
goto ERROR_EXIT;
}
py_que = PyObject_Call(py_que_class, py_qargs, NULL);
if (!py_que) {
log_err(PBSE_INTERNAL, __func__, "failed to create a python queue object");
goto ERROR_EXIT;
}
if (py_qargs)
Py_CLEAR(py_qargs);
/*
* OK, At this point we need to start populating the que class.
*/
/* As done is statque update the state count */
if (!svr_chk_history_conf()) {
total_jobs = que->qu_numjobs;
} else {
total_jobs = que->qu_numjobs - (que->qu_njstate[JOB_STATE_MOVED] + que->qu_njstate[JOB_STATE_FINISHED] + que->qu_njstate[JOB_STATE_EXPIRED]);
}
set_qattr_l_slim(que, QA_ATR_TotalJobs, total_jobs, SET);
qattr = get_qattr(que, QA_ATR_JobsByState);
update_state_ct(qattr, que->qu_njstate, &que_attr_def[QA_ATR_JobsByState]);
/* stuff all the attributes */
snprintf((char *) hook_debug.objname, HOOK_BUF_SIZE - 1, "%s(%s)", SERVER_QUEUE_OBJECT, que->qu_qs.qu_name);
snprintf(perf_action, sizeof(perf_action), "%s:%s", HOOK_PERF_POPULATE, hook_debug.objname);
tmp_rc = pbs_python_populate_attributes_to_python_class(py_que,
py_que_attr_types,
que->qu_attr,
que_attr_def,
QA_ATR_LAST, perf_label, perf_action);
if (tmp_rc == -1) {
log_err(PBSE_INTERNAL, __func__,
"partially populated python queue object");
}
free_attr(que_attr_def, qattr, QA_ATR_JobsByState);
tmp_rc = pbs_python_mark_object_readonly(py_que);
if (tmp_rc == -1) {
log_err(PBSE_INTERNAL, __func__, "Failed to mark queue readonly!");
goto ERROR_EXIT;
}
object_counter++;
if (server.sv_qs.sv_numque > 0) {
if (py_hook_pbsque == NULL) {
py_hook_pbsque = (PyObject **) calloc(server.sv_qs.sv_numque,
sizeof(PyObject *));
if (py_hook_pbsque == NULL) {
log_err(errno, __func__,
"Failed to calloc array of cached pbs queue objects");
goto ERROR_EXIT;
}
py_hook_pbsque_max = server.sv_qs.sv_numque;
} else if (server.sv_qs.sv_numque > py_hook_pbsque_max) {
PyObject **py_hook_pbsque_tmp;
py_hook_pbsque_tmp = (PyObject **) realloc(py_hook_pbsque,
server.sv_qs.sv_numque * sizeof(PyObject *));
if (py_hook_pbsque_tmp == NULL) {
log_err(errno, __func__,
"Failed to realloc array of cached pbs queue objects");
for (i = 0; (i < py_hook_pbsque_max) &&
(py_hook_pbsque[i] != NULL);
i++) {
Py_CLEAR(py_hook_pbsque[i]);
}
free(py_hook_pbsque);
py_hook_pbsque = NULL;
goto ERROR_EXIT;
}
py_hook_pbsque = py_hook_pbsque_tmp;
for (i = py_hook_pbsque_max; i < server.sv_qs.sv_numque; i++) {
py_hook_pbsque[i] = NULL;
}
py_hook_pbsque_max = server.sv_qs.sv_numque;
}
}
if (py_hook_pbsque != NULL) {
for (i = 0; i < py_hook_pbsque_max; i++) {
if (py_hook_pbsque[i] == NULL) {
Py_INCREF(py_que);
py_hook_pbsque[i] = py_que;
break;
}
}
}
return py_que;
ERROR_EXIT:
if (PyErr_Occurred())
pbs_python_write_error_to_log(__func__);
if (py_qargs)
Py_CLEAR(py_qargs);
if (py_que)
Py_CLEAR(py_que);
PyErr_SetString(PyExc_AssertionError, "Failed to create queue object");
return NULL;
}
/**
*
* @brief
* Helper method returning a server Python Object representing the local
* (current) server.
*
* @param[in] perf_label - passed on to hook_perf_stat* call.
*
* @note
* This marks the server object "read-only" in Python mode.
* Also, this first returns the cached 'py_hook_pbsserver' object.
* Otherwise, the obtained PBS Python server object is cached in
* 'py_hook_pbsserver'.
*
* @return PyObject * pointer to a Python server object to map the
* local server values.
*/
static PyObject *
_pps_helper_get_server(char *perf_label)
{
PyObject *py_svr_class = NULL;
PyObject *py_svr = NULL;
PyObject *py_sargs = NULL;
int tmp_rc = -1;
char perf_action[MAXBUFLEN];
if (py_hook_pbsserver != NULL) {
Py_INCREF(py_hook_pbsserver);
return py_hook_pbsserver;
}
/*
* First things first create a Python queue object.
* - Borrowed reference
* - Exception is *NOT* set
*/
py_svr_class = pbs_python_types_table[PP_SVR_IDX].t_class;
py_sargs = Py_BuildValue("(s)", server_name); /* NEW ref */
if (!py_sargs) {
log_err(-1, pbs_python_daemon_name, "could not build args list for server");
goto ERROR_EXIT;
}
py_svr = PyObject_Call(py_svr_class, py_sargs, NULL);
if (!py_svr) {
log_err(-1, pbs_python_daemon_name, "failed to create a python server object");
goto ERROR_EXIT;
}
if (py_sargs)
Py_CLEAR(py_sargs);
/*
* OK, At this point we need to start populating the server class.
*/
/* As done is stat_svr update the state count */
/* update count and state counts from sv_numjobs and sv_jobstates */
set_sattr_l_slim(SVR_ATR_TotalJobs, server.sv_qs.sv_numjobs, SET);
update_state_ct(get_sattr(SVR_ATR_JobsByState), server.sv_jobstates, &svr_attr_def[SVR_ATR_JobsByState]);
update_license_ct();
/* stuff all the attributes */
strncpy((char *) hook_debug.objname, SERVER_OBJECT, HOOK_BUF_SIZE - 1);
snprintf(perf_action, sizeof(perf_action), "%s:%s", HOOK_PERF_POPULATE, hook_debug.objname);
tmp_rc = pbs_python_populate_attributes_to_python_class(py_svr,
py_svr_attr_types,
server.sv_attr,
svr_attr_def,
SVR_ATR_LAST, perf_label, perf_action);
if (tmp_rc == -1) {
log_err(PBSE_INTERNAL, __func__,
"partially populated python server object");
}
tmp_rc = pbs_python_mark_object_readonly(py_svr);
if (tmp_rc == -1) {
log_err(PBSE_INTERNAL, __func__, "Failed to mark server readonly!");
goto ERROR_EXIT;
}
object_counter++;
Py_INCREF(py_svr);
py_hook_pbsserver = py_svr;
return py_svr;
ERROR_EXIT:
if (PyErr_Occurred())
pbs_python_write_error_to_log(__func__);
if (py_sargs)
Py_CLEAR(py_sargs);
if (py_svr)
Py_CLEAR(py_svr);
PyErr_SetString(PyExc_AssertionError, "Failed to create server object");
return NULL;
}
/**
* @brief
* Helper method returning a job Python Object from a job struct
* This marks the job object "read-only" in Python mode.
* If 'qname' is not NULL or "", then the job object is returned if
* it is queued in 'qname'.
*
* @param[in] pjob_o - job info
* @param[in] jobid - job identifier
* @param[in] qname - queuename
* @param[in] perf_label - data passed on to hook_perf_stat* call
*
* @return PyObject*
* @retval job python object success
* @retval NULL error
*
*/
static PyObject *
_pps_helper_get_job(job *pjob_o, const char *jobid, const char *qname, char *perf_label)
{
PyObject *py_job_class = NULL;
PyObject *py_job = NULL;
PyObject *py_jargs = NULL;
PyObject *py_que = NULL;
PyObject *py_resv = NULL;
PyObject *py_server = NULL;
job *pjob;
int tmp_rc = -1;
int t;
char perf_action[MAXBUFLEN];
if (pjob_o != NULL) {
pjob = pjob_o;
} else {
if ((jobid == NULL) || (jobid[0] == '\0')) {
log_err(PBSE_INTERNAL, __func__,
"Unable to populate python job object");
return NULL;
}
t = is_job_array((char *) jobid);
if (t == IS_ARRAY_Single) {
pjob = find_job((char *) jobid); /* has data if instantiated */
if (pjob == NULL) { /* otherwise, return parent */
pjob = find_arrayparent((char *) jobid);
}
} else if ((t == IS_ARRAY_NO) || (t == IS_ARRAY_ArrayJob)) {
pjob = find_job((char *) jobid); /* regular or ArrayJob itself */
} else {
pjob = find_arrayparent((char *) jobid); /* subjob(s) */
}
}
/* make sure pjob is not null */
if (!pjob) {
snprintf(log_buffer, LOG_BUF_SIZE - 1, "could not find job '%s'", jobid);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(PBSE_INTERNAL, __func__, log_buffer);
return py_job;
}
if (qname && (qname[0] != '\0') &&
(strcmp(pjob->ji_qs.ji_queue, qname) != 0)) {
snprintf(log_buffer, LOG_BUF_SIZE - 1, "job '%s' not in '%s'", jobid, qname);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(PBSE_INTERNAL, __func__, log_buffer);
return py_job;
}
/*
* First things first create a Python queue object.
* - Borrowed reference
* - Exception is *NOT* set
*/
py_job_class = pbs_python_types_table[PP_JOB_IDX].t_class;
py_jargs = Py_BuildValue("(s)", pjob->ji_qs.ji_jobid); /* NEW ref */
if (!py_jargs) {
log_err(-1, pbs_python_daemon_name, "could not build args list for job");
goto ERROR_EXIT;
}
py_job = PyObject_Call(py_job_class, py_jargs, NULL);
if (!py_job) {
log_err(-1, pbs_python_daemon_name, "failed to create a python job object");
goto ERROR_EXIT;
}
if (py_jargs)
Py_CLEAR(py_jargs);
/*
* OK, At this point we need to start populating the job class.
*/
snprintf((char *) hook_debug.objname, HOOK_BUF_SIZE - 1, "%s(%s)", SERVER_JOB_OBJECT, pjob->ji_qs.ji_jobid);
snprintf(perf_action, sizeof(perf_action), "%s:%s", HOOK_PERF_POPULATE, hook_debug.objname);
tmp_rc = pbs_python_populate_attributes_to_python_class(py_job,
py_job_attr_types,
pjob->ji_wattr,
job_attr_def,
JOB_ATR_LAST, perf_label, perf_action);
if (tmp_rc == -1) {
log_err(PBSE_INTERNAL, __func__,
"partially populated python job object");
}
/* set job.queue to actual queue object */
if (pjob->ji_qs.ji_queue) {
py_que = _pps_helper_get_queue(NULL, pjob->ji_qs.ji_queue, perf_label); /* NEW ref */
if (py_que) {
if (PyObject_HasAttrString(py_job, ATTR_queue)) {
/* py_que ref ct incremented as part of py_job */
(void) PyObject_SetAttrString(py_job, ATTR_queue, py_que);
}
Py_DECREF(py_que); /* we no longer need to reference */
}
}
if (pjob->ji_myResv) {
/* set job.resv to actual reservation object */
py_resv = _pps_helper_get_resv(pjob->ji_myResv,
pjob->ji_myResv->ri_qs.ri_resvID, perf_label); /* NEW ref */
if (py_resv) {
if (PyObject_HasAttrString(py_job, ATTR_resv)) {
/* py_resv ref ct incremented as part of py_job */
(void) PyObject_SetAttrString(py_job, ATTR_resv, py_resv);
}
Py_DECREF(py_resv); /* we no longer need to reference */
}
}
/* set job.server to actual server object */
py_server = _pps_helper_get_server(perf_label); /* NEW Ref */
if (py_server) {
if (PyObject_HasAttrString(py_job, ATTR_server)) {
/* py_server ref ct incremented as part of py_job */
(void) PyObject_SetAttrString(py_job, ATTR_server, py_server);
}
Py_DECREF(py_server);
}
tmp_rc = pbs_python_mark_object_readonly(py_job);
if (tmp_rc == -1) {
log_err(PBSE_INTERNAL, __func__, "Failed to mark job readonly!");
goto ERROR_EXIT;
}
object_counter++;
return py_job;
ERROR_EXIT:
if (PyErr_Occurred())
pbs_python_write_error_to_log(__func__);
Py_CLEAR(py_jargs);
Py_CLEAR(py_job);
PyErr_SetString(PyExc_AssertionError, "Failed to create job object");
return NULL;
}
/**
* @brief
* Helper method returning a resv Python Object from a a resc_resv struct.
*
* @param[in] presv_o - reservation structure
* @param[in] resvid - reservation name
* @param[in] perf_label - passed on to hook_perf_stat* call.
*
* @return PyObject *
* @retval This returns a Python object that maps
* to a resc_resv struct taken directly from presv_o if non-NULL,
* or to the struct returned by find_resv().
*/
static PyObject *
_pps_helper_get_resv(resc_resv *presv_o, const char *resvid, char *perf_label)
{
PyObject *py_resv_class = NULL;
PyObject *py_resv = NULL;
PyObject *py_rargs = NULL;
PyObject *py_que = NULL;
PyObject *py_server = NULL;
resc_resv *presv;
int tmp_rc = -1;
char resvid_out[PBS_MAXCLTJOBID];
char server_out[MAXSERVERNAME];
char perf_action[MAXBUFLEN];
if (presv_o != NULL) {
presv = presv_o;
} else {
if ((resvid == NULL) || (resvid[0] == '\0')) {
log_err(PBSE_INTERNAL, __func__,
"Unable to populate python reservation object");
return NULL;
}
if (get_server((char *) resvid, (char *) resvid_out,
(char *) server_out)) {
snprintf(log_buffer, LOG_BUF_SIZE - 1,
"illegally formed reservation identifier %s", resvid);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(PBSE_INTERNAL, __func__, log_buffer);
return NULL;
}
presv = find_resv((char *) resvid_out);
}
if (presv == NULL) {
snprintf(log_buffer, LOG_BUF_SIZE - 1, "%s: no such reservation", resvid);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(PBSE_INTERNAL, __func__, log_buffer);
/* this takes care of incrementing ref cnt of Py_None */
Py_RETURN_NONE;
}
/*
* First things first create a Python resv object.
* - Borrowed reference
* - Exception is *NOT* set
*/
py_resv_class = pbs_python_types_table[PP_RESV_IDX].t_class;
py_rargs = Py_BuildValue("(s)", presv->ri_qs.ri_resvID); /* NEW ref */
if (py_rargs == NULL) {
log_err(-1, pbs_python_daemon_name,
"could not build args list for resv");
goto GR_ERROR_EXIT;
}
py_resv = PyObject_Call(py_resv_class, py_rargs, NULL);
if (py_resv == NULL) {
log_err(-1, pbs_python_daemon_name,
"failed to create a python resv object");
goto GR_ERROR_EXIT;
}
Py_CLEAR(py_rargs);
/*
* OK, At this point we need to start populating the resv class.
*/
snprintf((char *) hook_debug.objname, HOOK_BUF_SIZE - 1, "%s(%s)", SERVER_RESV_OBJECT, presv->ri_qs.ri_resvID);
snprintf(perf_action, sizeof(perf_action), "%s:%s", HOOK_PERF_POPULATE, hook_debug.objname);
tmp_rc = pbs_python_populate_attributes_to_python_class(py_resv,
py_resv_attr_types,
presv->ri_wattr,
resv_attr_def,
RESV_ATR_LAST, perf_label, perf_action);
if (tmp_rc == -1) {
log_err(PBSE_INTERNAL, __func__,
"partially populated python resv object");
}
/* set resv.queue to actual queue object */
if (presv->ri_qs.ri_queue && PyObject_HasAttrString(py_resv, ATTR_queue)) {
py_que = _pps_helper_get_queue(NULL, presv->ri_qs.ri_queue, perf_label); /* NEW */
if (py_que) {
/* py_que ref ct incremented as part of py_resv */
(void) PyObject_SetAttrString(py_resv, ATTR_queue, py_que);
Py_DECREF(py_que); /* we no longer need to reference */
}
}
/* set resv.server to actual server object */
py_server = _pps_helper_get_server(perf_label); /* NEW */
if (py_server) {
if (PyObject_HasAttrString(py_resv, ATTR_server)) {
/* py_server ref ct incremented as part of py_resv */
(void) PyObject_SetAttrString(py_resv, ATTR_server, py_server);
}
Py_DECREF(py_server);
}
tmp_rc = pbs_python_mark_object_readonly(py_resv);
if (tmp_rc == -1) {
log_err(PBSE_INTERNAL, __func__, "Failed to mark resv readonly!");
goto GR_ERROR_EXIT;
}
object_counter++;
return py_resv;
GR_ERROR_EXIT:
if (PyErr_Occurred())
pbs_python_write_error_to_log(__func__);
Py_CLEAR(py_rargs);
Py_CLEAR(py_resv);
PyErr_SetString(PyExc_AssertionError, "Failed to create resv object");
return NULL;
}
/**
* @brief
* Returns a Python object that maps to a struct pbsnodes * taken directly
* from pvnode_o if non-NULL, or to the struct returned by
* find_nodebyname().
*
* @param[in] pvnode_o - the "struct pbsnode *" that will be used to
* populate a Python vnode object.
* @param[in] vname - name of a vnode to obtain "struct pbsnode *"
* content to populate a Python vnode object.
* @param[in] perf_label - passed on to hook_perf_stat* call.
*
* @return PyObject * - the Python vnode object corresponding to
* 'pvnode_o' or 'vname'.
*/
static PyObject *
_pps_helper_get_vnode(struct pbsnode *pvnode_o, const char *vname, char *perf_label)
{
PyObject *py_vnode_class = NULL;
PyObject *py_vnode = NULL;
PyObject *py_rargs = NULL;
PyObject *py_que = NULL;
struct pbsnode *pvnode;
int tmp_rc = -1;
char buf[512];
char perf_action[MAXBUFLEN];
if (pvnode_o != NULL) {
pvnode = pvnode_o;
} else {
if ((vname == NULL) || (vname[0] == '\0')) {
log_err(PBSE_INTERNAL, __func__,
"Unable to populate python vnode object");
return NULL;
}
pvnode = find_nodebyname((char *) vname);
}
if (pvnode == NULL) {
snprintf(log_buffer, LOG_BUF_SIZE - 1, "%s: no such vnode", vname);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(PBSE_INTERNAL, __func__, log_buffer);
Py_RETURN_NONE;
}
/*
* First things first create a Python vnode object.
* - Borrowed reference
* - Exception is *NOT* set
*/
py_vnode_class = pbs_python_types_table[PP_VNODE_IDX].t_class;
py_rargs = Py_BuildValue("(s)", pvnode->nd_name); /* NEW ref */
if (py_rargs == NULL) {
log_err(-1, pbs_python_daemon_name,
"could not build args list for vnode");
goto GR_ERROR_EXIT;
}
py_vnode = PyObject_Call(py_vnode_class, py_rargs, NULL);
if (py_vnode == NULL) {
log_err(-1, pbs_python_daemon_name,
"failed to create a python vnode object");
goto GR_ERROR_EXIT;
}
Py_CLEAR(py_rargs);
/*
* OK, At this point we need to start populating the vnode class.
*/
snprintf((char *) hook_debug.objname, HOOK_BUF_SIZE - 1, "%s(%s)", SERVER_VNODE_OBJECT, pvnode->nd_name);
snprintf(perf_action, sizeof(perf_action), "%s:%s", HOOK_PERF_POPULATE, hook_debug.objname);
tmp_rc = pbs_python_populate_attributes_to_python_class(py_vnode,
py_vnode_attr_types,
pvnode->nd_attr,
node_attr_def,
ND_ATR_LAST, perf_label, perf_action);
if (tmp_rc == -1) {
log_err(PBSE_INTERNAL, __func__,
"partially populated python vnode object");
}
/* set vnode.queue to actual queue object */
if (pvnode->nd_pque && PyObject_HasAttrString(py_vnode, ATTR_queue)) {
py_que = _pps_helper_get_queue(pvnode->nd_pque, NULL, perf_label); /* NEW */
if (py_que) {
/* py_que ref ct incremented as part of py_vnode */
(void) PyObject_SetAttrString(py_vnode, ATTR_queue, py_que);
Py_DECREF(py_que); /* we no longer need to reference */
}
}
snprintf(buf, sizeof(buf), "%ld", pvnode->nd_state);
tmp_rc = pbs_python_object_set_attr_string_value(py_vnode, ATTR_NODE_state,
buf);
if (tmp_rc == -1) {
log_err(PBSE_INTERNAL, __func__, "Failed to set vnode's state.");
goto GR_ERROR_EXIT;
}
snprintf(buf, sizeof(buf), "%d", pvnode->nd_ntype);
tmp_rc = pbs_python_object_set_attr_string_value(py_vnode, ATTR_NODE_ntype,
buf);
if (tmp_rc == -1) {
log_err(PBSE_INTERNAL, __func__, "Failed to set vnode's type.");
goto GR_ERROR_EXIT;
}
if (tmp_rc == -1) {
log_err(PBSE_INTERNAL, __func__, "Failed to mark vnode readonly.");
goto GR_ERROR_EXIT;
}
object_counter++;
return py_vnode;
GR_ERROR_EXIT:
if (PyErr_Occurred())
pbs_python_write_error_to_log(__func__);
Py_CLEAR(py_rargs);
Py_CLEAR(py_vnode);
PyErr_SetString(PyExc_AssertionError, "Failed to create vnode object");
return NULL;
}
/*
* ---------- EVENT RELATED FUNCTIONS ------------
*/
/**
* @brief
* Returns the event param's item corresponding to key 'name'.
*
* @param[in] name - key
*
* @return PyObject *
* @retval a borrowed reference.
*/
PyObject *
_pbs_python_event_get_param(char *name)
{
PyObject *py_param = NULL;
PyObject *py_p = NULL;
if (!py_hook_pbsevent) {
log_err(PBSE_INTERNAL, __func__, "No hook event found!");
return NULL;
}
/* py_param = event()._param[] */
if (!PyObject_HasAttrString(py_hook_pbsevent, PY_EVENT_PARAM)) {
log_err(PBSE_INTERNAL, __func__, "Failed to obtain event's param");
return NULL;
}
py_param = PyObject_GetAttrString(py_hook_pbsevent,
PY_EVENT_PARAM); /* NEW */
if (!py_param) {
log_err(PBSE_INTERNAL, __func__, "Failed to obtain event's param");
return NULL;
}
if (!PyDict_Check(py_param)) {
log_err(PBSE_INTERNAL, __func__, "event's param is not a dictionary");
Py_CLEAR(py_param);
return NULL;
}
/* ex. py_job = event().param["job"] */
py_p = PyDict_GetItemString(py_param, name);
Py_DECREF(py_param);
return (py_p);
}
/**
* @brief
* Makes the Python PBS event object read-only, meaning none of its
* could be modified in a hook script.
*
* @return int
* @retval 0 for sucess;
* @retval -1 otherwise
*/
int
_pbs_python_event_mark_readonly(void)
{
int rv;
if (!py_hook_pbsevent) {
log_err(PBSE_INTERNAL, __func__, "event not found!");
return (-1);
}
rv = pbs_python_mark_object_readonly(py_hook_pbsevent);
if (rv == -1) {
log_err(PBSE_INTERNAL, __func__, "Failed to mark event readonly!");
return (-1);
}
return (rv);
}
/**
* @brief
* Sets the "operation" mode of Python: if 'mode' is PY_MODE, then we're
* inside the hook script; if 'mode' is C_MODE, then we're inside some
* internal C helper function.
* Setting 'mode' to C_MODE usually means we don't have any restriction
* as to which attributes we can or cannot set.
*/
void
_pbs_python_set_mode(int mode)
{
if ((mode != PY_MODE) && (mode != C_MODE)) {
snprintf(log_buffer, LOG_BUF_SIZE - 1, "unexpected mode %d", mode);
log_buffer[LOG_BUF_SIZE - 1] = '\0';
log_err(PBSE_INTERNAL, __func__, log_buffer);
return;
}
hook_set_mode = mode;
}
/**
*
* @brief
* Given a list of vnode attributes/resources/values in 'vnlist',
* return a Python dictionary object to represent 'vnlist' as an array of
* vnode objects.
*
* @param[in] vnlist - list of vnode attributes/resources/values.
* format: a list of plist entries:
* @param[in] plist->al_name = .
* @param[in] plist->al_resc = ,
* @param[in] plist->al_value =
* @param[in] perf_label - data passed on to hook_perf_stat* call
* @param[in] perf_action - dat passed on to hook_perf_stat* call
*
* @return PyObject *
* @retval