Udated runtime contract to stop doing unnecessary imports and introduced dedicated process registry. Confirmed working.

core/apirequest/execute.py

@@ -6,6 +6,7 @@ import logging
 
 from .request import buildRequest
 
+
 #session = requests.Session()
 _thread_local = threading.local()
 
@@ -25,6 +26,7 @@ def getSession(reset=False):
 
 
 def executeRequest(action, outputs, resolved):
+    from core.execution.lifecyclemanager.lifecyclemanager import lifecycles
     session = getSession()
 
     session_log = os.environ.get("LOGS_SESSION", "false").lower() == "true"
@@ -38,6 +40,13 @@ def executeRequest(action, outputs, resolved):
     for attempt in range(2):
         request = buildRequest(action, outputs, resolved)
         try:
+            
+            if action.name in lifecycles:
+                request_info = {"Started at": time.monotonic()}
+                lifecycles[action.name]["Request Information"] = request_info
+
+            snapshot = lifecycles.copy()
+
             response = session.request(
                 method=request["method"],
                 url=request["path"],
@@ -47,11 +56,20 @@ def executeRequest(action, outputs, resolved):
                 files=request.get("files"),
                 timeout=(10, 30)
             )
+
+            logging.debug(snapshot)
+
             return response
 
         except (requests.Timeout, requests.ConnectionError) as error:
             #print(f"{type(error).__name__} during {action.name}: {error}")
+
             logging.warning(f"{type(error).__name__} during {action.name}: {error}")
+            logging.debug("LIFECYCLE STATE BEFORE REQUEST")
+            logging.debug(snapshot)
+            logging.debug("LIFECYCLE STATE AFTER REQUEST")
+            logging.debug(lifecycles)
+
             session = getSession(reset=True)
 
             if attempt == 0:

core/execution/action/action.py

@@ -5,10 +5,10 @@ from core.runtime.runtimecontract import buildRuntimeAttr, buildPreRuntimeAttr
 #from core.runtime.stopsignals import addStopSignal
 
 
-def buildAction (action, outputs, process):
+def buildAction (action, outputs):
     action_log = True
 
-    resolved, match, filter = buildPreRuntimeAttr(action, outputs, process)
+    resolved, match, filter = buildPreRuntimeAttr(action, outputs)
 
     if hasattr(action, "allowaction"):
         if not action.allowaction:
@@ -25,7 +25,7 @@ def buildAction (action, outputs, process):
     if response is None:
         return outputs, None
 
-    response = buildRuntimeAttr(action, outputs, resolved, response, process)
+    response = buildRuntimeAttr(action, outputs, resolved, response)
 
     if action_log:
         logging.info(f"{action.name} completed")

core/execution/executioncontract.py

@@ -4,7 +4,7 @@ from core.execution.monitor import buildMonitor
 #from core.runtime import manageFailure
 from core.execution.recursive import buildRecursive
 
-def executeContract(module, outputs, process):
+def executeContract(module, outputs):
 
     if module.kind == "operation":
 
@@ -14,7 +14,7 @@ def executeContract(module, outputs, process):
 
     elif module.kind == "action":
 
-        response = buildAction(module, outputs, process)
+        response = buildAction(module, outputs)
 
         return response
 

core/execution/lifecyclemanager/lifecyclemanager.py

@@ -17,7 +17,7 @@ def manageLifecycle(module):
         while lifecycles[module.name]["mode"] == "continuous":
             lifecycles[module.name]["state"] = "active"
 
-            response = executeContract(module, outputs, None)
+            response = executeContract(module, outputs)
 
             if lifecycle_log:
                 print(f"{module.name} thread {lifecycles[module.name][module.name]} running in {lifecycles[module.name]['mode']} mode")
@@ -34,7 +34,7 @@ def manageLifecycle(module):
             print(f"{module.name} thread {lifecycles[module.name][module.name]} running in {lifecycles[module.name]['mode']} mode")
             print(lifecycles)
 
-        response = executeContract(module, outputs, None)
+        response = executeContract(module, outputs)
 
         lifecycles[module.name]["state"] = "stopped"
 

core/execution/monitor.py

@@ -36,6 +36,6 @@ def buildMonitor(monitor, outputs):
         logging.info(filter.get("print"))
         module = filter["execute"]
 
-        response = executeContract(filter["execute"], outputs, None)
+        response = executeContract(filter["execute"], outputs)
 
     return response 

core/execution/operation/operation.py

@@ -5,7 +5,7 @@ from rich.console import Console
 
 from core.runtime.managefailure import manageFailure
 from core.runtime.stopsignals import checkDependency
-from core.execution.processregistry import registerProcess
+from core.execution import processregistry
 from core.console import console
 
 outputs = {}
