incyclist-services 1.0.68 → 1.0.70

package/lib/devices/ride/service.d.ts

@@ -39,7 +39,10 @@ export declare class DeviceRideService extends EventEmitter {
     startAdapters(adapters: AdapterRideInfo[], startType: 'start' | 'check' | 'pair', props?: RideServiceDeviceProperties): Promise<boolean>;
     startHealthCheck(ai: AdapterRideInfo): void;
     stopHealthCheck(ai: AdapterRideInfo): void;
-    prepareReconnect(down: AdapterRideInfo): Promise<void>;
+    prepareReconnect(unhealthy: AdapterRideInfo): Promise<void>;
+    private reconnectInterface;
+    protected stopAfterRestart(unhealthy: AdapterRideInfo): Promise<void>;
+    private reconnectSingle;
     start(props: RideServiceDeviceProperties): Promise<boolean>;
     startRetry(props: RideServiceDeviceProperties): Promise<boolean>;
     cancelStart(): Promise<boolean>;

package/lib/devices/ride/service.js

@@ -476,12 +476,12 @@ class DeviceRideService extends events_1.default {
         const check = () => {
             const tsNow = Date.now();
             const isPaused = ai.adapter.isPaused();
+            const prevStatus = ai.dataStatus;
             if (isPaused || !ai.tsLastData) {
                 ai.tsLastData = tsNow;
                 ai.dataStatus = 'green';
                 return;
             }
-            const prevStatus = ai.dataStatus;
             const isAmber = (tsNow - ai.tsLastData) > NO_DATA_THRESHOLD;
             const isRed = (tsNow - ai.tsLastData) > UNHEALTHY_THRESHOLD;
             ai.dataStatus = 'green';
@@ -489,19 +489,19 @@ class DeviceRideService extends events_1.default {
                 ai.dataStatus = 'amber';
             if (isRed)
                 ai.dataStatus = 'red';
-            if (ai.isHealthy && isAmber) {
+            if (ai.isHealthy && (isAmber || isRed)) {
                 ai.isHealthy = false;
                 this.logEvent({ message: 'device unhealthy', device: ai.adapter.getUniqueName(), udid: ai.udid });
-                const { enabledCapabilities } = this.getEnabledCapabilities(ai);
-                this.emit('unhealthy', ai.udid, ai.dataStatus, enabledCapabilities);
                 console.log('~~~~ health check: prepare reconnect');
                 this.prepareReconnect(ai);
             }
-            else if (!ai.isHealthy && !isAmber) {
-                const { enabledCapabilities } = this.getEnabledCapabilities(ai);
+            else if (!ai.isHealthy && !isAmber && !isRed) {
                 ai.isHealthy = true;
                 this.logEvent({ message: 'device healthy', device: ai.adapter.getUniqueName(), udid: ai.udid });
-                this.emit('healthy', ai.udid, ai.dataStatus, enabledCapabilities);
+            }
+            if (ai.dataStatus !== prevStatus) {
+                const { enabledCapabilities } = this.getEnabledCapabilities(ai);
+                this.emit('health', ai.udid, ai.dataStatus, enabledCapabilities);
             }
         };
         ai.ivToCheck = (0, timers_1.setInterval)(check, 1000);
@@ -514,75 +514,128 @@ class DeviceRideService extends events_1.default {
             delete ai.isHealthy;
         }
     }
-    prepareReconnect(down) {
+    prepareReconnect(unhealthy) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (down.isRestarting)
+            if (unhealthy.isRestarting)
                 return;
-            console.log('~~~~ health check: wait 45s', down.udid);
+            console.log('~~~~ health check: wait 45s', unhealthy.udid);
             yield (0, sleep_1.sleep)(UNHEALTHY_THRESHOLD - NO_DATA_THRESHOLD - 5000);
-            console.log('~~~~ health check: check if still unhealthy', down.udid, down.isHealthy, down.isRestarting);
-            if (down.isHealthy || down.isRestarting)
+            if (unhealthy.isHealthy || unhealthy.isRestarting)
                 return;
-            const ifName = down.adapter.getInterface();
+            console.log('~~~~ health check: still unhealthy', unhealthy.udid, unhealthy.isHealthy, unhealthy.isRestarting);
+            unhealthy.isRestarting = true;
+            const ifName = unhealthy.adapter.getInterface();
             const adapters = this.getAdapterList().filter(ai => ai.adapter.getInterface() === ifName);
-            down.isRestarting = true;
             if (!adapters.find(ai => ai.isHealthy)) {
-                console.log('~~~~ health check: restart interface', ifName);
-                this.logger.logEvent({ message: 'restart interface', interface: ifName });
-                const i = incyclist_devices_1.InterfaceFactory.create(ifName);
-                try {
-                    const promisesStop = [];
-                    adapters.map(ai => {
-                        ai.isRestarting = true;
-                        ai.adapter.off('data', this.deviceDataHandler);
+                yield this.reconnectInterface(ifName, adapters);
+            }
+            else {
+                yield this.reconnectSingle(unhealthy);
+            }
+            unhealthy.isRestarting = false;
+        });
+    }
+    reconnectInterface(ifName, adapters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('~~~~ health check: restart interface', ifName);
+            this.logger.logEvent({ message: 'restart interface', interface: ifName });
+            let stopRequested = false;
+            this.once('stop-ride', () => { stopRequested = true; });
+            const i = incyclist_devices_1.InterfaceFactory.create(ifName);
+            try {
+                console.log('~~~~ health check: stop Adapters', ifName);
+                const promisesStop = [];
+                adapters.map(ai => {
+                    if (ai.isRestarting) {
+                        promisesStop.push(this.stopAfterRestart(ai));
+                    }
+                    else {
                         promisesStop.push(ai.adapter.stop());
-                    });
-                    if (promisesStop.length > 0) {
-                        yield Promise.allSettled(promisesStop);
                     }
+                    ai.isRestarting = true;
+                    ai.adapter.off('data', this.deviceDataHandler);
+                });
+                if (promisesStop.length > 0) {
+                    yield Promise.allSettled(promisesStop);
+                }
+                console.log('~~~~ health check: reconnect interface', ifName);
+                if (!stopRequested) {
                     yield i.disconnect();
                     yield (0, sleep_1.sleep)(1000);
-                    yield i.connect;
+                    yield i.connect();
+                }
+                console.log('~~~~ health check: start adapters', ifName);
+                if (!stopRequested) {
                     const promisesStart = [];
                     adapters.map(ai => { promisesStart.push(ai.adapter.start()); });
                     if (promisesStart.length > 0) {
                         yield Promise.allSettled(promisesStart);
                     }
                 }
-                catch (err) {
-                    this.logger.logEvent({ message: 'restart interface failed', interface: ifName, reason: err.message });
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'restart interface failed', interface: ifName, reason: err.message });
+                console.log('~~~~ health check: restart interface error', ifName, err);
+            }
+            adapters.map(ai => {
+                if (ai.adapter.isStarted()) {
+                    ai.tsLastData = Date.now();
                 }
-                adapters.map(ai => {
-                    if (ai.adapter.isStarted()) {
-                        ai.isHealthy = true;
-                        ai.dataStatus = 'green';
-                    }
-                    else {
-                        ai.isHealthy = false;
-                        ai.dataStatus = 'red';
-                        this.prepareReconnect(ai);
-                    }
-                    ai.adapter.on('data', this.deviceDataHandler);
+                else {
+                    console.log('~~~~ health check: adapter still not healthy', ifName, ai.udid);
                     ai.isRestarting = false;
+                    this.prepareReconnect(ai);
+                }
+                ai.adapter.on('data', this.deviceDataHandler);
+                ai.isRestarting = false;
+            });
+        });
+    }
+    stopAfterRestart(unhealthy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (unhealthy.isRestarting) {
+                yield new Promise(done => {
+                    this.once('stop-adapter-confirmed', (udid) => {
+                        if (udid === unhealthy.udid)
+                            done();
+                    });
                 });
             }
-            else {
-                console.log('~~~~ health check: restart adapter', down.udid);
-                this.logger.logEvent({ message: 'restart adapter', device: down.udid });
-                down.adapter.off('data', this.deviceDataHandler);
-                const adapter = down.adapter;
+            yield unhealthy.adapter.stop();
+        });
+    }
+    reconnectSingle(unhealthy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let stopRequested = false;
+            this.once('stop-ride', () => { stopRequested = true; });
+            this.once('stop-adapter', (udid) => {
+                if (udid === unhealthy.udid)
+                    stopRequested = true;
+            });
+            let success = false;
+            do {
+                console.log('~~~~ health check: restart adapter', unhealthy.udid);
+                this.logger.logEvent({ message: 'restart adapter', device: unhealthy.udid });
+                unhealthy.adapter.off('data', this.deviceDataHandler);
+                const adapter = unhealthy.adapter;
                 try {
-                    yield adapter.restart();
-                    down.isHealthy = true;
-                    down.dataStatus = 'green';
+                    const started = yield adapter.restart();
+                    if (started) {
+                        unhealthy.tsLastData = Date.now();
+                        success = true;
+                    }
                 }
                 catch (err) {
-                    this.logger.logEvent({ message: 'restart adapter failed', device: down.udid, reason: err.message });
-                    this.prepareReconnect(down);
+                    this.logger.logEvent({ message: 'restart adapter failed', device: unhealthy.udid, reason: err.message });
+                    this.prepareReconnect(unhealthy);
                 }
-                down.adapter.on('data', this.deviceDataHandler);
-            }
-            down.isRestarting = false;
+                unhealthy.adapter.on('data', this.deviceDataHandler);
+                if (!success) {
+                    for (let i = 0; i < 60 && !stopRequested; i++)
+                        yield (0, sleep_1.sleep)(1000);
+                }
+            } while (!stopRequested && !success);
+            this.emit('stop-adapter-confirmed', unhealthy.udid);
         });
     }
     start(props) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-services",
-  "version": "1.0.68",
+  "version": "1.0.70",
   "peerDependencies": {
     "gd-eventlog": "^0.1.26"
   },
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "axios": "^1.6.1",
-    "incyclist-devices": "^2.1.28",
+    "incyclist-devices": "^2.1.29",
     "uuid": "^9.0.0",
     "xml2js": "^0.6.2"
   }