static const char * _node_state_list (void) { int i; static char *all_states = NULL; if (all_states) return (all_states); all_states = xstrdup (node_state_string_compact (0)); for (i = 1; i < NODE_STATE_END; i++) { xstrcat (all_states, ","); xstrcat (all_states, node_state_string(i)); } xstrcat(all_states, ",DRAIN,DRAINED,DRAINING,NO_RESPOND"); xstrcat(all_states, ","); xstrcat(all_states, node_state_string(NODE_STATE_COMPLETING)); xstrcat(all_states, ","); xstrcat(all_states, node_state_string(NODE_STATE_POWER_SAVE)); xstrcat(all_states, ","); xstrcat(all_states, node_state_string(NODE_STATE_FAIL)); xstrcat(all_states, ","); xstrcat(all_states, node_state_string(NODE_STATE_MAINT)); for (i = 0; i < strlen (all_states); i++) all_states[i] = tolower (all_states[i]); return (all_states); }
static uint32_t _decode_node_state(char *val) { int vallen; xassert(val); vallen = strlen(val); if (!strncasecmp(val, "DRAIN", MAX(vallen, 3))) return NODE_STATE_DRAIN; else if (!strncasecmp(val, "FAIL", MAX(vallen, 3))) return NODE_STATE_FAIL; else { uint32_t j; for (j = 0; j < NODE_STATE_END; j++) { if (strncasecmp(node_state_string(j), val, MAX(vallen, 3)) == 0){ return j; } } if (j == NODE_STATE_END) { exit_code = 1; fprintf(stderr, "Invalid state: %s\n", val); fprintf (stderr, "Valid node states are: "); fprintf (stderr, "DRAIN FAIL "); for (j = 0; j < NODE_STATE_END; j++) { fprintf (stderr, "%s ", node_state_string(j)); } fprintf (stderr, "\n"); } } return NO_VAL; }
/* Convert a node state string to it's equivalent enum value */ extern int state_str2int(const char *state_str, char *node_name) { int state_val = NO_VAL; int i; for (i = 0; i <= NODE_STATE_END; i++) { if (strcasecmp(node_state_string(i), "END") == 0) break; if (strcasecmp(node_state_string(i), state_str) == 0) { state_val = i; break; } } if (i >= NODE_STATE_END) { if (strncasecmp("CLOUD", state_str, 5) == 0) state_val = NODE_STATE_IDLE | NODE_STATE_CLOUD | NODE_STATE_POWER_SAVE; else if (strncasecmp("DRAIN", state_str, 5) == 0) state_val = NODE_STATE_UNKNOWN | NODE_STATE_DRAIN; else if (strncasecmp("FAIL", state_str, 4) == 0) state_val = NODE_STATE_IDLE | NODE_STATE_FAIL; } if (state_val == NO_VAL) { error("node %s has invalid state %s", node_name, state_str); errno = EINVAL; } return state_val; }
static bool _node_state_equal (int i, const char *str) { int len = strlen (str); if ((strncasecmp(node_state_string_compact(i), str, len) == 0) || (strncasecmp(node_state_string(i), str, len) == 0)) return (true); return (false); }
int _print_state_long(sinfo_data_t * sinfo_data, int width, bool right_justify, char *suffix) { if (sinfo_data && sinfo_data->nodes_total) { char *upper_state = node_state_string(sinfo_data->node_state); char *lower_state = _str_tolower(upper_state); _print_str(lower_state, width, right_justify, true); xfree(lower_state); } else if (sinfo_data) _print_str("n/a", width, right_justify, true); else _print_str("STATE", width, right_justify, true); if (suffix) printf("%s", suffix); return SLURM_SUCCESS; }
/* * log_front_end_state - log all front end node state */ extern void log_front_end_state(void) { #ifdef HAVE_FRONT_END front_end_record_t *front_end_ptr; int i; for (i = 0, front_end_ptr = front_end_nodes; i < front_end_node_cnt; i++, front_end_ptr++) { xassert(front_end_ptr->magic == FRONT_END_MAGIC); info("FrontendName=%s FrontendAddr=%s Port=%u State=%s " "Reason=%s JobCntRun=%u JobCntComp=%u", front_end_ptr->name, front_end_ptr->comm_name, front_end_ptr->port, node_state_string(front_end_ptr->node_state), front_end_ptr->reason, front_end_ptr->job_cnt_run, front_end_ptr->job_cnt_comp); } #endif }
static List _create_front_end_info_list( front_end_info_msg_t *front_end_info_ptr, int changed) { char *upper = NULL; char user[32], time_str[32]; static List info_list = NULL; List last_list = NULL; ListIterator last_list_itr = NULL; int i = 0; sview_front_end_info_t *sview_front_end_info_ptr = NULL; front_end_info_t *front_end_ptr = NULL; if (!changed && info_list) goto update_color; if (info_list) last_list = info_list; info_list = list_create(_front_end_info_list_del); if (last_list) last_list_itr = list_iterator_create(last_list); for (i = 0; i < front_end_info_ptr->record_count; i++) { front_end_ptr = &(front_end_info_ptr->front_end_array[i]); sview_front_end_info_ptr = NULL; if (last_list_itr) { while ((sview_front_end_info_ptr = list_next(last_list_itr))) { if (!xstrcmp(sview_front_end_info_ptr-> front_end_name, front_end_ptr->name)) { list_remove(last_list_itr); _front_end_info_free( sview_front_end_info_ptr); break; } } list_iterator_reset(last_list_itr); } if (!sview_front_end_info_ptr) sview_front_end_info_ptr = xmalloc(sizeof(sview_front_end_info_t)); sview_front_end_info_ptr->pos = i; sview_front_end_info_ptr->front_end_name = front_end_ptr->name; sview_front_end_info_ptr->front_end_ptr = front_end_ptr; sview_front_end_info_ptr->color_inx = i % sview_colors_cnt; if (g_node_info_ptr) { sview_front_end_info_ptr->node_inx[0] = 0; sview_front_end_info_ptr->node_inx[1] = g_node_info_ptr->record_count - 1; sview_front_end_info_ptr->node_inx[2] = -1; } else sview_front_end_info_ptr->node_inx[0] = -1; if (front_end_ptr->boot_time) { slurm_make_time_str(&front_end_ptr->boot_time, time_str, sizeof(time_str)); sview_front_end_info_ptr->boot_time = xstrdup(time_str); } if (front_end_ptr->slurmd_start_time) { slurm_make_time_str(&front_end_ptr->slurmd_start_time, time_str, sizeof(time_str)); sview_front_end_info_ptr->slurmd_start_time = xstrdup(time_str); } upper = node_state_string(front_end_ptr->node_state); sview_front_end_info_ptr->state = str_tolower(upper); if (front_end_ptr->reason && front_end_ptr->reason_time && (front_end_ptr->reason_uid != NO_VAL)) { struct passwd *pw = NULL; if ((pw=getpwuid(front_end_ptr->reason_uid))) snprintf(user, sizeof(user), "%s", pw->pw_name); else snprintf(user, sizeof(user), "Unk(%u)", front_end_ptr->reason_uid); slurm_make_time_str(&front_end_ptr->reason_time, time_str, sizeof(time_str)); sview_front_end_info_ptr->reason = xstrdup_printf("%s [%s@%s]", front_end_ptr->reason, user, time_str); } else { sview_front_end_info_ptr->reason = xstrdup(front_end_ptr->reason); } list_append(info_list, sview_front_end_info_ptr); } if (last_list) { list_iterator_destroy(last_list_itr); FREE_NULL_LIST(last_list); } update_color: return info_list; }
/* * 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 node_scaling - number of nodes each node represents * 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 node_scaling, int one_liner ) { uint16_t my_state = node_ptr->node_state; char *cloud_str = "", *comp_str = "", *drain_str = "", *power_str = ""; char load_str[32], tmp_line[512], time_str[32]; char *out = NULL, *reason_str = NULL, *select_reason_str = NULL; uint16_t err_cpus = 0, alloc_cpus = 0; int cpus_per_node = 1; int total_used = node_ptr->cpus; uint32_t cluster_flags = slurmdb_setup_cluster_flags(); if (node_scaling) cpus_per_node = node_ptr->cpus / node_scaling; 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_POWER_SAVE) { my_state &= (~NODE_STATE_POWER_SAVE); power_str = "+POWER"; } slurm_get_select_nodeinfo(node_ptr->select_nodeinfo, SELECT_NODEDATA_SUBCNT, NODE_STATE_ALLOCATED, &alloc_cpus); if (cluster_flags & CLUSTER_FLAG_BG) { if (!alloc_cpus && (IS_NODE_ALLOCATED(node_ptr) || IS_NODE_COMPLETING(node_ptr))) alloc_cpus = node_ptr->cpus; else alloc_cpus *= cpus_per_node; } total_used -= alloc_cpus; slurm_get_select_nodeinfo(node_ptr->select_nodeinfo, SELECT_NODEDATA_SUBCNT, NODE_STATE_ERROR, &err_cpus); if (cluster_flags & CLUSTER_FLAG_BG) err_cpus *= cpus_per_node; total_used -= err_cpus; if ((alloc_cpus && err_cpus) || (total_used && (total_used != node_ptr->cpus))) { my_state &= NODE_STATE_FLAGS; my_state |= NODE_STATE_MIXED; } /****** Line 1 ******/ snprintf(tmp_line, sizeof(tmp_line), "NodeName=%s ", node_ptr->name); xstrcat(out, tmp_line); if (cluster_flags & CLUSTER_FLAG_BG) { slurm_get_select_nodeinfo(node_ptr->select_nodeinfo, SELECT_NODEDATA_RACK_MP, 0, &select_reason_str); if (select_reason_str) { xstrfmtcat(out, "RackMidplane=%s ", select_reason_str); xfree(select_reason_str); } } if (node_ptr->arch) { snprintf(tmp_line, sizeof(tmp_line), "Arch=%s ", node_ptr->arch); xstrcat(out, tmp_line); } snprintf(tmp_line, sizeof(tmp_line), "CoresPerSocket=%u", node_ptr->cores); xstrcat(out, tmp_line); if (one_liner) xstrcat(out, " "); else xstrcat(out, "\n "); /****** Line 2 ******/ if (node_ptr->cpu_load == NO_VAL) strcpy(load_str, "N/A"); else { snprintf(load_str, sizeof(load_str), "%.2f", (node_ptr->cpu_load / 100.0)); } snprintf(tmp_line, sizeof(tmp_line), "CPUAlloc=%u CPUErr=%u CPUTot=%u CPULoad=%s Features=%s", alloc_cpus, err_cpus, node_ptr->cpus, load_str, node_ptr->features); xstrcat(out, tmp_line); if (one_liner) xstrcat(out, " "); else xstrcat(out, "\n "); /****** Line 3 ******/ snprintf(tmp_line, sizeof(tmp_line), "Gres=%s",node_ptr->gres); xstrcat(out, tmp_line); if (one_liner) xstrcat(out, " "); else xstrcat(out, "\n "); /****** Line 4 (optional) ******/ if (node_ptr->node_hostname || node_ptr->node_addr) { snprintf(tmp_line, sizeof(tmp_line), "NodeAddr=%s NodeHostName=%s", node_ptr->node_addr, node_ptr->node_hostname); xstrcat(out, tmp_line); if (one_liner) xstrcat(out, " "); else xstrcat(out, "\n "); } /****** Line 5 ******/ if (node_ptr->os) { snprintf(tmp_line, sizeof(tmp_line), "OS=%s ", node_ptr->os); xstrcat(out, tmp_line); } snprintf(tmp_line, sizeof(tmp_line), "RealMemory=%u Sockets=%u Boards=%u", node_ptr->real_memory, node_ptr->sockets, node_ptr->boards); xstrcat(out, tmp_line); if (one_liner) xstrcat(out, " "); else xstrcat(out, "\n "); /****** Line 6 ******/ snprintf(tmp_line, sizeof(tmp_line), "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); xstrcat(out, tmp_line); if (one_liner) xstrcat(out, " "); else xstrcat(out, "\n "); /****** Line 7 ******/ if (node_ptr->boot_time) { slurm_make_time_str ((time_t *)&node_ptr->boot_time, time_str, sizeof(time_str)); } else { strncpy(time_str, "None", sizeof(time_str)); } snprintf(tmp_line, sizeof(tmp_line), "BootTime=%s ", time_str); xstrcat(out, tmp_line); if (node_ptr->slurmd_start_time) { slurm_make_time_str ((time_t *)&node_ptr->slurmd_start_time, time_str, sizeof(time_str)); } else { strncpy(time_str, "None", sizeof(time_str)); } snprintf(tmp_line, sizeof(tmp_line), "SlurmdStartTime=%s", time_str); xstrcat(out, tmp_line); if (one_liner) xstrcat(out, " "); else xstrcat(out, "\n "); /****** power Line ******/ if (node_ptr->energy->current_watts == NO_VAL) snprintf(tmp_line, sizeof(tmp_line), "CurrentWatts=n/s " "LowestJoules=n/s ConsumedJoules=n/s"); else snprintf(tmp_line, sizeof(tmp_line), "CurrentWatts=%u " "LowestJoules=%u ConsumedJoules=%u", node_ptr->energy->current_watts, node_ptr->energy->base_watts, node_ptr->energy->consumed_energy); xstrcat(out, tmp_line); if (one_liner) xstrcat(out, " "); else xstrcat(out, "\n "); /****** Line 8 ******/ if (node_ptr->reason && node_ptr->reason[0]) xstrcat(reason_str, node_ptr->reason); slurm_get_select_nodeinfo(node_ptr->select_nodeinfo, SELECT_NODEDATA_EXTRA_INFO, 0, &select_reason_str); if (select_reason_str && select_reason_str[0]) { if (reason_str) xstrcat(reason_str, "\n"); xstrcat(reason_str, select_reason_str); } xfree(select_reason_str); 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 { if (one_liner) xstrcat(out, " "); else xstrcat(out, "\n "); xstrcat(out, " "); } snprintf(tmp_line, sizeof(tmp_line), "%s", tok); xstrcat(out, tmp_line); 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)); snprintf(tmp_line, sizeof(tmp_line), " [%s@%s]", user_name, time_str); xstrcat(out, tmp_line); } tok = strtok_r(NULL, "\n", &save_ptr); } xfree(reason_str); } if (one_liner) xstrcat(out, "\n"); else xstrcat(out, "\n\n"); return out; }
/* * 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 node_scaling - number of nodes each node represents * 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 node_scaling, 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, *select_reason_str = NULL; uint16_t err_cpus = 0, alloc_cpus = 0; int cpus_per_node = 1; int idle_cpus; uint32_t cluster_flags = slurmdb_setup_cluster_flags(); uint64_t alloc_memory; char *node_alloc_tres = NULL; char *line_end = (one_liner) ? " " : "\n "; if (node_scaling) cpus_per_node = node_ptr->cpus / node_scaling; 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"; } slurm_get_select_nodeinfo(node_ptr->select_nodeinfo, SELECT_NODEDATA_SUBCNT, NODE_STATE_ALLOCATED, &alloc_cpus); if (cluster_flags & CLUSTER_FLAG_BG) { if (!alloc_cpus && (IS_NODE_ALLOCATED(node_ptr) || IS_NODE_COMPLETING(node_ptr))) alloc_cpus = node_ptr->cpus; else alloc_cpus *= cpus_per_node; } idle_cpus = node_ptr->cpus - alloc_cpus; slurm_get_select_nodeinfo(node_ptr->select_nodeinfo, SELECT_NODEDATA_SUBCNT, NODE_STATE_ERROR, &err_cpus); if (cluster_flags & CLUSTER_FLAG_BG) err_cpus *= cpus_per_node; idle_cpus -= err_cpus; if ((alloc_cpus && err_cpus) || (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 (cluster_flags & CLUSTER_FLAG_BG) { slurm_get_select_nodeinfo(node_ptr->select_nodeinfo, SELECT_NODEDATA_RACK_MP, 0, &select_reason_str); if (select_reason_str) { xstrfmtcat(out, "RackMidplane=%s ", select_reason_str); xfree(select_reason_str); } } if (node_ptr->arch) xstrfmtcat(out, "Arch=%s ", node_ptr->arch); xstrfmtcat(out, "CoresPerSocket=%u", node_ptr->cores); xstrcat(out, line_end); /****** Line ******/ xstrfmtcat(out, "CPUAlloc=%u CPUErr=%u CPUTot=%u ", alloc_cpus, err_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) ******/ if (node_ptr->node_hostname || node_ptr->node_addr) { xstrfmtcat(out, "NodeAddr=%s NodeHostName=%s Version=%s", node_ptr->node_addr, node_ptr->node_hostname, node_ptr->version); xstrcat(out, line_end); } /****** Line ******/ if (node_ptr->os) xstrfmtcat(out, "OS=%s ", node_ptr->os); 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->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 LowestJoules=n/s ConsumedJoules=n/s"); else xstrfmtcat(out, "CurrentWatts=%u " "LowestJoules=%"PRIu64" " "ConsumedJoules=%"PRIu64"", node_ptr->energy->current_watts, node_ptr->energy->base_consumed_energy, node_ptr->energy->consumed_energy); xstrcat(out, line_end); /****** external sensors Line ******/ if (!node_ptr->ext_sensors || node_ptr->ext_sensors->consumed_energy == NO_VAL) 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); slurm_get_select_nodeinfo(node_ptr->select_nodeinfo, SELECT_NODEDATA_EXTRA_INFO, 0, &select_reason_str); if (select_reason_str && select_reason_str[0]) { if (reason_str) xstrcat(reason_str, "\n"); xstrcat(reason_str, select_reason_str); } xfree(select_reason_str); 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"); return out; }
/* * 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 node_scaling - number of nodes each node represents * 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 node_scaling, int one_liner ) { uint16_t my_state = node_ptr->node_state; char *comp_str = "", *drain_str = "", *power_str = ""; char tmp_line[512], time_str[32]; char *out = NULL; uint16_t err_cpus = 0, alloc_cpus = 0; int cpus_per_node = 1; int total_used = node_ptr->cpus; uint32_t cluster_flags = slurmdb_setup_cluster_flags(); if (node_scaling) cpus_per_node = node_ptr->cpus / node_scaling; 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_POWER_SAVE) { my_state &= (~NODE_STATE_POWER_SAVE); power_str = "+POWER"; } slurm_get_select_nodeinfo(node_ptr->select_nodeinfo, SELECT_NODEDATA_SUBCNT, NODE_STATE_ALLOCATED, &alloc_cpus); if (cluster_flags & CLUSTER_FLAG_BG) { if (!alloc_cpus && (IS_NODE_ALLOCATED(node_ptr) || IS_NODE_COMPLETING(node_ptr))) alloc_cpus = node_ptr->cpus; else alloc_cpus *= cpus_per_node; } total_used -= alloc_cpus; slurm_get_select_nodeinfo(node_ptr->select_nodeinfo, SELECT_NODEDATA_SUBCNT, NODE_STATE_ERROR, &err_cpus); if (cluster_flags & CLUSTER_FLAG_BG) err_cpus *= cpus_per_node; total_used -= err_cpus; if ((alloc_cpus && err_cpus) || (total_used && (total_used != node_ptr->cpus))) { my_state &= NODE_STATE_FLAGS; my_state |= NODE_STATE_MIXED; } /****** Line 1 ******/ snprintf(tmp_line, sizeof(tmp_line), "NodeName=%s ", node_ptr->name); xstrcat(out, tmp_line); if (node_ptr->arch) { snprintf(tmp_line, sizeof(tmp_line), "Arch=%s ", node_ptr->arch); xstrcat(out, tmp_line); } snprintf(tmp_line, sizeof(tmp_line), "CoresPerSocket=%u", node_ptr->cores); xstrcat(out, tmp_line); if (one_liner) xstrcat(out, " "); else xstrcat(out, "\n "); /****** Line 2 ******/ snprintf(tmp_line, sizeof(tmp_line), "CPUAlloc=%u CPUErr=%u CPUTot=%u Features=%s", alloc_cpus, err_cpus, node_ptr->cpus, node_ptr->features); xstrcat(out, tmp_line); if (one_liner) xstrcat(out, " "); else xstrcat(out, "\n "); /****** Line 3 ******/ snprintf(tmp_line, sizeof(tmp_line), "Gres=%s",node_ptr->gres); xstrcat(out, tmp_line); if (one_liner) xstrcat(out, " "); else xstrcat(out, "\n "); /****** Line 4 (optional) ******/ if (node_ptr->node_hostname || node_ptr->node_addr) { snprintf(tmp_line, sizeof(tmp_line), "NodeAddr=%s NodeHostName=%s", node_ptr->node_addr, node_ptr->node_hostname); xstrcat(out, tmp_line); if (one_liner) xstrcat(out, " "); else xstrcat(out, "\n "); } /****** Line 5 ******/ if (node_ptr->os) { snprintf(tmp_line, sizeof(tmp_line), "OS=%s ", node_ptr->os); xstrcat(out, tmp_line); } snprintf(tmp_line, sizeof(tmp_line), "RealMemory=%u Sockets=%u", node_ptr->real_memory, node_ptr->sockets); xstrcat(out, tmp_line); if (one_liner) xstrcat(out, " "); else xstrcat(out, "\n "); /****** Line 6 ******/ snprintf(tmp_line, sizeof(tmp_line), "State=%s%s%s%s ThreadsPerCore=%u TmpDisk=%u Weight=%u", node_state_string(my_state), comp_str, drain_str, power_str, node_ptr->threads, node_ptr->tmp_disk, node_ptr->weight); xstrcat(out, tmp_line); if (one_liner) xstrcat(out, " "); else xstrcat(out, "\n "); /****** Line 7 ******/ if (node_ptr->boot_time) { slurm_make_time_str ((time_t *)&node_ptr->boot_time, time_str, sizeof(time_str)); } else { strncpy(time_str, "None", sizeof(time_str)); } snprintf(tmp_line, sizeof(tmp_line), "BootTime=%s ", time_str); xstrcat(out, tmp_line); if (node_ptr->slurmd_start_time) { slurm_make_time_str ((time_t *)&node_ptr->slurmd_start_time, time_str, sizeof(time_str)); } else { strncpy(time_str, "None", sizeof(time_str)); } snprintf(tmp_line, sizeof(tmp_line), "SlurmdStartTime=%s", time_str); xstrcat(out, tmp_line); if (one_liner) xstrcat(out, " "); else xstrcat(out, "\n "); /****** Line 8 ******/ if (node_ptr->reason_time) { char *user_name = uid_to_string(node_ptr->reason_uid); slurm_make_time_str ((time_t *)&node_ptr->reason_time, time_str, sizeof(time_str)); snprintf(tmp_line, sizeof(tmp_line), "Reason=%s [%s@%s]", node_ptr->reason, user_name, time_str); xstrcat(out, tmp_line); xfree(user_name); } else { snprintf(tmp_line, sizeof(tmp_line), "Reason=%s", node_ptr->reason); xstrcat(out, tmp_line); } if (one_liner) xstrcat(out, "\n"); else xstrcat(out, "\n\n"); return out; }
/* * Update front end node state * update_front_end_msg_ptr IN change specification * RET SLURM_SUCCESS or error code */ extern int update_front_end(update_front_end_msg_t *msg_ptr) { #ifdef HAVE_FRONT_END char *this_node_name = NULL; hostlist_t host_list; front_end_record_t *front_end_ptr; int i, rc = SLURM_SUCCESS; time_t now = time(NULL); if ((host_list = hostlist_create(msg_ptr->name)) == NULL) { error("hostlist_create error on %s: %m", msg_ptr->name); return ESLURM_INVALID_NODE_NAME; } last_front_end_update = now; while ((this_node_name = hostlist_shift(host_list))) { for (i = 0, front_end_ptr = front_end_nodes; i < front_end_node_cnt; i++, front_end_ptr++) { xassert(front_end_ptr->magic == FRONT_END_MAGIC); if (strcmp(this_node_name, front_end_ptr->name)) continue; if (msg_ptr->node_state == (uint16_t) NO_VAL) { ; /* No change in node state */ } else if (msg_ptr->node_state == NODE_RESUME) { front_end_ptr->node_state = NODE_STATE_IDLE; xfree(front_end_ptr->reason); front_end_ptr->reason_time = 0; front_end_ptr->reason_uid = 0; } else if (msg_ptr->node_state == NODE_STATE_DRAIN) { front_end_ptr->node_state |= NODE_STATE_DRAIN; if (msg_ptr->reason) { xfree(front_end_ptr->reason); front_end_ptr->reason = xstrdup(msg_ptr->reason); front_end_ptr->reason_time = now; front_end_ptr->reason_uid = msg_ptr->reason_uid; } } else if (msg_ptr->node_state == NODE_STATE_DOWN) { set_front_end_down(front_end_ptr, msg_ptr->reason); } if (msg_ptr->node_state != (uint16_t) NO_VAL) { info("update_front_end: set state of %s to %s", this_node_name, node_state_string(front_end_ptr-> node_state)); } break; } if (i >= front_end_node_cnt) { info("update_front_end: could not find front end: %s", this_node_name); rc = ESLURM_INVALID_NODE_NAME; } free(this_node_name); } hostlist_destroy(host_list); return rc; #else return ESLURM_INVALID_NODE_NAME; #endif }
/* * 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; }
/* Return false if this node's data needs to be added to sinfo's table of * data to print. Return true if it is duplicate/redundant data. */ static bool _match_node_data(sinfo_data_t *sinfo_ptr, node_info_t *node_ptr) { uint32_t tmp = 0; if (params.node_flag) return false; if (params.match_flags.hostnames_flag && (hostlist_find(sinfo_ptr->hostnames, node_ptr->node_hostname) == -1)) return false; if (params.match_flags.node_addr_flag && (hostlist_find(sinfo_ptr->node_addr, node_ptr->node_addr) == -1)) return false; if (sinfo_ptr->nodes && params.match_flags.features_flag && (xstrcmp(node_ptr->features, sinfo_ptr->features))) return false; if (sinfo_ptr->nodes && params.match_flags.features_act_flag && (xstrcmp(node_ptr->features_act, sinfo_ptr->features_act))) return false; if (sinfo_ptr->nodes && params.match_flags.gres_flag && (xstrcmp(node_ptr->gres, sinfo_ptr->gres))) return false; if (sinfo_ptr->nodes && params.match_flags.reason_flag && (xstrcmp(node_ptr->reason, sinfo_ptr->reason))) return false; if (sinfo_ptr->nodes && params.match_flags.reason_timestamp_flag && (node_ptr->reason_time != sinfo_ptr->reason_time)) return false; if (sinfo_ptr->nodes && params.match_flags.reason_user_flag && node_ptr->reason_uid != sinfo_ptr->reason_uid) { return false; } if (params.match_flags.state_flag) { char *state1, *state2; state1 = node_state_string(node_ptr->node_state); state2 = node_state_string(sinfo_ptr->node_state); if (xstrcmp(state1, state2)) return false; } select_g_select_nodeinfo_get(node_ptr->select_nodeinfo, SELECT_NODEDATA_MEM_ALLOC, NODE_STATE_ALLOCATED, &tmp); if (params.match_flags.alloc_mem_flag && (tmp != sinfo_ptr->alloc_memory)) return false; /* If no need to exactly match sizes, just return here * otherwise check cpus, disk, memory and weigth individually */ if (!params.exact_match) return true; if (params.match_flags.cpus_flag && (node_ptr->cpus != sinfo_ptr->min_cpus)) return false; if (params.match_flags.sockets_flag && (node_ptr->sockets != sinfo_ptr->min_sockets)) return false; if (params.match_flags.cores_flag && (node_ptr->cores != sinfo_ptr->min_cores)) return false; if (params.match_flags.threads_flag && (node_ptr->threads != sinfo_ptr->min_threads)) return false; if (params.match_flags.sct_flag && ((node_ptr->sockets != sinfo_ptr->min_sockets) || (node_ptr->cores != sinfo_ptr->min_cores) || (node_ptr->threads != sinfo_ptr->min_threads))) return false; if (params.match_flags.disk_flag && (node_ptr->tmp_disk != sinfo_ptr->min_disk)) return false; if (params.match_flags.memory_flag && (node_ptr->real_memory != sinfo_ptr->min_mem)) return false; if (params.match_flags.weight_flag && (node_ptr->weight != sinfo_ptr->min_weight)) return false; if (params.match_flags.cpu_load_flag && (node_ptr->cpu_load != sinfo_ptr->min_cpu_load)) return false; if (params.match_flags.free_mem_flag && (node_ptr->free_mem != sinfo_ptr->min_free_mem)) return false; if (params.match_flags.version_flag && (node_ptr->version != sinfo_ptr->version)) return false; return true; }
/* * scontrol_update_node - update the slurm node 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_node (int argc, char **argv) { int i, j, rc = 0, update_cnt = 0; uint16_t state_val; update_node_msg_t node_msg; char *reason_str = NULL; char *tag, *val; int tag_len, val_len; slurm_init_update_node_msg(&node_msg); for (i = 0; i < argc; i++) { tag = argv[i]; val = strchr(argv[i], '='); if (val) { tag_len = val - argv[i]; val++; val_len = strlen(val); } else { exit_code = 1; error("Invalid input: %s Request aborted", argv[i]); return -1; } if (xstrncasecmp(tag, "NodeAddr", MAX(tag_len, 5)) == 0) { node_msg.node_addr = val; update_cnt++; } else if (xstrncasecmp(tag, "NodeHostName", MAX(tag_len, 5)) == 0) { node_msg.node_hostname = val; update_cnt++; } else if (xstrncasecmp(tag, "NodeName", MAX(tag_len, 1)) == 0) { node_msg.node_names = val; } else if (!xstrncasecmp(tag, "ActiveFeatures", MAX(tag_len,3))) { node_msg.features_act = val; update_cnt++; } else if (xstrncasecmp(tag, "CpuBind", MAX(tag_len, 7)) == 0) { if (xlate_cpu_bind_str(val, &node_msg.cpu_bind) != SLURM_SUCCESS) { exit_code = 1; error("Invalid input %s", argv[i]); return -1; } update_cnt++; } else if (!xstrncasecmp(tag, "Features", MAX(tag_len, 1)) || !xstrncasecmp(tag, "AvailableFeatures", MAX(tag_len,3))) { node_msg.features = val; update_cnt++; } else if (xstrncasecmp(tag, "Gres", MAX(tag_len, 1)) == 0) { node_msg.gres = val; update_cnt++; } else if (xstrncasecmp(tag, "Weight", MAX(tag_len,1)) == 0) { /* Logic borrowed from function _handle_uint32 */ char *endptr; unsigned long num; errno = 0; num = strtoul(val, &endptr, 0); if ((endptr[0] == 'k') || (endptr[0] == 'K')) { num *= 1024; endptr++; } if ((num == 0 && errno == EINVAL) || (*endptr != '\0')) { if ((xstrcasecmp(val, "UNLIMITED") == 0) || (xstrcasecmp(val, "INFINITE") == 0)) { num = INFINITE; } else { error("Weight value (%s) is not a " "valid number", val); break; } } else if (errno == ERANGE) { error("Weight value (%s) is out of range", val); break; } else if (val[0] == '-') { error("Weight value (%s) is less than zero", val); break; } else if (num > 0xfffffff0) { error("Weight value (%s) is greater than %u", val, 0xfffffff0); break; } node_msg.weight = num; update_cnt++; } else if (xstrncasecmp(tag, "Reason", MAX(tag_len, 1)) == 0) { int len = strlen(val); reason_str = xmalloc(len+1); if (*val == '"') strcpy(reason_str, val+1); else strcpy(reason_str, val); len = strlen(reason_str) - 1; if ((len >= 0) && (reason_str[len] == '"')) reason_str[len] = '\0'; node_msg.reason = reason_str; if ((getlogin() == NULL) || (uid_from_string(getlogin(), &node_msg.reason_uid) < 0)) { node_msg.reason_uid = getuid(); } update_cnt++; } else if (xstrncasecmp(tag, "State", MAX(tag_len, 1)) == 0) { if (cluster_flags & CLUSTER_FLAG_CRAY_A) { fprintf (stderr, "%s can not be changed through" " SLURM. Use native Cray tools such as" " xtprocadmin(8)\n", argv[i]); fprintf (stderr, "Request aborted\n"); exit_code = 1; goto done; } if (xstrncasecmp(val, "NoResp", MAX(val_len, 3)) == 0) { node_msg.node_state = NODE_STATE_NO_RESPOND; update_cnt++; } else if (xstrncasecmp(val, "DRAIN", MAX(val_len, 3)) == 0) { node_msg.node_state = NODE_STATE_DRAIN; update_cnt++; } else if (xstrncasecmp(val, "FAIL", MAX(val_len, 3)) == 0) { node_msg.node_state = NODE_STATE_FAIL; update_cnt++; } else if (xstrncasecmp(val, "FUTURE", MAX(val_len, 3)) == 0) { node_msg.node_state = NODE_STATE_FUTURE; update_cnt++; } else if (xstrncasecmp(val, "RESUME", MAX(val_len, 3)) == 0) { node_msg.node_state = NODE_RESUME; update_cnt++; } else if (xstrncasecmp(val, "POWER_DOWN", MAX(val_len, 7)) == 0) { node_msg.node_state = NODE_STATE_POWER_SAVE; update_cnt++; } else if (xstrncasecmp(val, "POWER_UP", MAX(val_len, 7)) == 0) { node_msg.node_state = NODE_STATE_POWER_UP; update_cnt++; } else if (xstrncasecmp(val, "UNDRAIN", MAX(val_len, 3)) == 0) { node_msg.node_state = NODE_STATE_UNDRAIN; update_cnt++; } else { state_val = NO_VAL16; for (j = 0; j < NODE_STATE_END; j++) { if (xstrncasecmp(node_state_string(j), val, MAX(val_len, 3)) == 0){ state_val = (uint16_t) j; break; } } if (j == NODE_STATE_END) { exit_code = 1; fprintf(stderr, "Invalid input: %s\n", argv[i]); fprintf (stderr, "Request aborted\n"); fprintf (stderr, "Valid states are: "); fprintf (stderr, "NoResp DRAIN FAIL FUTURE RESUME " "POWER_DOWN POWER_UP UNDRAIN"); fprintf (stderr, "\n"); fprintf (stderr, "Not all states are valid " "given a node's prior " "state\n"); goto done; } node_msg.node_state = state_val; update_cnt++; } } else { exit_code = 1; fprintf (stderr, "Update of this parameter is not " "supported: %s\n", argv[i]); fprintf (stderr, "Request aborted\n"); goto done; } } if (((node_msg.node_state == NODE_STATE_DOWN) || (node_msg.node_state == NODE_STATE_DRAIN) || (node_msg.node_state == NODE_STATE_FAIL)) && ((node_msg.reason == NULL) || (strlen(node_msg.reason) == 0))) { fprintf(stderr, "You must specify a reason when DOWNING or " "DRAINING a node. Request denied\n"); goto done; } if (update_cnt == 0) { exit_code = 1; fprintf (stderr, "No changes specified\n"); return 0; } rc = slurm_update_node(&node_msg); done: xfree(reason_str); if (rc) { exit_code = 1; return slurm_get_errno (); } else return 0; }
static bool _match_node_data(sinfo_data_t *sinfo_ptr, node_info_t *node_ptr) { if (params.match_flags.hostnames_flag || params.match_flags.node_addr_flag) return false; if (sinfo_ptr->nodes && params.match_flags.features_flag && (_strcmp(node_ptr->features, sinfo_ptr->features))) return false; if (sinfo_ptr->nodes && params.match_flags.gres_flag && (_strcmp(node_ptr->gres, sinfo_ptr->gres))) return false; if (sinfo_ptr->nodes && params.match_flags.reason_flag && (_strcmp(node_ptr->reason, sinfo_ptr->reason))) return false; if (sinfo_ptr->nodes && params.match_flags.reason_timestamp_flag && (node_ptr->reason_time != sinfo_ptr->reason_time)) return false; if (sinfo_ptr->nodes && params.match_flags.reason_user_flag && node_ptr->reason_uid != sinfo_ptr->reason_uid) { return false; } if (params.match_flags.state_flag) { char *state1, *state2; state1 = node_state_string(node_ptr->node_state); state2 = node_state_string(sinfo_ptr->node_state); if (strcmp(state1, state2)) return false; } /* If no need to exactly match sizes, just return here * otherwise check cpus, disk, memory and weigth individually */ if (!params.exact_match) return true; if (params.match_flags.cpus_flag && (node_ptr->cpus != sinfo_ptr->min_cpus)) return false; if (params.match_flags.sockets_flag && (node_ptr->sockets != sinfo_ptr->min_sockets)) return false; if (params.match_flags.cores_flag && (node_ptr->cores != sinfo_ptr->min_cores)) return false; if (params.match_flags.threads_flag && (node_ptr->threads != sinfo_ptr->min_threads)) return false; if (params.match_flags.sct_flag && ((node_ptr->sockets != sinfo_ptr->min_sockets) || (node_ptr->cores != sinfo_ptr->min_cores) || (node_ptr->threads != sinfo_ptr->min_threads))) return false; if (params.match_flags.disk_flag && (node_ptr->tmp_disk != sinfo_ptr->min_disk)) return false; if (params.match_flags.memory_flag && (node_ptr->real_memory != sinfo_ptr->min_mem)) return false; if (params.match_flags.weight_flag && (node_ptr->weight != sinfo_ptr->min_weight)) return false; if (params.match_flags.cpu_load_flag && (node_ptr->cpu_load != sinfo_ptr->min_cpu_load)) return false; if (params.match_flags.version_flag && (node_ptr->version != sinfo_ptr->version)) return false; return true; }
/* Creates a tree model containing the completions */ void _search_entry(sview_search_info_t *sview_search_info) { int id = 0; char title[100]; ListIterator itr = NULL; popup_info_t *popup_win = NULL; GError *error = NULL; char *upper = NULL, *lower = NULL; char *type; if (cluster_flags & CLUSTER_FLAG_BG) type = "Midplane"; else type = "Node"; if (sview_search_info->int_data == NO_VAL && (!sview_search_info->gchar_data || !strlen(sview_search_info->gchar_data))) { g_print("nothing given to search for.\n"); return; } switch(sview_search_info->search_type) { case SEARCH_JOB_STATE: id = JOB_PAGE; upper = job_state_string(sview_search_info->int_data); lower = str_tolower(upper); snprintf(title, 100, "Job(s) in the %s state", lower); xfree(lower); break; case SEARCH_JOB_ID: id = JOB_PAGE; snprintf(title, 100, "Job %s info", sview_search_info->gchar_data); break; case SEARCH_JOB_USER: id = JOB_PAGE; snprintf(title, 100, "Job(s) info for user %s", sview_search_info->gchar_data); break; case SEARCH_BLOCK_STATE: id = BLOCK_PAGE; upper = bg_block_state_string(sview_search_info->int_data); lower = str_tolower(upper); snprintf(title, 100, "BG Block(s) in the %s state", lower); xfree(lower); break; case SEARCH_BLOCK_NAME: id = BLOCK_PAGE; snprintf(title, 100, "Block %s info", sview_search_info->gchar_data); break; case SEARCH_BLOCK_SIZE: id = BLOCK_PAGE; sview_search_info->int_data = revert_num_unit(sview_search_info->gchar_data); if (sview_search_info->int_data == -1) return; snprintf(title, 100, "Block(s) of size %d cnodes", sview_search_info->int_data); break; case SEARCH_PARTITION_NAME: id = PART_PAGE; snprintf(title, 100, "Partition %s info", sview_search_info->gchar_data); break; case SEARCH_PARTITION_STATE: id = PART_PAGE; if (sview_search_info->int_data) snprintf(title, 100, "Partition(s) that are up"); else snprintf(title, 100, "Partition(s) that are down"); break; case SEARCH_NODE_NAME: id = NODE_PAGE; snprintf(title, 100, "%s(s) %s info", type, sview_search_info->gchar_data); break; case SEARCH_NODE_STATE: id = NODE_PAGE; upper = node_state_string(sview_search_info->int_data); lower = str_tolower(upper); snprintf(title, 100, "%s(s) in the %s state", type, lower); xfree(lower); break; case SEARCH_RESERVATION_NAME: id = RESV_PAGE; snprintf(title, 100, "Reservation %s info", sview_search_info->gchar_data); break; default: g_print("unknown search type %d.\n", sview_search_info->search_type); return; } itr = list_iterator_create(popup_list); while ((popup_win = list_next(itr))) { if (popup_win->spec_info) if (!strcmp(popup_win->spec_info->title, title)) { break; } } list_iterator_destroy(itr); if (!popup_win) { popup_win = create_popup_info(id, id, title); } else { gtk_window_present(GTK_WINDOW(popup_win->popup)); return; } memcpy(popup_win->spec_info->search_info, sview_search_info, sizeof(sview_search_info_t)); if (!g_thread_create((gpointer)popup_thr, popup_win, FALSE, &error)) { g_printerr ("Failed to create main popup thread: %s\n", error->message); return; } return; }
/* * slurm_sprint_front_end_table - output information about a specific Slurm * front_end based upon message as loaded using slurm_load_front_end * IN front_end_ptr - an individual front_end 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_front_end_table (front_end_info_t * front_end_ptr, int one_liner) { uint32_t my_state = front_end_ptr->node_state; char *drain_str = ""; char tmp_line[512], time_str[32]; char *out = NULL; if (my_state & NODE_STATE_DRAIN) { my_state &= (~NODE_STATE_DRAIN); drain_str = "+DRAIN"; } /****** Line 1 ******/ snprintf(tmp_line, sizeof(tmp_line), "FrontendName=%s ", front_end_ptr->name); xstrcat(out, tmp_line); snprintf(tmp_line, sizeof(tmp_line), "State=%s%s ", node_state_string(my_state), drain_str); xstrcat(out, tmp_line); snprintf(tmp_line, sizeof(tmp_line), "Version=%s ", front_end_ptr->version); xstrcat(out, tmp_line); if (front_end_ptr->reason_time) { char *user_name = uid_to_string(front_end_ptr->reason_uid); slurm_make_time_str((time_t *)&front_end_ptr->reason_time, time_str, sizeof(time_str)); snprintf(tmp_line, sizeof(tmp_line), "Reason=%s [%s@%s]", front_end_ptr->reason, user_name, time_str); xstrcat(out, tmp_line); xfree(user_name); } else { snprintf(tmp_line, sizeof(tmp_line), "Reason=%s", front_end_ptr->reason); xstrcat(out, tmp_line); } if (one_liner) xstrcat(out, " "); else xstrcat(out, "\n "); /****** Line 2 ******/ slurm_make_time_str((time_t *)&front_end_ptr->boot_time, time_str, sizeof(time_str)); snprintf(tmp_line, sizeof(tmp_line), "BootTime=%s ", time_str); xstrcat(out, tmp_line); slurm_make_time_str((time_t *)&front_end_ptr->slurmd_start_time, time_str, sizeof(time_str)); snprintf(tmp_line, sizeof(tmp_line), "SlurmdStartTime=%s", time_str); xstrcat(out, tmp_line); if (one_liner) xstrcat(out, " "); else xstrcat(out, "\n "); /****** Line 3 (optional) ******/ if (front_end_ptr->allow_groups || front_end_ptr->allow_users || front_end_ptr->deny_groups || front_end_ptr->deny_users) { if (one_liner) xstrcat(out, " "); else xstrcat(out, "\n "); if (front_end_ptr->allow_groups) { xstrfmtcat(out, "AllowGroups=%s ", front_end_ptr->allow_groups); } if (front_end_ptr->allow_users) { xstrfmtcat(out, "AllowUsers=%s ", front_end_ptr->allow_users); } if (front_end_ptr->deny_groups) { xstrfmtcat(out, "DenyGroups=%s ", front_end_ptr->deny_groups); } if (front_end_ptr->deny_users) { xstrfmtcat(out, "DenyUsers=%s ", front_end_ptr->deny_users); } } if (one_liner) xstrcat(out, "\n"); else xstrcat(out, "\n\n"); return out; }