Add dependents support for register_builtin

lib/ramble/ramble/graphs.py

@@ -261,7 +261,7 @@ def __init__(self, exec_order, executables, builtin_objects, builtin_groups, obj
             obj_inst (object): Object instance to extract attributes from (when necessary)
         """
         super().__init__(obj_inst)
-        self._builtin_dependencies = {}
+        self._builtin_dependencies = defaultdict(list)
         # Mapping from shorter_name -> fully qualified names
         self._builtin_aliases = defaultdict(list)
 
@@ -282,6 +282,10 @@ def __init__(self, exec_order, executables, builtin_objects, builtin_groups, obj
                 )
                 self.node_definitions[builtin] = exec_node
                 self._build_builtin_aliases(builtin)
+            for builtin, blt_conf in builtins.items():
+                dependents = blt_conf["dependents"].copy()
+                for dependent in dependents:
+                    self._builtin_dependencies[dependent].append(builtin)
 
         dep_exec = None
         for exec_name in exec_order:
@@ -308,14 +312,17 @@ def __init__(self, exec_order, executables, builtin_objects, builtin_groups, obj
                     blt_node = self.node_definitions[builtin]
                     super().update_graph(blt_node)
 
-                    if blt_conf["injection_method"] == "prepend":
+                    # TODO: This should include `depends_on` as well.
+                    relative = bool(blt_conf["dependents"])
+
+                    if not relative and blt_conf["injection_method"] == "prepend":
                         if head_node is not None:
                             super().update_graph(head_node, [blt_node])
 
                         if tail_prepend_builtin is not None:
                             super().update_graph(blt_node, [tail_prepend_builtin])
                         tail_prepend_builtin = blt_node
-                    elif blt_conf["injection_method"] == "append":
+                    elif not relative and blt_conf["injection_method"] == "append":
                         if tail_node is not None:
                             super().update_graph(blt_node, [tail_node])
 
@@ -333,6 +340,13 @@ def __init__(self, exec_order, executables, builtin_objects, builtin_groups, obj
                         exec_node = self.node_definitions[builtin]
                         super().update_graph(exec_node, deps)
 
+                    if blt_conf["dependents"]:
+                        exec_node = self.node_definitions[builtin]
+                        super().update_graph(exec_node)
+                        for dependent in blt_conf["dependents"]:
+                            dependent_node = self._resolve_builtin_node(dependent)
+                            super().update_graph(dependent_node, [exec_node])
+
     def inject_executable(self, exec_name, injection_order, relative):
         """Inject an executable into the graph
 

lib/ramble/ramble/language/shared_language.py

@@ -273,7 +273,9 @@ def _execute_success_criteria(obj):
 
 
 @shared_directive("builtins")
-def register_builtin(name, required=True, injection_method="prepend", depends_on=[]):
+def register_builtin(
+    name, required=True, injection_method="prepend", depends_on=[], dependents=[]
+):
     """Register a builtin
 
     Builtins are methods that return lists of strings. These methods represent
@@ -308,7 +310,7 @@ def example_builtin(self):
     The 'required' attribute marks a builtin as required for all workloads. This
     will ensure the builtin is added to the workload if it is not explicitly
     added. If required builtins are not explicitly added to a workload, they
-    are injected  into the list of executables, based on the injection_method
+    are injected into the list of executables, based on the injection_method
     attribute.
 
     The 'injection_method' attribute controls where the builtin will be
@@ -324,6 +326,8 @@ def example_builtin(self):
                                 'prepend' or 'append'
         depends_on (list(str)): The names of builtins this builtin depends on
                                 (and must execute after).
+        dependents (list(str)): The names of builtins that should come
+                                after the current one.
     """
     supported_injection_methods = ["prepend", "append"]
 
@@ -342,6 +346,7 @@ def _store_builtin(obj):
             "required": required,
             "injection_method": injection_method,
             "depends_on": depends_on.copy(),
+            "dependents": dependents.copy(),
         }
 
     return _store_builtin

lib/ramble/ramble/test/application_tests.py

@@ -189,6 +189,15 @@ def test_register_builtin_app(mutable_mock_apps_repo):
         for builtin in excluded_builtins:
             assert exec_graph.get_node(builtin) is None
 
+        # Test for dependency injection
+        found_prerequisite = False
+        for node in exec_graph.walk():
+            if node.key == "builtin::test_builtin":
+                break
+            if node.key == "builtin::test_builtin_pre":
+                found_prerequisite = True
+        assert found_prerequisite
+
 
 @pytest.mark.parametrize(
     "app", ["basic", "basic-inherited", "input-test", "interleved-env-vars", "register-builtin"]

var/ramble/repos/builtin.mock/applications/register-builtin/application.py

@@ -43,6 +43,10 @@ class RegisterBuiltin(ExecutableApplication):
     # Test disabling the typically included env_vars builtin.
     register_builtin("env_vars", required=False)
     register_builtin("test_builtin", required=True)
+    register_builtin("test_builtin_pre", dependents=["test_builtin"])
 
     def test_builtin(self):
         return ['echo "foo"']
+
+    def test_builtin_pre(self):
+        return ['echo "bar"']