| /****************************************************************************\ | |
| * defaults.c - put default configuration information here | |
| ***************************************************************************** | |
| * Copyright (C) 2004-2007 The Regents of the University of California. | |
| * Copyright (C) 2008-2010 Lawrence Livermore National Security. | |
| * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER). | |
| * Written by Danny Auble <da@llnl.gov>, et. al. | |
| * CODE-OCEC-09-009. All rights reserved. | |
| * | |
| * This file is part of Slurm, a resource management program. | |
| * For details, see <https://slurm.schedmd.com/>. | |
| * Please also read the included file: DISCLAIMER. | |
| * | |
| * Slurm is free software; you can redistribute it and/or modify it under | |
| * the terms of the GNU General Public License as published by the Free | |
| * Software Foundation; either version 2 of the License, or (at your option) | |
| * any later version. | |
| * | |
| * In addition, as a special exception, the copyright holders give permission | |
| * to link the code of portions of this program with the OpenSSL library under | |
| * certain conditions as described in each individual source file, and | |
| * distribute linked combinations including the two. You must obey the GNU | |
| * General Public License in all respects for all of the code used other than | |
| * OpenSSL. If you modify file(s) with this exception, you may extend this | |
| * exception to your version of the file(s), but you are not obligated to do | |
| * so. If you do not wish to do so, delete this exception statement from your | |
| * version. If you delete this exception statement from all source files in | |
| * the program, then also delete it here. | |
| * | |
| * Slurm is distributed in the hope that it will be useful, but WITHOUT ANY | |
| * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS | |
| * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more | |
| * details. | |
| * | |
| * You should have received a copy of the GNU General Public License along | |
| * with Slurm; if not, write to the Free Software Foundation, Inc., | |
| * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. | |
| \*****************************************************************************/ | |
| #include "config.h" | |
| #include <fcntl.h> | |
| #include "sview.h" | |
| #include "src/common/parse_config.h" | |
| #include "src/common/xstring.h" | |
| /* These need to be in alpha order (except POS and CNT) */ | |
| enum { | |
| SORTID_POS = POS_LOC, | |
| SORTID_ADMIN, | |
| SORTID_BUTTON_SIZE, | |
| SORTID_DEFAULT_PAGE, | |
| SORTID_GRID_HORI, | |
| SORTID_GRID_VERT, | |
| SORTID_GRID_X_WIDTH, | |
| SORTID_GRID_TOPO_ORDER, | |
| SORTID_PAGE_VISIBLE, | |
| SORTID_REFRESH_DELAY, | |
| SORTID_RULED_TV, | |
| SORTID_SHOW_GRID, | |
| SORTID_SHOW_HIDDEN, | |
| SORTID_SAVE_PAGE_OPTS, | |
| SORTID_TAB_POS, | |
| SORTID_CNT | |
| }; | |
| /* extra field here is for choosing the type of edit you that will | |
| * take place. If you choose EDIT_MODEL (means only display a set of | |
| * known options) create it in function create_model_*. | |
| */ | |
| static display_data_t display_data_defaults[] = { | |
| {G_TYPE_INT, SORTID_POS, NULL, false, EDIT_NONE, NULL}, | |
| {G_TYPE_STRING, SORTID_ADMIN, "Start in Admin Mode", | |
| true, EDIT_MODEL, NULL, create_model_defaults, NULL}, | |
| {G_TYPE_STRING, SORTID_BUTTON_SIZE, "Node Button Size in Pixels", | |
| true, EDIT_TEXTBOX, NULL, create_model_defaults, NULL}, | |
| {G_TYPE_STRING, SORTID_DEFAULT_PAGE, "Default Page", | |
| true, EDIT_MODEL, NULL, create_model_defaults, NULL}, | |
| {G_TYPE_STRING, SORTID_GRID_HORI, "Grid: Nodes before Horizontal break", | |
| true, EDIT_TEXTBOX, NULL, create_model_defaults, NULL}, | |
| {G_TYPE_STRING, SORTID_GRID_VERT, "Grid: Nodes before Vertical break", | |
| true, EDIT_TEXTBOX, NULL, create_model_defaults, NULL}, | |
| {G_TYPE_STRING, SORTID_GRID_X_WIDTH, "Grid: Nodes in Row", | |
| true, EDIT_TEXTBOX, NULL, create_model_defaults, NULL}, | |
| {G_TYPE_STRING, SORTID_GRID_TOPO_ORDER, "Grid: Topology Order", | |
| true, EDIT_MODEL, NULL, create_model_defaults, NULL}, | |
| {G_TYPE_STRING, SORTID_PAGE_VISIBLE, "Visible Pages", | |
| true, EDIT_ARRAY, NULL, create_model_defaults, NULL}, | |
| {G_TYPE_STRING, SORTID_REFRESH_DELAY, "Refresh Delay in Secs", | |
| true, EDIT_TEXTBOX, NULL, create_model_defaults, NULL}, | |
| {G_TYPE_STRING, SORTID_RULED_TV, "Ruled Tables", | |
| true, EDIT_MODEL, NULL, create_model_defaults, NULL}, | |
| {G_TYPE_STRING, SORTID_SHOW_GRID, "Show Grid", | |
| true, EDIT_MODEL, NULL, create_model_defaults, NULL}, | |
| {G_TYPE_STRING, SORTID_SHOW_HIDDEN, "Show Hidden", | |
| true, EDIT_MODEL, NULL, create_model_defaults, NULL}, | |
| {G_TYPE_STRING, SORTID_SAVE_PAGE_OPTS, "Save Page Settings", | |
| true, EDIT_MODEL, NULL, create_model_defaults, NULL}, | |
| {G_TYPE_STRING, SORTID_TAB_POS, "Tab Position", | |
| true, EDIT_MODEL, NULL, create_model_defaults, NULL}, | |
| {G_TYPE_NONE, -1, NULL, false, EDIT_NONE} | |
| }; | |
| extern display_data_t main_display_data[]; | |
| static int _trans_tab_pos(int tab_pos) | |
| { | |
| /* default to TOP if unknown is given */ | |
| switch (tab_pos) { | |
| case GTK_POS_TOP: | |
| return 0; | |
| case GTK_POS_BOTTOM: | |
| return 1; | |
| case GTK_POS_LEFT: | |
| return 2; | |
| case GTK_POS_RIGHT: | |
| return 3; | |
| default: | |
| return 0; | |
| } | |
| return 0; | |
| } | |
| static void _set_active_combo_defaults(GtkComboBox *combo, | |
| sview_config_t *sview_config, | |
| int type) | |
| { | |
| int action = 0; | |
| switch(type) { | |
| case SORTID_ADMIN: | |
| action = sview_config->admin_mode; | |
| break; | |
| case SORTID_GRID_TOPO_ORDER: | |
| action = sview_config->grid_topological; | |
| break; | |
| case SORTID_RULED_TV: | |
| action = sview_config->ruled_treeview; | |
| break; | |
| case SORTID_SHOW_GRID: | |
| action = sview_config->show_grid; | |
| break; | |
| case SORTID_SHOW_HIDDEN: | |
| action = sview_config->show_hidden; | |
| break; | |
| case SORTID_SAVE_PAGE_OPTS: | |
| action = sview_config->save_page_opts; | |
| break; | |
| case SORTID_DEFAULT_PAGE: | |
| action = sview_config->default_page; | |
| break; | |
| case SORTID_TAB_POS: | |
| action = _trans_tab_pos(sview_config->tab_pos); | |
| break; | |
| default: | |
| break; | |
| } | |
| gtk_combo_box_set_active(combo, action); | |
| } | |
| static const char *_set_sview_config(sview_config_t *sview_config, | |
| const char *new_text, int column) | |
| { | |
| char *type = ""; | |
| int temp_int = 0; | |
| /* need to clear global_edit_error here (just in case) */ | |
| global_edit_error = 0; | |
| if (!sview_config) | |
| return NULL; | |
| switch(column) { | |
| case SORTID_ADMIN: | |
| type = "Admin Mode"; | |
| if (!xstrcasecmp(new_text, "yes")) | |
| sview_config->admin_mode = 1; | |
| else | |
| sview_config->admin_mode = 0; | |
| break; | |
| case SORTID_BUTTON_SIZE: | |
| type = "Button Size"; | |
| temp_int = strtol(new_text, (char **)NULL, 10); | |
| if ((temp_int <= 0) && (temp_int != INFINITE)) | |
| goto return_error; | |
| sview_config->button_size = temp_int; | |
| sview_config->gap_size = MIN(temp_int/2, 2); | |
| break; | |
| case SORTID_DEFAULT_PAGE: | |
| if (!xstrcasecmp(new_text, "job")) | |
| sview_config->default_page = JOB_PAGE; | |
| else if (!xstrcasecmp(new_text, "part")) | |
| sview_config->default_page = PART_PAGE; | |
| else if (!xstrcasecmp(new_text, "res")) | |
| sview_config->default_page = RESV_PAGE; | |
| else if (!xstrcasecmp(new_text, "node")) | |
| sview_config->default_page = NODE_PAGE; | |
| else if (!xstrcasecmp(new_text, "burstbuffer")) | |
| sview_config->default_page = BB_PAGE; | |
| else | |
| sview_config->default_page = JOB_PAGE; | |
| break; | |
| case SORTID_GRID_HORI: | |
| temp_int = strtol(new_text, (char **)NULL, 10); | |
| if (temp_int <= 0) | |
| goto return_error; | |
| sview_config->grid_hori = temp_int; | |
| break; | |
| case SORTID_GRID_VERT: | |
| temp_int = strtol(new_text, (char **)NULL, 10); | |
| if (temp_int <= 0) | |
| goto return_error; | |
| sview_config->grid_vert = temp_int; | |
| break; | |
| case SORTID_GRID_X_WIDTH: | |
| temp_int = strtol(new_text, (char **)NULL, 10); | |
| if (temp_int <= 0) | |
| goto return_error; | |
| sview_config->grid_x_width = temp_int; | |
| break; | |
| case SORTID_PAGE_VISIBLE: | |
| break; | |
| case SORTID_REFRESH_DELAY: | |
| type = "Refresh Delay"; | |
| temp_int = strtol(new_text, (char **)NULL, 10); | |
| if ((temp_int <= 0) && (temp_int != INFINITE)) | |
| goto return_error; | |
| sview_config->refresh_delay = temp_int; | |
| break; | |
| case SORTID_RULED_TV: | |
| type = "Ruled Tables"; | |
| if (!xstrcasecmp(new_text, "yes")) | |
| sview_config->ruled_treeview = 1; | |
| else | |
| sview_config->ruled_treeview = 0; | |
| break; | |
| case SORTID_SHOW_GRID: | |
| type = "Show Grid"; | |
| if (!xstrcasecmp(new_text, "yes")) | |
| sview_config->show_grid = 1; | |
| else | |
| sview_config->show_grid = 0; | |
| break; | |
| case SORTID_GRID_TOPO_ORDER: | |
| type = "Topology order"; | |
| if (!xstrcasecmp(new_text, "yes")) | |
| sview_config->grid_topological = 1; | |
| else | |
| sview_config->grid_topological = 0; | |
| break; | |
| case SORTID_SHOW_HIDDEN: | |
| type = "Show Hidden"; | |
| if (!xstrcasecmp(new_text, "yes")) | |
| sview_config->show_hidden = 1; | |
| else | |
| sview_config->show_hidden = 0; | |
| break; | |
| case SORTID_SAVE_PAGE_OPTS: | |
| type = "Save Page Settings"; | |
| if (!xstrcasecmp(new_text, "yes")) | |
| sview_config->save_page_opts = 1; | |
| else | |
| sview_config->save_page_opts = 0; | |
| break; | |
| case SORTID_TAB_POS: | |
| type = "Tab Position"; | |
| if (!xstrcasecmp(new_text, "top")) { | |
| sview_config->tab_pos = GTK_POS_TOP; | |
| } else if (!xstrcasecmp(new_text, "bottom")) { | |
| sview_config->tab_pos = GTK_POS_BOTTOM; | |
| } else if (!xstrcasecmp(new_text, "left")) { | |
| sview_config->tab_pos = GTK_POS_LEFT; | |
| } else if (!xstrcasecmp(new_text, "right")) | |
| sview_config->tab_pos = GTK_POS_RIGHT; | |
| else | |
| goto return_error; | |
| break; | |
| default: | |
| type = "unknown"; | |
| break; | |
| } | |
| if (xstrcmp(type, "unknown")) { | |
| global_send_update_msg = 1; | |
| } | |
| return type; | |
| return_error: | |
| global_edit_error = 1; | |
| return type; | |
| } | |
| static void _admin_focus_toggle(GtkToggleButton *toggle_button, | |
| bool *visible) | |
| { | |
| if (visible) { | |
| (*visible) = gtk_toggle_button_get_active(toggle_button); | |
| global_send_update_msg = 1; | |
| } | |
| } | |
| static void _admin_edit_combo_box_defaults(GtkComboBox *combo, | |
| sview_config_t *sview_config) | |
| { | |
| GtkTreeModel *model = NULL; | |
| GtkTreeIter iter; | |
| int column = 0; | |
| char *name = NULL; | |
| if (!sview_config) | |
| return; | |
| 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, 0, &name, -1); | |
| gtk_tree_model_get(model, &iter, 1, &column, -1); | |
| _set_sview_config(sview_config, name, column); | |
| g_free(name); | |
| } | |
| static gboolean _admin_focus_out_defaults(GtkEntry *entry, | |
| GdkEventFocus *event, | |
| sview_config_t *sview_config) | |
| { | |
| if (global_entry_changed) { | |
| const char *col_name = NULL; | |
| int type = gtk_entry_get_max_length(entry); | |
| const char *name = gtk_entry_get_text(entry); | |
| type -= DEFAULT_ENTRY_LENGTH; | |
| col_name = _set_sview_config(sview_config, name, type); | |
| if (global_edit_error) { | |
| if (global_edit_error_msg) | |
| g_free(global_edit_error_msg); | |
| global_edit_error_msg = g_strdup_printf( | |
| "Default for %s can't be set to %s", | |
| col_name, | |
| name); | |
| } | |
| global_entry_changed = 0; | |
| } | |
| return false; | |
| } | |
| static void _local_display_admin_edit(GtkTable *table, | |
| sview_config_t *sview_config, int *row, | |
| display_data_t *display_data) | |
| { | |
| GtkWidget *label = NULL; | |
| GtkWidget *entry = NULL; | |
| if (display_data->extra == EDIT_MODEL) { | |
| /* edittable items that can only be known | |
| values */ | |
| GtkCellRenderer *renderer = NULL; | |
| GtkTreeModel *model2 = GTK_TREE_MODEL( | |
| create_model_defaults(display_data->id)); | |
| if (!model2) { | |
| g_print("no model set up for %d(%s)\n", | |
| display_data->id, | |
| display_data->name); | |
| return; | |
| } | |
| entry = gtk_combo_box_new_with_model(model2); | |
| g_object_unref(model2); | |
| _set_active_combo_defaults(GTK_COMBO_BOX(entry), sview_config, | |
| display_data->id); | |
| g_signal_connect(entry, "changed", | |
| G_CALLBACK(_admin_edit_combo_box_defaults), | |
| sview_config); | |
| renderer = gtk_cell_renderer_text_new(); | |
| gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(entry), | |
| renderer, true); | |
| gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(entry), | |
| renderer, "text", 0); | |
| } else if (display_data->extra == EDIT_TEXTBOX) { | |
| char *temp_char = NULL; | |
| /* other edittable items that are unknown */ | |
| entry = create_entry(); | |
| switch(display_data->id) { | |
| case SORTID_GRID_HORI: | |
| temp_char = xstrdup_printf("%u", | |
| sview_config->grid_hori); | |
| break; | |
| case SORTID_GRID_VERT: | |
| temp_char = xstrdup_printf("%u", | |
| sview_config->grid_vert); | |
| break; | |
| case SORTID_GRID_X_WIDTH: | |
| temp_char = xstrdup_printf("%u", | |
| sview_config->grid_x_width); | |
| break; | |
| case SORTID_BUTTON_SIZE: | |
| temp_char = xstrdup_printf("%u", | |
| sview_config->button_size); | |
| break; | |
| case SORTID_REFRESH_DELAY: | |
| temp_char = xstrdup_printf("%u", | |
| sview_config->refresh_delay); | |
| break; | |
| default: | |
| break; | |
| } | |
| gtk_entry_set_max_length(GTK_ENTRY(entry), | |
| (DEFAULT_ENTRY_LENGTH + | |
| display_data->id)); | |
| if (temp_char) { | |
| gtk_entry_set_text(GTK_ENTRY(entry), | |
| temp_char); | |
| xfree(temp_char); | |
| } | |
| g_signal_connect(entry, "focus-out-event", | |
| G_CALLBACK(_admin_focus_out_defaults), | |
| sview_config); | |
| /* set global variable so we know something changed */ | |
| g_signal_connect(entry, "changed", | |
| G_CALLBACK(entry_changed), | |
| NULL); | |
| } else if (display_data->extra == EDIT_ARRAY) { | |
| int i; | |
| switch(display_data->id) { | |
| case SORTID_PAGE_VISIBLE: | |
| label = gtk_label_new(display_data->name); | |
| /* left justify */ | |
| gtk_misc_set_alignment(GTK_MISC(label),0.0,0.5); | |
| gtk_table_attach(table, label, 0, 1, | |
| *row, (*row)+1, | |
| GTK_FILL | GTK_EXPAND, | |
| GTK_SHRINK, 0, 0); | |
| 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; | |
| entry = gtk_check_button_new_with_label( | |
| main_display_data[i].name); | |
| gtk_toggle_button_set_active( | |
| GTK_TOGGLE_BUTTON(entry), | |
| sview_config->page_visible[i]); | |
| g_signal_connect( | |
| G_OBJECT(entry), | |
| "toggled", | |
| G_CALLBACK(_admin_focus_toggle), | |
| &sview_config->page_visible[i]); | |
| gtk_table_attach(table, entry, 1, 2, | |
| *row, (*row)+1, | |
| GTK_FILL, GTK_SHRINK, | |
| 0, 0); | |
| (*row)++; | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| return; | |
| } else /* others can't be altered by the user */ | |
| return; | |
| label = gtk_label_new(display_data->name); | |
| /* left justify */ | |
| gtk_misc_set_alignment(GTK_MISC(label),0.0,0.5); | |
| gtk_table_attach(table, label, 0, 1, *row, (*row)+1, | |
| GTK_FILL | GTK_EXPAND, GTK_SHRINK, | |
| 0, 0); | |
| gtk_table_attach(table, entry, 1, 2, *row, (*row)+1, | |
| GTK_FILL, GTK_SHRINK, | |
| 0, 0); | |
| (*row)++; | |
| } | |
| static int _write_to_file(int fd, char *data) | |
| { | |
| int pos = 0, nwrite = strlen(data), amount; | |
| int rc = SLURM_SUCCESS; | |
| while (nwrite > 0) { | |
| amount = write(fd, &data[pos], nwrite); | |
| if ((amount < 0) && (errno != EINTR)) { | |
| error("Error writing file: %m"); | |
| rc = errno; | |
| break; | |
| } | |
| nwrite -= amount; | |
| pos += amount; | |
| } | |
| return rc; | |
| } | |
| static void _init_sview_conf(void) | |
| { | |
| int i; | |
| default_sview_config.main_width = 1000; | |
| default_sview_config.main_height = 500; | |
| default_sview_config.fi_popup_width = 800; | |
| default_sview_config.fi_popup_height = 500; | |
| default_sview_config.button_size = 10; | |
| default_sview_config.gap_size = 5; | |
| default_sview_config.refresh_delay = 5; | |
| default_sview_config.grid_x_width = 0; | |
| default_sview_config.grid_hori = 10; | |
| default_sview_config.grid_vert = 10; | |
| default_sview_config.show_hidden = 0; | |
| default_sview_config.admin_mode = false; | |
| default_sview_config.grid_topological = false; | |
| default_sview_config.ruled_treeview = false; | |
| default_sview_config.show_grid = true; | |
| default_sview_config.default_page = JOB_PAGE; | |
| default_sview_config.tab_pos = GTK_POS_TOP; | |
| default_sview_config.convert_flags = CONVERT_NUM_UNIT_EXACT; | |
| for(i=0; i<PAGE_CNT; i++) { | |
| memset(&default_sview_config.page_opts[i], | |
| 0, sizeof(page_opts_t)); | |
| if (!main_display_data[i].show) | |
| default_sview_config.page_visible[i] = false; | |
| else | |
| default_sview_config.page_visible[i] = true; | |
| } | |
| } | |
| extern int load_defaults(void) | |
| { | |
| s_p_hashtbl_t *hashtbl = NULL; | |
| s_p_options_t sview_conf_options[] = { | |
| {"AdminMode", S_P_BOOLEAN}, | |
| {"ButtonSize", S_P_UINT16}, | |
| {"DefaultPage", S_P_STRING}, | |
| {"ExcludedPartitions", S_P_STRING}, /* Vestigial */ | |
| {"FullInfoPopupWidth", S_P_UINT32}, | |
| {"FullInfoPopupHeight", S_P_UINT32}, | |
| {"GridHorizontal", S_P_UINT32}, | |
| {"GridSpeedUp", S_P_BOOLEAN}, | |
| {"GridTopo", S_P_BOOLEAN}, | |
| {"GridVertical", S_P_UINT32}, | |
| {"GridXWidth", S_P_UINT32}, | |
| {"MainHeight", S_P_UINT32}, | |
| {"MainWidth", S_P_UINT32}, | |
| {"PageOptsBlock", S_P_STRING}, | |
| {"PageOptsJob", S_P_STRING}, | |
| {"PageOptsNode", S_P_STRING}, | |
| {"PageOptsPartition", S_P_STRING}, | |
| {"PageOptsReservation", S_P_STRING}, | |
| {"PageOptsFrontend", S_P_STRING}, /* Vestigal */ | |
| {"PageOptsBurstBuffer", S_P_STRING}, | |
| {"RefreshDelay", S_P_UINT16}, | |
| {"RuledTables", S_P_BOOLEAN}, | |
| {"SavePageSettings", S_P_BOOLEAN}, | |
| {"ShowGrid", S_P_BOOLEAN}, | |
| {"ShowHidden", S_P_BOOLEAN}, | |
| {"TabPosition", S_P_STRING}, | |
| {"VisiblePages", S_P_STRING}, | |
| {NULL} | |
| }; | |
| char *pathname = NULL; | |
| char *home = getenv("HOME"); | |
| uint32_t hash_val = NO_VAL; | |
| int i, rc = SLURM_SUCCESS; | |
| char *tmp_str; | |
| uint32_t parse_flags = 0; | |
| _init_sview_conf(); | |
| if (!home) | |
| goto end_it; | |
| pathname = xstrdup_printf("%s/.slurm", home); | |
| if ((mkdir(pathname, 0750) < 0) && (errno != EEXIST)) { | |
| error("mkdir(%s): %m", pathname); | |
| rc = SLURM_ERROR; | |
| goto end_it; | |
| } | |
| xstrcat(pathname, "/sviewrc"); | |
| if (access(pathname, R_OK) != 0) { | |
| rc = SLURM_ERROR; | |
| goto end_it; | |
| } | |
| hashtbl = s_p_hashtbl_create(sview_conf_options); | |
| parse_flags |= PARSE_FLAGS_IGNORE_NEW; | |
| if (s_p_parse_file(hashtbl, &hash_val, pathname, parse_flags, NULL) | |
| == SLURM_ERROR) | |
| error("something wrong with opening/reading conf file"); | |
| s_p_get_boolean(&default_sview_config.admin_mode, "AdminMode", hashtbl); | |
| if (s_p_get_uint16(&default_sview_config.button_size, "ButtonSize", | |
| hashtbl)) { | |
| default_sview_config.gap_size = | |
| MAX(default_sview_config.button_size/2, 2); | |
| } | |
| if (s_p_get_string(&tmp_str, "DefaultPage", hashtbl)) { | |
| if (xstrcasestr(tmp_str, "job")) | |
| default_sview_config.default_page = JOB_PAGE; | |
| else if (xstrcasestr(tmp_str, "part")) | |
| default_sview_config.default_page = PART_PAGE; | |
| else if (xstrcasestr(tmp_str, "res")) | |
| default_sview_config.default_page = RESV_PAGE; | |
| else if (xstrcasestr(tmp_str, "node")) | |
| default_sview_config.default_page = NODE_PAGE; | |
| else if (xstrcasestr(tmp_str, "burstbuffer")) | |
| default_sview_config.default_page = BB_PAGE; | |
| xfree(tmp_str); | |
| } | |
| s_p_get_uint32(&default_sview_config.grid_hori, | |
| "GridHorizontal", hashtbl); | |
| s_p_get_boolean(&default_sview_config.grid_topological, | |
| "GridTopo", hashtbl); | |
| if (default_sview_config.grid_topological == 0) | |
| default_sview_config.grid_topological = false; | |
| s_p_get_uint32(&default_sview_config.grid_vert, | |
| "GridVertical", hashtbl); | |
| s_p_get_uint32(&default_sview_config.grid_x_width, | |
| "GridXWidth", hashtbl); | |
| s_p_get_uint16(&default_sview_config.refresh_delay, | |
| "RefreshDelay", hashtbl); | |
| s_p_get_boolean(&default_sview_config.ruled_treeview, | |
| "RuledTables", hashtbl); | |
| s_p_get_boolean(&default_sview_config.show_grid, | |
| "ShowGrid", hashtbl); | |
| s_p_get_boolean(&default_sview_config.show_hidden, | |
| "ShowHidden", hashtbl); | |
| s_p_get_boolean(&default_sview_config.save_page_opts, | |
| "SavePageSettings", hashtbl); | |
| s_p_get_uint32(&default_sview_config.main_width, | |
| "MainWidth", hashtbl); | |
| s_p_get_uint32(&default_sview_config.main_height, | |
| "MainHeight", hashtbl); | |
| s_p_get_uint32(&default_sview_config.fi_popup_width, | |
| "FullInfoPopupWidth", hashtbl); | |
| s_p_get_uint32(&default_sview_config.fi_popup_height, | |
| "FullInfoPopupHeight", hashtbl); | |
| if (s_p_get_string(&tmp_str, "TabPosition", hashtbl)) { | |
| if (xstrcasestr(tmp_str, "top")) | |
| default_sview_config.tab_pos = GTK_POS_TOP; | |
| else if (xstrcasestr(tmp_str, "bottom")) | |
| default_sview_config.tab_pos = GTK_POS_BOTTOM; | |
| else if (xstrcasestr(tmp_str, "left")) | |
| default_sview_config.tab_pos = GTK_POS_LEFT; | |
| else if (xstrcasestr(tmp_str, "right")) | |
| default_sview_config.tab_pos = GTK_POS_RIGHT; | |
| xfree(tmp_str); | |
| } | |
| if (s_p_get_string(&tmp_str, "VisiblePages", hashtbl)) { | |
| int i = 0; | |
| for (i=0; i<PAGE_CNT; i++) | |
| default_sview_config.page_visible[i] = false; | |
| if (xstrcasestr(tmp_str, "job")) | |
| default_sview_config.page_visible[JOB_PAGE] = 1; | |
| if (xstrcasestr(tmp_str, "part")) | |
| default_sview_config.page_visible[PART_PAGE] = 1; | |
| if (xstrcasestr(tmp_str, "res")) | |
| default_sview_config.page_visible[RESV_PAGE] = 1; | |
| if (xstrcasestr(tmp_str, "node")) | |
| default_sview_config.page_visible[NODE_PAGE] = 1; | |
| if (xstrcasestr(tmp_str, "burstbuffer")) | |
| default_sview_config.page_visible[BB_PAGE] = 1; | |
| xfree(tmp_str); | |
| } | |
| /*pull in page options*/ | |
| for (i=0; i<PAGE_CNT; i++) { | |
| char *col_list = NULL; | |
| char *page_name = page_to_str(i); | |
| page_opts_t *page_opts = &default_sview_config.page_opts[i]; | |
| if (!page_name) | |
| continue; | |
| memset(page_opts, 0, sizeof(page_opts_t)); | |
| page_opts->page_name = page_name; | |
| tmp_str = xstrdup_printf("PageOpts%s", page_name); | |
| s_p_get_string(&col_list, tmp_str, hashtbl); | |
| xfree(tmp_str); | |
| if (col_list) { | |
| page_opts->col_list = list_create(xfree_ptr); | |
| slurm_addto_char_list(page_opts->col_list, col_list); | |
| xfree(col_list); | |
| } | |
| } | |
| xfree(tmp_str); | |
| s_p_hashtbl_destroy(hashtbl); | |
| end_it: | |
| /* copy it all into the working struct (memory will work out | |
| * in the end the col_list doesn't change) */ | |
| memcpy(&working_sview_config, &default_sview_config, | |
| sizeof(sview_config_t)); | |
| xfree(pathname); | |
| return rc; | |
| } | |
| extern int save_defaults(bool final_save) | |
| { | |
| char *reg_file = NULL, *old_file = NULL, *new_file = NULL; | |
| char *home = getenv("HOME"); | |
| int rc = SLURM_SUCCESS; | |
| char *tmp_str = NULL, *tmp_str2 = NULL; | |
| int fd = 0; | |
| int i = 0; | |
| display_data_t *display_data; | |
| if (!home) | |
| return SLURM_ERROR; | |
| reg_file = xstrdup_printf("%s/.slurm", home); | |
| if ((mkdir(reg_file, 0750) < 0) && (errno != EEXIST)) { | |
| error("mkdir(%s): %m", reg_file); | |
| rc = SLURM_ERROR; | |
| goto end_it; | |
| } | |
| xstrcat(reg_file, "/sviewrc"); | |
| old_file = xstrdup_printf("%s.old", reg_file); | |
| new_file = xstrdup_printf("%s.new", reg_file); | |
| fd = creat(new_file, 0600); | |
| if (fd < 0) { | |
| error("Can't save config file %s error %m", reg_file); | |
| rc = errno; | |
| goto end_it; | |
| } | |
| tmp_str = xstrdup_printf("AdminMode=%s\n", | |
| default_sview_config.admin_mode ? | |
| "YES" : "NO"); | |
| rc = _write_to_file(fd, tmp_str); | |
| xfree(tmp_str); | |
| if (rc != SLURM_SUCCESS) | |
| goto end_it; | |
| tmp_str = xstrdup_printf("DefaultPage=%s\n", | |
| page_to_str(default_sview_config. | |
| default_page)); | |
| rc = _write_to_file(fd, tmp_str); | |
| xfree(tmp_str); | |
| if (rc != SLURM_SUCCESS) | |
| goto end_it; | |
| tmp_str = xstrdup_printf("GridHorizontal=%u\n", | |
| default_sview_config.grid_hori); | |
| rc = _write_to_file(fd, tmp_str); | |
| xfree(tmp_str); | |
| if (rc != SLURM_SUCCESS) | |
| goto end_it; | |
| tmp_str = xstrdup_printf("GridTopo=%s\n", | |
| default_sview_config.grid_topological ? | |
| "YES" : "NO"); | |
| rc = _write_to_file(fd, tmp_str); | |
| xfree(tmp_str); | |
| if (rc != SLURM_SUCCESS) | |
| goto end_it; | |
| tmp_str = xstrdup_printf("GridVertical=%u\n", | |
| default_sview_config.grid_vert); | |
| rc = _write_to_file(fd, tmp_str); | |
| xfree(tmp_str); | |
| if (rc != SLURM_SUCCESS) | |
| goto end_it; | |
| tmp_str = xstrdup_printf("GridXWidth=%u\n", | |
| default_sview_config.grid_x_width); | |
| rc = _write_to_file(fd, tmp_str); | |
| xfree(tmp_str); | |
| if (rc != SLURM_SUCCESS) | |
| goto end_it; | |
| tmp_str = xstrdup_printf("ButtonSize=%u\n", | |
| default_sview_config.button_size); | |
| rc = _write_to_file(fd, tmp_str); | |
| xfree(tmp_str); | |
| if (rc != SLURM_SUCCESS) | |
| goto end_it; | |
| tmp_str = xstrdup_printf("RefreshDelay=%u\n", | |
| default_sview_config.refresh_delay); | |
| rc = _write_to_file(fd, tmp_str); | |
| xfree(tmp_str); | |
| if (rc != SLURM_SUCCESS) | |
| goto end_it; | |
| tmp_str = xstrdup_printf("MainWidth=%u\n", | |
| default_sview_config.main_width); | |
| rc = _write_to_file(fd, tmp_str); | |
| xfree(tmp_str); | |
| if (rc != SLURM_SUCCESS) | |
| goto end_it; | |
| tmp_str = xstrdup_printf("MainHeight=%u\n", | |
| default_sview_config.main_height); | |
| rc = _write_to_file(fd, tmp_str); | |
| xfree(tmp_str); | |
| if (rc != SLURM_SUCCESS) | |
| goto end_it; | |
| tmp_str = xstrdup_printf("FullInfoPopupWidth=%u\n", | |
| default_sview_config.fi_popup_width); | |
| rc = _write_to_file(fd, tmp_str); | |
| xfree(tmp_str); | |
| if (rc != SLURM_SUCCESS) | |
| goto end_it; | |
| tmp_str = xstrdup_printf("FullInfoPopupHeight=%u\n", | |
| default_sview_config.fi_popup_height); | |
| rc = _write_to_file(fd, tmp_str); | |
| xfree(tmp_str); | |
| if (rc != SLURM_SUCCESS) | |
| goto end_it; | |
| tmp_str = xstrdup_printf("RuledTables=%s\n", | |
| default_sview_config.ruled_treeview ? | |
| "YES" : "NO"); | |
| rc = _write_to_file(fd, tmp_str); | |
| xfree(tmp_str); | |
| if (rc != SLURM_SUCCESS) | |
| goto end_it; | |
| tmp_str = xstrdup_printf("ShowGrid=%s\n", | |
| default_sview_config.show_grid ? | |
| "YES" : "NO"); | |
| rc = _write_to_file(fd, tmp_str); | |
| xfree(tmp_str); | |
| if (rc != SLURM_SUCCESS) | |
| goto end_it; | |
| tmp_str = xstrdup_printf("ShowHidden=%s\n", | |
| default_sview_config.show_hidden ? | |
| "YES" : "NO"); | |
| rc = _write_to_file(fd, tmp_str); | |
| xfree(tmp_str); | |
| if (rc != SLURM_SUCCESS) | |
| goto end_it; | |
| tmp_str = xstrdup_printf("SavePageSettings=%s\n", | |
| default_sview_config.save_page_opts ? | |
| "YES" : "NO"); | |
| rc = _write_to_file(fd, tmp_str); | |
| xfree(tmp_str); | |
| if (rc != SLURM_SUCCESS) | |
| goto end_it; | |
| tmp_str = xstrdup_printf("TabPosition=%s\n", | |
| tab_pos_to_str(default_sview_config.tab_pos)); | |
| rc = _write_to_file(fd, tmp_str); | |
| xfree(tmp_str); | |
| if (rc != SLURM_SUCCESS) | |
| goto end_it; | |
| tmp_str2 = visible_to_str(&default_sview_config); | |
| tmp_str = xstrdup_printf("VisiblePages=%s\n", tmp_str2); | |
| xfree(tmp_str2); | |
| rc = _write_to_file(fd, tmp_str); | |
| xfree(tmp_str); | |
| if (rc != SLURM_SUCCESS) | |
| goto end_it; | |
| /* save all current page options */ | |
| for (i=0; i<PAGE_CNT; i++) { | |
| page_opts_t *page_opts = | |
| &working_sview_config.page_opts[i]; | |
| if (!page_opts->page_name) | |
| continue; | |
| if (working_sview_config.save_page_opts) { | |
| display_data = page_opts->display_data; | |
| while (display_data++) { | |
| if (display_data->id == -1) | |
| break; | |
| if (!display_data->name || !display_data->show) | |
| continue; | |
| if (tmp_str2) | |
| xstrcat(tmp_str2, ","); | |
| xstrfmtcat(tmp_str2, "%s", display_data->name); | |
| } //spin the menu options ^^ | |
| } else if (!page_opts->def_col_list | |
| && page_opts->col_list | |
| && list_count(page_opts->col_list)) { | |
| list_itr_t *itr = | |
| list_iterator_create(page_opts->col_list); | |
| char *col_name = NULL; | |
| //user requested no save of page options | |
| while ((col_name = list_next(itr))) { | |
| if (tmp_str2) | |
| xstrcat(tmp_str2, ","); | |
| xstrfmtcat(tmp_str2, "%s", col_name); | |
| } | |
| list_iterator_destroy(itr); | |
| } | |
| if (tmp_str2) { | |
| replspace(tmp_str2); | |
| tmp_str = xstrdup_printf("PageOpts%s=%s\n", | |
| page_opts->page_name, | |
| tmp_str2); | |
| xfree(tmp_str2); | |
| rc = _write_to_file(fd, tmp_str); | |
| xfree(tmp_str); | |
| if (rc != SLURM_SUCCESS) | |
| goto end_it; | |
| } | |
| }//spin the pages | |
| end_it: | |
| fsync(fd); | |
| close(fd); | |
| if (rc) | |
| (void) unlink(new_file); | |
| else { /* file shuffle */ | |
| (void) unlink(old_file); | |
| if (link(reg_file, old_file)) | |
| debug4("unable to create link for %s -> %s: %m", | |
| reg_file, old_file); | |
| (void) unlink(reg_file); | |
| if (link(new_file, reg_file)) | |
| debug4("unable to create link for %s -> %s: %m", | |
| new_file, reg_file); | |
| (void) unlink(new_file); | |
| } | |
| xfree(old_file); | |
| xfree(new_file); | |
| xfree(reg_file); | |
| return rc; | |
| } | |
| extern GtkListStore *create_model_defaults(int type) | |
| { | |
| GtkListStore *model = NULL; | |
| GtkTreeIter iter; | |
| switch(type) { | |
| case SORTID_ADMIN: | |
| case SORTID_GRID_TOPO_ORDER: | |
| case SORTID_RULED_TV: | |
| case SORTID_SHOW_GRID: | |
| case SORTID_SHOW_HIDDEN: | |
| case SORTID_SAVE_PAGE_OPTS: | |
| model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); | |
| gtk_list_store_append(model, &iter); | |
| gtk_list_store_set(model, &iter, | |
| 0, "no", | |
| 1, type, | |
| -1); | |
| gtk_list_store_append(model, &iter); | |
| gtk_list_store_set(model, &iter, | |
| 0, "yes", | |
| 1, type, | |
| -1); | |
| break; | |
| case SORTID_DEFAULT_PAGE: | |
| model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); | |
| gtk_list_store_append(model, &iter); | |
| gtk_list_store_set(model, &iter, | |
| 0, "job", | |
| 1, type, | |
| -1); | |
| gtk_list_store_append(model, &iter); | |
| gtk_list_store_set(model, &iter, | |
| 0, "part", | |
| 1, type, | |
| -1); | |
| gtk_list_store_append(model, &iter); | |
| gtk_list_store_set(model, &iter, | |
| 0, "res", | |
| 1, type, | |
| -1); | |
| gtk_list_store_append(model, &iter); | |
| gtk_list_store_set(model, &iter, | |
| 0, "node", | |
| 1, type, | |
| -1); | |
| break; | |
| case SORTID_TAB_POS: | |
| model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); | |
| gtk_list_store_append(model, &iter); | |
| gtk_list_store_set(model, &iter, | |
| 0, "top", | |
| 1, type, | |
| -1); | |
| gtk_list_store_append(model, &iter); | |
| gtk_list_store_set(model, &iter, | |
| 0, "bottom", | |
| 1, type, | |
| -1); | |
| gtk_list_store_append(model, &iter); | |
| gtk_list_store_set(model, &iter, | |
| 0, "left", | |
| 1, type, | |
| -1); | |
| gtk_list_store_append(model, &iter); | |
| gtk_list_store_set(model, &iter, | |
| 0, "right", | |
| 1, type, | |
| -1); | |
| break; | |
| default: | |
| break; | |
| } | |
| return model; | |
| } | |
| 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_type_hint(GTK_WINDOW(popup), | |
| GDK_WINDOW_TYPE_HINT_NORMAL); | |
| 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) { | |
| 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_resv(); | |
| cluster_change_part(); | |
| cluster_change_job(); | |
| cluster_change_node(); | |
| } 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); | |
| tmp_char_ptr = g_strdup_printf( | |
| "Defaults updated successfully"); | |
| } | |
| 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; | |
| } |