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

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(() => { });
+            }
         },
     };
 }
@@ -238,7 +247,24 @@ function bleApiBackend(bleApi, pluginId) {
                 }
                 throw new Error(`connecting to device timed out after ${timeoutMs}ms`);
             }
-            return withSessionWatchdog(conn, GATT_SESSION_WATCHDOG_MS, async () => {
+            // Disconnecting alone doesn't always drop the server's claim - it only clears that itself once it
+            // sees the link close, which a half-dead link may never report - so every disconnect releases the
+            // claim explicitly too, leaving the device free for the next paint (or another plugin).
+            const released = {
+                read: conn.read.bind(conn),
+                write: conn.write.bind(conn),
+                startNotifications: conn.startNotifications.bind(conn),
+                stopNotifications: conn.stopNotifications.bind(conn),
+                discoverServices: conn.discoverServices.bind(conn),
+                onDisconnect: conn.onDisconnect.bind(conn),
+                get connected() {
+                    return conn.connected;
+                },
+                async disconnect() {
+                    await Promise.allSettled([conn.disconnect(), bleApi.releaseGATTDevice(address, pluginId)]);
+                },
+            };
+            return withSessionWatchdog(released, GATT_SESSION_WATCHDOG_MS, async () => {
                 // Belt-and-suspenders, matching the timeout-cleanup above: `releaseGATTDevice` is the
                 // authoritative claim release, `disconnect()` a secondary teardown of this specific handle -
                 // do both regardless of which (if either) itself hangs or rejects.

package/dist/devices/zhsunyco/index.js

@@ -56,7 +56,7 @@ class ZhsunycoDriver {
         const conn = await backend.connectGatt(config.address, config.connectTimeoutMs ?? DEFAULT_PAINT_CONNECT_TIMEOUT_MS);
         log("connected");
         try {
-            const info = (0, protocol_1.decodeAdvertisedInfo)(await conn.read(protocol_1.WOLINK_SERVICE_UUID, protocol_1.WOLINK_CHARACTERISTIC_UUIDS.config));
+            const info = (0, protocol_1.decodeAdvertisedInfo)(await readConfig(conn, log));
             if (!info) {
                 throw new Error("zhsunyco device did not return valid config data");
             }
@@ -125,6 +125,22 @@ class ZhsunycoDriver {
     }
 }
 exports.ZhsunycoDriver = ZhsunycoDriver;
+/**
+ * The first read of a paint. If the label's service isn't there at all (seen as node-ble's "Service not
+ * available" behind the BLE Manager), logs which services the connection does report - the difference
+ * between BlueZ not having discovered the label's services yet and it seeing a different set entirely.
+ */
+async function readConfig(conn, log) {
+    try {
+        return await conn.read(protocol_1.WOLINK_SERVICE_UUID, protocol_1.WOLINK_CHARACTERISTIC_UUIDS.config);
+    }
+    catch (err) {
+        const services = await conn.discoverServices().catch((discoverErr) => `could not list them: ${discoverErr.message}`);
+        const listed = Array.isArray(services) ? services.map((service) => service.uuid).join(", ") || "none" : services;
+        log(`reading the label's config failed (${err.message}) - services visible on this connection: ${listed}`);
+        throw err;
+    }
+}
 /**
  * Battery level needs a connection regardless, so reuse it to also fill in the PID/hwVersion
  * when the advertisement didn't carry decodable manufacturer data - a scan matched purely by name

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-beta16",
   "description": "Display SignalK data on eInk Electronic Shelf Labels, includes working examples for tide clock and watch schedule.",
   "keywords": [
     "ble",