@theotherwillembotha/node-red-cluster 0.0.55

package/build/Plugins.js

@@ -0,0 +1,70 @@
+
+/*
+
+    This file was automatically generated using the NODERED Core utility.
+    Any modifications to his file will be overwritten the next time the code is regenerated.
+        
+    You have been warned.
+    
+*/
+"use strict";
+const runtime = require("node-red").runtime;
+const ClusterService = require("./cluster/service/ClusterService").ClusterService;
+
+module.exports = function (RED) {
+
+    // 1. make a list of all the plugins that need to be installed.
+    let pluginList =  [ClusterService]
+        .map(service => service.getServiceDescriptor())
+        .filter(plugin => !RED.plugins.get(plugin.id()));
+
+    // 2. register a listener if there are any plugins in the pluginList.
+    if(pluginList.length > 0){
+        RED.events.on('registry:plugin-added', async pluginID => {
+
+            let addedPlugin = pluginList.find(plugin => plugin.id() === pluginID);
+            let plugin = RED.plugins.get(pluginID);
+
+            if(addedPlugin && plugin.instantiate && !plugin.instance){
+                console.log("Deploying instance of: " + plugin.id);
+                plugin.instance = new plugin.class();
+                
+                // instantiate the plugin.
+                await plugin.instance.init(RED);
+
+                // publish an event that it has ben deployed.
+                RED.events.emit("plugin.instantiated", pluginID);
+                                
+                pluginList.splice(pluginList.findIndex(current => current.id() === addedPlugin.id()), 1);
+
+                // register a flow deployment listener.
+                let startupDeployment = true;
+                RED.events.on('runtime-event', async (event) => {
+                    // startup deployment.
+                    if ("runtime-deploy" === event?.id && startupDeployment) {
+                        //console.log("STARTUP DEPLOYMENT");
+                        startupDeployment = false;
+                        const flows = await runtime.flows.getFlows({});
+                        await plugin.instance.onDeploy(flows);
+                    }
+                    
+                    // stopping flows on redeployment.
+                    if ("runtime-state" === event?.id && event?.payload?.state === "stop" && event?.payload?.deploy) {
+                        //console.log("REDEPLOY!");
+                        const flows = await runtime.flows.getFlows({});
+                        await plugin.instance.onDeploy(flows);
+                    }
+                });
+            }
+        });
+    }
+
+    // 3. register the plugins.
+    [...pluginList].forEach(plugin => {
+        RED.plugins.registerPlugin(plugin.id(), {
+            type: plugin.type(),
+            instantiate:true,
+            class: plugin.clazz()
+        });
+    })
+};

package/build/cluster/node/ClusterConfigNode.js

