/****** spool/berkeleydb/bdb_get_dbname() **************************************
* NAME
* bdb_get_dbname() -- get a meaningfull database name
*
* SYNOPSIS
* const char *
* bdb_get_dbname(bdb_info info, dstring *buffer)
*
* FUNCTION
* Return a meaningfull name for a database connection.
* It contains the server name (in case of RPC mechanism) and the database
* path.
* A dstring buffer has to be provided by the caller.
*
* INPUTS
* bdb_info info - the database object
* dstring *buffer - buffer to hold the database name
*
* RESULT
* const char * - the database name
*
* NOTES
* MT-NOTE: bdb_get_dbname() is MT safe
*******************************************************************************/
const char *
bdb_get_dbname(bdb_info info, dstring *buffer)
{
const char *ret;
const char *server = bdb_get_server(info);
const char *path = bdb_get_path(info);
if (path == NULL) {
ret = sge_dstring_copy_string(buffer, MSG_BERKELEY_DBNOTINITIALIZED);
} else if (server == NULL) {
ret = sge_dstring_copy_string(buffer, path);
} else {
ret = sge_dstring_sprintf(buffer, "%s:%s", server, path);
}
return ret;
}
/****** shepherd/shepconf/shepconf_has_userdef_method() ************************
* NAME
* shepconf_has_userdef_method() -- Do we have a user def. method?
*
* SYNOPSIS
* int shepconf_has_userdef_method(char *method_name, dstring *method)
*
* FUNCTION
* Try to find the variable "method_name" in config-file.
* Return true and set "method" if it is an absolute path
* otherwise return false.
*
*
* INPUTS
* char *method_name - "starter_method", "suspend_method",
* "resume_method" or "terminate_method"
* dstring *method - Absolut filename of the method
*
* RESULT
* int - true or false
*******************************************************************************/
int shepconf_has_userdef_method(const char *method_name, dstring *method)
{
char *conf_val = search_nonone_conf_val(method_name);
int ret = 0;
if (conf_val != NULL && conf_val[0] == '/') {
sge_dstring_copy_string(method, conf_val);
ret = 1;
}
return ret;
}
/****** uti/string/sge_strerror() **********************************************
* NAME
* sge_strerror() -- replacement for strerror
*
* SYNOPSIS
* const char*
* sge_strerror(int errnum)
*
* FUNCTION
* Returns a string describing an error condition set by system
* calls (errno).
*
* Wrapper arround strerror. Access to strerrror is serialized by the
* use of a mutex variable to make strerror thread safe.
*
* INPUTS
* int errnum - the errno to explain
* dstring *buffer - buffer into which the error message is written
*
* RESULT
* const char* - pointer to a string explaining errnum
*
* NOTES
* MT-NOTE: sge_strerror() is MT safe
*******************************************************************************/
const char *
sge_strerror(int errnum, dstring *buffer)
{
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
const char *ret;
pthread_mutex_lock(&mtx);
ret = strerror(errnum);
ret = sge_dstring_copy_string(buffer, ret);
pthread_mutex_unlock(&mtx);
return ret;
}
/****** sge_binding_hlp/parse_binding_parameter_string() ***********************
* NAME
* parse_binding_parameter_string() -- Parses binding parameter string.
*
* SYNOPSIS
* bool parse_binding_parameter_string(const char* parameter, u_long32*
* type, dstring* strategy, int* amount, int* stepsize, int* firstsocket,
* int* firstcore, dstring* socketcorelist, dstring* error)
*
* FUNCTION
* Parses binding parameter string and returns the values of the parameter.
* Please check output values in dependency of the strategy string.
*
* INPUTS
* const char* parameter - binding parameter string
*
* OUTPUT
* u_long32* type - type of binding (pe = 0| env = 1|set = 2)
* dstring* strategy - binding strategy string
* int* amount - amount of cores to bind to
* int* stepsize - step size between cores (or -1)
* int* firstsocket - first socket to use (or -1)
* int* firstcore - first core to use (on "first socket") (or -1)
* dstring* socketcorelist - list of socket,core pairs with prefix explicit or NULL
* dstring* error - error as string in case of return false
*
* RESULT
* bool - true in case parsing was successful false in case of errors
*
* NOTES
* MT-NOTE: parse_binding_parameter_string() is MT safe
*
*******************************************************************************/
bool parse_binding_parameter_string(const char* parameter, binding_type_t* type,
dstring* strategy, int* amount, int* stepsize, int* firstsocket,
int* firstcore, dstring* socketcorelist, dstring* error)
{
bool retval = true;
if (parameter == NULL) {
sge_dstring_sprintf(error, "input parameter was NULL");
return false;
}
/* check the type [pe|env|set] (set is default) */
if (strstr(parameter, "pe ") != NULL) {
*type = BINDING_TYPE_PE;
} else if (strstr(parameter, "env ") != NULL) {
*type = BINDING_TYPE_ENV;
} else {
*type = BINDING_TYPE_SET;
}
if (strstr(parameter, "linear") != NULL) {
*amount = binding_linear_parse_amount(parameter);
if (*amount < 0) {
/* couldn't parse amount of cores */
sge_dstring_sprintf(error, "couldn't parse amount (linear)");
return false;
}
*firstsocket = binding_linear_parse_socket_offset(parameter);
if (*firstsocket == -2) {
sge_dstring_sprintf(error, "couldn't parse socket number (linear)");
return false;
}
if (*firstsocket < 0) {
/* no socket number given, hence we don't scan for the core number */
*firstcore = *firstsocket;
} else {
*firstcore = binding_linear_parse_core_offset(parameter);
if (*firstcore < 0) {
/* there was an error during parsing the core number */
sge_dstring_sprintf(error, "couldn't parse core number (linear)");
return false;
}
}
if (*firstsocket < 0 && *firstcore < 0) {
/* couldn't find start <socket,core> -> must be determined
automatically */
sge_dstring_sprintf(strategy, "linear_automatic");
/* this might be an error on shepherd side only */
*firstsocket = -1;
*firstcore = -1;
} else {
sge_dstring_sprintf(strategy, "linear");
}
/* set step size to dummy */
*stepsize = -1;
} else if (strstr(parameter, "striding") != NULL) {
*amount = binding_striding_parse_amount(parameter);
if (*amount < 0) {
/* couldn't parse amount of cores */
sge_dstring_sprintf(error, "couldn't parse amount (striding)");
return false;
}
*stepsize = binding_striding_parse_step_size(parameter);
if (*stepsize < 0) {
/* no given stepsize does lead to stepsize 0 which will
be extended on the execution host to <amount of cores per socket>.
When using a start socket,core the stepsize 0 has to be
included (binding striding:<amount>:0:<socket>,<core>.*/
/* *stepsize = 0; */
sge_dstring_sprintf(error, "couldn't parse stepsize (striding)");
return false;
}
*firstsocket = binding_striding_parse_first_socket(parameter);
if (*firstsocket == -2) {
sge_dstring_sprintf(error, "couldn't parse socket number (striding)");
return false;
}
if (*firstsocket == -1) {
*firstcore = -1;
} else {
/* we need to parse the core number since a socket number is given */
*firstcore = binding_striding_parse_first_core(parameter);
if (*firstcore < 0) {
sge_dstring_sprintf(error, "couldn't parse core number (striding)");
return false;
}
}
if (*firstsocket < 0 || *firstcore < 0) {
sge_dstring_sprintf(strategy, "striding_automatic");
/* this might be an error on shepherd side only */
*firstsocket = -1;
*firstcore = -1;
} else {
sge_dstring_sprintf(strategy, "striding");
}
} else if (strstr(parameter, "explicit") != NULL) {
if (binding_explicit_has_correct_syntax(parameter, error) == false) {
retval = false;
} else {
if (socketcorelist == NULL) {
sge_dstring_sprintf(error, MSG_SYNTAX_DSTRINGBUG);
retval = false;
} else {
char* pos = strstr(parameter, "explicit");
sge_dstring_copy_string(socketcorelist, pos);
sge_dstring_sprintf(strategy, "explicit");
pos = NULL;
}
}
} else {
/* error: no valid strategy found */
sge_dstring_sprintf(error, "couldn't parse binding parameter (no strategy found)");
retval = false;
}
return retval;
}
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;
}
