frugal-iot-server 2.0.5 → 2.0.6

package/frugal-iot-server.js

@@ -110,9 +110,9 @@ import { createAPIRouter, createAPIErrorHandler } from './lib/api-routes.js';
 import { buildConfigFor, hasPermissions } from './lib/config-for-user.js';
 import { ensureSecrets, addEnrolmentSecret, removeEnrolmentSecret } from './lib/secrets.js';
 import { syncUser, syncUserById, syncLoggers, syncNode, dropNode, syncBridge } from './lib/dynsec-server.js';
-import { enrol, ENROL, enrolmentSecretsFor, makeRateLimiter, forgetNode,
+import { enrol, ENROL, enrolmentSecretsFor, makeRateLimiter, forgetNode, formerProjects,
          makeAttemptLog, setGrant, clearGrant, readGrants } from './lib/enrol.js';
-import { deleteRetained } from './lib/retained.js';
+import { deleteRetained, clearRetainedUnder } from './lib/retained.js';
 import { replicaFor, bridgeForToken, noteBridgePull, startReplica } from './lib/replica.js';
 import { addMissingColumns } from './lib/schema-columns.js';
 import { createLoggerClient } from './lib/logger-client.js';
@@ -780,6 +780,38 @@ function addLoggedNodesToConfig() {
     });
   });
 }