@@ -0,0 +1,89 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterConfigNode = exports.ClusterRole = void 0;
+const node_red_plugincore_1 = require("@theotherwillembotha/node-red-plugincore");
+const ClusterService_1 = require("../service/ClusterService");
+var ClusterRole;
+(function (ClusterRole) {
+    ClusterRole["Member"] = "Member";
+    ClusterRole["Observer"] = "Observer";
+})(ClusterRole || (exports.ClusterRole = ClusterRole = {}));
+function toNodeStatus(status, error) {
+    switch (status) {
+        case "connecting": return { fill: "yellow", shape: "ring", text: "connecting..." };
+        case "connected": return { fill: "green", shape: "dot", text: "connected" };
+        case "disconnected": return { fill: "red", shape: "ring", text: "disconnected" };
+        case "error": return { fill: "red", shape: "ring", text: error?.message ?? "error" };
+        default: return { fill: "grey", shape: "ring", text: "idle" };
+    }
+}
+let ClusterConfigNode = class ClusterConfigNode extends node_red_plugincore_1.ConfigNode {
+    constructor(node, config) {
+        super(node, config);
+        this._unsubscribeStatus = null;
+        this._instanceId = config.instanceId;
+        this._zkRootPath = config.zkRootPath || "/nodered-cluster";
+        this._natsAddress = config.natsAddress;
+        this._natsUser = config.natsUser || "";
+        this._natsPass = config.natsPass || "";
+        this._role = config.role || ClusterRole.Member;
+        const client = ClusterService_1.ClusterService.ensureClient(this.id(), {
+            instanceId: this._instanceId,
+            zkRootPath: this._zkRootPath,
+            natsAddress: this._natsAddress,
+            natsUser: this._natsUser || undefined,
+            natsPass: this._natsPass || undefined,
+            role: this._role,
+        });
+        // Reflect the live client status on this node's status indicator.
+        this.node().status(toNodeStatus(client.status()));
+        this._unsubscribeStatus = client.onStatusChange((status, error) => {
+            this.node().status(toNodeStatus(status, error));
+        });
+    }
+    onInit() {
+        this.node().on("close", (removed, done) => {
+            this._unsubscribeStatus?.();
+            this._unsubscribeStatus = null;
+            if (removed) {
+                // Node permanently deleted  tear down the cluster connection.
+                ClusterService_1.ClusterService.removeClient(this.id());
+            }
+            done();
+        });
+    }
+    // ── Accessors ────────────────────────────────────────────────────────────
+    instanceId() { return this._instanceId; }
+    zkRootPath() { return this._zkRootPath; }
+    natsAddress() { return this._natsAddress; }
+    natsUser() { return this._natsUser; }
+    natsPass() { return this._natsPass; }
+    role() { return this._role; }
+    isObserver() {
+        return this._role === ClusterRole.Observer;
+    }
+    getClient() {
+        return ClusterService_1.ClusterService.getClient(this.id());
+    }
+};
+exports.ClusterConfigNode = ClusterConfigNode;
+exports.ClusterConfigNode = ClusterConfigNode = __decorate([
+    (0, node_red_plugincore_1.NodeDescription)({
+        id: "ClusterConfigNode",
+        name: "Cluster Config Node",
+        group: "config",
+        sourceFile: node_red_plugincore_1.SourceUtility.getSourcePath("/build/", "/src/") + "ClusterConfigNode.html",
+        package: "@theotherwillembotha/node-red-cluster",
+        tags: ["Cluster"]
+    }),
+    __metadata("design:paramtypes", [Object, Object])
+], ClusterConfigNode);

package/build/cluster/node/ClusterPublishNode.js

