Merge commit 'be3e8236086165e5e45a5a10783823874b3f3ebd' as 'lib/vscode'

lib/vscode/extensions/vscode-test-resolver/.gitignore

@@ -0,0 +1,2 @@
+out
+node_modules

lib/vscode/extensions/vscode-test-resolver/.vscode/launch.json

@@ -0,0 +1,22 @@
+// A launch configuration that compiles the extension and then opens it inside a new window
+// Use IntelliSense to learn about possible attributes.
+// Hover to view descriptions of existing attributes.
+// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Extension",
+            "type": "extensionHost",
+            "request": "launch",
+            "runtimeExecutable": "${execPath}",
+            "args": [
+                "--extensionDevelopmentPath=${workspaceFolder}",
+                "--remote=test+test"
+            ],
+            "outFiles": [
+                "${workspaceFolder}/out/**/*.js"
+            ]
+        }
+    ]
+}

lib/vscode/extensions/vscode-test-resolver/.vscodeignore

@@ -0,0 +1,6 @@
+.vscode/**
+typings/**
+**/*.ts
+**/*.map
+.gitignore
+tsconfig.json

lib/vscode/extensions/vscode-test-resolver/package.json

@@ -0,0 +1,93 @@
+{
+	"name": "vscode-test-resolver",
+	"description": "Test resolver for VS Code",
+	"version": "0.0.1",
+	"publisher": "vscode",
+	"enableProposedApi": true,
+	"private": true,
+	"engines": {
+		"vscode": "^1.25.0"
+	},
+	"extensionKind": [ "ui" ],
+	"scripts": {
+		"compile": "node ./node_modules/vscode/bin/compile -watch -p ./",
+		"vscode:prepublish": "node ../../node_modules/gulp/bin/gulp.js --gulpfile ../../build/gulpfile.extensions.js compile-extension:vscode-test-resolver"
+	},
+	"activationEvents": [
+		"onResolveRemoteAuthority:test",
+		"onCommand:vscode-testresolver.newWindow",
+		"onCommand:vscode-testresolver.newWindowWithError",
+		"onCommand:vscode-testresolver.showLog"
+	],
+	"main": "./out/extension",
+	"devDependencies": {
+		"@types/node": "^12.11.7",
+		"vscode": "1.1.5"
+	},
+	"contributes": {
+		"resourceLabelFormatters": [
+			{
+				"scheme": "vscode-remote",
+				"authority": "test+*",
+				"formatting": {
+					"label": "${path}",
+					"separator": "/",
+					"tildify": true,
+					"workspaceSuffix": "TestResolver"
+				}
+			}
+		],
+		"commands": [
+			{
+				"title": "New Window",
+				"category": "Remote-TestResolver",
+				"command": "vscode-testresolver.newWindow"
+			},
+			{
+				"title": "Show Log",
+				"category": "Remote-TestResolver",
+				"command": "vscode-testresolver.showLog"
+			}
+		],
+		"menus": {
+			"statusBar/windowIndicator": [
+				{
+					"command": "vscode-testresolver.newWindow",
+					"when": "!remoteName",
+					"group": "9_local_testresolver@2"
+				},
+				{
+					"command": "vscode-testresolver.showLog",
+					"when": "remoteName == test",
+					"group": "1_remote_testresolver_open@3"
+				},
+				{
+					"command": "vscode-testresolver.newWindow",
+					"when": "remoteName == test",
+					"group": "1_remote_testresolver_open@1"
+				}
+			]
+		},
+		"configuration": {
+			"properties": {
+				"testresolver.startupDelay": {
+					"description": "If set, the resolver will delay for the given amount of seconds. Use ths setting for testing a slow resolver",
+					"type": "number",
+					"default": 0
+				},
+				"testresolver.startupError": {
+					"description": "If set, the resolver will fail. Use ths setting for testing the failure of a resolver.",
+					"type": "boolean",
+					"default": false
+				},
+				"testresolver.pause": {
+					"description": "If set, connection is paused",
+					"type": "boolean",
+					"default": false
+				}
+			}
+		}
+	}
+
+
+}

lib/vscode/extensions/vscode-test-resolver/scripts/terminateProcess.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+terminateTree() {
+	for cpid in $(/usr/bin/pgrep -P $1); do
+		terminateTree $cpid
+	done
+	kill -9 $1 > /dev/null 2>&1
+}
+
+for pid in $*; do
+	terminateTree $pid
+done

lib/vscode/extensions/vscode-test-resolver/src/download.ts

@@ -0,0 +1,117 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as https from 'https';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as cp from 'child_process';
+import { parse as parseUrl } from 'url';
+
+function ensureFolderExists(loc: string) {
+	if (!fs.existsSync(loc)) {
+		const parent = path.dirname(loc);
+		if (parent) {
+			ensureFolderExists(parent);
+		}
+		fs.mkdirSync(loc);
+	}
+}
+
+function getDownloadUrl(updateUrl: string, commit: string, platform: string, quality: string): string {
+	return `${updateUrl}/commit:${commit}/server-${platform}/${quality}`;
+}
+
+async function downloadVSCodeServerArchive(updateUrl: string, commit: string, quality: string, destDir: string): Promise<string> {
+	ensureFolderExists(destDir);
+
+	const platform = process.platform === 'win32' ? 'win32-x64' : process.platform === 'darwin' ? 'darwin' : 'linux-x64';
+	const downloadUrl = getDownloadUrl(updateUrl, commit, platform, quality);
+
+	return new Promise((resolve, reject) => {
+		console.log(`Downloading VS Code Server from: ${downloadUrl}`);
+		const requestOptions: https.RequestOptions = parseUrl(downloadUrl);
+
+		https.get(requestOptions, res => {
+			if (res.statusCode !== 302) {
+				reject('Failed to get VS Code server archive location');
+			}
+			const archiveUrl = res.headers.location;
+			if (!archiveUrl) {
+				reject('Failed to get VS Code server archive location');
+				return;
+			}
+
+			const archiveRequestOptions: https.RequestOptions = parseUrl(archiveUrl);
+			if (archiveUrl.endsWith('.zip')) {
+				const archivePath = path.resolve(destDir, `vscode-server-${commit}.zip`);
+				const outStream = fs.createWriteStream(archivePath);
+				outStream.on('close', () => {
+					resolve(archivePath);
+				});
+				https.get(archiveRequestOptions, res => {
+					res.pipe(outStream);
+				});
+			} else {
+				const zipPath = path.resolve(destDir, `vscode-server-${commit}.tgz`);
+				const outStream = fs.createWriteStream(zipPath);
+				https.get(archiveRequestOptions, res => {
+					res.pipe(outStream);
+				});
+				outStream.on('close', () => {
+					resolve(zipPath);
+				});
+			}
+		});
+	});
+}
+
+/**
+ * Unzip a .zip or .tar.gz VS Code archive
+ */
+function unzipVSCodeServer(vscodeArchivePath: string, extractDir: string) {
+	if (vscodeArchivePath.endsWith('.zip')) {
+		const tempDir = fs.mkdtempSync('vscode-server');
+		if (process.platform === 'win32') {
+			cp.spawnSync('powershell.exe', [
+				'-NoProfile',
+				'-ExecutionPolicy', 'Bypass',
+				'-NonInteractive',
+				'-NoLogo',
+				'-Command',
+				`Microsoft.PowerShell.Archive\\Expand-Archive -Path "${vscodeArchivePath}" -DestinationPath "${tempDir}"`
+			]);
+		} else {
+			cp.spawnSync('unzip', [vscodeArchivePath, '-d', `${tempDir}`]);
+		}
+		fs.renameSync(path.join(tempDir, process.platform === 'win32' ? 'vscode-server-win32-x64' : 'vscode-server-darwin'), extractDir);
+	} else {
+		// tar does not create extractDir by default
+		if (!fs.existsSync(extractDir)) {
+			fs.mkdirSync(extractDir);
+		}
+		cp.spawnSync('tar', ['-xzf', vscodeArchivePath, '-C', extractDir, '--strip-components', '1']);
+	}
+}
+
+export async function downloadAndUnzipVSCodeServer(updateUrl: string, commit: string, quality: string = 'stable', destDir: string): Promise<string> {
+
+	const extractDir = path.join(destDir, commit);
+	if (fs.existsSync(extractDir)) {
+		console.log(`Found ${extractDir}. Skipping download.`);
+	} else {
+		console.log(`Downloading VS Code Server ${quality} - ${commit} into ${extractDir}.`);
+		try {
+			const vscodeArchivePath = await downloadVSCodeServerArchive(updateUrl, commit, quality, destDir);
+			if (fs.existsSync(vscodeArchivePath)) {
+				unzipVSCodeServer(vscodeArchivePath, extractDir);
+				// Remove archive
+				fs.unlinkSync(vscodeArchivePath);
+			}
+		} catch (err) {
+			throw Error(`Failed to download and unzip VS Code ${quality} - ${commit}`);
+		}
+	}
+	return Promise.resolve(extractDir);
+}

