job-info: support job info CURRENT lookup flag

Problem: It is inconvenient that there is a job-info.lookup target
and job-info.update-lookup target.

Support the behavior of job-info.update-lookup in job-info.lookup
via a new FLUX_JOB_LOOKUP_CURRENT flag.

Author: chu11

src/common/libjob/job.h

@@ -35,6 +35,11 @@ enum job_lookup_flags {
      * - currently works for jobspec and R
      */
     FLUX_JOB_LOOKUP_JSON_DECODE = 1,
+    /* get current value of special fields by applying eventlog
+     * updates for those fields
+     * - currently works for R
+     */
+    FLUX_JOB_LOOKUP_CURRENT = 2,
 };
 
 enum job_urgency {

src/modules/job-info/lookup.c

@@ -18,6 +18,9 @@
 #include <assert.h>
 
 #include "src/common/libczmqcontainers/czmq_containers.h"
+#include "src/common/libeventlog/eventlog.h"
+#include "src/common/libjob/idf58.h"
+#include "src/common/libutil/jpath.h"
 #include "ccan/str/str.h"
 
 #include "job-info.h"
@@ -151,11 +154,105 @@ static int lookup_keys (struct lookup_ctx *l)
     return -1;
 }
 
+static void apply_updates_R (struct lookup_ctx *l,
+                             const char *key,
+                             json_t *update_object,
+                             json_t *context)
+{
+    const char *context_key;
+    json_t *value;
+
+    json_object_foreach (context, context_key, value) {
+        /* RFC 21 resource-update event only allows update
+         * to:
+         * - expiration
+         */
+        if (streq (context_key, "expiration"))
+            if (jpath_set (update_object,
+                           "execution.expiration",
+                           value) < 0)
+                flux_log (l->ctx->h, LOG_INFO,
+                          "%s: failed to update job %s %s",
+                          __FUNCTION__, idf58 (l->id), key);
+    }
+}
+
+static int lookup_current (struct lookup_ctx *l,
+                           flux_future_t *fall,
+                           const char *key,
+                           const char *value,
+                           char **current_value)
+{
+    flux_future_t *f_eventlog;
+    const char *s_eventlog;
+    json_t *value_object = NULL;
+    json_t *eventlog = NULL;
+    size_t index;
+    json_t *entry;
+    const char *update_event_name = NULL;
+    char *value_object_str = NULL;
+    int save_errno;
+
+    if (streq (key, "R"))
+        update_event_name = "resource-update";
+
+    if (!(value_object = json_loads (value, 0, NULL))) {
+        errno = EINVAL;
+        goto error;
+    }
+
+    if (!(f_eventlog = flux_future_get_child (fall, "eventlog"))) {
+        flux_log_error (l->ctx->h, "%s: flux_future_get_child",
+                        __FUNCTION__);
+        goto error;
+    }
+
+    if (flux_kvs_lookup_get (f_eventlog, &s_eventlog) < 0) {
+        if (errno != ENOENT)
+            flux_log_error (l->ctx->h, "%s: flux_kvs_lookup_get",
+                            __FUNCTION__);
+        goto error;
+    }
+
+    if (!(eventlog = eventlog_decode (s_eventlog))) {
+        errno = EINVAL;
+        goto error;
+    }
+
+    json_array_foreach (eventlog, index, entry) {
+        const char *name;
+        json_t *context = NULL;
+        if (eventlog_entry_parse (entry, NULL, &name, &context) < 0)
+            goto error;
+        if (streq (name, update_event_name)) {
+            if (streq (key, "R"))
+                apply_updates_R (l, key, value_object, context);
+        }
+    }
+
+    if (!(value_object_str = json_dumps (value_object, 0)))
+        goto error;
+
+    (*current_value) = value_object_str;
+    json_decref (eventlog);
+    json_decref (value_object);
+    return 0;
+
+error:
+    save_errno = errno;
+    json_decref (eventlog);
+    json_decref (value_object);
+    free (value_object_str);
+    errno = save_errno;
+    return -1;
+}
+
 static void info_lookup_continuation (flux_future_t *fall, void *arg)
 {
     struct lookup_ctx *l = arg;
     struct info_ctx *ctx = l->ctx;
     const char *s;
+    char *current_value = NULL;
     size_t index;
     json_t *key;
     json_t *o = NULL;
@@ -212,6 +309,15 @@ static void info_lookup_continuation (flux_future_t *fall, void *arg)
             goto error;
         }
 
