Vscode merge (#4582)

* Merge from vscode 37cb23d3dd4f9433d56d4ba5ea3203580719a0bd * fix issues with merges * bump node version in azpipe * replace license headers * remove duplicate launch task * fix build errors * fix build errors * fix tslint issues * working through package and linux build issues * more work * wip * fix packaged builds * working through linux build errors * wip * wip * wip * fix mac and linux file limits * iterate linux pipeline * disable editor typing * revert series to parallel * remove optimize vscode from linux * fix linting issues * revert testing change * add work round for new node * readd packaging for extensions * fix issue with angular not resolving decorator dependencies
2026-01-26 17:23:15 -05:00 · 2019-03-19 17:44:35 -07:00
parent 833d197412
commit 87765e8673
1879 changed files with 54505 additions and 38058 deletions
--- a/src/vs/workbench/api/node/extHostTerminalService.ts
+++ b/src/vs/workbench/api/node/extHostTerminalService.ts
@@ -4,21 +4,19 @@
 *--------------------------------------------------------------------------------------------*/

 import * as vscode from 'vscode';
+import pkg from 'vs/platform/product/node/package';
+import * as os from 'os';
 import { URI, UriComponents } from 'vs/base/common/uri';
 import * as platform from 'vs/base/common/platform';
-import * as terminalEnvironment from 'vs/workbench/parts/terminal/node/terminalEnvironment';
+import * as terminalEnvironment from 'vs/workbench/contrib/terminal/common/terminalEnvironment';
 import { Event, Emitter } from 'vs/base/common/event';
 import { ExtHostTerminalServiceShape, MainContext, MainThreadTerminalServiceShape, IMainContext, ShellLaunchConfigDto } from 'vs/workbench/api/node/extHost.protocol';
 import { ExtHostConfiguration } from 'vs/workbench/api/node/extHostConfiguration';
 import { ILogService } from 'vs/platform/log/common/log';
-import { EXT_HOST_CREATION_DELAY } from 'vs/workbench/parts/terminal/common/terminal';
-import { TerminalProcess } from 'vs/workbench/parts/terminal/node/terminalProcess';
+import { EXT_HOST_CREATION_DELAY, IShellLaunchConfig } from 'vs/workbench/contrib/terminal/common/terminal';
+import { TerminalProcess } from 'vs/workbench/contrib/terminal/node/terminalProcess';
 import { timeout } from 'vs/base/common/async';
-import { generateRandomPipeName } from 'vs/base/parts/ipc/node/ipc.net';
-import * as http from 'http';
-import * as fs from 'fs';
-import { ExtHostCommands } from 'vs/workbench/api/node/extHostCommands';
-import { sanitizeProcessEnvironment } from 'vs/base/node/processes';
+import { sanitizeProcessEnvironment } from 'vs/base/common/processes';

 const RENDERER_NO_PROCESS_ID = -1;

@@ -76,8 +74,10 @@ export class BaseExtHostTerminal {
 }

 export class ExtHostTerminal extends BaseExtHostTerminal implements vscode.Terminal {
-	private _pidPromise: Promise<number>;
-	private _pidPromiseComplete: (value: number) => any;
+	private _pidPromise: Promise<number | undefined>;
+	private _cols: number | undefined;
+	private _pidPromiseComplete: ((value: number | undefined) => any) | null;
+	private _rows: number | undefined;

 	private readonly _onData = new Emitter<string>();
 	public get onDidWriteData(): Event<string> {
@@ -90,7 +90,7 @@ export class ExtHostTerminal extends BaseExtHostTerminal implements vscode.Termi

 	constructor(
 		proxy: MainThreadTerminalServiceShape,
-		private _name: string,
+		private _name?: string,
 		id?: number,
 		pid?: number
 	) {
@@ -108,7 +108,7 @@ export class ExtHostTerminal extends BaseExtHostTerminal implements vscode.Termi
 		shellPath?: string,
 		shellArgs?: string[],
 		cwd?: string | URI,
-		env?: { [key: string]: string },
+		env?: { [key: string]: string | null },
 		waitOnExit?: boolean,
 		strictEnv?: boolean
 	): void {
@@ -119,14 +119,34 @@ export class ExtHostTerminal extends BaseExtHostTerminal implements vscode.Termi
 	}

 	public get name(): string {
-		return this._name;
+		return this._name || '';
 	}

 	public set name(name: string) {
 		this._name = name;
 	}

-	public get processId(): Promise<number> {
+	public get dimensions(): vscode.TerminalDimensions | undefined {
+		if (this._cols === undefined || this._rows === undefined) {
+			return undefined;
+		}
+		return {
+			columns: this._cols,
+			rows: this._rows
+		};
+	}
+
+	public setDimensions(cols: number, rows: number): boolean {
+		if (cols === this._cols && rows === this._rows) {
+			// Nothing changed
+			return false;
+		}
+		this._cols = cols;
+		this._rows = rows;
+		return true;
+	}
+
+	public get processId(): Promise<number | undefined> {
 		return this._pidPromise;
 	}

@@ -145,7 +165,7 @@ export class ExtHostTerminal extends BaseExtHostTerminal implements vscode.Termi
 		this._queueApiRequest(this._proxy.$hide, []);
 	}

-	public _setProcessId(processId: number): void {
+	public _setProcessId(processId: number | undefined): void {
 		// The event may fire 2 times when the panel is restored
 		if (this._pidPromiseComplete) {
 			this._pidPromiseComplete(processId);
@@ -183,15 +203,15 @@ export class ExtHostTerminalRenderer extends BaseExtHostTerminal implements vsco
 	}

 	private _dimensions: vscode.TerminalDimensions | undefined;
-	public get dimensions(): vscode.TerminalDimensions { return this._dimensions; }
-	public set dimensions(dimensions: vscode.TerminalDimensions) {
+	public get dimensions(): vscode.TerminalDimensions | undefined { return this._dimensions; }
+	public set dimensions(dimensions: vscode.TerminalDimensions | undefined) {
 		this._checkDisposed();
 		this._dimensions = dimensions;
 		this._queueApiRequest(this._proxy.$terminalRendererSetDimensions, [dimensions]);
 	}

-	private _maximumDimensions: vscode.TerminalDimensions;
-	public get maximumDimensions(): vscode.TerminalDimensions {
+	private _maximumDimensions: vscode.TerminalDimensions | undefined;
+	public get maximumDimensions(): vscode.TerminalDimensions | undefined {
 		if (!this._maximumDimensions) {
 			return undefined;
 		}
@@ -213,13 +233,17 @@ export class ExtHostTerminalRenderer extends BaseExtHostTerminal implements vsco
 	constructor(
 		proxy: MainThreadTerminalServiceShape,
 		private _name: string,
-		private _terminal: ExtHostTerminal
+		private _terminal: ExtHostTerminal,
+		id?: number
 	) {
-		super(proxy);
-		this._proxy.$createTerminalRenderer(this._name).then(id => {
-			this._runQueuedRequests(id);
-			(<any>this._terminal)._runQueuedRequests(id);
-		});
+		super(proxy, id);
+
+		if (!id) {
+			this._proxy.$createTerminalRenderer(this._name).then(id => {
+				this._runQueuedRequests(id);
+				(<any>this._terminal)._runQueuedRequests(id);
+			});
+		}
 	}

 	public write(data: string): void {
@@ -235,21 +259,21 @@ export class ExtHostTerminalRenderer extends BaseExtHostTerminal implements vsco
 		if (this._maximumDimensions && this._maximumDimensions.columns === columns && this._maximumDimensions.rows === rows) {
 			return;
 		}
-		this._maximumDimensions = { columns, rows };
-		this._onDidChangeMaximumDimensions.fire(this.maximumDimensions);
+		const newValue = { columns, rows };
+		this._maximumDimensions = newValue;
+		this._onDidChangeMaximumDimensions.fire(newValue);
 	}
 }

 export class ExtHostTerminalService implements ExtHostTerminalServiceShape {
 	private _proxy: MainThreadTerminalServiceShape;
-	private _activeTerminal: ExtHostTerminal;
+	private _activeTerminal: ExtHostTerminal | undefined;
 	private _terminals: ExtHostTerminal[] = [];
 	private _terminalProcesses: { [id: number]: TerminalProcess } = {};
 	private _terminalRenderers: ExtHostTerminalRenderer[] = [];
 	private _getTerminalPromises: { [id: number]: Promise<ExtHostTerminal> } = {};
-	private _cliServer: CLIServer | undefined;

-	public get activeTerminal(): ExtHostTerminal { return this._activeTerminal; }
+	public get activeTerminal(): ExtHostTerminal | undefined { return this._activeTerminal; }
 	public get terminals(): ExtHostTerminal[] { return this._terminals; }

 	private readonly _onDidCloseTerminal: Emitter<vscode.Terminal> = new Emitter<vscode.Terminal>();
@@ -258,12 +282,13 @@ export class ExtHostTerminalService implements ExtHostTerminalServiceShape {
 	public get onDidOpenTerminal(): Event<vscode.Terminal> { return this._onDidOpenTerminal && this._onDidOpenTerminal.event; }
 	private readonly _onDidChangeActiveTerminal: Emitter<vscode.Terminal | undefined> = new Emitter<vscode.Terminal | undefined>();
 	public get onDidChangeActiveTerminal(): Event<vscode.Terminal | undefined> { return this._onDidChangeActiveTerminal && this._onDidChangeActiveTerminal.event; }
+	private readonly _onDidChangeTerminalDimensions: Emitter<vscode.TerminalDimensionsChangeEvent> = new Emitter<vscode.TerminalDimensionsChangeEvent>();
+	public get onDidChangeTerminalDimensions(): Event<vscode.TerminalDimensionsChangeEvent> { return this._onDidChangeTerminalDimensions && this._onDidChangeTerminalDimensions.event; }

 	constructor(
 		mainContext: IMainContext,
 		private _extHostConfiguration: ExtHostConfiguration,
 		private _logService: ILogService,
-		private _commands: ExtHostCommands
 	) {
 		this._proxy = mainContext.getProxy(MainContext.MainThreadTerminalService);
 	}
@@ -293,6 +318,24 @@ export class ExtHostTerminalService implements ExtHostTerminalServiceShape {
 		return renderer;
 	}

+	public async resolveTerminalRenderer(id: number): Promise<vscode.TerminalRenderer> {
+		// Check to see if the extension host already knows about this terminal.
+		for (const terminalRenderer of this._terminalRenderers) {
+			if (terminalRenderer._id === id) {
+				return terminalRenderer;
+			}
+		}
+
+		const terminal = this._getTerminalById(id);
+		if (!terminal) {
+			throw new Error(`Cannot resolve terminal renderer for terminal id ${id}`);
+		}
+		const renderer = new ExtHostTerminalRenderer(this._proxy, terminal.name, terminal, terminal._id);
+		this._terminalRenderers.push(renderer);
+
+		return renderer;
+	}
+
 	public $acceptActiveTerminalChanged(id: number | null): void {
 		const original = this._activeTerminal;
 		if (id === null) {
@@ -300,6 +343,7 @@ export class ExtHostTerminalService implements ExtHostTerminalServiceShape {
 			if (original !== this._activeTerminal) {
 				this._onDidChangeActiveTerminal.fire(this._activeTerminal);
 			}
+			return;
 		}
 		this._performTerminalIdAction(id, terminal => {
 			if (terminal) {
@@ -319,7 +363,17 @@ export class ExtHostTerminalService implements ExtHostTerminalServiceShape {
 		});
 	}

-	public $acceptTerminalRendererDimensions(id: number, cols: number, rows: number): void {
+	public async $acceptTerminalDimensions(id: number, cols: number, rows: number): Promise<void> {
+		const terminal = this._getTerminalById(id);
+		if (terminal) {
+			if (terminal.setDimensions(cols, rows)) {
+				this._onDidChangeTerminalDimensions.fire({
+					terminal: terminal,
+					dimensions: terminal.dimensions as vscode.TerminalDimensions
+				});
+			}
+		}
+		// When a terminal's dimensions change, a renderer's _maximum_ dimensions change
 		const renderer = this._getTerminalRendererById(id);
 		if (renderer) {
 			renderer._setMaximumDimensions(cols, rows);
@@ -342,11 +396,10 @@ export class ExtHostTerminalService implements ExtHostTerminalServiceShape {

 	public $acceptTerminalClosed(id: number): void {
 		const index = this._getTerminalObjectIndexById(this.terminals, id);
-		if (index === null) {
-			return;
+		if (index !== null) {
+			const terminal = this._terminals.splice(index, 1)[0];
+			this._onDidCloseTerminal.fire(terminal);
 		}
-		const terminal = this._terminals.splice(index, 1)[0];
-		this._onDidCloseTerminal.fire(terminal);
 	}

 	public $acceptTerminalOpened(id: number, name: string): void {
@@ -356,6 +409,7 @@ export class ExtHostTerminalService implements ExtHostTerminalServiceShape {
 			this._onDidOpenTerminal.fire(this.terminals[index]);
 			return;
 		}
+
 		const renderer = this._getTerminalRendererById(id);
 		const terminal = new ExtHostTerminal(this._proxy, name, id, renderer ? RENDERER_NO_PROCESS_ID : undefined);
 		this._terminals.push(terminal);
@@ -381,7 +435,15 @@ export class ExtHostTerminalService implements ExtHostTerminalServiceShape {
 		}
 	}

-	public async $createProcess(id: number, shellLaunchConfig: ShellLaunchConfigDto, activeWorkspaceRootUriComponents: UriComponents, cols: number, rows: number): Promise<void> {
+	public async $createProcess(id: number, shellLaunchConfigDto: ShellLaunchConfigDto, activeWorkspaceRootUriComponents: UriComponents, cols: number, rows: number): Promise<void> {
+		const shellLaunchConfig: IShellLaunchConfig = {
+			name: shellLaunchConfigDto.name,
+			executable: shellLaunchConfigDto.executable,
+			args: shellLaunchConfigDto.args,
+			cwd: typeof shellLaunchConfigDto.cwd === 'string' ? shellLaunchConfigDto.cwd : URI.revive(shellLaunchConfigDto.cwd),
+			env: shellLaunchConfigDto.env
+		};
+
 		// TODO: This function duplicates a lot of TerminalProcessManager.createProcess, ideally
 		// they would be merged into a single implementation.
 		const configProvider = await this._extHostConfiguration.getConfigProvider();
@@ -392,8 +454,8 @@ export class ExtHostTerminalService implements ExtHostTerminalServiceShape {
 			// this._configHelper.mergeDefaultShellPathAndArgs(shellLaunchConfig);

 			const platformKey = platform.isWindows ? 'windows' : platform.isMacintosh ? 'osx' : 'linux';
-			const shellConfigValue: string = terminalConfig.get(`shell.${platformKey}`);
-			const shellArgsConfigValue: string = terminalConfig.get(`shellArgs.${platformKey}`);
+			const shellConfigValue: string | undefined = terminalConfig.get(`shell.${platformKey}`);
+			const shellArgsConfigValue: string | undefined = terminalConfig.get(`shellArgs.${platformKey}`);

 			shellLaunchConfig.executable = shellConfigValue;
 			shellLaunchConfig.args = shellArgsConfigValue;
@@ -401,7 +463,7 @@ export class ExtHostTerminalService implements ExtHostTerminalServiceShape {

 		// TODO: @daniel
 		const activeWorkspaceRootUri = URI.revive(activeWorkspaceRootUriComponents);
-		const initialCwd = terminalEnvironment.getCwd(shellLaunchConfig, activeWorkspaceRootUri, terminalConfig.cwd);
+		const initialCwd = terminalEnvironment.getCwd(shellLaunchConfig, os.homedir(), activeWorkspaceRootUri, terminalConfig.cwd);

 		// TODO: Pull in and resolve config settings
 		// // Resolve env vars from config and shell
@@ -413,25 +475,24 @@ export class ExtHostTerminalService implements ExtHostTerminalServiceShape {

 		// Merge process env with the env from config
 		const env = { ...process.env };
-		terminalEnvironment.mergeEnvironments(env, envFromConfig);
-		terminalEnvironment.mergeEnvironments(env, shellLaunchConfig.env);
+		Object.keys(env).filter(k => env[k] === undefined).forEach(k => {
+			delete env[k];
+		});
+		const castedEnv = env as platform.IProcessEnvironment;
+		terminalEnvironment.mergeEnvironments(castedEnv, envFromConfig);
+		terminalEnvironment.mergeEnvironments(castedEnv, shellLaunchConfig.env);

 		// Sanitize the environment, removing any undesirable VS Code and Electron environment
 		// variables
-		sanitizeProcessEnvironment(env);
+		sanitizeProcessEnvironment(castedEnv, 'VSCODE_IPC_HOOK_CLI');

 		// Continue env initialization, merging in the env from the launch
 		// config and adding keys that are needed to create the process
-		terminalEnvironment.addTerminalEnvironmentKeys(env, platform.locale, terminalConfig.get('setLocaleVariables'));
-
-		if (!this._cliServer) {
-			this._cliServer = new CLIServer(this._commands);
-		}
-		env['VSCODE_IPC_HOOK_CLI'] = this._cliServer.ipcHandlePath;
+		terminalEnvironment.addTerminalEnvironmentKeys(castedEnv, pkg.version, platform.locale, terminalConfig.get('setLocaleVariables') as boolean);

 		// Fork the process and listen for messages
-		this._logService.debug(`Terminal process launching on ext host`, shellLaunchConfig, initialCwd, cols, rows, env);
-		const p = new TerminalProcess(shellLaunchConfig, initialCwd, cols, rows, env, terminalConfig.get('windowsEnableConpty'));
+		this._logService.debug(`Terminal process launching on ext host`, shellLaunchConfig, initialCwd, cols, rows, castedEnv);
+		const p = new TerminalProcess(shellLaunchConfig, initialCwd, cols, rows, castedEnv, terminalConfig.get('windowsEnableConpty') as boolean);
 		p.onProcessIdReady(pid => this._proxy.$sendProcessPid(id, pid));
 		p.onProcessTitleChanged(title => this._proxy.$sendProcessTitle(id, title));
 		p.onProcessData(data => this._proxy.$sendProcessData(id, data));
@@ -477,11 +538,6 @@ export class ExtHostTerminalService implements ExtHostTerminalServiceShape {
 		// Send exit event to main side
 		this._proxy.$sendProcessExit(id, exitCode);

-		if (this._cliServer && !Object.keys(this._terminalProcesses).length) {
-			this._cliServer.dispose();
-			this._cliServer = undefined;
-		}
-
 	}

 	private _getTerminalByIdEventually(id: number, retries: number = 5): Promise<ExtHostTerminal> {
@@ -513,20 +569,20 @@ export class ExtHostTerminalService implements ExtHostTerminalServiceShape {
 		});
 	}

-	private _getTerminalById(id: number): ExtHostTerminal {
+	private _getTerminalById(id: number): ExtHostTerminal | null {
 		return this._getTerminalObjectById(this._terminals, id);
 	}

-	private _getTerminalRendererById(id: number): ExtHostTerminalRenderer {
+	private _getTerminalRendererById(id: number): ExtHostTerminalRenderer | null {
 		return this._getTerminalObjectById(this._terminalRenderers, id);
 	}

-	private _getTerminalObjectById<T extends ExtHostTerminal | ExtHostTerminalRenderer>(array: T[], id: number): T {
+	private _getTerminalObjectById<T extends ExtHostTerminal | ExtHostTerminalRenderer>(array: T[], id: number): T | null {
 		const index = this._getTerminalObjectIndexById(array, id);
 		return index !== null ? array[index] : null;
 	}

-	private _getTerminalObjectIndexById<T extends ExtHostTerminal | ExtHostTerminalRenderer>(array: T[], id: number): number {
+	private _getTerminalObjectIndexById<T extends ExtHostTerminal | ExtHostTerminalRenderer>(array: T[], id: number): number | null {
 		let index: number | null = null;
 		array.some((item, i) => {
 			const thisId = item._id;
@@ -553,73 +609,3 @@ class ApiRequest {
 		this._callback.apply(proxy, [id].concat(this._args));
 	}
 }
-
-
-class CLIServer {
-
-	private _server: http.Server;
-	private _ipcHandlePath: string | undefined;
-
-	constructor(private _commands: ExtHostCommands) {
-		this._server = http.createServer((req, res) => this.onRequest(req, res));
-		this.setup().catch(err => {
-			console.error(err);
-			return '';
-		});
-	}
-
-	public get ipcHandlePath() {
-		return this._ipcHandlePath;
-	}
-
-	private async setup(): Promise<string> {
-		this._ipcHandlePath = generateRandomPipeName();
-
-		try {
-			this._server.listen(this.ipcHandlePath);
-			this._server.on('error', err => console.error(err));
-		} catch (err) {
-			console.error('Could not start open from terminal server.');
-		}
-
-		return this.ipcHandlePath;
-	}
-	private toURIs(strs: string[]): URI[] {
-		const result: URI[] = [];
-		if (Array.isArray(strs)) {
-			for (const s of strs) {
-				try {
-					result.push(URI.parse(s));
-				} catch (e) {
-					// ignore
-				}
-			}
-		}
-		return result;
-	}
-
-	private onRequest(req: http.IncomingMessage, res: http.ServerResponse): void {
-		const chunks: string[] = [];
-		req.setEncoding('utf8');
-		req.on('data', (d: string) => chunks.push(d));
-		req.on('end', () => {
-			let { fileURIs, folderURIs, forceNewWindow, diffMode, addMode, forceReuseWindow } = JSON.parse(chunks.join(''));
-			if (folderURIs && folderURIs.length || fileURIs && fileURIs.length) {
-				if (folderURIs && folderURIs.length && !forceReuseWindow) {
-					forceNewWindow = true;
-				}
-				this._commands.executeCommand('_files.windowOpen', { folderURIs: this.toURIs(folderURIs), fileURIs: this.toURIs(fileURIs), forceNewWindow, diffMode, addMode, forceReuseWindow });
-			}
-			res.writeHead(200);
-			res.end();
-		});
-	}
-
-	dispose(): void {
-		this._server.close();
-
-		if (this._ipcHandlePath && process.platform !== 'win32' && fs.existsSync(this._ipcHandlePath)) {
-			fs.unlinkSync(this._ipcHandlePath);
-		}
-	}
-}