Created process registry and introduced preparatory code

core/execution/operation/operation.py

@@ -2,30 +2,44 @@ import logging
 from core.runtime.managefailure import manageFailure
 from core.execution.action.action import buildAction
 from core.runtime.stopsignals import checkDependency
+from core.execution.processregistry import registerProcess
 #from core.runtime.skipstep import skipStep
 #from core.runtime.recursive import recursiveSet
 
 outputs = {}
+
 def buildOperation(definition, outputs):
     from core.execution.executioncontract import executeContract
     actions = definition.actions
+    outputs = registerProcess(definition, outputs)
+
     responses = []
     outputs["stopsignals"] = []
     for action in actions:
+        #if action.kind == "action":
+        #    outputs["processes"][definition.name][action.name] = {}
         stop = checkDependency(action, outputs)
 
         #print(f"STOP SIGNAL DEBUGGING during {action.name}")
         #print(outputs["stopsignals"])
 
         if stop:
+            outputs["processes"][definition.name]["stopsignals"].append(action.alias)
             continue
 
+        if action.kind == "action":
+            outputs["processes"][definition.name][action.name] = {}
+
         outputs, response = executeContract(action, outputs)
         
         #if hasattr(action, recursive)
 
         responses.append(response)
+        if action.kind == "action":
+            outputs["processes"][definition.name][action.name]["response"] = response
         
+        outputs["processes"][definition.name]["completed"].append(action.alias)
+        #print(outputs["processes"])
 
         #except Exception as error:
             #outputs = manageFailure(error, action, outputs)

core/execution/processregistry.py

@@ -0,0 +1,16 @@
+def registerProcess(module, outputs):
+    if not "processes" in outputs:
+        outputs["processes"] = {}
+    #outputs["processes"] = {module.name: {}}
+
+    #print("WHERE IS MY PROCESS DICT?")
+    #print(outputs)
+
+    if not module.name in outputs["processes"]:
+        outputs["processes"][module.name] = {}
+
+    #outputs["processes"][module.name] = {}
+    outputs["processes"][module.name]["stopsignals"] = []
+    outputs["processes"][module.name]["completed"] = []
+
+    return outputs

core/execution/recursive.py

@@ -3,8 +3,11 @@ from core.execution.action.action import buildAction
 from core.runtime.runtimecontract import buildPreRuntimeAttr, buildRuntimeAttr
 from core.apirequest import executeRequest
 from core.runtime.stopsignals import checkDependency
+from core.execution.processregistry import registerProcess
 
 def buildRecursive(definition, outputs):
+    outputs = registerProcess(definition, outputs)
+
     responses = []
     from core.execution.executioncontract import executeContract
     recursiveset = definition.recursiveset["actions"]
@@ -30,6 +33,7 @@ def buildRecursive(definition, outputs):
 
         outputs["stopsignals"] = []
         for job in recursiveset:
+
             stop = checkDependency(job, outputs)
 
             #print(f"STOP SIGNAL DEBUGGING during {job.name}")
@@ -37,6 +41,7 @@ def buildRecursive(definition, outputs):
             #print(stop)
 
             if stop:
+                outputs["processes"][definition.name]["stopsignals"].append(job.alias)
                 #print("STOP SIGNAL DETECTED")
                 #print(f"Stopping {job.name} due to stop signal")
                 continue
@@ -44,9 +49,16 @@ def buildRecursive(definition, outputs):
             #print(f"RECURSIVE DEBUG DURING {job.name}")
             #print(item)
             #outputs, response = buildAction(job, outputs)
+            if job.kind == "action":
+                outputs["processes"][definition.name][job.name] = {}
             
             outputs, response = executeContract(job, outputs)
             responses.append(response)
+            if job.kind == "action":
+                outputs["processes"][definition.name][job.name]["response"] = response
+
+            outputs["processes"][definition.name]["completed"].append(job.alias)
+            
 
     retain = definition.recursiveset.get("retain", True)
 

core/runtime/stopsignals.py

@@ -1,6 +1,8 @@
 def checkDependency(action, outputs):
+#def checkDependency(action, operation, outputs):
     if hasattr(action, "depends"):
         stop = any(
+                #dependency in outputs["processes"][operation.name]["stopsignals"]
                 dependency in outputs["stopsignals"]
                 for dependency in action.depends
             )
@@ -11,7 +13,8 @@ def checkDependency(action, outputs):
     return False
 
 def addStopSignal(action, outputs):
+#def addStopSignal(action, operation, outputs):
     if hasattr(action, "depends"):
+        #outputs["processes"][operation.name]["stopsignals"].append(action.alias)
         outputs["stopsignals"].append(action.alias)
-
     return outputs