clang-format slurm.c source

diff --git a/src/slurm.c b/src/slurm.c
index de12272552dfbbbc45595734ee7af477a0820e45..ce6677631ebd54fa307698036ed378851626e237 100644 (file)
--- a/src/slurm.c
+++ b/src/slurm.c
@@ -27,14 +27,14 @@
 #include "common.h"
 #include "plugin.h"
 
-#include <stdio.h>
-#include <stdlib.h>
 #include <slurm/slurm.h>
 #include <slurm/slurm_errno.h>
-#include <sys/types.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
+#include <sys/types.h>
 
-#define PLUGIN_NAME    "slurm"
+#define PLUGIN_NAME "slurm"
 #define PART_NAME_SIZE 128
 
 typedef struct partition_state_st {
@@ -52,52 +52,37 @@ typedef struct partition_state_st {
 } partition_state_t;
 
 /* based on enum node_states from slurm.h */
-static const char* node_state_names[] = {
-  "unknown",
-  "down",
-  "idle",
-  "allocated",
-  "error",
-  "mixed",
-  "future",
+static const char *node_state_names[] = {
+    "unknown", "down", "idle", "allocated", "error", "mixed", "future",
 };
 
 /* based on enum job_states from slurm.h */
-static const char* job_state_names[] = {
-  "pending",
-  "running",
-  "suspended",
-  "complete",
-  "cancelled",
-  "failed",
-  "timeout",
-  "node_fail",
-  "preempted",
-  "boot_fail",
-  "deadline",
-  "oom",
+static const char *job_state_names[] = {
+    "pending", "running",   "suspended", "complete",  "cancelled", "failed",
+    "timeout", "node_fail", "preempted", "boot_fail", "deadline",  "oom",
 };
 
-static partition_state_t *alloc_partition_states(uint32_t num_partitions, partition_info_t *partitions)
-{
+static partition_state_t *alloc_partition_states(uint32_t num_partitions,
+                                                 partition_info_t *partitions) {
   partition_state_t *partition_states;
 
-  partition_states = (partition_state_t*)calloc(num_partitions, sizeof(partition_state_t));
+  partition_states =
+      (partition_state_t *)calloc(num_partitions, sizeof(partition_state_t));
   if (!partition_states) {
     return NULL;
   }
 
-  for (int i=0; i<num_partitions; i++)
+  for (int i = 0; i < num_partitions; i++)
     sstrncpy(partition_states[i].name, partitions[i].name, PART_NAME_SIZE);
 
   return partition_states;
 }
 
-static partition_state_t *find_partition(partition_state_t *partitions, uint32_t num_partitions, char *name)
-{
+static partition_state_t *find_partition(partition_state_t *partitions,
+                                         uint32_t num_partitions, char *name) {
   partition_state_t *part = NULL;
 
-  for(int i=0; i<num_partitions; i++) {
+  for (int i = 0; i < num_partitions; i++) {
     if (strncmp(name, partitions[i].name, PART_NAME_SIZE) == 0)
       part = &partitions[i];
   }
@@ -125,11 +110,13 @@ static void slurm_submit(const char *plugin_instance, const char *type,
 }
 
 static void slurm_submit_partition(partition_state_t *partition) {
-  for (int i=0; i<JOB_END; i++) {
-    slurm_submit(partition->name, "count", job_state_names[i], partition->jobs_states[i]);
+  for (int i = 0; i < JOB_END; i++) {
+    slurm_submit(partition->name, "count", job_state_names[i],
+                 partition->jobs_states[i]);
   }
-  for (int i=0; i<NODE_STATE_END; i++) {
-    slurm_submit(partition->name, "count", node_state_names[i], partition->nodes_states[i]);
+  for (int i = 0; i < NODE_STATE_END; i++) {
+    slurm_submit(partition->name, "count", node_state_names[i],
+                 partition->nodes_states[i]);
   }
   slurm_submit(partition->name, "count", "drain", partition->drain);
   slurm_submit(partition->name, "count", "completing", partition->completing);
@@ -139,8 +126,8 @@ static void slurm_submit_partition(partition_state_t *partition) {
 }
 
 static int slurm_read(void) {
-  job_info_msg_t       * job_buffer_ptr = NULL;
-  job_info_t * job_ptr;
+  job_info_msg_t *job_buffer_ptr = NULL;
+  job_info_t *job_ptr;
   partition_info_msg_t *part_buffer_ptr = NULL;
   partition_info_t *part_ptr;
   partition_state_t *partition_states;
@@ -148,21 +135,18 @@ static int slurm_read(void) {
   node_info_msg_t *node_buffer_ptr = NULL;
   node_info_t *node_ptr;
 
-  if (slurm_load_jobs((time_t)NULL,
-        &job_buffer_ptr, SHOW_ALL) ) {
+  if (slurm_load_jobs((time_t)NULL, &job_buffer_ptr, SHOW_ALL)) {
     ERROR("slurm_load_jobs error");
     return -1;
   }
 
-  if (slurm_load_node((time_t)NULL,
-        &node_buffer_ptr, SHOW_ALL) ) {
+  if (slurm_load_node((time_t)NULL, &node_buffer_ptr, SHOW_ALL)) {
     slurm_free_job_info_msg(job_buffer_ptr);
     ERROR("slurm_load_node error");
     return -1;
   }
 
-  if (slurm_load_partitions((time_t)NULL,
-        &part_buffer_ptr, 0) ) {
+  if (slurm_load_partitions((time_t)NULL, &part_buffer_ptr, 0)) {
     slurm_free_job_info_msg(job_buffer_ptr);
     slurm_free_node_info_msg(node_buffer_ptr);
     ERROR("slurm_load_partitions error");
@@ -170,11 +154,13 @@ static int slurm_read(void) {
   }
 
   /* SLURM APIs provide *non-relational* data about nodes, partitions and jobs.
-   * We allocate a data structure that relates all three together, and the following
+   * We allocate a data structure that relates all three together, and the
+   * following
    * two for loops fill this data structure. The data structure is an array
    * of partition_state_t that holds job and node states. */
   uint32_t num_partitions = part_buffer_ptr->record_count;
-  partition_states = alloc_partition_states(num_partitions, part_buffer_ptr->partition_array);
+  partition_states =
+      alloc_partition_states(num_partitions, part_buffer_ptr->partition_array);
   if (!partition_states) {
     slurm_free_job_info_msg(job_buffer_ptr);
     slurm_free_node_info_msg(node_buffer_ptr);
@@ -184,9 +170,10 @@ static int slurm_read(void) {
   }
 
   /* fill partition_states array with per-partition job state information */
-  for (int i=0; i<job_buffer_ptr->record_count; i++) {
+  for (int i = 0; i < job_buffer_ptr->record_count; i++) {
     job_ptr = &job_buffer_ptr->job_array[i];
-    partition_state = find_partition(partition_states, num_partitions, job_ptr->partition);
+    partition_state =
+        find_partition(partition_states, num_partitions, job_ptr->partition);
     if (!partition_state) {
       ERROR("slurm_read: cannot find partition %s from jobid %d"
             " in partition list returned by slurm_load_partitions",
@@ -199,10 +186,11 @@ static int slurm_read(void) {
   }
 
   /* fill partition_states array with per-partition node state information */
-  for (int i=0; i<part_buffer_ptr->record_count; i++) {
+  for (int i = 0; i < part_buffer_ptr->record_count; i++) {
     part_ptr = &part_buffer_ptr->partition_array[i];
 
-    partition_state = find_partition(partition_states, num_partitions, part_ptr->name);
+    partition_state =
+        find_partition(partition_states, num_partitions, part_ptr->name);
     if (!partition_state) {
       ERROR("slurm_read: cannot find partition %s"
             " in partition list returned by slurm_load_partitions",
@@ -210,14 +198,13 @@ static int slurm_read(void) {
       continue;
     }
 
-    for (int j=0; part_ptr->node_inx; j+=2) {
+    for (int j = 0; part_ptr->node_inx; j += 2) {
       if (part_ptr->node_inx[j] == -1)
         break;
-      for (int k = part_ptr->node_inx[j];
-          k <= part_ptr->node_inx[j+1];
-          k++) {
+      for (int k = part_ptr->node_inx[j]; k <= part_ptr->node_inx[j + 1]; k++) {
         node_ptr = &node_buffer_ptr->node_array[k];
-        /* some non-existant nodes (name is NULL) may show up as node_state FUTURE */
+        /* some non-existant nodes (name is NULL) may show up as node_state
+         * FUTURE */
         uint8_t node_state = node_ptr->node_state & NODE_STATE_BASE;
         partition_state->nodes_states[node_state]++;
         if (node_ptr->node_state & NODE_STATE_DRAIN)
@@ -234,16 +221,14 @@ static int slurm_read(void) {
     }
   }
 
-  for (int i=0; i<num_partitions; i++)
+  for (int i = 0; i < num_partitions; i++)
     slurm_submit_partition(&partition_states[i]);
 
-  slurm_free_job_info_msg (job_buffer_ptr);
+  slurm_free_job_info_msg(job_buffer_ptr);
   slurm_free_node_info_msg(node_buffer_ptr);
   slurm_free_partition_info_msg(part_buffer_ptr);
   free(partition_states);
   return 0;
 }
 
-void module_register(void) {
-  plugin_register_read("slurm", slurm_read);
-}
+void module_register(void) { plugin_register_read("slurm", slurm_read); }