Updated Server to used buildListener for pings and updated the listener and firewall to handle definitions accordingly

core/runtime/firewall.py

@@ -6,33 +6,34 @@ from core.runtime.resolver import resolveItem
 
 
 def buildFirewall(listener, outputs):
-    #firewall_log = os.environ.get("LOGS_FIREWALL", "false").lower() == "true"
+    if hasattr(listener, "filters"):
-    firewall_log = True
+        #firewall_log = os.environ.get("LOGS_FIREWALL", "false").lower() == "true"
+        firewall_log = True
 
-    status_code = 200
+        status_code = 200
-    outputs["firewall_allowed"] = []
+        outputs["firewall_allowed"] = []
-    for item in outputs[listener.recursive["source"]]:
+        for item in outputs[listener.recursive["source"]]:
-        resolved = resolveItem(listener, item)
+            resolved = resolveItem(listener, item)
 
-        match, filter = applyConditions(listener, resolved, outputs)
+            match, filter = applyConditions(listener, resolved, outputs)
 
-        if match:
+            if match:
-            status_code = filter.get("status_code", 200)
+                status_code = filter.get("status_code", 200)
 
-            if filter.get("execute", False):
+                if filter.get("execute", False):
-                from core.execution.createthread import buildThread
+                    from core.execution.createthread import buildThread
 
-                thread = buildThread(filter["execute"])
+                    thread = buildThread(filter["execute"])
 
-            if firewall_log:
+                if firewall_log:
-                logging.info(filter.get("print"))
+                    logging.info(filter.get("print"))
-                logging.info(f"Returning status_code: {status_code}")
+                    logging.info(f"Returning status_code: {status_code}")
-            continue
+                continue
 
-        outputs["firewall_allowed"].append(item)
+            outputs["firewall_allowed"].append(item)
-    
+        
-    if outputs["firewall_allowed"] != []:
+        if outputs["firewall_allowed"] != []:
-        return True, status_code
+            return True, status_code
 
-    #Needs to be present to prevent TypeError
+        #Needs to be present to prevent TypeError
-    return False, status_code
+        return False, status_code

core/server/createlistener.py

@@ -4,34 +4,48 @@ import logging
 from core.runtime.outputs import buildOutput
 from core.runtime.firewall import buildFirewall
 from core.runtime.createruntime import outputs
+from core.execution.processregistry import processes
 
 
 def buildListener(listener, self):
     if self.path.startswith(listener.acceptpath):
-    
+        if hasattr(listener, "print"):
-        #Prints can used buildlog for listener runtime
+            logging.info(listener.print)
-        logging.info("Matrix transaction received")
 
         content_length = int(self.headers["Content-Length"])
 
-        data = self.rfile.read(content_length)
+        bytes = self.rfile.read(content_length)
-        request = json.loads(data)
 
-        #outputs = {}
+        #request = json.loads(data)
 
-        buildOutput(data, listener, outputs)
+        buildOutput(bytes, listener, outputs)
 
-        allow, status_code = buildFirewall(listener, outputs)
+        if hasattr(listener, "filters"):
+            allow, status_code = buildFirewall(listener, outputs)
 
-        if allow:
+            if allow:
-            #from core.execution.createthread import buildThread
+                logging.info(outputs["firewall_allowed"])
-            from core.execution.executioncontract import executeContract
-            
-            logging.info(outputs["firewall_allowed"])
 
-            #thread = buildThread(listener.execute)
+                if hasattr(listener, "execute"):
-            executeContract(listener.execute)
+                    if listener.execute["engine"] == "thread":
+                        from core.execution.createthread import buildThread
+                        buildThread(listener.execute["module"])
 
+                    elif listener.execute["engine"] == "contract":
+                        from core.execution.executioncontract import executeContract
+                        executeContract(listener.execute["module"])
+
+        else:
+            if hasattr(listener, "execute"):
+                if listener.execute["engine"] == "thread":
+                    from core.execution.createthread import buildThread
+                    buildThread(listener.execute["module"])
+
+                elif listener.execute["engine"] == "contract":
+                    from core.execution.executioncontract import executeContract
+                    executeContract(listener.execute["module"])
+
+                status_code = listener.status_code["success"]
 
         self.send_response(status_code)
         self.send_header("Content-Type", "application/json")
@@ -42,4 +56,4 @@ def buildListener(listener, self):
     else:
         self.send_error(404)
     
-    return outputs
+    return

core/server/server.py

@@ -4,119 +4,121 @@ import logging
 
 from http.server import HTTPServer, BaseHTTPRequestHandler
 
-from .dispatcher import dispatchRequest
+
-from .createresponse import buildResponse
+#from .dispatcher import dispatchRequest
-from plugins.rmass.listeners import synapselistener
+#from .createresponse import buildResponse
+from plugins.rmass.listeners import synapselistener, matrixpinglistener
 from core.server.createlistener import buildListener
-from plugins.rmass.actions import synapsesetbridgeonline
+#from plugins.rmass.actions import synapsesetbridgeonline
 
 port = int(os.environ.get("SERVER_PORT", 19001))
 
 
 class RequestHandler(BaseHTTPRequestHandler):
     def do_POST(self):
-        if self.path == "/_matrix/app/v1/ping":
+        logging.debug("POST request received")
 
-            from core.execution.createthread import buildThread
+        buildListener(matrixpinglistener, self)
-            thread = buildThread(synapsesetbridgeonline)
 
-            self.send_response(200)
+        # if self.path == "/_matrix/app/v1/ping":
-            self.send_header("Content-Type", "application/json")
-            self.send_header("Content-Length", "2")
-            self.end_headers()
-            self.wfile.write(b"{}")
-            return
 
