@node-red/runtime 3.1.8 → 4.0.0-beta.2

package/lib/api/comms.js

@@ -36,7 +36,7 @@ var connections = [];
 const events = require("@node-red/util").events;
 
 function handleCommsEvent(event) {
-    publish(event.topic,event.data,event.retain);
+    publish(event.topic,event.data,event.retain,event.session,event.excludeSession);
 }
 function handleStatusEvent(event) {
     if (!event.status) {
@@ -74,13 +74,17 @@ function handleEventLog(event) {
     publish("event-log/"+event.id,event.payload||{});
 }
 
-function publish(topic,data,retain) {
+function publish(topic, data, retain, session, excludeSession) {
     if (retain) {
         retained[topic] = data;
     } else {
         delete retained[topic];
     }
-    connections.forEach(connection => connection.send(topic,data))
+    connections.forEach(connection => {
+        if ((!session || connection.session === session) && (!excludeSession || connection.session !== excludeSession)) {
+            connection.send(topic,data)
+        }
+    })
 }
 
 
@@ -109,6 +113,10 @@ var api = module.exports = {
     */
     addConnection: async function(opts) {
         connections.push(opts.client);
+        events.emit('comms:connection-added', {
+            session: opts.client.session,
+            user: opts.client.user
+        })
     },
 
     /**
@@ -126,6 +134,9 @@ var api = module.exports = {
                 break;
             }
         }
+        events.emit('comms:connection-removed', { 
+            session: opts.client.session
+        })
     },
 
     /**
@@ -157,5 +168,23 @@ var api = module.exports = {
     * @return {Promise<Object>} - resolves when complete
     * @memberof @node-red/runtime_comms
     */
-    unsubscribe: async function(opts) {}
+    unsubscribe: async function(opts) {},
+
+    /**
+     * @param {Object} opts
+     * @param {User} opts.user - the user calling the api
+     * @param {CommsConnection} opts.client - the client connection
+     * @param {String} opts.topic - the message topic
+     * @param {String} opts.data - the message data
+     * @return {Promise<Object>} - resolves when complete
+     */
+    receive: async function (opts) {
+        if (opts.topic) {
+            events.emit('comms:message:' + opts.topic, {
+                session: opts.client.session,
+                user: opts.user,
+                data: opts.data
+            })
+        }
+    }
 };

package/lib/api/context.js

@@ -68,6 +68,7 @@ var api = module.exports = {
     * @param {String} opts.store - the context store
     * @param {String} opts.key - the context key
     * @param {Object} opts.req - the request to log (optional)
+    * @param {Boolean} opts.keysOnly - whether to return keys only
     * @return {Promise} - the node information
     * @memberof @node-red/runtime_context
     */
@@ -102,6 +103,15 @@ var api = module.exports = {
                 if (key) {
                     store = store || availableStores.default;
                     ctx.get(key,store,function(err, v) {
+                        if (opts.keysOnly) {
+                            if (Array.isArray(v)) {
+                                resolve({ [store]: { format: `array[${v.length}]`}})
+                            } else if (typeof v === 'object') {
+                                resolve({ [store]: { keys: Object.keys(v), format: 'Object' } })
+                            } else {
+                                resolve({ [store]: { keys: [] }})
+                            }
+                        }
                         var encoded = util.encodeObject({msg:v});
                         if (store !== availableStores.default) {
                             encoded.store = store;
@@ -118,32 +128,58 @@ var api = module.exports = {
                         stores = [store];
                     }
 
+
                     var result = {};
                     var c = stores.length;
                     var errorReported = false;
                     stores.forEach(function(store) {
-                        exportContextStore(scope,ctx,store,result,function(err) {
-                            if (err) {
-                                // TODO: proper error reporting
-                                if (!errorReported) {
-                                    errorReported = true;
-                                    runtime.log.audit({event: "context.get",scope:scope,id:id,store:store,key:key,error:"unexpected_error"}, opts.req);
-                                    var err = new Error();
-                                    err.code = "unexpected_error";
-                                    err.status = 400;
-                                    return reject(err);
+                        if (opts.keysOnly) {
+                            ctx.keys(store,function(err, keys) {
+                                if (err) {
+                                    // TODO: proper error reporting
+                                    if (!errorReported) {
+                                        errorReported = true;
+                                        runtime.log.audit({event: "context.get",scope:scope,id:id,store:store,key:key,error:"unexpected_error"}, opts.req);
+                                        var err = new Error();
+                                        err.code = "unexpected_error";
+                                        err.status = 400;
+                                        return reject(err);
+                                    }
+                                    return
+                                }
+                                result[store] = { keys }
+                                c--;
+                                if (c === 0) {
+                                    if (!errorReported) {
+                                        runtime.log.audit({event: "context.get",scope:scope,id:id,store:store,key:key},opts.req);
+                                        resolve(result);
+                                    }
                                 }
+                            })
+                        } else {
+                            exportContextStore(scope,ctx,store,result,function(err) {
+                                if (err) {
+                                    // TODO: proper error reporting
+                                    if (!errorReported) {
+                                        errorReported = true;
+                                        runtime.log.audit({event: "context.get",scope:scope,id:id,store:store,key:key,error:"unexpected_error"}, opts.req);
+                                        var err = new Error();
+                                        err.code = "unexpected_error";
+                                        err.status = 400;
+                                        return reject(err);
+                                    }
 
-                                return;
-                            }
-                            c--;
-                            if (c === 0) {
-                                if (!errorReported) {
-                                    runtime.log.audit({event: "context.get",scope:scope,id:id,store:store,key:key},opts.req);
-                                    resolve(result);
+                                    return;
                                 }
-                            }
-                        });
+                                c--;
+                                if (c === 0) {
+                                    if (!errorReported) {
+                                        runtime.log.audit({event: "context.get",scope:scope,id:id,store:store,key:key},opts.req);
+                                        resolve(result);
+                                    }
+                                }
+                            });
+                        }
                     })
                 }
             } else {

package/lib/api/plugins.js

@@ -65,6 +65,25 @@ var api = module.exports = {
         runtime.log.audit({event: "plugins.configs.get"}, opts.req);
         return runtime.plugins.getPluginConfigs(opts.lang);
     },
+
+    /**
+    * Gets the editor content for one registered plugin
+    * @param {Object} opts
+    * @param {User} opts.user - the user calling the api
+    * @param {User} opts.user - the user calling the api
+    * @param {Object} opts.req - the request to log (optional)
+    * @return {Promise<NodeInfo>} - the plugin information
+    * @memberof @node-red/runtime_plugins
+    */
+    getPluginConfig: async function(opts) {
+        if (/[^0-9a-z=\-\*]/i.test(opts.lang)) {
+            throw new Error("Invalid language: "+opts.lang)
+            return;
+        }
+        runtime.log.audit({event: "plugins.configs.get"}, opts.req);
+        return runtime.plugins.getPluginConfig(opts.module, opts.lang);
+    },
+
     /**
     * Gets all registered module message catalogs
     * @param {Object} opts

package/lib/index.js

@@ -22,6 +22,7 @@ var storage = require("./storage");
 var library = require("./library");
 var plugins = require("./plugins");
 var settings = require("./settings");
+const multiplayer = require("./multiplayer");
 
 var express = require("express");
 var path = require('path');
@@ -135,6 +136,7 @@ function start() {
         .then(function() { return storage.init(runtime)})
         .then(function() { return settings.load(storage)})
         .then(function() { return library.init(runtime)})
+        .then(function() { return multiplayer.init(runtime)})
         .then(function() {
             if (settings.available()) {
                 if (settings.get('instanceId') === undefined) {
@@ -154,7 +156,7 @@ function start() {
             log.info(log._("runtime.version",{component:"Node.js ",version:process.version}));
             if (settings.UNSUPPORTED_VERSION) {
                 log.error("*****************************************************************");
-                log.error("* "+log._("runtime.unsupported_version",{component:"Node.js",version:process.version,requires: ">=8.9.0"})+" *");
+                log.error("* "+log._("runtime.unsupported_version",{component:"Node.js",version:process.version,requires: ">=18"})+" *");
                 log.error("*****************************************************************");
                 events.emit("runtime-event",{id:"runtime-unsupported-version",payload:{type:"error",text:"notification.errors.unsupportedVersion"},retain:true});
             }

package/lib/multiplayer/index.js

@@ -0,0 +1,119 @@
+let runtime
+
+/**
+ * Active sessions, mapped by multiplayer session ids
+ */
+const sessions = new Map()
+
+/**
+ * Active connections, mapping comms session to multiplayer session
+ */
+const connections = new Map()
+
+
+function getSessionsList() {
+    return Array.from(sessions.values()).filter(session => session.active)
+}
+
+module.exports = {
+    init: function(_runtime) {
+        runtime = _runtime
+        runtime.events.on('comms:connection-removed', (opts) => {
+            const existingSessionId = connections.get(opts.session)
+            if (existingSessionId) {
+                connections.delete(opts.session)
+                const session = sessions.get(existingSessionId)
+                session.active = false
+                session.idleTimeout = setTimeout(() => {
+                    sessions.delete(existingSessionId)
+                }, 30000)
+                runtime.events.emit('comms', {
+                    topic: "multiplayer/connection-removed",
+                    data: { session: existingSessionId }
+                })
+            }
+        })
+        runtime.events.on('comms:message:multiplayer/connect', (opts) => {
+            let session
+            if (!sessions.has(opts.data.session)) {
+                // Brand new session
+                let user = opts.user
+                if (!user || user.anonymous) {
+                    user = user || { anonymous: true }
+                    user.username = `Anon ${Math.floor(Math.random()*100)}`
+                }
+                session = {
+                    session: opts.data.session,
+                    user,
+                    active: true
+                }
+                sessions.set(opts.data.session, session)
+                connections.set(opts.session, opts.data.session)
+                runtime.log.trace(`multiplayer new session:${opts.data.session} user:${user.username}`)
+            } else {
+                // Reconnected connection - keep existing state
+                connections.set(opts.session, opts.data.session)
+                // const existingConnection  = connections.get(opts.data.session)
+                session = sessions.get(opts.data.session)
+                session.active = true
+                runtime.log.trace(`multiplayer reconnected session:${opts.data.session} user:${session.user.username}`)
+                clearTimeout(session.idleTimeout)
+            }
+            // Tell existing sessions about the new connection
+            runtime.events.emit('comms', {
+                topic: "multiplayer/connection-added",
+                excludeSession: opts.session,
+                data: session
+            })
+
+            // Send init info to new connection
+            const initPacket = {
+                topic: "multiplayer/init",
+                data: getSessionsList(),
+                session: opts.session
+            }
+            // console.log('<<', initPacket)
+            runtime.events.emit('comms', initPacket)
+        })
+        runtime.events.on('comms:message:multiplayer/disconnect', (opts) => {
+            const existingSessionId = connections.get(opts.session)
+            connections.delete(opts.session)
+            sessions.delete(existingSessionId)
+
+            runtime.events.emit('comms', {
+                topic: "multiplayer/connection-removed",
+                data: { session: existingSessionId, disconnected: true }
+            })
+        })
+        runtime.events.on('comms:message:multiplayer/location', (opts) => {
+            // console.log('>>>', opts.user, opts.data)
+
+            const sessionId = connections.get(opts.session)
+            const session = sessions.get(sessionId)
+
+            if (opts.user) {
+                if (session.user.anonymous !== opts.user.anonymous) {
+                    session.user = opts.user
+                    runtime.events.emit('comms', {
+                        topic: 'multiplayer/connection-added',
+                        excludeSession: opts.session,
+                        data: session
+                    })
+                }
+            }
+
+            session.location = opts.data
+
+            const payload = {
+                session: sessionId,
+                workspace: opts.data.workspace,
+                node: opts.data.node
+            }
+            runtime.events.emit('comms', {
+                topic: 'multiplayer/location',
+                data: payload,
+                excludeSession: opts.session
+            })
+        })
+    }
+}

package/lib/nodes/index.js

@@ -173,7 +173,11 @@ function installModule(module,version,url) {
         if (info.pending_version) {
             events.emit("runtime-event",{id:"node/upgraded",retain:false,payload:{module:info.name,version:info.pending_version}});
         } else {
-            events.emit("runtime-event",{id:"node/added",retain:false,payload:info.nodes});
+            if (!info.nodes.length && info.plugins.length) {
+                events.emit("runtime-event",{id:"plugin/added",retain:false,payload:info.plugins});
+            } else {
+                events.emit("runtime-event",{id:"node/added",retain:false,payload:info.nodes});
+            }
         }
         return info;
     });

package/lib/plugins.js

@@ -7,5 +7,6 @@ module.exports = {
     getPluginsByType: registry.getPluginsByType,
     getPluginList: registry.getPluginList,
     getPluginConfigs: registry.getPluginConfigs,
+    getPluginConfig: registry.getPluginConfig,
     exportPluginSettings: registry.exportPluginSettings
 }

package/locales/en-US/runtime.json

@@ -25,6 +25,7 @@
         "removing-modules": "Removing modules from config",
         "added-types": "Added node types:",
         "removed-types": "Removed node types:",
+        "removed-plugins": "Removed plugins:",
         "install": {
             "invalid": "Invalid module name",
             "installing": "Installing module: __name__, version: __version__",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@node-red/runtime",
-    "version": "3.1.8",
+    "version": "4.0.0-beta.2",
     "license": "Apache-2.0",
     "main": "./lib/index.js",
     "repository": {
@@ -16,8 +16,8 @@
         }
     ],
     "dependencies": {
-        "@node-red/registry": "3.1.8",
-        "@node-red/util": "3.1.8",
+        "@node-red/registry": "4.0.0-beta.2",
+        "@node-red/util": "4.0.0-beta.2",
         "async-mutex": "0.4.0",
         "clone": "2.1.2",
         "express": "4.19.2",