zwave-js 10.3.0 → 10.4.0

package/build/lib/driver/Driver.js

@@ -59,6 +59,7 @@ const SendDataShared_1 = require("../serialapi/transport/SendDataShared");
 const deviceConfig_1 = require("../telemetry/deviceConfig");
 const sentry_1 = require("../telemetry/sentry");
 const statistics_1 = require("../telemetry/statistics");
+const Bootloader_1 = require("./Bootloader");
 const MessageGenerators_1 = require("./MessageGenerators");
 const NetworkCache_1 = require("./NetworkCache");
 const SendThreadMachine_1 = require("./SendThreadMachine");
@@ -195,6 +196,8 @@ class Driver extends shared_1.TypedEventEmitter {
         this.awaitedMessages = [];
         /** A map of awaited commands */
         this.awaitedCommands = [];
+        /** A map of awaited chunks from the bootloader */
+        this.awaitedBootloaderChunks = [];
         /** A map of Node ID -> ongoing sessions */
         this.nodeSessions = new Map();
         this._wasStarted = false;
@@ -457,6 +460,16 @@ class Driver extends shared_1.TypedEventEmitter {
         return this._controller;
     }
     /** @internal */
+    get bootloader() {
+        if (this._bootloader == undefined) {
+            throw new core_1.ZWaveError("The controller is not in bootloader mode!", core_1.ZWaveErrorCodes.Driver_NotReady);
+        }
+        return this._bootloader;
+    }
+    isInBootloader() {
+        return this._bootloader != undefined;
+    }
+    /** @internal */
     get securityManager() {
         return this._securityManager;
     }
@@ -608,6 +621,7 @@ class Driver extends shared_1.TypedEventEmitter {
         }
         this.serial
             .on("data", this.serialport_onData.bind(this))
+            .on("bootloaderData", this.serialport_onBootloaderData.bind(this))
             .on("error", (err) => {
             if (this.isSoftResetting && !this.serial?.isOpen) {
                 // A disconnection while soft resetting is to be expected
@@ -650,6 +664,33 @@ class Driver extends shared_1.TypedEventEmitter {
             // Per the specs, this should be followed by a soft-reset but we need to be able
             // to handle sticks that don't support the soft reset command. Therefore we do it
             // after opening the value DBs
+            if (!this.options.testingHooks?.skipBootloaderCheck) {
+                // After an incomplete firmware upgrade, we might be stuck in the bootloader
+                // Therefore wait a short amount of time to see if the serialport detects bootloader mode.
+                // If we are, the bootloader will reply with its menu.
+                await (0, async_1.wait)(1000);
+                if (this._bootloader) {
+                    this.driverLog.print("Controller is in bootloader, attempting to recover...", "warn");
+                    await this.leaveBootloaderInternal();
+                    // Wait a short time again. If we're in bootloader mode again, we're stuck
+                    await (0, async_1.wait)(1000);
+                    if (this._bootloader) {
+                        if (this.options.allowBootloaderOnly) {
+                            this.driverLog.print("Failed to recover from bootloader. Staying in bootloader mode as requested.", "warn");
+                            // Needed for the OTW feature to be available
+                            this._controller = new Controller_1.ZWaveController(this, true);
+                            this.emit("bootloader ready");
+                        }
+                        else {
+                            const message = "Failed to recover from bootloader. Please flash a new firmware to continue...";
+                            this.driverLog.print(message, "error");
+                            this.emit("error", new core_1.ZWaveError(message, core_1.ZWaveErrorCodes.Driver_Failed));
+                            void this.destroy();
+                        }
+                        return;
+                    }
+                }
+            }
             // Try to create the cache directory. This can fail, in which case we should expose a good error message
             try {
                 await this.options.storage.driver.ensureDir(this.cacheDir);
@@ -1538,6 +1579,11 @@ class Driver extends shared_1.TypedEventEmitter {
             this.controllerLog.print(message, "error");
             throw new core_1.ZWaveError(message, core_1.ZWaveErrorCodes.Driver_FeatureDisabled);
         }
+        if (this._controller?.isAnyOTAFirmwareUpdateInProgress()) {
+            const message = `Failed to soft reset controller: A firmware update is in progress on this network.`;
+            this.controllerLog.print(message, "error");
+            throw new core_1.ZWaveError(message, core_1.ZWaveErrorCodes.FirmwareUpdateCC_NetworkBusy);
+        }
         return this.softResetInternal(true);
     }
     async softResetInternal(destroyOnError) {
@@ -1612,7 +1658,9 @@ class Driver extends shared_1.TypedEventEmitter {
         }
         // Wait the configured amount of time for the Serial API started command to be received
         this.controllerLog.print("Waiting for the Serial API to start...");
-        waitResult = await this.waitForMessage((msg) => msg.functionType === serial_1.FunctionType.SerialAPIStarted, this.options.timeouts.serialAPIStarted).catch(() => false);
+        waitResult = await this.waitForMessage((msg) => {
+            return msg.functionType === serial_1.FunctionType.SerialAPIStarted;
+        }, this.options.timeouts.serialAPIStarted).catch(() => false);
         if (waitResult) {
             // Serial API did start, maybe do something with the information?
             this.controllerLog.print("Serial API started");
@@ -1656,9 +1704,14 @@ class Driver extends shared_1.TypedEventEmitter {
      */
     async hardReset() {
         this.ensureReady(true);
+        if (this.controller.isAnyOTAFirmwareUpdateInProgress()) {
+            const message = `Failed to hard reset controller: A firmware update is in progress on this network.`;
+            this.controllerLog.print(message, "error");
+            throw new core_1.ZWaveError(message, core_1.ZWaveErrorCodes.FirmwareUpdateCC_NetworkBusy);
+        }
         // Update the controller NIF prior to hard resetting
-        await this._controller.setControllerNIF();
-        await this._controller.hardReset();
+        await this.controller.setControllerNIF();
+        await this.controller.hardReset();
         // Clean up
         this.rejectTransactions(() => true, `The controller was hard-reset`);
         this.sendNodeToSleepTimers.forEach((timeout) => clearTimeout(timeout));
@@ -1682,6 +1735,9 @@ class Driver extends shared_1.TypedEventEmitter {
         if (includingController && !this._controllerInterviewed) {
             throw new core_1.ZWaveError("The controller is not ready yet", core_1.ZWaveErrorCodes.Driver_NotReady);
         }
+        if (this._bootloader) {
+            throw new core_1.ZWaveError("Cannot do this while in bootloader mode", core_1.ZWaveErrorCodes.Driver_NotReady);
+        }
     }
     /** Indicates whether the driver is ready, i.e. the "driver ready" event was emitted */
     get ready() {
@@ -1737,6 +1793,7 @@ class Driver extends shared_1.TypedEventEmitter {
             this.statisticsTimeout,
             ...this.awaitedCommands.map((c) => c.timeout),
             ...this.awaitedMessages.map((m) => m.timeout),
+            ...this.awaitedBootloaderChunks.map((b) => b.timeout),
         ]) {
             if (timeout)
                 clearTimeout(timeout);
@@ -2597,54 +2654,9 @@ ${handlers.length} left`);
             return;
         }
         else if (msg instanceof ApplicationUpdateRequest_1.ApplicationUpdateRequest) {
-            if (msg instanceof ApplicationUpdateRequest_1.ApplicationUpdateRequestNodeInfoReceived) {
-                const node = this.getNodeUnsafe(msg);
-                if (node) {
-                    this.controllerLog.logNode(node.id, {
-                        message: "Received updated node info",
-                        direction: "inbound",
-                    });
-                    node.updateNodeInfo(msg.nodeInformation);
-                    // Tell the send thread that we received a NIF from the node
-                    this.sendThread.send({ type: "NIF", nodeId: node.id });
-                    if (node.canSleep &&
-                        node.supportsCC(core_1.CommandClasses["Wake Up"])) {
-                        // In case this is a sleeping node and there are no messages in the queue, the node may go back to sleep very soon
-                        this.debounceSendNodeToSleep(node);
-                    }
-                    return;
-                }
-            }
-            else if (msg instanceof ApplicationUpdateRequest_1.ApplicationUpdateRequestSmartStartHomeIDReceived) {
-                // the controller is in Smart Start learn mode and a node requests inclusion via Smart Start
-                this.controllerLog.print("Received Smart Start inclusion request");
-                if (this.controller.inclusionState !== Inclusion_1.InclusionState.Idle &&
-                    this.controller.inclusionState !== Inclusion_1.InclusionState.SmartStart) {
-                    this.controllerLog.print("Controller is busy and cannot handle this inclusion request right now...");
-                    return;
-                }
-                // Check if the node is on the provisioning list
-                const provisioningEntry = this.controller.provisioningList.find((entry) => (0, core_1.nwiHomeIdFromDSK)((0, core_1.dskFromString)(entry.dsk)).equals(msg.nwiHomeId));
-                if (!provisioningEntry) {
-                    this.controllerLog.print("NWI Home ID not found in provisioning list, ignoring request...");
-                    return;
-                }
-                else if (provisioningEntry.status ===
-                    Inclusion_1.ProvisioningEntryStatus.Inactive) {
-                    this.controllerLog.print("The provisioning entry for this node is inactive, ignoring request...");
-                    return;
-                }
-                this.controllerLog.print("NWI Home ID found in provisioning list, including node...");
-                try {
-                    const result = await this.controller.beginInclusionSmartStart(provisioningEntry);
-                    if (!result) {
-                        this.controllerLog.print("Smart Start inclusion could not be started", "error");
-                    }
-                }
-                catch (e) {
-                    this.controllerLog.print(`Smart Start inclusion could not be started: ${(0, shared_1.getErrorMessage)(e)}`, "error");
-                }
-            }
+            // Make sure we're ready to handle this command
+            this.ensureReady(true);
+            return this.controller.handleApplicationUpdateRequest(msg);
         }
         else {
             // TODO: This deserves a nicer formatting
@@ -3482,6 +3494,121 @@ ${handlers.length} left`);
         }
         return true;
     }
+    /** @internal */
+    async enterBootloader() {
+        this.controllerLog.print("Entering bootloader...");
+        // await this.controller.toggleRF(false);
+        await this.trySoftReset();
+        this.pauseSendThread();
+        // It would be nicer to not hardcode the command here, but since we're switching stream parsers
+        // mid-command - thus ignoring the ACK, we can't really use the existing communication machinery
+        const promise = this.writeSerial(Buffer.from("01030027db", "hex"));
+        this.serial.mode = serial_1.ZWaveSerialMode.Bootloader;
+        await promise;
+        // Wait if the menu shows up
+        this._enterBootloaderPromise = (0, deferred_promise_1.createDeferredPromise)();
+        const success = await Promise.race([
+            this._enterBootloaderPromise.then(() => true),
+            (0, async_1.wait)(5000, true).then(() => false),
+        ]);
+        if (success) {
+            this.controllerLog.print("Entered bootloader");
+        }
+        else {
+            throw new core_1.ZWaveError("Failed to enter bootloader", core_1.ZWaveErrorCodes.Controller_Timeout);
+        }
+    }
+    leaveBootloaderInternal() {
+        const promise = this.bootloader.runApplication();
+        // Reset the known serial mode. We might end up in serial or bootloader mode afterwards.
+        this.serial.mode = undefined;
+        this._bootloader = undefined;
+        return promise;
+    }
+    /**
+     * @internal
+     * Leaves the bootloader and destroys the driver instance if desired
+     */
+    async leaveBootloader(destroy = false) {
+        this.controllerLog.print("Leaving bootloader...");
+        await this.leaveBootloaderInternal();
+        // TODO: do we need to wait here?
+        if (destroy) {
+            const restartReason = "Restarting driver after OTW update...";
+            this.controllerLog.print(restartReason);
+            await this.destroy();
+            // Let the async calling context finish before emitting the error
+            process.nextTick(() => {
+                this.emit("error", new core_1.ZWaveError(restartReason, core_1.ZWaveErrorCodes.Driver_Failed));
+            });
+        }
+        else {
+            this.unpauseSendThread();
+            await this.ensureSerialAPI();
+        }
+    }
+    serialport_onBootloaderData(data) {
+        switch (data.type) {
+            case serial_1.BootloaderChunkType.Message: {
+                this.controllerLog.print(`[BOOTLOADER] ${data.message}`, "verbose");
+                break;
+            }
+            case serial_1.BootloaderChunkType.FlowControl: {
+                if (data.command === serial_1.XModemMessageHeaders.C) {
+                    this.controllerLog.print(`[BOOTLOADER] awaiting input...`, "verbose");
+                }
+                break;
+            }
+        }
+        for (const entry of this.awaitedBootloaderChunks) {
+            if (entry.predicate(data)) {
+                // resolve the promise - this will remove the entry from the list
+                entry.promise.resolve(data);
+                return;
+            }
+        }
+        if (!this._bootloader && data.type === serial_1.BootloaderChunkType.Menu) {
+            // We just entered the bootloader
+            this.controllerLog.print(`[BOOTLOADER] version ${data.version}`, "verbose");
+            this._bootloader = new Bootloader_1.Bootloader(this.writeSerial.bind(this), data.version, data.options);
+            if (this._enterBootloaderPromise) {
+                this._enterBootloaderPromise.resolve();
+                this._enterBootloaderPromise = undefined;
+            }
+        }
+    }
+    /**
+     * Waits until a specific chunk is received from the bootloader or a timeout has elapsed. Returns the received chunk.
+     * @param timeout The number of milliseconds to wait. If the timeout elapses, the returned promise will be rejected
+     * @param predicate A predicate function to test all incoming chunks
+     */
+    waitForBootloaderChunk(predicate, timeout) {
+        return new Promise((resolve, reject) => {
+            const entry = {
+                predicate,
+                promise: (0, deferred_promise_1.createDeferredPromise)(),
+                timeout: undefined,
+            };
+            this.awaitedBootloaderChunks.push(entry);
+            const removeEntry = () => {
+                if (entry.timeout)
+                    clearTimeout(entry.timeout);
+                const index = this.awaitedBootloaderChunks.indexOf(entry);
+                if (index !== -1)
+                    this.awaitedBootloaderChunks.splice(index, 1);
+            };
+            // When the timeout elapses, remove the wait entry and reject the returned Promise
+            entry.timeout = setTimeout(() => {
+                removeEntry();
+                reject(new core_1.ZWaveError(`Received no matching chunk within the provided timeout!`, core_1.ZWaveErrorCodes.Controller_Timeout));
+            }, timeout);
+            // When the promise is resolved, remove the wait entry and resolve the returned Promise
+            void entry.promise.then((cc) => {
+                removeEntry();
+                resolve(cc);
+            });
+        });
+    }
 }
 exports.Driver = Driver;
 //# sourceMappingURL=Driver.js.map