@fastybird/smart-panel-backend 1.1.0-alpha.5 → 1.1.0-alpha.7

package/dist/plugins/devices-shelly-ng/delegates/delegates-manager.service.js

@@ -8,16 +8,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 var DelegatesManagerService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DelegatesManagerService = void 0;
-const class_transformer_1 = require("class-transformer");
 const common_1 = require("@nestjs/common");
 const logger_1 = require("../../../common/logger");
 const transform_utils_1 = require("../../../common/utils/transform.utils");
 const devices_constants_1 = require("../../../modules/devices/devices.constants");
 const channels_properties_service_1 = require("../../../modules/devices/services/channels.properties.service");
 const channels_service_1 = require("../../../modules/devices/services/channels.service");
+const command_latency_trace_collector_service_1 = require("../../../modules/devices/services/command-latency-trace-collector.service");
 const device_connectivity_service_1 = require("../../../modules/devices/services/device-connectivity.service");
 const devices_service_1 = require("../../../modules/devices/services/devices.service");
 const devices_shelly_ng_constants_1 = require("../devices-shelly-ng.constants");
@@ -30,7 +33,7 @@ const device_manager_service_1 = require("../services/device-manager.service");
 const transform_utils_2 = require("../utils/transform.utils");
 const shelly_device_delegate_1 = require("./shelly-device.delegate");
 let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManagerService {
-    constructor(devicesService, channelsService, channelsPropertiesService, deviceConnectivityService, deviceManagerService, deviceAddressService, propertyMappingStorage, transformerRegistry) {
+    constructor(devicesService, channelsService, channelsPropertiesService, deviceConnectivityService, deviceManagerService, deviceAddressService, propertyMappingStorage, transformerRegistry, commandLatencyTraceCollector = new command_latency_trace_collector_service_1.CommandLatencyTraceCollectorService()) {
         this.devicesService = devicesService;
         this.channelsService = channelsService;
         this.channelsPropertiesService = channelsPropertiesService;
@@ -39,6 +42,7 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         this.deviceAddressService = deviceAddressService;
         this.propertyMappingStorage = propertyMappingStorage;
         this.transformerRegistry = transformerRegistry;
+        this.commandLatencyTraceCollector = commandLatencyTraceCollector;
         this.logger = (0, logger_1.createExtensionLogger)(devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_PLUGIN_NAME, 'DelegatesManagerService');
         this.delegates = new Map();
         this.delegateValueHandlers = new Map();
@@ -47,6 +51,10 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         this.setChannelsHandlers = new Map();
         this.setPropertiesHandlers = new Map();
         this.pendingWrites = new Map();
+        this.pendingPollWrites = new Map();
+        this.activePollWrites = new Map();
+        this.delegatePollGenerations = new Map();
+        this.currentValueUpdateContext = null;
         this.propertiesMap = new Map();
         this.delegateDeviceIds = new Map();
         this.delegateToIdentifier = new Map();
@@ -75,6 +83,7 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         }
         const generation = (this.insertGeneration.get(shelly.id) ?? 0) + 1;
         this.insertGeneration.set(shelly.id, generation);
+        this.delegatePollGenerations.set(shelly.id, (this.delegatePollGenerations.get(shelly.id) ?? 0) + 1);
         const delegate = new shelly_device_delegate_1.ShellyDeviceDelegate(shelly);
         this.delegates.set(shelly.id, delegate);
         const wifiIp = shelly.wifi?.sta_ip ?? null;
@@ -808,12 +817,13 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         }
         if (this.insertGeneration.get(shelly.id) !== generation)
             return delegate;
-        const valueHandler = (compKey, attr, val) => {
+        const valueHandler = (compKey, attr, val, origin = 'notify') => {
             const handler = this.changeHandlers.get(`${delegate.id}|${compKey}|${attr}`);
             if (!handler) {
                 return;
             }
             try {
+                this.currentValueUpdateContext = { delegateId: delegate.id, deviceId: device.id, origin };
                 handler(val);
             }
             catch (error) {
@@ -824,6 +834,9 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
                     stack: err.stack,
                 });
             }
+            finally {
+                this.currentValueUpdateContext = null;
+            }
         };
         delegate.on('value', valueHandler);
         this.delegateValueHandlers.set(delegate.id, valueHandler);
@@ -939,6 +952,8 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         if (!delegate) {
             return;
         }
