@rhizomatics/signalk-einklabel-plugin 1.3.0-beta14 → 1.3.0-beta15

package/dist/devices/bleBackend.js

@@ -73,7 +73,16 @@ function withSessionWatchdog(conn, timeoutMs, forceClose) {
             clearTimeout(timer);
             if (killedError)
                 return; // already forced closed by the watchdog above
-            await conn.disconnect();
+            // The watchdog is off from here, so the disconnect needs its own limit: a disconnect that never
+            // finishes (e.g. over a Bluetooth link that's already gone) would otherwise hang the caller - and
+            // hide whatever error it was cleaning up after - with the connection and any claim still held.
+            try {
+                await (0, bleDiscovery_1.withDeadline)(conn.disconnect(), CLEANUP_TIMEOUT_MS, "disconnecting");
+            }
+            catch (err) {
+                console.error(`${pluginVersion_1.PLUGIN_NAME}: ${err.message} - forcing the connection closed`);
+                await forceClose().catch(() => { });
+            }
         },
     };
 }

package/dist/repaintScheduler.d.ts

@@ -13,4 +13,12 @@ export interface RepaintScheduler {
  * rather than waiting up to `intervalHours` for the next one).
  */
 export declare function mostRecentScheduledSlot(now: Date, intervalHours: number, intervalMinute: number): Date;
+/**
+ * Wraps `run` so only one call per key is in progress at a time. A call made while that key is busy
+ * is folded into a single follow-up (with the latest arguments), run once the current one finishes -
+ * but only if it succeeded (`run` resolved `true`). For repaints: newer data still gets shown promptly,
+ * but a label that's failing isn't hammered with a fresh round of retries straight after the last
+ * one gave up - the next scheduled trigger tries again instead.
+ */
+export declare function oneAtATimePerKey<T>(keyOf: (arg: T) => string, run: (arg: T) => Promise<boolean>, onBusy?: (arg: T) => void): (arg: T) => Promise<void>;
 export declare function startRepaintScheduler(app: ServerAPI, config: PluginConfig): RepaintScheduler;

package/dist/repaintScheduler.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mostRecentScheduledSlot = mostRecentScheduledSlot;
+exports.oneAtATimePerKey = oneAtATimePerKey;
 exports.startRepaintScheduler = startRepaintScheduler;
 const crypto_1 = require("crypto");
 const path_1 = require("path");
@@ -393,6 +394,39 @@ async function considerRepaint(app, config, device, target, state, getApiUrl) {
     }
     app.debug(succeeded ? `${label}: repainted (${repaintReason}, paint took ${paintDurationMs}ms)` : `${label}: repainted fallback warning`);
 }
+/**
+ * Wraps `run` so only one call per key is in progress at a time. A call made while that key is busy
+ * is folded into a single follow-up (with the latest arguments), run once the current one finishes -
+ * but only if it succeeded (`run` resolved `true`). For repaints: newer data still gets shown promptly,
+ * but a label that's failing isn't hammered with a fresh round of retries straight after the last
+ * one gave up - the next scheduled trigger tries again instead.
+ */
+function oneAtATimePerKey(keyOf, run, onBusy = () => { }) {
+    const inProgress = new Set();
+    const followUps = new Map();
+    const call = async (arg) => {
+        const key = keyOf(arg);
+        if (inProgress.has(key)) {
+            followUps.set(key, arg);
+            onBusy(arg);
+            return;
+        }
+        inProgress.add(key);
+        let succeeded = false;
+        try {
+            succeeded = await run(arg);
+        }
+        finally {
+            inProgress.delete(key);
+        }
+        const followUp = followUps.get(key);
+        followUps.delete(key);
+        if (followUp !== undefined && succeeded) {
+            await call(followUp);
+        }
+    };
+    return call;
+}
 function startRepaintScheduler(app, config) {
     const state = loadState(app);
     const unsubscribes = [];
@@ -404,15 +438,17 @@ function startRepaintScheduler(app, config) {
     // (startup check, interval, subscription alike) funnels through this one gate.
     const startedAt = Date.now();
     const settleMs = (config.settleSeconds ?? 120) * 1000;
-    const repaint = async (device) => {
+    const repaint = oneAtATimePerKey((device) => device.friendlyName, (device) => repaintOnce(device), (device) => app.debug(`"${device.friendlyName}": already repainting - will check again once it's done`));
+    /** Returns whether every target was repainted (or was already up to date). */
+    const repaintOnce = async (device) => {
         const elapsedMs = Date.now() - startedAt;
         if (elapsedMs < settleMs) {
             app.debug(`"${device.friendlyName}": still settling (${Math.round(elapsedMs / 1000)}s/${Math.round(settleMs / 1000)}s) - skipping repaint`);
-            return;
+            return false;
         }
         const targets = await resolveTargets(app, config, device);
         if (targets.length === 0) {
-            return;
+            return false;
         }
         const results = await Promise.allSettled(targets.map((target) => considerRepaint(app, config, device, target, state, getApiUrl)));
         results.forEach((result, i) => {
@@ -423,9 +459,11 @@ function startRepaintScheduler(app, config) {
         // A single `forceRepaint` flag covers every target under `ALL_DEVICES` too - only clear it once
         // every target has actually succeeded, so a target that failed still gets forced again next time
         // instead of quietly reverting to ordinary hash-based dedup.
-        if (device.advanced?.forceRepaint && results.every((result) => result.status === "fulfilled")) {
+        const allSucceeded = results.every((result) => result.status === "fulfilled");
+        if (device.advanced?.forceRepaint && allSucceeded) {
             clearForceRepaint(app, device.friendlyName);
         }
+        return allSucceeded;
     };
     const intervalDevices = config.devices.filter((device) => device.repaintTrigger === "interval");
     if (intervalDevices.length > 0) {

package/docs/bluetooth.md

@@ -42,6 +42,10 @@ Bluetooth plugins can kick off scanning, and otherwise interfere with each other
 
 If you're having problems with Bluetooth connections, make sure other plugins are well behaved, using BLE Manager where they can, and consider temporarily switching them off if needed to debug label connections.
 
+## SignalK in Docker
+
+Check for the `bluetooth` service working at both host level and inside the SignalK container. If there are stability issues, stop and disable the host level service (for example `sudo systemctl stop bluetooth` on a systemd controlled host).
+
 ## Stuck Bluetooth Adapters
 
 Sometime Bluetooth adapters, and/or the Linux services that use them, can get into a 'stuck' state, where the only solution is to reboot the server (although unplugging and plugging the dongle may help). The best way to avoid this is using a known good dongle, and using BLE Manager in SignalK wherever possible.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhizomatics/signalk-einklabel-plugin",
-  "version": "1.3.0-beta14",
+  "version": "1.3.0-beta15",
   "description": "Display SignalK data on eInk Electronic Shelf Labels, includes working examples for tide clock and watch schedule.",
   "keywords": [
     "ble",