lib/vscode/extensions/vscode-test-resolver/src/extension.ts

@@ -0,0 +1,289 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 * as cp from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as net from 'net';
+import { downloadAndUnzipVSCodeServer } from './download';
+import { terminateProcess } from './util/processes';
+
+let extHostProcess: cp.ChildProcess | undefined;
+const enum CharCode {
+	Backspace = 8,
+	LineFeed = 10
+}
+
+let outputChannel: vscode.OutputChannel;
+
+export function activate(context: vscode.ExtensionContext) {
+
+	function doResolve(_authority: string, progress: vscode.Progress<{ message?: string; increment?: number }>): Promise<vscode.ResolvedAuthority> {
+		const serverPromise = new Promise<vscode.ResolvedAuthority>(async (res, rej) => {
+			progress.report({ message: 'Starting Test Resolver' });
+			outputChannel = vscode.window.createOutputChannel('TestResolver');
+
+			let isResolved = false;
+			async function processError(message: string) {
+				outputChannel.appendLine(message);
+				if (!isResolved) {
+					isResolved = true;
+					outputChannel.show();
+
+					const result = await vscode.window.showErrorMessage(message, { modal: true }, ...getActions());
+					if (result) {
+						await result.execute();
+					}
+					rej(vscode.RemoteAuthorityResolverError.NotAvailable(message, true));
+				}
+			}
+
+			let lastProgressLine = '';
+			function processOutput(output: string) {
+				outputChannel.append(output);
+				for (let i = 0; i < output.length; i++) {
+					const chr = output.charCodeAt(i);
+					if (chr === CharCode.LineFeed) {
+						const match = lastProgressLine.match(/Extension host agent listening on (\d+)/);
+						if (match) {
+							isResolved = true;
+							res(new vscode.ResolvedAuthority('localhost', parseInt(match[1], 10))); // success!
+						}
+						lastProgressLine = '';
+					} else if (chr === CharCode.Backspace) {
+						lastProgressLine = lastProgressLine.substr(0, lastProgressLine.length - 1);
+					} else {
+						lastProgressLine += output.charAt(i);
+					}
+				}
+			}
+			const delay = getConfiguration('startupDelay');
+			if (typeof delay === 'number') {
+				let remaining = Math.ceil(delay);
+				outputChannel.append(`Delaying startup by ${remaining} seconds (configured by "testresolver.startupDelay").`);
+				while (remaining > 0) {
+					progress.report({ message: `Delayed resolving: Remaining ${remaining}s` });
+					await (sleep(1000));
+					remaining--;
+				}
+			}
+
+			if (getConfiguration('startupError') === true) {
+				processError('Test Resolver failed for testing purposes (configured by "testresolver.startupError").');
+				return;
+			}
+
+			const { updateUrl, commit, quality, serverDataFolderName, dataFolderName } = getProductConfiguration();
+			const commandArgs = ['--port=0', '--disable-telemetry'];
+			const env = getNewEnv();
+			const remoteDataDir = process.env['TESTRESOLVER_DATA_FOLDER'] || path.join(os.homedir(), serverDataFolderName || `${dataFolderName}-testresolver`);
+			env['VSCODE_AGENT_FOLDER'] = remoteDataDir;
+			outputChannel.appendLine(`Using data folder at ${remoteDataDir}`);
+
+			if (!commit) { // dev mode
+				const serverCommand = process.platform === 'win32' ? 'server.bat' : 'server.sh';
+				const vscodePath = path.resolve(path.join(context.extensionPath, '..', '..'));
+				const serverCommandPath = path.join(vscodePath, 'resources', 'server', 'bin-dev', serverCommand);
+				extHostProcess = cp.spawn(serverCommandPath, commandArgs, { env, cwd: vscodePath });
+			} else {
+				const serverCommand = process.platform === 'win32' ? 'server.cmd' : 'server.sh';
+				let serverLocation = env['VSCODE_REMOTE_SERVER_PATH']; // support environment variable to specify location of server on disk
+				if (!serverLocation) {
+					const serverBin = path.join(remoteDataDir, 'bin');
+					progress.report({ message: 'Installing VSCode Server' });
+					serverLocation = await downloadAndUnzipVSCodeServer(updateUrl, commit, quality, serverBin);
+				}
+
+				outputChannel.appendLine(`Using server build at ${serverLocation}`);
+
+				extHostProcess = cp.spawn(path.join(serverLocation, serverCommand), commandArgs, { env, cwd: serverLocation });
+			}
+			extHostProcess.stdout!.on('data', (data: Buffer) => processOutput(data.toString()));
+			extHostProcess.stderr!.on('data', (data: Buffer) => processOutput(data.toString()));
+			extHostProcess.on('error', (error: Error) => {
+				processError(`server failed with error:\n${error.message}`);
+				extHostProcess = undefined;
+			});
+			extHostProcess.on('close', (code: number) => {
+				processError(`server closed unexpectedly.\nError code: ${code}`);
+				extHostProcess = undefined;
+			});
+			context.subscriptions.push({
+				dispose: () => {
+					if (extHostProcess) {
+						terminateProcess(extHostProcess, context.extensionPath);
+					}
+				}
+			});
+		});
+		return serverPromise.then(serverAddr => {
+			return new Promise<vscode.ResolvedAuthority>(async (res, _rej) => {
+				const proxyServer = net.createServer(proxySocket => {
+					outputChannel.appendLine(`Proxy connection accepted`);
+					let remoteReady = true, localReady = true;
+					const remoteSocket = net.createConnection({ port: serverAddr.port });
+
+					let isDisconnected = getConfiguration('pause') === true;
+					vscode.workspace.onDidChangeConfiguration(_ => {
+						let newIsDisconnected = getConfiguration('pause') === true;
+						if (isDisconnected !== newIsDisconnected) {
+							outputChannel.appendLine(`Connection state: ${newIsDisconnected ? 'open' : 'paused'}`);
+							isDisconnected = newIsDisconnected;
+							if (!isDisconnected) {
+								outputChannel.appendLine(`Resume remote and proxy sockets.`);
+								if (remoteSocket.isPaused() && localReady) {
+									remoteSocket.resume();
+								}
+								if (proxySocket.isPaused() && remoteReady) {
+									proxySocket.resume();
+								}
+							} else {
+								outputChannel.appendLine(`Pausing remote and proxy sockets.`);
+								if (!remoteSocket.isPaused()) {
+									remoteSocket.pause();
+								}
+								if (!proxySocket.isPaused()) {
+									proxySocket.pause();
+								}
+							}
+						}
+					});
+
+					proxySocket.on('data', (data) => {
+						remoteReady = remoteSocket.write(data);
+						if (!remoteReady) {
+							proxySocket.pause();
+						}
+					});
+					remoteSocket.on('data', (data) => {
+						localReady = proxySocket.write(data);
+						if (!localReady) {
+							remoteSocket.pause();
+						}
+					});
+					proxySocket.on('drain', () => {
+						localReady = true;
+						if (!isDisconnected) {
+							remoteSocket.resume();
+						}
+					});
+					remoteSocket.on('drain', () => {
+						remoteReady = true;
+						if (!isDisconnected) {
+							proxySocket.resume();
+						}
+					});
+					proxySocket.on('close', () => {
+						outputChannel.appendLine(`Proxy socket closed, closing remote socket.`);
+						remoteSocket.end();
+					});
+					remoteSocket.on('close', () => {
+						outputChannel.appendLine(`Remote socket closed, closing proxy socket.`);
+						proxySocket.end();
+					});
+					context.subscriptions.push({
+						dispose: () => {
+							proxySocket.end();
+							remoteSocket.end();
+						}
+					});
+				});
+				proxyServer.listen(0, () => {
+					const port = (<net.AddressInfo>proxyServer.address()).port;
+					outputChannel.appendLine(`Going through proxy at port ${port}`);
+					res(new vscode.ResolvedAuthority('127.0.0.1', port));
+				});
+				context.subscriptions.push({
+					dispose: () => {
+						proxyServer.close();
+					}
+				});
+			});
+		});
+	}
+
+	vscode.workspace.registerRemoteAuthorityResolver('test', {
+		resolve(_authority: string): Thenable<vscode.ResolvedAuthority> {
+			return vscode.window.withProgress({
+				location: vscode.ProgressLocation.Notification,
+				title: 'Open TestResolver Remote ([details](command:vscode-testresolver.showLog))',
+				cancellable: false
+			}, (progress) => doResolve(_authority, progress));
+		}
+	});
+
+	vscode.commands.registerCommand('vscode-testresolver.newWindow', () => {
+		return vscode.commands.executeCommand('vscode.newWindow', { remoteAuthority: 'test+test' });
+	});
+	vscode.commands.registerCommand('vscode-testresolver.newWindowWithError', () => {
+		return vscode.commands.executeCommand('vscode.newWindow', { remoteAuthority: 'test+error' });
+	});
+	vscode.commands.registerCommand('vscode-testresolver.showLog', () => {
+		if (outputChannel) {
+			outputChannel.show();
+		}
+	});
+}
+
+type ActionItem = (vscode.MessageItem & { execute: () => void; });
+
+function getActions(): ActionItem[] {
+	const actions: ActionItem[] = [];
+	const isDirty = vscode.workspace.textDocuments.some(d => d.isDirty) || vscode.workspace.workspaceFile && vscode.workspace.workspaceFile.scheme === 'untitled';
+
+	actions.push({
+		title: 'Retry',
+		execute: async () => {
+			await vscode.commands.executeCommand('workbench.action.reloadWindow');
+		}
+	});
+	if (!isDirty) {
+		actions.push({
+			title: 'Close Remote',
+			execute: async () => {
+				await vscode.commands.executeCommand('vscode.newWindow', { reuseWindow: true });
+			}
+		});
+	}
+	actions.push({
+		title: 'Ignore',
+		isCloseAffordance: true,
+		execute: async () => {
+			vscode.commands.executeCommand('vscode-testresolver.showLog'); // no need to wait
+		}
+	});
+	return actions;
+}
+
+export interface IProductConfiguration {
+	updateUrl: string;
+	commit: string;
+	quality: string;
+	dataFolderName: string;
+	serverDataFolderName?: string;
+}
+
+function getProductConfiguration(): IProductConfiguration {
+	const content = fs.readFileSync(path.join(vscode.env.appRoot, 'product.json')).toString();
+	return JSON.parse(content) as IProductConfiguration;
+}
+
+function getNewEnv(): { [x: string]: string | undefined } {
+	const env = { ...process.env };
+	delete env['ELECTRON_RUN_AS_NODE'];
+	return env;
+}
+
+function sleep(ms: number): Promise<void> {
+	return new Promise(resolve => {
+		setTimeout(resolve, ms);
+	});
+}
+
+function getConfiguration<T>(id: string): T | undefined {
+	return vscode.workspace.getConfiguration('testresolver').get<T>(id);
+}