+        if ((l->flags & FLUX_JOB_LOOKUP_CURRENT)
+            && streq (keystr, "R")) {
+            if (lookup_current (l, fall, keystr, s, &current_value) < 0)
+                goto error;
+            s = current_value;
+        }
+
+        /* check for JSON_DECODE flag last, as changes above could affect
+         * desired value */
         if ((l->flags & FLUX_JOB_LOOKUP_JSON_DECODE)
             && (streq (keystr, "jobspec")
                 || streq (keystr, "R"))) {
@@ -229,6 +335,9 @@ static void info_lookup_continuation (flux_future_t *fall, void *arg)
             json_decref (val);
             goto enomem;
         }
+
+        free (current_value);
+        current_value = NULL;
     }
 
     /* must have been allowed earlier or above, otherwise should have
@@ -256,18 +365,23 @@ static void info_lookup_continuation (flux_future_t *fall, void *arg)
      * via zlist_remove() */
     json_decref (o);
     free (data);
+    free (current_value);
     zlist_remove (ctx->lookups, l);
 }
 
-/* If keys array doesn't contain eventlog, flag that we'll need to do
- * an eventlog check.
+/* Check if lookup allowed, either b/c message is from instance owner
+ * or previous lookup verified it's ok.
  */
-static int check_keys_for_eventlog (struct lookup_ctx *l)
+static int check_allow (struct lookup_ctx *l)
 {
-    size_t index;
-    json_t *key;
     int ret;
 
+    /* if rpc from owner, no need to do guest access check */
+    if (flux_msg_authorize (l->msg, FLUX_USERID_UNKNOWN) == 0) {
+        l->allow = true;
+        return 0;
+    }
+
     if ((ret = eventlog_allow_lru (l->ctx,
                                    l->msg,
                                    l->id)) < 0)
@@ -278,12 +392,24 @@ static int check_keys_for_eventlog (struct lookup_ctx *l)
         return 0;
     }
 
-    json_array_foreach (l->keys, index, key) {
-        if (streq (json_string_value (key), "eventlog"))
-            return 0;
+    return 0;
+}
+
+/* If we need the eventlog for an allow check or for update-lookup
+ * we need to add it to the key lookup list.
+ */
+static int check_to_lookup_eventlog (struct lookup_ctx *l)
+{
+    if (!l->allow || (l->flags & FLUX_JOB_LOOKUP_CURRENT)) {
+        size_t index;
+        json_t *key;
+        json_array_foreach (l->keys, index, key) {
+            if (streq (json_string_value (key), "eventlog"))
+                return 0;
+        }
+        l->lookup_eventlog = true;
     }
 
-    l->lookup_eventlog = true;
     return 0;
 }
 
@@ -296,9 +422,8 @@ void lookup_cb (flux_t *h, flux_msg_handler_t *mh,
     json_t *key;
     json_t *keys;
     flux_jobid_t id;
-    uint32_t rolemask;
     int flags;
-    int valid_flags = FLUX_JOB_LOOKUP_JSON_DECODE;
+    int valid_flags = FLUX_JOB_LOOKUP_JSON_DECODE | FLUX_JOB_LOOKUP_CURRENT;
     const char *errmsg = NULL;
 
     if (flux_request_unpack (msg, NULL, "{s:I s:o s:i}",
@@ -331,16 +456,11 @@ void lookup_cb (flux_t *h, flux_msg_handler_t *mh,
     if (!(l = lookup_ctx_create (ctx, msg, id, keys, flags)))
         goto error;
 
-    if (flux_msg_get_rolemask (msg, &rolemask) < 0)
+    if (check_allow (l) < 0)
         goto error;
 
-    /* if rpc from owner, no need to do guest access check */
-    if ((rolemask & FLUX_ROLE_OWNER))
-        l->allow = true;
-    else {
-        if (check_keys_for_eventlog (l) < 0)
-            goto error;
-    }
+    if (check_to_lookup_eventlog (l) < 0)
+        goto error;
 
     if (lookup_keys (l) < 0)
         goto error;