@@ -0,0 +1,118 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterPublishNode = exports.DeliveryMode = void 0;
+const node_red_plugincore_1 = require("@theotherwillembotha/node-red-plugincore");
+const ClusterConfigNode_1 = require("./ClusterConfigNode");
+var DeliveryMode;
+(function (DeliveryMode) {
+    DeliveryMode["Durable"] = "Durable";
+    DeliveryMode["Ephemeral"] = "Ephemeral";
+})(DeliveryMode || (exports.DeliveryMode = DeliveryMode = {}));
+const observerStatus = { fill: "grey", shape: "ring", text: "observer  publish disabled" };
+const readyStatus = { fill: "green", shape: "dot", text: "ready" };
+const notConnectedStatus = { fill: "yellow", shape: "ring", text: "waiting for connection..." };
+let ClusterPublishNode = class ClusterPublishNode extends node_red_plugincore_1.BaseNode {
+    constructor(node, config) {
+        super(node, config);
+        this._unsubscribeStatus = null;
+        this._configNode = node_red_plugincore_1.NodeManager.RED.nodes.getNode(config.clusterConfig).node();
+        this._subject = config.subject;
+        this._mode = config.mode || DeliveryMode.Durable;
+        this._ttl = config.ttl || 30;
+        if (this._configNode.isObserver()) {
+            this.node().status(observerStatus);
+            return;
+        }
+        const client = this._configNode.getClient();
+        if (client) {
+            this.node().status(client.status() === "connected" ? readyStatus : notConnectedStatus);
+            this._unsubscribeStatus = client.onStatusChange((status) => {
+                if (status === "connected") {
+                    this.node().status(readyStatus);
+                    this._announceEndpoint(client);
+                }
+                else {
+                    this.node().status(notConnectedStatus);
+                }
+            });
+            if (client.status() === "connected") {
+                this._announceEndpoint(client);
+            }
+        }
+        else {
+            this.node().status(notConnectedStatus);
+        }
+    }
+    onInit() {
+        this.node().on("close", (removed, done) => {
+            this._unsubscribeStatus?.();
+            this._unsubscribeStatus = null;
+            if (removed) {
+                const client = this._configNode.getClient();
+                if (client)
+                    this._removeEndpoint(client);
+            }
+            done();
+        });
+    }
+    async messageReceived(message) {
+        if (this._configNode.isObserver())
+            return;
+        const client = this._configNode.getClient();
+        if (!client || client.status() !== "connected") {
+            this.node().warn("ClusterPublish: not connected, message dropped");
+            return;
+        }
+        const subject = client.buildPublishSubject(this._subject);
+        const data = JSON.stringify(message.payload);
+        try {
+            if (this._mode === DeliveryMode.Durable) {
+                await client.jsPublish(subject, data);
+            }
+            else {
+                client.corePublish(subject, data);
+            }
+        }
+        catch (err) {
+            this.node().error(`ClusterPublish: failed to publish: ${err.message}`, message);
+            this.node().status({ fill: "red", shape: "ring", text: `publish error: ${err.message}` });
+        }
+    }
+    // ── KV endpoint announcement ─────────────────────────────────────────────
+    _announceEndpoint(client) {
+        client.announceEndpoint(this._subject, this._mode, this._ttl).catch(err => {
+            this.node().warn(`ClusterPublish: failed to announce endpoint: ${err.message}`);
+        });
+    }
+    _removeEndpoint(client) {
+        client.removeEndpoint(this._subject).catch(() => { });
+    }
+};
+exports.ClusterPublishNode = ClusterPublishNode;
+__decorate([
+    (0, node_red_plugincore_1.onInput)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], ClusterPublishNode.prototype, "messageReceived", null);
+exports.ClusterPublishNode = ClusterPublishNode = __decorate([
+    (0, node_red_plugincore_1.NodeDescription)({
+        id: "ClusterPublishNode",
+        name: "Cluster Publish Node",
+        group: "cluster",
+        sourceFile: node_red_plugincore_1.SourceUtility.getSourcePath("/build/", "/src/") + "ClusterPublishNode.html",
+        package: "@theotherwillembotha/node-red-cluster",
+        dependencies: [ClusterConfigNode_1.ClusterConfigNode],
+        tags: ["Cluster"]
+    }),
+    __metadata("design:paramtypes", [Object, Object])
+], ClusterPublishNode);

package/build/cluster/node/ClusterSubscribeNode.js