lib/vscode/extensions/vscode-test-resolver/src/typings/ref.d.ts

@@ -0,0 +1,8 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/// <reference path="../../../../src/vs/vscode.d.ts" />
+/// <reference path="../../../../src/vs/vscode.proposed.d.ts" />
+/// <reference types='@types/node'/>

lib/vscode/extensions/vscode-test-resolver/src/util/processes.ts

@@ -0,0 +1,37 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as cp from 'child_process';
+import * as path from 'path';
+
+export interface TerminateResponse {
+	success: boolean;
+	error?: any;
+}
+
+export function terminateProcess(p: cp.ChildProcess, extensionPath: string): TerminateResponse {
+	if (process.platform === 'win32') {
+		try {
+			const options: any = {
+				stdio: ['pipe', 'pipe', 'ignore']
+			};
+			cp.execFileSync('taskkill', ['/T', '/F', '/PID', p.pid.toString()], options);
+		} catch (err) {
+			return { success: false, error: err };
+		}
+	} else if (process.platform === 'darwin' || process.platform === 'linux') {
+		try {
+			const cmd = path.join(extensionPath, 'scripts', 'terminateProcess.sh');
+			const result = cp.spawnSync(cmd, [process.pid.toString()]);
+			if (result.error) {
+				return { success: false, error: result.error };
+			}
+		} catch (err) {
+			return { success: false, error: err };
+		}
+	} else {
+		p.kill('SIGKILL');
+	}
+	return { success: true };
+}

lib/vscode/extensions/vscode-test-resolver/tsconfig.json

@@ -0,0 +1,9 @@
+{
+	"extends": "../shared.tsconfig.json",
+	"compilerOptions": {
+		"outDir": "./out"
+	},
+	"include": [
+		"src/**/*"
+	]
+}