state match

Author: chu11

src/modules/job-list/match.c

@@ -23,6 +23,7 @@
 #include "match.h"
 
 typedef bool (*match_f) (struct constraint *, const struct job *);
+typedef struct constraint * (*create_f) (json_t *, flux_error_t *);
 typedef int (*array_to_bitmask_f) (json_t *, flux_error_t *);
 
 struct constraint {
@@ -84,6 +85,9 @@ static bool match_not (struct constraint *c, const struct job *job)
 }
 
 static struct constraint *conditional_constraint (const char *type,
+                                                  match_f match_or_cb,
+                                                  match_f match_not_cb,
+                                                  create_f create_cb,
                                                   json_t *values,
                                                   flux_error_t *errp)
 {
@@ -101,13 +105,13 @@ static struct constraint *conditional_constraint (const char *type,
     if (streq (type, "and"))
         c->match = match_and;
     else if (streq (type, "or"))
-        c->match = match_or;
+        c->match = match_or_cb;
     else if (streq (type, "not"))
-        c->match = match_not;
+        c->match = match_not_cb;
     zlistx_set_destructor (c->values, constraint_destructor);
 
     json_array_foreach (values, index, entry) {
-        struct constraint *cp = constraint_create (entry, errp);
+        struct constraint *cp = create_cb (entry, errp);
         if (!cp)
             goto error;
         if (!zlistx_add_end (c->values, cp)) {
@@ -452,7 +456,12 @@ struct constraint *constraint_create (json_t *constraint, flux_error_t *errp)
         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_or,
+                                           match_not,
+                                           constraint_create,
+                                           values,
+                                           errp);
         else {
             errprintf (errp, "unknown constraint operator: %s", op);
             return NULL;
@@ -468,5 +477,92 @@ bool job_match (const struct job *job, struct constraint *constraint)
     return constraint->match (constraint, job);
 }
 
+static bool match_or_checkempty (struct constraint *c, const struct job *job)
+{
+    struct constraint *cp = zlistx_first (c->values);
+    bool ran_a_match = false;
+    while (cp) {
+        if (cp->match (cp, job))
+            return true;
+        ran_a_match = true;
+        cp = zlistx_next (c->values);
+    }
+    /* corner case: if no ops, assume this is true */
+    if (!ran_a_match)
+        return true;
+    return false;
+}
+
+static bool match_not_checkempty (struct constraint *c, const struct job *job)
+{
+    struct 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 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 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_or_checkempty,
+                                           match_not_checkempty,
+                                           state_constraint_create,
+                                           values,
+                                           errp);
+        else {
+            errprintf (errp, "unknown constraint operator: %s", op);
+            return NULL;
+        }
+    }
+    return constraint_new (errp);
+}
+
+bool state_match (flux_job_state_t state, struct 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

@@ -34,4 +34,16 @@ void constraint_destroy (struct constraint *constraint);
  */
 bool job_match (const struct job *job, struct constraint *constraint);
 
+/*  Identical to constraint_create() but only cares about
+ *  "states" operation.  Effectively tests the "states" constraint
+ *  operation and everything else is considered true all of the time.
+ */
+struct 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 constraint *constraint);
+
 #endif /* !HAVE_JOB_LIST_MATCH_H */