fixup! feat(request-manager): support external Tor

packages/request-manager/src/controller.ts

@@ -12,6 +12,7 @@ import {
 } from './types';
 import { bootstrapParser, BOOTSTRAP_EVENT_PROGRESS } from './events/bootstrap';
 import { waitUntil } from './utils';
+import { ScheduleActionParams, ScheduledAction, scheduleAction } from '@trezor/utils';
 
 const WAITING_TIME = 1000;
 const MAX_TRIES_WAITING = 200;
@@ -193,24 +194,37 @@ export class TorController extends EventEmitter {
 
     public async waitUntilAlive(): Promise<void> {
         this.status = TOR_CONTROLLER_STATUS.Bootstrapping;
-        await waitUntil(
-            MAX_TRIES_WAITING,
-            WAITING_TIME,
-            async () => {
-                const isConnected = await this.controlPort.connect();
-                const isAlive = this.controlPort.ping();
-                const isCircuitEstablished = this.getIsCircuitEstablished();
-                // It is running so let's not wait anymore.
-                if (isConnected && isAlive && isCircuitEstablished) {
-                    return true;
-                } else {
-                    return false;
+
+        const abortController = new AbortController();
+        const checkConnection: ScheduledAction<boolean> = async signal => {
+            if (signal?.aborted) {
+                throw new Error('Tor controller check alive aborted');
+            }
+            const isConnected = await this.controlPort.connect();
+            const isAlive = this.controlPort.ping();
+            const isCircuitEstablished = this.getIsCircuitEstablished();
+            // It is running so let's not wait anymore.
+            if (isConnected && isAlive && isCircuitEstablished) {
+                return true;
+            }
+            throw new Error('Tor not alive');
+        };
+        const params: ScheduleActionParams = {
+            attempts: MAX_TRIES_WAITING,
+            timeout: WAITING_TIME,
+            gap: WAITING_TIME,
+            signal: abortController.signal,
+            attemptFailureHandler: () => {
+                if (this.getIsStopped()) {
+                    abortController.abort();
+
+                    return new Error('Operation stopped.');
                 }
+
+                return undefined;
             },
-            () => {
-                return this.getIsStopped();
-            },
-        );
+        };
+        await scheduleAction(checkConnection, params);
     }
 
     public getStatus(): Promise<TorControllerStatus> {

packages/request-manager/src/controllerExternal.ts

@@ -2,8 +2,8 @@ import { EventEmitter } from 'events';
 
 import { checkSocks5Proxy } from '@trezor/node-utils';
 
-import { waitUntil } from './utils';
 import { TOR_CONTROLLER_STATUS, TorControllerStatus, TorExternalConnectionOptions } from './types';
+import { ScheduleActionParams, ScheduledAction, scheduleAction } from '@trezor/utils';
 
 const WAITING_TIME = 1_000;
 const MAX_TRIES_WAITING = 200;
@@ -46,33 +46,43 @@ export class TorControllerExternal extends EventEmitter {
 
     public async waitUntilAlive() {
         this.startBootstrap();
-        await waitUntil(
-            MAX_TRIES_WAITING,
-            WAITING_TIME,
-            async () => {
-                const isRunning = await this.getIsExternalTorRunning();
-                if (isRunning) {
-                    this.successfullyBootstrapped();
-                }
 
-                return isRunning;
-            },
-            () => {
-                return this.getIsStopped();
+        const abortController = new AbortController();
+        const checkConnection: ScheduledAction<boolean> = async signal => {
+            if (signal?.aborted) {
+                throw new Error('Operation aborted');
+            }
+            const isRunning = await this.getIsExternalTorRunning();
+            if (isRunning) {
+                this.successfullyBootstrapped();
+                return true;
+            }
+            throw new Error('Tor external not alive');
+        };
+
+        const params: ScheduleActionParams = {
+            attempts: MAX_TRIES_WAITING,
+            timeout: WAITING_TIME,
+            gap: WAITING_TIME,
+            signal: abortController.signal,
+            attemptFailureHandler: () => {
+                if (this.getIsStopped()) {
+                    abortController.abort();
+                    return new Error('Operation stopped.');
+                }
+                return undefined;
             },
-        );
+        };
+        await scheduleAction(checkConnection, params);
     }
 
     public async getStatus() {
         const isExternalTorRunning = await this.getIsExternalTorRunning();
+        if (isExternalTorRunning) {
+            return TOR_CONTROLLER_STATUS.ExternalTorRunning;
+        }
 
-        return new Promise(resolve => {
-            if (isExternalTorRunning) {
-                return resolve(TOR_CONTROLLER_STATUS.ExternalTorRunning);
-            }
-
-            return resolve(TOR_CONTROLLER_STATUS.Stopped);
-        });
+        return TOR_CONTROLLER_STATUS.Stopped;
     }
 
     public closeActiveCircuits() {