static void _set_ruled(GtkToggleAction *action)
{
char *tmp;
if (action)
working_sview_config.ruled_treeview
= gtk_toggle_action_get_active(action);
if (!working_sview_config.ruled_treeview)
tmp = g_strdup_printf(
"Tables not ruled");
else
tmp = g_strdup_printf(
"Tables ruled");
/* get rid of each existing table */
cluster_change_block();
cluster_change_front_end();
cluster_change_resv();
cluster_change_part();
cluster_change_job();
cluster_change_node();
cluster_change_bb();
refresh_main(NULL, NULL);
display_edit_note(tmp);
g_free(tmp);
return;
}
static void _set_flags(GtkToggleAction *action)
{
char *temp = NULL;
uint64_t debug_flags_plus = 0, debug_flags_minus = 0;
uint64_t flag = (uint64_t)NO_VAL;
const char *name;
if (!action)
return;
name = gtk_action_get_name(GTK_ACTION(action));
if (!name)
return;
if (debug_str2flags((char *)name, &flag) != SLURM_SUCCESS)
return;
if (action && gtk_toggle_action_get_active(action))
debug_flags_plus |= flag;
else
debug_flags_minus |= flag;
if (!slurm_set_debugflags(debug_flags_plus, debug_flags_minus))
temp = g_strdup_printf("Slurmctld DebugFlags reset");
else
temp = g_strdup_printf("Problem with set DebugFlags request");
display_edit_note(temp);
g_free(temp);
}
static void _set_hidden(GtkToggleAction *action)
{
char *tmp;
if (action)
working_sview_config.show_hidden
= gtk_toggle_action_get_active(action);
if (!working_sview_config.show_hidden)
tmp = g_strdup_printf(
"Hidden partitions and their jobs are now hidden");
else
tmp = g_strdup_printf(
"Hidden partitions and their jobs are now visible");
if (apply_hidden_change) {
if (grid_button_list) {
list_destroy(grid_button_list);
grid_button_list = NULL;
}
get_system_stats(main_grid_table);
}
apply_hidden_change = TRUE;
refresh_main(NULL, NULL);
display_edit_note(tmp);
g_free(tmp);
return;
}
static void _set_topogrid(GtkToggleAction *action)
{
char *tmp;
int rc = SLURM_SUCCESS;
if (action) {
working_sview_config.grid_topological
= gtk_toggle_action_get_active(action);
}
apply_hidden_change = false;
if (working_sview_config.grid_topological) {
if (!g_switch_nodes_maps)
rc = get_topo_conf();
if (rc != SLURM_SUCCESS)
/*denied*/
tmp = g_strdup_printf("Valid topology not detected");
else
tmp = g_strdup_printf("Grid changed to topology order");
}
refresh_main(NULL, NULL);
display_edit_note(tmp);
g_free(tmp);
return;
}
static void _reconfigure(GtkToggleAction *action)
{
char *temp = NULL;
if (!slurm_reconfigure())
temp = g_strdup_printf(
"Reconfigure sent to slurm successfully");
else
temp = g_strdup_printf("Problem with reconfigure request");
display_edit_note(temp);
g_free(temp);
}
static void _set_page_opts(GtkToggleAction *action)
{
char *tmp;
if (action)
working_sview_config.save_page_opts
= gtk_toggle_action_get_active(action);
if (working_sview_config.save_page_opts)
tmp = g_strdup_printf("Save Page Options now ON");
else
tmp = g_strdup_printf("Save Page Options now OFF");
refresh_main(NULL, NULL);
display_edit_note(tmp);
g_free(tmp);
return;
}
static void _set_debug(GtkRadioAction *action,
GtkRadioAction *extra,
GtkNotebook *notebook)
{
char *temp = NULL;
int level;
/* This is here to make sure we got the correct value in the
beginning. This gets called when the value is
changed. And since we don't set it at the beginning we
need to check it here. */
if (!debug_inited) {
debug_inited = 1;
return;
}
level = gtk_radio_action_get_current_value(action);
if (!slurm_set_debug_level(level)) {
temp = g_strdup_printf(
"Slurmctld debug level is now set to %d", level);
} else
temp = g_strdup_printf("Problem with set debug level request");
display_edit_note(temp);
g_free(temp);
}
extern void create_create_popup(GtkAction *action, gpointer user_data)
{
GtkWidget *popup = gtk_dialog_new_with_buttons(
"Create",
GTK_WINDOW(user_data),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
NULL);
int i, response = 0;
GtkWidget *label = NULL;
GtkWidget *entry = NULL;
GtkTreeModel *model = NULL;
GtkTreeIter iter;
const gchar *name = gtk_action_get_name(action);
sview_search_info_t sview_search_info;
job_desc_msg_t *job_msg = NULL;
submit_response_msg_t *slurm_alloc_msg = NULL;
update_part_msg_t *part_msg = NULL;
resv_desc_msg_t *resv_msg = NULL;
char *res_name, *temp;
sview_search_info.gchar_data = NULL;
sview_search_info.int_data = NO_VAL;
sview_search_info.int_data2 = NO_VAL;
label = gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_window_set_default(GTK_WINDOW(popup), label);
gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_window_set_default_size(GTK_WINDOW(popup), 400, 600);
if (!strcmp(name, "batch_job")) {
sview_search_info.search_type = CREATE_BATCH_JOB;
entry = create_entry();
label = gtk_label_new(
"Batch job submission specifications\n\n"
"Specify size (task and/or node count) plus the\n"
"script. All other fields are optional.\n\n"
"More fields will be made available later.");
job_msg = xmalloc(sizeof(job_desc_msg_t));
slurm_init_job_desc_msg(job_msg);
job_msg->group_id = getgid();
job_msg->user_id = getuid();
job_msg->work_dir = xmalloc(1024);
if (!getcwd(job_msg->work_dir, 1024))
goto end_it;
entry = create_job_entry(job_msg, model, &iter);
} else if (!strcmp(name, "partition")) {
sview_search_info.search_type = CREATE_PARTITION;
entry = create_entry();
label = gtk_label_new(
"Partition creation specifications\n\n"
"Specify Name. All other fields are optional.");
part_msg = xmalloc(sizeof(update_part_msg_t));
slurm_init_part_desc_msg(part_msg);
entry = create_part_entry(part_msg, model, &iter);
} else if (!strcmp(name, "reservation")) {
sview_search_info.search_type = CREATE_RESERVATION;
label = gtk_label_new(
"Reservation creation specifications\n\n"
"Specify Time_Start and either Duration or Time_End.\n"
#ifdef HAVE_BG
"Specify either Node_Count or Midplane_List.\n"
#else
"Specify either Node_Count or Node_List.\n"
#endif
"Specify either Accounts or Users.\n\n"
"Supported Flags include: Maintenance, Overlap,\n"
"Ignore_Jobs, Daily and Weekly, License_Only\n"
"and Static_Alloc.\n"
"All other fields are optional.");
resv_msg = xmalloc(sizeof(resv_desc_msg_t));
slurm_init_resv_desc_msg(resv_msg);
entry = create_resv_entry(resv_msg, model, &iter);
} else {
sview_search_info.search_type = 0;
goto end_it;
}
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
entry, TRUE, TRUE, 0);
gtk_widget_show_all(popup);
response = gtk_dialog_run (GTK_DIALOG(popup));
if (response == GTK_RESPONSE_OK) {
if (!sview_search_info.search_type)
goto end_it;
switch(sview_search_info.search_type) {
case CREATE_BATCH_JOB:
response = slurm_submit_batch_job(job_msg,
&slurm_alloc_msg);
if (response == SLURM_SUCCESS) {
temp = g_strdup_printf(
"Job %u submitted",
slurm_alloc_msg->job_id);
} else {
temp = g_strdup_printf(
"Problem submitting job: %s",
slurm_strerror(slurm_get_errno()));
}
display_edit_note(temp);
g_free(temp);
break;
case CREATE_PARTITION:
response = slurm_create_partition(part_msg);
if (response == SLURM_SUCCESS) {
temp = g_strdup_printf("Partition %s created",
part_msg->name);
} else {
temp = g_strdup_printf(
"Problem creating partition: %s",
slurm_strerror(slurm_get_errno()));
}
display_edit_note(temp);
g_free(temp);
break;
case CREATE_RESERVATION:
res_name = slurm_create_reservation(resv_msg);
if (res_name) {
temp = g_strdup_printf(
"Reservation %s created",
res_name);
free(res_name);
} else {
temp = g_strdup_printf(
"Problem creating reservation: %s",
slurm_strerror(slurm_get_errno()));
}
display_edit_note(temp);
g_free(temp);
break;
default:
break;
}
}
end_it:
gtk_widget_destroy(popup);
if (slurm_alloc_msg)
slurm_free_submit_response_response_msg(slurm_alloc_msg);
if (job_msg) {
for (i = 0; i < job_msg->argc; i++)
xfree(job_msg->argv[i]);
xfree(job_msg->argv);
xfree(job_msg->name);
xfree(job_msg->script);
xfree(job_msg->work_dir);
xfree(job_msg);
}
xfree(part_msg);
if (resv_msg)
slurm_free_resv_desc_msg(resv_msg);
return;
}
static void _admin_resv(GtkTreeModel *model, GtkTreeIter *iter, char *type)
{
resv_desc_msg_t *resv_msg = xmalloc(sizeof(resv_desc_msg_t));
reservation_name_msg_t resv_name_msg;
char *resvid = NULL;
char tmp_char[100];
char *temp = NULL;
int edit_type = 0;
int response = 0;
GtkWidget *label = NULL;
GtkWidget *entry = NULL;
GtkWidget *popup = gtk_dialog_new_with_buttons(
type,
GTK_WINDOW(main_window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
NULL);
gtk_window_set_transient_for(GTK_WINDOW(popup), NULL);
gtk_tree_model_get(model, iter, SORTID_NAME, &resvid, -1);
slurm_init_resv_desc_msg(resv_msg);
memset(&resv_name_msg, 0, sizeof(reservation_name_msg_t));
resv_msg->name = xstrdup(resvid);
if (!strcasecmp("Remove Reservation", type)) {
resv_name_msg.name = resvid;
label = gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_YES, GTK_RESPONSE_OK);
gtk_window_set_default(GTK_WINDOW(popup), label);
gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
snprintf(tmp_char, sizeof(tmp_char),
"Are you sure you want to remove "
"reservation %s?",
resvid);
label = gtk_label_new(tmp_char);
edit_type = EDIT_REMOVE;
} else {
label = gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_window_set_default(GTK_WINDOW(popup), label);
gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_window_set_default_size(GTK_WINDOW(popup), 200, 400);
snprintf(tmp_char, sizeof(tmp_char),
"Editing reservation %s think before you type",
resvid);
label = gtk_label_new(tmp_char);
edit_type = EDIT_EDIT;
entry = _admin_full_edit_resv(resv_msg, model, iter);
}
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
label, FALSE, FALSE, 0);
if (entry)
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
entry, TRUE, TRUE, 0);
gtk_widget_show_all(popup);
response = gtk_dialog_run (GTK_DIALOG(popup));
if (response == GTK_RESPONSE_OK) {
switch(edit_type) {
case EDIT_REMOVE:
if (slurm_delete_reservation(&resv_name_msg)
== SLURM_SUCCESS) {
temp = g_strdup_printf(
"Reservation %s removed successfully",
resvid);
} else {
temp = g_strdup_printf(
"Problem removing reservation %s.",
resvid);
}
display_edit_note(temp);
g_free(temp);
break;
case EDIT_EDIT:
if (got_edit_signal)
goto end_it;
if (!global_send_update_msg) {
temp = g_strdup_printf("No change detected.");
} else if (slurm_update_reservation(resv_msg)
== SLURM_SUCCESS) {
temp = g_strdup_printf(
"Reservation %s updated successfully",
resvid);
} else {
temp = g_strdup_printf(
"Problem updating reservation %s.",
resvid);
}
display_edit_note(temp);
g_free(temp);
break;
default:
break;
}
}
end_it:
g_free(resvid);
global_entry_changed = 0;
slurm_free_resv_desc_msg(resv_msg);
gtk_widget_destroy(popup);
if (got_edit_signal) {
type = got_edit_signal;
got_edit_signal = NULL;
_admin_resv(model, iter, type);
xfree(type);
}
return;
}
extern void admin_edit_resv(GtkCellRendererText *cell,
const char *path_string,
const char *new_text,
gpointer data)
{
GtkTreeStore *treestore = GTK_TREE_STORE(data);
GtkTreePath *path = gtk_tree_path_new_from_string(path_string);
GtkTreeIter iter;
resv_desc_msg_t *resv_msg = xmalloc(sizeof(resv_desc_msg_t));
char *temp = NULL;
char *old_text = NULL;
const char *type = NULL;
int column = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(cell),
"column"));
if (!new_text || !strcmp(new_text, ""))
goto no_input;
gtk_tree_model_get_iter(GTK_TREE_MODEL(treestore), &iter, path);
slurm_init_resv_desc_msg(resv_msg);
gtk_tree_model_get(GTK_TREE_MODEL(treestore), &iter,
SORTID_NAME, &temp,
column, &old_text,
-1);
resv_msg->name = xstrdup(temp);
g_free(temp);
type = _set_resv_msg(resv_msg, new_text, column);
if (global_edit_error)
goto print_error;
if (got_edit_signal) {
temp = got_edit_signal;
got_edit_signal = NULL;
_admin_resv(GTK_TREE_MODEL(treestore), &iter, temp);
xfree(temp);
goto no_input;
}
if (old_text && !strcmp(old_text, new_text)) {
temp = g_strdup_printf("No change in value.");
} else if (slurm_update_reservation(resv_msg)
== SLURM_SUCCESS) {
gtk_tree_store_set(treestore, &iter, column, new_text, -1);
temp = g_strdup_printf("Reservation %s %s changed to %s",
resv_msg->name,
type,
new_text);
} else if (errno == ESLURM_DISABLED) {
temp = g_strdup_printf(
"Can only edit %s on reservations not yet started.",
type);
} else {
print_error:
temp = g_strdup_printf("Reservation %s %s can't be "
"set to %s",
resv_msg->name,
type,
new_text);
}
display_edit_note(temp);
g_free(temp);
no_input:
slurm_free_resv_desc_msg(resv_msg);
gtk_tree_path_free (path);
g_free(old_text);
g_mutex_unlock(sview_mutex);
}
static void _admin_front_end(GtkTreeModel *model, GtkTreeIter *iter, char *type,
char *node_list)
{
uint16_t state = (uint16_t) NO_VAL;
update_front_end_msg_t front_end_update_msg;
char *new_type = NULL, *reason = NULL;
char tmp_char[100];
char *lower;
int rc;
GtkWidget *label = NULL;
GtkWidget *entry = NULL;
GtkWidget *popup = NULL;
if (cluster_flags & CLUSTER_FLAG_FED) {
display_fed_disabled_popup(type);
global_entry_changed = 0;
return;
}
popup = gtk_dialog_new_with_buttons(
type,
GTK_WINDOW(main_window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
NULL);
gtk_window_set_transient_for(GTK_WINDOW(popup), NULL);
label = gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_YES, GTK_RESPONSE_OK);
gtk_window_set_default(GTK_WINDOW(popup), label);
gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
if (!strncasecmp("Drain", type, 5)) {
new_type = "DRAIN";
reason = "\n\nPlease enter reason.";
state = NODE_STATE_DRAIN;
entry = create_entry();
} else if (!strncasecmp("Resume", type, 6)) {
new_type = "RESUME";
reason = "";
state = NODE_RESUME;
}
snprintf(tmp_char, sizeof(tmp_char),
"Are you sure you want to set state of front end node %s "
"to %s?%s", node_list, new_type, reason);
label = gtk_label_new(tmp_char);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
label, false, false, 0);
if (entry)
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
entry, true, true, 0);
gtk_widget_show_all(popup);
rc = gtk_dialog_run (GTK_DIALOG(popup));
slurm_init_update_front_end_msg(&front_end_update_msg);
if (rc == GTK_RESPONSE_OK) {
front_end_update_msg.name = node_list;
front_end_update_msg.node_state = state;
if (entry) {
front_end_update_msg.reason = xstrdup(
gtk_entry_get_text(GTK_ENTRY(entry)));
if (!front_end_update_msg.reason ||
!strlen(front_end_update_msg.reason)) {
lower = g_strdup_printf(
"You need a reason to do that.");
display_edit_note(lower);
g_free(lower);
goto end_it;
}
rc = uid_from_string(getlogin(),
&front_end_update_msg.reason_uid);
if (rc < 0)
front_end_update_msg.reason_uid = getuid();
}
rc = slurm_update_front_end(&front_end_update_msg);
if (rc == SLURM_SUCCESS) {
lower = g_strdup_printf(
"Nodes %s updated successfully.",
node_list);
display_edit_note(lower);
g_free(lower);
} else {
lower = g_strdup_printf(
"Problem updating nodes %s: %s",
node_list, slurm_strerror(rc));
display_edit_note(lower);
g_free(lower);
}
}
end_it:
global_entry_changed = 0;
xfree(front_end_update_msg.reason);
gtk_widget_destroy(popup);
if (got_edit_signal) {
type = got_edit_signal;
got_edit_signal = NULL;
_admin_front_end(model, iter, type, node_list);
xfree(type);
}
return;
}
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);
}
/*
* _parse_flags is used to parse the Flags= option. It handles
* daily, weekly, and maint, optionally preceded by + or -,
* separated by a comma but no spaces.
*/
static uint32_t _parse_flags(const char *flagstr)
{
int flip;
uint32_t outflags = 0;
const char *curr = flagstr;
int taglen = 0;
while (*curr != '\0') {
flip = 0;
if (*curr == '+') {
curr++;
} else if (*curr == '-') {
flip = 1;
curr++;
}
taglen = 0;
while (curr[taglen] != ',' && curr[taglen] != '\0')
taglen++;
if (strncasecmp(curr, "Maintenance", MAX(taglen,1)) == 0) {
curr += taglen;
if (flip)
outflags |= RESERVE_FLAG_NO_MAINT;
else
outflags |= RESERVE_FLAG_MAINT;
} else if ((strncasecmp(curr, "Overlap",MAX(taglen,1))
== 0) && (!flip)) {
curr += taglen;
outflags |= RESERVE_FLAG_OVERLAP;
} else if (strncasecmp(curr, "Ignore_Jobs", MAX(taglen,1))
== 0) {
curr += taglen;
if (flip)
outflags |= RESERVE_FLAG_NO_IGN_JOB;
else
outflags |= RESERVE_FLAG_IGN_JOBS;
} else if (strncasecmp(curr, "Daily", MAX(taglen,1)) == 0) {
curr += taglen;
if (flip)
outflags |= RESERVE_FLAG_NO_DAILY;
else
outflags |= RESERVE_FLAG_DAILY;
} else if (strncasecmp(curr, "Weekly", MAX(taglen,1)) == 0) {
curr += taglen;
if (flip)
outflags |= RESERVE_FLAG_NO_WEEKLY;
else
outflags |= RESERVE_FLAG_WEEKLY;
} else if (strncasecmp(curr, "License_Only", MAX(taglen,1))
== 0) {
curr += taglen;
if (flip)
outflags |= RESERVE_FLAG_NO_LIC_ONLY;
else
outflags |= RESERVE_FLAG_LIC_ONLY;
} else {
char *temp = g_strdup_printf("Error parsing flags %s.",
flagstr);
display_edit_note(temp);
g_free(temp);
outflags = (uint32_t)NO_VAL;
break;
}
if (*curr == ',')
curr++;
}
return outflags;
}
extern int configure_defaults(void)
{
GtkScrolledWindow *window = create_scrolled_window();
GtkWidget *popup = gtk_dialog_new_with_buttons(
"Sview Defaults",
GTK_WINDOW(main_window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
NULL);
GtkWidget *label = gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_OK, GTK_RESPONSE_OK);
GtkBin *bin = NULL;
GtkViewport *view = NULL;
GtkTable *table = NULL;
int i = 0, row = 0;
char tmp_char[100];
char *tmp_char_ptr;
display_data_t *display_data = display_data_defaults;
sview_config_t tmp_config;
int response = 0;
int rc = SLURM_SUCCESS;
uint32_t width = 150;
uint32_t height = 700;
apply_hidden_change = TRUE;
memcpy(&tmp_config, &default_sview_config, sizeof(sview_config_t));
gtk_window_set_default(GTK_WINDOW(popup), label);
gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
/*
for(i=0;; i++) {
if (main_popup_positioner[i].width == -1)
break;
if (strstr("Sview Defaults", main_popup_positioner[i].name)) {
pos_x = main_popup_positioner[i].width;
pos_y = main_popup_positioner[i].height;
break;
}
}
*/
gtk_window_set_default_size(GTK_WINDOW(popup), width, height);
snprintf(tmp_char, sizeof(tmp_char),
"Default Settings for Sview");
label = gtk_label_new(tmp_char);
gtk_scrolled_window_set_policy(window,
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
bin = GTK_BIN(&window->container);
view = GTK_VIEWPORT(bin->child);
bin = GTK_BIN(&view->bin);
table = GTK_TABLE(bin->child);
gtk_table_resize(table, SORTID_CNT, 2);
gtk_table_set_homogeneous(table, FALSE);
for (i = 0; i < SORTID_CNT; i++) {
while (display_data++) {
if (display_data->id == -1)
break;
if (!display_data->name)
continue;
if (display_data->id != i)
continue;
_local_display_admin_edit(
table, &tmp_config, &row,
display_data);
break;
}
display_data = display_data_defaults;
}
gtk_table_resize(table, row, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
label, FALSE, FALSE, 0);
if (window)
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
GTK_WIDGET(window), TRUE, TRUE, 0);
gtk_widget_show_all(popup);
response = gtk_dialog_run (GTK_DIALOG(popup));
if (response == GTK_RESPONSE_OK) {
tmp_char_ptr = g_strdup_printf(
"Defaults updated successfully");
if (global_edit_error)
tmp_char_ptr = global_edit_error_msg;
else if (!global_send_update_msg)
tmp_char_ptr = g_strdup_printf(
"No change detected.");
else {
int action = 0;
gdk_window_set_cursor(main_window->window,
in_process_cursor);
if (tmp_config.ruled_treeview
!= working_sview_config.ruled_treeview) {
/* get rid of each existing table */
cluster_change_block();
cluster_change_resv();
cluster_change_part();
cluster_change_job();
cluster_change_node();
cluster_change_front_end();
} else if (tmp_config.grid_topological !=
working_sview_config.grid_topological) {
apply_hidden_change = FALSE;
if (tmp_config.grid_topological) {
default_sview_config.grid_topological =
tmp_config.grid_topological;
if (!g_switch_nodes_maps)
rc = get_topo_conf();
if (rc != SLURM_SUCCESS) {
/*denied*/
tmp_char_ptr = g_strdup_printf(
"Valid topology not "
"detected");
tmp_config.grid_topological =
FALSE;
goto denied_change;
}
}
/*force fresh grid and
* node state check
* */
FREE_NULL_LIST(grid_button_list);
slurm_free_node_info_msg(g_node_info_ptr);
g_node_info_ptr = NULL;
}
/*apply change*/
memcpy(&default_sview_config, &tmp_config,
sizeof(sview_config_t));
memcpy(&working_sview_config, &tmp_config,
sizeof(sview_config_t));
/* set the current display to the default */
gtk_toggle_action_set_active(
default_sview_config.action_admin,
working_sview_config.admin_mode);
gtk_toggle_action_set_active(
default_sview_config.action_ruled,
working_sview_config.ruled_treeview);
gtk_toggle_action_set_active(
default_sview_config.action_grid,
working_sview_config.show_grid);
gtk_toggle_action_set_active(
default_sview_config.action_hidden,
working_sview_config.show_hidden);
apply_hidden_change = TRUE;
gtk_toggle_action_set_active(
default_sview_config.action_page_opts,
working_sview_config.save_page_opts);
#ifdef GTK2_USE_RADIO_SET
/* Since this value isn't a simple 0->n we
need to translate if we don't have the
newer gtk.
*/
action = working_sview_config.tab_pos;
#else
/* If using older gtk we need to translate the
tab position to that of the position in the
radio list.
*/
action = _trans_tab_pos(working_sview_config.tab_pos);
#endif
sview_radio_action_set_current_value(
default_sview_config.action_tab, action);
for (i=0; i<PAGE_CNT; i++) {
if (main_display_data[i].id == -1)
break;
if (!main_display_data[i].name
|| (i == TAB_PAGE))
continue;
toggle_tab_visiblity(NULL, main_display_data+i);
}
get_system_stats(main_grid_table);
/******************************************/
save_defaults(false);
}
denied_change:
display_edit_note(tmp_char_ptr);
g_free(tmp_char_ptr);
}
global_entry_changed = 0;
gtk_widget_destroy(popup);
if (main_window && main_window->window)
gdk_window_set_cursor(main_window->window, NULL);
return rc;
}
extern int update_state_block(GtkDialog *dialog,
const char *blockid, const char *type)
{
int i = 0;
int rc = SLURM_SUCCESS;
char tmp_char[100];
update_block_msg_t block_msg;
GtkWidget *label = NULL;
int no_dialog = 0;
if (!dialog) {
dialog = GTK_DIALOG(
gtk_dialog_new_with_buttons(
type,
GTK_WINDOW(main_window),
GTK_DIALOG_MODAL
| GTK_DIALOG_DESTROY_WITH_PARENT,
NULL));
no_dialog = 1;
}
slurm_init_update_block_msg(&block_msg);
block_msg.bg_block_id = (char *)blockid;
label = gtk_dialog_add_button(dialog,
GTK_STOCK_YES, GTK_RESPONSE_OK);
gtk_window_set_default(GTK_WINDOW(dialog), label);
gtk_dialog_add_button(dialog,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
if (!xstrcasecmp("Error", type) ||
!xstrcasecmp("Put block in error state", type)) {
snprintf(tmp_char, sizeof(tmp_char),
"Are you sure you want to put block %s "
"in an error state?",
blockid);
block_msg.state = BG_BLOCK_ERROR_FLAG;
} else if (!xstrcasecmp("Recreate block", type)) {
snprintf(tmp_char, sizeof(tmp_char),
"Are you sure you want to recreate block %s?",
blockid);
block_msg.state = BG_BLOCK_BOOTING;
} else if (!xstrcasecmp("Remove block", type)) {
snprintf(tmp_char, sizeof(tmp_char),
"Are you sure you want to remove block %s?",
blockid);
block_msg.state = BG_BLOCK_NAV;
} else if (!xstrcasecmp("Resume block", type)) {
snprintf(tmp_char, sizeof(tmp_char),
"Are you sure you want to resume block %s?",
blockid);
block_msg.state = BG_BLOCK_TERM;
} else {
snprintf(tmp_char, sizeof(tmp_char),
"Are you sure you want to put block %s "
"in a free state?",
blockid);
block_msg.state = BG_BLOCK_FREE;
}
label = gtk_label_new(tmp_char);
gtk_box_pack_start(GTK_BOX(dialog->vbox), label, FALSE, FALSE, 0);
gtk_widget_show_all(GTK_WIDGET(dialog));
i = gtk_dialog_run(dialog);
if (i == GTK_RESPONSE_OK) {
if (slurm_update_block(&block_msg)
== SLURM_SUCCESS) {
snprintf(tmp_char, sizeof(tmp_char),
"Block %s updated successfully",
blockid);
} else {
snprintf(tmp_char, sizeof(tmp_char),
"Problem updating block %s.",
blockid);
}
display_edit_note(tmp_char);
}
if (no_dialog)
gtk_widget_destroy(GTK_WIDGET(dialog));
return rc;
}
