Refined dispatcher and threading. Added lifecycle registry

trash/checkavailable.py

@@ -0,0 +1,5 @@
+from plugins import rmass
+from core.operation.operation import buildOperation
+
+outputs = buildOperation(rmass.checkavailableoperation)
+

trash/createdispatch.py

@@ -0,0 +1,17 @@
+import importlib
+from lifecyclemanager import manageLifecycle
+from dispatchstate import buildState
+
+def buildDispatch(request):
+    dispatch = []
+
+    for key in request["module"]:
+        dispatch.append(request["module"][key])
+
+    resolveddispatch = "plugins."+ ".".join(dispatch)
+
+    module = importlib.import_module(resolveddispatch)
+
+    mode = request.get("mode", "oneshot")
+
+    return module, mode

trash/createthread.py

@@ -0,0 +1,30 @@
+import threading
+from lifecycleregistry import registerLifecycle
+from lifecyclemanager import manageLifecycle
+
+threadlist = []
+threadnum = 0
+
+def buildThread(module, lifecycles):
+    global threadnum
+    threadnum += 1
+
+    threadname = f"thread.{threadnum}"
+
+    thread = threading.Thread(
+        target=manageLifecycle,
+        args=(module, lifecycles)
+    )
+    thread.start()
+
+    registryname = threadname
+    registryvalue = thread
+
+    lifecycles = registerLifecycle (module, lifecycles, registryname, registryvalue)
+
+    threadlist.append(thread)
+
+    print(threadlist)
+    print(lifecycles)
+
+    return threadnum, threadname, lifecycles, threadlist

trash/dispatcher.py

@@ -0,0 +1,22 @@
+from createdispatch import buildDispatch
+from createthread import buildThread
+from dispatchstate import buildState
+
+import threading
+
+def dispatchRequest(request, lifecycles):
+
+    module, mode = buildDispatch(request)
+
+    mode, lifecycles = buildState(module, mode, lifecycles)
+
+    if mode == "stop":
+        return lifecycles
+
+    else:
+        threadnum, threadname, lifecycles, threadlist = buildThread(module, lifecycles)
+
+    #print("Active Threads")
+    #print(threadlist)
+
+        return threadnum, threadname, lifecycles, threadlist

trash/dispatchstate.py

@@ -0,0 +1,41 @@
+import requests
+
+from lifecycleregistry import registerLifecycle
+
+def filterMode(mode):
+    if mode in ("continuous", "oneshot", "stop"):
+        state = mode
+        return state
+    else: raise ValueError(f"Unsupported lifecycle mode: {mode}")
+
+def buildState(module, mode, lifecycles):
+    state = filterMode(mode)
+
+    registryvalue = state
+    registryname = "mode"
+
+    if state != "stop":
+        lifecycles = registerLifecycle(module, lifecycles, registryname, registryvalue)
+
+    elif state == "stop":
+        if not module.name in lifecycles:
+
+            print(f"No registered lifecycle: {module.name}")
+
+            return None
+
+        elif "mode" in lifecycles[module.name] != "stop":
+            lifecycles = registerLifecycle(module, lifecycles, registryname, registryvalue)
+
+            print(f"Stopping lifecycle: {module.name}")
+
+    #elif mode == "oneshot":
+        #registryvalue = {"mode": "oneshot"}
+        #lifecycles = registerLifecycle(module, lifecycles, registryname, registryvalue)
+
+           # else:
+                #raise ValueError(f"Unsupported lifecycle mode: {mode}")
+
+    #state = registryvalue
+
+    return state, lifecycles

trash/lifecyclemanager.py

@@ -0,0 +1,25 @@
+import time
+
+from core.execution.operation import buildOperation
+from core.execution.action import buildAction
+from core import executeContract
+
+def manageLifecycle(module, lifecycles): #lifecycles, state):
+    #print(lifecycles[module.name]["mode"])
+
+    if  lifecycles[module.name]["mode"] == "continuous":
+        while lifecycles[module.name]["mode"] == "continuous":
+            print(lifecycles)
+
+            outputs = executeContract(module)
+
+            #print(lifecycles)
+
+            time.sleep(module.sleeptime)
+
+    elif lifecycles[module.name]["mode"] == "oneshot":
+        print(lifecycles)
+        outputs = executeContract(module)
+
+        #print(lifecycles)
+    return

trash/lifecycleregistry.py

@@ -0,0 +1,8 @@
+def registerLifecycle(module, lifecycles, registryname, registryvalue):
+    if module.name not in lifecycles:
+        lifecycles[module.name] = {}
+
+
+    lifecycles[module.name][registryname] = registryvalue
+
+    return lifecycles

trash/manage.py

@@ -0,0 +1,4 @@
+from plugins import rmass
+from operation import buildOperation
+
+outputs = buildOperation(rmass.checkavailableoperation)

trash/manager.py

@@ -0,0 +1,4 @@
+from core.manager.manager import buildManager
+from plugins import rmass
+
+outputs = buildManager(rmass.manager)

trash/server.py

@@ -0,0 +1,29 @@
+import socket
+import json
+from dispatcher import dispatchRequest
+#from createthread import buildThread
+
+server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+
+server.bind(("127.0.0.1", 19002))
+
+lifecycles = {}
+
+server.listen()
+
+while True:
+    connection, address = server.accept()
+
+    while True:
+        data = connection.recv(4096)
+
+        request = json.loads(data)
+
+#        if not data:
+#            break
+
+        dispatch = dispatchRequest(request, lifecycles)
+
+    connection.close()
+
+#    server.close()