Ping extension ipc server before use local ssh IDE-77 (#73)

* Ping extension ipc server before use local ssh

Author: mustard-mh

src/local-ssh/ipc/extensionServiceServer.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { ExtensionServiceDefinition, ExtensionServiceImplementation, GetWorkspaceAuthInfoRequest, GetWorkspaceAuthInfoResponse, SendErrorReportRequest, SendLocalSSHUserFlowStatusRequest } from '../../proto/typescript/ipc/v1/ipc';
+import { ExtensionServiceDefinition, ExtensionServiceImplementation, GetWorkspaceAuthInfoRequest, GetWorkspaceAuthInfoResponse, PingRequest, SendErrorReportRequest, SendLocalSSHUserFlowStatusRequest } from '../../proto/typescript/ipc/v1/ipc';
 import { Disposable } from '../../common/dispose';
 export { ExtensionServiceDefinition } from '../../proto/typescript/ipc/v1/ipc';
 import { withServerApi } from '../../internalApi';
@@ -13,7 +13,7 @@ import { ILogService } from '../../services/logService';
 import { ISessionService } from '../../services/sessionService';
 import { CallContext, ServerError, Status } from 'nice-grpc-common';
 import { IHostService } from '../../services/hostService';
-import { Server, createServer } from 'nice-grpc';
+import { Server, createChannel, createClient, createServer } from 'nice-grpc';
 import { ITelemetryService, UserFlowTelemetryProperties } from '../../common/telemetry';
 import { ExperimentalSettings } from '../../experiments';
 import { Configuration } from '../../configuration';
@@ -24,6 +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';
 
 const phaseMap: Record<WorkspaceInstanceStatus_Phase, WorkspaceInstancePhase | undefined> = {
     [WorkspaceInstanceStatus_Phase.CREATING]: 'pending',
@@ -150,6 +151,10 @@ class ExtensionServiceImpl implements ExtensionServiceImplementation {
         });
         return {};
     }
+
+    async ping(_request: PingRequest, _context: CallContext): Promise<{}> {
+        return {};
+    }
 }
 
 export class ExtensionServiceServer extends Disposable {
@@ -198,3 +203,27 @@ export class ExtensionServiceServer extends Disposable {
         this.server.forceShutdown();
     }
 }
+
+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))) {
+        return true;
+    }
+    const extensionIpc = createClient(ExtensionServiceDefinition, createChannel(`127.0.0.1:${port}`));
+    await extensionIpc.ping({});
+    return true;
+}

src/proto/ipc/v1/ipc.proto

@@ -6,8 +6,12 @@ service ExtensionService {
     rpc GetWorkspaceAuthInfo (GetWorkspaceAuthInfoRequest) returns (GetWorkspaceAuthInfoResponse) {}
     rpc SendLocalSSHUserFlowStatus (SendLocalSSHUserFlowStatusRequest) returns (SendLocalSSHUserFlowStatusResponse) {}
     rpc SendErrorReport (SendErrorReportRequest) returns (SendErrorReportResponse) {}
+    rpc Ping (PingRequest) returns (PingResponse) {}
 }
 