@@ -0,0 +1,104 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterSubscribeNode = void 0;
+const node_red_plugincore_1 = require("@theotherwillembotha/node-red-plugincore");
+const ClusterConfigNode_1 = require("./ClusterConfigNode");
+const subscribedStatus = { fill: "green", shape: "dot", text: "subscribed" };
+const disconnectedStatus = { fill: "red", shape: "ring", text: "disconnected" };
+const connectingStatus = { fill: "yellow", shape: "ring", text: "waiting for connection..." };
+let ClusterSubscribeNode = class ClusterSubscribeNode extends node_red_plugincore_1.BaseNode {
+    constructor(node, config) {
+        super(node, config);
+        this._subscriptions = [];
+        this._unsubscribeStatus = null;
+        this._configNode = node_red_plugincore_1.NodeManager.RED.nodes.getNode(config.clusterConfig).node();
+        this._subjectPattern = config.subjectPattern;
+        const client = this._configNode.getClient();
+        if (client) {
+            this._unsubscribeStatus = client.onStatusChange((status) => {
+                if (status === "connected") {
+                    this._subscribe(client);
+                }
+                else {
+                    this._unsubscribe();
+                    this.node().status(disconnectedStatus);
+                }
+            });
+            if (client.status() === "connected") {
+                this._subscribe(client);
+            }
+            else {
+                this.node().status(connectingStatus);
+            }
+        }
+        else {
+            this.node().status(connectingStatus);
+        }
+    }
+    onInit() {
+        this.node().on("close", (removed, done) => {
+            this._unsubscribeStatus?.();
+            this._unsubscribeStatus = null;
+            if (removed) { /* nothing to clean up */ }
+            this._unsubscribe();
+            done();
+        });
+    }
+    // ── Subscription management ──────────────────────────────────────────────
+    _subscribe(client) {
+        if (this._subscriptions.length > 0)
+            return; // already subscribed
+        const nc = client.natsClient();
+        if (!nc)
+            return;
+        const patterns = this._subjectPattern
+            .split(",")
+            .map(p => p.trim())
+            .filter(p => p.length > 0);
+        const node = this.node();
+        for (const pattern of patterns) {
+            const sub = nc.subscribe(client.buildSubscribePattern(pattern));
+            this._subscriptions.push(sub);
+            (async () => {
+                for await (const msg of sub) {
+                    try {
+                        node.send({ payload: JSON.parse(msg.string()), topic: msg.subject });
+                    }
+                    catch (_) {
+                        node.send({ payload: msg.string(), topic: msg.subject });
+                    }
+                }
+            })();
+        }
+        const count = this._subscriptions.length;
+        this.node().status(count > 1
+            ? { fill: "green", shape: "dot", text: `subscribed (${count})` }
+            : subscribedStatus);
+    }
+    _unsubscribe() {
+        this._subscriptions.forEach(sub => sub.unsubscribe());
+        this._subscriptions = [];
+    }
+};
+exports.ClusterSubscribeNode = ClusterSubscribeNode;
+exports.ClusterSubscribeNode = ClusterSubscribeNode = __decorate([
+    (0, node_red_plugincore_1.NodeDescription)({
+        id: "ClusterSubscribeNode",
+        name: "Cluster Subscribe Node",
+        group: "cluster",
+        sourceFile: node_red_plugincore_1.SourceUtility.getSourcePath("/build/", "/src/") + "ClusterSubscribeNode.html",
+        package: "@theotherwillembotha/node-red-cluster",
+        dependencies: [ClusterConfigNode_1.ClusterConfigNode],
+        tags: ["Cluster"]
+    }),
+    __metadata("design:paramtypes", [Object, Object])
+], ClusterSubscribeNode);

