node-red-contrib-3dm-space 0.0.2

package/3dm-cloud-config.html

@@ -0,0 +1,44 @@
+<script type="text/javascript">
+    RED.nodes.registerType("3dm-cloud-config", {
+        category: "config",
+        defaults: {
+            name: { value: "" },
+            clientid: { value: "" }
+        },
+        credentials: {
+            username: { type: "text" },
+            password: { type: "password" }
+        },
+        label: function () {
+            return this.name || "3DM Cloud Login";
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="3dm-cloud-config">
+    <div class="form-row">
+        <label for="node-config-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-config-input-name" placeholder="e.g. Main PassPort">
+    </div>
+
+    <div class="form-row">
+        <label for="node-config-input-username"><i class="fa fa-user"></i> Username</label>
+        <input type="text" id="node-config-input-username" placeholder="Paste device username">
+    </div>
+
+    <div class="form-row">
+        <label for="node-config-input-password"><i class="fa fa-key"></i> Password</label>
+        <input type="password" id="node-config-input-password" placeholder="Paste device password">
+    </div>
+
+    <div class="form-row">
+        <label for="node-config-input-clientid"><i class="fa fa-id-card"></i> Client ID</label>
+        <input type="text" id="node-config-input-clientid" placeholder="Optional, leave blank unless supplied">
+    </div>
+</script>
+
+<script type="text/html" data-help-name="3dm-cloud-config">
+    <p>Login details for 3DM.space SCADA Cloud.</p>
+    <p>Give this login a friendly name, then paste the device username and password from 3DM.space.</p>
+    <p>Client ID is optional. Leave it blank unless supplied.</p>
+</script>

package/3dm-cloud-config.js

@@ -0,0 +1,192 @@
+module.exports = function (RED) {
+    "use strict";
+
+    var mqtt = require("mqtt");
+
+    /*
+     * 3DM.space Cloud connection settings
+     * Hidden from users.
+     */
+    var CLOUD_HOST = "3dm.space";
+    var CLOUD_PORT = 1883;
+    var CLOUD_URL = "mqtt://" + CLOUD_HOST + ":" + CLOUD_PORT;
+
+    var MQTT_KEEPALIVE = 60;
+    var MQTT_CLEAN_SESSION = true;
+    var MQTT_RECONNECT_MS = 5000;
+    var MQTT_CONNECT_TIMEOUT_MS = 15000;
+
+    /*
+     * Prevent the logs getting hammered with the same auth error every 5 seconds.
+     */
+    var REPEAT_ERROR_LOG_MS = 60000;
+
+    function cleanText(value) {
+        if (value === null || value === undefined) {
+            return "";
+        }
+
+        return String(value).trim();
+    }
+
+    function ThreeDMCloudConfigNode(config) {
+        RED.nodes.createNode(this, config);
+
+        var node = this;
+
+        node.name = cleanText(config.name);
+        node.clientid = cleanText(config.clientid);
+
+        node.username = node.credentials && node.credentials.username
+            ? cleanText(node.credentials.username)
+            : "";
+
+        node.password = node.credentials && node.credentials.password
+            ? cleanText(node.credentials.password)
+            : "";
+
+        node.connected = false;
+        node.client = null;
+        node.subscriptions = {};
+
+        node.lastErrorText = "";
+        node.lastErrorTime = 0;
+
+        node.setMaxListeners(0);
+
+        function warnOncePerMinute(text) {
+            var now = Date.now();
+
+            if (text !== node.lastErrorText || (now - node.lastErrorTime) > REPEAT_ERROR_LOG_MS) {
+                node.lastErrorText = text;
+                node.lastErrorTime = now;
+                node.warn(text);
+            }
+        }
+
+        node.connect = function () {
+            if (!node.username) {
+                node.connected = false;
+                node.emit("state", false);
+                warnOncePerMinute("3DM Cloud username is missing");
+                return;
+            }
+
+            var options = {
+                username: node.username,
+                password: node.password,
+                clean: MQTT_CLEAN_SESSION,
+                keepalive: MQTT_KEEPALIVE,
+                reconnectPeriod: MQTT_RECONNECT_MS,
+                connectTimeout: MQTT_CONNECT_TIMEOUT_MS
+            };
+
+            /*
+             * Only send Client ID if the user entered one.
+             */
+            if (node.clientid) {
+                options.clientId = node.clientid;
+            }
+
+            node.client = mqtt.connect(CLOUD_URL, options);
+
+            node.client.on("connect", function () {
+                node.connected = true;
+                node.lastErrorText = "";
+                node.lastErrorTime = 0;
+
+                node.emit("state", true);
+
+                Object.keys(node.subscriptions).forEach(function (topic) {
+                    node.client.subscribe(topic, node.subscriptions[topic], function (err) {
+                        if (err) {
+                            warnOncePerMinute("3DM Cloud subscribe failed: " + (err.message || err));
+                        }
+                    });
+                });
+            });
+
+            node.client.on("reconnect", function () {
+                node.emit("reconnect");
+            });
+
+            node.client.on("offline", function () {
+                node.connected = false;
+                node.emit("state", false);
+            });
+
+            node.client.on("close", function () {
+                node.connected = false;
+                node.emit("state", false);
+            });
+
+            node.client.on("error", function (err) {
+                node.connected = false;
+                node.emit("state", false);
+
+                var text = err && err.message ? err.message : String(err);
+
+                if (text.indexOf("Not authorized") !== -1 || text.indexOf("not authorized") !== -1) {
+                    warnOncePerMinute("3DM Cloud login rejected. Check username, password, and Client ID.");
+                } else {
+                    warnOncePerMinute("3DM Cloud connection error: " + text);
+                }
+            });
+
+            node.client.on("message", function (topic, payload) {
+                node.emit("cloud-message", topic, payload);
+            });
+        };
+
+        node.publish = function (topic, payload, options, callback) {
+            if (!node.client || !node.connected) {
+                var err = new Error("3DM Cloud is not connected");
+
+                if (callback) {
+                    callback(err);
+                }
+
+                return;
+            }
+
+            var data = payload;
+
+            if (typeof data !== "string" && !Buffer.isBuffer(data)) {
+                data = JSON.stringify(data);
+            }
+
+            node.client.publish(topic, data, options || {}, callback);
+        };
+
+        node.subscribe = function (topic, options, callback) {
+            node.subscriptions[topic] = options || {};
+
+            if (node.client && node.connected) {
+                node.client.subscribe(topic, options || {}, callback);
+            } else if (callback) {
+                callback();
+            }
+        };
+
+        node.on("close", function (removed, done) {
+            node.connected = false;
+
+            if (node.client) {
+                node.client.end(true, function () {
+                    done();
+                });
+            } else {
+                done();
+            }
+        });
+
+        node.connect();
+    }
+
+    RED.nodes.registerType("3dm-cloud-config", ThreeDMCloudConfigNode, {
+        credentials: {
+            username: { type: "text" },
+            password: { type: "password" }
+        }
+    });
+};

package/3dm-cloud-in.html

@@ -0,0 +1,58 @@
+<script type="text/javascript">
+    RED.nodes.registerType("3dm-cloud-in", {
+        category: "3DM.space",
+        color: "#656565",
+        defaults: {
+            name: { value: "" },
+            server: { value: "", type: "3dm-cloud-config", required: true },
+            keyFilter: { value: "" },
+            outputMode: { value: "value" }
+        },
+        inputs: 0,
+        outputs: 1,
+        icon: "icon.png",
+        label: function () {
+            return this.name || "3DM attributes in";
+        },
+        paletteLabel: "3DM in"
+    });
+</script>
+
+<script type="text/html" data-template-name="3dm-cloud-in">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="3DM attributes in">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-server"><i class="fa fa-cloud"></i> Login</label>
+        <input type="text" id="node-input-server">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-keyFilter"><i class="fa fa-filter"></i> Key Filter</label>
+        <input type="text" id="node-input-keyFilter" placeholder="Leave blank to allow all">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-outputMode"><i class="fa fa-sign-out"></i> Output</label>
+        <select id="node-input-outputMode" style="width:70%;">
+            <option value="value">Value only</option>
+            <option value="object">Object with key</option>
+        </select>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="3dm-cloud-in">
+    <p>Receives cloud attribute updates from 3DM.space.</p>
+
+    <p>If Key Filter is blank, all incoming attributes pass through.</p>
+
+    <p>If Key Filter is set to <code>pump_cmd</code>, only messages containing <code>pump_cmd</code> are passed through.</p>
+
+    <p>Output modes:</p>
+    <ul>
+        <li><b>Value only</b>: outputs just the selected value.</li>
+        <li><b>Object with key</b>: outputs a JSON object containing the selected key.</li>
+    </ul>
+</script>

package/3dm-cloud-in.js

@@ -0,0 +1,115 @@
+module.exports = function (RED) {
+    "use strict";
+
+    /*
+     * Hidden cloud subscribe settings.
+     */
+    var ATTRIBUTES_TOPIC = "v1/devices/me/attributes";
+    var MQTT_QOS = 1;
+
+    function ThreeDMCloudInNode(config) {
+        RED.nodes.createNode(this, config);
+
+        var node = this;
+
+        node.name = config.name;
+        node.server = RED.nodes.getNode(config.server);
+        node.keyFilter = config.keyFilter || "";
+        node.outputMode = config.outputMode || "value";
+
+        if (!node.server) {
+            node.status({ fill: "red", shape: "ring", text: "missing config" });
+            return;
+        }
+
+        function updateStatus(connected) {
+            if (connected) {
+                node.status({ fill: "green", shape: "dot", text: "connected" });
+            } else {
+                node.status({ fill: "red", shape: "ring", text: "disconnected" });
+            }
+        }
+
+        function parsePayload(payload) {
+            var text = payload.toString();
+
+            try {
+                return JSON.parse(text);
+            } catch (e) {
+                return text;
+            }
+        }
+
+        function hasOwn(obj, key) {
+            return Object.prototype.hasOwnProperty.call(obj, key);
+        }
+
+        var stateHandler = function (connected) {
+            updateStatus(connected);
+        };
+
+        var messageHandler = function (topic, payload) {
+            if (topic !== ATTRIBUTES_TOPIC) {
+                return;
+            }
+
+            var data = parsePayload(payload);
+
+            if (node.keyFilter) {
+                if (typeof data !== "object" || data === null || Array.isArray(data)) {
+                    return;
+                }
+
+                if (!hasOwn(data, node.keyFilter)) {
+                    return;
+                }
+
+                var msg = {
+                    topic: node.keyFilter,
+                    key: node.keyFilter,
+                    value: data[node.keyFilter],
+                    values: data
+                };
+
+                if (node.outputMode === "object") {
+                    var obj = {};
+                    obj[node.keyFilter] = data[node.keyFilter];
+                    msg.payload = obj;
+                } else {
+                    msg.payload = data[node.keyFilter];
+                }
+
+                node.send(msg);
+                return;
+            }
+
+            node.send({
+                topic: "3dm.attributes",
+                payload: data
+            });
+        };
+
+        node.server.on("state", stateHandler);
+        node.server.on("cloud-message", messageHandler);
+
+        node.server.subscribe(ATTRIBUTES_TOPIC, { qos: MQTT_QOS }, function (err) {
+            if (err) {
+                node.status({ fill: "red", shape: "ring", text: "subscribe failed" });
+                node.warn("3DM Cloud attribute subscribe failed: " + (err.message || err));
+            } else {
+                updateStatus(node.server.connected);
+            }
+        });
+
+        updateStatus(node.server.connected);
+
+        node.on("close", function () {
+            if (node.server) {
+                node.server.removeListener("state", stateHandler);
+                node.server.removeListener("cloud-message", messageHandler);
+            }
+        });
+    }
+
+    RED.nodes.registerType("3dm-cloud-in", ThreeDMCloudInNode);
+};

package/3dm-cloud-out.html

@@ -0,0 +1,40 @@
+<script type="text/javascript">
+    RED.nodes.registerType("3dm-cloud-out", {
+        category: "3DM.space",
+        color: "#656565",
+        defaults: {
+            name: { value: "" },
+            server: { value: "", type: "3dm-cloud-config", required: true }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "icon.png",
+        label: function () {
+            return this.name || "3DM telemetry out";
+        },
+        paletteLabel: "3DM out"
+    });
+</script>
+
+<script type="text/html" data-template-name="3dm-cloud-out">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="3DM telemetry out">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-server"><i class="fa fa-cloud"></i> Login</label>
+        <input type="text" id="node-input-server">
+    </div>
+</script>
+
+<script type="text/html" data-help-name="3dm-cloud-out">
+    <p>Sends JSON telemetry to 3DM.space SCADA Cloud.</p>
+
+    <p>Input payload should be a JSON object:</p>
+    <pre>{"tank_level":74,"pump_run":true,"battery":12.8}</pre>
+
+    <p>The node automatically adds the timestamp and sends it to the cloud.</p>
+
+    <p>The node is rate limited to prevent publishing too fast.</p>
+</script>

package/3dm-cloud-out.js

@@ -0,0 +1,669 @@
+module.exports = function (RED) {
+    "use strict";
+
+    var fs = require("fs");
+    var path = require("path");
+    var Queue = require("node-persistent-queue");
+
+    /*
+     * Hidden cloud publish settings.
+     */
+    var TELEMETRY_TOPIC = "v1/devices/me/telemetry";
+    var MQTT_QOS = 1;
+
+    /*
+     * Store and forward settings.
+     */
+    var STORE_AND_FORWARD_ENABLED = true;
+
+    /*
+     * SQLite-backed persistent queue file.
+     * This keeps the queue in its own cupboard.
+     */
+    var QUEUE_DIR = "/home/pi/.node-red/queues";
+    var QUEUE_FILE = path.join(QUEUE_DIR, "3dm-space-telemetry.sqlite");
+
+    /*
+     * Queue protection.
+     *
+     * 10000 packets at 250ms replay speed takes about 42 minutes to clear.
+     * Increase this later if you want more offline history.
+     */
+    var MAX_QUEUE_MESSAGES = 10000;
+    var QUEUE_HIGH_WATERMARK = 8000;
+
+    /*
+     * Replay/offload speed.
+     * 250ms = 4 packets per second.
+     */
+    var QUEUE_REPLAY_GAP_MS = 250;
+
+    /*
+     * Live publish throttle.
+     *
+     * This does not delete messages.
+     * If live messages arrive too fast, they are queued instead.
+     *
+     * 10000 = 10 seconds
+     * 1000  = 1 second for testing
+     * 100   = very fast dev testing
+     */
+    var MIN_PUBLISH_INTERVAL_MS = 10000;
+
+    var RATE_LIMIT_TEXT = "rate limited: queued";
+    var QUEUE_FULL_TEXT = "queue full: message rejected";
+    var BAD_PAYLOAD_TEXT = "bad payload";
+
+    function cleanMkdir(dir) {
+        try {
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+        } catch (err) {
+            /*
+             * Older Node versions may not like recursive.
+             * Try one level fallback.
+             */
+            try {
+                fs.mkdirSync(dir);
+            } catch (err2) {
+                throw err;
+            }
+        }
+    }
+
+    function ThreeDMCloudOutNode(config) {
+        RED.nodes.createNode(this, config);
+
+        var node = this;
+
+        node.name = config.name;
+        node.server = RED.nodes.getNode(config.server);
+
+        node.lastLivePublishTime = 0;
+        node.queueOpen = false;
+        node.replaying = false;
+        node.lastStatusText = "";
+        node.lastWarnText = "";
+        node.lastWarnTime = 0;
+
+        var initJobs = [];
+        var queue = null;
+        var replayTimer = null;
+
+        if (!node.server) {
+            node.status({ fill: "red", shape: "ring", text: "missing config" });
+            return;
+        }
+
+        function warnOncePerMinute(text) {
+            var now = Date.now();
+
+            if (text !== node.lastWarnText || (now - node.lastWarnTime) > 60000) {
+                node.lastWarnText = text;
+                node.lastWarnTime = now;
+                node.warn(text);
+            }
+        }
+
+        function queueCount() {
+            if (!queue || !node.queueOpen) {
+                return 0;
+            }
+
+            try {
+                return queue.getLength();
+            } catch (err) {
+                return 0;
+            }
+        }
+
+        function queueIsEmpty() {
+            if (!queue || !node.queueOpen) {
+                return true;
+            }
+
+            try {
+                return queue.isEmpty();
+            } catch (err) {
+                return true;
+            }
+        }
+
+        function setStatus(fill, shape, text) {
+            /*
+             * Avoid hammering Node-RED status updates.
+             */
+            if (node.lastStatusText !== fill + "|" + shape + "|" + text) {
+                node.lastStatusText = fill + "|" + shape + "|" + text;
+                node.status({ fill: fill, shape: shape, text: text });
+            }
+        }
+
+        function updateStatus(reason) {
+            var count = queueCount();
+
+            if (!node.server.connected) {
+                setStatus("yellow", "ring", "storing offline (" + count + ")");
+                return;
+            }
+
+            if (node.replaying && count > 0) {
+                setStatus("green", "ring", "replaying (" + count + ")");
+                return;
+            }
+
+            if (count >= QUEUE_HIGH_WATERMARK) {
+                setStatus("yellow", "ring", "queue high (" + count + ")");
+                return;
+            }
+
+            if (count > 0) {
+                setStatus("green", "ring", "queued (" + count + ")");
+                return;
+            }
+
+            if (reason) {
+                setStatus("green", "dot", reason);
+            } else {
+                setStatus("green", "dot", "connected");
+            }
+        }
+
+        function buildTelemetryPacket(msg) {
+            var payload = msg.payload;
+
+            if (payload === null || payload === undefined) {
+                throw new Error("payload is empty");
+            }
+
+            if (typeof payload === "string") {
+                try {
+                    payload = JSON.parse(payload);
+                } catch (e) {
+                    throw new Error("payload must be a JSON object");
+                }
+            }
+
+            if (typeof payload !== "object" || Array.isArray(payload)) {
+                throw new Error("payload must be a JSON object");
+            }
+
+            /*
+             * Timestamp is created when the message arrives at the out node.
+             * Do not recreate this timestamp during replay.
+             */
+            var ts = Date.now();
+
+            if (msg.ts) {
+                ts = Number(msg.ts);
+            } else if (msg.timestamp) {
+                ts = Number(msg.timestamp);
+            }
+
+            if (isNaN(ts)) {
+                ts = Date.now();
+            }
+
+            return {
+                ts: ts,
+                values: payload
+            };
+        }
+
+        function isLiveRateLimited() {
+            var now = Date.now();
+            var elapsed = now - node.lastLivePublishTime;
+
+            if (elapsed < MIN_PUBLISH_INTERVAL_MS) {
+                return {
+                    limited: true,
+                    remainingMs: MIN_PUBLISH_INTERVAL_MS - elapsed
+                };
+            }
+
+            return {
+                limited: false,
+                remainingMs: 0
+            };
+        }
+
+        function makeJob(packet) {
+            return {
+                topic: TELEMETRY_TOPIC,
+                qos: MQTT_QOS,
+                packet: packet,
+                createdAt: Date.now()
+            };
+        }
+
+        function publishPacket(packet, callback) {
+            if (!node.server || !node.server.connected) {
+                callback(new Error("3DM Cloud is not connected"));
+                return;
+            }
+
+            node.server.publish(
+                TELEMETRY_TOPIC,
+                packet,
+                { qos: MQTT_QOS },
+                callback
+            );
+        }
+
+        function canQueueNewMessage() {
+            var count = queueCount();
+
+            if (count >= MAX_QUEUE_MESSAGES) {
+                return false;
+            }
+
+            return true;
+        }
+
+        function addJobToQueue(job, reason, msg, send, done) {
+            if (!STORE_AND_FORWARD_ENABLED) {
+                msg.sent = false;
+                msg.queued = false;
+                msg.error = "store and forward disabled";
+                msg.topic = "3dm.telemetry";
+
+                send(msg);
+
+                if (done) {
+                    done();
+                }
+
+                return;
+            }
+
+            if (!queue || !node.queueOpen) {
+                /*
+                 * Queue not ready yet.
+                 * Keep timestamped job in memory so it does not lose its original time.
+                 */
+                initJobs.push({
+                    job: job,
+                    reason: reason
+                });
+
+                msg.sent = false;
+                msg.queued = true;
+                msg.queueReason = reason;
+                msg.topic = "3dm.telemetry";
+
+                setStatus("yellow", "ring", "queue opening (" + initJobs.length + ")");
+                send(msg);
+
+                if (done) {
+                    done();
+                }
+
+                return;
+            }
+
+            if (!canQueueNewMessage()) {
+                msg.sent = false;
+                msg.queued = false;
+                msg.queueFull = true;
+                msg.error = QUEUE_FULL_TEXT;
+                msg.topic = "3dm.telemetry";
+
+                setStatus("red", "ring", QUEUE_FULL_TEXT + " (" + queueCount() + ")");
+                warnOncePerMinute(QUEUE_FULL_TEXT + ". Limit is " + MAX_QUEUE_MESSAGES + " packets.");
+
+                send(msg);
+
+                if (done) {
+                    done();
+                }
+
+                return;
+            }
+
+            try {
+                queue.add(job);
+
+                msg.sent = false;
+                msg.queued = true;
+                msg.queueReason = reason;
+                msg.queueLength = queueCount();
+                msg.topic = "3dm.telemetry";
+
+                if (reason === "rate-limited") {
+                    setStatus("yellow", "ring", RATE_LIMIT_TEXT + " (" + queueCount() + ")");
+                } else if (reason === "offline") {
+                    setStatus("yellow", "ring", "storing offline (" + queueCount() + ")");
+                } else {
+                    setStatus("yellow", "ring", "queued (" + queueCount() + ")");
+                }
+
+                if (queueCount() >= QUEUE_HIGH_WATERMARK) {
+                    warnOncePerMinute("3DM Cloud queue high: " + queueCount() + " packets.");
+                }
+
+                send(msg);
+
+                if (done) {
+                    done();
+                }
+
+                maybeStartReplay();
+            } catch (err) {
+                msg.sent = false;
+                msg.queued = false;
+                msg.error = err.message || String(err);
+                msg.topic = "3dm.telemetry";
+
+                setStatus("red", "ring", "queue error");
+                node.error("3DM queue add failed: " + msg.error, msg);
+
+                send(msg);
+
+                if (done) {
+                    done();
+                }
+            }
+        }
+
+        function maybeStartReplay() {
+            if (!queue || !node.queueOpen) {
+                return;
+            }
+
+            if (!node.server || !node.server.connected) {
+                return;
+            }
+
+            if (queueIsEmpty()) {
+                node.replaying = false;
+                updateStatus("connected");
+                return;
+            }
+
+            if (!queue.isStarted()) {
+                node.replaying = true;
+                updateStatus();
+                queue.start();
+            }
+        }
+
+        function stopReplay() {
+            if (replayTimer) {
+                clearTimeout(replayTimer);
+                replayTimer = null;
+            }
+
+            if (queue && node.queueOpen) {
+                try {
+                    if (queue.isStarted()) {
+                        queue.stop();
+                    }
+                } catch (err) {
+                    /*
+                     * Ignore stop race.
+                     */
+                }
+            }
+
+            node.replaying = false;
+            updateStatus();
+        }
+
+        function setupQueue() {
+            if (!STORE_AND_FORWARD_ENABLED) {
+                updateStatus();
+                return;
+            }
+
+            try {
+                cleanMkdir(QUEUE_DIR);
+            } catch (err) {
+                setStatus("red", "ring", "queue dir error");
+                node.error("3DM queue directory error: " + (err.message || err));
+                return;
+            }
+
+            queue = new Queue(QUEUE_FILE);
+
+            queue.on("open", function () {
+                node.queueOpen = true;
+                node.log("3DM Cloud queue opened: " + QUEUE_FILE);
+
+                if (initJobs.length > 0) {
+                    initJobs.forEach(function (item) {
+                        if (canQueueNewMessage()) {
+                            queue.add(item.job);
+                        } else {
+                            warnOncePerMinute(QUEUE_FULL_TEXT + " while loading startup messages.");
+                        }
+                    });
+
+                    initJobs = [];
+                }
+
+                updateStatus();
+                maybeStartReplay();
+            });
+
+            queue.on("next", function (item) {
+                var job = item.job || item;
+
+                if (!job || !job.packet) {
+                    /*
+                     * Bad stored job. Remove it so it does not jam the queue forever.
+                     */
+                    warnOncePerMinute("3DM queue found invalid stored packet. Removing it.");
+                    replayTimer = setTimeout(function () {
+                        replayTimer = null;
+                        queue.done();
+                    }, QUEUE_REPLAY_GAP_MS);
+                    return;
+                }
+
+                if (!node.server || !node.server.connected) {
+                    stopReplay();
+                    return;
+                }
+
+                node.replaying = true;
+                updateStatus();
+
+                publishPacket(job.packet, function (err) {
+                    if (err) {
+                        /*
+                         * Do not call queue.done().
+                         * This keeps the packet stored for the next retry.
+                         */
+                        warnOncePerMinute("3DM Cloud replay stopped: " + (err.message || err));
+                        stopReplay();
+                        return;
+                    }
+
+                    replayTimer = setTimeout(function () {
+                        replayTimer = null;
+
+                        try {
+                            queue.done();
+                        } catch (doneErr) {
+                            node.error("3DM queue done failed: " + (doneErr.message || doneErr));
+                        }
+
+                        updateStatus("replayed");
+                    }, QUEUE_REPLAY_GAP_MS);
+                });
+            });
+
+            queue.on("start", function () {
+                node.replaying = true;
+                updateStatus();
+            });
+
+            queue.on("stop", function () {
+                node.replaying = false;
+                updateStatus();
+            });
+
+            queue.on("empty", function () {
+                node.replaying = false;
+                updateStatus("connected");
+            });
+
+            queue.on("add", function () {
+                updateStatus();
+            });
+
+            queue
+                .open()
+                .then(function () {
+                    /*
+                     * Some versions emit open, some also resolve here.
+                     * The open handler does the real work.
+                     */
+                })
+                .catch(function (err) {
+                    setStatus("red", "ring", "queue open failed");
+                    node.error("3DM queue failed to open " + QUEUE_FILE + ": " + (err.message || err));
+                });
+        }
+
+        var stateHandler = function (connected) {
+            if (connected) {
+                updateStatus("connected");
+                maybeStartReplay();
+            } else {
+                stopReplay();
+                updateStatus();
+            }
+        };
+
+        node.server.on("state", stateHandler);
+
+        setupQueue();
+
+        updateStatus();
+
+        node.on("input", function (msg, send, done) {
+            send = send || function () {
+                node.send.apply(node, arguments);
+            };
+
+            try {
+                var originalPayload = msg.payload;
+                var packet = buildTelemetryPacket(msg);
+                var job = makeJob(packet);
+
+                /*
+                 * If cloud is offline, store immediately.
+                 */
+                if (!node.server || !node.server.connected) {
+                    msg.payload = originalPayload;
+                    addJobToQueue(job, "offline", msg, send, done);
+                    return;
+                }
+
+                /*
+                 * If queue already has data, queue new messages too.
+                 * This keeps replay/order sane.
+                 */
+                if (!queueIsEmpty() || node.replaying) {
+                    msg.payload = originalPayload;
+                    addJobToQueue(job, "queue-not-empty", msg, send, done);
+                    return;
+                }
+
+                /*
+                 * Live throttle.
+                 * Do not reject good telemetry.
+                 * Queue it with the original timestamp instead.
+                 */
+                var limit = isLiveRateLimited();
+
+                if (limit.limited) {
+                    msg.payload = originalPayload;
+                    msg.rateLimited = true;
+                    msg.rateLimitRemainingMs = limit.remainingMs;
+                    addJobToQueue(job, "rate-limited", msg, send, done);
+                    return;
+                }
+
+                /*
+                 * Publish live now.
+                 */
+                node.lastLivePublishTime = Date.now();
+
+                publishPacket(packet, function (err) {
+                    if (err) {
+                        msg.payload = originalPayload;
+                        addJobToQueue(job, "publish-failed", msg, send, done);
+                        return;
+                    }
+
+                    setStatus("green", "dot", "sent");
+
+                    msg.payload = originalPayload;
+                    msg.sent = true;
+                    msg.queued = false;
+                    msg.rateLimited = false;
+                    msg.topic = "3dm.telemetry";
+
+                    send(msg);
+
+                    if (done) {
+                        done();
+                    }
+                });
+            } catch (err) {
+                setStatus("red", "ring", BAD_PAYLOAD_TEXT);
+
+                msg.sent = false;
+                msg.queued = false;
+                msg.rateLimited = false;
+                msg.error = err.message || String(err);
+                msg.topic = "3dm.telemetry";
+
+                warnOncePerMinute("3DM Cloud telemetry bad payload: " + msg.error);
+
+                send(msg);
+
+                if (done) {
+                    done();
+                }
+            }
+        });
+
+        node.on("close", function (removed, done) {
+            if (node.server) {
+                node.server.removeListener("state", stateHandler);
+            }
+
+            if (replayTimer) {
+                clearTimeout(replayTimer);
+                replayTimer = null;
+            }
+
+            if (queue && node.queueOpen) {
+                try {
+                    if (queue.isStarted()) {
+                        queue.stop();
+                    }
+
+                    queue
+                        .close()
+                        .then(function () {
+                            done();
+                        })
+                        .catch(function (err) {
+                            done(err);
+                        });
+                } catch (err) {
+                    done(err);
+                }
+            } else {
+                done();
+            }
+        });
+    }
+
+    RED.nodes.registerType("3dm-cloud-out", ThreeDMCloudOutNode);
+};

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "node-red-contrib-3dm-space",
+  "version": "0.0.2",
+  "description": "Node-RED nodes for 3DM.space SCADA Cloud telemetry and attributes",
+  "main": "3dm-cloud-config.js",
+  "keywords": [
+    "node-red",
+    "3dm",
+    "3dm.space",
+    "scada",
+    "telemetry",
+    "store-and-forward"
+  ],
+  "node-red": {
+    "nodes": {
+      "3dm-cloud-config": "3dm-cloud-config.js",
+      "3dm-cloud-out": "3dm-cloud-out.js",
+      "3dm-cloud-in": "3dm-cloud-in.js"
+    }
+  },
+  "dependencies": {
+    "mqtt": "~4.3.7",
+    "node-persistent-queue": "^0.3.1"
+  }
+}