@@ -16,7 +16,8 @@ def buildOperation(definition, outputs):
     from core.execution.executioncontract import executeContract
     
     actions = definition.actions
-    registerProcess(definition, outputs)
+    currentOp = processregistry.registerProcess(definition)
+
     responses = []
     
     if getattr(definition, "track", False):
@@ -27,44 +28,44 @@ def buildOperation(definition, outputs):
         )
 
     for action in actions:
+        processregistry.registeredOp = currentOp
 
-        stop = checkDependency(action, outputs, definition)
+        stop = checkDependency(action)
 
         if stop:
             continue
 
         if action.kind == "action":
-            outputs["processes"][definition.name][action.name] = {}
+            currentOp[action.name] = {}
 
-        response = executeContract(action, outputs, definition)
+        response = executeContract(action, outputs)
 
         responses.append(response)
 
         if action.kind == "action":
-            outputs["processes"][definition.name][action.name]["response"] = response
+            currentOp[action.name]["response"] = response 
 
-        ##Append completed process to process registry
+        if action.alias in currentOp["stopsignals"]:
-        outputs["processes"][definition.name]["completed"].append(action.alias)
+            continue
+        currentOp["completed"].append(action.alias)
 
         #Temporarily disabled manageFailure functions
         #except Exception as error:
             #outputs = manageFailure(error, action, outputs)
 
-    #Print completion status after runtime processes
     if process_log:
-        stopsignal_count = len(outputs["processes"][definition.name]["stopsignals"])
+        completed_count = len(currentOp["completed"])
-        completed_count = len(outputs["processes"][definition.name]["completed"])
 
-        if completed_count == 1 and stopsignal_count == 1:
+        if completed_count == 0:
             logging.info(f"{definition.name} bypassed")
         else:
             logging.info(f"{definition.name} completed")
 
-    #For debugging purposes only
+
     process_registry_logs = False
+
     if process_registry_logs:
-        pprint.pprint(outputs["processes"])
+        import pprint
-
+        pprint.pprint(processregistry.processes)
-
     
     return responses

core/execution/processregistry.py

@@ -1,12 +1,14 @@
-def registerProcess(module, outputs):
+processes = {}
-    if not "processes" in outputs:
+registeredOp = {}
-        outputs["processes"] = {}
 
-    if not module.name in outputs["processes"]:
+def registerProcess(module):
-        outputs["processes"][module.name] = {}
+    global registeredOp
 
-    #outputs["processes"][module.name] = {}
+    processes[module.name] = {}
-    outputs["processes"][module.name]["stopsignals"] = []
-    outputs["processes"][module.name]["completed"] = []
 
-    return
+    registeredOp = processes[module.name]
+
+    processes[module.name]["stopsignals"] = []
+    processes[module.name]["completed"] = []
+
+    return registeredOp

core/execution/recursive.py

@@ -2,7 +2,7 @@ import logging
 import os
 
 from core.runtime.stopsignals import checkDependency
-from core.execution.processregistry import registerProcess
+from core.execution import processregistry
 from rich.progress import track
 from core.console import console
 
@@ -10,8 +10,6 @@ def buildRecursive(definition, outputs):
     process_log = True
     recursive_log = os.environ.get("LOGS_RECURSIVE", "false").lower() == "true"
 
-    #print(outputs[definition.recursiveset["source"]])
-
     source = outputs.get(definition.recursiveset["source"])
 
     if source is None or source == []:
@@ -19,7 +17,7 @@ def buildRecursive(definition, outputs):
             logging.debug(f"No items available in {source} for {definition.name}")
         return outputs, []
 
-    registerProcess(definition, outputs)
+    currentOp = processregistry.registerProcess(definition)
 
     responses = []
     from core.execution.executioncontract import executeContract
@@ -32,7 +30,6 @@ def buildRecursive(definition, outputs):
     reverse = definition.recursiveset.get("reverse", False)
 
     if reverse:
-        #print("reversing")
         items = reversed(items)
 
     for item in track(
@@ -46,37 +43,28 @@ def buildRecursive(definition, outputs):
 
         outputs["stopsignals"] = []
         for job in recursiveset:
+            processregistry.registeredOp = currentOp
 
-            stop = checkDependency(job, outputs, definition)
+            stop = checkDependency(job)
-
-            #print(f"STOP SIGNAL DEBUGGING during {job.name}")
-            #print(outputs["stopsignals"])
-            #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
 
-            #print(f"RECURSIVE DEBUG DURING {job.name}")
-            #print(item)
-            #outputs, response = buildAction(job, outputs)
             if job.kind == "action":
-                outputs["processes"][definition.name][job.name] = {}
+                currentOp[job.name] = {}
             
-            response = executeContract(job, outputs, definition)
+            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)
+            if job.kind == "action":
+                currentOp[job.name]["response"] = response
+
+            currentOp["completed"].append(job.alias)
 
     if process_log:
