static int _nodes_in_list(char *node_list)
{
hostset_t host_set = hostset_create(node_list);
int count = hostset_count(host_set);
hostset_destroy(host_set);
return count;
}
/* Convert an array of task IDs into a list of host names
* RET: the string, caller must xfree() this value */
static char *_task_ids_to_host_list(int ntasks, uint32_t taskids[])
{
int i;
hostset_t hs;
char *hosts;
slurm_step_layout_t *sl;
if ((sl = launch_common_get_slurm_step_layout(local_srun_job)) == NULL)
return (xstrdup("Unknown"));
hs = hostset_create(NULL);
for (i = 0; i < ntasks; i++) {
char *host = slurm_step_layout_host_name(sl, taskids[i]);
if (host) {
hostset_insert(hs, host);
free(host);
} else {
error("Could not identify host name for task %u",
taskids[i]);
}
}
hosts = _hostset_to_string(hs);
hostset_destroy(hs);
return (hosts);
}
/*
* scontrol_print_topo - print the switch topology above the specified node
* IN node_name - NULL to print all topology information
*/
extern void scontrol_print_topo (char *node_list)
{
static topo_info_response_msg_t *topo_info_msg = NULL;
int i, match, match_cnt = 0;
hostset_t hs;
if ((topo_info_msg == NULL) &&
slurm_load_topo(&topo_info_msg)) {
slurm_perror ("slurm_load_topo error");
return;
}
if ((node_list == NULL) || (node_list[0] == '\0')) {
slurm_print_topo_info_msg(stdout, topo_info_msg, one_liner);
return;
}
/* Search for matching switch name */
for (i=0; i<topo_info_msg->record_count; i++) {
if (strcmp(topo_info_msg->topo_array[i].name, node_list))
continue;
slurm_print_topo_record(stdout, &topo_info_msg->topo_array[i],
one_liner);
return;
}
/* Search for matching node name */
for (i=0; i<topo_info_msg->record_count; i++) {
if ((topo_info_msg->topo_array[i].nodes == NULL) ||
(topo_info_msg->topo_array[i].nodes[0] == '\0'))
continue;
hs = hostset_create(topo_info_msg->topo_array[i].nodes);
if (hs == NULL)
fatal("hostset_create: memory allocation failure");
match = hostset_within(hs, node_list);
hostset_destroy(hs);
if (!match)
continue;
match_cnt++;
slurm_print_topo_record(stdout, &topo_info_msg->topo_array[i],
one_liner);
}
if (match_cnt == 0) {
error("Topology information contains no switch or "
"node named %s", node_list);
}
}
/* Convert an array of task IDs into a list of host names
* RET: the string, caller must xfree() this value */
static char *_task_ids_to_host_list(int ntasks, uint32_t *taskids)
{
int i, task_cnt = 0;
hostset_t hs;
char *hosts;
slurm_step_layout_t *sl;
if ((sl = launch_common_get_slurm_step_layout(local_srun_job)) == NULL)
return (xstrdup("Unknown"));
/* If overhead of determining the hostlist is too high then srun
* communications will timeout and fail, so return "Unknown" instead.
*
* See slurm_step_layout_host_id() in src/common/slurm_step_layout.c
* for details. */
for (i = 0; i < sl->node_cnt; i++) {
task_cnt += sl->tasks[i];
}
if (task_cnt > 100000)
return (xstrdup("Unknown"));
hs = hostset_create(NULL);
for (i = 0; i < ntasks; i++) {
char *host = slurm_step_layout_host_name(sl, taskids[i]);
if (host) {
hostset_insert(hs, host);
free(host);
} else {
error("Could not identify host name for task %u",
taskids[i]);
}
}
hosts = _hostset_to_string(hs);
hostset_destroy(hs);
return (hosts);
}
/*
* Parse a multi-prog input file line
* line IN - line to parse
* command_pos IN/OUT - where in opt_local->argv we are
* count IN - which command we are on
* return 0 if empty line, 1 if added
*/
static int _parse_prog_line(char *in_line, int *command_pos, int count,
opt_t *opt_local)
{
int i, cmd_inx;
int first_task_inx, last_task_inx;
hostset_t hs = NULL;
char *tmp_str = NULL;
xassert(opt_local->ntasks);
/* Get the task ID string */
for (i = 0; in_line[i]; i++)
if (!isspace(in_line[i]))
break;
if (!in_line[i]) /* empty line */
return 0;
else if (in_line[i] == '#')
return 0;
else if (!isdigit(in_line[i]))
goto bad_line;
first_task_inx = i;
for (i++; in_line[i]; i++) {
if (isspace(in_line[i]))
break;
}
if (!isspace(in_line[i]))
goto bad_line;
last_task_inx = i;
/* Now transfer data to the function arguments */
in_line[last_task_inx] = '\0';
xstrfmtcat(tmp_str, "[%s]", in_line + first_task_inx);
hs = hostset_create(tmp_str);
xfree(tmp_str);
in_line[last_task_inx] = ' ';
if (!hs)
goto bad_line;
if (count) {
opt_local->argc += 1;
xrealloc(opt_local->argv, opt_local->argc * sizeof(char *));
opt_local->argv[(*command_pos)++] = xstrdup(":");
}
opt_local->argc += 2;
xrealloc(opt_local->argv, opt_local->argc * sizeof(char *));
opt_local->argv[(*command_pos)++] = xstrdup("-n");
opt_local->argv[(*command_pos)++] = xstrdup_printf("%d",
hostset_count(hs));
hostset_destroy(hs);
/* Get the command */
for (i++; in_line[i]; i++) {
if (!isspace(in_line[i]))
break;
}
if (in_line[i] == '\0')
goto bad_line;
cmd_inx = i;
for ( ; in_line[i]; i++) {
if (isspace(in_line[i])) {
if (i > cmd_inx) {
int diff = i - cmd_inx + 1;
char tmp_char[diff + 1];
snprintf(tmp_char, diff, "%s",
in_line + cmd_inx);
opt_local->argc += 1;
xrealloc(opt_local->argv,
opt_local->argc * sizeof(char *));
opt_local->argv[(*command_pos)++] =
xstrdup(tmp_char);
}
cmd_inx = i + 1;
} else if (in_line[i] == '\n')
break;
}
return 1;
bad_line:
error("invalid input line: %s", in_line);
return 0;
}
/*
* slurm_pack_job_will_run - determine if a heterogenous job would execute
* immediately if submitted now
* IN job_req_list - List of job_desc_msg_t structures describing the resource
* allocation request
* RET 0 on success, otherwise return -1 and set errno to indicate the error
*/
extern int slurm_pack_job_will_run(List job_req_list)
{
job_desc_msg_t *req;
will_run_response_msg_t *will_run_resp;
char buf[64], local_hostname[64] = "", *sep = "";
int rc = SLURM_SUCCESS;
char *type = "processors";
ListIterator iter, itr;
time_t first_start = (time_t) 0;
uint32_t first_job_id = 0, tot_proc_count = 0, *job_id_ptr;
hostset_t hs = NULL;
char *job_list = NULL;
if (!job_req_list || (list_count(job_req_list) == 0)) {
error("No job descriptors input");
return SLURM_ERROR;
}
(void) gethostname_short(local_hostname, sizeof(local_hostname));
iter = list_iterator_create(job_req_list);
while ((req = (job_desc_msg_t *) list_next(iter))) {
if ((req->alloc_node == NULL) && local_hostname[0])
req->alloc_node = local_hostname;
will_run_resp = NULL;
rc = slurm_job_will_run2(req, &will_run_resp);
if ((rc == SLURM_SUCCESS) && will_run_resp) {
if (first_job_id == 0)
first_job_id = will_run_resp->job_id;
if ((first_start == 0) ||
(first_start < will_run_resp->start_time))
first_start = will_run_resp->start_time;
tot_proc_count += will_run_resp->proc_cnt;
if (hs)
hostset_insert(hs, will_run_resp->node_list);
else
hs = hostset_create(will_run_resp->node_list);
if (will_run_resp->preemptee_job_id) {
itr = list_iterator_create(will_run_resp->
preemptee_job_id);
while ((job_id_ptr = list_next(itr))) {
if (job_list)
sep = ",";
xstrfmtcat(job_list, "%s%u", sep,
*job_id_ptr);
}
list_iterator_destroy(itr);
}
slurm_free_will_run_response_msg(will_run_resp);
}
if (req->alloc_node == local_hostname)
req->alloc_node = NULL;
if (rc != SLURM_SUCCESS)
break;
}
list_iterator_destroy(iter);
if (rc == SLURM_SUCCESS) {
uint32_t cluster_flags = slurmdb_setup_cluster_flags();
char node_list[1028] = "";
if (cluster_flags & CLUSTER_FLAG_BG)
type = "cnodes";
if (hs)
hostset_ranged_string(hs, sizeof(node_list), node_list);
slurm_make_time_str(&first_start, buf, sizeof(buf));
info("Job %u to start at %s using %u %s on %s",
first_job_id, buf, tot_proc_count, type, node_list);
if (job_list)
info(" Preempts: %s", job_list);
}
if (hs)
hostset_destroy(hs);
xfree(job_list);
return rc;
}
extern void specific_info_resv(popup_info_t *popup_win)
{
int resv_error_code = SLURM_SUCCESS;
static reserve_info_msg_t *resv_info_ptr = NULL;
static reserve_info_t *resv_ptr = NULL;
specific_info_t *spec_info = popup_win->spec_info;
sview_search_info_t *search_info = spec_info->search_info;
char error_char[100];
GtkWidget *label = NULL;
GtkTreeView *tree_view = NULL;
List resv_list = NULL;
List send_resv_list = NULL;
sview_resv_info_t *sview_resv_info_ptr = NULL;
int j=0, i=-1;
hostset_t hostset = NULL;
ListIterator itr = NULL;
if (!spec_info->display_widget) {
setup_popup_info(popup_win, display_data_resv, SORTID_CNT);
}
if (spec_info->display_widget && popup_win->toggled) {
gtk_widget_destroy(spec_info->display_widget);
spec_info->display_widget = NULL;
goto display_it;
}
if ((resv_error_code =
get_new_info_resv(&resv_info_ptr, popup_win->force_refresh))
== SLURM_NO_CHANGE_IN_DATA) {
if (!spec_info->display_widget || spec_info->view == ERROR_VIEW)
goto display_it;
} else if (resv_error_code != SLURM_SUCCESS) {
if (spec_info->view == ERROR_VIEW)
goto end_it;
spec_info->view = ERROR_VIEW;
if (spec_info->display_widget)
gtk_widget_destroy(spec_info->display_widget);
sprintf(error_char, "get_new_info_resv: %s",
slurm_strerror(slurm_get_errno()));
label = gtk_label_new(error_char);
gtk_table_attach_defaults(popup_win->table,
label,
0, 1, 0, 1);
gtk_widget_show(label);
spec_info->display_widget = gtk_widget_ref(label);
goto end_it;
}
display_it:
resv_list = _create_resv_info_list(resv_info_ptr);
if (!resv_list)
return;
if (spec_info->view == ERROR_VIEW && spec_info->display_widget) {
gtk_widget_destroy(spec_info->display_widget);
spec_info->display_widget = NULL;
}
if (spec_info->type != INFO_PAGE && !spec_info->display_widget) {
tree_view = create_treeview(local_display_data,
&popup_win->grid_button_list);
gtk_tree_selection_set_mode(
gtk_tree_view_get_selection(tree_view),
GTK_SELECTION_MULTIPLE);
spec_info->display_widget =
gtk_widget_ref(GTK_WIDGET(tree_view));
gtk_table_attach_defaults(popup_win->table,
GTK_WIDGET(tree_view),
0, 1, 0, 1);
/* since this function sets the model of the tree_view
to the treestore we don't really care about
the return value */
create_treestore(tree_view, popup_win->display_data,
SORTID_CNT, SORTID_TIME_START, SORTID_COLOR);
}
setup_popup_grid_list(popup_win);
spec_info->view = INFO_VIEW;
if (spec_info->type == INFO_PAGE) {
_display_info_resv(resv_list, popup_win);
goto end_it;
}
/* just linking to another list, don't free the inside, just
the list */
send_resv_list = list_create(NULL);
itr = list_iterator_create(resv_list);
i = -1;
while ((sview_resv_info_ptr = list_next(itr))) {
i++;
resv_ptr = sview_resv_info_ptr->resv_ptr;
switch(spec_info->type) {
case PART_PAGE:
case BLOCK_PAGE:
case NODE_PAGE:
if (!resv_ptr->node_list)
continue;
if (!(hostset = hostset_create(
search_info->gchar_data)))
continue;
if (!hostset_intersects(hostset, resv_ptr->node_list)) {
hostset_destroy(hostset);
continue;
}
hostset_destroy(hostset);
break;
case JOB_PAGE:
if (strcmp(resv_ptr->name,
search_info->gchar_data))
continue;
break;
case RESV_PAGE:
switch(search_info->search_type) {
case SEARCH_RESERVATION_NAME:
if (!search_info->gchar_data)
continue;
if (strcmp(resv_ptr->name,
search_info->gchar_data))
continue;
break;
default:
continue;
}
break;
default:
g_print("Unknown type %d\n", spec_info->type);
continue;
}
list_push(send_resv_list, sview_resv_info_ptr);
j=0;
while (resv_ptr->node_inx[j] >= 0) {
change_grid_color(
popup_win->grid_button_list,
resv_ptr->node_inx[j],
resv_ptr->node_inx[j+1],
sview_resv_info_ptr->color_inx,
true, 0);
j += 2;
}
}
list_iterator_destroy(itr);
post_setup_popup_grid_list(popup_win);
_update_info_resv(send_resv_list,
GTK_TREE_VIEW(spec_info->display_widget));
FREE_NULL_LIST(send_resv_list);
end_it:
popup_win->toggled = 0;
popup_win->force_refresh = 0;
return;
}
/*
* slurm_pack_job_will_run - determine if a heterogenous job would execute
* immediately if submitted now
* IN job_req_list - List of job_desc_msg_t structures describing the resource
* allocation request
* RET SLURM_SUCCESS on success, otherwise return SLURM_ERROR with errno set
*/
extern int slurm_pack_job_will_run(List job_req_list)
{
job_desc_msg_t *req;
will_run_response_msg_t *will_run_resp;
char buf[64], *sep = "";
int rc = SLURM_SUCCESS, inx = 0;
ListIterator iter, itr;
time_t first_start = (time_t) 0;
uint32_t first_job_id = 0, tot_proc_count = 0, *job_id_ptr;
hostset_t hs = NULL;
char *job_list = NULL;
if (!job_req_list || (list_count(job_req_list) == 0)) {
error("No job descriptors input");
return SLURM_ERROR;
}
iter = list_iterator_create(job_req_list);
while ((req = (job_desc_msg_t *) list_next(iter))) {
will_run_resp = NULL;
rc = slurm_job_will_run2(req, &will_run_resp);
if (will_run_resp)
print_multi_line_string(
will_run_resp->job_submit_user_msg,
inx, LOG_LEVEL_INFO);
if ((rc == SLURM_SUCCESS) && will_run_resp) {
if (first_job_id == 0)
first_job_id = will_run_resp->job_id;
if ((first_start == 0) ||
(first_start < will_run_resp->start_time))
first_start = will_run_resp->start_time;
tot_proc_count += will_run_resp->proc_cnt;
if (hs)
hostset_insert(hs, will_run_resp->node_list);
else
hs = hostset_create(will_run_resp->node_list);
if (will_run_resp->preemptee_job_id) {
itr = list_iterator_create(will_run_resp->
preemptee_job_id);
while ((job_id_ptr = list_next(itr))) {
if (job_list)
sep = ",";
xstrfmtcat(job_list, "%s%u", sep,
*job_id_ptr);
}
list_iterator_destroy(itr);
}
slurm_free_will_run_response_msg(will_run_resp);
}
if (rc != SLURM_SUCCESS)
break;
inx++;
}
list_iterator_destroy(iter);
if (rc == SLURM_SUCCESS) {
char node_list[1028] = "";
if (hs)
hostset_ranged_string(hs, sizeof(node_list), node_list);
slurm_make_time_str(&first_start, buf, sizeof(buf));
info("Job %u to start at %s using %u processors on %s",
first_job_id, buf, tot_proc_count, node_list);
if (job_list)
info(" Preempts: %s", job_list);
}
if (hs)
hostset_destroy(hs);
xfree(job_list);
return rc;
}
/*
* get_nodes - get information on specific node(s) changed since some time
* cmd_ptr IN - CMD=GETNODES ARG=[<UPDATETIME>:<NODEID>[:<NODEID>]...]
* [<UPDATETIME>:ALL]
* err_code OUT - 0 or an error code
* err_msg OUT - response message
* NOTE: xfree() err_msg if err_code is zero
* RET 0 on success, -1 on failure
*
* Response format
* ARG=<cnt>#<NODEID>:
* STATE=<state>; Moab equivalent node state
* [CAT=<reason>]; Reason for a node being down or drained
* colon separator
* CCLASS=<[part:cpus]>; SLURM partition with CPU count of node,
* make have more than one partition
* [CPULOAD=<load_ave>;] One minute BSD load average
* [ARCH=<architecture>;] Computer architecture
* [OS=<operating_system>;] Operating system
* CMEMORY=<MB>; MB of memory on node
* CDISK=<MB>; MB of disk space on node
* CPROC=<cpus>; CPU count on node
* [FEATURE=<feature>;] Features associated with node, if any
* [GRES=<name>[:<count>],...;] generic resources on the node
* [#<NODEID>:...];
*/
extern int get_nodes(char *cmd_ptr, int *err_code, char **err_msg)
{
char *arg_ptr = NULL, *tmp_char = NULL, *tmp_buf = NULL, *buf = NULL;
time_t update_time;
/* Locks: read node, read partition */
slurmctld_lock_t node_read_lock = {
NO_LOCK, NO_LOCK, READ_LOCK, READ_LOCK };
int node_rec_cnt = 0, buf_size = 0;
#ifdef HAVE_ALPS_CRAY
/* Locks: write node */
slurmctld_lock_t node_write_lock = {
NO_LOCK, NO_LOCK, WRITE_LOCK, NO_LOCK };
/*
* Run a Basil Inventory immediately before scheduling, to avoid
* race conditions caused by ALPS node state change (caused e.g.
* by the node health checker).
* This relies on the above write lock for the node state.
*/
lock_slurmctld(node_write_lock);
if (select_g_reconfigure()) {
unlock_slurmctld(node_write_lock);
*err_code = -720;
*err_msg = "Unable to run ALPS inventory";
error("wiki: Unable to run ALPS inventory");
return -1;
}
unlock_slurmctld(node_write_lock);
#endif
arg_ptr = strstr(cmd_ptr, "ARG=");
if (arg_ptr == NULL) {
*err_code = -300;
*err_msg = "GETNODES lacks ARG";
error("wiki: GETNODES lacks ARG");
return -1;
}
update_time = (time_t) strtoul(arg_ptr+4, &tmp_char, 10);
if (tmp_char[0] != ':') {
*err_code = -300;
*err_msg = "Invalid ARG value";
error("wiki: GETNODES has invalid ARG value");
return -1;
}
tmp_char++;
lock_slurmctld(node_read_lock);
if (strncmp(tmp_char, "ALL", 3) == 0) {
/* report all nodes */
buf = _dump_all_nodes(&node_rec_cnt, update_time);
} else {
struct node_record *node_ptr = NULL;
char *node_name, *slurm_hosts;
int node_cnt;
hostset_t slurm_hostset;
slurm_hosts = moab2slurm_task_list(tmp_char, &node_cnt);
if ((slurm_hostset = hostset_create(slurm_hosts))) {
while ((node_name = hostset_shift(slurm_hostset))) {
node_ptr = find_node_record(node_name);
if (node_ptr == NULL) {
error("sched/wiki2: bad hostname %s",
node_name);
continue;
}
if (_hidden_node(node_ptr))
continue;
tmp_buf = _dump_node(node_ptr, NULL,
update_time);
if (node_rec_cnt > 0)
xstrcat(buf, "#");
xstrcat(buf, tmp_buf);
xfree(tmp_buf);
node_rec_cnt++;
}
hostset_destroy(slurm_hostset);
} else {
error("hostset_create(%s): %m", slurm_hosts);
}
xfree(slurm_hosts);
}
unlock_slurmctld(node_read_lock);
/* Prepend ("ARG=%d", node_rec_cnt) to reply message */
if (buf)
buf_size = strlen(buf);
tmp_buf = xmalloc(buf_size + 32);
if (node_rec_cnt)
sprintf(tmp_buf, "SC=0 ARG=%d#%s", node_rec_cnt, buf);
else
sprintf(tmp_buf, "SC=0 ARG=0#");
xfree(buf);
*err_code = 0;
*err_msg = tmp_buf;
return 0;
}
/* _filter_job_records - filtering job information per user specification
* RET Count of job's filtered out OTHER than for job ID value */
static int _filter_job_records (void)
{
int filter_cnt = 0;
int i;
job_info_t *job_ptr = NULL;
uint32_t job_base_state;
job_ptr = job_buffer_ptr->job_array;
for (i = 0; i < job_buffer_ptr->record_count; i++, job_ptr++) {
if (IS_JOB_FINISHED(job_ptr))
job_ptr->job_id = 0;
if (job_ptr->job_id == 0)
continue;
job_base_state = job_ptr->job_state & JOB_STATE_BASE;
if ((job_base_state != JOB_PENDING) &&
(job_base_state != JOB_RUNNING) &&
(job_base_state != JOB_SUSPENDED)) {
job_ptr->job_id = 0;
filter_cnt++;
continue;
}
if (opt.account != NULL &&
xstrcmp(job_ptr->account, opt.account)) {
job_ptr->job_id = 0;
filter_cnt++;
continue;
}
if (opt.job_name != NULL &&
xstrcmp(job_ptr->name, opt.job_name)) {
job_ptr->job_id = 0;
filter_cnt++;
continue;
}
if ((opt.partition != NULL) &&
xstrcmp(job_ptr->partition, opt.partition)) {
job_ptr->job_id = 0;
filter_cnt++;
continue;
}
if ((opt.qos != NULL) &&
xstrcmp(job_ptr->qos, opt.qos)) {
job_ptr->job_id = 0;
filter_cnt++;
continue;
}
if ((opt.reservation != NULL) &&
xstrcmp(job_ptr->resv_name, opt.reservation)) {
job_ptr->job_id = 0;
filter_cnt++;
continue;
}
if ((opt.state != JOB_END) &&
(job_ptr->job_state != opt.state)) {
job_ptr->job_id = 0;
filter_cnt++;
continue;
}
if ((opt.user_name != NULL) &&
(job_ptr->user_id != opt.user_id)) {
job_ptr->job_id = 0;
filter_cnt++;
continue;
}
if (opt.nodelist != NULL) {
/* If nodelist contains a '/', treat it as a file name */
if (strchr(opt.nodelist, '/') != NULL) {
char *reallist;
reallist = slurm_read_hostfile(opt.nodelist,
NO_VAL);
if (reallist) {
xfree(opt.nodelist);
opt.nodelist = reallist;
}
}
hostset_t hs = hostset_create(job_ptr->nodes);
if (!hostset_intersects(hs, opt.nodelist)) {
job_ptr->job_id = 0;
filter_cnt++;
hostset_destroy(hs);
continue;
} else {
hostset_destroy(hs);
}
}
if (opt.wckey != NULL) {
char *job_key = job_ptr->wckey;
/*
* A wckey that begins with '*' indicates that the wckey
* was applied by default. When the --wckey option does
* not begin with a '*', act on all wckeys with the same
* name, default or not.
*/
if ((opt.wckey[0] != '*') && (job_key[0] == '*'))
job_key++;
if (xstrcmp(job_key, opt.wckey) != 0) {
job_ptr->job_id = 0;
filter_cnt++;
continue;
}
}
}
return filter_cnt;
}
/*
* parse_command_line
*/
extern void
parse_command_line( int argc, char* argv[] )
{
char *env_val = NULL;
bool override_format_env = false;
int opt_char;
int option_index;
static struct option long_options[] = {
{"accounts", required_argument, 0, 'A'},
{"all", no_argument, 0, 'a'},
{"format", required_argument, 0, 'o'},
{"help", no_argument, 0, OPT_LONG_HELP},
{"hide", no_argument, 0, OPT_LONG_HIDE},
{"iterate", required_argument, 0, 'i'},
{"jobs", optional_argument, 0, 'j'},
{"long", no_argument, 0, 'l'},
{"cluster", required_argument, 0, 'M'},
{"clusters", required_argument, 0, 'M'},
{"node", required_argument, 0, 'n'},
{"nodes", required_argument, 0, 'n'},
{"noheader", no_argument, 0, 'h'},
{"partitions", required_argument, 0, 'p'},
{"qos", required_argument, 0, 'q'},
{"reservation",required_argument, 0, 'R'},
{"sort", required_argument, 0, 'S'},
{"start", no_argument, 0, OPT_LONG_START},
{"steps", optional_argument, 0, 's'},
{"states", required_argument, 0, 't'},
{"usage", no_argument, 0, OPT_LONG_USAGE},
{"user", required_argument, 0, 'u'},
{"users", required_argument, 0, 'u'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{NULL, 0, 0, 0}
};
if (getenv("SQUEUE_ALL"))
params.all_flag = true;
if ( ( env_val = getenv("SQUEUE_SORT") ) )
params.sort = xstrdup(env_val);
if ( ( env_val = getenv("SLURM_CLUSTERS") ) ) {
if (!(params.clusters = slurmdb_get_info_cluster(env_val))) {
error("'%s' can't be reached now, "
"or it is an invalid entry for "
"SLURM_CLUSTERS. Use 'sacctmgr --list "
"cluster' to see avaliable clusters.",
env_val);
exit(1);
}
working_cluster_rec = list_peek(params.clusters);
}
while ((opt_char = getopt_long(argc, argv,
"A:ahi:j::ln:M:o:p:q:R:s::S:t:u:U:vV",
long_options, &option_index)) != -1) {
switch (opt_char) {
case (int)'?':
fprintf(stderr, "Try \"squeue --help\" "
"for more information\n");
exit(1);
case (int) 'A':
case (int) 'U': /* backwards compatibility */
xfree(params.accounts);
params.accounts = xstrdup(optarg);
params.account_list =
_build_str_list( params.accounts );
break;
case (int)'a':
params.all_flag = true;
break;
case (int)'h':
params.no_header = true;
break;
case (int) 'i':
params.iterate= atoi(optarg);
if (params.iterate <= 0) {
error ("--iterate=%s\n", optarg);
exit(1);
}
break;
case (int) 'j':
if (optarg) {
params.jobs = xstrdup(optarg);
params.job_list =
_build_job_list(params.jobs);
}
params.job_flag = true;
break;
case (int) 'l':
params.long_list = true;
override_format_env = true;
break;
case (int) 'M':
if (params.clusters)
list_destroy(params.clusters);
if (!(params.clusters =
slurmdb_get_info_cluster(optarg))) {
error("'%s' can't be reached now, "
"or it is an invalid entry for "
"--cluster. Use 'sacctmgr --list "
"cluster' to see avaliable clusters.",
optarg);
exit(1);
}
working_cluster_rec = list_peek(params.clusters);
break;
case (int) 'n':
if (params.nodes)
hostset_destroy(params.nodes);
params.nodes = hostset_create(optarg);
if (params.nodes == NULL) {
error("'%s' invalid entry for --nodes",
optarg);
exit(1);
}
break;
case (int) 'o':
xfree(params.format);
params.format = xstrdup(optarg);
override_format_env = true;
break;
case (int) 'p':
xfree(params.partitions);
params.partitions = xstrdup(optarg);
params.part_list =
_build_str_list( params.partitions );
params.all_flag = true;
break;
case (int) 'q':
xfree(params.qoss);
params.qoss = xstrdup(optarg);
params.qos_list =
_build_str_list( params.qoss );
break;
case (int) 'R':
xfree(params.reservation);
params.reservation = xstrdup(optarg);
break;
case (int) 's':
if (optarg) {
params.steps = xstrdup(optarg);
params.step_list =
_build_step_list(params.steps);
}
params.step_flag = true;
override_format_env = true;
break;
case (int) 'S':
xfree(params.sort);
params.sort = xstrdup(optarg);
break;
case (int) 't':
xfree(params.states);
params.states = xstrdup(optarg);
params.state_list =
_build_state_list( params.states );
break;
case (int) 'u':
xfree(params.users);
params.users = xstrdup(optarg);
params.user_list =
_build_user_list( params.users );
break;
case (int) 'v':
params.verbose++;
break;
case (int) 'V':
print_slurm_version();
exit(0);
case OPT_LONG_HELP:
_help();
exit(0);
case OPT_LONG_HIDE:
params.all_flag = false;
break;
case OPT_LONG_START:
params.start_flag = true;
break;
case OPT_LONG_USAGE:
_usage();
exit(0);
}
}
if ( override_format_env == false ) {
if ( ( env_val = getenv("SQUEUE_FORMAT") ) )
params.format = xstrdup(env_val);
}
params.cluster_flags = slurmdb_setup_cluster_flags();
if (optind < argc) {
if (params.job_flag) {
params.jobs = xstrdup(argv[optind++]);
params.job_list = _build_job_list(params.jobs);
} else if (params.step_flag) {
params.steps = xstrdup(argv[optind++]);
params.step_list = _build_step_list(params.steps);
}
if (optind < argc) {
error("Unrecognized option: %s",argv[optind]);
_usage();
exit(1);
}
}
if ( params.job_flag && params.step_flag) {
if (params.job_list) {
verbose("Printing job steps with job filter");
params.job_flag = false;
} else {
error("Incompatible options --jobs and --steps");
exit(1);
}
}
if ( params.nodes ) {
char *name1 = NULL;
char *name2 = NULL;
hostset_t nodenames = hostset_create(NULL);
if (nodenames == NULL)
fatal("malloc failure");
while ( hostset_count(params.nodes) > 0 ) {
name1 = hostset_pop(params.nodes);
/* localhost = use current host name */
if ( strcasecmp("localhost", name1) == 0 ) {
name2 = xmalloc(128);
gethostname_short(name2, 128);
} else {
/* translate NodeHostName to NodeName */
name2 = slurm_conf_get_nodename(name1);
/* use NodeName if translation failed */
if ( name2 == NULL )
name2 = xstrdup(name1);
}
hostset_insert(nodenames, name2);
free(name1);
xfree(name2);
}
/* Replace params.nodename with the new one */
hostset_destroy(params.nodes);
params.nodes = nodenames;
}
if ( ( params.accounts == NULL ) &&
( env_val = getenv("SQUEUE_ACCOUNT") ) ) {
params.accounts = xstrdup(env_val);
params.account_list = _build_str_list( params.accounts );
}
if ( ( params.partitions == NULL ) &&
( env_val = getenv("SQUEUE_PARTITION") ) ) {
params.partitions = xstrdup(env_val);
params.part_list = _build_str_list( params.partitions );
params.all_flag = true;
}
if ( ( params.qoss == NULL ) &&
( env_val = getenv("SQUEUE_QOS") ) ) {
params.qoss = xstrdup(env_val);
params.qos_list = _build_str_list( params.qoss );
}
if ( ( params.states == NULL ) &&
( env_val = getenv("SQUEUE_STATES") ) ) {
params.states = xstrdup(env_val);
params.state_list = _build_state_list( params.states );
}
if ( ( params.users == NULL ) &&
( env_val = getenv("SQUEUE_USERS") ) ) {
params.users = xstrdup(env_val);
params.user_list = _build_user_list( params.users );
}
if ( params.start_flag && !params.step_flag ) {
/* Set more defaults */
if (params.format == NULL)
params.format = xstrdup("%.7i %.9P %.8j %.8u %.2t %.19S %.6D %R");
if (params.sort == NULL)
params.sort = xstrdup("S");
if (params.states == NULL) {
params.states = xstrdup("PD");
params.state_list = _build_state_list( params.states );
}
}
params.max_cpus = _max_cpus_per_node();
if ( params.verbose )
_print_options();
}
extern void specific_info_block(popup_info_t *popup_win)
{
int part_error_code = SLURM_SUCCESS;
int block_error_code = SLURM_SUCCESS;
static partition_info_msg_t *part_info_ptr = NULL;
static block_info_msg_t *block_info_ptr = NULL;
specific_info_t *spec_info = popup_win->spec_info;
sview_search_info_t *search_info = spec_info->search_info;
char error_char[100];
GtkWidget *label = NULL;
GtkTreeView *tree_view = NULL;
List block_list = NULL;
List send_block_list = NULL;
sview_block_info_t *block_ptr = NULL;
int j=0, i=-1;
hostset_t hostset = NULL;
ListIterator itr = NULL;
if (!spec_info->display_widget) {
setup_popup_info(popup_win, display_data_block, SORTID_CNT);
}
if (spec_info->display_widget && popup_win->toggled) {
gtk_widget_destroy(spec_info->display_widget);
spec_info->display_widget = NULL;
goto display_it;
}
if ((part_error_code = get_new_info_part(&part_info_ptr,
popup_win->force_refresh))
== SLURM_NO_CHANGE_IN_DATA) {
} else if (part_error_code != SLURM_SUCCESS) {
if (spec_info->view == ERROR_VIEW)
goto end_it;
spec_info->view = ERROR_VIEW;
if (spec_info->display_widget)
gtk_widget_destroy(spec_info->display_widget);
sprintf(error_char, "slurm_load_partitions: %s",
slurm_strerror(slurm_get_errno()));
label = gtk_label_new(error_char);
gtk_table_attach_defaults(popup_win->table,
label,
0, 1, 0, 1);
gtk_widget_show(label);
spec_info->display_widget = gtk_widget_ref(label);
goto end_it;
}
if ((block_error_code =
get_new_info_block(&block_info_ptr, popup_win->force_refresh))
== SLURM_NO_CHANGE_IN_DATA) {
if ((!spec_info->display_widget
|| spec_info->view == ERROR_VIEW)
|| (part_error_code != SLURM_NO_CHANGE_IN_DATA)) {
goto display_it;
}
} else if (block_error_code != SLURM_SUCCESS) {
if (spec_info->view == ERROR_VIEW)
goto end_it;
spec_info->view = ERROR_VIEW;
if (spec_info->display_widget)
gtk_widget_destroy(spec_info->display_widget);
sprintf(error_char, "slurm_load_block: %s",
slurm_strerror(slurm_get_errno()));
label = gtk_label_new(error_char);
gtk_table_attach_defaults(popup_win->table,
label,
0, 1, 0, 1);
gtk_widget_show(label);
spec_info->display_widget = gtk_widget_ref(label);
goto end_it;
}
display_it:
block_list = _create_block_list(part_info_ptr, block_info_ptr);
if (!block_list)
return;
if (spec_info->view == ERROR_VIEW && spec_info->display_widget) {
gtk_widget_destroy(spec_info->display_widget);
spec_info->display_widget = NULL;
}
if (spec_info->type != INFO_PAGE && !spec_info->display_widget) {
tree_view = create_treeview(local_display_data,
&popup_win->grid_button_list);
gtk_tree_selection_set_mode(
gtk_tree_view_get_selection(tree_view),
GTK_SELECTION_MULTIPLE);
spec_info->display_widget =
gtk_widget_ref(GTK_WIDGET(tree_view));
gtk_table_attach_defaults(popup_win->table,
GTK_WIDGET(tree_view),
0, 1, 0, 1);
/* since this function sets the model of the tree_view
to the treestore we don't really care about
the return value */
create_treestore(tree_view, popup_win->display_data,
SORTID_CNT, SORTID_BLOCK, SORTID_COLOR);
}
setup_popup_grid_list(popup_win);
spec_info->view = INFO_VIEW;
if (spec_info->type == INFO_PAGE) {
_display_info_block(block_list, popup_win);
goto end_it;
}
/* just linking to another list, don't free the inside, just
the list */
send_block_list = list_create(NULL);
itr = list_iterator_create(block_list);
i = -1;
while ((block_ptr = list_next(itr))) {
/* we want to over ride any subgrp in error
state */
enum node_states state = NODE_STATE_UNKNOWN;
char *name = NULL;
i++;
switch(spec_info->type) {
case PART_PAGE:
if (xstrcmp(block_ptr->slurm_part_name,
search_info->gchar_data))
continue;
break;
case RESV_PAGE:
case NODE_PAGE:
if (!block_ptr->mp_str)
continue;
if (!(hostset = hostset_create(
search_info->gchar_data)))
continue;
name = block_ptr->mp_str;
if (block_ptr->small_block) {
int j=0;
/* strip off the ionodes part */
while (name[j]) {
if (name[j] == '[') {
name[j] = '\0';
break;
}
j++;
}
}
if (!hostset_intersects(hostset, name)) {
hostset_destroy(hostset);
continue;
}
hostset_destroy(hostset);
break;
case BLOCK_PAGE:
switch(search_info->search_type) {
case SEARCH_BLOCK_NAME:
if (!search_info->gchar_data)
continue;
if (xstrcmp(block_ptr->bg_block_name,
search_info->gchar_data))
continue;
break;
case SEARCH_BLOCK_SIZE:
if (search_info->int_data == NO_VAL)
continue;
if (block_ptr->cnode_cnt
!= search_info->int_data)
continue;
break;
case SEARCH_BLOCK_STATE:
if (search_info->int_data == NO_VAL)
continue;
if (block_ptr->state != search_info->int_data)
continue;
break;
default:
continue;
break;
}
break;
case JOB_PAGE:
if (xstrcmp(block_ptr->bg_block_name,
search_info->gchar_data))
continue;
break;
default:
g_print("Unknown type %d\n", spec_info->type);
continue;
}
list_push(send_block_list, block_ptr);
if (block_ptr->state & BG_BLOCK_ERROR_FLAG)
state = NODE_STATE_ERROR;
else if (list_count(block_ptr->job_list))
state = NODE_STATE_ALLOCATED;
else
state = NODE_STATE_IDLE;
j=0;
while (block_ptr->mp_inx[j] >= 0) {
change_grid_color(
popup_win->grid_button_list,
block_ptr->mp_inx[j],
block_ptr->mp_inx[j+1], block_ptr->color_inx,
true, state);
j += 2;
}
}
list_iterator_destroy(itr);
post_setup_popup_grid_list(popup_win);
_update_info_block(send_block_list,
GTK_TREE_VIEW(spec_info->display_widget));
FREE_NULL_LIST(send_block_list);
end_it:
popup_win->toggled = 0;
popup_win->force_refresh = 0;
return;
}