package/build/cluster/service/ClusterClient.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterClient = void 0;
+const transport_node_1 = require("@nats-io/transport-node");
+const jetstream_1 = require("@nats-io/jetstream");
+const kv_1 = require("@nats-io/kv");
+class ClusterClient {
+    constructor(params) {
+        this._natsClient = null;
+        this._kvBucket = null;
+        this._status = "idle";
+        this._statusListeners = [];
+        this._streamName = null;
+        this._params = params;
+    }
+    // ── Lifecycle ────────────────────────────────────────────────────────────
+    updateParams(params) {
+        if (JSON.stringify(params) === JSON.stringify(this._params))
+            return;
+        this._streamName = null;
+        // stop() must run with the OLD params so it cleans up the correct KV keys,
+        // then swap params in before start() so the new identity is registered.
+        this.stop().then(() => {
+            this._params = params;
+            return this.start();
+        }).catch(err => {
+            console.error("ClusterClient: restart after param change failed:", err);
+        });
+    }
+    async start() {
+        this._setStatus("connecting");
+        const connectOpts = { servers: this._params.natsAddress };
+        if (this._params.natsUser)
+            connectOpts.user = this._params.natsUser;
+        if (this._params.natsPass)
+            connectOpts.pass = this._params.natsPass;
+        this._natsClient = await (0, transport_node_1.connect)(connectOpts);
+        await this._initKV();
+        this._setStatus("connected");
+    }
+    async stop() {
+        if (this._kvBucket) {
+            try {
+                await this._kvBucket.delete(`instances.${this._params.instanceId}`);
+            }
+            catch (_) { }
+            try {
+                const iter = await this._kvBucket.keys(`endpoints.${this._params.instanceId}.>`);
+                for await (const key of iter) {
+                    try {
+                        await this._kvBucket.delete(key);
+                    }
+                    catch (_) { }
+                }
+            }
+            catch (_) { /* no endpoint keys to clean up */ }
+            this._kvBucket = null;
+        }
+        if (this._natsClient) {
+            try {
+                await this._natsClient.drain();
+            }
+            catch (_) { /* ignore drain errors */ }
+            this._natsClient = null;
+        }
+        this._streamName = null;
+        this._setStatus("idle");
+    }
+    // ── Accessors ────────────────────────────────────────────────────────────
+    natsClient() { return this._natsClient; }
+    kvBucket() { return this._kvBucket; }
+    status() { return this._status; }
+    params() { return this._params; }
+    // ── Subject helpers ──────────────────────────────────────────────────────
+    /** `nodered-cluster.field-a.commands.opengate` */
+    buildPublishSubject(subject) {
+        return `${this.rootPrefix()}.${this._params.instanceId}.${subject}`;
+    }
+    /** `nodered-cluster.*.commands.opengate` */
+    buildSubscribePattern(subjectPattern) {
+        return `${this.rootPrefix()}.${subjectPattern}`;
+    }
+    /** Strip leading `/`, replace `/` with `.`  e.g. `/nodered-cluster` → `nodered-cluster` */
+    rootPrefix() {
+        return this._params.zkRootPath.replace(/^\//, "").replace(/\//g, ".");
+    }
+    /** KV bucket name e.g. `CLUSTER_NODERED_CLUSTER` */
+    kvBucketName() {
+        return "CLUSTER_" + this.rootPrefix().toUpperCase().replace(/[.\-\/]/g, "_");
+    }
+    // ── KV endpoint/instance helpers ─────────────────────────────────────────
+    async announceEndpoint(subject, mode, ttl) {
+        const kv = this._kvBucket;
+        if (!kv)
+            return;
+        await kv.put(`endpoints.${this._params.instanceId}.${subject}`, JSON.stringify({ mode, ttl }));
+    }
+    async removeEndpoint(subject) {
+        const kv = this._kvBucket;
+        if (!kv)
+            return;
+        await kv.delete(`endpoints.${this._params.instanceId}.${subject}`);
+    }
+    // ── Stream management ────────────────────────────────────────────────────
+    async ensureStream() {
+        if (this._streamName)
+            return this._streamName;
+        const nc = this._natsClient;
+        const jsm = await (0, jetstream_1.jetstreamManager)(nc);
+        const prefix = this.rootPrefix();
+        const name = prefix.toUpperCase().replace(/[.\-\/]/g, "_");
+        try {
+            await jsm.streams.info(name);
+        }
+        catch (_) {
+            await jsm.streams.add({ name, subjects: [`${prefix}.>`] });
+        }
+        this._streamName = name;
+        return name;
+    }
+    /** Publish to JetStream (durable delivery). Ensures stream exists first. */
+    async jsPublish(subject, data) {
+        await this.ensureStream();
+        const js = (0, jetstream_1.jetstream)(this._natsClient);
+        await js.publish(subject, data);
+    }
+    /** Publish via core NATS (ephemeral  fire and forget). */
+    corePublish(subject, data) {
+        this._natsClient.publish(subject, data);
+    }
+    // ── Status subscriptions ─────────────────────────────────────────────────
+    onStatusChange(listener) {
+        this._statusListeners.push(listener);
+        return () => {
+            this._statusListeners = this._statusListeners.filter(l => l !== listener);
+        };
+    }
+    // ── Internals ────────────────────────────────────────────────────────────
+    _setStatus(status, error) {
+        this._status = status;
+        this._statusListeners.forEach(l => l(status, error));
+    }
+    async _initKV() {
+        const kvm = new kv_1.Kvm(this._natsClient);
+        this._kvBucket = await kvm.create(this.kvBucketName(), { history: 1 });
+        await this._kvBucket.put(`instances.${this._params.instanceId}`, JSON.stringify({ natsAddress: this._params.natsAddress, role: this._params.role }));
+    }
+}
+exports.ClusterClient = ClusterClient;