💄

Author: jeanp413

src/common/ports.ts

@@ -0,0 +1,20 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Gitpod. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as net from 'net';
+
+export async function isPortUsed(port: number): Promise<boolean> {
+    return new Promise<boolean>((resolve, _reject) => {
+        const server = net.createServer();
+        server.once('error', () => {
+            resolve(true);
+        });
+        server.once('listening', () => {
+            server.close();
+            resolve(false);
+        });
+        server.listen(port);
+    });
+}

src/local-ssh/ipc/extensionServiceServer.ts

@@ -24,7 +24,7 @@ import { NodeHttpTransport } from '@improbable-eng/grpc-web-node-http-transport'
 import { CreateSSHKeyPairRequest } from '@gitpod/supervisor-api-grpcweb/lib/control_pb';
 import * as ssh2 from 'ssh2';
 import { ParsedKey } from 'ssh2-streams';
-import { createServer as netCreateServer } from 'net';
+import { isPortUsed } from '../../common/ports';
 
 const phaseMap: Record<WorkspaceInstanceStatus_Phase, WorkspaceInstancePhase | undefined> = {
     [WorkspaceInstanceStatus_Phase.CREATING]: 'pending',
@@ -204,20 +204,6 @@ export class ExtensionServiceServer extends Disposable {
     }
 }
 
-async function isPortUsed(port: number): Promise<boolean> {
-    return new Promise<boolean>((resolve, _reject) => {
-        const server = netCreateServer();
-        server.once('error', () => {
-            resolve(true);
-        });
-        server.once('listening', () => {
-            server.close();
-            resolve(false);
-        });
-        server.listen(port);
-    });
-}
-
 export async function canExtensionServiceServerWork(): Promise<true> {
     const port = Configuration.getLocalSshExtensionIpcPort();
     if (!(await isPortUsed(port))) {
@@ -226,4 +212,4 @@ export async function canExtensionServiceServerWork(): Promise<true> {
     const extensionIpc = createClient(ExtensionServiceDefinition, createChannel(`127.0.0.1:${port}`));
     await extensionIpc.ping({});
     return true;
-}
+}

src/remoteConnector.ts

@@ -689,15 +689,13 @@ export class RemoteConnector extends Disposable {
 
 				let useLocalSSH = await this.experiments.getUseLocalSSHProxy();
 				if (useLocalSSH) {
+					// If needed, revert local-app changes first
+					await this.updateRemoteSSHConfig(true, undefined);
+
 					this.localSSHService.flow = sshFlow;
 					const [_, isExtensionServerReady] = await Promise.all([
-						(async () => {
-							// we need to update the remote ssh config first, since another call is too late for local-ssh
-							await this.updateRemoteSSHConfig(true, undefined);
-							this.localSSHService.prepareInitialize();
-							await this.localSSHService.initialized;
-						})(),
-						this.localSSHService.extensionServerReady(),
+						this.localSSHService.initialize(),
+						this.localSSHService.extensionServerReady()
 					]);
 					if (!isExtensionServerReady) {
 						this.logService.error('Extension IPC server is not ready');

src/services/localSSHService.ts

@@ -21,8 +21,8 @@ import { canExtensionServiceServerWork } from '../local-ssh/ipc/extensionService
 export interface ILocalSSHService {
     flow?: UserFlowTelemetryProperties;
     isSupportLocalSSH: boolean;
-    initialized: Promise<void>;
-    prepareInitialize: () => void;
+
+    initialize: () => Promise<void>;
     extensionServerReady: () => Promise<boolean>;
 }
 
@@ -32,9 +32,11 @@ type FailedToInitializeCode = 'Unknown' | 'LockFailed' | string;
 const IgnoredFailedCodes: FailedToInitializeCode[] = ['ENOSPC'];
 
 export class LocalSSHService extends Disposable implements ILocalSSHService {
+    private initPromise!: Promise<void>;
+
     public isSupportLocalSSH: boolean = false;
-    public initialized!: Promise<void>;
     public flow?: UserFlowTelemetryProperties;
+
     constructor(
         private readonly context: vscode.ExtensionContext,
         private readonly hostService: IHostService,
@@ -45,8 +47,12 @@ export class LocalSSHService extends Disposable implements ILocalSSHService {
         super();
     }
 
-    prepareInitialize() {
-        this.initialized = this.initialize();
+    async initialize(): Promise<void> {
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+
+        this.initPromise = this.doInitialize();
         this._register(vscode.workspace.onDidChangeConfiguration(async e => {
             if (
                 e.affectsConfiguration('gitpod.lsshExtensionIpcPort') ||
@@ -59,13 +65,15 @@ export class LocalSSHService extends Disposable implements ILocalSSHService {
                     // event, so ignore it if more settings are affected at the same time.
                     return;
                 }
-                if (this.initialized) {
-                    await this.initialized;
-                }
-                this.initialized = this.initialize();
+
+                await this.initPromise;
+                this.initPromise = this.doInitialize();
             }
         }));
+
+        return this.initPromise;
     }
+
     async extensionServerReady(): Promise<boolean> {
         try {
             await canExtensionServiceServerWork();
@@ -91,34 +99,35 @@ export class LocalSSHService extends Disposable implements ILocalSSHService {
         }
     }
 
-    private async initialize() {
+    private async doInitialize() {
         let failureCode: FailedToInitializeCode | undefined;
-        const useLocalAPP = String(Configuration.getUseLocalApp());
-        const lockFolder = vscode.Uri.joinPath(this.context.globalStorageUri, 'initialize.lock');
         try {
+            const lockFolder = vscode.Uri.joinPath(this.context.globalStorageUri, 'initialize');
             await this.lock(lockFolder.fsPath, async () => {
                 const locations = await this.copyProxyScript();
                 await this.configureSettings(locations);
                 this.isSupportLocalSSH = true;
             });
         } catch (e) {
-            this.logService.error(e, 'failed to initialize');
+            this.logService.error('Failed to initialize ssh proxy config', e);
+
             let sendErrorReport = true;
             failureCode = 'Unknown';
             if (e?.code) {
                 failureCode = e.code;
-                sendErrorReport = !IgnoredFailedCodes.includes(e.code)
+                sendErrorReport = !IgnoredFailedCodes.includes(e.code);
             }
             if (e?.message) {
                 e.message = `Failed to initialize: ${e.message}`;
             }
             if (sendErrorReport) {
-                this.telemetryService.sendTelemetryException(e, { gitpodHost: this.hostService.gitpodHost, useLocalAPP });
+                this.telemetryService.sendTelemetryException(e, { gitpodHost: this.hostService.gitpodHost, useLocalAPP: String(Configuration.getUseLocalApp()) });
             }
             this.isSupportLocalSSH = false;
         }
-        const flowData = this.flow ? this.flow : { gitpodHost: this.hostService.gitpodHost, userId: this.sessionService.safeGetUserId() };
-        this.telemetryService.sendUserFlowStatus(this.isSupportLocalSSH ? 'success' : 'failure', { ...flowData, flow: 'local_ssh_config', failureCode, useLocalAPP });
+
+        const flowData = this.flow ?? { gitpodHost: this.hostService.gitpodHost, userId: this.sessionService.safeGetUserId() };
+        this.telemetryService.sendUserFlowStatus(this.isSupportLocalSSH ? 'success' : 'failure', { ...flowData, flow: 'local_ssh_config', failureCode, useLocalAPP: String(Configuration.getUseLocalApp()) });
     }
 
     private async configureSettings({ proxyScript, launcher }: { proxyScript: string; launcher: string }) {