Merge vscode source through 1.62 release (#19981)

* Build breaks 1 * Build breaks * Build breaks * Build breaks * More build breaks * Build breaks (#2512) * Runtime breaks * Build breaks * Fix dialog location break * Update typescript * Fix ASAR break issue * Unit test breaks * Update distro * Fix breaks in ADO builds (#2513) * Bump to node 16 * Fix hygiene errors * Bump distro * Remove reference to node type * Delete vscode specific extension * Bump to node 16 in CI yaml * Skip integration tests in CI builds (while fixing) * yarn.lock update * Bump moment dependency in remote yarn * Fix drop-down chevron style * Bump to node 16 * Remove playwrite from ci.yaml * Skip building build scripts in hygine check
2026-02-04 17:23:45 -05:00 · 2022-07-11 14:09:32 -07:00
parent fa0fcef303
commit 26455e9113
1876 changed files with 72050 additions and 37997 deletions
--- a/src/vs/code/electron-browser/sharedProcess/contrib/codeCacheCleaner.ts
+++ b/src/vs/code/electron-browser/sharedProcess/contrib/codeCacheCleaner.ts
@@ -36,7 +36,7 @@ export class CodeCacheCleaner extends Disposable {
 	}

 	private async cleanUpCodeCaches(currentCodeCachePath: string): Promise<void> {
-		this.logService.info('[code cache cleanup]: Starting to clean up old code cache folders.');
+		this.logService.trace('[code cache cleanup]: Starting to clean up old code cache folders.');

 		try {
 			const now = Date.now();
@@ -56,7 +56,7 @@ export class CodeCacheCleaner extends Disposable {
 				const codeCacheEntryPath = join(codeCacheRootPath, codeCache);
 				const codeCacheEntryStat = await Promises.stat(codeCacheEntryPath);
 				if (codeCacheEntryStat.isDirectory() && (now - codeCacheEntryStat.mtime.getTime()) > this._DataMaxAge) {
-					this.logService.info(`[code cache cleanup]: Removing code cache folder ${codeCache}.`);
+					this.logService.trace(`[code cache cleanup]: Removing code cache folder ${codeCache}.`);

 					return Promises.rm(codeCacheEntryPath);
 				}
--- a/src/vs/code/electron-browser/sharedProcess/contrib/languagePackCachedDataCleaner.ts
+++ b/src/vs/code/electron-browser/sharedProcess/contrib/languagePackCachedDataCleaner.ts
@@ -54,7 +54,7 @@ export class LanguagePackCachedDataCleaner extends Disposable {
 	}

 	private async cleanUpLanguagePackCache(): Promise<void> {
-		this.logService.info('[language pack cache cleanup]: Starting to clean up unused language packs.');
+		this.logService.trace('[language pack cache cleanup]: Starting to clean up unused language packs.');

 		try {
 			const installed: IStringDictionary<boolean> = Object.create(null);
@@ -74,11 +74,11 @@ export class LanguagePackCachedDataCleaner extends Disposable {
 			const entries = await Promises.readdir(cacheDir);
 			for (const entry of entries) {
 				if (installed[entry]) {
-					this.logService.info(`[language pack cache cleanup]: Skipping folder ${entry}. Language pack still in use.`);
+					this.logService.trace(`[language pack cache cleanup]: Skipping folder ${entry}. Language pack still in use.`);
 					continue;
 				}

-				this.logService.info(`[language pack cache cleanup]: Removing unused language pack: ${entry}`);
+				this.logService.trace(`[language pack cache cleanup]: Removing unused language pack: ${entry}`);

 				await Promises.rm(join(cacheDir, entry));
 			}
@@ -95,7 +95,7 @@ export class LanguagePackCachedDataCleaner extends Disposable {
 					const candidate = join(folder, entry);
 					const stat = await Promises.stat(candidate);
 					if (stat.isDirectory() && (now - stat.mtime.getTime()) > this._DataMaxAge) {
-						this.logService.info(`[language pack cache cleanup]: Removing language pack cache folder: ${join(packEntry, entry)}`);
+						this.logService.trace(`[language pack cache cleanup]: Removing language pack cache folder: ${join(packEntry, entry)}`);

 						await Promises.rm(candidate);
 					}
--- a/src/vs/code/electron-browser/sharedProcess/contrib/logsDataCleaner.ts
+++ b/src/vs/code/electron-browser/sharedProcess/contrib/logsDataCleaner.ts
@@ -26,7 +26,7 @@ export class LogsDataCleaner extends Disposable {
 	}

 	private async cleanUpOldLogs(): Promise<void> {
-		this.logService.info('[logs cleanup]: Starting to clean up old logs.');
+		this.logService.trace('[logs cleanup]: Starting to clean up old logs.');

 		try {
 			const currentLog = basename(this.environmentService.logsPath);
@@ -39,7 +39,7 @@ export class LogsDataCleaner extends Disposable {
 			const sessionsToDelete = oldSessions.slice(0, Math.max(0, oldSessions.length - 9));

 			if (sessionsToDelete.length > 0) {
-				this.logService.info(`[logs cleanup]: Removing log folders '${sessionsToDelete.join(', ')}'`);
+				this.logService.trace(`[logs cleanup]: Removing log folders '${sessionsToDelete.join(', ')}'`);

 				await Promise.all(sessionsToDelete.map(sessionToDelete => Promises.rm(join(logsRoot, sessionToDelete))));
 			}
--- a/src/vs/code/electron-browser/sharedProcess/contrib/storageDataCleaner.ts
+++ b/src/vs/code/electron-browser/sharedProcess/contrib/storageDataCleaner.ts
@@ -31,7 +31,7 @@ export class StorageDataCleaner extends Disposable {
 	}

 	private async cleanUpStorage(): Promise<void> {
-		this.logService.info('[storage cleanup]: Starting to clean up storage folders.');
+		this.logService.trace('[storage cleanup]: Starting to clean up storage folders.');

 		try {

@@ -50,7 +50,7 @@ export class StorageDataCleaner extends Disposable {
 				}

 				if (emptyWorkspaces.indexOf(storageFolder) === -1) {
-					this.logService.info(`[storage cleanup]: Deleting storage folder ${storageFolder}.`);
+					this.logService.trace(`[storage cleanup]: Deleting storage folder ${storageFolder}.`);

 					await Promises.rm(join(this.environmentService.workspaceStorageHome.fsPath, storageFolder));
 				}
--- a/src/vs/code/electron-browser/sharedProcess/sharedProcessMain.ts
+++ b/src/vs/code/electron-browser/sharedProcess/sharedProcessMain.ts
@@ -4,8 +4,6 @@
 *--------------------------------------------------------------------------------------------*/

 import { ipcRenderer } from 'electron';
-import * as fs from 'fs';
-import { gracefulify } from 'graceful-fs';
 import { hostname, release } from 'os';
 import { toErrorMessage } from 'vs/base/common/errorMessage';
 import { onUnexpectedError, setUnexpectedErrorHandler } from 'vs/base/common/errors';
@@ -65,7 +63,7 @@ import { ICustomEndpointTelemetryService, ITelemetryService } from 'vs/platform/
 import { TelemetryAppenderChannel } from 'vs/platform/telemetry/common/telemetryIpc';
 import { TelemetryLogAppender } from 'vs/platform/telemetry/common/telemetryLogAppender';
 import { TelemetryService } from 'vs/platform/telemetry/common/telemetryService';
-import { combinedAppender, ITelemetryAppender, NullAppender, NullTelemetryService } from 'vs/platform/telemetry/common/telemetryUtils';
+import { supportsTelemetry, ITelemetryAppender, NullAppender, NullTelemetryService } from 'vs/platform/telemetry/common/telemetryUtils';
 import { AppInsightsAppender } from 'vs/platform/telemetry/node/appInsightsAppender';
 import { CustomEndpointTelemetryService } from 'vs/platform/telemetry/node/customEndpointTelemetryService';
 import { LocalReconnectConstants, TerminalIpcChannels, TerminalSettingId } from 'vs/platform/terminal/common/terminal';
@@ -86,26 +84,51 @@ import { UserDataSyncChannel } from 'vs/platform/userDataSync/common/userDataSyn
 import { UserDataSyncStoreManagementService, UserDataSyncStoreService } from 'vs/platform/userDataSync/common/userDataSyncStoreService';
 import { UserDataAutoSyncService } from 'vs/platform/userDataSync/electron-sandbox/userDataAutoSyncService';
 import { ActiveWindowManager } from 'vs/platform/windows/node/windowTracker';
+import { IExtensionHostStarter, ipcExtensionHostStarterChannelName } from 'vs/platform/extensions/common/extensionHostStarter';
+import { ExtensionHostStarter } from 'vs/platform/extensions/node/extensionHostStarter';
+import { ISignService } from 'vs/platform/sign/common/sign';
+import { SignService } from 'vs/platform/sign/node/signService';
+import { ISharedTunnelsService } from 'vs/platform/remote/common/tunnel';
+import { SharedTunnelsService } from 'vs/platform/remote/node/tunnelService';
+import { ipcSharedProcessTunnelChannelName, ISharedProcessTunnelService } from 'vs/platform/remote/common/sharedProcessTunnelService';
+import { SharedProcessTunnelService } from 'vs/platform/remote/node/sharedProcessTunnelService';
+import { ipcSharedProcessWorkerChannelName, ISharedProcessWorkerConfiguration, ISharedProcessWorkerService } from 'vs/platform/sharedProcess/common/sharedProcessWorkerService';
+import { SharedProcessWorkerService } from 'vs/platform/sharedProcess/electron-browser/sharedProcessWorkerService';
+import { IUserConfigurationFileService, UserConfigurationFileServiceId } from 'vs/platform/configuration/common/userConfigurationFileService';

 class SharedProcessMain extends Disposable {

 	private server = this._register(new MessagePortServer());

+	private sharedProcessWorkerService: ISharedProcessWorkerService | undefined = undefined;
+
 	constructor(private configuration: ISharedProcessConfiguration) {
 		super();

-		// Enable gracefulFs
-		gracefulify(fs);
-
 		this.registerListeners();
 	}

 	private registerListeners(): void {

-		// Dispose on exit
+		// Shared process lifecycle
 		const onExit = () => this.dispose();
 		process.once('exit', onExit);
 		ipcRenderer.once('vscode:electron-main->shared-process=exit', onExit);
+
+		// Shared process worker lifecycle
+		//
+		// We dispose the listener when the shared process is
+		// disposed to avoid disposing workers when the entire
+		// application is shutting down anyways.
+		//
+		const eventName = 'vscode:electron-main->shared-process=disposeWorker';
+		const onDisposeWorker = (event: unknown, configuration: ISharedProcessWorkerConfiguration) => this.onDisposeWorker(configuration);
+		ipcRenderer.on(eventName, onDisposeWorker);
+		this._register(toDisposable(() => ipcRenderer.removeListener(eventName, onDisposeWorker)));
+	}
+
+	private onDisposeWorker(configuration: ISharedProcessWorkerConfiguration): void {
+		this.sharedProcessWorkerService?.disposeWorker(configuration);
 	}

 	async open(): Promise<void> {
@@ -170,6 +193,10 @@ class SharedProcessMain extends Disposable {
 		const logService = this._register(new FollowerLogService(logLevelClient, multiplexLogger));
 		services.set(ILogService, logService);

+		// Worker
+		this.sharedProcessWorkerService = new SharedProcessWorkerService(logService);
+		services.set(ISharedProcessWorkerService, this.sharedProcessWorkerService);
+
 		// Files
 		const fileService = this._register(new FileService(logService));
 		services.set(IFileService, fileService);
@@ -181,15 +208,20 @@ class SharedProcessMain extends Disposable {
 		const configurationService = this._register(new ConfigurationService(environmentService.settingsResource, fileService));
 		services.set(IConfigurationService, configurationService);

-		await configurationService.initialize();
-
 		// Storage (global access only)
 		const storageService = new NativeStorageService(undefined, mainProcessService, environmentService);
 		services.set(IStorageService, storageService);
-
-		await storageService.initialize();
 		this._register(toDisposable(() => storageService.flush()));

+		// Initialize config & storage in parallel
+		await Promise.all([
+			configurationService.initialize(),
+			storageService.initialize()
+		]);
+
+		// User Configuration File
+		services.set(IUserConfigurationFileService, ProxyChannel.toService<IUserConfigurationFileService>(mainProcessService.getChannel(UserConfigurationFileServiceId)));
+
 		// Request
 		services.set(IRequestService, new SyncDescriptor(RequestService));

@@ -210,31 +242,32 @@ class SharedProcessMain extends Disposable {

 		// Telemetry
 		let telemetryService: ITelemetryService;
-		let telemetryAppender: ITelemetryAppender;
-		if (!environmentService.isExtensionDevelopment && !environmentService.disableTelemetry && productService.enableTelemetry) {
-			telemetryAppender = new TelemetryLogAppender(loggerService, environmentService);
-
-			const { appRoot, extensionsPath, isBuilt, installSourcePath } = environmentService;
+		const appenders: ITelemetryAppender[] = [];
+		if (supportsTelemetry(productService, environmentService)) {
+			const logAppender = new TelemetryLogAppender(loggerService, environmentService);
+			appenders.push(logAppender);
+			const { appRoot, extensionsPath, installSourcePath } = environmentService;

 			// Application Insights
-			if (productService.aiConfig && productService.aiConfig.asimovKey && isBuilt) {
+			if (productService.aiConfig && productService.aiConfig.asimovKey) {
 				const appInsightsAppender = new AppInsightsAppender('adsworkbench', null, productService.aiConfig.asimovKey); // {{SQL CARBON EDIT}} Use our own event prefix
 				this._register(toDisposable(() => appInsightsAppender.flush())); // Ensure the AI appender is disposed so that it flushes remaining data
-				telemetryAppender = combinedAppender(appInsightsAppender, telemetryAppender);
+				appenders.push(appInsightsAppender);
 			}

 			telemetryService = new TelemetryService({
-				appender: telemetryAppender,
+				appenders,
 				commonProperties: resolveCommonProperties(fileService, release(), hostname(), process.arch, productService.commit, productService.version, this.configuration.machineId, productService.msftInternalDomains, installSourcePath),
 				sendErrorTelemetry: true,
 				piiPaths: [appRoot, extensionsPath]
 			}, configurationService);
 		} else {
 			telemetryService = NullTelemetryService;
-			telemetryAppender = NullAppender;
+			const nullAppender = NullAppender;
+			appenders.push(nullAppender);
 		}

-		this.server.registerChannel('telemetryAppender', new TelemetryAppenderChannel(telemetryAppender));
+		this.server.registerChannel('telemetryAppender', new TelemetryAppenderChannel(appenders));
 		services.set(ITelemetryService, telemetryService);

 		// Custom Endpoint Telemetry
@@ -271,22 +304,30 @@ class SharedProcessMain extends Disposable {
 		services.set(IUserDataSyncResourceEnablementService, new SyncDescriptor(UserDataSyncResourceEnablementService));
 		services.set(IUserDataSyncService, new SyncDescriptor(UserDataSyncService));

-		// Terminal
-		services.set(
-			ILocalPtyService,
-			this._register(
-				new PtyHostService({
-					graceTime: LocalReconnectConstants.GraceTime,
-					shortGraceTime: LocalReconnectConstants.ShortGraceTime,
-					scrollback: configurationService.getValue<number>(TerminalSettingId.PersistentSessionScrollback) ?? 100,
-					useExperimentalSerialization: configurationService.getValue<boolean>(TerminalSettingId.PersistentSessionExperimentalSerializer) ?? true,
-				},
-					configurationService,
-					logService,
-					telemetryService
-				)
-			)
+		const ptyHostService = new PtyHostService({
+			graceTime: LocalReconnectConstants.GraceTime,
+			shortGraceTime: LocalReconnectConstants.ShortGraceTime,
+			scrollback: configurationService.getValue<number>(TerminalSettingId.PersistentSessionScrollback) ?? 100
+		},
+			configurationService,
+			environmentService,
+			logService,
+			telemetryService
 		);
+		await ptyHostService.initialize();
+
+		// Terminal
+		services.set(ILocalPtyService, this._register(ptyHostService));
+
+		// Extension Host
+		services.set(IExtensionHostStarter, this._register(new ExtensionHostStarter(logService)));
+
+		// Signing
+		services.set(ISignService, new SyncDescriptor(SignService));
+
+		// Tunnel
+		services.set(ISharedTunnelsService, new SyncDescriptor(SharedTunnelsService));
+		services.set(ISharedProcessTunnelService, new SyncDescriptor(SharedProcessTunnelService));

 		return new InstantiationService(services);
 	}
@@ -338,6 +379,18 @@ class SharedProcessMain extends Disposable {
 		const localPtyService = accessor.get(ILocalPtyService);
 		const localPtyChannel = ProxyChannel.fromService(localPtyService);
 		this.server.registerChannel(TerminalIpcChannels.LocalPty, localPtyChannel);
+
+		// Extension Host
+		const extensionHostStarterChannel = ProxyChannel.fromService(accessor.get(IExtensionHostStarter));
+		this.server.registerChannel(ipcExtensionHostStarterChannelName, extensionHostStarterChannel);
+
+		// Tunnel
+		const sharedProcessTunnelChannel = ProxyChannel.fromService(accessor.get(ISharedProcessTunnelService));
+		this.server.registerChannel(ipcSharedProcessTunnelChannelName, sharedProcessTunnelChannel);
+
+		// Worker
+		const sharedProcessWorkerChannel = ProxyChannel.fromService(accessor.get(ISharedProcessWorkerService));
+		this.server.registerChannel(ipcSharedProcessWorkerChannelName, sharedProcessWorkerChannel);
 	}

 	private registerErrorHandler(logService: ILogService): void {