+message PingRequest {}
+message PingResponse {}
+
 message SendErrorReportRequest {
     string workspace_id = 1;
     string instance_id = 2;

src/proto/typescript/ipc/v1/ipc.ts

@@ -4,6 +4,12 @@ import * as _m0 from "protobufjs/minimal";
 
 export const protobufPackage = "ipc.v1";
 
+export interface PingRequest {
+}
+
+export interface PingResponse {
+}
+
 export interface SendErrorReportRequest {
   workspaceId: string;
   instanceId: string;
@@ -206,6 +212,92 @@ export interface GetWorkspaceAuthInfoResponse {
   phase: string;
 }
 
+function createBasePingRequest(): PingRequest {
+  return {};
+}
+
+export const PingRequest = {
+  encode(_: PingRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PingRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePingRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(_: any): PingRequest {
+    return {};
+  },
+
+  toJSON(_: PingRequest): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create(base?: DeepPartial<PingRequest>): PingRequest {
+    return PingRequest.fromPartial(base ?? {});
+  },
+
+  fromPartial(_: DeepPartial<PingRequest>): PingRequest {
+    const message = createBasePingRequest();
+    return message;
+  },
+};
+
+function createBasePingResponse(): PingResponse {
+  return {};
+}
+
+export const PingResponse = {
+  encode(_: PingResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PingResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePingResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(_: any): PingResponse {
+    return {};
+  },
+
+  toJSON(_: PingResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create(base?: DeepPartial<PingResponse>): PingResponse {
+    return PingResponse.fromPartial(base ?? {});
+  },
+
+  fromPartial(_: DeepPartial<PingResponse>): PingResponse {
+    const message = createBasePingResponse();
+    return message;
+  },
+};
+
 function createBaseSendErrorReportRequest(): SendErrorReportRequest {
   return {
     workspaceId: "",
@@ -790,6 +882,14 @@ export const ExtensionServiceDefinition = {
       responseStream: false,
       options: {},
     },
+    ping: {
+      name: "Ping",
+      requestType: PingRequest,
+      requestStream: false,
+      responseType: PingResponse,
+      responseStream: false,
+      options: {},
+    },
   },
 } as const;
 
@@ -806,6 +906,7 @@ export interface ExtensionServiceImplementation<CallContextExt = {}> {
     request: SendErrorReportRequest,
     context: CallContext & CallContextExt,
   ): Promise<DeepPartial<SendErrorReportResponse>>;
+  ping(request: PingRequest, context: CallContext & CallContextExt): Promise<DeepPartial<PingResponse>>;
 }
 
 export interface ExtensionServiceClient<CallOptionsExt = {}> {
@@ -821,6 +922,7 @@ export interface ExtensionServiceClient<CallOptionsExt = {}> {
     request: DeepPartial<SendErrorReportRequest>,
     options?: CallOptions & CallOptionsExt,
   ): Promise<SendErrorReportResponse>;
+  ping(request: DeepPartial<PingRequest>, options?: CallOptions & CallOptionsExt): Promise<PingResponse>;
 }
 
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;

src/remoteConnector.ts

@@ -689,11 +689,20 @@ export class RemoteConnector extends Disposable {
 
 				let useLocalSSH = await this.experiments.getUseLocalSSHProxy();
 				if (useLocalSSH) {
-					// 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.flow = sshFlow;
-					this.localSSHService.prepareInitialize();
-					await this.localSSHService.initialized;
+					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(),
+					]);
+					if (!isExtensionServerReady) {
+						this.logService.error('Extension IPC server is not ready');
+						useLocalSSH = false;
+					}
 					if (!this.localSSHService.isSupportLocalSSH) {
 						this.logService.error('Local SSH is not supported on this platform');
 						useLocalSSH = false;

src/services/localSSHService.ts

@@ -16,12 +16,14 @@ import { getLocalSSHDomain } from '../remote';
 import { ITelemetryService, UserFlowTelemetryProperties } from '../common/telemetry';
 import { ISessionService } from './sessionService';
 import { WrapError } from '../common/utils';
+import { canExtensionServiceServerWork } from '../local-ssh/ipc/extensionServiceServer';
 
 export interface ILocalSSHService {
     flow?: UserFlowTelemetryProperties;
     isSupportLocalSSH: boolean;
     initialized: Promise<void>;
     prepareInitialize: () => void;
+    extensionServerReady: () => Promise<boolean>;
 }
 
 type FailedToInitializeCode = 'Unknown' | 'LockFailed' | string;
@@ -64,6 +66,30 @@ export class LocalSSHService extends Disposable implements ILocalSSHService {
             }
         }));
     }
+    async extensionServerReady(): Promise<boolean> {
+        try {
+            await canExtensionServiceServerWork();
+            return true;
+        } catch (e) {
+            const failureCode = 'ExtensionServerUnavailable';
+            const err = new WrapError('cannot ping extension ipc service server', e, failureCode);
+            const flow = {
+                ...this.flow,
+                flow: 'ping_extension_server',
+                gitpodHost: this.hostService.gitpodHost,
+                userId: this.sessionService.safeGetUserId(),
+                failureCode,
+            };
+            this.telemetryService.sendTelemetryException(err, {
+                gitpodHost: flow.gitpodHost,
+                userId: flow.userId,
+                instanceId: flow.instanceId,
+                workspaceId: flow.workspaceId,
+            });
+            this.telemetryService.sendUserFlowStatus('failure', flow);
+            return false;
+        }
+    }
 
     private async initialize() {
         let failureCode: FailedToInitializeCode | undefined;