/*
* slurm_print_federation - prints slurmdb_federation_rec_t (passed as void*
* since slurm.h doesn't know about slurmdb.h).
*/
extern void slurm_print_federation(void *ptr)
{
ListIterator itr;
slurmdb_cluster_rec_t *cluster;
int left_col_size;
char *conn_status[] = {"Disconnected", "Connected"};
char *cluster_name = NULL;
slurmdb_federation_rec_t *fed = (slurmdb_federation_rec_t *)ptr;
xassert(fed);
if (!fed->name)
return;
cluster_name = slurm_get_cluster_name();
left_col_size = strlen("federation:");
printf("%-*s %s\n", left_col_size, "Federation:", fed->name);
list_sort(fed->cluster_list, (ListCmpF)_sort_clusters_by_name);
itr = list_iterator_create(fed->cluster_list);
/* Display local Cluster*/
while ((cluster = list_next(itr))) {
if (!xstrcmp(cluster->name, cluster_name)) {
char *tmp_str =
slurmdb_cluster_fed_states_str(
cluster->fed.state);
printf("%-*s %s:%s:%d ID:%d FedState:%s Weight:%d\n",
left_col_size, "Self:", cluster->name,
cluster->control_host, cluster->control_port,
cluster->fed.id, (tmp_str ? tmp_str : ""),
cluster->fed.weight);
}
}
/* Display siblings */
list_iterator_reset(itr);
while ((cluster = list_next(itr))) {
char *tmp_str = NULL;
int conn_type = 0;
if (!xstrcmp(cluster->name, cluster_name))
continue;
if (cluster->sockfd != -1)
conn_type = 1;
tmp_str = slurmdb_cluster_fed_states_str(cluster->fed.state);
printf("%-*s %s:%s:%d ID:%d FedState:%s Weight:%d "
"PersistConn:%s\n",
left_col_size, "Sibling:", cluster->name,
cluster->control_host, cluster->control_port,
cluster->fed.id, (tmp_str ? tmp_str : ""),
cluster->fed.weight, conn_status[conn_type]);
}
list_iterator_destroy(itr);
xfree(cluster_name);
}
extern int sbatch_set_first_avail_cluster(job_desc_msg_t *req)
{
//printf("cao: src/sbatch/multi_cluster.c: sbatch_set_first_avail_cluster(job_desc_msg_t *req)\n");
int rc = SLURM_SUCCESS;
ListIterator itr;
local_cluster_rec_t *local_cluster = NULL;
char buf[64];
bool host_set = false;
List ret_list = NULL;
/* return if we only have 1 or less clusters here */
if (!opt.clusters || !list_count(opt.clusters)) {
return rc;
} else if (list_count(opt.clusters) == 1) {
working_cluster_rec = list_peek(opt.clusters);
return rc;
}
if ((req->alloc_node == NULL) &&
(gethostname_short(buf, sizeof(buf)) == 0)) {
req->alloc_node = buf;
host_set = true;
}
ret_list = list_create(_destroy_local_cluster_rec);
itr = list_iterator_create(opt.clusters);
while ((working_cluster_rec = list_next(itr))) {
if ((local_cluster = _job_will_run(req)))
list_append(ret_list, local_cluster);
else
error("Problem with submit to cluster %s: %m",
working_cluster_rec->name);
}
list_iterator_destroy(itr);
if (host_set)
req->alloc_node = NULL;
if (!list_count(ret_list)) {
error("Can't run on any of the clusters given");
rc = SLURM_ERROR;
goto end_it;
}
/* sort the list so the first spot is on top */
local_cluster_name = slurm_get_cluster_name();
list_sort(ret_list, (ListCmpF)_sort_local_cluster);
xfree(local_cluster_name);
local_cluster = list_peek(ret_list);
/* set up the working cluster and be done */
working_cluster_rec = local_cluster->cluster_rec;
end_it:
list_destroy(ret_list);
return rc;
}
/*
* slurm_load_node - issue RPC to get slurm all node configuration information
* if changed since update_time
* IN update_time - time of current configuration data
* OUT resp - place to store a node configuration pointer
* IN show_flags - node filtering options
* RET 0 or a slurm error code
* NOTE: free the response using slurm_free_node_info_msg
*/
extern int slurm_load_node(time_t update_time, node_info_msg_t **resp,
uint16_t show_flags)
{
slurm_msg_t req_msg;
node_info_request_msg_t req;
char *cluster_name = NULL;
void *ptr = NULL;
slurmdb_federation_rec_t *fed;
int rc;
if (working_cluster_rec)
cluster_name = xstrdup(working_cluster_rec->name);
else
cluster_name = slurm_get_cluster_name();
if ((show_flags & SHOW_FEDERATION) && !(show_flags & SHOW_LOCAL) &&
(slurm_load_federation(&ptr) == SLURM_SUCCESS) &&
cluster_in_federation(ptr, cluster_name)) {
/* In federation. Need full info from all clusters */
update_time = (time_t) 0;
show_flags &= (~SHOW_LOCAL);
} else {
/* Report local cluster info only */
show_flags |= SHOW_LOCAL;
show_flags &= (~SHOW_FEDERATION);
}
slurm_msg_t_init(&req_msg);
memset(&req, 0, sizeof(req));
req.last_update = update_time;
req.show_flags = show_flags;
req_msg.msg_type = REQUEST_NODE_INFO;
req_msg.data = &req;
if ((show_flags & SHOW_FEDERATION) && ptr) { /* "ptr" check for CLANG */
fed = (slurmdb_federation_rec_t *) ptr;
rc = _load_fed_nodes(&req_msg, resp, show_flags, cluster_name,
fed);
} else {
rc = _load_cluster_nodes(&req_msg, resp, working_cluster_rec,
show_flags);
}
if (ptr)
slurm_destroy_federation_rec(ptr);
xfree(cluster_name);
return rc;
}
static int _set_cond(int *start, int argc, char *argv[],
slurmdb_event_cond_t *event_cond,
List format_list)
{
int i, end = 0;
int set = 0;
int command_len = 0;
int local_cluster_flag = 0;
int all_time_flag = 0;
if(!event_cond->cluster_list)
event_cond->cluster_list = list_create(slurm_destroy_char);
for (i=(*start); i<argc; i++) {
end = parse_option_end(argv[i]);
if(!end)
command_len=strlen(argv[i]);
else {
command_len=end-1;
if (argv[i][end] == '=') {
end++;
}
}
if(!end && !strncasecmp(argv[i], "all_clusters",
MAX(command_len, 5))) {
local_cluster_flag = 1;
} else if(!end && !strncasecmp(argv[i], "all_time",
MAX(command_len, 5))) {
all_time_flag = 1;
} else if(!end && !strncasecmp(argv[i], "where",
MAX(command_len, 5))) {
continue;
} else if(!end || (!strncasecmp (argv[i], "Events",
MAX(command_len, 1)))) {
ListIterator itr = NULL;
List tmp_list = list_create(slurm_destroy_char);
char *temp = NULL;
if(slurm_addto_char_list(tmp_list,
argv[i]+end))
set = 1;
/* check to make sure user gave ints here */
itr = list_iterator_create(tmp_list);
while ((temp = list_next(itr))) {
if(!strncasecmp("Node", temp,
MAX(strlen(temp), 1))) {
if(event_cond->event_type)
event_cond->event_type =
SLURMDB_EVENT_ALL;
else
event_cond->event_type =
SLURMDB_EVENT_NODE;
} else if(!strncasecmp("Cluster", temp,
MAX(strlen(temp), 1))) {
if(event_cond->event_type)
event_cond->event_type =
SLURMDB_EVENT_ALL;
else
event_cond->event_type =
SLURMDB_EVENT_CLUSTER;
} else {
exit_code=1;
fprintf(stderr,
" Unknown event type: '%s' "
"Valid events are Cluster "
"and Node.\n",
temp);
}
}
list_iterator_destroy(itr);
list_destroy(tmp_list);
} else if (!strncasecmp (argv[i], "Clusters",
MAX(command_len, 1))) {
if(!event_cond->cluster_list)
event_cond->cluster_list =
list_create(slurm_destroy_char);
if(slurm_addto_char_list(event_cond->cluster_list,
argv[i]+end))
set = 1;
} else if (!strncasecmp (argv[i], "End", MAX(command_len, 1))) {
event_cond->period_end = parse_time(argv[i]+end, 1);
set = 1;
} else if (!strncasecmp (argv[i], "Format",
MAX(command_len, 1))) {
if(format_list)
slurm_addto_char_list(format_list, argv[i]+end);
} else if (!strncasecmp (argv[i], "MinCpus",
MAX(command_len, 2))) {
if (get_uint(argv[i]+end, &event_cond->cpus_min,
"MinCpus") == SLURM_SUCCESS)
set = 1;
} else if (!strncasecmp (argv[i], "MaxCpus",
MAX(command_len, 2))) {
if (get_uint(argv[i]+end, &event_cond->cpus_max,
"MaxCpus") == SLURM_SUCCESS)
set = 1;
} else if (!strncasecmp (argv[i], "Nodes",
MAX(command_len, 1))) {
if(!event_cond->node_list)
event_cond->node_list =
list_create(slurm_destroy_char);
if(slurm_addto_char_list(event_cond->node_list,
argv[i]+end))
set = 1;
} else if (!strncasecmp (argv[i], "Reason",
MAX(command_len, 1))) {
if(!event_cond->reason_list)
event_cond->reason_list =
list_create(slurm_destroy_char);
if(slurm_addto_char_list(event_cond->reason_list,
argv[i]+end))
set = 1;
} else if (!strncasecmp (argv[i], "Start",
MAX(command_len, 4))) {
event_cond->period_start = parse_time(argv[i]+end, 1);
set = 1;
} else if (!strncasecmp (argv[i], "States",
MAX(command_len, 4))) {
if(!event_cond->state_list)
event_cond->state_list =
list_create(slurm_destroy_char);
if(_addto_state_char_list(event_cond->state_list,
argv[i]+end)) {
event_cond->event_type = SLURMDB_EVENT_NODE;
set = 1;
}
} else if (!strncasecmp (argv[i], "User",
MAX(command_len, 1))) {
if(!event_cond->reason_uid_list)
event_cond->reason_uid_list =
list_create(slurm_destroy_char);
if(_addto_id_char_list(event_cond->reason_uid_list,
argv[i]+end, 0)) {
event_cond->event_type = SLURMDB_EVENT_NODE;
set = 1;
}
} else {
exit_code=1;
fprintf(stderr, " Unknown condition: %s\n", argv[i]);
}
}
(*start) = i;
if(!local_cluster_flag && !list_count(event_cond->cluster_list)) {
char *temp = slurm_get_cluster_name();
if(temp)
list_append(event_cond->cluster_list, temp);
}
if(!all_time_flag && !event_cond->period_start) {
event_cond->period_start = time(NULL);
if(!event_cond->state_list) {
struct tm start_tm;
if(!localtime_r(&event_cond->period_start, &start_tm)) {
fprintf(stderr,
" Couldn't get localtime from %ld",
(long)event_cond->period_start);
exit_code=1;
return 0;
}
start_tm.tm_sec = 0;
start_tm.tm_min = 0;
start_tm.tm_hour = 0;
start_tm.tm_mday--;
start_tm.tm_isdst = -1;
event_cond->period_start = mktime(&start_tm);
}
}
return set;
}
/*
* parse_command_line, fill in params data structure with data
*/
extern void parse_command_line(int argc, char **argv)
{
char *env_val = NULL;
int opt_char;
int option_index;
hostlist_t host_list;
bool long_form = false;
bool opt_a_set = false, opt_p_set = false;
bool env_a_set = false, env_p_set = false;
static struct option long_options[] = {
{"all", no_argument, 0, 'a'},
{"bg", no_argument, 0, 'b'},
{"dead", no_argument, 0, 'd'},
{"exact", no_argument, 0, 'e'},
{"federation",no_argument, 0, OPT_LONG_FEDR},
{"help", no_argument, 0, OPT_LONG_HELP},
{"hide", no_argument, 0, OPT_LONG_HIDE},
{"iterate", required_argument, 0, 'i'},
{"local", no_argument, 0, OPT_LONG_LOCAL},
{"long", no_argument, 0, 'l'},
{"cluster", required_argument, 0, 'M'},
{"clusters", required_argument, 0, 'M'},
{"nodes", required_argument, 0, 'n'},
{"noconvert", no_argument, 0, OPT_LONG_NOCONVERT},
{"noheader", no_argument, 0, 'h'},
{"Node", no_argument, 0, 'N'},
{"format", required_argument, 0, 'o'},
{"Format", required_argument, 0, 'O'},
{"partition", required_argument, 0, 'p'},
{"responding",no_argument, 0, 'r'},
{"list-reasons", no_argument, 0, 'R'},
{"summarize", no_argument, 0, 's'},
{"sort", required_argument, 0, 'S'},
{"states", required_argument, 0, 't'},
{"reservation",no_argument, 0, 'T'},
{"usage", no_argument, 0, OPT_LONG_USAGE},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{NULL, 0, 0, 0}
};
params.convert_flags = CONVERT_NUM_UNIT_EXACT;
if (slurmctld_conf.fed_params &&
strstr(slurmctld_conf.fed_params, "fed_display"))
params.federation_flag = true;
if (getenv("SINFO_ALL")) {
env_a_set = true;
params.all_flag = true;
}
if (getenv("SINFO_FEDERATION"))
params.federation_flag = true;
if (getenv("SINFO_LOCAL"))
params.local = true;
if ( ( env_val = getenv("SINFO_PARTITION") ) ) {
env_p_set = true;
params.partition = xstrdup(env_val);
params.part_list = _build_part_list(env_val);
params.all_flag = true;
}
if (env_a_set && env_p_set) {
error("Conflicting options, SINFO_ALL and SINFO_PARTITION, specified. "
"Please choose one or the other.");
exit(1);
}
if ( ( env_val = getenv("SINFO_SORT") ) )
params.sort = xstrdup(env_val);
if ( ( env_val = getenv("SLURM_CLUSTERS") ) ) {
if (!(params.clusters = slurmdb_get_info_cluster(env_val))) {
print_db_notok(env_val, 1);
exit(1);
}
working_cluster_rec = list_peek(params.clusters);
params.local = true;
}
while ((opt_char = getopt_long(argc, argv,
"abdehi:lM:n:No:O:p:rRsS:t:TvV",
long_options, &option_index)) != -1) {
switch (opt_char) {
case (int)'?':
fprintf(stderr,
"Try \"sinfo --help\" for more information\n");
exit(1);
break;
case (int)'a':
opt_a_set = true;
xfree(params.partition);
FREE_NULL_LIST(params.part_list);
params.all_flag = true;
break;
case (int)'b':
params.cluster_flags = slurmdb_setup_cluster_flags();
if (params.cluster_flags & CLUSTER_FLAG_BG)
params.bg_flag = true;
else {
error("Must be on a BG system to use --bg "
"option, if using --cluster option "
"put the --bg option "
"after the --cluster option.");
exit(1);
}
break;
case (int)'d':
params.dead_nodes = true;
break;
case (int)'e':
params.exact_match = true;
break;
case (int)'h':
params.no_header = true;
break;
case (int) 'i':
params.iterate= atoi(optarg);
if (params.iterate <= 0) {
error ("Error: invalid entry for "
"--iterate=%s", optarg);
exit(1);
}
break;
case (int) 'l':
params.long_output = true;
break;
case (int) 'M':
FREE_NULL_LIST(params.clusters);
if (!(params.clusters =
slurmdb_get_info_cluster(optarg))) {
print_db_notok(optarg, 0);
exit(1);
}
working_cluster_rec = list_peek(params.clusters);
params.local = true;
break;
case OPT_LONG_NOCONVERT:
params.convert_flags |= CONVERT_NUM_UNIT_NO;
break;
case (int) 'n':
xfree(params.nodes);
params.nodes = xstrdup(optarg);
/*
* confirm valid nodelist entry
*/
host_list = hostlist_create(params.nodes);
if (!host_list) {
error("'%s' invalid entry for --nodes",
optarg);
exit(1);
}
if (hostlist_count(host_list) == 1) {
params.node_name_single = true;
xfree(params.nodes);
params.nodes =
hostlist_deranged_string_xmalloc(host_list);
} else
params.node_name_single = false;
hostlist_destroy(host_list);
break;
case (int) 'N':
params.node_flag = true;
break;
case (int) 'o':
xfree(params.format);
params.format = xstrdup(optarg);
break;
case (int) 'O':
long_form = true;
xfree(params.format);
params.format = xstrdup(optarg);
break;
case (int) 'p':
opt_p_set = true;
xfree(params.partition);
FREE_NULL_LIST(params.part_list);
params.partition = xstrdup(optarg);
params.part_list = _build_part_list(optarg);
params.all_flag = true;
break;
case (int) 'r':
params.responding_nodes = true;
break;
case (int) 'R':
params.list_reasons = true;
break;
case (int) 's':
params.summarize = true;
break;
case (int) 'S':
xfree(params.sort);
params.sort = xstrdup(optarg);
break;
case (int) 't':
xfree(params.states);
params.states = xstrdup(optarg);
if (!(params.state_list = _build_state_list(optarg))) {
error ("valid states: %s", _node_state_list ());
exit (1);
}
break;
case (int) 'T':
params.reservation_flag = true;
break;
case (int) 'v':
params.verbose++;
break;
case (int) 'V':
print_slurm_version ();
exit(0);
case (int) OPT_LONG_FEDR:
params.federation_flag = true;
break;
case (int) OPT_LONG_HELP:
_help();
exit(0);
case (int) OPT_LONG_USAGE:
_usage();
exit(0);
case OPT_LONG_HIDE:
params.all_flag = false;
break;
case OPT_LONG_LOCAL:
params.local = true;
break;
}
}
if (opt_a_set && opt_p_set) {
error("Conflicting options, -a and -p, specified. "
"Please choose one or the other.");
exit(1);
}
params.cluster_flags = slurmdb_setup_cluster_flags();
if (params.federation_flag && !params.clusters && !params.local) {
void *ptr = NULL;
char *cluster_name = slurm_get_cluster_name();
if (slurm_load_federation(&ptr) ||
!cluster_in_federation(ptr, cluster_name)) {
/* Not in federation */
params.local = true;
slurm_destroy_federation_rec(ptr);
} else {
params.fed = (slurmdb_federation_rec_t *) ptr;
}
xfree(cluster_name);
}
if ( params.format == NULL ) {
if ( params.summarize ) {
params.part_field_flag = true; /* compute size later */
if (params.cluster_flags & CLUSTER_FLAG_BG)
params.format = "%9P %.5a %.10l %.32F %N";
else
params.format = "%9P %.5a %.10l %.16F %N";
} else if ( params.node_flag ) {
params.node_field_flag = true; /* compute size later */
params.part_field_flag = true; /* compute size later */
params.format = params.long_output ?
"%N %.6D %.9P %.11T %.4c %.8z %.6m %.8d %.6w %.8f %20E" :
"%N %.6D %.9P %6t";
} else if (params.list_reasons) {
params.format = params.long_output ?
"%20E %12U %19H %6t %N" :
"%20E %9u %19H %N";
} else if ((env_val = getenv ("SINFO_FORMAT"))) {
params.format = xstrdup(env_val);
} else if (params.fed) {
params.part_field_flag = true; /* compute size later */
params.format = params.long_output ?
"%9P %8V %.5a %.10l %.10s %.4r %.8h %.10g %.6D %.11T %N" :
"%9P %8V %.5a %.10l %.6D %.6t %N";
} else {
params.part_field_flag = true; /* compute size later */
params.format = params.long_output ?
"%9P %.5a %.10l %.10s %.4r %.8h %.10g %.6D %.11T %N" :
"%9P %.5a %.10l %.6D %.6t %N";
}
}
if (long_form)
_parse_long_format(params.format);
else
_parse_format(params.format);
if (params.list_reasons && (params.state_list == NULL)) {
params.states = xstrdup ("down,drain,error");
if (!(params.state_list = _build_state_list (params.states)))
fatal ("Unable to build state list for -R!");
}
if (params.dead_nodes || params.nodes || params.partition ||
params.responding_nodes ||params.state_list)
params.filtering = true;
if (params.verbose)
_print_options();
}
/*
* slurm_print_federation - prints slurmdb_federation_rec_t (passed as void*
* since slurm.h doesn't know about slurmdb.h).
*/
extern void slurm_print_federation(void *ptr)
{
ListIterator itr;
slurmdb_cluster_rec_t *cluster;
int left_col_size;
char *cluster_name = NULL;
slurmdb_federation_rec_t *fed = (slurmdb_federation_rec_t *)ptr;
if (!fed || !fed->name)
return;
if (working_cluster_rec)
cluster_name = xstrdup(working_cluster_rec->name);
else
cluster_name = slurm_get_cluster_name();
left_col_size = strlen("federation:");
printf("%-*s %s\n", left_col_size, "Federation:",
fed->name);
list_sort(fed->cluster_list, (ListCmpF)_sort_clusters_by_name);
itr = list_iterator_create(fed->cluster_list);
/* Display local Cluster */
while ((cluster = list_next(itr))) {
char *features, *tmp_str;
if (xstrcmp(cluster->name, cluster_name))
continue;
features = slurm_char_list_to_xstr( cluster->fed.feature_list);
tmp_str = slurmdb_cluster_fed_states_str( cluster->fed.state);
printf("%-*s %s:%s:%d ID:%d FedState:%s Features:%s\n",
left_col_size, "Self:", cluster->name,
cluster->control_host ? cluster->control_host : "",
cluster->control_port,
cluster->fed.id, (tmp_str ? tmp_str : ""),
features ? features : "");
xfree(features);
break;
}
/* Display siblings */
list_iterator_reset(itr);
while ((cluster = list_next(itr))) {
char *tmp_str = NULL;
char *features = NULL;
if (!xstrcmp(cluster->name, cluster_name))
continue;
features = slurm_char_list_to_xstr(cluster->fed.feature_list);
tmp_str = slurmdb_cluster_fed_states_str(cluster->fed.state);
printf("%-*s %s:%s:%d ID:%d FedState:%s Features:%s PersistConnSend/Recv:%s/%s\n",
left_col_size, "Sibling:", cluster->name,
cluster->control_host ? cluster->control_host : "",
cluster->control_port,
cluster->fed.id, (tmp_str ? tmp_str : ""),
features ? features : "",
cluster->fed.send ? "Yes" : "No",
cluster->fed.recv ? "Yes" : "No");
xfree(features);
}
list_iterator_destroy(itr);
xfree(cluster_name);
}
static GtkWidget *_create_cluster_combo(void)
{
GtkListStore *model = NULL;
GtkWidget *combo = NULL;
GtkTreeIter iter;
ListIterator itr;
slurmdb_cluster_rec_t *cluster_rec;
GtkCellRenderer *renderer = NULL;
bool got_db = slurm_get_is_association_based_accounting();
int count = 0, spot = 0;
if (!got_db)
return NULL;
cluster_list = slurmdb_get_info_cluster(NULL);
if (!cluster_list || !list_count(cluster_list)) {
FREE_NULL_LIST(cluster_list);
return NULL;
}
if (!orig_cluster_name)
orig_cluster_name = slurm_get_cluster_name();
if (list_count(cluster_list) > 1)
model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_POINTER);
/* Set up the working_cluster_rec just incase we are on a node
that doesn't technically belong to a cluster (like
the node running the slurmdbd).
*/
working_cluster_rec = list_peek(cluster_list);
itr = list_iterator_create(cluster_list);
while ((cluster_rec = list_next(itr))) {
if (model) {
gtk_list_store_append(model, &iter);
gtk_list_store_set(model, &iter,
0, cluster_rec->name,
1, cluster_rec,
-1);
}
if (!xstrcmp(cluster_rec->name, orig_cluster_name)) {
/* clear it since we found the current cluster */
working_cluster_rec = NULL;
spot = count;
}
count++;
}
list_iterator_destroy(itr);
if (model) {
combo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model));
g_object_unref(model);
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo),
renderer, true);
gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(combo),
renderer, "text", 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), spot);
g_signal_connect(combo, "changed",
G_CALLBACK(_change_cluster_main),
NULL);
}
return combo;
}
extern void _change_cluster_main(GtkComboBox *combo, gpointer extra)
{
GtkTreeModel *model;
display_data_t *display_data;
GtkTreeIter iter;
slurmdb_cluster_rec_t *cluster_rec = NULL;
char *tmp, *ui_description;
GError *error = NULL;
GtkWidget *node_tab = NULL;
int rc;
bool got_grid = 0;
if (!gtk_combo_box_get_active_iter(combo, &iter)) {
g_print("nothing selected\n");
return;
}
model = gtk_combo_box_get_model(combo);
if (!model) {
g_print("nothing selected\n");
return;
}
gtk_tree_model_get(model, &iter, 1, &cluster_rec, -1);
if (!cluster_rec) {
g_print("no cluster_rec pointer here!");
return;
}
/* From testing it doesn't appear you can get here without a
legitimate change, so there isn't a need to check if we are
going back to the same cluster we were just at.
*/
/* if (working_cluster_rec) { */
/* if (!xstrcmp(cluster_rec->name, working_cluster_rec->name)) */
/* return; */
/* } */
/* free old info under last cluster */
slurm_free_block_info_msg(g_block_info_ptr);
g_block_info_ptr = NULL;
slurm_free_front_end_info_msg(g_front_end_info_ptr);
g_front_end_info_ptr = NULL;
slurm_free_burst_buffer_info_msg(g_bb_info_ptr);
g_bb_info_ptr = NULL;
slurm_free_job_info_msg(g_job_info_ptr);
g_job_info_ptr = NULL;
slurm_free_node_info_msg(g_node_info_ptr);
g_node_info_ptr = NULL;
slurm_free_partition_info_msg(g_part_info_ptr);
g_part_info_ptr = NULL;
slurm_free_reservation_info_msg(g_resv_info_ptr);
g_resv_info_ptr = NULL;
slurm_free_ctl_conf(g_ctl_info_ptr);
g_ctl_info_ptr = NULL;
slurm_free_job_step_info_response_msg(g_step_info_ptr);
g_step_info_ptr = NULL;
slurm_free_topo_info_msg(g_topo_info_msg_ptr);
g_topo_info_msg_ptr = NULL;
/* set up working_cluster_rec */
if (cluster_dims > 1) {
/* reset from a multi-dim cluster */
working_sview_config.grid_x_width =
default_sview_config.grid_x_width;
working_sview_config.grid_hori = default_sview_config.grid_hori;
working_sview_config.grid_vert = default_sview_config.grid_vert;
}
gtk_table_set_col_spacings(main_grid_table, 0);
gtk_table_set_row_spacings(main_grid_table, 0);
if (!orig_cluster_name)
orig_cluster_name = slurm_get_cluster_name();
if (!xstrcmp(cluster_rec->name, orig_cluster_name))
working_cluster_rec = NULL;
else
working_cluster_rec = cluster_rec;
cluster_dims = slurmdb_setup_cluster_dims();
cluster_flags = slurmdb_setup_cluster_flags();
display_data = main_display_data;
while (display_data++) {
if (display_data->id == -1)
break;
if (cluster_flags & CLUSTER_FLAG_BG) {
switch(display_data->id) {
case BLOCK_PAGE:
display_data->show = true;
break;
case NODE_PAGE:
display_data->name = "Midplanes";
break;
default:
break;
}
} else {
switch(display_data->id) {
case BLOCK_PAGE:
display_data->show = false;
break;
case NODE_PAGE:
display_data->name = "Nodes";
break;
default:
break;
}
}
}
/* set up menu */
ui_description = _get_ui_description();
gtk_ui_manager_remove_ui(g_ui_manager, g_menu_id);
if (!(g_menu_id = gtk_ui_manager_add_ui_from_string(
g_ui_manager, ui_description, -1, &error))) {
xfree(ui_description);
g_error("building menus failed: %s", error->message);
g_error_free (error);
exit (0);
}
xfree(ui_description);
/* make changes for each object */
cluster_change_block();
cluster_change_front_end();
cluster_change_resv();
cluster_change_part();
cluster_change_job();
cluster_change_node();
cluster_change_bb();
/* destroy old stuff */
if (grid_button_list) {
FREE_NULL_LIST(grid_button_list);
got_grid = 1;
}
select_g_ba_fini();
/* sorry popups can't survive a cluster change */
if (popup_list)
list_flush(popup_list);
if (signal_params_list)
list_flush(signal_params_list);
if (signal_params_list)
list_flush(signal_params_list);
if (g_switch_nodes_maps)
free_switch_nodes_maps(g_switch_nodes_maps);
/* change the node tab name if needed */
node_tab = gtk_notebook_get_nth_page(
GTK_NOTEBOOK(main_notebook), NODE_PAGE);
node_tab = gtk_notebook_get_tab_label(GTK_NOTEBOOK(main_notebook),
node_tab);
#ifdef GTK2_USE_GET_FOCUS
/* ok, now we have a table which we have set up to contain an
* event_box which contains the label we are interested. We
* setup this label to be the focus child of the table, so all
* we have to do is grab that and we are set. */
node_tab = gtk_container_get_focus_child(GTK_CONTAINER(node_tab));
#else
/* See above comment. Since gtk_container_get_focus_child
* doesn't exist yet we will just traverse the children until
* we find the label widget and then break.
*/
{
int i = 0;
GList *children = gtk_container_get_children(
GTK_CONTAINER(node_tab));
while ((node_tab = g_list_nth_data(children, i++))) {
int j = 0;
GList *children2 = gtk_container_get_children(
GTK_CONTAINER(node_tab));
while ((node_tab = g_list_nth_data(children2, j++))) {
if (GTK_IS_LABEL(node_tab))
break;
}
g_list_free(children2);
if (node_tab)
break;
}
g_list_free(children);
}
#endif
if (node_tab)
gtk_label_set_text(GTK_LABEL(node_tab),
main_display_data[NODE_PAGE].name);
/* The name in the visible tabs is easier since it is really
just a button with a label on it.
*/
if (default_sview_config.page_check_widget[NODE_PAGE]) {
gtk_button_set_label(GTK_BUTTON(default_sview_config.
page_check_widget[NODE_PAGE]),
main_display_data[NODE_PAGE].name);
}
/* reinit */
rc = get_system_stats(main_grid_table);
if (rc == SLURM_SUCCESS) {
/* It turns out if we didn't have the grid (cluster
not responding) before the
new grid doesn't get set up correctly. Redoing the
system_stats fixes it. There is probably a better
way of doing this, but it doesn't happen very often
and isn't that bad to handle every once in a while.
*/
if (!got_grid) {
/* I know we just did this before, but it
needs to be done again here.
*/
FREE_NULL_LIST(grid_button_list);
get_system_stats(main_grid_table);
}
refresh_main(NULL, NULL);
}
tmp = g_strdup_printf("Cluster changed to %s", cluster_rec->name);
display_edit_note(tmp);
g_free(tmp);
}
static int _set_cond(int *start, int argc, char *argv[],
slurmdb_job_modify_cond_t *job_cond)
{
char *next_str;
int i;
int set = 0;
int end = 0;
int command_len = 0;
if (!job_cond) {
error("No job_cond given");
return -1;
}
job_cond->job_id = NO_VAL;
for (i=(*start); i<argc; i++) {
end = parse_option_end(argv[i]);
if (!end)
command_len=strlen(argv[i]);
else {
command_len=end-1;
if (argv[i][end] == '=') {
/* option = (int)argv[i][end-1]; */
end++;
}
}
if (!strncasecmp (argv[i], "Set", MAX(command_len, 3))) {
i--;
break;
} else if (!end && !strncasecmp(argv[i], "where",
MAX(command_len, 5))) {
continue;
} else if (!strncasecmp (argv[i], "Cluster",
MAX(command_len, 1))) {
job_cond->cluster = xstrdup(argv[i]+end);
} else if (!strncasecmp (argv[i], "JobID",
MAX(command_len, 1))) {
job_cond->job_id = (uint32_t) strtol(argv[i]+end,
&next_str, 10);
if ((job_cond->job_id == 0) ||
((next_str[0] != '\0') && (next_str[0] != ' '))) {
fprintf(stderr, "Invalid job id %s specified\n",
argv[i]+end);
exit_code = 1;
} else
set = 1;
} else {
exit_code = 1;
fprintf(stderr, " Unknown condition: %s\n"
" Use keyword 'set' to modify value\n",
argv[i]);
}
}
if (!job_cond->cluster)
job_cond->cluster = slurm_get_cluster_name();
(*start) = i;
return set;
}
static int _set_wckey_cond(int *start, int argc, char *argv[],
slurmdb_wckey_cond_t *wckey_cond,
List format_list)
{
int i;
int set = 0;
int end = 0;
int command_len = 0;
int local_cluster_flag = all_clusters_flag;
time_t start_time, end_time;
int option = 0;
if(!wckey_cond) {
error("No wckey_cond given");
return -1;
}
wckey_cond->with_usage = 1;
wckey_cond->with_deleted = 1;
if(!wckey_cond->cluster_list)
wckey_cond->cluster_list = list_create(slurm_destroy_char);
for (i=(*start); i<argc; i++) {
end = parse_option_end(argv[i]);
if(!end)
command_len=strlen(argv[i]);
else {
command_len=end-1;
if(argv[i][end] == '=') {
option = (int)argv[i][end-1];
end++;
}
}
if(!end && !strncasecmp(argv[i], "all_clusters",
MAX(command_len, 1))) {
local_cluster_flag = 1;
} else if(!end && !strncasecmp(argv[i], "withdeleted",
MAX(command_len, 5))) {
wckey_cond->with_deleted = 1;
set = 1;
} else if(!end
|| !strncasecmp (argv[i], "WCKeys",
MAX(command_len, 3))) {
if(!wckey_cond->name_list)
wckey_cond->name_list =
list_create(slurm_destroy_char);
if(slurm_addto_char_list(wckey_cond->name_list,
argv[i]+end))
set = 1;
} else if (!strncasecmp (argv[i], "Clusters",
MAX(command_len, 3))) {
if(!wckey_cond->cluster_list)
wckey_cond->cluster_list =
list_create(slurm_destroy_char);
if(slurm_addto_char_list(wckey_cond->cluster_list,
argv[i]+end))
set = 1;
} else if (!strncasecmp (argv[i], "End", MAX(command_len, 1))) {
wckey_cond->usage_end = parse_time(argv[i]+end, 1);
set = 1;
} else if (!strncasecmp (argv[i], "Format",
MAX(command_len, 1))) {
if(format_list)
slurm_addto_char_list(format_list, argv[i]+end);
} else if (!strncasecmp (argv[i], "Start",
MAX(command_len, 1))) {
wckey_cond->usage_start = parse_time(argv[i]+end, 1);
set = 1;
} else if (!strncasecmp (argv[i], "User",
MAX(command_len, 1))) {
if(!wckey_cond->user_list)
wckey_cond->user_list =
list_create(slurm_destroy_char);
if(slurm_addto_char_list(wckey_cond->user_list,
argv[i]+end))
set = 1;
} else {
exit_code=1;
fprintf(stderr, " Unknown condition: %s\n", argv[i]);
}
}
(*start) = i;
if(!local_cluster_flag && !list_count(wckey_cond->cluster_list)) {
char *temp = slurm_get_cluster_name();
if(temp)
list_append(wckey_cond->cluster_list, temp);
}
/* This needs to be done on some systems to make sure
wckey_cond isn't messed. This has happened on some 64
bit machines and this is here to be on the safe side.
*/
start_time = wckey_cond->usage_start;
end_time = wckey_cond->usage_end;
slurmdb_report_set_start_end_time(&start_time, &end_time);
wckey_cond->usage_start = start_time;
wckey_cond->usage_end = end_time;
return set;
}
static int _set_assoc_cond(int *start, int argc, char *argv[],
slurmdb_association_cond_t *assoc_cond,
List format_list)
{
int i;
int set = 0;
int end = 0;
int local_cluster_flag = all_clusters_flag;
time_t start_time, end_time;
int command_len = 0;
int option = 0;
if(!assoc_cond) {
error("We need an slurmdb_association_cond to call this");
return SLURM_ERROR;
}
assoc_cond->with_usage = 1;
assoc_cond->with_deleted = 1;
if(!assoc_cond->cluster_list)
assoc_cond->cluster_list = list_create(slurm_destroy_char);
for (i=(*start); i<argc; i++) {
end = parse_option_end(argv[i]);
if(!end)
command_len=strlen(argv[i]);
else {
command_len=end-1;
if(argv[i][end] == '=') {
option = (int)argv[i][end-1];
end++;
}
}
if(!end && !strncasecmp(argv[i], "all_clusters",
MAX(command_len, 1))) {
local_cluster_flag = 1;
} else if (!end && !strncasecmp (argv[i], "Tree",
MAX(command_len, 4))) {
tree_display = 1;
} else if(!end
|| !strncasecmp (argv[i], "Users",
MAX(command_len, 1))) {
if(!assoc_cond->user_list)
assoc_cond->user_list =
list_create(slurm_destroy_char);
slurm_addto_char_list(assoc_cond->user_list,
argv[i]+end);
set = 1;
} else if (!strncasecmp (argv[i], "Accounts",
MAX(command_len, 2))
|| !strncasecmp(argv[i], "Acct",
MAX(command_len, 4))) {
if(!assoc_cond->acct_list)
assoc_cond->acct_list =
list_create(slurm_destroy_char);
slurm_addto_char_list(assoc_cond->acct_list,
argv[i]+end);
set = 1;
} else if (!strncasecmp (argv[i], "Clusters",
MAX(command_len, 1))) {
slurm_addto_char_list(assoc_cond->cluster_list,
argv[i]+end);
set = 1;
} else if (!strncasecmp (argv[i], "End", MAX(command_len, 1))) {
assoc_cond->usage_end = parse_time(argv[i]+end, 1);
set = 1;
} else if (!strncasecmp (argv[i], "Format",
MAX(command_len, 1))) {
if(format_list)
slurm_addto_char_list(format_list,
argv[i]+end);
} else if (!strncasecmp (argv[i], "Start",
MAX(command_len, 1))) {
assoc_cond->usage_start = parse_time(argv[i]+end, 1);
set = 1;
} else {
exit_code=1;
fprintf(stderr, " Unknown condition: %s\n"
"Use keyword set to modify value\n", argv[i]);
}
}
(*start) = i;
if(!local_cluster_flag && !list_count(assoc_cond->cluster_list)) {
char *temp = slurm_get_cluster_name();
if(temp)
list_append(assoc_cond->cluster_list, temp);
}
/* This needs to be done on some systems to make sure
assoc_cond isn't messed. This has happened on some 64
bit machines and this is here to be on the safe side.
*/
start_time = assoc_cond->usage_start;
end_time = assoc_cond->usage_end;
slurmdb_report_set_start_end_time(&start_time, &end_time);
assoc_cond->usage_start = start_time;
assoc_cond->usage_end = end_time;
return set;
}
void parse_command_line(int argc, char **argv)
{
extern int optind;
int c, i, optionIndex = 0;
char *end = NULL, *start = NULL, *acct_type = NULL;
slurmdb_selected_step_t *selected_step = NULL;
ListIterator itr = NULL;
struct stat stat_buf;
char *dot = NULL;
bool brief_output = FALSE, long_output = FALSE;
bool all_users = 0;
bool all_clusters = 0;
slurmdb_job_cond_t *job_cond = params.job_cond;
log_options_t opts = LOG_OPTS_STDERR_ONLY ;
int verbosity; /* count of -v options */
bool set;
static struct option long_options[] = {
{"allusers", no_argument, 0, 'a'},
{"accounts", required_argument, 0, 'A'},
{"allocations", no_argument, ¶ms.opt_allocs, OPT_LONG_ALLOCS},
{"brief", no_argument, 0, 'b'},
{"completion", no_argument, ¶ms.opt_completion, 'c'},
{"duplicates", no_argument, ¶ms.opt_dup, OPT_LONG_DUP},
{"helpformat", no_argument, 0, 'e'},
{"help-fields", no_argument, 0, 'e'},
{"endtime", required_argument, 0, 'E'},
{"file", required_argument, 0, 'f'},
{"gid", required_argument, 0, 'g'},
{"group", required_argument, 0, 'g'},
{"help", no_argument, 0, 'h'},
{"helpformat", no_argument, ¶ms.opt_help, OPT_LONG_HELP},
{"name", required_argument, 0, OPT_LONG_NAME},
{"nnodes", required_argument, 0, 'i'},
{"ncpus", required_argument, 0, 'I'},
{"jobs", required_argument, 0, 'j'},
{"timelimit-min", required_argument, 0, 'k'},
{"timelimit-max", required_argument, 0, 'K'},
{"long", no_argument, 0, 'l'},
{"allclusters", no_argument, 0, 'L'},
{"cluster", required_argument, 0, 'M'},
{"clusters", required_argument, 0, 'M'},
{"nodelist", required_argument, 0, 'N'},
{"noheader", no_argument, 0, 'n'},
{"fields", required_argument, 0, 'o'},
{"format", required_argument, 0, 'o'},
{"parsable", no_argument, 0, 'p'},
{"parsable2", no_argument, 0, 'P'},
{"qos", required_argument, 0, 'q'},
{"partition", required_argument, 0, 'r'},
{"state", required_argument, 0, 's'},
{"starttime", required_argument, 0, 'S'},
{"truncate", no_argument, 0, 'T'},
{"uid", required_argument, 0, 'u'},
{"usage", no_argument, ¶ms.opt_help, OPT_LONG_USAGE},
{"user", required_argument, 0, 'u'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"wckeys", required_argument, 0, 'W'},
{"associations", required_argument, 0, 'x'},
{0, 0, 0, 0}};
params.opt_uid = getuid();
params.opt_gid = getgid();
verbosity = 0;
log_init("sacct", opts, SYSLOG_FACILITY_DAEMON, NULL);
opterr = 1; /* Let getopt report problems to the user */
while (1) { /* now cycle through the command line */
c = getopt_long(argc, argv,
"aA:bcC:dDeE:f:g:hi:I:j:k:K:lLM:nN:o:OpPq:r:s:S:Ttu:vVW:x:X",
long_options, &optionIndex);
if (c == -1)
break;
switch (c) {
case 'a':
all_users = 1;
break;
case 'A':
if(!job_cond->acct_list)
job_cond->acct_list =
list_create(slurm_destroy_char);
slurm_addto_char_list(job_cond->acct_list, optarg);
break;
case 'b':
brief_output = true;
break;
case 'c':
params.opt_completion = 1;
break;
case 'C':
/* 'C' is deprecated since 'M' is cluster on
everything else.
*/
case 'M':
if(!strcasecmp(optarg, "-1")) {
all_clusters = 1;
break;
}
all_clusters=0;
if(!job_cond->cluster_list)
job_cond->cluster_list =
list_create(slurm_destroy_char);
slurm_addto_char_list(job_cond->cluster_list, optarg);
break;
case 'D':
params.opt_dup = 1;
break;
case 'e':
params.opt_help = 2;
break;
case 'E':
job_cond->usage_end = parse_time(optarg, 1);
if (errno == ESLURM_INVALID_TIME_VALUE)
exit(1);
break;
case 'f':
xfree(params.opt_filein);
params.opt_filein = xstrdup(optarg);
break;
case 'g':
if(!job_cond->groupid_list)
job_cond->groupid_list =
list_create(slurm_destroy_char);
_addto_id_char_list(job_cond->groupid_list, optarg, 1);
break;
case 'h':
params.opt_help = 1;
break;
case 'i':
set = get_resource_arg_range(
optarg,
"requested node range",
(int *)&job_cond->nodes_min,
(int *)&job_cond->nodes_max,
true);
if (set == false) {
error("invalid node range -i '%s'",
optarg);
exit(1);
}
break;
case 'I':
set = get_resource_arg_range(
optarg,
"requested cpu range",
(int *)&job_cond->cpus_min,
(int *)&job_cond->cpus_max,
true);
if (set == false) {
error("invalid cpu range -i '%s'",
optarg);
exit(1);
}
break;
case 'j':
if ((strspn(optarg, "0123456789, ") < strlen(optarg))
&& (strspn(optarg, ".batch0123456789, ")
< strlen(optarg))) {
fprintf(stderr, "Invalid jobs list: %s\n",
optarg);
exit(1);
}
if(!job_cond->step_list)
job_cond->step_list = list_create(
slurmdb_destroy_selected_step);
_addto_step_list(job_cond->step_list, optarg);
break;
case 'k':
job_cond->timelimit_min = time_str2mins(optarg);
if (((int32_t)job_cond->timelimit_min <= 0)
&& (job_cond->timelimit_min != INFINITE))
fatal("Invalid time limit specification");
break;
case 'K':
job_cond->timelimit_max = time_str2mins(optarg);
if (((int32_t)job_cond->timelimit_max <= 0)
&& (job_cond->timelimit_max != INFINITE))
fatal("Invalid time limit specification");
break;
case 'L':
all_clusters = 1;
break;
case 'l':
long_output = true;
break;
case 'n':
print_fields_have_header = 0;
break;
case 'N':
if(job_cond->used_nodes) {
error("Aleady asked for nodes '%s'",
job_cond->used_nodes);
break;
}
job_cond->used_nodes = xstrdup(optarg);
break;
case OPT_LONG_NAME:
if(!job_cond->jobname_list)
job_cond->jobname_list =
list_create(slurm_destroy_char);
slurm_addto_char_list(job_cond->jobname_list, optarg);
break;
case 'o':
xstrfmtcat(params.opt_field_list, "%s,", optarg);
break;
case 'p':
print_fields_parsable_print =
PRINT_FIELDS_PARSABLE_ENDING;
break;
case 'P':
print_fields_parsable_print =
PRINT_FIELDS_PARSABLE_NO_ENDING;
break;
case 'q':
if (!g_qos_list) {
slurmdb_qos_cond_t qos_cond;
memset(&qos_cond, 0,
sizeof(slurmdb_qos_cond_t));
qos_cond.with_deleted = 1;
g_qos_list = slurmdb_qos_get(
acct_db_conn, &qos_cond);
}
if(!job_cond->qos_list)
job_cond->qos_list =
list_create(slurm_destroy_char);
if(!slurmdb_addto_qos_char_list(job_cond->qos_list,
g_qos_list, optarg, 0))
fatal("problem processing qos list");
break;
case 'r':
if(!job_cond->partition_list)
job_cond->partition_list =
list_create(slurm_destroy_char);
slurm_addto_char_list(job_cond->partition_list,
optarg);
break;
case 's':
if(!job_cond->state_list)
job_cond->state_list =
list_create(slurm_destroy_char);
_addto_state_char_list(job_cond->state_list, optarg);
break;
case 'S':
job_cond->usage_start = parse_time(optarg, 1);
if (errno == ESLURM_INVALID_TIME_VALUE)
exit(1);
break;
case 'T':
job_cond->without_usage_truncation = 0;
break;
case 'U':
params.opt_help = 3;
break;
case 'u':
if(!strcmp(optarg, "-1")) {
all_users = 1;
break;
}
all_users = 0;
if(!job_cond->userid_list)
job_cond->userid_list =
list_create(slurm_destroy_char);
_addto_id_char_list(job_cond->userid_list, optarg, 0);
break;
case 'v':
/* Handle -vvv thusly...
*/
verbosity++;
break;
case 'W':
if(!job_cond->wckey_list)
job_cond->wckey_list =
list_create(slurm_destroy_char);
slurm_addto_char_list(job_cond->wckey_list, optarg);
break;
case 'V':
print_slurm_version();
exit(0);
case 'x':
if(!job_cond->associd_list)
job_cond->associd_list =
list_create(slurm_destroy_char);
slurm_addto_char_list(job_cond->associd_list, optarg);
break;
case 't':
case 'X':
params.opt_allocs = 1;
break;
case ':':
case '?': /* getopt() has explained it */
exit(1);
}
}
if (verbosity) {
opts.stderr_level += verbosity;
opts.prefix_level = 1;
log_alter(opts, 0, NULL);
}
/* Now set params.opt_dup, unless they've already done so */
if (params.opt_dup < 0) /* not already set explicitly */
params.opt_dup = 0;
job_cond->duplicates = params.opt_dup;
job_cond->without_steps = params.opt_allocs;
if(!job_cond->usage_start && !job_cond->step_list) {
struct tm start_tm;
job_cond->usage_start = time(NULL);
if (!localtime_r(&job_cond->usage_start, &start_tm)) {
error("Couldn't get localtime from %ld",
(long)job_cond->usage_start);
return;
}
start_tm.tm_sec = 0;
start_tm.tm_min = 0;
start_tm.tm_hour = 0;
start_tm.tm_isdst = -1;
job_cond->usage_start = mktime(&start_tm);
}
if(verbosity > 0) {
char *start_char =NULL, *end_char = NULL;
start_char = xstrdup(ctime(&job_cond->usage_start));
/* remove the new line */
start_char[strlen(start_char)-1] = '\0';
if(job_cond->usage_end) {
end_char = xstrdup(ctime(&job_cond->usage_end));
/* remove the new line */
end_char[strlen(end_char)-1] = '\0';
} else
end_char = xstrdup("Now");
info("Jobs eligible from %s - %s", start_char, end_char);
xfree(start_char);
xfree(end_char);
}
debug("Options selected:\n"
"\topt_completion=%d\n"
"\topt_dup=%d\n"
"\topt_field_list=%s\n"
"\topt_help=%d\n"
"\topt_allocs=%d",
params.opt_completion,
params.opt_dup,
params.opt_field_list,
params.opt_help,
params.opt_allocs);
if(params.opt_completion) {
g_slurm_jobcomp_init(params.opt_filein);
acct_type = slurm_get_jobcomp_type();
if ((strcmp(acct_type, "jobcomp/none") == 0)
&& (stat(params.opt_filein, &stat_buf) != 0)) {
fprintf(stderr, "SLURM job completion is disabled\n");
exit(1);
}
xfree(acct_type);
} else {
slurm_acct_storage_init(params.opt_filein);
acct_type = slurm_get_accounting_storage_type();
if ((strcmp(acct_type, "accounting_storage/none") == 0)
&& (stat(params.opt_filein, &stat_buf) != 0)) {
fprintf(stderr,
"SLURM accounting storage is disabled\n");
exit(1);
}
xfree(acct_type);
acct_db_conn = slurmdb_connection_get();
if(errno != SLURM_SUCCESS) {
error("Problem talking to the database: %m");
exit(1);
}
}
/* specific clusters requested? */
if(all_clusters) {
if(job_cond->cluster_list
&& list_count(job_cond->cluster_list)) {
list_destroy(job_cond->cluster_list);
job_cond->cluster_list = NULL;
}
debug2("Clusters requested:\tall");
} else if (job_cond->cluster_list
&& list_count(job_cond->cluster_list)) {
debug2( "Clusters requested:");
itr = list_iterator_create(job_cond->cluster_list);
while((start = list_next(itr)))
debug2("\t: %s", start);
list_iterator_destroy(itr);
} else if(!job_cond->cluster_list
|| !list_count(job_cond->cluster_list)) {
if(!job_cond->cluster_list)
job_cond->cluster_list =
list_create(slurm_destroy_char);
if((start = slurm_get_cluster_name())) {
list_append(job_cond->cluster_list, start);
debug2("Clusters requested:\t%s", start);
}
}
/* if any jobs or nodes are specified set to look for all users if none
are set */
if(!job_cond->userid_list || !list_count(job_cond->userid_list))
if((job_cond->step_list && list_count(job_cond->step_list))
|| job_cond->used_nodes)
all_users=1;
/* set all_users for user root if not requesting any */
if(!job_cond->userid_list && !params.opt_uid)
all_users = 1;
if(all_users) {
if(job_cond->userid_list && list_count(job_cond->userid_list)) {
list_destroy(job_cond->userid_list);
job_cond->userid_list = NULL;
}
debug2("Userids requested:\tall");
} else if (job_cond->userid_list && list_count(job_cond->userid_list)) {
debug2("Userids requested:");
itr = list_iterator_create(job_cond->userid_list);
while((start = list_next(itr)))
debug2("\t: %s", start);
list_iterator_destroy(itr);
} else if(!job_cond->userid_list
|| !list_count(job_cond->userid_list)) {
if(!job_cond->userid_list)
job_cond->userid_list = list_create(slurm_destroy_char);
start = xstrdup_printf("%u", params.opt_uid);
list_append(job_cond->userid_list, start);
debug2("Userid requested\t: %s", start);
}
if (job_cond->groupid_list && list_count(job_cond->groupid_list)) {
debug2("Groupids requested:");
itr = list_iterator_create(job_cond->groupid_list);
while((start = list_next(itr)))
debug2("\t: %s", start);
list_iterator_destroy(itr);
}
/* specific partitions requested? */
if (job_cond->partition_list && list_count(job_cond->partition_list)) {
debug2("Partitions requested:");
itr = list_iterator_create(job_cond->partition_list);
while((start = list_next(itr)))
debug2("\t: %s", start);
list_iterator_destroy(itr);
}
/* specific qos' requested? */
if (job_cond->qos_list && list_count(job_cond->qos_list)) {
start = get_qos_complete_str(g_qos_list, job_cond->qos_list);
debug2("QOS requested\t: %s\n", start);
xfree(start);
}
/* specific jobs requested? */
if (job_cond->step_list && list_count(job_cond->step_list)) {
debug2("Jobs requested:");
itr = list_iterator_create(job_cond->step_list);
while((selected_step = list_next(itr))) {
if(selected_step->stepid != NO_VAL)
debug2("\t: %d.%d",
selected_step->jobid,
selected_step->stepid);
else
debug2("\t: %d",
selected_step->jobid);
}
list_iterator_destroy(itr);
}
/* specific states (completion state) requested? */
if (job_cond->state_list && list_count(job_cond->state_list)) {
debug2("States requested:");
itr = list_iterator_create(job_cond->state_list);
while((start = list_next(itr))) {
debug2("\t: %s",
job_state_string(atoi(start)));
}
list_iterator_destroy(itr);
}
if (job_cond->wckey_list && list_count(job_cond->wckey_list)) {
debug2("Wckeys requested:");
itr = list_iterator_create(job_cond->wckey_list);
while((start = list_next(itr)))
debug2("\t: %s\n", start);
list_iterator_destroy(itr);
}
if (job_cond->timelimit_min) {
char time_str[128], tmp1[32], tmp2[32];
mins2time_str(job_cond->timelimit_min, tmp1, sizeof(tmp1));
sprintf(time_str, "%s", tmp1);
if(job_cond->timelimit_max) {
int len = strlen(tmp1);
mins2time_str(job_cond->timelimit_max,
tmp2, sizeof(tmp2));
sprintf(time_str+len, " - %s", tmp2);
}
debug2("Timelimit requested\t: %s", time_str);
}
/* specific jobnames requested? */
if (job_cond->jobname_list && list_count(job_cond->jobname_list)) {
debug2("Jobnames requested:");
itr = list_iterator_create(job_cond->jobname_list);
while((start = list_next(itr))) {
debug2("\t: %s", start);
}
list_iterator_destroy(itr);
}
/* select the output fields */
if(brief_output) {
if(params.opt_completion)
dot = BRIEF_COMP_FIELDS;
else
dot = BRIEF_FIELDS;
xstrfmtcat(params.opt_field_list, "%s,", dot);
}
if(long_output) {
if(params.opt_completion)
dot = LONG_COMP_FIELDS;
else
dot = LONG_FIELDS;
xstrfmtcat(params.opt_field_list, "%s,", dot);
}
if (params.opt_field_list==NULL) {
if(params.opt_completion)
dot = DEFAULT_COMP_FIELDS;
else
dot = DEFAULT_FIELDS;
xstrfmtcat(params.opt_field_list, "%s,", dot);
}
start = params.opt_field_list;
while ((end = strstr(start, ","))) {
char *tmp_char = NULL;
int command_len = 0;
int newlen = 0;
*end = 0;
while (isspace(*start))
start++; /* discard whitespace */
if(!(int)*start)
continue;
if((tmp_char = strstr(start, "\%"))) {
newlen = atoi(tmp_char+1);
tmp_char[0] = '\0';
}
command_len = strlen(start);
for (i = 0; fields[i].name; i++) {
if (!strncasecmp(fields[i].name, start, command_len))
goto foundfield;
}
error("Invalid field requested: \"%s\"", start);
exit(1);
foundfield:
if(newlen)
fields[i].len = newlen;
list_append(print_fields_list, &fields[i]);
start = end + 1;
}
/* Open a connection to the Slurm DBD and set slurmdbd_conn */
static void _open_slurmdbd_conn(bool need_db)
{
bool try_backup = true;
int rc;
if (slurmdbd_conn && slurmdbd_conn->fd >= 0) {
debug("Attempt to re-open slurmdbd socket");
/* clear errno (checked after this for errors) */
errno = 0;
return;
}
slurm_persist_conn_close(slurmdbd_conn);
if (!slurmdbd_conn) {
slurmdbd_conn = xmalloc(sizeof(slurm_persist_conn_t));
slurmdbd_conn->flags =
PERSIST_FLAG_DBD | PERSIST_FLAG_RECONNECT;
slurmdbd_conn->persist_type = PERSIST_TYPE_DBD;
if (!slurmdbd_cluster)
slurmdbd_cluster = slurm_get_cluster_name();
slurmdbd_conn->cluster_name = xstrdup(slurmdbd_cluster);
slurmdbd_conn->timeout = (slurm_get_msg_timeout() + 35) * 1000;
slurmdbd_conn->rem_port = slurm_get_accounting_storage_port();
if (!slurmdbd_conn->rem_port) {
slurmdbd_conn->rem_port = SLURMDBD_PORT;
slurm_set_accounting_storage_port(
slurmdbd_conn->rem_port);
}
}
slurmdbd_shutdown = 0;
slurmdbd_conn->shutdown = &slurmdbd_shutdown;
slurmdbd_conn->version = SLURM_PROTOCOL_VERSION;
xfree(slurmdbd_conn->rem_host);
slurmdbd_conn->rem_host = slurm_get_accounting_storage_host();
if (!slurmdbd_conn->rem_host) {
slurmdbd_conn->rem_host = xstrdup(DEFAULT_STORAGE_HOST);
slurm_set_accounting_storage_host(
slurmdbd_conn->rem_host);
}
again:
if (((rc = slurm_persist_conn_open(slurmdbd_conn)) != SLURM_SUCCESS) &&
try_backup) {
xfree(slurmdbd_conn->rem_host);
try_backup = false;
if ((slurmdbd_conn->rem_host =
slurm_get_accounting_storage_backup_host()))
goto again;
}
if (rc == SLURM_SUCCESS) {
/* set the timeout to the timeout to be used for all other
* messages */
slurmdbd_conn->timeout = SLURMDBD_TIMEOUT * 1000;
if (slurmdbd_conn->trigger_callbacks.dbd_resumed)
(slurmdbd_conn->trigger_callbacks.dbd_resumed)();
if (slurmdbd_conn->trigger_callbacks.db_resumed)
(slurmdbd_conn->trigger_callbacks.db_resumed)();
}
if ((!need_db && (rc == ESLURM_DB_CONNECTION)) ||
(rc == SLURM_SUCCESS)) {
debug("slurmdbd: Sent PersistInit msg");
/* clear errno (checked after this for
errors)
*/
errno = 0;
} else {
if ((rc == ESLURM_DB_CONNECTION) &&
slurmdbd_conn->trigger_callbacks.db_fail)
(slurmdbd_conn->trigger_callbacks.db_fail)();
error("slurmdbd: Sending PersistInit msg: %m");
slurm_persist_conn_close(slurmdbd_conn);
}
}
/* sacctmgr_list_reservation()
*/
int sacctmgr_list_reservation(int argc, char **argv)
{
List reservation_list;
ListIterator itr;
ListIterator itr2;
List format_list;
List print_fields_list;
slurmdb_reservation_cond_t *reservation_cond =
xmalloc(sizeof(slurmdb_reservation_cond_t));
slurmdb_reservation_rec_t *reservation;
int field_count, i;
print_field_t *field;
char *tmp_char;
/* If we don't have any arguments make sure we set up the
* time correctly for just the past day. */
if (argc == 0) {
struct tm start_tm;
reservation_cond->time_start = time(NULL);
if (!slurm_localtime_r(&reservation_cond->time_start,
&start_tm)) {
fprintf(stderr,
" Couldn't get localtime from %ld",
(long)reservation_cond->time_start);
slurmdb_destroy_reservation_cond(reservation_cond);
exit_code = 1;
return 0;
}
start_tm.tm_sec = 0;
start_tm.tm_min = 0;
start_tm.tm_hour = 0;
start_tm.tm_mday--;
reservation_cond->time_start = slurm_mktime(&start_tm);
}
format_list = list_create(slurm_destroy_char);
for (i=0; i<argc; i++) {
int command_len = strlen(argv[i]);
if (!xstrncasecmp(argv[i], "Where", MAX(command_len, 5))
|| !xstrncasecmp(argv[i], "Set", MAX(command_len, 3)))
i++;
_set_cond(&i, argc, argv, reservation_cond, format_list);
}
if (reservation_cond->nodes && !reservation_cond->cluster_list) {
char *cluster_name = slurm_get_cluster_name();
char *warning = xstrdup_printf(
"If requesting nodes you must also request the cluster.\nWould you like to use the local cluster of '%s'?",
cluster_name);
if (!commit_check(warning)) {
exit_code = 1;
} else {
reservation_cond->cluster_list =
list_create(slurm_destroy_char);
list_append(reservation_cond->cluster_list,
cluster_name);
cluster_name = NULL;
}
xfree(warning);
xfree(cluster_name);
}
if (exit_code) {
slurmdb_destroy_reservation_cond(reservation_cond);
FREE_NULL_LIST(format_list);
return SLURM_ERROR;
}
if (!list_count(format_list)) {
/* Append to the format list the fields
* we want to print, these are the data structure
* members of the type returned by slurmdbd
*/
slurm_addto_char_list(format_list,
"Cluster,Name%15,TRES%30,"
"TimeStart,TimeEnd,Unused");
}
reservation_list = slurmdb_reservations_get(
db_conn, reservation_cond);
slurmdb_destroy_reservation_cond(reservation_cond);
if (!reservation_list) {
exit_code=1;
fprintf(stderr, " Problem with query.\n");
FREE_NULL_LIST(format_list);
return SLURM_ERROR;
}
/* Process the format list creating a list of
* print field_t structures
*/
print_fields_list = sacctmgr_process_format_list(format_list);
FREE_NULL_LIST(format_list);
itr = list_iterator_create(reservation_list);
itr2 = list_iterator_create(print_fields_list);
print_fields_header(print_fields_list);
field_count = list_count(print_fields_list);
/* For each reservation prints the data structure members
*/
while ((reservation = list_next(itr))) {
while ((field = list_next(itr2))) {
switch (field->type) {
case PRINT_ASSOC_NAME:
field->print_routine(
field,
reservation->assocs,
field_count);
break;
case PRINT_CLUSTER:
field->print_routine(
field,
reservation->cluster,
field_count);
break;
case PRINT_FLAGS:
tmp_char = reservation_flags_string(
reservation->flags);
field->print_routine(
field,
tmp_char,
field_count);
xfree(tmp_char);
break;
case PRINT_ID:
field->print_routine(field,
reservation->id,
field_count);
break;
case PRINT_NAME:
field->print_routine(field,
reservation->name,
field_count);
break;
case PRINT_NODENAME:
field->print_routine(
field,
reservation->nodes,
field_count);
break;
case PRINT_NODEINX:
field->print_routine(
field,
reservation->node_inx,
field_count);
break;
case PRINT_TIMEEND:
field->print_routine(
field,
reservation->time_end,
field_count);
break;
case PRINT_TIMESTART:
field->print_routine(
field,
reservation->time_start,
field_count);
break;
case PRINT_TRES:
sacctmgr_initialize_g_tres_list();
tmp_char = slurmdb_make_tres_string_from_simple(
reservation->tres_str, g_tres_list,
NO_VAL, CONVERT_NUM_UNIT_EXACT,
0, NULL);
field->print_routine(field,
tmp_char,
field_count);
xfree(tmp_char);
break;
case PRINT_UNUSED:
field->print_routine(
field,
reservation->unused_wall,
field_count);
break;
}
}
list_iterator_reset(itr2);
printf("\n");
}
list_iterator_destroy(itr);
list_iterator_destroy(itr2);
FREE_NULL_LIST(reservation_list);
FREE_NULL_LIST(print_fields_list);
return 0;
}
void get_command(void)
{
char com[255];
int text_width, text_startx;
allocated_block_t *allocated_block = NULL;
int i = 0;
int count = 0;
WINDOW *command_win = NULL;
List allocated_blocks = NULL;
ListIterator results_i;
if (params.commandline && !params.command) {
printf("Configure won't work with commandline mode.\n");
printf("Please remove the -c from the commandline.\n");
bg_configure_ba_fini();
exit(0);
}
if (working_cluster_rec) {
char *cluster_name = slurm_get_cluster_name();
if (strcmp(working_cluster_rec->name, cluster_name)) {
xfree(cluster_name);
endwin();
printf("To use the configure option you must be on the "
"cluster the configure is for.\nCross cluster "
"support doesn't exist today.\nSorry for the "
"inconvenince.\n");
bg_configure_ba_fini();
exit(0);
}
xfree(cluster_name);
}
/* make sure we don't get any noisy debug */
ba_configure_set_ba_debug_flags(0);
bg_configure_ba_setup_wires();
color_count = 0;
allocated_blocks = list_create(_destroy_allocated_block);
if (params.commandline) {
snprintf(com, sizeof(com), "%s", params.command);
goto run_command;
} else {
text_width = text_win->_maxx;
text_startx = text_win->_begx;
command_win = newwin(3, text_width - 1, LINES - 4,
text_startx + 1);
curs_set(1);
echo();
}
while (strcmp(com, "quit")) {
clear_window(grid_win);
print_grid();
clear_window(text_win);
box(text_win, 0, 0);
box(grid_win, 0, 0);
if (!params.no_header)
_print_header_command();
if (error_string != NULL) {
i = 0;
while (error_string[i] != '\0') {
if (error_string[i] == '\n') {
main_ycord++;
main_xcord=1;
i++;
}
mvwprintw(text_win,
main_ycord,
main_xcord,
"%c",
error_string[i++]);
main_xcord++;
}
main_ycord++;
main_xcord = 1;
memset(error_string, 0, 255);
}
results_i = list_iterator_create(allocated_blocks);
count = list_count(allocated_blocks)
- (LINES-(main_ycord+5));
if (count<0)
count=0;
i=0;
while ((allocated_block = list_next(results_i)) != NULL) {
if (i >= count)
_print_text_command(allocated_block);
i++;
}
list_iterator_destroy(results_i);
wnoutrefresh(text_win);
wnoutrefresh(grid_win);
doupdate();
clear_window(command_win);
box(command_win, 0, 0);
mvwprintw(command_win, 0, 3,
"Input Command: (type quit to change view, "
"exit to exit)");
wmove(command_win, 1, 1);
wgetstr(command_win, com);
if (!strcmp(com, "exit")) {
endwin();
if (allocated_blocks)
list_destroy(allocated_blocks);
bg_configure_ba_fini();
exit(0);
}
run_command:
if (!strcmp(com, "quit") || !strcmp(com, "\\q")) {
break;
} else if (!strncasecmp(com, "layout", 6)) {
_set_layout(com);
} else if (!strncasecmp(com, "basepartition", 13)) {
_set_base_part_cnt(com);
} else if (!strncasecmp(com, "nodecard", 8)) {
_set_nodecard_cnt(com);
} else if (!strncasecmp(com, "resolve", 7) ||
!strncasecmp(com, "r ", 2)) {
_resolve(com);
} else if (!strncasecmp(com, "resume", 6)) {
mvwprintw(text_win,
main_ycord,
main_xcord, "%s", com);
} else if (!strncasecmp(com, "drain", 5)) {
mvwprintw(text_win,
main_ycord,
main_xcord, "%s", com);
} else if (!strncasecmp(com, "alldown", 7)) {
_change_state_all_bps(com, NODE_STATE_DOWN);
} else if (!strncasecmp(com, "down", 4)) {
_change_state_bps(com, NODE_STATE_DOWN);
} else if (!strncasecmp(com, "allup", 5)) {
_change_state_all_bps(com, NODE_STATE_IDLE);
} else if (!strncasecmp(com, "up", 2)) {
_change_state_bps(com, NODE_STATE_IDLE);
} else if (!strncasecmp(com, "remove", 6)
|| !strncasecmp(com, "delete", 6)
|| !strncasecmp(com, "drop", 4)) {
_remove_allocation(com, allocated_blocks);
} else if (!strncasecmp(com, "create", 6)) {
_create_allocation(com, allocated_blocks);
} else if (!strncasecmp(com, "copy", 4)
|| !strncasecmp(com, "c ", 2)
|| !strncasecmp(com, "c\0", 2)) {
_copy_allocation(com, allocated_blocks);
} else if (!strncasecmp(com, "save", 4)) {
_save_allocation(com, allocated_blocks);
} else if (!strncasecmp(com, "load", 4)) {
_load_configuration(com, allocated_blocks);
} else if (!strncasecmp(com, "clear all", 9)
|| !strncasecmp(com, "clear", 5)) {
list_flush(allocated_blocks);
} else {
memset(error_string, 0, 255);
sprintf(error_string, "Unknown command '%s'",com);
}
if (params.commandline) {
bg_configure_ba_fini();
exit(1);
}
}
if (allocated_blocks)
list_destroy(allocated_blocks);
params.display = 0;
noecho();
clear_window(text_win);
main_xcord = 1;
main_ycord = 1;
curs_set(0);
print_date();
get_job();
return;
}
/* Open a connection to the Slurm DBD and set slurmdbd_conn */
static void _open_slurmdbd_conn(bool need_db)
{
char *backup_host = NULL;
int rc;
if (slurmdbd_conn && slurmdbd_conn->fd >= 0) {
debug("Attempt to re-open slurmdbd socket");
/* clear errno (checked after this for errors) */
errno = 0;
return;
}
slurm_persist_conn_close(slurmdbd_conn);
if (!slurmdbd_conn) {
slurmdbd_conn = xmalloc(sizeof(slurm_persist_conn_t));
slurmdbd_conn->flags =
PERSIST_FLAG_DBD | PERSIST_FLAG_RECONNECT;
slurmdbd_conn->persist_type = PERSIST_TYPE_DBD;
if (!slurmdbd_cluster)
slurmdbd_cluster = slurm_get_cluster_name();
slurmdbd_conn->cluster_name = xstrdup(slurmdbd_cluster);
slurmdbd_conn->timeout = (slurm_get_msg_timeout() + 35) * 1000;
slurmdbd_conn->rem_port = slurm_get_accounting_storage_port();
if (!slurmdbd_conn->rem_port) {
slurmdbd_conn->rem_port = SLURMDBD_PORT;
slurm_set_accounting_storage_port(
slurmdbd_conn->rem_port);
}
}
slurmdbd_shutdown = 0;
slurmdbd_conn->shutdown = &slurmdbd_shutdown;
slurmdbd_conn->version = SLURM_PROTOCOL_VERSION;
xfree(slurmdbd_conn->rem_host);
slurmdbd_conn->rem_host = slurm_get_accounting_storage_host();
if (!slurmdbd_conn->rem_host) {
slurmdbd_conn->rem_host = xstrdup(DEFAULT_STORAGE_HOST);
slurm_set_accounting_storage_host(
slurmdbd_conn->rem_host);
}
// See if a backup slurmdbd is configured
backup_host = slurm_get_accounting_storage_backup_host();
again:
// A connection failure is only an error if backup dne or also fails
if (backup_host)
slurmdbd_conn->flags |= PERSIST_FLAG_SUPPRESS_ERR;
else
slurmdbd_conn->flags &= (~PERSIST_FLAG_SUPPRESS_ERR);
if (((rc = slurm_persist_conn_open(slurmdbd_conn)) != SLURM_SUCCESS) &&
backup_host) {
xfree(slurmdbd_conn->rem_host);
// Force the next error to display
slurmdbd_conn->comm_fail_time = 0;
slurmdbd_conn->rem_host = backup_host;
backup_host = NULL;
goto again;
}
xfree(backup_host);
if (rc == SLURM_SUCCESS) {
/* set the timeout to the timeout to be used for all other
* messages */
slurmdbd_conn->timeout = SLURMDBD_TIMEOUT * 1000;
if (slurmdbd_conn->trigger_callbacks.dbd_resumed)
(slurmdbd_conn->trigger_callbacks.dbd_resumed)();
if (slurmdbd_conn->trigger_callbacks.db_resumed)
(slurmdbd_conn->trigger_callbacks.db_resumed)();
}
if ((!need_db && (rc == ESLURM_DB_CONNECTION)) ||
(rc == SLURM_SUCCESS)) {
debug("slurmdbd: Sent PersistInit msg");
/* clear errno (checked after this for
errors)
*/
errno = 0;
} else {
if ((rc == ESLURM_DB_CONNECTION) &&
slurmdbd_conn->trigger_callbacks.db_fail)
(slurmdbd_conn->trigger_callbacks.db_fail)();
error("slurmdbd: Sending PersistInit msg: %m");
slurm_persist_conn_close(slurmdbd_conn);
}
}
