Reestablished working state

core/apirequest/execute.py

@@ -4,8 +4,8 @@ from .request import buildRequest
 
 session = requests.Session()
 
-def executeRequest(definition, outputs):
-    request = buildRequest(definition, outputs)
+def executeRequest(action, outputs):
+    request, outputs = buildRequest(action, outputs)
 
     response = session.request(
         method=request["method"],
@@ -23,4 +23,4 @@ def executeRequest(definition, outputs):
 #            sessioncookies[cookie_name] = response[cookie_key],
 
 
-    return response
+    return response, outputs

core/apirequest/request.py

@@ -25,4 +25,4 @@ def buildRequest(definition, outputs):
 
         request["headers"] = headers
 
-    return request
+    return request, outputs

core/execution/action/action.py

@@ -2,24 +2,17 @@ from core.apirequest import executeRequest
 from core.runtime.savedata import loadSave, buildSave
 from core.runtime.outputs import buildOutput
 from core.runtime.logs import buildLog
+from core.runtime.runtimecontract import buildRuntimeAttr
 
 def buildAction (action, outputs):
 
     if hasattr(action, "loaddata"):
         outputs = loadSave(outputs, action)
 
-    response = executeRequest(action, outputs)
+    response, outputs = executeRequest(action, outputs)
 
-    if hasattr(action, "outputs"):
-        outputs = buildOutput(response, action, outputs)
+    #print("DEBUG:", outputs)
 
-    if hasattr(action, "savedata"):
-        save_file = buildSave(outputs, action)
-
-    if hasattr(action, "prints"):
-        logs = buildLog(action, outputs)
-
-    if action.showstatus is True and response.status_code == 200:
-        print(f"{action.name} successful")
+    outputs, response = buildRuntimeAttr(action, outputs, response)
 
     return outputs, response

core/execution/createthread.py

@@ -1,6 +1,6 @@
 import threading
-from lifecycleregistry import registerLifecycle
-from lifecyclemanager import manageLifecycle
+from .lifecyclemanager import registerLifecycle
+from .lifecyclemanager import manageLifecycle
 
 threadlist = []
 threadnum = 0
@@ -27,4 +27,4 @@ def buildThread(module, lifecycles):
     print(threadlist)
     print(lifecycles)
 
-    return threadnum, threadname, lifecycles, threadlist
+    return thread, lifecycles

core/execution/executioncontract.py

@@ -1,11 +1,16 @@
 from core.execution.action import buildAction
 from core.execution.operation import buildOperation
+from core.runtime import manageFailure
 
 def executeContract(module):
+    #try:
     if module.kind == "operation":
         outputs = buildOperation(module)
 
     elif module.kind == "action":
         outputs = buildAction(module)
 
+    #except Exception as error:
+        #outputs = manageFailure(error, module)
+
     return outputs

core/execution/lifecyclemanager/lifecyclemanager.py

@@ -1,8 +1,11 @@
 import time
+import os
 
 from core.execution.operation import buildOperation
 from core.execution.action import buildAction
-from core import executeContract
+from core.execution.executioncontract import executeContract
+
+sleeptime = int(os.environ.get("REFRESH_INTERVAL", 180))
 
 def manageLifecycle(module, lifecycles): #lifecycles, state):
     #print(lifecycles[module.name]["mode"])
@@ -15,7 +18,7 @@ def manageLifecycle(module, lifecycles): #lifecycles, state):
 
             #print(lifecycles)
 
-            time.sleep(module.sleeptime)
+            time.sleep(sleeptime)
 
     elif lifecycles[module.name]["mode"] == "oneshot":
         print(lifecycles)

core/execution/operation/operation.py

@@ -9,33 +9,19 @@ from .skipstep import skipStep
 
 def buildOperation(definition):
     actions = definition.actions
-
-#    responses = []
+    #print("DEBUG", actions)
+    responses = []
     outputs = {}
 
     for action in actions:
-        try:
-            if hasattr(definition, "skipstep"):
-                if skipStep(definition, action, outputs):
-                    continue
+        #try:
+        if hasattr(definition, "skipstep"):
+            if skipStep(definition, action, outputs):
+                continue
 
-            outputs, response = buildAction(action, outputs)
-#            responses.append(response)
-
-        except Exception as error:
-            outputs = manageFailure(error, action, outputs)
-
-#        if hasattr(action, "cookies"):
-#            for cookiename, cookie, in cookies:
-
-#                session.cookies.set(
-#                    cookiename,
-#                    outputs[cookie],
-#                    domain=domainname
-#                )
-
-#            print(
-#                {outputs[cookie]},
-#                domain,
-#                cookiename,
-#            )
+        outputs, response = buildAction(action, outputs)
+        responses.append(response)
+            
+        #except Exception as error:
+            #outputs = manageFailure(error, action, outputs)
+    return outputs

core/execution/operation/skipstep.py

@@ -2,13 +2,19 @@ def skipStep(definition, action, outputs):
     try:
         if action in definition.skipstep:
             condition = definition.skipstep[action]
-
+        
+            #if outputs.get([condition["output"]]) is None:
+                #return False
+                #current_value = 1
+            #else:
             current_value = outputs[condition["output"]]
+                #current_value = 1
 
             if condition["operator"] == ">=":
                 if current_value >= condition["value"]:
                     print(f"Skipping {action.name}")
                     return True
 
-    except TypeError, KeyError:
+    except KeyError:
+        #outputs = manageFailure(error)
         return False

core/runtime/logs.py

@@ -1,11 +1,17 @@
-def buildLog (action, outputs):
-#    try:
-    for print_name, print_key in action.prints.items():
-        print(
-            f"{print_name}:",
-            f"{outputs[print_key]}",
-        )
+import logging
 
- #   except KeyError:
-        #outputs[print_key] = "N/A"
- #       return
+def buildLog (action, outputs):
+    #if response.status_code == 200:
+        #print(f"{action.name} successful")
+    try:
+        for print_name, print_key in action.prints.items():
+            print(
+                f"{print_name}:",
+                f"{outputs[print_key]}",
+            )
+
+
+    #else:
+        #print(f"{action.name} failed")
+    except: KeyError, TypeError
+    return

core/runtime/managefailure.py

@@ -7,13 +7,22 @@ def manageFailure(error, action, outputs):
         errors = action.recoverPolicy
         error_type = type(error)
 
-        print(f"{type(error).__name__} detected during {action.name}. Applying recovery policy.")
+        #print(f"{type(error).__name__} detected during {action.name}. Applying recovery policy.")
 
         if error_type in errors:
             repairs = errors[error_type]
-
+            
             for repair in repairs:
-                outputs, response = buildAction(repair, outputs)
+                if repair == False:
+                    return False
 
-            return outputs
+                elif repair is None:
+                    return
+
+                else:
+                    print(f"{type(error).__name__} detected during {action.name}. Applying recovery policy.")
+                    
+                    outputs, response = buildAction(repair, outputs)
+
+                return outputs
     print(f"{error}")

core/runtime/outputs.py

@@ -17,5 +17,3 @@ def buildOutput(response, action, outputs):
 
 
     return outputs
-
-

core/runtime/runtimecontract.py

@@ -0,0 +1,30 @@
+from core.runtime import buildOutput, buildSave, buildLog
+
+def buildRuntimeAttr(action, outputs, response):
+    #print("BEFORE buildOutput:", type(outputs))
+    if hasattr(action, "outputs"):
+        outputs = buildOutput(response, action, outputs)
+        
+    #print("AFTER buildOutput:", type(outputs))
+    #print("DEBUG buildSave")
+    #print("outputs type:", type(outputs))
+    #print("action type:", type(action))
+    #print("outputs keys:", list(outputs) if isinstance(outputs, dict) else "NOT A DICT")
+
+    if hasattr(action, "savedata"):
+        buildSave(outputs, action)
+
+    if hasattr(action, "prints"):
+        buildLog(action, outputs)
+
+    #if hasattr(action, "conversion"):
+        #conversions = action.conversion.items()
+        #for key in action.conversion.items():
+           #print(f"{action.conversion.items[key]}")
+           #convertedoutput = conversions[key]
+           #outputs[conversions[key]] = convertedoutput
+
+    if action.showstatus is True and response.status_code == 200:
+        print(f"{action.name} successful")
+        
+    return outputs, response

core/runtime/savedata.py

@@ -9,9 +9,9 @@ def buildSave(outputs, action):
         with open(f"{action.savepath}", "w") as save_file:
             json.dump(save_data, save_file)
 
-        print(f"{save_name} saved by {action.name}")
-
-    return save_file
+        #print(f"{save_name} saved by {action.name}")
+    print(f"Data saved by {action.name} to {action.savepath}")
+    return outputs
 
 def loadSave(outputs, action):
     with open(f"{action.savepath}", "r") as save_file:
@@ -19,6 +19,7 @@ def loadSave(outputs, action):
 
     for load_name in action.loaddata:
         outputs[load_name] = load_data[load_name]
-        print(f"{load_name} loaded by {action.name}")
+        #print(f"{load_name} loaded by {action.name}")
 
+    print(f"Data loaded by {action.name} from {action.savepath}")
     return outputs

core/server/createdispatch.py

@@ -1,5 +1,5 @@
 import importlib
-from lifecyclemanager import manageLifecycle
+from core.execution.lifecyclemanager import manageLifecycle
 from .dispatchstate import buildState
 
 def buildDispatch(request):

core/server/createresponse.py

@@ -0,0 +1,14 @@
+import json
+
+def buildResponse(module, thread, mode):
+
+    response = {
+        "status": "success",
+        "message": f"{module.name} dispatched",
+        "thread": f"{thread}",
+        "mode": f"{mode}",
+    }
+
+    #responsedata = json.dumps(response).encode("utf-8")
+
+    return response

core/server/dispatcher.py

@@ -1,6 +1,7 @@
 from .createdispatch import buildDispatch
 from .dispatchstate import buildState
 from core.execution.createthread import buildThread
+from .createresponse import buildResponse
 
 import threading
 
@@ -14,9 +15,6 @@ def dispatchRequest(request, lifecycles):
         return lifecycles
 
     else:
-        threadnum, threadname, lifecycles, threadlist = buildThread(module, lifecycles)
+        thread, lifecycles = buildThread(module, lifecycles)
 
-    #print("Active Threads")
-    #print(threadlist)
-
-        return threadnum, threadname, lifecycles, threadlist
+        return thread, lifecycles, module, mode

core/server/dispatchstate.py

@@ -1,6 +1,6 @@
 import requests
 
-from core import registerLifecycle
+from core.execution.lifecyclemanager import registerLifecycle
 
 def filterMode(mode):
     if mode in ("continuous", "oneshot", "stop"):

core/server/server.py

@@ -1,19 +1,25 @@
 import socket
 import json
+import os
+import logging
+
+from .dispatcher import dispatchRequest
+from .createresponse import buildResponse
+
+port = int(os.environ.get("SERVER_PORT", 19001))
 
 def startServer():
-    from .dispatcher import dispatchRequest
-
     server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
-    server.bind(("127.0.0.1", 19002))
+    server.bind(("0.0.0.0", port))
 
     lifecycles = {}
 
     server.listen()
-
+    logging.info(f"Server listening on port {port}")
     while True:
         connection, address = server.accept()
+        logging.info("Accepting connections")
 
         while True:
             data = connection.recv(4096)
@@ -23,7 +29,13 @@ def startServer():
     #        if not data:
     #            break
 
-            dispatch = dispatchRequest(request, lifecycles)
+            thread, lifecycles, module, mode = dispatchRequest(request, lifecycles)
+
+            response = buildResponse(module, thread, mode)
+
+            connection.sendall(
+                json.dumps(response).encode("utf-8"),
+            )
 
         connection.close()