static char * util_bt_alloc_current_executable(const char * bt_symbol) {
if (__current_executable != NULL)
return util_alloc_string_copy(__current_executable );
else {
if (bt_symbol != NULL) {
int paren_pos = 0;
char * path;
while (bt_symbol[paren_pos] != '(' && bt_symbol[paren_pos] != ' ')
paren_pos++;
path = util_alloc_substring_copy(bt_symbol , 0 , paren_pos);
if (util_is_abs_path(path))
return path;
else {
char * full_path = util_alloc_PATH_executable( path );
free(path);
return full_path;
}
} else
return NULL;
}
}
bool config_schema_item_validate_set(const config_schema_item_type * item , stringlist_type * token_list , const char * config_file, const config_path_elm_type * path_elm , config_error_type * error_list) {
bool OK = true;
int argc = stringlist_get_size( token_list ) - 1;
if (item->validate->argc_min >= 0) {
if (argc < item->validate->argc_min) {
OK = false;
{
char * error_message;
if (config_file != NULL)
error_message = util_alloc_sprintf("Error when parsing config_file:\"%s\" Keyword:%s must have at least %d arguments.",config_file , item->kw , item->validate->argc_min);
else
error_message = util_alloc_sprintf("Error:: Keyword:%s must have at least %d arguments.",item->kw , item->validate->argc_min);
config_error_add( error_list , error_message );
}
}
}
if (item->validate->argc_max >= 0) {
if (argc > item->validate->argc_max) {
OK = false;
{
char * error_message;
if (config_file != NULL)
error_message = util_alloc_sprintf("Error when parsing config_file:\"%s\" Keyword:%s must have maximum %d arguments.",config_file , item->kw , item->validate->argc_max);
else
error_message = util_alloc_sprintf("Error:: Keyword:%s must have maximum %d arguments.",item->kw , item->validate->argc_max);
config_error_add( error_list , error_message );
}
}
}
/*
OK - now we have verified that the number of arguments is correct. Then
we start actually looking at the values.
*/
if (OK) {
/* Validating selection set - first common, then indexed */
if (item->validate->common_selection_set) {
for (int iarg = 0; iarg < argc; iarg++) {
if (!set_has_key(item->validate->common_selection_set , stringlist_iget( token_list , iarg + 1))) {
config_error_add( error_list , util_alloc_sprintf("%s: is not a valid value for: %s.",stringlist_iget( token_list , iarg + 1) , item->kw));
OK = false;
}
}
} else if (item->validate->indexed_selection_set != NULL) {
for (int iarg = 0; iarg < argc; iarg++) {
if ((item->validate->argc_max > 0) || (iarg < item->validate->argc_min)) { /* Without this test we might go out of range on the indexed selection set. */
const set_type * selection_set = validate_iget_selection_set( item->validate , iarg);
if (selection_set) {
if (!set_has_key( selection_set, stringlist_iget( token_list , iarg + 1))) {
config_error_add( error_list , util_alloc_sprintf("%s: is not a valid value for item %d of \'%s\'.",stringlist_iget( token_list , iarg + 1) , iarg + 1 , item->kw));
OK = false;
}
}
}
}
}
/*
Observe that the following code might rewrite the content of
argv for arguments referring to path locations.
*/
/* Validate the TYPE of the various argumnents */
{
for (int iarg = 0; iarg < argc; iarg++) {
const char * value = stringlist_iget(token_list , iarg + 1);
switch (validate_iget_type( item->validate , iarg)) {
case(CONFIG_STRING): /* This never fails ... */
break;
case(CONFIG_ISODATE):
if (!util_sscanf_isodate( value , NULL ))
config_error_add( error_list , util_alloc_sprintf("Failed to parse:%s as an ISO date: YYYY-MM-DD.",value));
break;
case(CONFIG_INT):
if (!util_sscanf_int( value , NULL ))
config_error_add( error_list , util_alloc_sprintf("Failed to parse:%s as an integer.",value));
break;
case(CONFIG_FLOAT):
if (!util_sscanf_double( value , NULL )) {
config_error_add( error_list , util_alloc_sprintf("Failed to parse:%s as a floating point number.", value));
OK = false;
}
break;
case(CONFIG_PATH):
// As long as we do not reuqire the path to exist it is just a string.
break;
case(CONFIG_EXISTING_PATH):
{
char * path = config_path_elm_alloc_abspath( path_elm , value );
if (!util_entry_exists(path)) {
config_error_add( error_list , util_alloc_sprintf("Can not find entry %s in %s ",value , config_path_elm_get_relpath( path_elm) ));
OK = false;
}
free( path );
}
break;
case(CONFIG_EXECUTABLE):
{
/*
1. If the supplied value is an abolute path - do nothing.
2. If the supplied is _not_ an absolute path:
a. Try if the relocated exists - then use that.
b. Else - try if the util_alloc_PATH_executable() exists.
*/
if (!util_is_abs_path( value )) {
char * relocated = __alloc_relocated__(path_elm , value);
char * path_exe = util_alloc_PATH_executable( value );
if (util_file_exists(relocated)) {
if (util_is_executable(relocated))
stringlist_iset_copy( token_list , iarg , relocated);
} else if (path_exe != NULL)
stringlist_iset_copy( token_list , iarg , path_exe);
else
config_error_add( error_list , util_alloc_sprintf("Could not locate executable:%s ", value));
free(relocated);
util_safe_free(path_exe);
} else {
if (!util_is_executable( value ))
config_error_add( error_list , util_alloc_sprintf("Could not locate executable:%s ", value));
}
}
break;
case(CONFIG_BOOL):
if (!util_sscanf_bool( value , NULL )) {
config_error_add( error_list , util_alloc_sprintf("Failed to parse:%s as a boolean.", value));
OK = false;
}
break;
case(CONFIG_BYTESIZE):
if (!util_sscanf_bytesize( value , NULL)) {
config_error_add( error_list , util_alloc_sprintf("Failed to parse:\"%s\" as number of bytes." , value));
OK = false;
}
break;
default:
util_abort("%s: config_item_type:%d not recognized \n",__func__ , validate_iget_type(item->validate , iarg));
}
}
}
}
return OK;
}
job_queue_node_type * job_queue_node_alloc( const char * job_name ,
const char * run_path ,
const char * run_cmd ,
int argc ,
const char ** argv,
int num_cpu,
const char * ok_file,
const char * exit_file,
job_callback_ftype * done_callback,
job_callback_ftype * retry_callback,
job_callback_ftype * exit_callback,
void * callback_arg) {
if (util_is_directory( run_path )) {
job_queue_node_type * node = util_malloc(sizeof * node );
UTIL_TYPE_ID_INIT( node , JOB_QUEUE_NODE_TYPE_ID );
{
/* The data initialized in this block should *NEVER* change. */
node->job_name = util_alloc_string_copy( job_name );
if (util_is_abs_path(run_path))
node->run_path = util_alloc_string_copy( run_path );
else
node->run_path = util_alloc_realpath( run_path );
node->run_cmd = util_alloc_string_copy( run_cmd );
node->argc = argc;
node->argv = util_alloc_stringlist_copy( argv , argc );
node->num_cpu = num_cpu;
if (ok_file)
node->ok_file = util_alloc_filename(node->run_path , ok_file , NULL);
else
node->ok_file = NULL;
if (exit_file)
node->exit_file = util_alloc_filename(node->run_path , exit_file , NULL);
else
node->exit_file = NULL;
node->exit_callback = exit_callback;
node->retry_callback = retry_callback;
node->done_callback = done_callback;
node->callback_arg = callback_arg;
}
{
node->error_reason = NULL;
node->stderr_capture = NULL;
node->stderr_file = NULL;
node->failed_job = NULL;
}
{
node->job_status = JOB_QUEUE_NOT_ACTIVE;
node->queue_index = INVALID_QUEUE_INDEX;
node->submit_attempt = 0;
node->job_data = NULL; /* The allocation is run in single thread mode - we assume. */
node->sim_start = 0;
node->sim_end = 0;
node->submit_time = time( NULL );
}
pthread_mutex_init( &node->data_mutex , NULL );
return node;
} else
return NULL;
}