+        this.delegatePollGenerations.set(deviceId, (this.delegatePollGenerations.get(deviceId) ?? 0) + 1);
+        this.cancelPollWritesForDelegate(deviceId);
         const valueHandler = this.delegateValueHandlers.get(delegate.id);
         const connectionHandler = this.delegateConnectionHandlers.get(delegate.id);
         if (connectionHandler) {
@@ -1075,7 +1090,24 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         }
     }
     async handleChange(property, value, immediately = true) {
+        const context = this.currentValueUpdateContext;
+        if (context !== null) {
+            this.commandLatencyTraceCollector.recordProviderReceipt(property.id, value, context.origin, {
+                delegateId: context.delegateId,
+                deviceId: context.deviceId,
+            });
+        }
+        if (context?.origin === 'poll') {
+            this.commandLatencyTraceCollector.recordPollActivity(property.id, 'poll-coalescer-admission', {
+                delegateId: context.delegateId,
+                deviceId: context.deviceId,
+            });
+            this.schedulePollWrite(context, property, value);
+            return;
+        }
         if (immediately) {
+            this.cancelScheduledWrite(property.id);
+            this.cancelPollWrite(property.id);
             await this.writeValueToProperty(property, value);
         }
         else {
@@ -1234,9 +1266,123 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
         }, 250);
         this.pendingWrites.set(property.id, t);
     }
+    schedulePollWrite(context, property, value) {
+        let bucket = this.pendingPollWrites.get(context.deviceId);
+        if (!bucket) {
+            const values = new Map();
+            const timer = setTimeout(() => {
+                void this.flushPollWrites(context.deviceId);
+            }, 250);
+            bucket = { timer, values };
+            this.pendingPollWrites.set(context.deviceId, bucket);
+        }
+        bucket.values.set(property.id, {
+            delegateId: context.delegateId,
+            delegateGeneration: this.delegatePollGenerations.get(context.delegateId) ?? 0,
+            property,
+            value,
+        });
+    }
+    async flushPollWrites(deviceId) {
+        const bucket = this.pendingPollWrites.get(deviceId);
+        if (!bucket) {
+            return;
+        }
+        this.pendingPollWrites.delete(deviceId);
+        clearTimeout(bucket.timer);
+        let activeBuckets = this.activePollWrites.get(deviceId);
+        if (activeBuckets === undefined) {
+            activeBuckets = new Set();
+            this.activePollWrites.set(deviceId, activeBuckets);
+        }
+        activeBuckets.add(bucket);
+        try {
+            for (const [propertyId, pending] of [...bucket.values.entries()]) {
+                if (bucket.values.get(propertyId) !== pending) {
+                    continue;
+                }
+                if (!this.delegates.has(pending.delegateId) ||
+                    (this.delegatePollGenerations.get(pending.delegateId) ?? 0) !== pending.delegateGeneration) {
+                    continue;
+                }
+                try {
+                    this.commandLatencyTraceCollector.recordPollActivity(pending.property.id, 'poll-drain', {
+                        delegateId: pending.delegateId,
+                        deviceId,
+                    });
+                    await this.writeValueToProperty(pending.property, pending.value);
+                }
+                catch (error) {
+                    const err = error;
+                    this.logger.error(`Failed to process poll write of value=${(0, transform_utils_1.safeToString)(pending.value)} to property=${pending.property.id}`, { message: err.message, stack: err.stack });
+                }
+            }
+        }
+        finally {
+            activeBuckets.delete(bucket);
+            if (activeBuckets.size === 0 && this.activePollWrites.get(deviceId) === activeBuckets) {
+                this.activePollWrites.delete(deviceId);
+            }
+        }
+    }
+    cancelScheduledWrite(propertyId) {
+        const timer = this.pendingWrites.get(propertyId);
+        if (timer) {
+            clearTimeout(timer);
+            this.pendingWrites.delete(propertyId);
+        }
+    }
+    cancelPollWrite(propertyId) {
+        for (const [deviceId, bucket] of this.pendingPollWrites.entries()) {
+            bucket.values.delete(propertyId);
+            if (bucket.values.size === 0) {
+                clearTimeout(bucket.timer);
+                this.pendingPollWrites.delete(deviceId);
+            }
+        }
+        for (const buckets of this.activePollWrites.values()) {
+            for (const bucket of buckets) {
+                bucket.values.delete(propertyId);
+            }
+        }
+    }
+    cancelPollWritesForDelegate(delegateId) {
+        for (const [deviceId, bucket] of this.pendingPollWrites.entries()) {
+            for (const [propertyId, pending] of bucket.values.entries()) {
+                if (pending.delegateId === delegateId) {
+                    bucket.values.delete(propertyId);
+                }
+            }
+            if (bucket.values.size === 0) {
+                clearTimeout(bucket.timer);
+                this.pendingPollWrites.delete(deviceId);
+            }
+        }
+        for (const buckets of this.activePollWrites.values()) {
+            for (const bucket of buckets) {
+                for (const [propertyId, pending] of bucket.values.entries()) {
+                    if (pending.delegateId === delegateId) {
+                        bucket.values.delete(propertyId);
+                    }
+                }
+            }
+        }
+    }
+    clearPollWrites() {
+        for (const bucket of this.pendingPollWrites.values()) {
+            clearTimeout(bucket.timer);
+        }
+        this.pendingPollWrites.clear();
+        for (const buckets of this.activePollWrites.values()) {
+            for (const bucket of buckets) {
+                bucket.values.clear();
+            }
+        }
+        this.activePollWrites.clear();
+    }
     async writeValueToProperty(property, value) {
         return await this.channelsPropertiesService.update(property.id, (0, transform_utils_1.toInstance)(update_channel_property_dto_1.UpdateShellyNgChannelPropertyDto, {
-            ...(0, class_transformer_1.instanceToPlain)(property),
+            type: devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE,
             value,
         }));
     }
