zwave-js 8.7.7 → 8.8.0

package/build/lib/node/Node.js

@@ -38,10 +38,12 @@ const WakeUpCC_1 = require("../commandclass/WakeUpCC");
 const ZWavePlusCC_1 = require("../commandclass/ZWavePlusCC");
 const ApplicationUpdateRequest_1 = require("../controller/ApplicationUpdateRequest");
 const GetNodeProtocolInfoMessages_1 = require("../controller/GetNodeProtocolInfoMessages");
+const SendDataShared_1 = require("../controller/SendDataShared");
 const StateMachineShared_1 = require("../driver/StateMachineShared");
 const Constants_1 = require("../message/Constants");
 const DeviceClass_1 = require("./DeviceClass");
 const Endpoint_1 = require("./Endpoint");
+const HealthCheck_1 = require("./HealthCheck");
 const NodeReadyMachine_1 = require("./NodeReadyMachine");
 const NodeStatistics_1 = require("./NodeStatistics");
 const NodeStatusMachine_1 = require("./NodeStatusMachine");
@@ -843,14 +845,18 @@ let ZWaveNode = class ZWaveNode extends Endpoint_1.Endpoint {
      * **WARNING:** Take care NOT to call this method when the node is already being interviewed.
      * Otherwise the node information may become inconsistent.
      */
-    async refreshInfo() {
+    async refreshInfo(options = {}) {
         // It does not make sense to re-interview the controller. All important information is queried
         // directly via the serial API
         if (this.isControllerNode())
             return;
+        const { resetSecurityClasses = false } = options;
         // preserve the node name and location, since they might not be stored on the node
         const name = this.name;
         const location = this.location;
+        // Force a new detection of security classes if desired
+        if (resetSecurityClasses)
+            this.securityClasses.clear();
         this._interviewAttempts = 0;
         this.interviewStage = Types_1.InterviewStage.None;
         this._ready = false;
@@ -1787,8 +1793,11 @@ protocol version:      ${this._protocolVersion}`;
             // the shared SPAN, since it did the same
             secMan.storeRemoteEI(this.nodeId, command.receiverEI);
         }
-        // Tell the driver to re-send the current message if necessary
-        this.driver.resendS2EncapsulatedCommand();
+        this.driver.controllerLog.logNode(this.id, {
+            message: `received S2 nonce, not sure what to do with it`,
+            level: "warn",
+            direction: "inbound",
+        });
     }
     async handleHail(_command) {
         // treat this as a sign that the node is awake
@@ -2959,7 +2968,7 @@ protocol version:      ${this._protocolVersion}`;
      *
      * **Note:** Depending on the number of test frames, this may take a while
      */
-    async testPowerlevel(testNodeId, powerlevel, testFrameCount, onProgress) {
+    async testPowerlevel(testNodeId, powerlevel, healthCheckTestFrameCount, onProgress) {
         const api = this.commandClasses.Powerlevel;
         // Keep sleeping nodes awake
         const wasKeptAwake = this.keepAwake;
@@ -2971,10 +2980,10 @@ protocol version:      ${this._protocolVersion}`;
             return value;
         };
         // Start the process
-        await api.startNodeTest(testNodeId, powerlevel, testFrameCount);
+        await api.startNodeTest(testNodeId, powerlevel, healthCheckTestFrameCount);
         // Each frame will take a few ms to be sent, let's assume 5 per second
         // to estimate how long the test will take
-        const expectedDurationMs = Math.round((testFrameCount / 5) * 1000);
+        const expectedDurationMs = Math.round((healthCheckTestFrameCount / 5) * 1000);
         // Poll the status of the test regularly
         const pollFrequencyMs = expectedDurationMs >= 60000
             ? 10000
@@ -3011,9 +3020,276 @@ protocol version:      ${this._protocolVersion}`;
             }
             else if (onProgress) {
                 // Notify the caller of the test progress
-                onProgress(status.acknowledgedFrames, testFrameCount);
+                onProgress(status.acknowledgedFrames, healthCheckTestFrameCount);
+            }
+        }
+    }
+    /**
+     * Checks the health of connection between the controller and this node and returns the results.
+     */
+    async checkLifelineHealth(rounds = 5, onProgress) {
+        if (rounds > 10 || rounds < 1) {
+            throw new core_1.ZWaveError("The number of health check rounds must be between 1 and 10!", core_1.ZWaveErrorCodes.Argument_Invalid);
+        }
+        // No. of pings per round
+        const start = Date.now();
+        /** Computes a health rating from a health check result */
+        const computeRating = (result) => {
+            var _a, _b, _c;
+            const failedPings = Math.max((_a = result.failedPingsController) !== null && _a !== void 0 ? _a : 0, result.failedPingsNode);
+            const numNeighbors = result.numNeighbors;
+            const minPowerlevel = (_b = result.minPowerlevel) !== null && _b !== void 0 ? _b : PowerlevelCC_1.Powerlevel["-6 dBm"];
+            const snrMargin = (_c = result.snrMargin) !== null && _c !== void 0 ? _c : 17;
+            const latency = result.latency;
+            if (failedPings === 10)
+                return 0;
+            if (failedPings > 2)
+                return 1;
+            if (failedPings === 2 || latency > 1000)
+                return 2;
+            if (failedPings === 1 || latency > 500)
+                return 3;
+            if (latency > 250)
+                return 4;
+            if (latency > 100)
+                return 5;
+            if (minPowerlevel < PowerlevelCC_1.Powerlevel["-6 dBm"] || snrMargin < 17) {
+                // Lower powerlevel reductions (= higher power) have lower numeric values
+                return numNeighbors > 2 ? 7 : 6;
+            }
+            if (numNeighbors <= 2)
+                return 8;
+            if (latency > 50)
+                return 9;
+            return 10;
+        };
+        this.driver.controllerLog.logNode(this.id, `Starting lifeline health check (${rounds} round${rounds !== 1 ? "s" : ""})...`);
+        const results = [];
+        for (let round = 1; round <= rounds; round++) {
+            // Determine the number of repeating neighbors
+            const numNeighbors = (await this.driver.controller.getNodeNeighbors(this.nodeId, true)).length;
+            // Ping the node 10x, measuring the RSSI
+            let txReport;
+            let routeChanges;
+            let rssi;
+            let channel;
+            let snrMargin;
+            let failedPingsNode = 0;
+            let latency = 0;
+            const pingAPI = this.commandClasses["No Operation"].withOptions({
+                onTXReport: (report) => {
+                    txReport = report;
+                },
+            });
+            for (let i = 1; i <= HealthCheck_1.healthCheckTestFrameCount; i++) {
+                const start = Date.now();
+                const pingResult = await pingAPI.send().then(() => true, () => false);
+                const rtt = Date.now() - start;
+                latency = Math.max(latency, txReport ? txReport.txTicks * 10 : rtt);
+                if (!pingResult) {
+                    failedPingsNode++;
+                }
+                else if (txReport) {
+                    routeChanges !== null && routeChanges !== void 0 ? routeChanges : (routeChanges = 0);
+                    if (txReport.routingAttempts > 1) {
+                        routeChanges++;
+                    }
+                    rssi = txReport.ackRSSI;
+                    channel = txReport.ackChannelNo;
+                }
+            }
+            // If possible, compute the SNR margin from the test results
+            if (rssi != undefined &&
+                rssi < SendDataShared_1.RssiError.NoSignalDetected &&
+                channel != undefined) {
+                const backgroundRSSI = await this.driver.controller.getBackgroundRSSI();
+                if (`rssiChannel${channel}` in backgroundRSSI) {
+                    snrMargin =
+                        rssi - backgroundRSSI[`rssiChannel${channel}`];
+                }
+            }
+            const ret = {
+                latency,
+                failedPingsNode,
+                numNeighbors,
+                routeChanges,
+                snrMargin,
+                rating: 0,
+            };
+            // Now instruct the node to ping the controller, figuring out the minimum powerlevel
+            if (this.supportsCC(core_1.CommandClasses.Powerlevel)) {
+                // Do a binary search and find the highest reduction in powerlevel for which there are no errors
+                let failedPingsController = 0;
+                const executor = async (powerlevel) => {
+                    this.driver.controllerLog.logNode(this.id, `Sending ${HealthCheck_1.healthCheckTestFrameCount} pings to controller at ${(0, shared_1.getEnumMemberName)(PowerlevelCC_1.Powerlevel, powerlevel)}...`);
+                    const result = await this.testPowerlevel(this.driver.controller.ownNodeId, powerlevel, HealthCheck_1.healthCheckTestFrameCount);
+                    failedPingsController = HealthCheck_1.healthCheckTestFrameCount - result;
+                    this.driver.controllerLog.logNode(this.id, `At ${(0, shared_1.getEnumMemberName)(PowerlevelCC_1.Powerlevel, powerlevel)}, ${result}/${HealthCheck_1.healthCheckTestFrameCount} pings were acknowledged...`);
+                    return failedPingsController === 0;
+                };
+                try {
+                    const powerlevel = await (0, shared_1.discreteBinarySearch)(PowerlevelCC_1.Powerlevel["Normal Power"], // minimum reduction
+                    PowerlevelCC_1.Powerlevel["-9 dBm"], // maximum reduction
+                    executor);
+                    if (powerlevel == undefined) {
+                        // There were still failures at normal power, report it
+                        ret.minPowerlevel = PowerlevelCC_1.Powerlevel["Normal Power"];
+                        ret.failedPingsController = failedPingsController;
+                    }
+                    else {
+                        ret.minPowerlevel = powerlevel;
+                    }
+                }
+                catch (e) {
+                    if ((0, core_1.isZWaveError)(e) &&
+                        e.code === core_1.ZWaveErrorCodes.Controller_CallbackNOK) {
+                        // The node is dead, treat this as a failure
+                        ret.minPowerlevel = PowerlevelCC_1.Powerlevel["Normal Power"];
+                        ret.failedPingsController = HealthCheck_1.healthCheckTestFrameCount;
+                    }
+                    else {
+                        throw e;
+                    }
+                }
             }
+            ret.rating = computeRating(ret);
+            results.push(ret);
+            onProgress === null || onProgress === void 0 ? void 0 : onProgress(round, rounds, ret.rating);
         }
+        const duration = Date.now() - start;
+        const rating = Math.min(...results.map((r) => r.rating));
+        const summary = { results, rating };
+        this.driver.controllerLog.logNode(this.id, `Lifeline health check complete in ${duration} ms
+${(0, HealthCheck_1.formatLifelineHealthCheckSummary)(summary)}`);
+        return summary;
+    }
+    /**
+     * Checks the health of connection between this node and the target node and returns the results.
+     */
+    async checkRouteHealth(targetNodeId, rounds = 5, onProgress) {
+        if (rounds > 10 || rounds < 1) {
+            throw new core_1.ZWaveError("The number of health check rounds must be between 1 and 10!", core_1.ZWaveErrorCodes.Argument_Invalid);
+        }
+        const otherNode = this.driver.controller.nodes.getOrThrow(targetNodeId);
+        if (!this.supportsCC(core_1.CommandClasses.Powerlevel) &&
+            !otherNode.supportsCC(core_1.CommandClasses.Powerlevel)) {
+            throw new core_1.ZWaveError("For a route health check, at least one of the nodes must support Powerlevel CC!", core_1.ZWaveErrorCodes.CC_NotSupported);
+        }
+        // No. of pings per round
+        const healthCheckTestFrameCount = 10;
+        const start = Date.now();
+        /** Computes a health rating from a health check result */
+        const computeRating = (result) => {
+            var _a, _b, _c, _d;
+            const failedPings = Math.max((_a = result.failedPingsToSource) !== null && _a !== void 0 ? _a : 0, (_b = result.failedPingsToTarget) !== null && _b !== void 0 ? _b : 0);
+            const numNeighbors = result.numNeighbors;
+            const minPowerlevel = Math.max((_c = result.minPowerlevelSource) !== null && _c !== void 0 ? _c : PowerlevelCC_1.Powerlevel["-6 dBm"], (_d = result.minPowerlevelTarget) !== null && _d !== void 0 ? _d : PowerlevelCC_1.Powerlevel["-6 dBm"]);
+            if (failedPings === 10)
+                return 0;
+            if (failedPings > 2)
+                return 1;
+            if (failedPings === 2)
+                return 2;
+            if (failedPings === 1)
+                return 3;
+            if (minPowerlevel < PowerlevelCC_1.Powerlevel["-6 dBm"]) {
+                // Lower powerlevel reductions (= higher power) have lower numeric values
+                return numNeighbors > 2 ? 7 : 6;
+            }
+            if (numNeighbors <= 2)
+                return 8;
+            return 10;
+        };
+        this.driver.controllerLog.logNode(this.id, `Starting route health check to node ${targetNodeId} (${rounds} round${rounds !== 1 ? "s" : ""})...`);
+        const results = [];
+        for (let round = 1; round <= rounds; round++) {
+            // Determine the minimum number of repeating neighbors between the
+            // source and target node
+            const numNeighbors = Math.min((await this.driver.controller.getNodeNeighbors(this.nodeId, true)).length, (await this.driver.controller.getNodeNeighbors(targetNodeId, true)).length);
+            let failedPings = 0;
+            let failedPingsToSource;
+            let minPowerlevelSource;
+            let failedPingsToTarget;
+            let minPowerlevelTarget;
+            const executor = (node, otherNode) => async (powerlevel) => {
+                this.driver.controllerLog.logNode(node.id, `Sending ${healthCheckTestFrameCount} pings to node ${otherNode.id} at ${(0, shared_1.getEnumMemberName)(PowerlevelCC_1.Powerlevel, powerlevel)}...`);
+                const result = await node.testPowerlevel(otherNode.id, powerlevel, healthCheckTestFrameCount);
+                failedPings = healthCheckTestFrameCount - result;
+                this.driver.controllerLog.logNode(node.id, `At ${(0, shared_1.getEnumMemberName)(PowerlevelCC_1.Powerlevel, powerlevel)}, ${result}/${healthCheckTestFrameCount} pings were acknowledged by node ${otherNode.id}...`);
+                return failedPings === 0;
+            };
+            // Now instruct this node to ping the other one, figuring out the minimum powerlevel
+            if (this.supportsCC(core_1.CommandClasses.Powerlevel)) {
+                try {
+                    const powerlevel = await (0, shared_1.discreteBinarySearch)(PowerlevelCC_1.Powerlevel["Normal Power"], // minimum reduction
+                    PowerlevelCC_1.Powerlevel["-9 dBm"], // maximum reduction
+                    executor(this, otherNode));
+                    if (powerlevel == undefined) {
+                        // There were still failures at normal power, report it
+                        minPowerlevelSource = PowerlevelCC_1.Powerlevel["Normal Power"];
+                        failedPingsToTarget = failedPings;
+                    }
+                    else {
+                        minPowerlevelSource = powerlevel;
+                    }
+                }
+                catch (e) {
+                    if ((0, core_1.isZWaveError)(e) &&
+                        e.code === core_1.ZWaveErrorCodes.Controller_CallbackNOK) {
+                        // The node is dead, treat this as a failure
+                        minPowerlevelSource = PowerlevelCC_1.Powerlevel["Normal Power"];
+                        failedPingsToTarget = healthCheckTestFrameCount;
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+            // And do the same with the other node
+            if (otherNode.supportsCC(core_1.CommandClasses.Powerlevel)) {
+                try {
+                    const powerlevel = await (0, shared_1.discreteBinarySearch)(PowerlevelCC_1.Powerlevel["Normal Power"], // minimum reduction
+                    PowerlevelCC_1.Powerlevel["-9 dBm"], // maximum reduction
+                    executor(otherNode, this));
+                    if (powerlevel == undefined) {
+                        // There were still failures at normal power, report it
+                        minPowerlevelTarget = PowerlevelCC_1.Powerlevel["Normal Power"];
+                        failedPingsToSource = failedPings;
+                    }
+                    else {
+                        minPowerlevelTarget = powerlevel;
+                    }
+                }
+                catch (e) {
+                    if ((0, core_1.isZWaveError)(e) &&
+                        e.code === core_1.ZWaveErrorCodes.Controller_CallbackNOK) {
+                        // The node is dead, treat this as a failure
+                        minPowerlevelTarget = PowerlevelCC_1.Powerlevel["Normal Power"];
+                        failedPingsToSource = healthCheckTestFrameCount;
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+            const ret = {
+                numNeighbors,
+                failedPingsToSource,
+                failedPingsToTarget,
+                minPowerlevelSource,
+                minPowerlevelTarget,
+                rating: 0,
+            };
+            ret.rating = computeRating(ret);
+            results.push(ret);
+            onProgress === null || onProgress === void 0 ? void 0 : onProgress(round, rounds, ret.rating);
+        }
+        const duration = Date.now() - start;
+        const rating = Math.min(...results.map((r) => r.rating));
+        const summary = { results, rating };
+        this.driver.controllerLog.logNode(this.id, `Route health check to node ${otherNode.id} complete in ${duration} ms
+${(0, HealthCheck_1.formatRouteHealthCheckSummary)(this.id, otherNode.id, summary)}`);
+        return summary;
     }
 };
 ZWaveNode = __decorate([