-        else:
+        #     from core.execution.createthread import buildThread
-            #lifecycles = {}
+        #     thread = buildThread(synapsesetbridgeonline)
-            print("POST request received")
 
-            max_request_size = 1024
+        #     self.send_response(200)
+        #     self.send_header("Content-Type", "application/json")
+        #     self.send_header("Content-Length", "2")
+        #     self.end_headers()
+        #     self.wfile.write(b"{}")
+        #     return
 
-            content_length = self.headers.get("Content-Length")
+        # else:
+        #     print("POST request received")
 
-            # Check whether Content-Length exists
+        #     max_request_size = 1024
-            if content_length is None:
-                response = {
-                    "status": "error",
-                    "message": "Content length required"
-                }
-                status = 411
 
-            else:
+        #     content_length = self.headers.get("Content-Length")
-                # Attempt to convert the header into an integer
-                try:
-                    length = int(content_length)
-                except ValueError:
-                    length = None
 
-                # Validate the converted length
+        #     # Check whether Content-Length exists
-                if length is None:
+        #     if content_length is None:
-                    response = {
+        #         response = {
-                        "status": "error",
+        #             "status": "error",
-                        "message": "Invalid Content-Length"
+        #             "message": "Content length required"
-                    }
+        #         }
-                    status = 400
+        #         status = 411
 
-                elif length < 0:
+        #     else:
-                    response = {
+        #         # Attempt to convert the header into an integer
-                        "status": "error",
+        #         try:
-                        "message": "Bad Request"
+        #             length = int(content_length)
-                    }
+        #         except ValueError:
-                    status = 400
+        #             length = None
 
-                elif length > max_request_size:
+        #         # Validate the converted length
-                    response = {
+        #         if length is None:
-                        "status": "error",
+        #             response = {
-                        "message": "Content exceeds maximum request size"
+        #                 "status": "error",
-                    }
+        #                 "message": "Invalid Content-Length"
-                    status = 413
+        #             }
+        #             status = 400
 
-                else:
+        #         elif length < 0:
-                    # Content-Length is valid, so read the body
+        #             response = {
-                    data = self.rfile.read(length)
+        #                 "status": "error",
+        #                 "message": "Bad Request"
+        #             }
+        #             status = 400
 
-                    try:
+        #         elif length > max_request_size:
-                        request = json.loads(data)
+        #             response = {
+        #                 "status": "error",
+        #                 "message": "Content exceeds maximum request size"
+        #             }
+        #             status = 413
 
-                    except json.JSONDecodeError:
+        #         else:
-                        response = {
+        #             # Content-Length is valid, so read the body
-                            "status": "error",
+        #             data = self.rfile.read(length)
-                            "message": "Invalid JSON received"
-                        }
-                        status = 400
 
-                    else:
+        #             try:
-                        # Only valid JSON reaches the dispatcher
+        #                 request = json.loads(data)
-                        thread, lifecycles, module, mode = dispatchRequest(
-                            request, lifecycles
-                        )
 
-                        response = buildResponse(module, thread, mode)
+        #             except json.JSONDecodeError:
-                        status = 200
+        #                 response = {
+        #                     "status": "error",
+        #                     "message": "Invalid JSON received"
+        #                 }
+        #                 status = 400
 
-            # Serialize the response
+        #             else:
-            responsebytes = json.dumps(response).encode("utf-8")
+        #                 # Only valid JSON reaches the dispatcher
+        #                 thread, lifecycles, module, mode = dispatchRequest(
+        #                     request, lifecycles
+        #                 )
 
-            # Send one HTTP response
+        #                 response = buildResponse(module, thread, mode)
-            self.send_response(status)
+        #                 status = 200
-            self.send_header("Content-Type", "application/json")
-            self.send_header("Content-Length", str(len(responsebytes)))
-            self.end_headers()
 
-            self.wfile.write(responsebytes)
+        #     # Serialize the response
+        #     responsebytes = json.dumps(response).encode("utf-8")
+
+        #     # Send one HTTP response
+        #     self.send_response(status)
+        #     self.send_header("Content-Type", "application/json")
+        #     self.send_header("Content-Length", str(len(responsebytes)))
+        #     self.end_headers()
+
+        #     self.wfile.write(responsebytes)
 
 
     def do_PUT(self):
-        #print("PUT request received")
+        logging.debug("PUT request received")
 
-        outputs = buildListener(synapselistener, self)
+        buildListener(synapselistener, self)
 
 def startServer():
     server = HTTPServer(("0.0.0.0", port), RequestHandler)
 
-    logging.info(f"Server listening on port {port}")
+    logging.info(f"Server listening on port {port}")  
-    #outputs = {}
-    #outputs, response = buildAction(pingsynapse, outputs)    
 
     server.serve_forever()

plugins/rmass/listeners/matrixpinglistener.py

@@ -0,0 +1,16 @@
+from plugins.rmass.actions import synapsesetbridgeonline
+
+name = "Matrix Ping Listener"
+
+kind = "listener"
+
+acceptpath = "/_matrix/app/v1/ping"
+
+execute = {
+    "module": synapsesetbridgeonline,
+    "engine": "thread",
+}
+
+status_code = {
+    "success": 200
+}

plugins/rmass/listeners/synapselistener.py

@@ -30,7 +30,10 @@ recursive = {
 
 acceptpath = "/_matrix/app/v1/transactions/"
 
-execute = rmassmessagepush
+execute = {
+    "module": rmassmessagepush,
+    "engine": "contract",
+}
 
 filters = [
     {
@@ -74,3 +77,4 @@ filters = [
 
 ]
 
+print = "Matrix transaction received"