@@ -1293,6 +1439,9 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
             clearTimeout(pendingWrite);
         }
         this.pendingWrites.clear();
+        this.clearPollWrites();
+        this.delegatePollGenerations.clear();
+        this.currentValueUpdateContext = null;
         this.deviceLocks.clear();
         this.canonicalMacLocks.clear();
         this.connectedDelegatesPerDevice.clear();
@@ -1336,20 +1485,46 @@ let DelegatesManagerService = DelegatesManagerService_1 = class DelegatesManager
             await Promise.all(tasks.slice(i, i + CONCURRENCY).map((fn) => fn()));
         }
     }
-    async pollAllDevices(timeoutMs = 10_000) {
-        const CONCURRENCY = 10;
-        const tasks = [];
-        for (const [id, delegate] of this.delegates.entries()) {
-            if (!delegate.connected) {
-                continue;
-            }
-            tasks.push(async () => {
-                const ok = await delegate.pollStatus(timeoutMs);
-                if (!ok) {
-                    this.logger.warn(`Status poll failed for device=${id}`);
-                }
+    getConnectedDelegateIds() {
+        return Array.from(this.delegates.entries())
+            .filter(([, delegate]) => delegate.connected)
+            .map(([id]) => id)
+            .sort();
+    }
+    invalidateStatusPolls() {
+        for (const delegateId of this.delegates.keys()) {
+            this.delegatePollGenerations.set(delegateId, (this.delegatePollGenerations.get(delegateId) ?? 0) + 1);
+        }
+        this.clearPollWrites();
+    }
+    async pollDevice(deviceId, timeoutMs = 10_000) {
+        const delegate = this.delegates.get(deviceId);
+        if (!delegate || !delegate.connected) {
+            return;
+        }
+        const generation = this.delegatePollGenerations.get(deviceId) ?? 0;
+        this.commandLatencyTraceCollector.recordPollRpc(deviceId, 'poll-rpc-start', { timeoutMs });
+        let ok;
+        try {
+            ok = await delegate.pollStatus(timeoutMs, () => this.delegates.get(deviceId) === delegate &&
+                delegate.connected &&
+                this.delegatePollGenerations.get(deviceId) === generation);
+        }
+        catch (error) {
+            this.commandLatencyTraceCollector.recordPollRpc(deviceId, 'poll-rpc-complete', {
+                ok: false,
+                error: error instanceof Error ? error.message : 'unknown failure',
             });
+            throw error;
         }
+        this.commandLatencyTraceCollector.recordPollRpc(deviceId, 'poll-rpc-complete', { ok });
+        if (!ok && this.delegates.get(deviceId) === delegate && this.delegatePollGenerations.get(deviceId) === generation) {
+            this.logger.warn(`Status poll failed for device=${deviceId}`);
+        }
+    }
+    async pollAllDevices(timeoutMs = 10_000) {
+        const CONCURRENCY = 10;
+        const tasks = this.getConnectedDelegateIds().map((id) => () => this.pollDevice(id, timeoutMs));
         for (let i = 0; i < tasks.length; i += CONCURRENCY) {
             await Promise.all(tasks.slice(i, i + CONCURRENCY).map((fn) => fn()));
         }
@@ -1398,6 +1573,7 @@ exports.DelegatesManagerService = DelegatesManagerService;
 DelegatesManagerService.DISCONNECT_GRACE_MS = 15_000;
 exports.DelegatesManagerService = DelegatesManagerService = DelegatesManagerService_1 = __decorate([
     (0, common_1.Injectable)(),
+    __param(8, (0, common_1.Optional)()),
     __metadata("design:paramtypes", [devices_service_1.DevicesService,
         channels_service_1.ChannelsService,
         channels_properties_service_1.ChannelsPropertiesService,
@@ -1405,6 +1581,7 @@ exports.DelegatesManagerService = DelegatesManagerService = DelegatesManagerServ
         device_manager_service_1.DeviceManagerService,
         device_address_service_1.DeviceAddressService,
         mappings_1.PropertyMappingStorageService,
-        mappings_1.TransformerRegistry])
+        mappings_1.TransformerRegistry,
+        command_latency_trace_collector_service_1.CommandLatencyTraceCollectorService])
 ], DelegatesManagerService);
 //# sourceMappingURL=delegates-manager.service.js.map