state match

Author: chu11

src/modules/job-list/match.c

@@ -23,6 +23,7 @@
 #include "match.h"
 
 typedef bool (*match_f) (struct list_constraint *, const struct job *);
+typedef struct list_constraint * (*create_f) (json_t *, flux_error_t *);
 typedef int (*array_to_bitmask_f) (json_t *, flux_error_t *);
 
 struct list_constraint {
@@ -84,6 +85,8 @@ static bool match_not (struct list_constraint *c, const struct job *job)
 }
 
 static struct list_constraint *conditional_constraint (const char *type,
+                                                       match_f match_not_cb,
+                                                       create_f create_cb,
                                                        json_t *values,
                                                        flux_error_t *errp)
 {
@@ -103,11 +106,11 @@ static struct list_constraint *conditional_constraint (const char *type,
     else if (streq (type, "or"))
         c->match = match_or;
     else if (streq (type, "not"))
-        c->match = match_not;
+        c->match = match_not_cb;
     zlistx_set_destructor (c->values, list_constraint_destructor);
 
     json_array_foreach (values, index, entry) {
-        struct list_constraint *cp = list_constraint_create (entry, errp);
+        struct list_constraint *cp = create_cb (entry, errp);
         if (!cp)
             goto error;
         if (!zlistx_add_end (c->values, cp)) {
@@ -450,7 +453,11 @@ struct list_constraint *list_constraint_create (json_t *constraint,
         else if (streq (op, "since"))
             return create_since_constraint (values, errp);
         else if (streq (op, "or") || streq (op, "and") || streq (op, "not"))
-            return conditional_constraint (op, values, errp);
+            return conditional_constraint (op,
+                                           match_not,
+                                           list_constraint_create,
+                                           values,
+                                           errp);
         else {
             errprintf (errp, "unknown constraint operator: %s", op);
             return NULL;
@@ -466,5 +473,75 @@ bool job_match (const struct job *job, struct list_constraint *constraint)
     return constraint->match (constraint, job);
 }
 
+static bool match_not_checkempty (struct list_constraint *c, const struct job *job)
+{
+    struct list_constraint *cp = zlistx_first (c->values);
+    bool ran_a_match = false;
+    while (cp) {
+        if (!cp->match (cp, job))
+            return true;
+        if (cp->match != match_empty)
+            ran_a_match = true;
+        cp = zlistx_next (c->values);
+    }
+    /* if no real match callbacks were run, assume this conditional is true */
+    if (!ran_a_match)
+        return true;
+    return false;
+}
+
+struct list_constraint *state_constraint_create (json_t *constraint,
+                                                 flux_error_t *errp)
+{
+    const char *op;
+    json_t *values;
+
+    if (!constraint || !json_is_object (constraint)) {
+        errprintf (errp, "constraint must be JSON object");
+        return NULL;
+    }
+    if (json_object_size (constraint) > 1) {
+        errprintf (errp, "constraint must only contain 1 element");
+        return NULL;
+    }
+    json_object_foreach (constraint, op, values) {
+        if (!json_is_array (values)) {
+            errprintf (errp, "operator %s values not an array", op);
+            return NULL;
+        }
+        if (streq (op, "userid")
+            || streq (op, "name")
+            || streq (op, "queue")
+            || streq (op, "results")
+            || streq (op, "since"))
+            return list_constraint_new (errp);
+        else if (streq (op, "states"))
+            return create_states_constraint (values, errp);
+        else if (streq (op, "or") || streq (op, "and") || streq (op, "not"))
+            return conditional_constraint (op,
+                                           match_not_checkempty,
+                                           state_constraint_create,
+                                           values,
+                                           errp);
+        else {
+            errprintf (errp, "unknown constraint operator: %s", op);
+            return NULL;
+        }
+    }
+    return list_constraint_new (errp);
+}
+
+bool state_match (flux_job_state_t state, struct list_constraint *constraint)
+{
+    int valid_states = (FLUX_JOB_STATE_ACTIVE | FLUX_JOB_STATE_INACTIVE);
+    struct job job;
+
+    if (!state || (state & ~valid_states) || !constraint)
+        return false;
+
+    job.state = state;
+    return constraint->match (constraint, &job);
+}
+
 /* vi: ts=4 sw=4 expandtab
  */

src/modules/job-list/match.h

@@ -35,4 +35,17 @@ void list_constraint_destroy (struct list_constraint *constraint);
  */
 bool job_match (const struct job *job, struct list_constraint *constraint);
 
+/*  Identical to list_constraint_create() but only cares about
+ *  "states" operation.  Effectively tests the 'states' constraint
+ *  operation and conditionals with 'states', everything else is
+ *  considered true all of the time.
+ */
+struct list_constraint *state_constraint_create (json_t *constraint,
+                                                 flux_error_t *errp);
+
+/* determines if a job in 'state' could potentially return true with
+ * the given constraint.
+ */
+bool state_match (flux_job_state_t state, struct list_constraint *constraint);
+
 #endif /* !HAVE_JOB_LIST_MATCH_H */