/****** uti/dstring/sge_dstring_strip_white_space_at_eol() *********************
* NAME
* sge_dstring_strip_white_space_at_eol() -- as it says
*
* SYNOPSIS
* void sge_dstring_strip_white_space_at_eol(dstring *string)
*
* FUNCTION
* removes whitespace at the end of the given "string".
*
* INPUTS
* dstring *string - dstring
*******************************************************************************/
void sge_dstring_strip_white_space_at_eol(dstring *string)
{
DENTER(DSTRING_LAYER, "sge_strip_white_space_at_eol");
if (string != NULL) {
char *s = (string != NULL) ? string->s : NULL;
if (s != NULL) {
sge_strip_white_space_at_eol(s);
}
}
DRETURN_VOID;
}
#if 0 /* EB: DEBUG: */
int main(void)
{
char *s;
dstring sb = DSTRING_INIT; /* initialize */
/*
* change content
*/
s = sge_dstring_append(&sb, "Trala");
s = sge_dstring_append(&sb, " trolo");
s = sge_dstring_append(&sb, " troet");
s = sge_dstring_sprintf(&sb, "%d, %s, %f\n", 5, "rabarber ", 5.6);
/*
* use string
*/
printf("%s\n", s);
printf("%s\n", sge_dstring_get_string(&sb));
/*
* free the string when no longer needed
*/
sge_dstring_free(&sb);
return 0;
}
/*-------------------------------------------------------------------------*/
static void qmonCalendarFillConf(
Widget w,
lListElem *ep
) {
XmString *items;
Cardinal itemCount;
const char *s;
int i;
dstring sb = DSTRING_INIT;
DENTER(GUI_LAYER, "qmonCalendarFillConf");
if (!ep) {
/*
** clear the cal_conf_list
*/
XtVaSetValues( cal_conf_list,
XmNitems, NULL,
XmNitemCount, 0,
NULL);
DEXIT;
return;
}
itemCount = 2;
items = (XmString*) XtMalloc(sizeof(XmString)*itemCount);
i = 0;
/* year calendar */
sge_dstring_sprintf(&sb, "%-20.20s ", XmtLocalize(w, "Year", "Year"));
sge_dstring_append(&sb, (s=lGetString(ep, CAL_year_calendar))?s:
XmtLocalize(w, "NONE", "NONE"));
items[i++] = XmStringCreateLtoR(sb.s, "LIST");
sge_dstring_free(&sb);
/* week calendar */
sge_dstring_sprintf(&sb, "%-20.20s ", XmtLocalize(w, "Week", "Week"));
sge_dstring_append(&sb, (s=lGetString(ep, CAL_week_calendar))?s:
XmtLocalize(w, "NONE", "NONE"));
items[i++] = XmStringCreateLtoR((char*)sge_dstring_get_string(&sb), "LIST");
sge_dstring_free(&sb);
XtVaSetValues( cal_conf_list,
XmNitems, items,
XmNitemCount, itemCount,
NULL);
XmStringTableFree(items, itemCount);
DEXIT;
}
/****** uti/monitor/sge_monitor_output() ***************************************
* NAME
* sge_monitor_output() -- outputs the result into the message file
*
* SYNOPSIS
* void sge_monitor_output(monitoring_t *monitor)
*
* FUNCTION
* This function computes the output line from the gathered statistics.
* The output is only generated, when the the output flag in the
* monitoring structure is set.
*
* The monitoring line is printed to the message file in the profiling
* class and it made available for the qping -f output. For the qping
* output, it stores the the generation time, though that qping can
* show, when the message was generated.
*
* If an extension is set, it calls the apropriate output function for
* it.
*
* INPUTS
* monitoring_t *monitor - the monitoring info
*
* NOTES
* MT-NOTE: sge_monitor_output() is MT safe
*
*******************************************************************************/
void sge_monitor_output(monitoring_t *monitor)
{
DENTER(GDI_LAYER, "sge_monitor_output");
if ((monitor != NULL) && (monitor->output == true)) {
struct timeval after;
double time;
gettimeofday(&after, NULL);
time = after.tv_usec - monitor->now.tv_usec;
time = after.tv_sec - monitor->now.tv_sec + (time/1000000);
sge_dstring_clear(monitor->work_line);
sge_dstring_sprintf_append(monitor->work_line, MSG_UTI_MONITOR_DEFLINE_SF,
monitor->thread_name, monitor->message_in_count/time);
if (monitor->ext_type != NONE_EXT) {
sge_dstring_append(monitor->work_line, " (");
monitor->ext_output(monitor->work_line, monitor->ext_data, time);
sge_dstring_append(monitor->work_line, ")");
};
sge_dstring_sprintf_append(monitor->work_line, MSG_UTI_MONITOR_DEFLINE_FFFFF,
monitor->message_out_count/time,
monitor->message_in_count ? (time - monitor->idle)/monitor->message_in_count: 0,
monitor->idle/time*100, monitor->wait/time*100, time);
/* only log into the message file, if the user wants it */
if (monitor->log_monitor_mes) {
sge_log(LOG_PROF, sge_dstring_get_string(monitor->work_line),__FILE__,SGE_FUNC,__LINE__);
}
if (monitor->pos != -1) {
dstring *tmp = NULL;
sge_mutex_lock("sge_monitor_init", SGE_FUNC, __LINE__, &(Output[monitor->pos].Output_Mutex));
tmp = Output[monitor->pos].output;
Output[monitor->pos].output = monitor->work_line;
Output[monitor->pos].update_time = after.tv_sec;
sge_mutex_unlock("sge_monitor_init", SGE_FUNC, __LINE__, &(Output[monitor->pos].Output_Mutex));
monitor->work_line = tmp;
}
sge_monitor_reset(monitor);
}
DRETURN_VOID;
}
/****** sge_binding/binding_print_to_string() **********************************
* NAME
* binding_print_to_string() -- Prints the content of a binding list to a string
*
* SYNOPSIS
* bool binding_print_to_string(const lListElem *this_elem, dstring *string)
*
* FUNCTION
* Prints the binding type and binding strategy of a binding list element
* into a string.
*
* INPUTS
* const lListElem* this_elem - Binding list element
*
* OUTPUTS
* const dstring *string - Output string which must be initialized.
*
* RESULT
* bool - true in all cases
*
* NOTES
* MT-NOTE: is_starting_point() is MT safe
*
*******************************************************************************/
bool
binding_print_to_string(const lListElem *this_elem, dstring *string) {
bool ret = true;
DENTER(BINDING_LAYER, "binding_print_to_string");
if (this_elem != NULL && string != NULL) {
const char *const strategy = lGetString(this_elem, BN_strategy);
binding_type_t type = (binding_type_t)lGetUlong(this_elem, BN_type);
switch (type) {
case BINDING_TYPE_SET:
sge_dstring_append(string, "set ");
break;
case BINDING_TYPE_PE:
sge_dstring_append(string, "pe ");
break;
case BINDING_TYPE_ENV:
sge_dstring_append(string, "env ");
break;
case BINDING_TYPE_NONE:
sge_dstring_append(string, "NONE");
}
if (strcmp(strategy, "linear_automatic") == 0) {
u_long32 n = sge_u32c(lGetUlong(this_elem, BN_parameter_n));
if (BIND_INFINITY == n)
sge_dstring_sprintf_append(string, "linear:slots");
else
sge_dstring_sprintf_append(string, "linear:"sge_U32CFormat, n);
} else if (strcmp(strategy, "linear") == 0) {
sge_dstring_sprintf_append(string, "%s:"sge_U32CFormat":"sge_U32CFormat","sge_U32CFormat,
"linear", sge_u32c(lGetUlong(this_elem, BN_parameter_n)),
sge_u32c(lGetUlong(this_elem, BN_parameter_socket_offset)),
sge_u32c(lGetUlong(this_elem, BN_parameter_core_offset)));
} else if (strcmp(strategy, "striding_automatic") == 0) {
sge_dstring_sprintf_append(string, "%s:"sge_U32CFormat":"sge_U32CFormat,
"striding", sge_u32c(lGetUlong(this_elem, BN_parameter_n)),
sge_u32c(lGetUlong(this_elem, BN_parameter_striding_step_size)));
} else if (strcmp(strategy, "striding") == 0) {
sge_dstring_sprintf_append(string, "%s:"sge_U32CFormat":"sge_U32CFormat":"sge_U32CFormat","sge_U32CFormat,
"striding", sge_u32c(lGetUlong(this_elem, BN_parameter_n)),
sge_u32c(lGetUlong(this_elem, BN_parameter_striding_step_size)),
sge_u32c(lGetUlong(this_elem, BN_parameter_socket_offset)),
sge_u32c(lGetUlong(this_elem, BN_parameter_core_offset)));
} else if (strcmp(strategy, "explicit") == 0) {
sge_dstring_sprintf_append(string, "%s", lGetString(this_elem, BN_parameter_explicit));
}
}
DRETURN(ret);
}
void sge_error_to_dstring(sge_error_class_t *eh, dstring *ds) {
sge_error_iterator_class_t *iter = NULL;
bool first = true;
iter = eh->iterator(eh);
while (iter && iter->next(iter)) {
if (first) {
first = false;
} else {
sge_dstring_append(ds, "\n");
}
sge_dstring_append(ds, iter->get_message(iter));
}
}
/****** libs/sgeobj/ar_state2dstring() ***************************************
* NAME
* ar_state2dstring() -- writes the ar state as letter combination
*
* SYNOPSIS
* void ar_state2dstring(ar_state_t state, dstring *state_as_string)
*
* FUNCTION
* This function writes the given state of a advance reservation as
* letter into the given dstring. The letter will be appended at the and.
*
* INPUTS
* ar_state_t state - ar state
* dstring *state_as_string - dstring
*
* RESULT
* void
*
* NOTES
* MT-NOTE: ar_get_string_from_event() is MT safe
*******************************************************************************/
void
ar_state2dstring(ar_state_t state, dstring *state_as_string)
{
const char *letter = "u";
switch (state) {
case AR_WAITING:
letter = "w";
break;
case AR_RUNNING:
letter = "r";
break;
case AR_EXITED:
letter = "x";
break;
case AR_DELETED:
letter = "d";
break;
case AR_ERROR:
letter = "E";
break;
case AR_WARNING:
letter = "W";
break;
default:
break;
}
sge_dstring_append(state_as_string, letter);
}
static int elect_path(dstring *aBuffer)
{
const char *d;
d = getenv("TMPDIR");
if ((d != NULL) && sge_is_directory(d)) {
sge_dstring_append(aBuffer, d);
return 0;
} else if (sge_is_directory(P_tmpdir)) {
sge_dstring_append(aBuffer, P_tmpdir);
return 0;
} else if (sge_is_directory("/tmp")) {
sge_dstring_append(aBuffer, "/tmp/");
return 0;
}
return -1;
}
void showError(sge_error_class_t *eh) {
sge_error_iterator_class_t *iter = NULL;
dstring ds = DSTRING_INIT;
bool first = true;
iter = eh->iterator(eh);
while (iter && iter->next(iter)) {
if (first) {
first = true;
} else {
sge_dstring_append(&ds, "\n");
}
sge_dstring_append(&ds, iter->get_message(iter));
}
printf("%s\n", sge_dstring_get_string(&ds));
sge_dstring_free(&ds);
}
/****** read_defaults/get_user_home_file_path() *****************************
* NAME
* get_user_home_file_path() -- get absolut path name to file in user
* home
*
* SYNOPSIS
* char *get_user_home_file_path (lList **answer_list)
*
* FUNCTION
* This function returns the path to the file in the user's home
* directory
*
* INPUTS
* dstring - computed absoult filename
* const char *filename - file name
* const char *user - user name
* lList* - answer list, AN_Type or NULL if everything ok
* possible errors:
* STATUS_ENOSUCHUSER - could not retrieve passwd info on me.user_name
* STATUS_EDISK - home directory for user is missing or cwd
* cannot be read or file could not be opened
* (is just a warning)
* STATUS_EEXIST - (parse_script_file), (is just a warning)
* STATUS_EUNKNOWN - (parse_script_file), error opening or
* reading from existing file, (is just a warning)
* plus all other error stati returned by
* parse_script_file, see there
*
* RETURNS
* bool - true or false
*
* MT-NOTE: get_user_home_file_path() is MT safe
*******************************************************************************/
bool get_user_home_file_path(dstring *absolut_filename, const char *filename, const char *user, lList **answer_list)
{
bool ret = false;
DENTER (TOP_LAYER, "get_user_home_file_path");
if (absolut_filename != NULL && filename != NULL) {
sge_dstring_clear(absolut_filename);
if (get_user_home(absolut_filename, user, answer_list)) {
sge_dstring_append(absolut_filename, "/");
sge_dstring_append(absolut_filename, filename);
ret = true;
}
}
DRETURN(ret);
}
/****** uti/dstring/sge_dstring_copy_string() *********************************
* NAME
* sge_dstring_copy_string() -- copy string into dstring
*
* SYNOPSIS
* const char* sge_dstring_copy_string(dstring *sb, char* str)
*
* FUNCTION
* Copy string into dstring
*
* INPUTS
* dstring *sb - destination dstring
* char* str - source string
*
* NOTES
* MT-NOTE: sge_dstring_copy_string() is MT safe
*
* RESULT
* const char* - result string
*******************************************************************************/
const char *sge_dstring_copy_string(dstring *sb, const char *str)
{
const char *ret = NULL;
DENTER(DSTRING_LAYER, "sge_dstring_copy_string");
if (sb != NULL) {
sge_dstring_clear(sb);
ret = sge_dstring_append(sb, str);
}
DEXIT;
return ret;
}
/****** uti/dstring/sge_dstring_copy_dstring() ********************************
* NAME
* sge_dstring_copy_dstring() -- strcpy() for dstrings's
*
* SYNOPSIS
* const char* sge_dstring_copy_dstring(dstring *sb1,
* const dstring *sb2)
*
* FUNCTION
* strcpy() for dstrings's
*
* INPUTS
* dstring *sb1 - destination dstring
* const dstring *sb2 - source dstring
*
* NOTES
* MT-NOTE: sge_dstring_copy_dstring() is MT safe
*
* RESULT
* const char* - result string buffer
*******************************************************************************/
const char *sge_dstring_copy_dstring(dstring *sb1, const dstring *sb2)
{
const char *ret = NULL;
DENTER(DSTRING_LAYER, "sge_dstring_copy_dstring");
if (sb1 != NULL) {
sge_dstring_clear(sb1);
ret = sge_dstring_append(sb1, sge_dstring_get_string(sb2));
}
DEXIT;
return ret;
}
/****** uti/spool/sge_get_active_job_file_path() ********************************
* NAME
* sge_get_active_job_file_path() -- Create paths in active_jobs dir
*
* SYNOPSIS
* const char* sge_get_active_job_file_path(dstring *buffer,
* u_long32 job_id, u_long32 ja_task_id, const char *pe_task_id,
* const char *filename)
*
* FUNCTION
* Creates paths in the execd's active_jobs directory.
* Both directory and file paths can be created.
* The result is placed in a buffer provided by the caller.
*
* WARNING: Do only use in shepherd and execution daemon!
*
* INPUTS
* dstring *buffer - buffer to hold the generated path
* u_long32 job_id - job id
* u_long32 ja_task_id - array task id
* const char *pe_task_id - optional pe task id
* const char *filename - optional file name
*
* RESULT
* const char* - pointer to the string buffer on success, else NULL
*
* EXAMPLE
* To create the relative path to a jobs/tasks environment file, the
* following call would be used:
*
* char buffer[SGE_PATH_MAX]
* sge_get_active_job_file_path(buffer, SGE_PATH_MAX,
* job_id, ja_task_id, pe_task_id,
* "environment");
*
*
* NOTES
* JG: TODO: The function might be converted to or might use a more
* general path creating function (utilib).
*
* SEE ALSO
* execd/sge_make_ja_task_active_dir()
* execd/sge_make_pe_task_active_dir()
*******************************************************************************/
const char *sge_get_active_job_file_path(dstring *buffer, u_long32 job_id,
u_long32 ja_task_id, const char *pe_task_id, const char *filename)
{
DENTER(TOP_LAYER, "sge_get_active_job_file_path");
if (buffer == NULL) {
DRETURN(NULL);
}
sge_dstring_sprintf(buffer, "%s/"sge_u32"."sge_u32, ACTIVE_DIR, job_id, ja_task_id);
if (pe_task_id != NULL) {
sge_dstring_append_char(buffer, '/');
sge_dstring_append(buffer, pe_task_id);
}
if (filename != NULL) {
sge_dstring_append_char(buffer, '/');
sge_dstring_append(buffer, filename);
}
DRETURN(sge_dstring_get_string(buffer));
}
/****** loadcheck/fill_socket_core_topology() **********************************
* NAME
* fill_socket_core_topology() -- Get load values regarding processor topology.
*
* SYNOPSIS
* void fill_socket_core_topology(dstring* msocket, dstring* mcore, dstring*
* mtopology)
*
* FUNCTION
* Gets the values regarding processor topology.
*
* OUTPUTS
* dstring* msocket - The amount of sockets the host have.
* dstring* mcore - The amount of cores the host have.
* dstring* mtopology - The topology the host have.
*
* RESULT
* void - nothing
*
*******************************************************************************/
void fill_socket_core_topology(dstring* msocket, dstring* mcore, dstring* mtopology)
{
int ms, mc;
char* topo = NULL;
int length = 0;
ms = get_execd_amount_of_sockets();
mc = get_execd_amount_of_cores();
if (!get_execd_topology(&topo, &length) || topo == NULL) {
topo = sge_strdup(NULL, "-");
}
sge_dstring_sprintf(msocket, "%d", ms);
sge_dstring_sprintf(mcore, "%d", mc);
sge_dstring_append(mtopology, topo);
sge_free(&topo);
}
/****** sgeobj/str/str_list_append_to_dstring() *******************************
* NAME
* str_list_append_to_dstring() -- append strings to dstring
*
* SYNOPSIS
* const char *
* str_list_append_to_dstring(const lList *this_list,
* dstring *string,
* const char delimiter)
*
* FUNCTION
* Append the strings contained in "this_list" to the dstring
* "string". Separate them by the character contained in
* "delimiter".
* If "this_list" is NULL or conaines no elements, "NONE" will
* be added to the dstring.
*
* INPUTS
* const lList *this_list - ST_Type list
* dstring *string - dynamic string
* const char delimiter - delimiter
*
* RESULT
* const char * - pointer to the given "string"-buffer
*
* SEE ALSO
* sgeobj/str/str_list_parse_from_string()
*******************************************************************************/
const char *
str_list_append_to_dstring(const lList *this_list, dstring *string,
const char delimiter)
{
const char *ret = NULL;
DENTER(STR_LAYER, "str_list_append_to_dstring");
if (string != NULL) {
lListElem *elem = NULL;
bool printed = false;
for_each(elem, this_list) {
sge_dstring_append(string, lGetString(elem, ST_name));
if (lNext(elem) != NULL) {
sge_dstring_sprintf_append(string, "%c", delimiter);
}
printed = true;
}
static int spawn_file(dstring *aBuffer, dstring *error_message) {
int my_errno;
char* mktemp_return = NULL;
char tmp_file_string[256];
char tmp_string[SGE_PATH_MAX];
/*
* generate template filename for mktemp()
*/
snprintf(tmp_file_string, 256, "pid-%u-XXXXXX", (unsigned int)getpid());
/*
* check final length of path
*/
if (sge_dstring_strlen(aBuffer) + strlen(tmp_file_string) >= SGE_PATH_MAX) {
sge_dstring_append(aBuffer, tmp_file_string);
sge_dstring_sprintf(error_message, MSG_TMPNAM_SGE_MAX_PATH_LENGTH_US,
sge_u32c(SGE_PATH_MAX), sge_dstring_get_string(aBuffer));
return -1;
}
/*
* now build full path string for mktemp()
*/
snprintf(tmp_string, SGE_PATH_MAX, "%s%s", sge_dstring_get_string(aBuffer), tmp_file_string);
/*
* generate temp file by call to mktemp()
*/
errno = 0;
mktemp_return = mktemp(tmp_string);
my_errno = errno;
if (mktemp_return[0] == '\0') {
sge_dstring_sprintf(error_message, MSG_TMPNAM_GOT_SYSTEM_ERROR_SS,
strerror(my_errno), sge_dstring_get_string(aBuffer));
return -1;
}
/*
* finally copy the resulting path to aBuffer
*/
sge_dstring_sprintf(aBuffer, tmp_string);
return 0;
}
/****** uti/dstring/sge_dstring_split() ****************************************
* NAME
* sge_dstring_split() -- splits a string into two parts
*
* SYNOPSIS
* bool
* sge_dstring_split(dstring *string, char character,
* dstring *before, dstring *after)
*
* FUNCTION
* This functions tires to find the first occurence of "character"
* in "string". The characters before will be copied into "before"
* and the characters behind into "after" dstring.
*
* INPUTS
* dstring *sb - dstring
* char character - character
* dstring *before - characters before
* dstring *after - characters after
*
* RESULT
* error state
* true - success
* false - error
*******************************************************************************/
bool
sge_dstring_split(dstring *string, char character, dstring *before, dstring *after)
{
bool ret = true;
DENTER(DSTRING_LAYER, "sge_dstring_split");
if (string != NULL && before != NULL && after != NULL) {
const char *s = sge_dstring_get_string(string);
const char *end = strchr(s, character);
while (end != NULL && s != end) {
sge_dstring_append_char(before, *(s++));
}
if (*s == character) {
s++;
}
sge_dstring_append(after, s);
}
DRETURN(ret);
}
/****** uti/dstring/sge_dstring_append_dstring() ******************************
* NAME
* sge_dstring_append() -- strcat() for dstring's
*
* SYNOPSIS
* const char* sge_dstring_append(dstring *sb, const dstring *a)
*
* FUNCTION
* Append 'a' after 'sb'
*
* INPUTS
* dstring *sb - dynamic string
* const dstring *a - string
*
* NOTES
* MT-NOTE: sge_dstring_append_dstring() is MT safe
*
* RESULT
* const char* - result string
******************************************************************************/
const char* sge_dstring_append_dstring(dstring *sb, const dstring *a)
{
return sge_dstring_append(sb, sge_dstring_get_string(a));
}
/****** category/sge_build_job_category_dstring() ******************************
* NAME
* sge_build_job_category_dstring() -- build the category string
*
* SYNOPSIS
* void sge_build_job_category_dstring(dstring *category_str, lListElem
* *job, lList *acl_list)
*
* FUNCTION
* The following parameter are put into the category:
* hard_queue_list
* master_hard_queue_list
* hard_resource_list
* soft_resource_list
* checkpoint_name
* type
*
* owner/group: -U user_lists
* Omitted, if user_lists/xuser_lists were not used in
* host_conf(5), sge_pe(5) and queue_conf(5). In sge_conf(5)
* user_lists/xuser_lists still can be used, as it causes
* jobs already be rejected at submit time.
*
* project: -P user_lists
* Omitted, if projects/xprojects were not used in
* host_conf(5), sge_pe(5) and queue_conf(5). In sge_conf(5)
* projects/xprojects still can be used, as it cuases
* jobs already be rejected at submit time.
*
* pe
*
* INPUTS
* dstring *category_str - target string, contains the category or nothing
* lListElem *job - the job for the category creating
* lList *acl_list - global access list
*
* NOTES
* MT-NOTE: sge_build_job_category_dstring() is MT safe as long as the caller is
*
*******************************************************************************/
void sge_build_job_category_dstring(dstring *category_str, lListElem *job, lList *acl_list, const lList *prj_list, bool *did_project, const lList *rqs_list)
{
const char *owner = NULL;
const char *group = NULL;
DENTER(TOP_LAYER, "sge_build_job_category_dstring");
DTRACE;
#if 0
sge_mutex_lock("cull_order_mutex", SGE_FUNC, __LINE__, &Category_Control.cull_order_mutex);
if (Category_Control.cull_order_pos.JB_hard_queue_list_pos == -1) {
Category_Control.cull_order_pos.JB_checkpoint_name_pos = lGetPosViaElem(job, JB_checkpoint_name, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_soft_resource_list_pos = lGetPosViaElem(job, JB_soft_resource_list, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_master_hard_queue_list_pos = lGetPosViaElem(job, JB_master_hard_queue_list, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_hard_queue_list_pos = lGetPosViaElem(job, JB_hard_queue_list, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_owner_pos = lGetPosViaElem(job, JB_owner, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_group_pos = lGetPosViaElem(job, JB_group, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_hard_resource_list_pos = lGetPosViaElem(job, JB_hard_resource_list, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_type_pos = lGetPosViaElem(job, JB_type, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_project_pos = lGetPosViaElem(job, JB_project, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_ar_pos = lGetPosViaElem(job, JB_ar, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_pe_pos = lGetPosViaElem(job, JB_pe, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_range_pos = lGetPosViaElem(job, JB_pe_range, SGE_NO_ABORT);
}
sge_mutex_unlock("cull_order_mutex", SGE_FUNC, __LINE__, &Category_Control.cull_order_mutex);
#endif
DTRACE;
/*
** owner -> acl
*/
owner = lGetPosString(job, lGetPosViaElem(job, JB_owner, SGE_NO_ABORT));
DTRACE;
group = lGetPosString(job, lGetPosViaElem(job, JB_group, SGE_NO_ABORT));
DTRACE;
sge_unparse_acl_dstring(category_str, owner, group, acl_list, "-U");
DTRACE;
/*
** -u if referenced in resource quota sets
*/
/* RD TODO: A possible performance enhancement is to split user and group inside category.
Some users are only referenced by the unix group. Their jobs could be grouped
together by referencing only the group in the category string
*/
if (sge_user_is_referenced_in_rqs(rqs_list, lGetString(job, JB_owner), lGetString(job, JB_group), acl_list)) {
if (sge_dstring_strlen(category_str) > 0) {
sge_dstring_append(category_str, " ");
}
sge_dstring_append(category_str, "-u ");
sge_dstring_append(category_str, lGetString(job, JB_owner));
}
DTRACE;
/*
** -hard -q qlist
*/
sge_unparse_queue_list_dstring(category_str, job, lGetPosViaElem(job, JB_hard_queue_list, SGE_NO_ABORT), "-q");
DTRACE;
/*
** -masterq qlist
*/
sge_unparse_queue_list_dstring(category_str, job, lGetPosViaElem(job, JB_master_hard_queue_list, SGE_NO_ABORT), "-masterq");
DTRACE;
/*
** -l rlist (hard resource list)
*/
sge_unparse_resource_list_dstring(category_str, job, lGetPosViaElem(job, JB_hard_resource_list, SGE_NO_ABORT), "-l");
DTRACE;
/*
** -soft -l rlist
*/
sge_unparse_resource_list_dstring(category_str, job, lGetPosViaElem(job, JB_soft_resource_list, SGE_NO_ABORT), "-soft -l");
DTRACE;
/*
** -pe pe_name pe_range
*/
sge_unparse_pe_dstring(category_str, job, lGetPosViaElem(job, JB_pe, SGE_NO_ABORT),
lGetPosViaElem(job, JB_pe_range, SGE_NO_ABORT), "-pe");
DTRACE;
/*
** -ckpt ckpt_name
*/
sge_unparse_string_option_dstring(category_str, job, lGetPosViaElem(job, JB_checkpoint_name, SGE_NO_ABORT), "-ckpt");
DTRACE;
/*
** interactive jobs
*/
if (JOB_TYPE_IS_IMMEDIATE(lGetPosUlong(job, lGetPosViaElem(job, JB_type, SGE_NO_ABORT)))) {
if (sge_dstring_strlen(category_str) > 0) {
sge_dstring_append(category_str, " -I y");
}
else {
sge_dstring_append(category_str, "-I y");
}
}
DTRACE;
/*
** project
*/
{
const char *project = lGetPosString(job, lGetPosViaElem(job, JB_project, SGE_NO_ABORT));
const lListElem *prj;
if (project && (prj=lGetElemStr(prj_list, PR_name, project)) && lGetBool(prj, PR_consider_with_categories)) {
if (did_project)
*did_project = true;
sge_unparse_string_option_dstring(category_str, job, lGetPosViaElem(job, JB_project, SGE_NO_ABORT), "-P");
} else
if (did_project)
*did_project = false;
}
DTRACE;
/*
** -ar ar_id
*/
sge_unparse_ulong_option_dstring(category_str, job, lGetPosViaElem(job, JB_ar, SGE_NO_ABORT), "-ar");
DRETURN_VOID;
}
static int check_config(lList **alpp, lListElem *conf)
{
lListElem *ep;
const char *name, *value;
const char *conf_name;
DENTER(TOP_LAYER, "check_config");
conf_name = lGetHost(conf, CONF_name);
for_each(ep, lGetList(conf, CONF_entries)) {
name = lGetString(ep, CF_name);
value = lGetString(ep, CF_value);
if (name == NULL) {
ERROR((SGE_EVENT, MSG_CONF_NAMEISNULLINCONFIGURATIONLISTOFX_S,
conf_name));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
if (value == NULL) {
ERROR((SGE_EVENT, MSG_CONF_VALUEISNULLFORATTRXINCONFIGURATIONLISTOFY_SS,
name, conf_name));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
if (!strcmp(name, "loglevel")) {
u_long32 tmp_uval;
if (sge_parse_loglevel_val(&tmp_uval, value) != 1) {
ERROR((SGE_EVENT, MSG_CONF_GOTINVALIDVALUEXFORLOGLEVEL_S, value));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
} else if (strcmp(name, "jsv_url") == 0) {
if (strcasecmp("none", value) != 0) {
dstring input = DSTRING_INIT;
dstring type = DSTRING_INIT;
dstring user = DSTRING_INIT;
dstring path = DSTRING_INIT;
bool lret = true;
sge_dstring_append(&input, value);
lret = jsv_url_parse(&input, alpp, &type, &user, &path, false);
sge_dstring_free(&input);
sge_dstring_free(&type);
sge_dstring_free(&user);
sge_dstring_free(&path);
if (!lret) {
/* answer is written by jsv_url_parse */
DRETURN(STATUS_EEXIST);
}
}
} else if (!strcmp(name, "shell_start_mode")) {
if ((strcasecmp("unix_behavior", value) != 0) &&
(strcasecmp("posix_compliant", value) != 0) &&
(strcasecmp("script_from_stdin", value) != 0) ) {
ERROR((SGE_EVENT, MSG_CONF_GOTINVALIDVALUEXFORSHELLSTARTMODE_S, value));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
} else if (!strcmp(name, "shell")) {
if (!path_verify(name, alpp, "shell", true)) {
ERROR((SGE_EVENT, MSG_CONF_GOTINVALIDVALUEXFORSHELL_S, value));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
} else if (!strcmp(name, "load_report_time")) {
/* do not allow infinity entry for load_report_time */
if (strcasecmp(value, "infinity") == 0) {
ERROR((SGE_EVENT, MSG_CONF_INFNOTALLOWEDFORATTRXINCONFLISTOFY_SS, name, conf_name));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
} else if (!strcmp(name, "max_unheard")) {
/* do not allow infinity entry */
if (strcasecmp(value,"infinity") == 0) {
ERROR((SGE_EVENT, MSG_CONF_INFNOTALLOWEDFORATTRXINCONFLISTOFY_SS, name, conf_name));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
} else if (!strcmp(name, "admin_user")) {
struct passwd pw_struct;
char *buffer;
int size;
size = get_pw_buffer_size();
buffer = sge_malloc(size);
if (strcasecmp(value, "none") && !sge_getpwnam_r(value, &pw_struct, buffer, size)) {
ERROR((SGE_EVENT, MSG_CONF_GOTINVALIDVALUEXASADMINUSER_S, value));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
sge_free(&buffer);
DRETURN(STATUS_EEXIST);
}
sge_free(&buffer);
} else if (!strcmp(name, "user_lists")||!strcmp(name, "xuser_lists")) {
lList *tmp = NULL;
int ok;
/* parse just for .. */
if (lString2ListNone(value, &tmp, US_Type, US_name, " \t,")) {
ERROR((SGE_EVENT, MSG_CONF_FORMATERRORFORXINYCONFIG_SS, name, conf_name));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
/* .. checking userset names */
ok = (userset_list_validate_acl_list(tmp, alpp) == STATUS_OK);
lFreeList(&tmp);
if (!ok) {
DRETURN(STATUS_EEXIST);
}
} else if (!strcmp(name, "projects") || !strcmp(name, "xprojects")) {
lList *tmp = NULL;
int ok=1;
/* parse just for .. */
if (lString2ListNone(value, &tmp, PR_Type, PR_name, " \t,")) {
ERROR((SGE_EVENT, MSG_CONF_FORMATERRORFORXINYCONFIG_SS, name, conf_name));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
/* .. checking project names */
ok = (verify_project_list(alpp, tmp, *object_type_get_master_list(SGE_TYPE_PROJECT),
name, "configuration", conf_name)==STATUS_OK);
lFreeList(&tmp);
if (!ok) {
DRETURN(STATUS_EEXIST);
}
} else if (!strcmp(name, "prolog") || !strcmp(name, "epilog")
|| !strcmp(name, "mailer")) {
if (strcasecmp(value, "none")) {
const char *t, *script = value;
/* skip user name */
if ((t = strpbrk(script, "@ ")) && *t == '@')
script = &t[1];
/* force use of absolute paths if string <> none */
if (script[0] != '/' ) {
ERROR((SGE_EVENT, MSG_CONF_THEPATHGIVENFORXMUSTSTARTWITHANY_S, name));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
/* ensure that variables are valid */
if (replace_params(script, NULL, 0, prolog_epilog_variables)) {
ERROR((SGE_EVENT, MSG_CONF_PARAMETERXINCONFIGURATION_SS, name, err_msg));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
}
} else if (!strcmp(name, "auto_user_oticket") || !strcmp(name, "auto_user_fshare")) {
u_long32 uval = 0;
if (!extended_parse_ulong_val(NULL, &uval, TYPE_INT, value, NULL, 0, 0, true)) {
ERROR((SGE_EVENT, MSG_CONF_FORMATERRORFORXINYCONFIG_SS, name, value ? value : "(NULL)"));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
}
/*
* check paths, see also CR 6506580.
* The following must be none or a valid absolute path:
* - load_sensor
* - set_token_cmd
* - pag_cmd
* - shepherd_cmd
*
* The following must be a valid absolute path:
* - mailer
* - xterm
* - *_daemon, may also be "builtin"
*/
else if (strcmp(name, "set_token_cmd") == 0 ||
strcmp(name, "pag_cmd") == 0 ||
strcmp(name, "shepherd_cmd") == 0) {
if (strcasecmp(value, "none") != 0) {
if (!path_verify(value, alpp, name, true)) {
answer_list_log(alpp, false, false);
DRETURN(STATUS_EEXIST);
}
}
} else if (strcmp(name, "mailer") == 0 ||
strcmp(name, "xterm") == 0) {
if (!path_verify(value, alpp, name, true)) {
answer_list_log(alpp, false, false);
DRETURN(STATUS_EEXIST);
}
} else if (strcmp(name, "qlogin_daemon") == 0 ||
strcmp(name, "rlogin_daemon") == 0 ||
strcmp(name, "rsh_daemon") == 0) {
if (strcasecmp(value, "builtin") != 0) {
if (!path_verify(value, alpp, name, true)) {
answer_list_log(alpp, false, false);
DRETURN(STATUS_EEXIST);
}
}
}
/* load_sensor is a comma separated list of scripts */
else if (strcmp(name, "load_sensor") == 0 && strcasecmp(value, "none") != 0) {
struct saved_vars_s *context = NULL;
const char *path = sge_strtok_r(value, ",", &context);
do {
if (!path_verify(path, alpp, name, true)) {
answer_list_log(alpp, false, false);
sge_free_saved_vars(context);
DRETURN(STATUS_EEXIST);
}
} while ((path = sge_strtok_r(NULL, ",", &context)) != NULL);
sge_free_saved_vars(context);
}
}
/****** uti/monitor/sge_monitor_init() *****************************************
* NAME
* sge_monitor_init() -- init the monitoring structure
*
* SYNOPSIS
* void sge_monitor_init(monitoring_t *monitor, const char *thread_name,
* extension_t ext, thread_warning_t warning_timeout, thread_error_t
* error_timeout)
*
* FUNCTION
* Sets the default values and inits the structure, finds the line pos
* for the comlib output
*
* INPUTS
* monitoring_t *monitor - monitoring strucutre
* const char *thread_name - the thread name
* extension_t ext - the extension time (-> enum)
* thread_warning_t warning_timeout - the warning timeout (-> enum)
* thread_error_t error_timeout - the error timeout (-> enum)
*
* NOTES
* MT-NOTE: sge_monitor_init() is MT safe
*
*******************************************************************************/
void
sge_monitor_init(monitoring_t *monitor, const char *thread_name, extension_t ext,
thread_warning_t warning_timeout, thread_error_t error_timeout)
{
DENTER(GDI_LAYER, "sge_monitor_init");
/*
* initialize the mallinfo function pointer if it is available
*/
#if defined(LINUX) || defined(AIX43) || defined(AIX51) || defined(IRIX) || defined(SOLARIS) || defined(HP11)
sge_mutex_lock("sge_monitor_status", SGE_FUNC, __LINE__, &global_mutex);
if (mallinfo_initialized == false) {
const char *function_name = "mallinfo";
mallinfo_initialized = true;
# ifdef RTLD_NODELETE
mallinfo_shlib_handle = dlopen(NULL, RTLD_LAZY | RTLD_NODELETE);
# else
mallinfo_shlib_handle = dlopen(NULL, RTLD_LAZY );
# endif /* RTLD_NODELETE */
if (mallinfo_shlib_handle != NULL) {
mallinfo_func_pointer = (struct mallinfo (*)(void)) dlsym(mallinfo_shlib_handle, function_name);
}
}
sge_mutex_unlock("sge_monitor_status", SGE_FUNC, __LINE__, &global_mutex);
#endif
monitor->thread_name = thread_name;
monitor->output_line1 = (dstring*) malloc(sizeof(dstring));
monitor->output_line2 = (dstring*) malloc(sizeof(dstring));
if (monitor->output_line1 == NULL || monitor->output_line2 == NULL) {
CRITICAL((SGE_EVENT, SFNMAX, MSG_UTI_MONITOR_MEMERROR));
exit(1);
}
memset(monitor->output_line1, 0, sizeof(dstring));
memset(monitor->output_line2, 0, sizeof(dstring));
sge_dstring_append(monitor->output_line1, thread_name);
sge_dstring_append(monitor->output_line1, MSG_UTI_MONITOR_NODATA);
sge_dstring_clear(monitor->output_line2);
monitor->work_line = monitor->output_line2;
switch(ext) {
case SCH_EXT :
monitor->ext_data = malloc(sizeof(m_sch_t));
if (monitor->ext_data != NULL) {
monitor->ext_type = SCH_EXT;
monitor->ext_data_size = sizeof(m_sch_t);
monitor->ext_output = &ext_sch_output;
} else {
monitor->ext_type = NONE_EXT;
ERROR((SGE_EVENT, SFNMAX, MSG_UTI_MONITOR_MEMERROREXT));
}
break;
case GDI_EXT :
monitor->ext_data = malloc(sizeof(m_gdi_t));
if (monitor->ext_data != NULL) {
monitor->ext_type = GDI_EXT;
monitor->ext_data_size = sizeof(m_gdi_t);
monitor->ext_output = &ext_gdi_output;
} else {
monitor->ext_type = NONE_EXT;
ERROR((SGE_EVENT, SFNMAX, MSG_UTI_MONITOR_MEMERROREXT));
}
break;
case LIS_EXT :
monitor->ext_data = malloc(sizeof(m_lis_t));
if (monitor->ext_data != NULL) {
monitor->ext_type = LIS_EXT;
monitor->ext_data_size = sizeof(m_lis_t);
monitor->ext_output = &ext_lis_output;
} else {
monitor->ext_type = NONE_EXT;
ERROR((SGE_EVENT, SFNMAX, MSG_UTI_MONITOR_MEMERROREXT));
}
break;
case EDT_EXT :
monitor->ext_data = malloc(sizeof(m_edt_t));
if (monitor->ext_data != NULL) {
monitor->ext_type = EDT_EXT;
monitor->ext_data_size = sizeof(m_edt_t);
monitor->ext_output = &ext_edt_output;
} else {
monitor->ext_type = NONE_EXT;
ERROR((SGE_EVENT, SFNMAX, MSG_UTI_MONITOR_MEMERROREXT));
}
break;
case TET_EXT :
monitor->ext_data = malloc(sizeof(m_tet_t));
if (monitor->ext_data != NULL) {
monitor->ext_type = TET_EXT;
monitor->ext_data_size = sizeof(m_tet_t);
monitor->ext_output = &ext_tet_output;
} else {
monitor->ext_type = NONE_EXT;
ERROR((SGE_EVENT, SFNMAX, MSG_UTI_MONITOR_MEMERROREXT));
}
break;
case NONE_EXT :
monitor->ext_type = NONE_EXT;
break;
default :
monitor->ext_type = NONE_EXT;
ERROR((SGE_EVENT, MSG_UTI_MONITOR_UNSUPPORTEDEXT_D, ext));
};
if (monitor->ext_type == NONE_EXT) {
monitor->ext_data_size = 0;
monitor->ext_data = NULL;
monitor->ext_output = NULL;
}
sge_monitor_reset(monitor);
{
int i;
struct timeval time;
monitor->pos = -1;
gettimeofday(&time, NULL);
for (i = 0; i < MAX_OUTPUT_LINES; i++) {
sge_mutex_lock("sge_monitor_init", SGE_FUNC, __LINE__, &(Output[i].Output_Mutex));
if (Output[i].name == NULL) {
monitor->pos = i;
Output[i].output = monitor->output_line1;
Output[i].name = thread_name;
Output[i].warning_timeout = warning_timeout;
Output[i].error_timeout = error_timeout;
Output[i].update_time = time.tv_sec;
sge_mutex_unlock("sge_monitor_init", SGE_FUNC, __LINE__, &(Output[i].Output_Mutex));
break;
}
sge_mutex_unlock("sge_monitor_init", SGE_FUNC, __LINE__, &(Output[i].Output_Mutex));
}
sge_set_last_wait_time(monitor, time);
}
if (monitor->pos == -1) {
ERROR((SGE_EVENT, MSG_UTI_MONITOR_NOLINES_S, monitor->thread_name));
}
DEXIT;
}
/****** cull/dump_scan/lDumpElemFp() ******************************************
* NAME
* lDumpElemFp() -- Dump a given element into FILE stream
*
* SYNOPSIS
* int lDumpElemFp(FILE *fp, const lListElem *ep, int indent)
*
* FUNCTION
* Dump a given element into FILE stream
*
* INPUTS
* FILE *fp - file stream
* const lListElem *ep - element
* int indent -
*
* RESULT
* int - error state
* 0 - OK
* -1 - Error
*
* NOTES
* MT-NOTE: lDumpElemFp() is not MT safe
******************************************************************************/
int lDumpElemFp(FILE *fp, const lListElem *ep, int indent)
{
int i, ret = ~EOF;
lList *tlp;
lListElem *tep;
char space[256];
const char *str;
dstring dstr = DSTRING_INIT;
DENTER(CULL_LAYER, "lDumpElemFp");
space[0] = '\0';
for (i = 0; i < indent; i++)
strcat(space, INDENT_STRING);
if (!fp) {
LERROR(LEFILENULL);
DEXIT;
return -1;
}
if (!ep) {
LERROR(LEELEMNULL);
DEXIT;
return -1;
}
ret = fprintf(fp, "%s{ \n", space);
for (i = 0, ret = 0; ep->descr[i].nm != NoName && ret != EOF; i++) {
char *tok = NULL;
switch (mt_get_type(ep->descr[i].mt)) {
case lIntT:
ret = fprintf(fp, "%s/* %-20.20s */ %d\n",
space, lNm2Str(ep->descr[i].nm), lGetPosInt(ep, i));
break;
case lUlongT:
ret = fprintf(fp, "%s/* %-20.20s */ " sge_u32 "\n",
space, lNm2Str(ep->descr[i].nm), lGetPosUlong(ep, i));
break;
case lStringT:
str = lGetPosString(ep, i);
/* quote " inside str */
if ((tok = sge_strtok(str, "\"")) != NULL) {
sge_dstring_append(&dstr, tok);
while ((tok=sge_strtok(NULL, "\"")) != NULL) {
sge_dstring_append(&dstr, "\\\"");
sge_dstring_append(&dstr, tok);
}
}
str = sge_dstring_get_string(&dstr);
ret = fprintf(fp, "%s/* %-20.20s */ \"%s\"\n",
space, lNm2Str(ep->descr[i].nm), str != NULL ? str : "");
sge_dstring_clear(&dstr);
break;
case lHostT:
str = lGetPosHost(ep, i);
ret = fprintf(fp, "%s/* %-20.20s */ \"%s\"\n",
space, lNm2Str(ep->descr[i].nm), str != NULL ? str : "");
break;
case lFloatT:
ret = fprintf(fp, "%s/* %-20.20s */ %f\n",
space, lNm2Str(ep->descr[i].nm), lGetPosFloat(ep, i));
break;
case lDoubleT:
ret = fprintf(fp, "%s/* %-20.20s */ %f\n",
space, lNm2Str(ep->descr[i].nm), lGetPosDouble(ep, i));
break;
case lLongT:
ret = fprintf(fp, "%s/* %-20.20s */%ld \n",
space, lNm2Str(ep->descr[i].nm), lGetPosLong(ep, i));
break;
case lCharT:
ret = fprintf(fp, "%s/* %-20.20s */ %c\n",
space, lNm2Str(ep->descr[i].nm), lGetPosChar(ep, i));
break;
case lBoolT:
ret = fprintf(fp, "%s/* %-20.20s */ %d\n",
space, lNm2Str(ep->descr[i].nm), lGetPosBool(ep, i));
break;
case lRefT:
ret = fprintf(fp, "%s/* %-20.20s */ %ld\n",
space, lNm2Str(ep->descr[i].nm), (long)lGetPosRef(ep, i));
break;
case lObjectT:
if ((tep = lGetPosObject(ep, i)) == NULL)
ret = fprintf(fp, "%s/* %-20.20s */ none\n",
space, lNm2Str(ep->descr[i].nm));
else {
ret = fprintf(fp, "%s/* %-20.20s */ object\n",
space, lNm2Str(ep->descr[i].nm));
if (ret != EOF)
ret = lDumpObject(fp, tep, indent + 1);
}
break;
case lListT:
if ((tlp = lGetPosList(ep, i)) == NULL)
ret = fprintf(fp, "%s/* %-20.20s */ empty\n",
space, lNm2Str(ep->descr[i].nm));
else {
ret = fprintf(fp, "%s/* %-20.20s */ full\n",
space, lNm2Str(ep->descr[i].nm));
if (ret != EOF)
ret = lDumpList(fp, tlp, indent + 1);
}
break;
}
}
sge_dstring_free(&dstr);
ret = fprintf(fp, "%s}\n", space);
DEXIT;
return (ret == EOF) ? -1 : 0;
}
/****** uti/monitor/sge_monitor_status() ***************************************
* NAME
* sge_monitor_status() -- generates the status for qping / commlib
*
* SYNOPSIS
* u_long32 sge_monitor_status(char **info_message, u_long32 monitor_time)
*
* FUNCTION
* This method creats the health monitoring output and returns the monitoring
* info to the commlib.
*
* INPUTS
* char **info_message - info_message pointer, has to point to a NULL string
* u_long32 monitor_time - the configured monitoring interval
*
* RESULT
* u_long32 - 0 : everything is okay
* 1 : warning
* 2 : error
* 3 : init problems
*
* NOTES
* MT-NOTE: sge_monitor_status() is MT safe
*
*******************************************************************************/
u_long32 sge_monitor_status(char **info_message, u_long32 monitor_time)
{
u_long32 ret = 0;
char date[40];
dstring ddate;
DENTER(GDI_LAYER, "sge_monitor_status");
if (info_message == NULL) {
DEXIT;
return 3;
}
sge_dstring_init(&ddate, date, sizeof(date));
sge_mutex_lock("sge_monitor_status", SGE_FUNC, __LINE__, &global_mutex);
sge_dstring_clear(&Info_Line);
{/* this is the qping info section, it checks if each thread is still alive */
int i;
int error_count = 0;
struct timeval now;
double time;
char state = 'R';
gettimeofday(&now,NULL);
for (i = 0; i < MAX_OUTPUT_LINES; i++) {
sge_mutex_lock("sge_monitor_status", SGE_FUNC, __LINE__, &(Output[i].Output_Mutex));
if (Output[i].name != NULL) {
time = now.tv_usec - Output[i].last_wait_time.tv_usec;
time = now.tv_sec - Output[i].last_wait_time.tv_sec + (time /1000000);
if (Output[i].warning_timeout != NO_WARNING) {
if (Output[i].warning_timeout < time) {
if (Output[i].error_timeout < time) {
state = 'E';
}
else {
state = 'W';
}
error_count++;
}
}
sge_dstring_sprintf_append(&Info_Line, MSG_UTI_MONITOR_INFO_SCF, Output[i].name, state, time);
}
sge_mutex_unlock("sge_monitor_status", SGE_FUNC, __LINE__, &(Output[i].Output_Mutex));
}
if (error_count == 0) {
sge_dstring_append(&Info_Line, MSG_UTI_MONITOR_OK);
}
else if (error_count == 1) {
ret = 1;
sge_dstring_append(&Info_Line, MSG_UTI_MONITOR_WARNING);
}
else {
ret = 2;
sge_dstring_append(&Info_Line, MSG_UTI_MONITOR_ERROR);
}
sge_dstring_append(&Info_Line, "\n");
}
#if defined(LINUX) || defined(AIX43) || defined(AIX51) || defined(IRIX) || defined(SOLARIS) || defined(HP11)
if (mallinfo_func_pointer != NULL) {
struct mallinfo mallinfo_data = mallinfo_func_pointer();
sge_dstring_sprintf_append(&Info_Line, MSG_UTI_MONITOR_SCHEXT_UUUUUUUUUU,
mallinfo_data.arena,
mallinfo_data.ordblks,
mallinfo_data.smblks,
mallinfo_data.hblks,
mallinfo_data.hblkhd,
mallinfo_data.usmblks,
mallinfo_data.fsmblks,
mallinfo_data.uordblks,
mallinfo_data.fordblks,
mallinfo_data.keepcost);
sge_dstring_append(&Info_Line, "\n");
}
#endif
if (monitor_time != 0) { /* generates the output monitoring output data */
int i;
sge_dstring_append(&Info_Line, MSG_UTI_MONITOR_COLON);
sge_dstring_append(&Info_Line, "\n");
for (i = 0; i < MAX_OUTPUT_LINES; i++) {
sge_mutex_lock("sge_monitor_status", SGE_FUNC, __LINE__, &(Output[i].Output_Mutex));
if (Output[i].name != NULL) {
append_time(Output[i].update_time, &Info_Line, false);
sge_dstring_append(&Info_Line, " | ");
sge_dstring_append_dstring(&Info_Line, Output[i].output);
sge_dstring_append(&Info_Line,"\n");
}
sge_mutex_unlock("sge_monitor_status", SGE_FUNC, __LINE__, &(Output[i].Output_Mutex));
}
}
else {
sge_dstring_append(&Info_Line, MSG_UTI_MONITOR_DISABLED);
sge_dstring_append(&Info_Line, "\n");
}
*info_message = strdup(sge_dstring_get_string(&Info_Line));
sge_mutex_unlock("sge_monitor_status", SGE_FUNC, __LINE__, &global_mutex);
DEXIT;
return ret;
}
static bool
check_all(dstring *sb)
{
bool ret = true;
int i;
/* sge_dstring_append */
printf("\nchecking sge_dstring_append\n");
sge_dstring_append(NULL, NULL);
sge_dstring_append(sb, NULL);
check_dstring(sb);
sge_dstring_append(sb, "blah");
check_dstring(sb);
sge_dstring_clear(sb);
sge_dstring_append(sb, "too long string to fit into a static string buffer");
check_dstring(sb);
sge_dstring_clear(sb);
sge_dstring_append(sb,
"long string that requires multiple chunks ....... ");
check_dstring(sb);
for (i = 0; i < 20; i++) {
sge_dstring_append(sb,
"long string that requires multiple chunks ....... ");
}
check_dstring(sb);
/* sge_dstring_append_dstring */
printf("\nchecking sge_dstring_append_dstring\n");
sge_dstring_clear(sb);
sge_dstring_append_dstring(NULL, NULL);
{
dstring second = DSTRING_INIT;
sge_dstring_append(&second, "dstring");
sge_dstring_append_dstring(NULL, &second);
sge_dstring_append_dstring(sb, NULL);
sge_dstring_append_dstring(sb, &second);
check_dstring(sb);
sge_dstring_free(&second);
}
/* sge_dstring_append_char */
printf("\nchecking sge_dstring_append_char\n");
sge_dstring_clear(sb);
sge_dstring_append_char(NULL, 'a');
sge_dstring_append_char(sb, '\0');
check_dstring(sb);
sge_dstring_append_char(sb, 'a');
check_dstring(sb);
sge_dstring_append_char(sb, 'b');
check_dstring(sb);
/* sge_dstring_sprintf */
printf("\nchecking sge_dstring_sprintf\n");
sge_dstring_sprintf(NULL, "test %s", "string");
sge_dstring_sprintf(sb, NULL);
sge_dstring_sprintf(sb, "test %s", "string");
check_dstring(sb);
#if 0
/* does not build on irix */
/* sge_dstring_vsprintf */
printf("\nchecking sge_dstring_vsprintf\n");
{
const char *args[] = { "string", NULL };
sge_dstring_clear(sb);
sge_dstring_vsprintf(NULL, "test %s", args);
sge_dstring_vsprintf(sb, NULL, args);
sge_dstring_vsprintf(sb, "test %s", args);
check_dstring(sb);
}
#endif
/* sge_dstring_sprintf_append */
printf("\nchecking sge_dstring_sprintf_append\n");
sge_dstring_clear(sb);
sge_dstring_sprintf_append(NULL, "test %s", "string");
sge_dstring_sprintf_append(sb, NULL);
sge_dstring_sprintf_append(sb, "test %s", "string");
sge_dstring_sprintf_append(sb, " appended test %s", "string");
check_dstring(sb);
/* sge_dstring_clear */
printf("\nchecking sge_dstring_clear\n");
sge_dstring_clear(NULL);
sge_dstring_clear(sb);
check_dstring(sb);
/* sge_dstring_free */
printf("\nchecking sge_dstring_free\n");
sge_dstring_free(NULL);
sge_dstring_free(sb);
check_dstring(sb);
/* sge_dstring_get_string */
printf("\nchecking sge_dstring_get_string\n");
sge_dstring_clear(sb);
sge_dstring_append(sb, "test string");
{
const char *result;
result = sge_dstring_get_string(NULL);
printf("sge_dstring_get_string(NULL) = %s\n",
result == NULL ? "NULL" : result);
result = sge_dstring_get_string(sb);
printf("sge_dstring_get_string(sb) = %s\n",
result == NULL ? "NULL" : result);
}
/* sge_dstring_copy_string */
printf("\nchecking sge_dstring_copy_string\n");
sge_dstring_copy_string(NULL, NULL);
sge_dstring_copy_string(sb, NULL);
sge_dstring_copy_string(NULL, "new test string");
sge_dstring_copy_string(sb, "new test string");
check_dstring(sb);
/* sge_dstring_copy_dstring
* check only NULL pointer behaviour, it just calls sge_dstring_copy_string
*/
printf("\nchecking sge_dstring_copy_dstring\n");
sge_dstring_copy_dstring(NULL, NULL);
sge_dstring_copy_dstring(sb, NULL);
check_dstring(sb);
/* sge_dstring_strlen */
printf("\nchecking sge_dstring_strlen\n");
{
int len;
sge_dstring_copy_string(sb, "test string");
len = sge_dstring_strlen(NULL);
printf("sge_dstring_strlen(NULL) = %d\n", len);
len = sge_dstring_strlen(sb);
printf("sge_dstring_strlen(sb) = %d\n", len);
}
/* sge_dstring_remaining */
printf("\nchecking sge_dstring_remaining\n");
{
int len;
sge_dstring_copy_string(sb, "test string");
len = sge_dstring_remaining(NULL);
printf("sge_dstring_remaining(NULL) = %d\n", len);
len = sge_dstring_remaining(sb);
printf("sge_dstring_remaining(sb) = %d\n", len);
}
return ret;
}
static void qevent_parse_command_line(int argc, char **argv, qevent_options *option_struct) {
DENTER(TOP_LAYER, "qevent_parse_command_line");
option_struct->help_option = 0;
option_struct->testsuite_option = 0;
option_struct->subscribe_option = 0;
option_struct->trigger_option_count =0;
while (*(++argv)) {
if (!strcmp("-h", *argv) || !strcmp("-help", *argv)) {
option_struct->help_option = 1;
continue;
}
if (!strcmp("-ts", *argv) || !strcmp("-testsuite", *argv)) {
option_struct->testsuite_option = 1;
continue;
}
if (!strcmp("-sm", *argv) || !strcmp("-subscribe", *argv)) {
option_struct->subscribe_option = 1;
continue;
}
if (!strcmp("-trigger", *argv)) {
int ok = 0;
if (option_struct->trigger_option_count >= MAX_TRIGGER_SCRIPTS ) {
sge_dstring_sprintf(option_struct->error_message,
"option \"-trigger\": only "sge_U32CFormat" trigger arguments supported\n",
sge_u32c(MAX_TRIGGER_SCRIPTS) );
break;
}
++argv;
if (*argv) {
/* get EVENT argument */
if (strcmp(qevent_get_event_name(QEVENT_JB_END),*argv) == 0) {
ok = 1;
(option_struct->trigger_option_events)[option_struct->trigger_option_count] = QEVENT_JB_END;
}
if (strcmp(qevent_get_event_name(QEVENT_JB_TASK_END),*argv) == 0) {
ok = 1;
(option_struct->trigger_option_events)[option_struct->trigger_option_count] = QEVENT_JB_TASK_END;
}
if (!ok) {
sge_dstring_append(option_struct->error_message,"option \"-trigger\": undefined EVENT type\n");
break;
}
} else {
sge_dstring_append(option_struct->error_message,"option \"-trigger\": found no EVENT argument\n");
break;
}
++argv;
if (*argv) {
/* get SCRIPT argument */
/* check for SCRIPT file */
if (!sge_is_file(*argv)) {
sge_dstring_sprintf(option_struct->error_message,
"option \"-trigger\": SCRIPT file %s not found\n",
(*argv));
break;
}
/* is file executable ? */
if (!sge_is_executable(*argv)) {
sge_dstring_sprintf(option_struct->error_message,
"option \"-trigger\": SCRIPT file %s not executable\n",
(*argv));
break;
}
(option_struct->trigger_option_scripts)[option_struct->trigger_option_count] = *argv;
(option_struct->trigger_option_count)++;
} else {
sge_dstring_append(option_struct->error_message,"option \"-trigger\": found no SCRIPT argument\n");
break;
}
continue;
}
/* unkown option */
if ( *argv[0] == '-' ) {
sge_dstring_append(option_struct->error_message,"unkown option: ");
sge_dstring_append(option_struct->error_message,*argv);
sge_dstring_append(option_struct->error_message,"\n");
} else {
sge_dstring_append(option_struct->error_message,"unkown argument: ");
sge_dstring_append(option_struct->error_message,*argv);
sge_dstring_append(option_struct->error_message,"\n");
}
}
DEXIT;
}
/****** tty_to_commlib() *******************************************************
* NAME
* tty_to_commlib() -- tty_to_commlib thread entry point and main loop
*
* SYNOPSIS
* void* tty_to_commlib(void *t_conf)
*
* FUNCTION
* Entry point and main loop of the tty_to_commlib thread.
* Reads data from the tty and writes it to the commlib.
*
* INPUTS
* void *t_conf - pointer to cl_thread_settings_t struct of the thread
*
* RESULT
* void* - always NULL
*
* NOTES
* MT-NOTE: tty_to_commlib is MT-safe ?
*
* SEE ALSO
*******************************************************************************/
void* tty_to_commlib(void *t_conf)
{
char *pbuf;
fd_set read_fds;
struct timeval timeout;
dstring err_msg = DSTRING_INIT;
dstring dbuf = DSTRING_INIT;
int do_exit = 0;
int ret, nread = 0;
DENTER(TOP_LAYER, "tty_to_commlib");
thread_func_startup(t_conf);
/*
* allocate working buffer
*/
pbuf = (char*)malloc(BUFSIZE);
if (pbuf == NULL) {
DPRINTF(("tty_to_commlib can't allocate working buffer: %s (%d)\n",
strerror(errno), errno));
do_exit = 1;
}
while (do_exit == 0) {
FD_ZERO(&read_fds);
if (g_nostdin == 0) {
/* wait for input on tty */
FD_SET(STDIN_FILENO, &read_fds);
}
timeout.tv_sec = 1;
timeout.tv_usec = 0;
if (received_signal == SIGCONT) {
received_signal = 0;
if (continue_handler (g_comm_handle, g_hostname) == 1) {
do_exit = 1;
continue;
}
if (g_raw_mode_state == 1) {
/* restore raw-mode after SIGCONT */
if (terminal_enter_raw_mode () != 0) {
DPRINTF(("tty_to_commlib: couldn't enter raw mode for pty\n"));
do_exit = 1;
continue;
}
}
}
DPRINTF(("tty_to_commlib: Waiting in select() for data\n"));
ret = select(STDIN_FILENO+1, &read_fds, NULL, NULL, &timeout);
thread_testcancel(t_conf);
client_check_window_change(g_comm_handle);
if (received_signal == SIGHUP ||
received_signal == SIGINT ||
received_signal == SIGQUIT ||
received_signal == SIGTERM) {
/* If we receive one of these signals, we must terminate */
do_exit = 1;
continue;
}
if (ret > 0) {
if (g_nostdin == 1) {
/* We should never get here if STDIN is closed */
DPRINTF(("tty_to_commlib: STDIN ready to read while it should be closed!!!\n"));
}
DPRINTF(("tty_to_commlib: trying to read() from stdin\n"));
nread = read(STDIN_FILENO, pbuf, BUFSIZE-1);
pbuf[nread] = '\0';
sge_dstring_append (&dbuf, pbuf);
DPRINTF(("tty_to_commlib: nread = %d\n", nread));
if (nread < 0 && (errno == EINTR || errno == EAGAIN)) {
DPRINTF(("tty_to_commlib: EINTR or EAGAIN\n"));
/* do nothing */
} else if (nread <= 0) {
do_exit = 1;
} else {
DPRINTF(("tty_to_commlib: writing to commlib: %d bytes\n", nread));
if (suspend_handler(g_comm_handle, g_hostname, g_is_rsh, g_suspend_remote, g_pid, &dbuf) == 1) {
if (comm_write_message(g_comm_handle, g_hostname,
COMM_CLIENT, 1, (unsigned char*)pbuf,
(unsigned long)nread, STDIN_DATA_MSG, &err_msg) != nread) {
DPRINTF(("tty_to_commlib: couldn't write all data\n"));
} else {
DPRINTF(("tty_to_commlib: data successfully written\n"));
}
}
comm_flush_write_messages(g_comm_handle, &err_msg);
}
} else {
/*
* We got either a select timeout or a select error. In both cases,
* it's a good chance to check if our client is still alive.
*/
DPRINTF(("tty_to_commlib: Checking if client is still alive\n"));
if (comm_get_connection_count(g_comm_handle, &err_msg) == 0) {
DPRINTF(("tty_to_commlib: Client is not alive! -> exiting.\n"));
do_exit = 1;
} else {
DPRINTF(("tty_to_commlib: Client is still alive\n"));
}
}
} /* while (do_exit == 0) */
/* clean up */
sge_dstring_free(&dbuf);
sge_free(&pbuf);
thread_func_cleanup(t_conf);
sge_dstring_free(&err_msg);
DPRINTF(("tty_to_commlib: exiting tty_to_commlib thread!\n"));
DEXIT;
return NULL;
}