configurapi-runner-ws 1.10.0 → 1.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "configurapi-runner-ws",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "Websocket runner for configurapi.",
   "bin": {
     "configurapi-runner-ws": "src/app.mjs"

package/src/app.mjs

@@ -32,6 +32,7 @@ function logDebug(s)
 const commander = new Command();
 commander.option('-p, --port [number]', 'Port number')
          .option('--s-port [number]', 'Secure port number')
+         .option('-m, --mport [number]', 'Management port number')
          .option('-f, --file [path]', 'Path to the config file')
          .option('--key [path]', 'Path to the private key file (.key)')
          .option('--cert [path]', 'Path to the certificate file (.pem)')
@@ -40,6 +41,7 @@ commander.option('-p, --port [number]', 'Port number')
 
 let port = commander.port ? commander.port : 9090;
 let sPort = commander.sPort ? commander.sPort : 9443;
+let mPort = commander.mPort ? commander.mPort : 9100;
 let configPath = commander.file ? commander.file : 'config.yaml';
 let keepAliveTimeout = commander.keepAlive ? commander.keepAlive : (process.env.CONFIGURAPI_RUNNER_SELF_KEEP_ALIVE || 0);
 let key = commander.key ? fs.readFileSync(commander.key) : undefined;
@@ -52,4 +54,4 @@ let app = new App();
 app.on('error', (s) => {logError(s);});
 app.on('debug', (s) => {logDebug(s);});
 app.on('trace', (s) => {logTrace(s);});
-await app.run({port: port, configPath:configPath, keepAliveTimeout:keepAliveTimeout, key: key, cert: cert, sPort: sPort});
+await app.run({port: port, configPath:configPath, keepAliveTimeout:keepAliveTimeout, key: key, cert: cert, sPort: sPort, mPort});

package/src/index.js

@@ -6,6 +6,28 @@ const events = require('events');
 const Configurapi = require('configurapi');
 const { WebSocketServer } = require('ws');
 const { randomUUID } = require("node:crypto");
+const { Response, Route, Policy, PolicyHandlerLoader, LogLevel } = require('configurapi');
+const oneliner = require('one-liner');
+const wsAdapter = require('./wsAdapter');
+const URL = require('url');
+
+function addInternalRoute(self, config, routeName,)
+{
+    let route = new Route();
+    route.name = routeName;
+
+    route.on(LogLevel.Trace, (s)=>self.emit(LogLevel.Trace, oneliner(s)));
+    route.on(LogLevel.Debug, (s)=>self.emit(LogLevel.Debug, oneliner(s)));
+    route.on(LogLevel.Error, (s)=>self.emit(LogLevel.Error, oneliner(s)));
+
+    let policy = new Policy()
+    policy.name = `${routeName}`;
+    route.policies = [policy]
+
+    config.events.set(route.name, route);
+}
+
+const connections = []
 
 module.exports = class HttpRunner extends events.EventEmitter 
 {
@@ -15,6 +37,7 @@ module.exports = class HttpRunner extends events.EventEmitter
 
         this.port = 8000;
         this.sPort = 8443;
+        this.mPort = 9100;
         this.configPath = "config.yaml";
         this.service = undefined;
         this.keepAliveTimeout = 0;
@@ -28,7 +51,35 @@ module.exports = class HttpRunner extends events.EventEmitter
 
         let config = Configurapi.Config.load(this.configPath);
 
-        this.service = new Configurapi.Service(config);
+        let loader = new PolicyHandlerLoader()
+        loader.handlers.set('list_@connections', (e)=>
+        { 
+            e.response.headers['Content-Type'] = 'application/json';
+            e.response.body = Object.keys(connections);
+        });
+        loader.handlers.set('post_@connection', async (e)=>
+        { 
+            e.response.headers['Content-Type'] = 'application/json';
+
+            const connectionId = e.params?.['@connection'];
+
+            if(connectionId && connections[connectionId])
+            {
+                let wsResponse = new Response(e.payload, 200, {...e.request.headers, 'connection-id': connectionId})
+                await wsAdapter.write(connections[connectionId].ws, wsResponse)
+                e.response.statusCode = 204
+            }
+            else
+            {
+                e.response.statusCode = 404;
+                e.response.body = JSON.stringify({ message: `The connection '${connectionId}' does not exist.`, details: ''})
+            }
+        });
+
+        addInternalRoute(this, config, 'list_@connections')
+        addInternalRoute(this, config, 'post_@connection')
+        
+        this.service = new Configurapi.Service(config, loader);
         this.service.on("trace", (s) => this.emit("trace", s));
         this.service.on("debug", (s) => this.emit("debug", s));
         this.service.on("error", (s) => this.emit("error", s));
@@ -55,6 +106,14 @@ module.exports = class HttpRunner extends events.EventEmitter
             this.emit("trace", "Server is listening..."+this.port);
         }
 
+        let managementServer =  http.createServer({key: this.key, cert: this.cert}, (req, resp) => {
+            this._handleManagementRequest(req, resp);
+        });
+        managementServer.keepAliveTimeout = this.keepAliveTimeout;
+        managementServer.listen(this.mPort);
+
+        this.emit('trace', 'Management server is listening...'+this.mPort);
+
         const wss = new WebSocketServer({ server: httpServer, path: "/ws", handleProtocols: (protocols, req) => {
                         if(protocols === undefined)
                         {
@@ -77,9 +136,13 @@ module.exports = class HttpRunner extends events.EventEmitter
             const connectionId = randomUUID();
             ws.connectionId = connectionId;
           
+            connections[connectionId] = {
+                connectionId,
+                ws
+            }
             this.emit("trace", `[connect] ${connectionId}`);
           
-            let onConnectPromise = this._requestListener(ws, undefined, 'on_connect');
+            let onConnectPromise = config.events.has('on_connect') ? this._requestListener(ws, undefined, 'on_connect') : undefined;
 
             ws.on("message", async (data) => 
             {
@@ -92,10 +155,12 @@ module.exports = class HttpRunner extends events.EventEmitter
           
             ws.on("close", async(code, reason) => 
             {
-                await this._requestListener(ws, undefined, 'on_disconnect');
+                await (config.events.has('on_disconnect') ? this._requestListener(ws, undefined, 'on_disconnect') : undefined);
 
                 const reasonMessage = reason && reason.length ? reason.toString("utf8") : "";
 
+                delete connections[connectionId];
+
                 this.emit("trace", `[disconnect] ${connectionId} (${code}${reasonMessage ? ` - ${reasonMessage}` : ""})`);
             });
           
@@ -118,6 +183,7 @@ module.exports = class HttpRunner extends events.EventEmitter
         if ('key' in options) this.key = options.key;
         if ('cert' in options) this.cert = options.cert;
         if ('sPort' in options) this.sPort = options.sPort;
+        if ('mPort' in options) this.mPort = options.mPort;
     }
 
     async _requestListener(ws, incomingMessage, customEventName) 
@@ -188,4 +254,81 @@ module.exports = class HttpRunner extends events.EventEmitter
         }
     }
 
+    async _handleManagementRequest(incomingMessage, serverResponse) 
+    {
+        try 
+        {
+            let event = new Configurapi.Event(await this._toRequest(incomingMessage));
+            
+            await this.service.process(event);
+
+            serverResponse.writeHead(200, event.response.headers);
+            serverResponse.end(JSON.stringify(event.response));
+        }
+        catch (error) 
+        {
+            let response = new Configurapi.ErrorResponse(error, error instanceof SyntaxError ? 400 : 500);
+
+            serverResponse.writeHead(response.statusCode, response.headers);
+            serverResponse.end(JSON.stringify(response.body));
+        }
+    }
+
+    async _toRequest(incomingMessage)
+    {
+        let request = new Configurapi.Request();
+        
+        request.method = incomingMessage.method.toLowerCase();
+        request.headers = incomingMessage.headers;
+
+        let url = URL.parse(incomingMessage.url, true);
+        let data = [];
+
+        request.payload = undefined;
+        request.query = url.query;
+        request.path = url.pathname;
+        request.pathAndQuery = url.href;
+
+        return new Promise((resolve, reject) => 
+        {    
+            incomingMessage.on('data', function(chunk) {
+                data.push(chunk);
+            }).on('end', function() {
+                if(data.length <= 0) {
+                    request.payload = undefined;
+                    return resolve(request);
+                }
+
+                request.payload = Buffer.concat(data);
+
+                if(request.payload && 'content-type' in request.headers)
+                {
+                    let contentType = request.headers['content-type'];
+
+                    if(contentType.startsWith('text/'))
+                    {
+                        request.payload = request.payload.toString();
+                    }
+                    else if(contentType.startsWith('application/json'))
+                    {
+                        try
+                        {
+                            if(request.payload)
+                            {
+                                request.payload = JSON.parse(request.payload);  
+                            }
+                        }
+                        catch(err)
+                        {
+                            reject(err);
+                        } 
+                    }
+                }
+
+                resolve(request);
+            }).on('error', function(err) {
+                reject(err);
+            });
+        });
+    }
 };