/**
* print a block request
*/
extern void print_select_ba_request(select_ba_request_t* ba_request)
{
int dim;
uint32_t cluster_flags = slurmdb_setup_cluster_flags();
uint16_t cluster_dims = slurmdb_setup_cluster_dims();
if (ba_request == NULL){
error("print_ba_request Error, request is NULL");
return;
}
debug(" ba_request:");
debug(" geometry:\t");
for (dim=0; dim<cluster_dims; dim++){
debug("%d", ba_request->geometry[dim]);
}
debug(" size:\t%d", ba_request->size);
if (cluster_flags & CLUSTER_FLAG_BGQ) {
for (dim=0; dim<cluster_dims; dim++)
debug(" conn_type:\t%d", ba_request->conn_type[dim]);
} else
debug(" conn_type:\t%d", ba_request->conn_type[0]);
debug(" rotate:\t%d", ba_request->rotate);
debug(" elongate:\t%d", ba_request->elongate);
}
extern uint16_t slurmdb_setup_cluster_name_dims(void)
{
if (is_cray_system())
return 1; /* Cray uses 1-dimensional hostlists */
return slurmdb_setup_cluster_dims();
}
/*
* verify geometry arguments, must have proper count
* returns -1 on error, 0 otherwise
*/
int verify_geometry(const char *arg, uint16_t *geometry)
{
char* token, *delimiter = ",x", *next_ptr;
int i, rc = 0;
char* geometry_tmp = xstrdup(arg);
char* original_ptr = geometry_tmp;
int dims = slurmdb_setup_cluster_dims();
token = strtok_r(geometry_tmp, delimiter, &next_ptr);
for (i=0; i<dims; i++) {
if (token == NULL) {
error("insufficient dimensions in --geometry");
rc = -1;
break;
}
geometry[i] = (uint16_t)atoi(token);
if (geometry[i] == 0 || geometry[i] == (uint16_t)NO_VAL) {
error("invalid --geometry argument");
rc = -1;
break;
}
geometry_tmp = next_ptr;
token = strtok_r(geometry_tmp, delimiter, &next_ptr);
}
if (token != NULL) {
error("too many dimensions in --geometry");
rc = -1;
}
if (original_ptr)
xfree(original_ptr);
return rc;
}
extern void select_p_ba_init(node_info_msg_t *node_info_ptr, bool sanity_check)
{
int i, j, offset;
int dims = slurmdb_setup_cluster_dims();
if (select_cray_dim_size[0] == -1) {
node_info_t *node_ptr;
/* init the rest of the dim sizes. All current (2011)
* XT/XE installations have a maximum dimension of 3,
* smaller systems deploy a 2D Torus which has no
* connectivity in X-dimension. Just incase they
* decide to change it where we only get 2 instead of
* 3 we will initialize it later. */
for (i = 1; i < dims; i++)
select_cray_dim_size[i] = -1;
for (i = 0; i < node_info_ptr->record_count; i++) {
node_ptr = &(node_info_ptr->node_array[i]);
if (!node_ptr->node_addr ||
(strlen(node_ptr->node_addr) != dims))
continue;
for (j = 0; j < dims; j++) {
offset = select_char2coord(
node_ptr->node_addr[j]);
select_cray_dim_size[j] =
MAX((offset+1),
select_cray_dim_size[j]);
}
}
}
/*
* Override the generic setup of dim_size made in _setup_cluster_rec()
* FIXME: use a better way, e.g. encoding the 3-dim triplet as a
* string which gets stored in a database (event_table?) entry.
*/
if (working_cluster_rec) {
xfree(working_cluster_rec->dim_size);
working_cluster_rec->dim_size = xmalloc(sizeof(int) * dims);
for (j = 0; j < dims; j++)
working_cluster_rec->dim_size[j] =
select_cray_dim_size[j];
}
other_ba_init(node_info_ptr, sanity_check);
}
char *print_geometry(const uint16_t *geometry)
{
int i;
char buf[32], *rc = NULL;
int dims = slurmdb_setup_cluster_dims();
if ((dims == 0) || !geometry[0]
|| (geometry[0] == (uint16_t)NO_VAL))
return NULL;
for (i=0; i<dims; i++) {
if (i > 0)
snprintf(buf, sizeof(buf), "x%u", geometry[i]);
else
snprintf(buf, sizeof(buf), "%u", geometry[i]);
xstrcat(rc, buf);
}
return rc;
}
/*
* scontrol_update_job - update the slurm job configuration per the supplied
* arguments
* IN argc - count of arguments
* IN argv - list of arguments
* RET 0 if no slurm error, errno otherwise. parsing error prints
* error message and returns 0
*/
extern int
scontrol_update_job (int argc, char *argv[])
{
bool update_size = false;
int i, update_cnt = 0;
char *tag, *val;
int taglen, vallen;
job_desc_msg_t job_msg;
slurm_init_job_desc_msg (&job_msg);
/* set current user, needed e.g., for AllowGroups checks */
job_msg.user_id = getuid();
for (i=0; i<argc; i++) {
tag = argv[i];
val = strchr(argv[i], '=');
if (val) {
taglen = val - argv[i];
val++;
vallen = strlen(val);
} else if (strncasecmp(tag, "Nice", MAX(strlen(tag), 2)) == 0){
/* "Nice" is the only tag that might not have an
equal sign, so it is handled specially. */
job_msg.nice = NICE_OFFSET + 100;
update_cnt++;
continue;
} else {
exit_code = 1;
fprintf (stderr, "Invalid input: %s\n", argv[i]);
fprintf (stderr, "Request aborted\n");
return -1;
}
if (strncasecmp(tag, "JobId", MAX(taglen, 3)) == 0) {
job_msg.job_id =
(uint32_t) strtol(val, (char **) NULL, 10);
}
else if (strncasecmp(tag, "Comment", MAX(taglen, 3)) == 0) {
job_msg.comment = val;
update_cnt++;
}
else if (strncasecmp(tag, "TimeLimit", MAX(taglen, 5)) == 0) {
bool incr, decr;
uint32_t job_current_time, time_limit;
incr = (val[0] == '+');
decr = (val[0] == '-');
if (incr || decr)
val++;
time_limit = time_str2mins(val);
if ((time_limit < 0) && (time_limit != INFINITE)) {
error("Invalid TimeLimit value");
exit_code = 1;
return 0;
}
if (incr || decr) {
job_current_time = _get_job_time(job_msg.
job_id);
if (job_current_time == NO_VAL) {
exit_code = 1;
return 0;
}
if (incr) {
time_limit += job_current_time;
} else if (time_limit > job_current_time) {
error("TimeLimit decrement larger than"
" current time limit (%u > %u)",
time_limit, job_current_time);
exit_code = 1;
return 0;
} else {
time_limit = job_current_time -
time_limit;
}
}
job_msg.time_limit = time_limit;
update_cnt++;
}
else if (strncasecmp(tag, "TimeMin", MAX(taglen, 5)) == 0) {
int time_min = time_str2mins(val);
if ((time_min < 0) && (time_min != INFINITE)) {
error("Invalid TimeMin value");
exit_code = 1;
return 0;
}
job_msg.time_min = time_min;
update_cnt++;
}
else if (strncasecmp(tag, "Priority", MAX(taglen, 2)) == 0) {
job_msg.priority =
(uint32_t) strtoll(val, (char **) NULL, 10);
update_cnt++;
}
else if (strncasecmp(tag, "Nice", MAX(taglen, 2)) == 0) {
int nice;
nice = strtoll(val, (char **) NULL, 10);
if (abs(nice) > NICE_OFFSET) {
error("Invalid nice value, must be between "
"-%d and %d", NICE_OFFSET,
NICE_OFFSET);
exit_code = 1;
return 0;
}
job_msg.nice = NICE_OFFSET + nice;
update_cnt++;
}
else if (strncasecmp(tag, "NumCPUs", MAX(taglen, 6)) == 0) {
int min_cpus, max_cpus=0;
if (!get_resource_arg_range(val, "NumCPUs", &min_cpus,
&max_cpus, false) ||
(min_cpus <= 0) ||
(max_cpus && (max_cpus < min_cpus))) {
error("Invalid NumCPUs value: %s", val);
exit_code = 1;
return 0;
}
job_msg.min_cpus = min_cpus;
if (max_cpus)
job_msg.max_cpus = max_cpus;
update_cnt++;
}
/* ReqProcs was removed in SLURM version 2.1 */
else if (strncasecmp(tag, "ReqProcs", MAX(taglen, 8)) == 0) {
job_msg.num_tasks =
(uint32_t) strtol(val, (char **) NULL, 10);
update_cnt++;
}
else if (strncasecmp(tag, "Requeue", MAX(taglen, 4)) == 0) {
job_msg.requeue =
(uint16_t) strtol(val, (char **) NULL, 10);
update_cnt++;
}
/* ReqNodes was replaced by NumNodes in SLURM version 2.1 */
else if ((strncasecmp(tag, "ReqNodes", MAX(taglen, 8)) == 0) ||
(strncasecmp(tag, "NumNodes", MAX(taglen, 8)) == 0)) {
int min_nodes, max_nodes, rc;
if (strcmp(val, "0") == 0) {
job_msg.min_nodes = 0;
} else if (strcasecmp(val, "ALL") == 0) {
job_msg.min_nodes = INFINITE;
} else {
min_nodes = (int) job_msg.min_nodes;
max_nodes = (int) job_msg.max_nodes;
rc = get_resource_arg_range(
val, "requested node count",
&min_nodes, &max_nodes, false);
if (!rc)
return rc;
job_msg.min_nodes = (uint32_t) min_nodes;
job_msg.max_nodes = (uint32_t) max_nodes;
}
update_size = true;
update_cnt++;
}
else if (strncasecmp(tag, "ReqSockets", MAX(taglen, 4)) == 0) {
job_msg.sockets_per_node =
(uint16_t) strtol(val, (char **) NULL, 10);
update_cnt++;
}
else if (strncasecmp(tag, "ReqCores", MAX(taglen, 4)) == 0) {
job_msg.cores_per_socket =
(uint16_t) strtol(val, (char **) NULL, 10);
update_cnt++;
}
else if (strncasecmp(tag, "TasksPerNode", MAX(taglen, 2))==0) {
job_msg.ntasks_per_node =
(uint16_t) strtol(val, (char **) NULL, 10);
update_cnt++;
}
else if (strncasecmp(tag, "ReqThreads", MAX(taglen, 4)) == 0) {
job_msg.threads_per_core =
(uint16_t) strtol(val, (char **) NULL, 10);
update_cnt++;
}
else if (strncasecmp(tag, "MinCPUsNode", MAX(taglen, 4)) == 0) {
job_msg.pn_min_cpus =
(uint32_t) strtol(val, (char **) NULL, 10);
update_cnt++;
}
else if (strncasecmp(tag, "MinMemoryNode",
MAX(taglen, 10)) == 0) {
job_msg.pn_min_memory =
(uint32_t) strtol(val, (char **) NULL, 10);
update_cnt++;
}
else if (strncasecmp(tag, "MinMemoryCPU",
MAX(taglen, 10)) == 0) {
job_msg.pn_min_memory =
(uint32_t) strtol(val, (char **) NULL, 10);
job_msg.pn_min_memory |= MEM_PER_CPU;
update_cnt++;
}
else if (strncasecmp(tag, "MinTmpDiskNode",
MAX(taglen, 5)) == 0) {
job_msg.pn_min_tmp_disk =
(uint32_t) strtol(val, (char **) NULL, 10);
update_cnt++;
}
else if (strncasecmp(tag, "Partition", MAX(taglen, 2)) == 0) {
job_msg.partition = val;
update_cnt++;
}
else if (strncasecmp(tag, "QOS", MAX(taglen, 2)) == 0) {
job_msg.qos = val;
update_cnt++;
}
else if (strncasecmp(tag, "ReservationName",
MAX(taglen, 3)) == 0) {
job_msg.reservation = val;
update_cnt++;
}
else if (strncasecmp(tag, "Name", MAX(taglen, 2)) == 0) {
job_msg.name = val;
update_cnt++;
}
else if (strncasecmp(tag, "WCKey", MAX(taglen, 1)) == 0) {
job_msg.wckey = val;
update_cnt++;
}
else if (strncasecmp(tag, "Switches", MAX(taglen, 5)) == 0) {
char *sep_char;
job_msg.req_switch =
(uint32_t) strtol(val, &sep_char, 10);
update_cnt++;
if (sep_char && sep_char[0] == '@') {
job_msg.wait4switch = time_str2mins(sep_char+1)
* 60;
}
}
else if (strncasecmp(tag, "wait-for-switch", MAX(taglen, 5))
== 0) {
job_msg.wait4switch =
(uint32_t) strtol(val, (char **) NULL, 10);
update_cnt++;
}
else if (strncasecmp(tag, "Shared", MAX(taglen, 2)) == 0) {
if (strncasecmp(val, "YES", MAX(vallen, 1)) == 0)
job_msg.shared = 1;
else if (strncasecmp(val, "NO", MAX(vallen, 1)) == 0)
job_msg.shared = 0;
else
job_msg.shared =
(uint16_t) strtol(val,
(char **) NULL, 10);
update_cnt++;
}
else if (strncasecmp(tag, "Contiguous", MAX(taglen, 3)) == 0) {
if (strncasecmp(val, "YES", MAX(vallen, 1)) == 0)
job_msg.contiguous = 1;
else if (strncasecmp(val, "NO", MAX(vallen, 1)) == 0)
job_msg.contiguous = 0;
else
job_msg.contiguous =
(uint16_t) strtol(val,
(char **) NULL, 10);
update_cnt++;
}
else if (strncasecmp(tag, "ExcNodeList", MAX(taglen, 3)) == 0){
job_msg.exc_nodes = val;
update_cnt++;
}
else if (!strncasecmp(tag, "NodeList", MAX(taglen, 8)) ||
!strncasecmp(tag, "ReqNodeList", MAX(taglen, 8))) {
job_msg.req_nodes = val;
update_size = true;
update_cnt++;
}
else if (strncasecmp(tag, "Features", MAX(taglen, 1)) == 0) {
job_msg.features = val;
update_cnt++;
}
else if (strncasecmp(tag, "Gres", MAX(taglen, 2)) == 0) {
if (!strcasecmp(val, "help") ||
!strcasecmp(val, "list")) {
print_gres_help();
} else {
job_msg.gres = val;
update_cnt++;
}
}
else if (strncasecmp(tag, "Account", MAX(taglen, 1)) == 0) {
job_msg.account = val;
update_cnt++;
}
else if (strncasecmp(tag, "Dependency", MAX(taglen, 1)) == 0) {
job_msg.dependency = val;
update_cnt++;
}
else if (strncasecmp(tag, "Geometry", MAX(taglen, 2)) == 0) {
char* token, *delimiter = ",x", *next_ptr;
int j, rc = 0;
int dims = slurmdb_setup_cluster_dims();
uint16_t geo[dims];
char* geometry_tmp = xstrdup(val);
char* original_ptr = geometry_tmp;
token = strtok_r(geometry_tmp, delimiter, &next_ptr);
for (j=0; j<dims; j++) {
if (token == NULL) {
error("insufficient dimensions in "
"Geometry");
rc = -1;
break;
}
geo[j] = (uint16_t) atoi(token);
if (geo[j] <= 0) {
error("invalid --geometry argument");
rc = -1;
break;
}
geometry_tmp = next_ptr;
token = strtok_r(geometry_tmp, delimiter,
&next_ptr);
}
if (token != NULL) {
error("too many dimensions in Geometry");
rc = -1;
}
if (original_ptr)
xfree(original_ptr);
if (rc != 0)
exit_code = 1;
else {
for (j=0; j<dims; j++)
job_msg.geometry[j] = geo[j];
update_cnt++;
}
}
else if (strncasecmp(tag, "Rotate", MAX(taglen, 2)) == 0) {
uint16_t rotate;
if (strncasecmp(val, "YES", MAX(vallen, 1)) == 0)
rotate = 1;
else if (strncasecmp(val, "NO", MAX(vallen, 1)) == 0)
rotate = 0;
else
rotate = (uint16_t) strtol(val,
(char **) NULL, 10);
job_msg.rotate = rotate;
update_cnt++;
}
else if (strncasecmp(tag, "Conn-Type", MAX(taglen, 2)) == 0) {
verify_conn_type(val, job_msg.conn_type);
if(job_msg.conn_type[0] != (uint16_t)NO_VAL)
update_cnt++;
}
else if (strncasecmp(tag, "Licenses", MAX(taglen, 1)) == 0) {
job_msg.licenses = val;
update_cnt++;
}
else if (!strncasecmp(tag, "EligibleTime", MAX(taglen, 2)) ||
!strncasecmp(tag, "StartTime", MAX(taglen, 2))) {
if ((job_msg.begin_time = parse_time(val, 0))) {
if (job_msg.begin_time < time(NULL))
job_msg.begin_time = time(NULL);
update_cnt++;
}
}
else if (!strncasecmp(tag, "EndTime", MAX(taglen, 2))) {
job_msg.end_time = parse_time(val, 0);
update_cnt++;
}
else {
exit_code = 1;
fprintf (stderr, "Update of this parameter is not "
"supported: %s\n", argv[i]);
fprintf (stderr, "Request aborted\n");
return 0;
}
}
if (update_cnt == 0) {
exit_code = 1;
fprintf (stderr, "No changes specified\n");
return 0;
}
if (slurm_update_job(&job_msg))
return slurm_get_errno ();
if (update_size)
_update_job_size(job_msg.job_id);
return SLURM_SUCCESS;
}
int main(int argc, char **argv)
{
GtkWidget *menubar = NULL;
GtkWidget *table = NULL;
GtkWidget *combo = NULL;
GtkBin *bin = NULL;
GtkViewport *view = NULL;
int i=0;
log_options_t lopts = LOG_OPTS_STDERR_ONLY;
if (!getenv("SLURM_BITSTR_LEN"))
setenv("SLURM_BITSTR_LEN", "128", 1); /* More array info */
slurm_conf_init(NULL);
log_init(argv[0], lopts, SYSLOG_FACILITY_USER, NULL);
load_defaults();
cluster_flags = slurmdb_setup_cluster_flags();
cluster_dims = slurmdb_setup_cluster_dims();
_init_pages();
sview_thread_init(NULL);
gdk_threads_init();
gdk_threads_enter();
/* Initialize GTK */
gtk_init (&argc, &argv);
sview_mutex_new(&sview_mutex);
sview_mutex_new(&grid_mutex);
sview_cond_new(&grid_cond);
/* make sure the system is up */
grid_window = GTK_WIDGET(create_scrolled_window());
bin = GTK_BIN(>K_SCROLLED_WINDOW(grid_window)->container);
view = GTK_VIEWPORT(bin->child);
bin = GTK_BIN(&view->bin);
main_grid_table = GTK_TABLE(bin->child);
gtk_table_set_homogeneous(main_grid_table, true);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(grid_window),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
/* fill in all static info for pages */
/* Make a window */
main_window = gtk_dialog_new();
g_signal_connect(G_OBJECT(main_window), "delete_event",
G_CALLBACK(_delete), NULL);
gtk_window_set_title(GTK_WINDOW(main_window), "Sview");
gtk_window_set_default_size(GTK_WINDOW(main_window),
working_sview_config.main_width,
working_sview_config.main_height);
gtk_container_set_border_width(
GTK_CONTAINER(GTK_DIALOG(main_window)->vbox), 1);
/* Create the main notebook, place the position of the tabs */
main_notebook = gtk_notebook_new();
g_signal_connect(G_OBJECT(main_notebook), "switch_page",
G_CALLBACK(_page_switched),
NULL);
table = gtk_table_new(1, 3, false);
gtk_table_set_homogeneous(GTK_TABLE(table), false);
gtk_container_set_border_width(GTK_CONTAINER(table), 1);
/* Create a menu */
menubar = _get_menubar_menu(main_window, main_notebook);
gtk_table_attach_defaults(GTK_TABLE(table), menubar, 0, 1, 0, 1);
if ((combo = _create_cluster_combo())) {
GtkWidget *label = gtk_label_new("Cluster ");
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1,
GTK_FILL, GTK_SHRINK, 0, 0);
gtk_table_attach(GTK_TABLE(table), combo, 2, 3, 0, 1,
GTK_FILL, GTK_SHRINK, 0, 0);
}
gtk_notebook_popup_enable(GTK_NOTEBOOK(main_notebook));
gtk_notebook_set_scrollable(GTK_NOTEBOOK(main_notebook), true);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(main_notebook),
working_sview_config.tab_pos);
main_statusbar = gtk_statusbar_new();
gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(main_statusbar),
false);
/* Pack it all together */
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(main_window)->vbox),
table, false, false, 0);
table = gtk_table_new(1, 2, false);
gtk_table_attach(GTK_TABLE(table), grid_window, 0, 1, 0, 1,
GTK_SHRINK, GTK_EXPAND | GTK_FILL,
0, 0);
gtk_table_attach_defaults(GTK_TABLE(table), main_notebook, 1, 2, 0, 1);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(main_window)->vbox),
table, true, true, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(main_window)->vbox),
main_statusbar, false, false, 0);
in_process_cursor = gdk_cursor_new(GDK_WATCH);
for(i=0; i<PAGE_CNT; i++) {
if (main_display_data[i].id == -1)
break;
create_page(GTK_NOTEBOOK(main_notebook),
&main_display_data[i]);
}
/* tell signal we are done adding */
popup_list = list_create(destroy_popup_info);
signal_params_list = list_create(destroy_signal_params);
gtk_widget_show_all(main_window);
adding = 0;
/* apply default settings */
if (!working_sview_config.show_grid)
gtk_widget_hide(grid_window);
for(i=0; i<PAGE_CNT; i++) {
GtkWidget *visible_tab = NULL;
if (main_display_data[i].id == -1)
break;
visible_tab = gtk_notebook_get_nth_page(
GTK_NOTEBOOK(main_notebook), i);
if (working_sview_config.page_visible[i]
|| (i == working_sview_config.default_page)
|| (i == TAB_PAGE))
gtk_widget_show(visible_tab);
else
gtk_widget_hide(visible_tab);
}
/* Set the default page. This has to be done after the
* gtk_widget_show_all since it, for some reason always sets
* 0 to be the default page and will just overwrite this. */
/* Also if we already are set at the current page we need to
start up the page thread, so just call the _page_switched
function. If we aren't already there, then set the current
page which will inturn call the _page_switched. If the
pages is already this the signal doesn't happen so handle
it here.
*/
if (gtk_notebook_get_current_page(GTK_NOTEBOOK(main_notebook))
== working_sview_config.default_page)
_page_switched(GTK_NOTEBOOK(main_notebook), NULL,
working_sview_config.default_page, NULL);
else
gtk_notebook_set_current_page(GTK_NOTEBOOK(main_notebook),
working_sview_config.
default_page);
/* Finished! */
gtk_main ();
gdk_threads_leave();
return 0;
}
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);
}
/* unpack a select job credential from a buffer
* OUT jobinfo - the select job credential read
* IN buffer - buffer with select credential read from current pointer loc
* IN protocol_version - slurm protocol version of client
* RET - slurm error code
* NOTE: returned value must be freed using free_jobinfo
*/
extern int unpack_select_jobinfo(select_jobinfo_t **jobinfo_pptr, Buf buffer,
uint16_t protocol_version)
{
int i;
uint32_t uint32_tmp;
uint16_t mp_cnode_cnt;
int dims = slurmdb_setup_cluster_dims();
select_jobinfo_t *jobinfo = xmalloc(sizeof(struct select_jobinfo));
char *bit_char = NULL;
*jobinfo_pptr = jobinfo;
jobinfo->magic = JOBINFO_MAGIC;
if (protocol_version >= SLURM_2_5_PROTOCOL_VERSION) {
safe_unpack16(&jobinfo->dim_cnt, buffer);
xassert(jobinfo->dim_cnt);
dims = jobinfo->dim_cnt;
for (i=0; i<dims; i++) {
safe_unpack16(&(jobinfo->geometry[i]), buffer);
safe_unpack16(&(jobinfo->conn_type[i]), buffer);
safe_unpack16(&(jobinfo->start_loc[i]), buffer);
}
safe_unpack16(&(jobinfo->reboot), buffer);
safe_unpack16(&(jobinfo->rotate), buffer);
safe_unpack32(&(jobinfo->block_cnode_cnt), buffer);
safe_unpack32(&(jobinfo->cnode_cnt), buffer);
safe_unpackstr_xmalloc(&(jobinfo->bg_block_id), &uint32_tmp,
buffer);
safe_unpackstr_xmalloc(&(jobinfo->mp_str), &uint32_tmp, buffer);
safe_unpackstr_xmalloc(&(jobinfo->ionode_str), &uint32_tmp,
buffer);
safe_unpackstr_xmalloc(&(jobinfo->blrtsimage),
&uint32_tmp, buffer);
safe_unpackstr_xmalloc(&(jobinfo->linuximage), &uint32_tmp,
buffer);
safe_unpackstr_xmalloc(&(jobinfo->mloaderimage), &uint32_tmp,
buffer);
safe_unpackstr_xmalloc(&(jobinfo->ramdiskimage), &uint32_tmp,
buffer);
safe_unpack16(&mp_cnode_cnt, buffer);
safe_unpackstr_xmalloc(&bit_char, &uint32_tmp, buffer);
if (bit_char) {
jobinfo->units_avail = bit_alloc(mp_cnode_cnt);
bit_unfmt(jobinfo->units_avail, bit_char);
xfree(bit_char);
}
safe_unpackstr_xmalloc(&bit_char, &uint32_tmp, buffer);
if (bit_char) {
jobinfo->units_used = bit_alloc(mp_cnode_cnt);
bit_unfmt(jobinfo->units_used, bit_char);
xfree(bit_char);
}
} else {
error("unpack_select_jobinfo: protocol_version "
"%hu not supported", protocol_version);
}
return SLURM_SUCCESS;
unpack_error:
free_select_jobinfo(jobinfo);
*jobinfo_pptr = NULL;
return SLURM_ERROR;
}
/* pack a select job credential into a buffer in machine independent form
* IN jobinfo - the select job credential to be saved
* OUT buffer - buffer with select credential appended
* IN protocol_version - slurm protocol version of client
* RET - slurm error code
*/
extern int pack_select_jobinfo(select_jobinfo_t *jobinfo, Buf buffer,
uint16_t protocol_version)
{
int i;
int dims = slurmdb_setup_cluster_dims();
if (protocol_version >= SLURM_2_5_PROTOCOL_VERSION) {
if (jobinfo) {
if (jobinfo->dim_cnt)
dims = jobinfo->dim_cnt;
else if (bg_recover != NOT_FROM_CONTROLLER)
xassert(0);
pack16(dims, buffer);
/* NOTE: If new elements are added here, make sure to
* add equivalant pack of zeros below for NULL
* pointer */
for (i=0; i<dims; i++) {
pack16(jobinfo->geometry[i], buffer);
pack16(jobinfo->conn_type[i], buffer);
pack16(jobinfo->start_loc[i], buffer);
}
pack16(jobinfo->reboot, buffer);
pack16(jobinfo->rotate, buffer);
pack32(jobinfo->block_cnode_cnt, buffer);
pack32(jobinfo->cnode_cnt, buffer);
packstr(jobinfo->bg_block_id, buffer);
packstr(jobinfo->mp_str, buffer);
packstr(jobinfo->ionode_str, buffer);
packstr(jobinfo->blrtsimage, buffer);
packstr(jobinfo->linuximage, buffer);
packstr(jobinfo->mloaderimage, buffer);
packstr(jobinfo->ramdiskimage, buffer);
if (bg_conf) {
pack16(bg_conf->mp_cnode_cnt, buffer);
pack_bit_fmt(jobinfo->units_avail, buffer);
pack_bit_fmt(jobinfo->units_used, buffer);
} else {
pack16(0, buffer);
packnull(buffer);
packnull(buffer);
}
} else {
pack16(dims, buffer);
/* pack space for 3 positions for geo
* conn_type and start_loc and then, reboot, and rotate
*/
for (i=0; i<((dims*3)+2); i++) {
pack16((uint16_t) 0, buffer);
}
pack32((uint32_t) 0, buffer); //block_cnode_cnt
pack32((uint32_t) 0, buffer); //cnode_cnt
packnull(buffer); //bg_block_id
packnull(buffer); //nodes
packnull(buffer); //ionodes
packnull(buffer); //blrts
packnull(buffer); //linux
packnull(buffer); //mloader
packnull(buffer); //ramdisk
pack16((uint16_t) 0, buffer); //mp_cnode_cnt
packnull(buffer); //units_avail
packnull(buffer); //units_used
}
} else {
error("pack_select_jobinfo: protocol_version "
"%hu not supported", protocol_version);
}
return SLURM_SUCCESS;
}
/*
* parse_command_line, fill in params data structure with data
*/
extern void parse_command_line(int argc, char *argv[])
{
int opt_char;
int option_index;
int tmp = 0;
static struct option long_options[] = {
{"commandline", no_argument, 0, 'c'},
{"display", required_argument, 0, 'D'},
{"noheader", no_argument, 0, 'h'},
{"iterate", required_argument, 0, 'i'},
{"ionodes", required_argument, 0, 'I'},
{"cluster", required_argument, 0, 'M'},
{"clusters",required_argument, 0, 'M'},
{"nodes", required_argument, 0, 'n'},
{"quiet", no_argument, 0, 'Q'},
{"resolve", required_argument, 0, 'R'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, OPT_LONG_HELP},
{"usage", no_argument, 0, OPT_LONG_USAGE},
{"show_hidden", no_argument, 0, 'H'},
{NULL, 0, 0, 0}
};
memset(¶ms, 0, sizeof(params));
while ((opt_char =
getopt_long(argc, argv, "cD:hi:I:Hn:M:QR:vV",
long_options, &option_index)) != -1) {
switch (opt_char) {
case '?':
fprintf(stderr,
"Try \"smap --help\" for more information\n");
exit(1);
break;
case 'c':
params.commandline = TRUE;
break;
case 'D':
if (!strcmp(optarg, "j"))
tmp = JOBS;
else if (!strcmp(optarg, "s"))
tmp = SLURMPART;
else if (!strcmp(optarg, "b"))
tmp = BGPART;
else if (!strcmp(optarg, "c"))
tmp = COMMANDS;
else if (!strcmp(optarg, "r"))
tmp = RESERVATIONS;
params.display = tmp;
break;
case 'h':
params.no_header = true;
break;
case 'H':
params.all_flag = true;
break;
case 'i':
params.iterate = atoi(optarg);
if (params.iterate <= 0) {
error("Error: --iterate=%s", optarg);
exit(1);
}
break;
case 'I':
/*
* confirm valid ionodelist entry (The 128 is
* a large number here to avoid having to do a
* lot more querying to figure out the correct
* pset size. This number should be large enough.
*/
params.io_bit = bit_alloc(128);
if(bit_unfmt(params.io_bit, optarg) == -1) {
error("'%s' invalid entry for --ionodes",
optarg);
exit(1);
}
break;
case 'M':
if(params.clusters)
list_destroy(params.clusters);
if(!(params.clusters =
slurmdb_get_info_cluster(optarg))) {
error("'%s' invalid entry for --cluster",
optarg);
exit(1);
}
working_cluster_rec = list_peek(params.clusters);
break;
case 'n':
/*
* confirm valid nodelist entry
*/
params.hl = hostlist_create(optarg);
if (!params.hl) {
error("'%s' invalid entry for --nodes",
optarg);
exit(1);
}
break;
case 'Q':
quiet_flag = 1;
break;
case 'R':
params.commandline = TRUE;
params.resolve = xstrdup(optarg);
break;
case 'v':
params.verbose++;
break;
case 'V':
print_slurm_version();
exit(0);
case OPT_LONG_HELP:
_help();
exit(0);
case OPT_LONG_USAGE:
_usage();
exit(0);
}
}
params.cluster_dims = slurmdb_setup_cluster_dims();
if (params.cluster_dims > 4)
fatal("smap is unable to support more than four dimensions");
params.cluster_base = hostlist_get_base(params.cluster_dims);
params.cluster_flags = slurmdb_setup_cluster_flags();
}
