Clean up socket lifecycle. Remove unused socket wrappers.

Author: GirlBossRush

src/vs/base/parts/ipc/node/ipc.cp.ts

@@ -3,18 +3,20 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { ChildProcess, fork, ForkOptions } from 'child_process';
+import { ChildProcess, fork, ForkOptions, SendHandle } from 'child_process';
 import { IDisposable, toDisposable, dispose } from 'vs/base/common/lifecycle';
 import { Delayer, createCancelablePromise } from 'vs/base/common/async';
 import { deepClone } from 'vs/base/common/objects';
 import { Emitter, Event } from 'vs/base/common/event';
 import { createQueuedSender } from 'vs/base/node/processes';
 import { IChannel, ChannelServer as IPCServer, ChannelClient as IPCClient, IChannelClient } from 'vs/base/parts/ipc/common/ipc';
-import { isRemoteConsoleLog, log } from 'vs/base/common/console';
+import { IRemoteConsoleLog, isRemoteConsoleLog, log } from 'vs/base/common/console';
 import { CancellationToken } from 'vs/base/common/cancellation';
 import * as errors from 'vs/base/common/errors';
 import { VSBuffer } from 'vs/base/common/buffer';
 import { isMacintosh } from 'vs/base/common/platform';
+// eslint-disable-next-line code-import-patterns
+import { IExtHostMessage, IExtHostReadyMessage } from 'vs/workbench/services/extensions/common/extensionHostProtocol';
 
 /**
  * This implementation doesn't perform well since it uses base64 encoding for buffers.
@@ -290,3 +292,101 @@ export class Client implements IChannelClient, IDisposable {
 		this.activeRequests.clear();
 	}
 }
+
+export type ExtensionHostMessage = IRemoteConsoleLog | IExtHostReadyMessage;
+export class ExtensionHost implements IDisposable {
+	private child: ChildProcess | null = null;
+	private readonly _onDidProcessExit = new Emitter<{ code: number, signal: string }>();
+	public readonly onDidProcessExit = this._onDidProcessExit.event;
+
+	private readonly _onReadyMessage = new Emitter<IExtHostReadyMessage>();
+	public readonly onReady = this._onReadyMessage.event;
+
+	private disposeClient() {
+		if (this.child) {
+			this.child.kill();
+			this.child = null;
+		}
+	}
+
+	dispose() {
+		this._onDidProcessExit.dispose();
+
+		this.disposeClient();
+	}
+
+	sendIPCMessage(message: IExtHostMessage, sendHandle?: SendHandle) {
+		if (this.child && this.child.connected) {
+			return this.child.send(message, sendHandle);
+		}
+
+		return false;
+	}
+
+	constructor(private modulePath: string, private options: IIPCOptions) {
+		const args = options && options.args ? this.options.args : [];
+		const forkOpts: ForkOptions = Object.create(null);
+
+		forkOpts.env = { ...deepClone(process.env), 'VSCODE_PARENT_PID': String(process.pid) };
+
+		if (this.options && this.options.env) {
+			forkOpts.env = { ...forkOpts.env, ...this.options.env };
+		}
+
+		if (this.options && this.options.freshExecArgv) {
+			forkOpts.execArgv = [];
+		}
+
+		if (this.options && typeof this.options.debug === 'number') {
+			forkOpts.execArgv = ['--nolazy', '--inspect=' + this.options.debug];
+		}
+
+		if (this.options && typeof this.options.debugBrk === 'number') {
+			forkOpts.execArgv = ['--nolazy', '--inspect-brk=' + this.options.debugBrk];
+		}
+
+		if (forkOpts.execArgv === undefined) {
+			// if not set, the forked process inherits the execArgv of the parent process
+			// --inspect and --inspect-brk can not be inherited as the port would conflict
+			forkOpts.execArgv = process.execArgv.filter(a => !/^--inspect(-brk)?=/.test(a)); // remove
+		}
+
+		if (isMacintosh && forkOpts.env) {
+			// Unset `DYLD_LIBRARY_PATH`, as it leads to process crashes
+			// See https://github.com/microsoft/vscode/issues/105848
+			delete forkOpts.env['DYLD_LIBRARY_PATH'];
+		}
+
+		this.child = fork(this.modulePath, args, forkOpts);
+
+		const onRawMessage = Event.fromNodeEventEmitter<ExtensionHostMessage>(this.child, 'message', msg => msg);
+
+		onRawMessage(msg => {
+			// Handle remote console logs specially
+			if (isRemoteConsoleLog(msg)) {
+				log(msg, `IPC Library: ${this.options.serverName}`);
+				return;
+			}
+
+			if (msg.type === 'VSCODE_EXTHOST_IPC_READY') {
+				this._onReadyMessage.fire(msg);
+			}
+		});
+
+		const onExit = () => this.disposeClient();
+		process.once('exit', onExit);
+
+		this.child.on('error', err => console.warn('IPC "' + this.options.serverName + '" errored with ' + err));
+
+		this.child.on('exit', (code: any, signal: any) => {
+			process.removeListener('exit' as 'loaded', onExit); // https://github.com/electron/electron/issues/21475
+
+
+			if (code !== 0 && signal !== 'SIGTERM') {
+				console.warn('IPC "' + this.options.serverName + '" crashed with exit code ' + code + ' and signal ' + signal);
+			}
+
+			this._onDidProcessExit.fire({ code, signal });
+		});
+	}
+}

src/vs/platform/remote/node/serverSocket.ts

@@ -3,6 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import { onUnexpectedError } from 'vs/base/common/errors';
 import { Emitter } from 'vs/base/common/event';
 import { ConsoleLogger } from 'vs/platform/log/common/log';
 import { ServerProtocol } from 'vs/server/protocol';
@@ -17,39 +18,50 @@ export abstract class AbstractConnection {
 	private disposed = false;
 	private _offline: number | undefined;
 
-	protected readonly logger: ConsoleLogger;
+	protected readonly logService: ConsoleLogger;
 
 	public constructor(
 		protected readonly protocol: ServerProtocol,
 		public readonly name: string,
 	) {
-		this.logger = new ConsoleLogger();
+		this.logService = new ConsoleLogger();
 
-		this.logger.debug('Connecting...');
-		this.onClose(() => this.logger.debug('Closed'));
+		this.logService.debug('Connecting...');
+		this.onClose(() => this.logService.debug('Closed'));
 	}
 
 	public get offline(): number | undefined {
 		return this._offline;
 	}
 
 	public reconnect(protocol: ServerProtocol): void {
-		this.logger.debug(`${this.protocol.reconnectionToken} Reconnecting...`);
+		this.logService.debug(`${this.protocol.reconnectionToken} Reconnecting...`);
 		this._offline = undefined;
 		this.doReconnect(protocol);
 	}
 
 	public dispose(reason?: string): void {
-		this.logger.debug(`${this.protocol.reconnectionToken} Disposing...`, reason);
+		this.logService.debug(`${this.protocol.reconnectionToken} Disposing...`, reason);
 		if (!this.disposed) {
 			this.disposed = true;
 			this.doDispose();
 			this._onClose.fire();
 		}
 	}
 
+	public safeDisposeProtocolAndSocket(): void {
+		try {
+			this.protocol.acceptDisconnect();
+			const socket = this.protocol.getSocket();
+			this.protocol.dispose();
+			socket.dispose();
+		} catch (err) {
+			onUnexpectedError(err);
+		}
+	}
+
 	protected setOffline(): void {
-		this.logger.debug('Disconnected');
+		this.logService.debug('Disconnected');
 		if (!this._offline) {
 			this._offline = Date.now();
 		}