Improve workspace restart (#75)

Author: jeanp413

package.json

@@ -175,10 +175,10 @@
 	},
 	"dependencies": {
 		"@bufbuild/connect-node": "^0.8.4",
-		"@gitpod/gitpod-protocol": "main",
-		"@gitpod/local-app-api-grpcweb": "main",
-		"@gitpod/public-api": "^0.1.5-main.6530",
-		"@gitpod/supervisor-api-grpc": "0.1.5-main.6711",
+		"@gitpod/gitpod-protocol": "main-gha",
+		"@gitpod/local-app-api-grpcweb": "main-gha",
+		"@gitpod/public-api": "main-gha",
+		"@gitpod/supervisor-api-grpc": "main-gha",
 		"@grpc/grpc-js": "^1.8.8",
 		"@improbable-eng/grpc-web-node-http-transport": "^0.14.0",
 		"@microsoft/dev-tunnels-ssh": "^3.11.8",

src/extension.ts

@@ -21,7 +21,7 @@ import { CommandManager } from './commandManager';
 import { SignInCommand } from './commands/account';
 import { ExportLogsCommand } from './commands/logs';
 import { Configuration } from './configuration';
-import { LocalSSHService } from './services/localSSHService';
+import { RemoteService } from './services/remoteService';
 
 // connect-web uses fetch api, so we need to polyfill it
 if (!global.fetch) {
@@ -38,13 +38,12 @@ const FIRST_INSTALL_KEY = 'gitpod-desktop.firstInstall';
 let telemetryService: TelemetryService | undefined;
 let remoteSession: RemoteSession | undefined;
 let logger: vscode.LogOutputChannel | undefined;
-let hostService: HostService | undefined;
 
 export async function activate(context: vscode.ExtensionContext) {
 	const extensionId = context.extension.id;
 	const packageJSON = context.extension.packageJSON;
 
-	let remoteConnectionInfo: { remoteAuthority: string; connectionInfo: SSHConnectionParams } | undefined;
+	let remoteConnectionInfo: { connectionInfo: SSHConnectionParams; remoteUri: vscode.Uri; sshDestStr: string } | undefined;
 	let success = false;
 	try {
 		logger = vscode.window.createOutputChannel('Gitpod', { log: true });
@@ -76,22 +75,22 @@ export async function activate(context: vscode.ExtensionContext) {
 		const authProvider = new GitpodAuthenticationProvider(context, logger, telemetryService, notificationService);
 		context.subscriptions.push(authProvider);
 
-		hostService = new HostService(context, notificationService, logger);
+		const hostService = new HostService(context, notificationService, logger);
 		context.subscriptions.push(hostService);
 
 		const sessionService = new SessionService(hostService, logger);
 		context.subscriptions.push(sessionService);
 
-		const localSSHService = new LocalSSHService(context, hostService, telemetryService, sessionService, logger);
-		context.subscriptions.push(localSSHService);
+		const remoteService = new RemoteService(context, hostService, telemetryService, sessionService, logger);
+		context.subscriptions.push(remoteService);
 
 		const experiments = new ExperimentalSettings(packageJSON.configcatKey, packageJSON.version, context, sessionService, hostService, logger);
 		context.subscriptions.push(experiments);
 
 		const settingsSync = new SettingsSync(commandManager, logger, telemetryService, notificationService);
 		context.subscriptions.push(settingsSync);
 
-		const remoteConnector = new RemoteConnector(context, sessionService, hostService, experiments, logger, telemetryService, notificationService, localSSHService);
+		const remoteConnector = new RemoteConnector(context, sessionService, hostService, experiments, logger, telemetryService, notificationService, remoteService);
 		context.subscriptions.push(remoteConnector);
 
 		context.subscriptions.push(vscode.window.registerUriHandler({
@@ -120,17 +119,17 @@ export async function activate(context: vscode.ExtensionContext) {
 			if (remoteConnectionInfo) {
 				commandManager.register({ id: 'gitpod.api.autoTunnel', execute: () => remoteConnector.autoTunnelCommand });
 
-				remoteSession = new RemoteSession(remoteConnectionInfo.remoteAuthority, remoteConnectionInfo.connectionInfo, context, hostService!, sessionService, settingsSync, experiments, logger!, telemetryService!, notificationService);
+				remoteSession = new RemoteSession(remoteConnectionInfo.connectionInfo, context, hostService, sessionService, settingsSync, experiments, logger!, telemetryService!, notificationService);
 				await remoteSession.initialize();
 			}
 		});
 
 		success = true;
 	} finally {
 		const rawActivateProperties = {
-			gitpodHost: remoteConnectionInfo?.connectionInfo.gitpodHost || hostService?.gitpodHost || Configuration.getGitpodHost(),
+			gitpodHost: remoteConnectionInfo?.connectionInfo.gitpodHost || Configuration.getGitpodHost(),
 			isRemoteSSH: String(vscode.env.remoteName === 'ssh-remote'),
-			remoteUri: vscode.workspace.workspaceFile?.toString() || vscode.workspace.workspaceFolders?.[0].uri.toString() || '',
+			remoteUri: remoteConnectionInfo?.remoteUri?.toString(),
 			workspaceId: remoteConnectionInfo?.connectionInfo.workspaceId || '',
 			instanceId: remoteConnectionInfo?.connectionInfo.instanceId || '',
 			debugWorkspace: remoteConnectionInfo ? String(!!remoteConnectionInfo.connectionInfo.debugWorkspace) : '',

src/heartbeat.ts

@@ -128,7 +128,7 @@ export class HeartbeatManager extends Disposable {
         this.ideHeartbeatTelemetryHandle = setInterval(() => this.sendIDEHeartbeatTelemetry(), HeartbeatManager.IDE_HEARTBEAT_INTERVAL);
 
         if (this.workspaceState) {
-            this._register(this.workspaceState.onWorkspaceStopped(() => {
+            this._register(this.workspaceState.onWorkspaceWillStop(() => {
                 this.logService.trace('Stopping heartbeat as workspace is not running');
                 this.stopHeartbeat();
                 this.stopIDEHeartbeatTelemetry();
@@ -151,7 +151,7 @@ export class HeartbeatManager extends Disposable {
         let heartbeatSucceed = false;
         try {
             if (this.workspaceState) {
-                if (this.workspaceState.isWorkspaceRunning()) {
+                if (this.workspaceState.isWorkspaceRunning) {
                     if (!wasClosed) {
                         await this.sessionService.getAPI().sendHeartbeat(this.connectionInfo.workspaceId);
                         this.logService.trace(`Send heartbeat, triggered by ${this.lastActivityEvent} event`);
@@ -234,7 +234,7 @@ export class HeartbeatManager extends Disposable {
         super.dispose();
         this.stopIDEHeartbeatTelemetry();
         this.stopHeartbeat();
-        if (this.workspaceState?.isWorkspaceRunning() ?? this.isWorkspaceRunning) {
+        if (this.workspaceState?.isWorkspaceRunning ?? this.isWorkspaceRunning) {
             this.sendIDEHeartbeatTelemetry();
             await this.sendHeartBeat(true);
         }

src/local-ssh/proxy.ts

@@ -8,7 +8,7 @@ import { NodeStream, SshClientCredentials, SshClientSession, SshDisconnectReason
 import { importKey, importKeyBytes } from '@microsoft/dev-tunnels-ssh-keys';
 import { ExtensionServiceDefinition, GetWorkspaceAuthInfoResponse } from '../proto/typescript/ipc/v1/ipc';
 import { Client, ClientError, Status, createChannel, createClient } from 'nice-grpc';
-import { retry } from '../common/async';
+import { retry, timeout } from '../common/async';
 import { WebSocket } from 'ws';
 import * as stream from 'stream';
 import { ILogService } from '../services/logService';
@@ -154,6 +154,9 @@ class WebSocketSSHProxy {
                         this.sendErrorReport(this.flow, err, 'failed to authenticate proxy with username: ' + e.username ?? '');
                     }
 
+                    // Await a few seconds to delay showing ssh extension error modal dialog
+                    await timeout(5000);
+
                     this.logService.error('failed to authenticate proxy with username: ' + e.username ?? '', err);
                     await session.close(SshDisconnectReason.byApplication, err.toString(), err instanceof Error ? err : undefined);
                     return null;

src/publicApi.ts

@@ -14,6 +14,7 @@ import * as vscode from 'vscode';
 import { Disposable } from './common/dispose';
 import { WorkspacesServiceClient, WorkspaceStatus } from './lib/gitpod/experimental/v1/workspaces.pb';
 import * as grpc from '@grpc/grpc-js';
+import { getErrorCode } from '@grpc/grpc-js/build/src/error';
 import { timeout } from './common/async';
 import { MetricsReporter, getConnectMetricsInterceptor, getGrpcMetricsInterceptor } from './metrics';
 import { ILogService } from './services/logService';
@@ -33,7 +34,8 @@ function isTelemetryEnabled(): boolean {
 }
 
 export interface IGitpodAPI {
-    getWorkspace(workspaceId: string): Promise<Workspace | undefined>;
+    getWorkspace(workspaceId: string): Promise<Workspace>;
+    startWorkspace(workspaceId: string): Promise<Workspace>;
     getOwnerToken(workspaceId: string): Promise<string>;
     getSSHKeys(): Promise<SSHKey[]>;
     sendHeartbeat(workspaceId: string): Promise<void>;
@@ -91,10 +93,14 @@ export class GitpodPublicApi extends Disposable implements IGitpodAPI {
             this.metricsReporter.startReporting();
         }
     }
-
-    async getWorkspace(workspaceId: string): Promise<Workspace | undefined> {
+    async getWorkspace(workspaceId: string): Promise<Workspace> {
         const response = await this.workspaceService.getWorkspace({ workspaceId });
-        return response.result;
+        return response.result!;
+    }
+
+    async startWorkspace(workspaceId: string): Promise<Workspace> {
+        const response = await this.workspaceService.startWorkspace({ workspaceId });
+        return response.result!;
     }
 
     async getOwnerToken(workspaceId: string): Promise<string> {
@@ -131,7 +137,16 @@ export class GitpodPublicApi extends Disposable implements IGitpodAPI {
                 clearTimeout(stopTimer);
                 await timeout(1000);
                 if (isDisposed) { return; }
-                [stream, stopTimer] = this._streamWorkspaceStatus(workspaceId, emitter, onStreamEnd);
+                this.grpcWorkspaceClient.getWorkspace({ workspaceId }, this.grpcMetadata, (err, resp) => {
+                    if (isDisposed) { return; }
+                    if (err) {
+                        this.logger.error(`Error in streamWorkspaceStatus(getWorkspace) for ${workspaceId}`, err);
+                        onStreamEnd();
+                        return;
+                    }
+                    emitter.fire(resp.result!.status!);
+                    [stream, stopTimer] = this._streamWorkspaceStatus(workspaceId, emitter, onStreamEnd);
+                });
             };
             let [stream, stopTimer] = this._streamWorkspaceStatus(workspaceId, emitter, onStreamEnd);
 
@@ -165,7 +180,9 @@ export class GitpodPublicApi extends Disposable implements IGitpodAPI {
             onStreamEnd();
         });
         stream.on('error', (err) => {
-            this.logger.trace(`Error in streamWorkspaceStatus for ${workspaceId}`, err);
+            if (getErrorCode(err) !== grpc.status.CANCELLED) {
+                this.logger.error(`Error in streamWorkspaceStatus for ${workspaceId}`, err);
+            }
         });
 
         // force reconnect after 7m to avoid unexpected 10m reconnection (internal error)

src/remote.ts

@@ -4,9 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { UserFlowTelemetryProperties } from './common/telemetry';
-import { INotificationService } from './services/notificationService';
-import { ILogService } from './services/logService';
 
 export interface SSHConnectionParams {
 	workspaceId: string;
@@ -16,11 +13,6 @@ export interface SSHConnectionParams {
 	connType?: 'local-app' | 'local-ssh' | 'ssh-gateway';
 }
 
-export interface WorkspaceRestartInfo {
-	workspaceId: string;
-	gitpodHost: string;
-}
-
 export class NoRunningInstanceError extends Error {
 	code = 'NoRunningInstanceError';
 	constructor(readonly workspaceId: string, readonly phase?: string) {
@@ -51,37 +43,19 @@ export class NoLocalSSHSupportError extends Error {
 
 export const SSH_DEST_KEY = 'ssh-dest:';
 
-export function getGitpodRemoteWindowConnectionInfo(context: vscode.ExtensionContext): { remoteAuthority: string; connectionInfo: SSHConnectionParams } | undefined {
+export function getGitpodRemoteWindowConnectionInfo(context: vscode.ExtensionContext): { connectionInfo: SSHConnectionParams; remoteUri: vscode.Uri; sshDestStr:string } | undefined {
 	const remoteUri = vscode.workspace.workspaceFile || vscode.workspace.workspaceFolders?.[0].uri;
 	if (vscode.env.remoteName === 'ssh-remote' && context.extension.extensionKind === vscode.ExtensionKind.UI && remoteUri) {
 		const [, sshDestStr] = remoteUri.authority.split('+');
 		const connectionInfo = context.globalState.get<SSHConnectionParams>(`${SSH_DEST_KEY}${sshDestStr}`);
 		if (connectionInfo) {
-			return { remoteAuthority: remoteUri.authority, connectionInfo };
+			return { connectionInfo, remoteUri, sshDestStr };
 		}
 	}
 
 	return undefined;
 }
 
-export async function showWsNotRunningDialog(workspaceId: string, gitpodHost: string, flow: UserFlowTelemetryProperties, notificationService: INotificationService, logService: ILogService) {
-	const msg = `Workspace ${workspaceId} is not running. Please restart the workspace.`;
-	logService.error(msg);
-
-	const workspaceUrl = new URL(gitpodHost);
-	workspaceUrl.pathname = '/start';
-	workspaceUrl.hash = workspaceId;
-
-	const openUrl = 'Restart workspace';
-	const resp = await notificationService.showErrorMessage(msg, { id: 'ws_not_running', flow, modal: true }, openUrl);
-	if (resp === openUrl) {
-		const opened = await vscode.env.openExternal(vscode.Uri.parse(workspaceUrl.toString()));
-		if (opened) {
-			vscode.commands.executeCommand('workbench.action.closeWindow');
-		}
-	}
-}
-
 export function getLocalSSHDomain(gitpodHost: string): string {
 	const scope = vscode.env.appName.includes('Insiders') ? 'vsi' : 'vss';
 	return `${scope}.` + (new URL(gitpodHost)).hostname;

src/remoteConnector.ts

@@ -39,7 +39,7 @@ import { ILogService } from './services/logService';
 import { IHostService } from './services/hostService';
 import { Configuration } from './configuration';
 import { WrapError, getServiceURL } from './common/utils';
-import { ILocalSSHService } from './services/localSSHService';
+import { IRemoteService } from './services/remoteService';
 
 interface LocalAppConfig {
 	gitpodHost: string;
@@ -110,7 +110,7 @@ export class RemoteConnector extends Disposable {
 		private readonly logService: ILogService,
 		private readonly telemetryService: ITelemetryService,
 		private readonly notificationService: INotificationService,
-		private readonly localSSHService: ILocalSSHService,
+		private readonly remoteService: IRemoteService,
 	) {
 		super();
 
@@ -701,10 +701,10 @@ export class RemoteConnector extends Disposable {
 						// If needed, revert local-app changes first
 						await this.updateRemoteSSHConfig(true, undefined);
 
-						this.localSSHService.flow = sshFlow;
+						this.remoteService.flow = sshFlow;
 						const [isSupportLocalSSH, isExtensionServerReady] = await Promise.all([
-							this.localSSHService.initialize(),
-							this.localSSHService.extensionServerReady()
+							this.remoteService.setupSSHProxy(),
+							this.remoteService.extensionServerReady()
 						]);
 						if (!isExtensionServerReady) {
 							throw new NoExtensionIPCServerError();