extern int get_new_info_config(slurm_ctl_conf_info_msg_t **info_ptr)
{
static slurm_ctl_conf_info_msg_t *new_ctl_ptr = NULL;
int error_code = SLURM_NO_CHANGE_IN_DATA;
if (g_ctl_info_ptr) {
error_code = slurm_load_ctl_conf(g_ctl_info_ptr->last_update,
&new_ctl_ptr);
if (error_code == SLURM_SUCCESS)
slurm_free_ctl_conf(g_ctl_info_ptr);
else if (slurm_get_errno () == SLURM_NO_CHANGE_IN_DATA) {
error_code = SLURM_NO_CHANGE_IN_DATA;
new_ctl_ptr = g_ctl_info_ptr;
}
} else {
new_ctl_ptr = NULL;
error_code = slurm_load_ctl_conf((time_t) NULL, &new_ctl_ptr);
}
g_ctl_info_ptr = new_ctl_ptr;
if (g_ctl_info_ptr && (*info_ptr != g_ctl_info_ptr))
error_code = SLURM_SUCCESS;
*info_ptr = new_ctl_ptr;
return error_code;
}
static const char *
slurmdrmaa_get_DRM_system( fsd_drmaa_singletone_t *self )
{
if(slurmdrmaa_version[0] == '\0') /*no locks as drmaa_get_drm_system is usually called only once */
{
slurm_ctl_conf_t * conf_info_msg_ptr = NULL;
if ( slurm_load_ctl_conf ((time_t) NULL, &conf_info_msg_ptr ) == -1 )
{
fsd_log_error(("slurm_load_ctl_conf error: %s",slurm_strerror(slurm_get_errno())));
fsd_snprintf(NULL, slurmdrmaa_version, sizeof(slurmdrmaa_version)-1,"SLURM");
}
else
{
fsd_snprintf(NULL, slurmdrmaa_version, sizeof(slurmdrmaa_version)-1,"SLURM %s", conf_info_msg_ptr->version);
slurm_free_ctl_conf (conf_info_msg_ptr);
}
}
return slurmdrmaa_version;
}
int main (int argc, char *argv[])
{
char *prio_type = NULL;
int error_code = SLURM_SUCCESS;
priority_factors_request_msg_t req_msg;
priority_factors_response_msg_t *resp_msg = NULL;
log_options_t opts = LOG_OPTS_STDERR_ONLY ;
slurm_conf_init(NULL);
log_init(xbasename(argv[0]), opts, SYSLOG_FACILITY_USER, NULL);
parse_command_line( argc, argv );
if (params.verbose) {
opts.stderr_level += params.verbose;
log_alter(opts, SYSLOG_FACILITY_USER, NULL);
}
if (working_cluster_rec) {
slurm_ctl_conf_info_msg_t *slurm_ctl_conf_ptr;
error_code = slurm_load_ctl_conf((time_t) NULL,
&slurm_ctl_conf_ptr);
if (error_code) {
slurm_perror ("slurm_load_ctl_conf error");
exit(error_code);
}
weight_age = slurm_ctl_conf_ptr->priority_weight_age;
weight_fs = slurm_ctl_conf_ptr->priority_weight_fs;
weight_js = slurm_ctl_conf_ptr->priority_weight_js;
weight_part = slurm_ctl_conf_ptr->priority_weight_part;
weight_qos = slurm_ctl_conf_ptr->priority_weight_qos;
weight_tres = slurm_ctl_conf_ptr->priority_weight_tres;
prio_type = xstrdup(slurm_ctl_conf_ptr->priority_type);
slurm_free_ctl_conf(slurm_ctl_conf_ptr);
} else {
weight_age = slurm_get_priority_weight_age();
weight_fs = slurm_get_priority_weight_fairshare();
weight_js = slurm_get_priority_weight_job_size();
weight_part = slurm_get_priority_weight_partition();
weight_qos = slurm_get_priority_weight_qos();
weight_tres = slurm_get_priority_weight_tres();
prio_type = slurm_get_priority_type();
}
/* Check to see if we are running a supported accounting plugin */
if (xstrcasecmp(prio_type, "priority/basic") == 0) {
fprintf (stderr, "You are not running a supported "
"priority plugin\n(%s).\n"
"Only 'priority/multifactor' is supported.\n",
prio_type);
exit(1);
}
xfree(prio_type);
memset(&req_msg, 0, sizeof(priority_factors_request_msg_t));
if (params.jobs)
req_msg.job_id_list = params.job_list;
else
req_msg.job_id_list = NULL;
if (params.users)
req_msg.uid_list = params.user_list;
else
req_msg.uid_list = NULL;
error_code = _get_info(&req_msg, &resp_msg);
if (error_code) {
slurm_perror("Couldn't get priority factors from controller");
exit(error_code);
}
if (params.format == NULL) {
if (params.normalized) {
if (params.long_list)
params.format = "%.15i %.8u %10y %10a %10f "
"%10j %10p %10q %20t";
else{
params.format = xstrdup("%.15i");
if (params.users)
xstrcat(params.format, " %.8u");
xstrcat(params.format, " %10y");
if (weight_age)
xstrcat(params.format, " %10a");
if (weight_fs)
xstrcat(params.format, " %10f");
if (weight_js)
xstrcat(params.format, " %10j");
if (weight_part)
xstrcat(params.format, " %10p");
if (weight_qos)
xstrcat(params.format, " %10q");
if (weight_tres)
xstrcat(params.format, " %20t");
}
} else {
if (params.long_list)
params.format = "%.15i %.8u %.10Y %.10A %.10F "
"%.10J %.10P %.10Q %.6N %.20T";
else{
params.format = xstrdup("%.15i");
if (params.users)
xstrcat(params.format, " %.8u");
xstrcat(params.format, " %.10Y");
if (weight_age)
xstrcat(params.format, " %.10A");
if (weight_fs)
xstrcat(params.format, " %.10F");
if (weight_js)
xstrcat(params.format, " %.10J");
if (weight_part)
xstrcat(params.format, " %.10P");
if (weight_qos)
xstrcat(params.format, " %.10Q");
if (weight_tres)
xstrcat(params.format, " %.20T");
}
}
}
/* create the format list from the format */
parse_format(params.format);
if (params.jobs && (!resp_msg || !resp_msg->priority_factors_list ||
!list_count(resp_msg->priority_factors_list))) {
printf("Unable to find jobs matching user/id(s) specified\n");
} else if (resp_msg) {
print_jobs_array(resp_msg->priority_factors_list,
params.format_list);
}
#if 0
/* Free storage here if we want to verify that logic.
* Since we exit next, this is not important */
FREE_NULL_LIST(params.format_list);
slurm_free_priority_factors_response_msg(resp_msg);
#endif
exit (error_code);
}
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);
}
/*
* slurm_sprint_node_table - output information about a specific Slurm nodes
* based upon message as loaded using slurm_load_node
* IN node_ptr - an individual node information record pointer
* IN one_liner - print as a single line if true
* RET out - char * containing formatted output (must be freed after call)
* NULL is returned on failure.
*/
char *slurm_sprint_node_table(node_info_t *node_ptr, int one_liner)
{
uint32_t my_state = node_ptr->node_state;
char *cloud_str = "", *comp_str = "", *drain_str = "", *power_str = "";
char time_str[32];
char *out = NULL, *reason_str = NULL;
uint16_t alloc_cpus = 0;
int idle_cpus;
uint64_t alloc_memory;
char *node_alloc_tres = NULL;
char *line_end = (one_liner) ? " " : "\n ";
slurm_ctl_conf_info_msg_t *slurm_ctl_conf_ptr = NULL;
if (slurm_load_ctl_conf((time_t) NULL, &slurm_ctl_conf_ptr)
!= SLURM_SUCCESS)
fatal("Cannot load slurmctld conf file");
if (my_state & NODE_STATE_CLOUD) {
my_state &= (~NODE_STATE_CLOUD);
cloud_str = "+CLOUD";
}
if (my_state & NODE_STATE_COMPLETING) {
my_state &= (~NODE_STATE_COMPLETING);
comp_str = "+COMPLETING";
}
if (my_state & NODE_STATE_DRAIN) {
my_state &= (~NODE_STATE_DRAIN);
drain_str = "+DRAIN";
}
if (my_state & NODE_STATE_FAIL) {
my_state &= (~NODE_STATE_FAIL);
drain_str = "+FAIL";
}
if (my_state & NODE_STATE_POWER_SAVE) {
my_state &= (~NODE_STATE_POWER_SAVE);
power_str = "+POWER";
}
if (my_state & NODE_STATE_POWERING_DOWN) {
my_state &= (~NODE_STATE_POWERING_DOWN);
power_str = "+POWERING_DOWN";
}
slurm_get_select_nodeinfo(node_ptr->select_nodeinfo,
SELECT_NODEDATA_SUBCNT,
NODE_STATE_ALLOCATED,
&alloc_cpus);
idle_cpus = node_ptr->cpus - alloc_cpus;
if (idle_cpus && (idle_cpus != node_ptr->cpus)) {
my_state &= NODE_STATE_FLAGS;
my_state |= NODE_STATE_MIXED;
}
/****** Line 1 ******/
xstrfmtcat(out, "NodeName=%s ", node_ptr->name);
if (node_ptr->arch)
xstrfmtcat(out, "Arch=%s ", node_ptr->arch);
if (node_ptr->cpu_bind) {
char tmp_str[128];
slurm_sprint_cpu_bind_type(tmp_str, node_ptr->cpu_bind);
xstrfmtcat(out, "CpuBind=%s ", tmp_str);
}
xstrfmtcat(out, "CoresPerSocket=%u ", node_ptr->cores);
xstrcat(out, line_end);
/****** Line ******/
xstrfmtcat(out, "CPUAlloc=%u CPUTot=%u ",
alloc_cpus, node_ptr->cpus);
if (node_ptr->cpu_load == NO_VAL)
xstrcat(out, "CPULoad=N/A");
else
xstrfmtcat(out, "CPULoad=%.2f", (node_ptr->cpu_load / 100.0));
xstrcat(out, line_end);
/****** Line ******/
xstrfmtcat(out, "AvailableFeatures=%s", node_ptr->features);
xstrcat(out, line_end);
/****** Line ******/
xstrfmtcat(out, "ActiveFeatures=%s", node_ptr->features_act);
xstrcat(out, line_end);
/****** Line ******/
xstrfmtcat(out, "Gres=%s", node_ptr->gres);
xstrcat(out, line_end);
/****** Line (optional) ******/
if (node_ptr->gres_drain) {
xstrfmtcat(out, "GresDrain=%s", node_ptr->gres_drain);
xstrcat(out, line_end);
}
/****** Line (optional) ******/
if (node_ptr->gres_used) {
xstrfmtcat(out, "GresUsed=%s", node_ptr->gres_used);
xstrcat(out, line_end);
}
/****** Line (optional) ******/
{
bool line_used = false;
if (node_ptr->node_addr) {
xstrfmtcat(out, "NodeAddr=%s ", node_ptr->node_addr);
line_used = true;
}
if (node_ptr->node_hostname) {
xstrfmtcat(out, "NodeHostName=%s ",
node_ptr->node_hostname);
line_used = true;
}
if (node_ptr->port != slurm_get_slurmd_port()) {
xstrfmtcat(out, "Port=%u ", node_ptr->port);
line_used = true;
}
if (node_ptr->version &&
xstrcmp(node_ptr->version, slurm_ctl_conf_ptr->version)) {
xstrfmtcat(out, "Version=%s", node_ptr->version);
line_used = true;
}
if (line_used)
xstrcat(out, line_end);
}
/****** Line ******/
if (node_ptr->os) {
xstrfmtcat(out, "OS=%s ", node_ptr->os);
xstrcat(out, line_end);
}
/****** Line ******/
slurm_get_select_nodeinfo(node_ptr->select_nodeinfo,
SELECT_NODEDATA_MEM_ALLOC,
NODE_STATE_ALLOCATED,
&alloc_memory);
xstrfmtcat(out, "RealMemory=%"PRIu64" AllocMem=%"PRIu64" ",
node_ptr->real_memory, alloc_memory);
if (node_ptr->free_mem == NO_VAL64)
xstrcat(out, "FreeMem=N/A ");
else
xstrfmtcat(out, "FreeMem=%"PRIu64" ", node_ptr->free_mem);
xstrfmtcat(out, "Sockets=%u Boards=%u",
node_ptr->sockets, node_ptr->boards);
xstrcat(out, line_end);
/****** core & memory specialization Line (optional) ******/
if (node_ptr->core_spec_cnt || node_ptr->cpu_spec_list ||
node_ptr->mem_spec_limit) {
if (node_ptr->core_spec_cnt) {
xstrfmtcat(out, "CoreSpecCount=%u ",
node_ptr->core_spec_cnt);
}
if (node_ptr->cpu_spec_list) {
xstrfmtcat(out, "CPUSpecList=%s ",
node_ptr->cpu_spec_list);
}
if (node_ptr->mem_spec_limit) {
xstrfmtcat(out, "MemSpecLimit=%"PRIu64"",
node_ptr->mem_spec_limit);
}
xstrcat(out, line_end);
}
/****** Line ******/
xstrfmtcat(out, "State=%s%s%s%s%s ThreadsPerCore=%u TmpDisk=%u Weight=%u ",
node_state_string(my_state),
cloud_str, comp_str, drain_str, power_str,
node_ptr->threads, node_ptr->tmp_disk, node_ptr->weight);
if (node_ptr->owner == NO_VAL) {
xstrcat(out, "Owner=N/A ");
} else {
char *user_name = uid_to_string((uid_t) node_ptr->owner);
xstrfmtcat(out, "Owner=%s(%u) ", user_name, node_ptr->owner);
xfree(user_name);
}
xstrfmtcat(out, "MCS_label=%s",
(node_ptr->mcs_label == NULL) ? "N/A" : node_ptr->mcs_label);
xstrcat(out, line_end);
/****** Line ******/
if ((node_ptr->next_state != NO_VAL) &&
(my_state & NODE_STATE_REBOOT)) {
xstrfmtcat(out, "NextState=%s",
node_state_string(node_ptr->next_state));
xstrcat(out, line_end);
}
/****** Line ******/
if (node_ptr->partitions) {
xstrfmtcat(out, "Partitions=%s ", node_ptr->partitions);
xstrcat(out, line_end);
}
/****** Line ******/
if (node_ptr->boot_time) {
slurm_make_time_str((time_t *)&node_ptr->boot_time,
time_str, sizeof(time_str));
xstrfmtcat(out, "BootTime=%s ", time_str);
} else {
xstrcat(out, "BootTime=None ");
}
if (node_ptr->slurmd_start_time) {
slurm_make_time_str ((time_t *)&node_ptr->slurmd_start_time,
time_str, sizeof(time_str));
xstrfmtcat(out, "SlurmdStartTime=%s", time_str);
} else {
xstrcat(out, "SlurmdStartTime=None");
}
xstrcat(out, line_end);
/****** TRES Line ******/
select_g_select_nodeinfo_get(node_ptr->select_nodeinfo,
SELECT_NODEDATA_TRES_ALLOC_FMT_STR,
NODE_STATE_ALLOCATED, &node_alloc_tres);
xstrfmtcat(out, "CfgTRES=%s", node_ptr->tres_fmt_str);
xstrcat(out, line_end);
xstrfmtcat(out, "AllocTRES=%s",
(node_alloc_tres) ? node_alloc_tres : "");
xfree(node_alloc_tres);
xstrcat(out, line_end);
/****** Power Management Line ******/
if (!node_ptr->power || (node_ptr->power->cap_watts == NO_VAL))
xstrcat(out, "CapWatts=n/a");
else
xstrfmtcat(out, "CapWatts=%u", node_ptr->power->cap_watts);
xstrcat(out, line_end);
/****** Power Consumption Line ******/
if (!node_ptr->energy || node_ptr->energy->current_watts == NO_VAL)
xstrcat(out, "CurrentWatts=n/s AveWatts=n/s");
else
xstrfmtcat(out, "CurrentWatts=%u AveWatts=%u",
node_ptr->energy->current_watts,
node_ptr->energy->ave_watts);
xstrcat(out, line_end);
/****** external sensors Line ******/
if (!node_ptr->ext_sensors
|| node_ptr->ext_sensors->consumed_energy == NO_VAL64)
xstrcat(out, "ExtSensorsJoules=n/s ");
else
xstrfmtcat(out, "ExtSensorsJoules=%"PRIu64" ",
node_ptr->ext_sensors->consumed_energy);
if (!node_ptr->ext_sensors
|| node_ptr->ext_sensors->current_watts == NO_VAL)
xstrcat(out, "ExtSensorsWatts=n/s ");
else
xstrfmtcat(out, "ExtSensorsWatts=%u ",
node_ptr->ext_sensors->current_watts);
if (!node_ptr->ext_sensors
|| node_ptr->ext_sensors->temperature == NO_VAL)
xstrcat(out, "ExtSensorsTemp=n/s");
else
xstrfmtcat(out, "ExtSensorsTemp=%u",
node_ptr->ext_sensors->temperature);
xstrcat(out, line_end);
/****** Line ******/
if (node_ptr->reason && node_ptr->reason[0])
xstrcat(reason_str, node_ptr->reason);
if (reason_str) {
int inx = 1;
char *save_ptr = NULL, *tok, *user_name;
tok = strtok_r(reason_str, "\n", &save_ptr);
while (tok) {
if (inx == 1) {
xstrcat(out, "Reason=");
} else {
xstrcat(out, line_end);
xstrcat(out, " ");
}
xstrfmtcat(out, "%s", tok);
if ((inx++ == 1) && node_ptr->reason_time) {
user_name = uid_to_string(node_ptr->reason_uid);
slurm_make_time_str((time_t *)&node_ptr->reason_time,
time_str, sizeof(time_str));
xstrfmtcat(out, " [%s@%s]", user_name, time_str);
xfree(user_name);
}
tok = strtok_r(NULL, "\n", &save_ptr);
}
xfree(reason_str);
}
if (one_liner)
xstrcat(out, "\n");
else
xstrcat(out, "\n\n");
slurm_free_ctl_conf(slurm_ctl_conf_ptr);
return out;
}