wip: works !!!

packages/request-manager/src/controller.ts

@@ -68,6 +68,24 @@ export class TorController extends EventEmitter {
         }, BOOTSTRAP_SLOW_TRESHOLD);
     }
 
+    private onMessageReceived(message: string) {
+        const bootstrap: BootstrapEvent[] = bootstrapParser(message);
+        bootstrap.forEach(event => {
+            if (event.type !== 'progress') return;
+            if (event.progress && !this.getIsBootstrapping()) {
+                // We consider that bootstrap has started when we receive any bootstrap event and
+                // Tor is not bootstrapping yet.
+                // If we do not receive any bootstrapping event, we can consider there is something going wrong and
+                // an error will be thrown when `MAX_TRIES_WAITING` is reached in `waitUntilAlive`.
+                this.startBootstrap();
+            }
+            if (event.progress === BOOTSTRAP_EVENT_PROGRESS.Done) {
+                this.successfullyBootstrapped();
+            }
+            this.emit('bootstrap/event', event);
+        });
+    }
+
     public async getTorConfiguration(
         processId: number,
         snowflakeBinaryPath?: string,
@@ -174,34 +192,20 @@ export class TorController extends EventEmitter {
         return config;
     }
 
-    public onMessageReceived(message: string) {
-        const bootstrap: BootstrapEvent[] = bootstrapParser(message);
-        bootstrap.forEach(event => {
-            if (event.type !== 'progress') return;
-            if (event.progress && !this.getIsBootstrapping()) {
-                // We consider that bootstrap has started when we receive any bootstrap event and
-                // Tor is not bootstrapping yet.
-                // If we do not receive any bootstrapping event, we can consider there is something going wrong and
-                // an error will be thrown when `MAX_TRIES_WAITING` is reached in `waitUntilAlive`.
-                this.startBootstrap();
-            }
-            if (event.progress === BOOTSTRAP_EVENT_PROGRESS.Done) {
-                this.successfullyBootstrapped();
-            }
-            this.emit('bootstrap/event', event);
-        });
-    }
-
     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();
+                console.log('isConnected', isConnected);
                 const isAlive = this.controlPort.ping();
+                console.log('isAlive', isAlive);
+                const isCircuitEstablished = this.getIsCircuitEstablished();
+                console.log('isCircuitEstablished', isCircuitEstablished);
                 // It is running so let's not wait anymore.
-                if (isConnected && isAlive && this.getIsCircuitEstablished()) {
+                if (isConnected && isAlive && isCircuitEstablished) {
                     return true;
                 } else {
                     return false;

packages/request-manager/src/controllerExternal.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from 'events';
+
+export class TorControllerExternal extends EventEmitter {
+    constructor() {
+        super();
+    }
+    getTorConfiguration() {
+        return '';
+    }
+    waitUntilAlive() {}
+    getStatus() {}
+    closeActiveCircuits() {}
+    stop() {}
+}

packages/request-manager/src/index.ts

@@ -1,4 +1,5 @@
 export { TorController } from './controller';
+export { TorControllerExternal } from './controllerExternal';
 export { createInterceptor } from './interceptor';
 export type { InterceptedEvent, BootstrapEvent, TorControllerStatus } from './types';
 export { TOR_CONTROLLER_STATUS } from './types';

packages/request-manager/src/utils.ts

@@ -18,6 +18,7 @@ export const waitUntil = (
         }
         try {
             const completed = await checkToSuccess();
+            console.log('completed', completed);
             if (completed) {
                 return;
             }

packages/suite-desktop-core/src/index.d.ts

@@ -101,8 +101,8 @@ declare type TorSettings = {
     running: boolean; // Tor should be enabled
     host: string; // Hostname of the tor process through which traffic is routed
     port: number; // Port of the Tor process through which traffic is routed
-    // controlPort: number; // Port of the Tor Control Port
-    // torDataDir: string; // Path of tor data directory
+    controlPort: number; // Port of the Tor Control Port
+    torDataDir: string; // Path of tor data directory
     snowflakeBinaryPath: string; // Path in user system to the snowflake binary
     // externalPort: number; // Port of the Tor process run by the user externally to suite
     useExternalTor: boolean; // Tor should use external daemon instead of the one built-in suite.

packages/suite-desktop-core/src/libs/processes/BaseProcess.ts

@@ -74,6 +74,7 @@ export abstract class BaseProcess {
      * @param params Command line parameters for the process
      */
     async start(params: string[] = []) {
+        console.log('start in base process');
         if (this.startupThrottle) {
             this.logger.warn(this.logTopic, 'Canceling process start (throttle)');
 
@@ -82,6 +83,7 @@ export abstract class BaseProcess {
 
         const status = await this.status();
 
+        console.log('status in base process', status);
         // Service is running, nothing to do
         if (status.service) {
             this.logger.warn(this.logTopic, 'Canceling process start (service running)');

packages/suite-desktop-core/src/libs/processes/TorExternalProcess.ts

@@ -1,8 +1,10 @@
 import { TorConnectionOptions } from '@trezor/request-manager/src/types';
 import { checkSocks5Proxy } from '@trezor/node-utils';
 
-import { Status } from './BaseProcess';
+import { BaseProcess, Status } from './BaseProcess';
 import { waitUntil } from '@trezor/request-manager/src/utils';
+import { TorControllerExternal } from '@trezor/request-manager';
+// import { TorController } from '@trezor/request-manager';
 
 export type TorProcessStatus = Status & { isBootstrapping?: boolean; isSocks5ProxyPort?: boolean };
 
@@ -12,30 +14,13 @@ const DEFAULT_TOR_EXTERNAL_HOST = '127.0.0.1';
 const DEFAULT_TOR_EXTERNAL_PORT = 9050;
 
 export class TorExternalProcess {
-    // torController: TorController;
-    // port: number;
-    // controlPort: number;
-    // torHost: string;
-    // torDataDir: string;
-    // snowflakeBinaryPath: string;
-    // useExternalTor: boolean;
-
-    stop = true;
-
-    constructor(_options: TorConnectionOptions & { useExternalTor: boolean }) {
-        // this.port = options.port;
-        // this.controlPort = options.controlPort;
-        // this.torHost = options.host;
-        // this.torDataDir = options.torDataDir;
-        // this.useExternalTor = options.useExternalTor;
-        // this.snowflakeBinaryPath = '';
-        // this.torController = new TorController({
-        //     host: this.torHost,
-        //     port: this.port,
-        //     controlPort: this.controlPort,
-        //     torDataDir: this.torDataDir,
-        //     snowflakeBinaryPath: this.snowflakeBinaryPath,
-        // });
+    isStopped = true;
+    torController: TorControllerExternal;
+    port = DEFAULT_TOR_EXTERNAL_PORT;
+    host = DEFAULT_TOR_EXTERNAL_HOST;
+    constructor() {
+        // this.torController = new FakeTorController();
+        this.torController = new TorControllerExternal();
     }
 
     setTorConfig(_torConfig: { useExternalTor: boolean; snowflakeBinaryPath: string }) {
@@ -64,7 +49,7 @@ export class TorExternalProcess {
     }
 
     public getIsStopped() {
-        return this.stop;
+        return this.isStopped;
     }
 
     public async waitUntilAliveExternal(host: string, port: number): Promise<void> {
@@ -89,7 +74,12 @@ export class TorExternalProcess {
 
     async start(): Promise<void> {
         console.log('startExternal in TorProcess start');
+        this.isStopped = false;
         await this.waitUntilAliveExternal(DEFAULT_TOR_EXTERNAL_HOST, DEFAULT_TOR_EXTERNAL_PORT);
-        this.stop = false;
+    }
+
+    async stop() {
+        // We should not stop External Tor Process but ignore it.
+        this.isStopped = true;
     }
 }

packages/suite-desktop-core/src/libs/store.ts

@@ -63,9 +63,11 @@ export class Store {
         return this.store.get('torSettings', {
             running: false,
             port: 9050,
+            controlPort: 9051,
             host: '127.0.0.1',
             snowflakeBinaryPath: '',
             useExternalTor: false,
+            torDataDir: '',
         });
     }