Do some refactor and cleanup (#43)

* Do some refactor and cleanup
* Fix workspaceStatusStreaming dispose

Co-authored-by: Huiwen <[email protected]>

Author: jeanp413

package.json

@@ -111,6 +111,11 @@
 				"command": "gitpod.installLocalExtensions",
 				"title": "Gitpod: Install Local Extensions...",
 				"enablement": "gitpod.inWorkspace == true"
+			},
+			{
+				"command": "gitpod.signIn",
+				"category": "Gitpod",
+				"title": "Sign In"
 			}
 		],
 		"menus": {

src/authentication.ts renamed to src/authentication/authentication.ts

@@ -5,13 +5,13 @@
 
 import * as vscode from 'vscode';
 import { v4 as uuid } from 'uuid';
-import Keychain from './common/keychain';
+import Keychain from '../common/keychain';
 import GitpodServer from './gitpodServer';
-import { arrayEquals } from './common/utils';
-import { Disposable } from './common/dispose';
-import TelemetryReporter from './telemetryReporter';
-import { UserFlowTelemetry } from './common/telemetry';
-import { NotificationService } from './notification';
+import { arrayEquals } from '../common/utils';
+import { Disposable } from '../common/dispose';
+import { ITelemetryService, UserFlowTelemetry } from '../services/telemetryService';
+import { INotificationService } from '../services/notificationService';
+import { ILogService } from '../services/logService';
 
 interface SessionData {
 	id: string;
@@ -26,7 +26,6 @@ interface SessionData {
 
 export default class GitpodAuthenticationProvider extends Disposable implements vscode.AuthenticationProvider {
 	private _sessionChangeEmitter = new vscode.EventEmitter<vscode.AuthenticationProviderAuthenticationSessionsChangeEvent>();
-	private _telemetry: TelemetryReporter;
 
 	private _gitpodServer!: GitpodServer;
 	private _keychain!: Keychain;
@@ -38,14 +37,12 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 
 	constructor(
 		private readonly context: vscode.ExtensionContext,
-		private readonly _logger: vscode.LogOutputChannel,
-		telemetry: TelemetryReporter,
-		private readonly notifications: NotificationService
+		private readonly logService: ILogService,
+		private readonly telemetryService: ITelemetryService,
+		private readonly notificationService: INotificationService
 	) {
 		super();
 
-		this._telemetry = telemetry;
-
 		this.reconcile();
 		this._register(vscode.workspace.onDidChangeConfiguration(e => {
 			if (e.affectsConfiguration('gitpod.host')) {
@@ -67,9 +64,9 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 		this._serviceUrl = gitpodHostUrl.toString().replace(/\/$/, '');
 		Object.assign(this.flow, { gitpodHost: this._serviceUrl });
 		this._gitpodServer?.dispose();
-		this._gitpodServer = new GitpodServer(this._serviceUrl, this._logger, this.notifications);
-		this._keychain = new Keychain(this.context, `gitpod.auth.${gitpodHostUrl.hostname}`, this._logger);
-		this._logger.info(`Started authentication provider for ${gitpodHost}`);
+		this._gitpodServer = new GitpodServer(this._serviceUrl, this.logService, this.notificationService);
+		this._keychain = new Keychain(this.context, `gitpod.auth.${gitpodHostUrl.hostname}`, this.logService);
+		this.logService.info(`Started authentication provider for ${gitpodHost}`);
 	}
 
 	get onDidChangeSessions() {
@@ -81,16 +78,16 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 		const sortedScopes = scopes?.sort() || [];
 		const validScopes = await this.fetchValidScopes();
 		const sortedFilteredScopes = sortedScopes.filter(s => !validScopes || validScopes.includes(s));
-		this._logger.info(`Getting sessions for ${sortedScopes.length ? sortedScopes.join(',') : 'all scopes'}${sortedScopes.length !== sortedFilteredScopes.length ? `, but valid scopes are ${sortedFilteredScopes.join(',')}` : ''}...`);
+		this.logService.info(`Getting sessions for ${sortedScopes.length ? sortedScopes.join(',') : 'all scopes'}${sortedScopes.length !== sortedFilteredScopes.length ? `, but valid scopes are ${sortedFilteredScopes.join(',')}` : ''}...`);
 		if (sortedScopes.length !== sortedFilteredScopes.length) {
-			this._logger.warn(`But valid scopes are ${sortedFilteredScopes.join(',')}, returning session with only valid scopes...`);
+			this.logService.warn(`But valid scopes are ${sortedFilteredScopes.join(',')}, returning session with only valid scopes...`);
 		}
 		const sessions = await this._sessionsPromise;
 		const finalSessions = sortedFilteredScopes.length
 			? sessions.filter(session => arrayEquals([...session.scopes].sort(), sortedFilteredScopes))
 			: sessions;
 
-		this._logger.info(`Got ${finalSessions.length} sessions for ${sortedFilteredScopes?.join(',') ?? 'all scopes'}...`);
+		this.logService.info(`Got ${finalSessions.length} sessions for ${sortedFilteredScopes?.join(',') ?? 'all scopes'}...`);
 		return finalSessions;
 	}
 
@@ -110,7 +107,7 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 				return this._validScopes;
 			}
 		} catch (e) {
-			this._logger.error(`Error fetching endpoint ${endpoint}`, e);
+			this.logService.error(`Error fetching endpoint ${endpoint}`, e);
 		}
 		return undefined;
 	}
@@ -127,7 +124,7 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 			const matchesExisting = previousSessions.some(s => s.id === session.id);
 			// Another window added a session to the keychain, add it to our state as well
 			if (!matchesExisting) {
-				this._logger.info('Adding session found in keychain');
+				this.logService.info('Adding session found in keychain');
 				added.push(session);
 			}
 		});
@@ -136,7 +133,7 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 			const matchesExisting = storedSessions.some(s => s.id === session.id);
 			// Another window has logged out, remove from our state
 			if (!matchesExisting) {
-				this._logger.info('Removing session no longer found in keychain');
+				this.logService.info('Removing session no longer found in keychain');
 				removed.push(session);
 			}
 		});
@@ -149,12 +146,12 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 	private async readSessions(): Promise<vscode.AuthenticationSession[]> {
 		let sessionData: SessionData[];
 		try {
-			this._logger.info('Reading sessions from keychain...');
+			this.logService.info('Reading sessions from keychain...');
 			const storedSessions = await this._keychain.getToken();
 			if (!storedSessions) {
 				return [];
 			}
-			this._logger.info('Got stored sessions!');
+			this.logService.info('Got stored sessions!');
 
 			try {
 				sessionData = JSON.parse(storedSessions);
@@ -163,7 +160,7 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 				throw e;
 			}
 		} catch (e) {
-			this._logger.error(`Error reading token: ${e}`);
+			this.logService.error(`Error reading token: ${e}`);
 			return [];
 		}
 
@@ -175,16 +172,16 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 			let userInfo: { id: string; accountName: string } | undefined;
 			try {
 				userInfo = await this._gitpodServer.getUserInfo(session.accessToken);
-				this._logger.info(`Verified session with the following scopes: ${scopesStr}`);
+				this.logService.info(`Verified session with the following scopes: ${scopesStr}`);
 			} catch (e) {
 				// Remove sessions that return unauthorized response
 				if (e.message === 'Unexpected server response: 401') {
 					return undefined;
 				}
-				this._logger.error(`Error while verifying session with the following scopes: ${scopesStr}`, e);
+				this.logService.error(`Error while verifying session with the following scopes: ${scopesStr}`, e);
 			}
 
-			this._logger.trace(`Read the following session from the keychain with the following scopes: ${scopesStr}`);
+			this.logService.trace(`Read the following session from the keychain with the following scopes: ${scopesStr}`);
 			return {
 				id: session.id,
 				account: {
@@ -203,7 +200,7 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 			.map(p => (p as PromiseFulfilledResult<vscode.AuthenticationSession | undefined>).value)
 			.filter(<T>(p?: T): p is T => Boolean(p));
 
-		this._logger.info(`Got ${verifiedSessions.length} verified sessions.`);
+		this.logService.info(`Got ${verifiedSessions.length} verified sessions.`);
 		if (verifiedSessions.length !== sessionData.length) {
 			await this.storeSessions(verifiedSessions);
 		}
@@ -212,10 +209,10 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 	}
 
 	private async storeSessions(sessions: vscode.AuthenticationSession[]): Promise<void> {
-		this._logger.info(`Storing ${sessions.length} sessions...`);
+		this.logService.info(`Storing ${sessions.length} sessions...`);
 		this._sessionsPromise = Promise.resolve(sessions);
 		await this._keychain.setToken(JSON.stringify(sessions));
-		this._logger.info(`Stored ${sessions.length} sessions!`);
+		this.logService.info(`Stored ${sessions.length} sessions!`);
 	}
 
 	public async createSession(scopes: string[]): Promise<vscode.AuthenticationSession> {
@@ -226,10 +223,10 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 			const validScopes = await this.fetchValidScopes();
 			const sortedFilteredScopes = sortedScopes.filter(s => !validScopes || validScopes.includes(s));
 			if (sortedScopes.length !== sortedFilteredScopes.length) {
-				this._logger.warn(`Creating session with only valid scopes ${sortedFilteredScopes.join(',')}, original scopes were ${sortedScopes.join(',')}`);
+				this.logService.warn(`Creating session with only valid scopes ${sortedFilteredScopes.join(',')}, original scopes were ${sortedScopes.join(',')}`);
 			}
 			flow.scopes = JSON.stringify(sortedFilteredScopes);
-			this._telemetry.sendUserFlowStatus('login', flow);
+			this.telemetryService.sendUserFlowStatus('login', flow);
 
 			const scopeString = sortedFilteredScopes.join(' ');
 			const token = await this._gitpodServer.login(scopeString, flow);
@@ -247,19 +244,19 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 
 			this._sessionChangeEmitter.fire({ added: [session], removed: [], changed: [] });
 
-			this._logger.info('Login success!');
+			this.logService.info('Login success!');
 
-			this._telemetry.sendUserFlowStatus('login_successful', flow);
+			this.telemetryService.sendUserFlowStatus('login_successful', flow);
 
 			return session;
 		} catch (e) {
 			// If login was cancelled, do not notify user.
 			if (e === 'Cancelled' || e.message === 'Cancelled') {
-				this._telemetry.sendUserFlowStatus('login_cancelled', flow);
+				this.telemetryService.sendUserFlowStatus('login_cancelled', flow);
 				throw e;
 			}
-			this.notifications.showErrorMessage(`Sign in failed: ${e}`, { flow, id: 'login_failed' });
-			this._logger.error(e);
+			this.notificationService.showErrorMessage(`Sign in failed: ${e}`, { flow, id: 'login_failed' });
+			this.logService.error(e);
 			throw e;
 		}
 	}
@@ -277,8 +274,8 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 	public async removeSession(id: string) {
 		const flow = { ...this.flow };
 		try {
-			this._telemetry.sendUserFlowStatus('logout', flow);
-			this._logger.info(`Logging out of ${id}`);
+			this.telemetryService.sendUserFlowStatus('logout', flow);
+			this.logService.info(`Logging out of ${id}`);
 
 			const sessions = await this._sessionsPromise;
 			const sessionIndex = sessions.findIndex(session => session.id === id);
@@ -291,12 +288,12 @@ export default class GitpodAuthenticationProvider extends Disposable implements
 
 				this._sessionChangeEmitter.fire({ added: [], removed: [session], changed: [] });
 			} else {
-				this._logger.error('Session not found');
+				this.logService.error('Session not found');
 			}
-			this._telemetry.sendUserFlowStatus('logout_successful', flow);
+			this.telemetryService.sendUserFlowStatus('logout_successful', flow);
 		} catch (e) {
-			this.notifications.showErrorMessage(`Sign out failed: ${e}`, { flow, id: 'logout_failed' });
-			this._logger.error(e);
+			this.notificationService.showErrorMessage(`Sign out failed: ${e}`, { flow, id: 'logout_failed' });
+			this.logService.error(e);
 			throw e;
 		}
 	}

src/gitpodServer.ts renamed to src/authentication/gitpodServer.ts

@@ -4,13 +4,14 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { PromiseAdapter, promiseFromEvent } from './common/utils';
-import { withServerApi } from './internalApi';
+import { PromiseAdapter, promiseFromEvent } from '../common/utils';
+import { withServerApi } from '../internalApi';
 import pkceChallenge from 'pkce-challenge';
 import { v4 as uuid } from 'uuid';
-import { Disposable } from './common/dispose';
-import { NotificationService } from './notification';
-import { UserFlowTelemetry } from './common/telemetry';
+import { Disposable } from '../common/dispose';
+import { INotificationService } from '../services/notificationService';
+import { UserFlowTelemetry } from '../services/telemetryService';
+import { ILogService } from '../services/logService';
 
 interface ExchangeTokenResponse {
 	token_type: 'Bearer';
@@ -20,7 +21,7 @@ interface ExchangeTokenResponse {
 	scope: string;
 }
 
-async function getUserInfo(token: string, serviceUrl: string, logger: vscode.LogOutputChannel) {
+async function getUserInfo(token: string, serviceUrl: string, logger: ILogService) {
 	const user = await withServerApi(token, serviceUrl, service => service.server.getLoggedInUser(), logger);
 	return {
 		id: user.id,
@@ -40,16 +41,16 @@ export default class GitpodServer extends Disposable {
 
 	constructor(
 		serviceUrl: string,
-		private readonly _logger: vscode.LogOutputChannel,
-		private readonly notifications: NotificationService
+		private readonly logService: ILogService,
+		private readonly notificationService: INotificationService
 	) {
 		super();
 
 		this._serviceUrl = serviceUrl.replace(/\/$/, '');
 	}
 
 	public async login(scopes: string, flow: UserFlowTelemetry): Promise<string> {
-		this._logger.info(`Logging in for the following scopes: ${scopes}`);
+		this.logService.info(`Logging in for the following scopes: ${scopes}`);
 
 		const callbackUri = await vscode.env.asExternalUri(vscode.Uri.parse(`${vscode.env.uriScheme}://gitpod.gitpod-desktop/complete-gitpod-auth`));
 
@@ -108,12 +109,12 @@ export default class GitpodServer extends Disposable {
 			const state = query.get('state');
 
 			if (!code) {
-				this._logger.error('No code in response.');
+				this.logService.error('No code in response.');
 				return;
 			}
 
 			if (!state) {
-				this._logger.error('No state in response.');
+				this.logService.error('No state in response.');
 				return;
 			}
 
@@ -124,17 +125,17 @@ export default class GitpodServer extends Disposable {
 				// 2. Before finishing 1, you trigger a sign in with a different set of scopes
 				// In this scenario we should just return and wait for the next UriHandler event
 				// to run as we are probably still waiting on the user to hit 'Continue'
-				this._logger.info('Nonce not found in accepted nonces. Skipping this execution...');
+				this.logService.info('Nonce not found in accepted nonces. Skipping this execution...');
 				return;
 			}
 
 			const verifier = this._pendingVerifiers.get(state);
 			if (!verifier) {
-				this._logger.error('Code verifier not found in memory.');
+				this.logService.error('Code verifier not found in memory.');
 				return;
 			}
 
-			this._logger.info('Exchanging code for token...');
+			this.logService.info('Exchanging code for token...');
 
 			const callbackUri = await vscode.env.asExternalUri(vscode.Uri.parse(`${vscode.env.uriScheme}://gitpod.gitpod-desktop${GitpodServer.AUTH_COMPLETE_PATH}`));
 			try {
@@ -150,7 +151,7 @@ export default class GitpodServer extends Disposable {
 				});
 
 				if (!exchangeTokenResponse.ok) {
-					this.notifications.showErrorMessage(`Couldn't connect (token exchange): ${exchangeTokenResponse.statusText}, ${await exchangeTokenResponse.text()}`, { flow, id: 'failed_to_exchange' });
+					this.notificationService.showErrorMessage(`Couldn't connect (token exchange): ${exchangeTokenResponse.statusText}, ${await exchangeTokenResponse.text()}`, { flow, id: 'failed_to_exchange' });
 					reject(exchangeTokenResponse.statusText);
 					return;
 				}
@@ -160,13 +161,13 @@ export default class GitpodServer extends Disposable {
 				const accessToken = JSON.parse(Buffer.from(jwtToken.split('.')[1], 'base64').toString())['jti'];
 				resolve(accessToken);
 			} catch (err) {
-				this.notifications.showErrorMessage(`Couldn't connect (token exchange): ${err}`, { flow, id: 'failed_to_exchange' });
+				this.notificationService.showErrorMessage(`Couldn't connect (token exchange): ${err}`, { flow, id: 'failed_to_exchange' });
 				reject(err);
 			}
 		};
 
 	public getUserInfo(token: string): Promise<{ id: string; accountName: string }> {
-		return getUserInfo(token, this._serviceUrl, this._logger);
+		return getUserInfo(token, this._serviceUrl, this.logService);
 	}
 
 	public handleUri(uri: vscode.Uri) {

src/commandManager.ts

@@ -0,0 +1,30 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Gitpod. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+
+export interface Command {
+	readonly id: string;
+
+	execute(...args: any[]): void | any;
+}
+
+export class CommandManager {
+	private readonly commands = new Map<string, vscode.Disposable>();
+
+	public register<T extends Command>(command: T): T {
+		if (!this.commands.has(command.id)) {
+			this.commands.set(command.id, vscode.commands.registerCommand(command.id, command.execute, command));
+		}
+		return command;
+	}
+
+	public dispose() {
+		for (const registration of this.commands.values()) {
+			registration.dispose();
+		}
+		this.commands.clear();
+	}
+}