-        stopsignal_count = len(outputs["processes"][definition.name]["stopsignals"])
+        completed_count = len(currentOp["completed"])
-        completed_count = len(outputs["processes"][definition.name]["completed"])
 
-        if completed_count == 1 and stopsignal_count == 1:
+        if completed_count == 0:
             logging.info(f"{definition.name} bypassed")
         else:
             logging.info(f"{definition.name} completed")
@@ -88,4 +76,10 @@ def buildRecursive(definition, outputs):
 
     outputs.pop("stopsignals", None)
 
+    process_registry_logs = False
+    
+    if process_registry_logs:
+        import pprint
+        pprint.pprint(processregistry.processes)
+
     return responses

core/runtime/firewall.py

@@ -21,7 +21,8 @@ def buildFirewall(listener, outputs):
 
             if filter.get("execute", False):
                 from core.apirequest.execute import executeRequest
-                response, outputs = executeRequest(filter["execute"], outputs, resolved)
+
+                response = executeRequest(filter["execute"], outputs, resolved)
 
             if firewall_log:
                 logging.info(filter.get("print"))

core/runtime/managefailure.py

@@ -22,7 +22,7 @@ def manageFailure(error, action, outputs):
                 else:
                     print(f"{type(error).__name__} detected during {action.name}. Applying recovery policy.")
                     
-                    response = buildAction(repair, outputs, None)
+                    response = buildAction(repair, outputs)
 
                 return outputs
     print(f"{error}")

core/runtime/runtimecontract.py

@@ -2,7 +2,7 @@ import logging
 
 from core.runtime.stopsignals import addStopSignal
 
-def buildPreRuntimeAttr(action, outputs, process):
+def buildPreRuntimeAttr(action, outputs):
     from core.runtime import loadSave, readRow
     from core.runtime.applyconditions import applyConditions
     from core.runtime.resolver import resolveItem
@@ -17,12 +17,12 @@ def buildPreRuntimeAttr(action, outputs, process):
 
     if match:
         logging.info(filter.get("print"))
-        addStopSignal(action, outputs, process)
+        addStopSignal(action)
     
     return resolved, match, filter
     
 
-def buildRuntimeAttr(action, outputs, resolved, response, process):
+def buildRuntimeAttr(action, outputs, resolved, response):
     from core.runtime.resolver import extractItem
     from core.runtime.responsepolicy import responsePolicy
     from core.runtime.image import buildImage
@@ -33,7 +33,7 @@ def buildRuntimeAttr(action, outputs, resolved, response, process):
     buildOutput(response, action, outputs)
 
     if not response.ok:
-        addStopSignal(action, outputs, process)
+        addStopSignal(action)
         return outputs, response
 
     extractItem(action, outputs, resolved)

core/runtime/stopsignals.py

@@ -1,9 +1,10 @@
-#def checkDependency(action, outputs):
+#from core.execution.processregistry import registeredOp
-def checkDependency(action, outputs, operation):
+
+def checkDependency(action):
+    from core.execution.processregistry import registeredOp
     if hasattr(action, "depends"):
         stop = any(
-                dependency in outputs["processes"][operation.name]["stopsignals"]
+                dependency in registeredOp["stopsignals"]
-                #dependency in outputs["stopsignals"]
                 for dependency in action.depends
             )
         
@@ -12,9 +13,10 @@ def checkDependency(action, outputs, operation):
 
     return False
 
-#def addStopSignal(action, outputs):
+def addStopSignal(action):
-def addStopSignal(action, outputs, operation):
+    from core.execution.processregistry import registeredOp
+
     if hasattr(action, "depends"):
-        outputs["processes"][operation.name]["stopsignals"].append(action.alias)
+
-        #outputs["stopsignals"].append(action.alias)
+        registeredOp["stopsignals"].append(action.alias)
     return

core/server/createlistener.py

@@ -2,7 +2,6 @@ import json
 import logging
 
 from core.runtime.outputs import buildOutput
-from core.execution.executioncontract import executeContract
 from core.runtime.firewall import buildFirewall
 
 
@@ -32,11 +31,13 @@ def buildListener(listener, self):
         allow, status_code = buildFirewall(listener, outputs)
 
         if allow:
+            from core.execution.executioncontract import executeContract
+            
             #Print allowed items for logging purposes
             logging.info(outputs["firewall_allowed"])
 
             #Process and forward to RMASS
-            responses = executeContract(listener.execute, outputs, None)
+            responses = executeContract(listener.execute, outputs)