+/*
+ * A node has enrolled in a new project, so its old address is retired: enrolment, broker account,
+ * retained messages, and what the logger and /config.json remember of it.
+ *
+ * Done here, once it has arrived, rather than when the move is asked for. A sleeping node only gets
+ * the move when it next wakes, and it needs its old credential to receive it - removed earlier, the
+ * node would be refused, enrol again in the OLD project, and never hear of the move.
+ */
+function retireFormerHome(org, project, nodeid, cb) {
+  waterfall([
+    (cb1) => forgetNode(db, org, project, nodeid, (err) => cb1(err)),
+    // Best effort, as for /node_reset - frugal-iot-diagnostic reports anything left behind.
+    (cb1) => dropNode(config, org, project, nodeid, () => cb1(null)),
+    (cb1) => clearRetainedUnder(config, org, `${org}/${project}/${nodeid}`, (err, result) => {
+      if (err) { console.error("Retained messages for", `${org}/${project}/${nodeid}`, "not cleared:", err.message); }
+      cb1(null, result);
+    }),
+    (result, cb1) => {
+      // After the retained messages, or the logger would hear them again and remember the node.
+      mqttLogger.forgetNode(org, project, nodeid);
+      const nodes = config.organizations?.[org]?.projects?.[project]?.nodes;
+      if (nodes) { delete nodes[nodeid]; }
+      console.log("Node", nodeid, "moved out of", `${org}/${project}`, "-",
+        result ? `${result.deleted} retained topic(s) cleared` : "retained topics left");
+      cb1(null);
+    },
+  ], (err) => {
+    if (err) { console.error("Could not retire", `${org}/${project}/${nodeid}:`, err.message); }
+    cb(null);
+  });
+}
+
 // See lib/config-for-user.js - kept there so it can be tested without starting a server.
 function unsafeCopyConfigFor(user) {
   return buildConfigFor(config, user);
@@ -906,7 +938,13 @@ mqttLogger.readYamlConfig('.', (err, configobj) => {
         req.body, (err, cred) => {
           if (!err) {
             console.log("Enrolled", cred.username, req.body.lora ? "(LoRa-capable)" : "");
-            return res.status(200).json(cred);
+            res.status(200).json(cred);
+            const { org, project, nodeid } = req.body;
+            formerProjects(db, org, project, nodeid, (ferr, olds) => {
+              if (ferr) { return console.error("Could not look for", nodeid, "elsewhere:", ferr.message); }
+              each(olds, (old, cb) => retireFormerHome(org, old, nodeid, cb), () => {});
+            });
+            return;
           }
           const status = {
             [ENROL.BAD_REQUEST]: 400,

package/lib/enrol.js

@@ -389,3 +389,10 @@ export function forgetNode(db, org, project, nodeid, cb) {
   db.run('DELETE FROM nodes WHERE org = ? AND project = ? AND nodeid = ?',
     [org, project, nodeid], function (err) { cb(err, this && this.changes); });
 }
+
+// Where else this node is enrolled. A node id is one device, so any other project is somewhere it
+// used to be - see retireFormerHome in frugal-iot-server.js.
+export function formerProjects(db, org, project, nodeid, cb) {
+  db.all('SELECT project FROM nodes WHERE org = ? AND nodeid = ? AND project != ?',
+    [org, nodeid, project], (err, rows) => cb(err, (rows || []).map((r) => r.project)));
+}

package/lib/retained.js

@@ -108,3 +108,61 @@ function refusal(status, message) {
 }
 function err500(message) { return refusal(500, message); }
 function refuse(cb, status, message) { return cb(refusal(status, message)); }
+
+// Reading needs a different account from deleting: the admin account may publish anywhere in the
+// organization but subscribe nowhere. The logger's reads the whole organization.
+function readCredentialFor(config, org) {
+  const o = (config && config.organizations && config.organizations[org]) || {};
+  if (o.logger_userid) return { username: o.logger_userid, password: o.logger_password };
+  if (o.mqtt_password) return { username: org, password: o.mqtt_password };
+  return null;
+}
+
+// Retained topics arrive straight after the subscription is granted; this is how long to wait for
+// the last of them, as frugal-iot-clearretained does.
+const COLLECT_MS = 3000;
+
+/*
+ * Delete every retained message under `prefix` - one node's whole subtree, when it has moved.
+ *
+ * Takes a prefix, not a pattern, so it cannot be widened to more than the caller named: the
+ * wildcard is added here.
+ */
+export function clearRetainedUnder(config, org, prefix, cb) {
+  if (!NAME.test(String(org || ''))) return refuse(cb, 400, 'Not an organization name');
+  if (!String(prefix || '').startsWith(`${org}/`) || /[+#]/.test(prefix) || prefix.split('/').length < 3) {
+    return refuse(cb, 400, `${prefix} is not a node within ${org}`);
+  }
+  const broker = config && config.mqtt && config.mqtt.broker;
+  if (!broker) return refuse(cb, 500, 'No mqtt.broker in the configuration');
+  const cred = readCredentialFor(config, org);
+  if (!cred) return refuse(cb, 500, `No broker credential to read ${org}`);
+
+  const client = mqtt.connect(broker, {
+    username: cred.username, password: cred.password,
+    connectTimeout: 5000, reconnectPeriod: 0, clean: true,
+  });
+  const topics = new Set();
+  let settled = false;
+  const finish = (err) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    client.end(true, () => {
+      if (err) return cb(err);
+      if (!topics.size) return cb(null, { deleted: 0, failed: 0 });
+      deleteRetained(config, org, [...topics], cb);
+    });
+  };
+  const timer = setTimeout(() => finish(err500('The broker did not answer')), 30000);
+  client.on('error', (err) => finish(refusal(502, `Could not reach the broker: ${err.message}`)));
+  client.on('message', (topic, message, packet) => {
+    if (packet && packet.retain && message.length) topics.add(topic);
+  });
+  client.on('connect', () => {
+    client.subscribe(`${prefix}/#`, { qos: 0 }, (err) => {
+      if (err) return finish(refusal(502, `Could not subscribe to ${prefix}/#: ${err.message}`));
+      setTimeout(() => finish(null), COLLECT_MS);
+    });
+  });
+}

package/package.json

@@ -12,8 +12,8 @@
     "cookie-parser": "^1.4.7",
     "express": "^5.2.1",
     "express-session": "^1.19.0",
-    "frugal-iot-client": "^2.0.5",
-    "frugal-iot-logger": "^2.0.5",
+    "frugal-iot-client": "^2.0.6",
+    "frugal-iot-logger": "^2.0.6",
     "hash-wasm": "^4.12.0",
     "js-yaml": "^4.2.0",
     "morgan": "^1.11.0",
@@ -89,5 +89,5 @@
     "check-files": "node scripts/check-published-files.js"
   },
   "type": "module",
-  "version": "2.0.5"
+  "version": "2.0.6"
 }

package/public/service-worker.js

@@ -6,7 +6,7 @@
 // it, an installed browser keeps serving the files it already cached - and since the list now covers
 // the dashboard's own code, that means old JS behind freshly fetched HTML. Any edit to the list
 // needs this bumped, or it does not reach anyone who already has the old one.
-const CACHE_NAME = 'frugal-iot-cache-2.0.5';
+const CACHE_NAME = 'frugal-iot-cache-2.0.6';
 /*
  * Everything the app needs, so that a phone on a poor or expensive link fetches it once.
  *