readers: implement jgf_shorthand reader

Problem: the `jgf_shorthand` reader is the same as the regular JGF
reader, meaning it cannot properly handle the `jgf_shorthand` format.

Add a virtual method to the JGF reader that, when updating a graph
using JGF, can fetch additional vertices and treat them as if they
were included in the JGF.

When the `jgf_shorthand` reader encounters an exclusive vertex, make
it recursively fetch all child vertices of that vertex.

Author: jameshcorbett

resource/readers/resource_reader_jgf.cpp

@@ -967,20 +967,42 @@ int resource_reader_jgf_t::update_vertices (resource_graph_t &g,
     int rc = -1;
     unsigned int i = 0;
     fetch_helper_t fetcher;
+    std::vector<fetch_helper_t> additional_vertices;
+    std::map<std::string, vmap_val_t> empty_vmap{};
 
     for (i = 0; i < json_array_size (nodes); i++) {
         fetcher.scrub ();
+        additional_vertices.clear ();
         if ((rc = unpack_vtx (json_array_get (nodes, i), fetcher)) != 0)
             goto done;
         if ((rc = update_vtx (g, m, vmap, fetcher, update_data)) != 0)
             goto done;
+        if (fetch_additional_vertices (g, m, empty_vmap, fetcher, additional_vertices) != 0)
+            goto done;
+        for (auto it = additional_vertices.begin (); it != additional_vertices.end (); ++it) {
+            std::string vertex_id = std::to_string (it->uniq_id);
+            it->vertex_id = vertex_id.c_str ();
+            if ((rc = update_vtx (g, m, vmap, *it, update_data)) != 0) {
+                goto done;
+            }
+        }
     }
     rc = 0;
 
 done:
     return rc;
 }
 
+int resource_reader_jgf_t::fetch_additional_vertices (
+    resource_graph_t &g,
+    resource_graph_metadata_t &m,
+    std::map<std::string, vmap_val_t> &vmap,
+    fetch_helper_t &fetcher,
+    std::vector<fetch_helper_t> &additional_vertices)
+{
+    return 0;
+}
+
 int resource_reader_jgf_t::unpack_edge (json_t *element,
                                         std::map<std::string, vmap_val_t> &vmap,
                                         std::string &source,

resource/readers/resource_reader_jgf.hpp

@@ -240,6 +240,11 @@ class resource_reader_jgf_t : public resource_reader_base_t {
                          std::map<std::string, vmap_val_t> &vmap,
                          json_t *nodes,
                          jgf_updater_data &updater_data);
+    virtual int fetch_additional_vertices (resource_graph_t &g,
+                                           resource_graph_metadata_t &m,
+                                           std::map<std::string, vmap_val_t> &vmap,
+                                           fetch_helper_t &fetcher,
+                                           std::vector<fetch_helper_t> &additional_vertices);
     int unpack_edge (json_t *element,
                      std::map<std::string, vmap_val_t> &vmap,
                      std::string &source,

resource/readers/resource_reader_jgf_shorthand.cpp

@@ -20,3 +20,62 @@ using namespace Flux::resource_model;
 resource_reader_jgf_shorthand_t::~resource_reader_jgf_shorthand_t ()
 {
 }
+
+int resource_reader_jgf_shorthand_t::fetch_additional_vertices (
+    resource_graph_t &g,
+    resource_graph_metadata_t &m,
+    std::map<std::string, vmap_val_t> &vmap,
+    fetch_helper_t &fetcher,
+    std::vector<fetch_helper_t> &additional_vertices)
+{
+    int rc = -1;
+    vtx_t v = boost::graph_traits<resource_graph_t>::null_vertex ();
+    if (!fetcher.exclusive)  // vertex isn't exclusive, nothing to do
+        return 0;
+
+    if ((rc = resource_reader_jgf_t::find_vtx (g, m, vmap, fetcher, v)) != 0)
+        return rc;
+
+    return recursively_collect_vertices (g, v, additional_vertices);
+}
+
+int resource_reader_jgf_shorthand_t::recursively_collect_vertices (
+    resource_graph_t &g,
+    vtx_t v,
+    std::vector<fetch_helper_t> &additional_vertices)
+{
+    static const subsystem_t containment_sub{"containment"};
+    f_out_edg_iterator_t ei, ei_end;
+    vtx_t target;
+
+    if (v == boost::graph_traits<resource_graph_t>::null_vertex ()) {
+        return -1;
+    }
+
+    for (boost::tie (ei, ei_end) = boost::out_edges (v, g); ei != ei_end; ++ei) {
+        if (g[*ei].subsystem != containment_sub)
+            continue;
+        target = boost::target (*ei, g);
+
+        fetch_helper_t vertex_copy;
+        vertex_copy.type = g[target].type.c_str ();
+        vertex_copy.basename = g[target].basename.c_str ();
+        vertex_copy.size = g[target].size;
+        vertex_copy.uniq_id = g[target].uniq_id;
+        vertex_copy.rank = g[target].rank;
+        vertex_copy.status = g[target].status;
+        vertex_copy.id = g[target].id;
+        vertex_copy.name = g[target].name;
+        vertex_copy.properties = g[target].properties;
+        vertex_copy.paths = g[target].paths;
+        vertex_copy.unit = g[target].unit.c_str ();
+        if (resource_reader_jgf_t::apply_defaults (vertex_copy, g[target].name.c_str ()) < 0)
+            return -1;
+
+        additional_vertices.push_back (vertex_copy);
+        if (recursively_collect_vertices (g, target, additional_vertices) < 0) {
+            return -1;
+        }
+    }
+    return 0;
+}

resource/readers/resource_reader_jgf_shorthand.hpp

@@ -25,6 +25,17 @@ namespace resource_model {
 class resource_reader_jgf_shorthand_t : public resource_reader_jgf_t {
    public:
     virtual ~resource_reader_jgf_shorthand_t ();
+
+   protected:
+    int fetch_additional_vertices (resource_graph_t &g,
+                                   resource_graph_metadata_t &m,
+                                   std::map<std::string, vmap_val_t> &vmap,
+                                   fetch_helper_t &fetcher,
+                                   std::vector<fetch_helper_t> &additional_vertices) override;
+
+    int recursively_collect_vertices (resource_graph_t &g,
+                                      vtx_t v,
+                                      std::vector<fetch_helper_t> &additional_vertices);
 };
 
 }  // namespace resource_model