Merge from vscode a348d103d1256a06a2c9b3f9b406298a9fef6898 (#15681)

* Merge from vscode a348d103d1256a06a2c9b3f9b406298a9fef6898 * Fixes and cleanup * Distro * Fix hygiene yarn * delete no yarn lock changes file * Fix hygiene * Fix layer check * Fix CI * Skip lib checks * Remove tests deleted in vs code * Fix tests * Distro * Fix tests and add removed extension point * Skip failing notebook tests for now * Disable broken tests and cleanup build folder * Update yarn.lock and fix smoke tests * Bump sqlite * fix contributed actions and file spacing * Fix user data path * Update yarn.locks Co-authored-by: ADS Merger <karlb@microsoft.com>
2026-01-13 17:22:15 -05:00 · 2021-06-17 08:17:11 -07:00
parent fdcb97c7f7
commit 3cb2f552a6
2582 changed files with 124827 additions and 87099 deletions
--- a/extensions/github-authentication/src/common/utils.ts
+++ b/extensions/github-authentication/src/common/utils.ts
@@ -3,7 +3,7 @@
 *  Licensed under the Source EULA. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

-import { Event, Disposable } from 'vscode';
+import { EventEmitter, Event, Disposable } from 'vscode';

 export function filterEvent<T>(event: Event<T>, filter: (e: T) => boolean): Event<T> {
 	return (listener, thisArgs = null, disposables?) => event(e => filter(e) && listener.call(thisArgs, e), null, disposables);
@@ -47,27 +47,54 @@ const passthrough = (value: any, resolve: (value?: any) => void) => resolve(valu
 * @param adapter controls resolution of the returned promise
 * @returns a promise that resolves or rejects as specified by the adapter
 */
-export async function promiseFromEvent<T, U>(
+export function promiseFromEvent<T, U>(
 	event: Event<T>,
-	adapter: PromiseAdapter<T, U> = passthrough): Promise<U> {
+	adapter: PromiseAdapter<T, U> = passthrough): { promise: Promise<U>, cancel: EventEmitter<void> } {
 	let subscription: Disposable;
-	return new Promise<U>((resolve, reject) =>
-		subscription = event((value: T) => {
-			try {
-				Promise.resolve(adapter(value, resolve, reject))
-					.catch(reject);
-			} catch (error) {
-				reject(error);
+	let cancel = new EventEmitter<void>();
+	return {
+		promise: new Promise<U>((resolve, reject) => {
+			cancel.event(_ => reject());
+			subscription = event((value: T) => {
+				try {
+					Promise.resolve(adapter(value, resolve, reject))
+						.catch(reject);
+				} catch (error) {
+					reject(error);
+				}
+			});
+		}).then(
+			(result: U) => {
+				subscription.dispose();
+				return result;
+			},
+			error => {
+				subscription.dispose();
+				throw error;
 			}
-		})
-	).then(
-		(result: U) => {
-			subscription.dispose();
-			return result;
-		},
-		error => {
-			subscription.dispose();
-			throw error;
-		}
-	);
+		),
+		cancel
+	};
+}
+
+export function arrayEquals<T>(one: ReadonlyArray<T> | undefined, other: ReadonlyArray<T> | undefined, itemEquals: (a: T, b: T) => boolean = (a, b) => a === b): boolean {
+	if (one === other) {
+		return true;
+	}
+
+	if (!one || !other) {
+		return false;
+	}
+
+	if (one.length !== other.length) {
+		return false;
+	}
+
+	for (let i = 0, len = one.length; i < len; i++) {
+		if (!itemEquals(one[i], other[i])) {
+			return false;
+		}
+	}
+
+	return true;
 }
--- a/extensions/github-authentication/src/experimentationService.ts
+++ b/extensions/github-authentication/src/experimentationService.ts
@@ -0,0 +1,73 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import TelemetryReporter from 'vscode-extension-telemetry';
+import { getExperimentationService, IExperimentationService, IExperimentationTelemetry, TargetPopulation } from 'vscode-tas-client';
+
+export class ExperimentationTelemetry implements IExperimentationTelemetry {
+	private sharedProperties: Record<string, string> = {};
+
+	constructor(private baseReporter: TelemetryReporter) { }
+
+	sendTelemetryEvent(eventName: string, properties?: Record<string, string>, measurements?: Record<string, number>) {
+		this.baseReporter.sendTelemetryEvent(
+			eventName,
+			{
+				...this.sharedProperties,
+				...properties,
+			},
+			measurements,
+		);
+	}
+
+	sendTelemetryErrorEvent(
+		eventName: string,
+		properties?: Record<string, string>,
+		_measurements?: Record<string, number>,
+	) {
+		this.baseReporter.sendTelemetryErrorEvent(eventName, {
+			...this.sharedProperties,
+			...properties,
+		});
+	}
+
+	setSharedProperty(name: string, value: string): void {
+		this.sharedProperties[name] = value;
+	}
+
+	postEvent(eventName: string, props: Map<string, string>): void {
+		const event: Record<string, string> = {};
+		for (const [key, value] of props) {
+			event[key] = value;
+		}
+		this.sendTelemetryEvent(eventName, event);
+	}
+
+	dispose(): Promise<any> {
+		return this.baseReporter.dispose();
+	}
+}
+
+function getTargetPopulation(): TargetPopulation {
+	switch (vscode.env.uriScheme) {
+		case 'vscode':
+			return TargetPopulation.Public;
+		case 'vscode-insiders':
+			return TargetPopulation.Insiders;
+		case 'vscode-exploration':
+			return TargetPopulation.Internal;
+		case 'code-oss':
+			return TargetPopulation.Team;
+		default:
+			return TargetPopulation.Public;
+	}
+}
+
+export async function createExperimentationService(context: vscode.ExtensionContext, telemetry: ExperimentationTelemetry): Promise<IExperimentationService> {
+	const id = context.extension.id;
+	const version = context.extension.packageJSON.version;
+	return getExperimentationService(id, version, getTargetPopulation(), telemetry, context.globalState);
+}
--- a/extensions/github-authentication/src/extension.ts
+++ b/extensions/github-authentication/src/extension.ts
@@ -8,13 +8,17 @@ import { GitHubAuthenticationProvider, onDidChangeSessions } from './github';
 import { uriHandler } from './githubServer';
 import Logger from './common/logger';
 import TelemetryReporter from 'vscode-extension-telemetry';
+import { createExperimentationService, ExperimentationTelemetry } from './experimentationService';

 export async function activate(context: vscode.ExtensionContext) {
 	const { name, version, aiKey } = require('../package.json') as { name: string, version: string, aiKey: string };
-	const telemetryReporter = new TelemetryReporter(name, version, aiKey);
+	const telemetryReporter = new ExperimentationTelemetry(new TelemetryReporter(name, version, aiKey));
+
+	const experimentationService = await createExperimentationService(context, telemetryReporter);
+	await experimentationService.initialFetch;

 	context.subscriptions.push(vscode.window.registerUriHandler(uriHandler));
-	const loginService = new GitHubAuthenticationProvider(context);
+	const loginService = new GitHubAuthenticationProvider(context, telemetryReporter);

 	await loginService.initialize(context);

@@ -24,17 +28,17 @@ export async function activate(context: vscode.ExtensionContext) {

 	context.subscriptions.push(vscode.authentication.registerAuthenticationProvider('github', 'GitHub', {
 		onDidChangeSessions: onDidChangeSessions.event,
-		getSessions: () => Promise.resolve(loginService.sessions),
-		login: async (scopeList: string[]) => {
+		getSessions: (scopes?: string[]) => loginService.getSessions(scopes),
+		createSession: async (scopeList: string[]) => {
 			try {
 				/* __GDPR__
 					"login" : { }
 				*/
 				telemetryReporter.sendTelemetryEvent('login');

-				const session = await loginService.login(scopeList.sort().join(' '));
+				const session = await loginService.createSession(scopeList.sort().join(' '));
 				Logger.info('Login success!');
-				onDidChangeSessions.fire({ added: [session.id], removed: [], changed: [] });
+				onDidChangeSessions.fire({ added: [session], removed: [], changed: [] });
 				return session;
 			} catch (e) {
 				// If login was cancelled, do not notify user.
@@ -56,15 +60,17 @@ export async function activate(context: vscode.ExtensionContext) {
 				throw e;
 			}
 		},
-		logout: async (id: string) => {
+		removeSession: async (id: string) => {
 			try {
 				/* __GDPR__
 					"logout" : { }
 				*/
 				telemetryReporter.sendTelemetryEvent('logout');

-				await loginService.logout(id);
-				onDidChangeSessions.fire({ added: [], removed: [id], changed: [] });
+				const session = await loginService.removeSession(id);
+				if (session) {
+					onDidChangeSessions.fire({ added: [], removed: [session], changed: [] });
+				}
 			} catch (e) {
 				/* __GDPR__
 					"logoutFailed" : { }
--- a/extensions/github-authentication/src/github.ts
+++ b/extensions/github-authentication/src/github.ts
@@ -8,6 +8,8 @@ import { v4 as uuid } from 'uuid';
 import { Keychain } from './common/keychain';
 import { GitHubServer, NETWORK_ERROR } from './githubServer';
 import Logger from './common/logger';
+import { arrayEquals } from './common/utils';
+import { ExperimentationTelemetry } from './experimentationService';

 export const onDidChangeSessions = new vscode.EventEmitter<vscode.AuthenticationProviderAuthenticationSessionsChangeEvent>();

@@ -24,12 +26,13 @@ interface SessionData {

 export class GitHubAuthenticationProvider {
 	private _sessions: vscode.AuthenticationSession[] = [];
-	private _githubServer = new GitHubServer();
+	private _githubServer: GitHubServer;

 	private _keychain: Keychain;

-	constructor(context: vscode.ExtensionContext) {
+	constructor(context: vscode.ExtensionContext, telemetryReporter: ExperimentationTelemetry) {
 		this._keychain = new Keychain(context);
+		this._githubServer = new GitHubServer(telemetryReporter);
 	}

 	public async initialize(context: vscode.ExtensionContext): Promise<void> {
@@ -43,11 +46,18 @@ export class GitHubAuthenticationProvider {
 		context.subscriptions.push(context.secrets.onDidChange(() => this.checkForUpdates()));
 	}

+	async getSessions(scopes?: string[]): Promise<vscode.AuthenticationSession[]> {
+		return scopes
+			? this._sessions.filter(session => arrayEquals(session.scopes, scopes))
+			: this._sessions;
+	}
+
 	private async verifySessions(): Promise<void> {
 		const verifiedSessions: vscode.AuthenticationSession[] = [];
 		const verificationPromises = this._sessions.map(async session => {
 			try {
 				await this._githubServer.getUserInfo(session.accessToken);
+				this._githubServer.checkIsEdu(session.accessToken);
 				verifiedSessions.push(session);
 			} catch (e) {
 				// Remove sessions that return unauthorized response
@@ -74,8 +84,8 @@ export class GitHubAuthenticationProvider {
 			return;
 		}

-		const added: string[] = [];
-		const removed: string[] = [];
+		const added: vscode.AuthenticationSession[] = [];
+		const removed: vscode.AuthenticationSession[] = [];

 		storedSessions.forEach(session => {
 			const matchesExisting = this._sessions.some(s => s.id === session.id);
@@ -83,7 +93,7 @@ export class GitHubAuthenticationProvider {
 			if (!matchesExisting) {
 				Logger.info('Adding session found in keychain');
 				this._sessions.push(session);
-				added.push(session.id);
+				added.push(session);
 			}
 		});

@@ -97,7 +107,7 @@ export class GitHubAuthenticationProvider {
 					this._sessions.splice(sessionIndex, 1);
 				}

-				removed.push(session.id);
+				removed.push(session);
 			}
 		});

@@ -153,9 +163,10 @@ export class GitHubAuthenticationProvider {
 		return this._sessions;
 	}

-	public async login(scopes: string): Promise<vscode.AuthenticationSession> {
+	public async createSession(scopes: string): Promise<vscode.AuthenticationSession> {
 		const token = await this._githubServer.login(scopes);
 		const session = await this.tokenToSession(token, scopes.split(' '));
+		this._githubServer.checkIsEdu(token);
 		await this.setToken(session);
 		return session;
 	}
@@ -185,15 +196,18 @@ export class GitHubAuthenticationProvider {
 		await this.storeSessions();
 	}

-	public async logout(id: string) {
+	public async removeSession(id: string): Promise<vscode.AuthenticationSession | undefined> {
 		Logger.info(`Logging out of ${id}`);
 		const sessionIndex = this._sessions.findIndex(session => session.id === id);
+		let session: vscode.AuthenticationSession | undefined;
 		if (sessionIndex > -1) {
+			session = this._sessions[sessionIndex];
 			this._sessions.splice(sessionIndex, 1);
 		} else {
 			Logger.error('Session not found');
 		}

 		await this.storeSessions();
+		return session;
 	}
 }
--- a/extensions/github-authentication/src/githubServer.ts
+++ b/extensions/github-authentication/src/githubServer.ts
@@ -9,11 +9,13 @@ import fetch, { Response } from 'node-fetch';
 import { v4 as uuid } from 'uuid';
 import { PromiseAdapter, promiseFromEvent } from './common/utils';
 import Logger from './common/logger';
+import { ExperimentationTelemetry } from './experimentationService';

 const localize = nls.loadMessageBundle();

 export const NETWORK_ERROR = 'network error';
 const AUTH_RELAY_SERVER = 'vscode-auth.github.com';
+// const AUTH_RELAY_STAGING_SERVER = 'client-auth-staging-14a768b.herokuapp.com';

 class UriEventHandler extends vscode.EventEmitter<vscode.Uri> implements vscode.UriHandler {
 	public handleUri(uri: vscode.Uri) {
@@ -39,10 +41,18 @@ export class GitHubServer {
 	private _statusBarItem: vscode.StatusBarItem | undefined;

 	private _pendingStates = new Map<string, string[]>();
-	private _codeExchangePromises = new Map<string, Promise<string>>();
+	private _codeExchangePromises = new Map<string, { promise: Promise<string>, cancel: vscode.EventEmitter<void> }>();
+
+	constructor(private readonly telemetryReporter: ExperimentationTelemetry) { }

 	private isTestEnvironment(url: vscode.Uri): boolean {
-		return url.authority === 'vscode-web-test-playground.azurewebsites.net' || url.authority.startsWith('localhost:');
+		return /\.azurewebsites\.net$/.test(url.authority) || url.authority.startsWith('localhost:');
+	}
+
+	// TODO@joaomoreno TODO@RMacfarlane
+	private async isNoCorsEnvironment(): Promise<boolean> {
+		const uri = await vscode.env.asExternalUri(vscode.Uri.parse(`${vscode.env.uriScheme}://vscode.github-authentication/did-authenticate`));
+		return uri.scheme === 'https' && /^vscode\./.test(uri.authority);
 	}

 	public async login(scopes: string): Promise<string> {
@@ -50,7 +60,10 @@ export class GitHubServer {
 		this.updateStatusBarItem(true);

 		const state = uuid();
-		const callbackUri = await vscode.env.asExternalUri(vscode.Uri.parse(`${vscode.env.uriScheme}://vscode.github-authentication/did-authenticate`));
+
+		// TODO@joaomoreno TODO@RMacfarlane
+		const nocors = await this.isNoCorsEnvironment();
+		const callbackUri = await vscode.env.asExternalUri(vscode.Uri.parse(`${vscode.env.uriScheme}://vscode.github-authentication/did-authenticate${nocors ? '?nocors=true' : ''}`));

 		if (this.isTestEnvironment(callbackUri)) {
 			const token = await vscode.window.showInputBox({ prompt: 'GitHub Personal Access Token', ignoreFocusOut: true });
@@ -77,23 +90,30 @@ export class GitHubServer {
 			const existingStates = this._pendingStates.get(scopes) || [];
 			this._pendingStates.set(scopes, [...existingStates, state]);

-			const uri = vscode.Uri.parse(`https://${AUTH_RELAY_SERVER}/authorize/?callbackUri=${encodeURIComponent(callbackUri.toString())}&scope=${scopes}&state=${state}&responseType=code&authServer=https://github.com`);
+			const uri = vscode.Uri.parse(`https://${AUTH_RELAY_SERVER}/authorize/?callbackUri=${encodeURIComponent(callbackUri.toString())}&scope=${scopes}&state=${state}&responseType=code&authServer=https://github.com${nocors ? '&nocors=true' : ''}`);
 			await vscode.env.openExternal(uri);
 		}

 		// Register a single listener for the URI callback, in case the user starts the login process multiple times
 		// before completing it.
-		let existingPromise = this._codeExchangePromises.get(scopes);
-		if (!existingPromise) {
-			existingPromise = promiseFromEvent(uriHandler.event, this.exchangeCodeForToken(scopes));
-			this._codeExchangePromises.set(scopes, existingPromise);
+		let codeExchangePromise = this._codeExchangePromises.get(scopes);
+		if (!codeExchangePromise) {
+			codeExchangePromise = promiseFromEvent(uriHandler.event, this.exchangeCodeForToken(scopes));
+			this._codeExchangePromises.set(scopes, codeExchangePromise);
 		}

 		return Promise.race([
-			existingPromise,
-			promiseFromEvent<string | undefined, string>(onDidManuallyProvideToken.event, (token: string | undefined): string => { if (!token) { throw new Error('Cancelled'); } return token; })
+			codeExchangePromise.promise,
+			promiseFromEvent<string | undefined, string>(onDidManuallyProvideToken.event, (token: string | undefined, resolve, reject): void => {
+				if (!token) {
+					reject('Cancelled');
+				} else {
+					resolve(token);
+				}
+			}).promise
 		]).finally(() => {
 			this._pendingStates.delete(scopes);
+			codeExchangePromise?.cancel.fire();
 			this._codeExchangePromises.delete(scopes);
 			this.updateStatusBarItem(false);
 		});
@@ -111,23 +131,36 @@ export class GitHubServer {
 				return;
 			}

-			try {
-				const result = await fetch(`https://${AUTH_RELAY_SERVER}/token?code=${code}&state=${query.state}`, {
-					method: 'POST',
-					headers: {
-						Accept: 'application/json'
-					}
-				});
+			const url = `https://${AUTH_RELAY_SERVER}/token?code=${code}&state=${query.state}`;

-				if (result.ok) {
-					const json = await result.json();
+			// TODO@joao: remove
+			if (query.nocors) {
+				try {
+					const json: any = await vscode.commands.executeCommand('_workbench.fetchJSON', url, 'POST');
 					Logger.info('Token exchange success!');
 					resolve(json.access_token);
-				} else {
-					reject(result.statusText);
+				} catch (err) {
+					reject(err);
+				}
+			} else {
+				try {
+					const result = await fetch(url, {
+						method: 'POST',
+						headers: {
+							Accept: 'application/json'
+						}
+					});
+
+					if (result.ok) {
+						const json = await result.json();
+						Logger.info('Token exchange success!');
+						resolve(json.access_token);
+					} else {
+						reject(result.statusText);
+					}
+				} catch (ex) {
+					reject(ex);
 				}
-			} catch (ex) {
-				reject(ex);
 			}
 		};

@@ -153,7 +186,7 @@ export class GitHubServer {
 		}

 		try {
-			const uri = vscode.Uri.parse(uriOrToken);
+			const uri = vscode.Uri.parse(uriOrToken.trim());
 			if (!uri.scheme || uri.scheme === 'file') { throw new Error; }
 			uriHandler.handleUri(uri);
 		} catch (e) {
@@ -210,4 +243,42 @@ export class GitHubServer {
 			throw new Error(result.statusText);
 		}
 	}
+
+	public async checkIsEdu(token: string): Promise<void> {
+		const nocors = await this.isNoCorsEnvironment();
+
+		if (nocors) {
+			return;
+		}
+
+		try {
+			const result = await fetch('https://education.github.com/api/user', {
+				headers: {
+					Authorization: `token ${token}`,
+					'faculty-check-preview': 'true',
+					'User-Agent': 'Visual-Studio-Code'
+				}
+			});
+
+			if (result.ok) {
+				const json: { student: boolean, faculty: boolean } = await result.json();
+
+				/* __GDPR__
+					"session" : {
+						"isEdu": { "classification": "NonIdentifiableDemographicInfo", "purpose": "FeatureInsight" }
+					}
+				*/
+				this.telemetryReporter.sendTelemetryEvent('session', {
+					isEdu: json.student
+						? 'student'
+						: json.faculty
+							? 'faculty'
+							: 'none'
+				});
+			}
+		} catch (e) {
+			// No-op
+		}
+
+	}
 }