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;
}