sandbox - move shared process to node layer (#174581)

src/vs/code/node/sharedProcess/contrib/codeCacheCleaner.ts

@@ -0,0 +1,68 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { RunOnceScheduler } from 'vs/base/common/async';
+import { onUnexpectedError } from 'vs/base/common/errors';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { basename, dirname, join } from 'vs/base/common/path';
+import { Promises } from 'vs/base/node/pfs';
+import { ILogService } from 'vs/platform/log/common/log';
+import { IProductService } from 'vs/platform/product/common/productService';
+
+export class CodeCacheCleaner extends Disposable {
+
+	private readonly _DataMaxAge = this.productService.quality !== 'stable'
+		? 1000 * 60 * 60 * 24 * 7 		// roughly 1 week (insiders)
+		: 1000 * 60 * 60 * 24 * 30 * 3; // roughly 3 months (stable)
+
+	constructor(
+		currentCodeCachePath: string | undefined,
+		@IProductService private readonly productService: IProductService,
+		@ILogService private readonly logService: ILogService
+	) {
+		super();
+
+		// Cached data is stored as user data and we run a cleanup task every time
+		// the editor starts. The strategy is to delete all files that are older than
+		// 3 months (1 week respectively)
+		if (currentCodeCachePath) {
+			const scheduler = this._register(new RunOnceScheduler(() => {
+				this.cleanUpCodeCaches(currentCodeCachePath);
+			}, 30 * 1000 /* after 30s */));
+			scheduler.schedule();
+		}
+	}
+
+	private async cleanUpCodeCaches(currentCodeCachePath: string): Promise<void> {
+		this.logService.trace('[code cache cleanup]: Starting to clean up old code cache folders.');
+
+		try {
+			const now = Date.now();
+
+			// The folder which contains folders of cached data.
+			// Each of these folders is partioned per commit
+			const codeCacheRootPath = dirname(currentCodeCachePath);
+			const currentCodeCache = basename(currentCodeCachePath);
+
+			const codeCaches = await Promises.readdir(codeCacheRootPath);
+			await Promise.all(codeCaches.map(async codeCache => {
+				if (codeCache === currentCodeCache) {
+					return; // not the current cache folder
+				}
+
+				// Delete cache folder if old enough
+				const codeCacheEntryPath = join(codeCacheRootPath, codeCache);
+				const codeCacheEntryStat = await Promises.stat(codeCacheEntryPath);
+				if (codeCacheEntryStat.isDirectory() && (now - codeCacheEntryStat.mtime.getTime()) > this._DataMaxAge) {
+					this.logService.trace(`[code cache cleanup]: Removing code cache folder ${codeCache}.`);
+
+					return Promises.rm(codeCacheEntryPath);
+				}
+			}));
+		} catch (error) {
+			onUnexpectedError(error);
+		}
+	}
+}

src/vs/code/node/sharedProcess/contrib/extensions.ts

@@ -0,0 +1,30 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable } from 'vs/base/common/lifecycle';
+import { IExtensionGalleryService, IGlobalExtensionEnablementService } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { ExtensionStorageService, IExtensionStorageService } from 'vs/platform/extensionManagement/common/extensionStorage';
+import { migrateUnsupportedExtensions } from 'vs/platform/extensionManagement/common/unsupportedExtensionsMigration';
+import { INativeServerExtensionManagementService } from 'vs/platform/extensionManagement/node/extensionManagementService';
+import { ILogService } from 'vs/platform/log/common/log';
+import { IStorageService } from 'vs/platform/storage/common/storage';
+
+export class ExtensionsContributions extends Disposable {
+	constructor(
+		@INativeServerExtensionManagementService extensionManagementService: INativeServerExtensionManagementService,
+		@IExtensionGalleryService extensionGalleryService: IExtensionGalleryService,
+		@IExtensionStorageService extensionStorageService: IExtensionStorageService,
+		@IGlobalExtensionEnablementService extensionEnablementService: IGlobalExtensionEnablementService,
+		@IStorageService storageService: IStorageService,
+		@ILogService logService: ILogService,
+	) {
+		super();
+
+		extensionManagementService.cleanUp();
+		migrateUnsupportedExtensions(extensionManagementService, extensionGalleryService, extensionStorageService, extensionEnablementService, logService);
+		ExtensionStorageService.removeOutdatedExtensionVersions(extensionManagementService, storageService);
+	}
+
+}

src/vs/code/node/sharedProcess/contrib/languagePackCachedDataCleaner.ts

@@ -0,0 +1,108 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { RunOnceScheduler } from 'vs/base/common/async';
+import { IStringDictionary } from 'vs/base/common/collections';
+import { onUnexpectedError } from 'vs/base/common/errors';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { join } from 'vs/base/common/path';
+import { Promises } from 'vs/base/node/pfs';
+import { INativeEnvironmentService } from 'vs/platform/environment/common/environment';
+import { ILogService } from 'vs/platform/log/common/log';
+import { IProductService } from 'vs/platform/product/common/productService';
+
+interface IExtensionEntry {
+	version: string;
+	extensionIdentifier: {
+		id: string;
+		uuid: string;
+	};
+}
+
+interface ILanguagePackEntry {
+	hash: string;
+	extensions: IExtensionEntry[];
+}
+
+interface ILanguagePackFile {
+	[locale: string]: ILanguagePackEntry;
+}
+
+export class LanguagePackCachedDataCleaner extends Disposable {
+
+	private readonly _DataMaxAge = this.productService.quality !== 'stable'
+		? 1000 * 60 * 60 * 24 * 7 		// roughly 1 week (insiders)
+		: 1000 * 60 * 60 * 24 * 30 * 3; // roughly 3 months (stable)
+
+	constructor(
+		@INativeEnvironmentService private readonly environmentService: INativeEnvironmentService,
+		@ILogService private readonly logService: ILogService,
+		@IProductService private readonly productService: IProductService
+	) {
+		super();
+
+		// We have no Language pack support for dev version (run from source)
+		// So only cleanup when we have a build version.
+		if (this.environmentService.isBuilt) {
+			const scheduler = this._register(new RunOnceScheduler(() => {
+				this.cleanUpLanguagePackCache();
+			}, 40 * 1000 /* after 40s */));
+			scheduler.schedule();
+		}
+	}
+
+	private async cleanUpLanguagePackCache(): Promise<void> {
+		this.logService.trace('[language pack cache cleanup]: Starting to clean up unused language packs.');
+
+		try {
+			const installed: IStringDictionary<boolean> = Object.create(null);
+			const metaData: ILanguagePackFile = JSON.parse(await Promises.readFile(join(this.environmentService.userDataPath, 'languagepacks.json'), 'utf8'));
+			for (const locale of Object.keys(metaData)) {
+				const entry = metaData[locale];
+				installed[`${entry.hash}.${locale}`] = true;
+			}
+
+			// Cleanup entries for language packs that aren't installed anymore
+			const cacheDir = join(this.environmentService.userDataPath, 'clp');
+			const cacheDirExists = await Promises.exists(cacheDir);
+			if (!cacheDirExists) {
+				return;
+			}
+
+			const entries = await Promises.readdir(cacheDir);
+			for (const entry of entries) {
+				if (installed[entry]) {
+					this.logService.trace(`[language pack cache cleanup]: Skipping folder ${entry}. Language pack still in use.`);
+					continue;
+				}
+
+				this.logService.trace(`[language pack cache cleanup]: Removing unused language pack: ${entry}`);
+
+				await Promises.rm(join(cacheDir, entry));
+			}
+
+			const now = Date.now();
+			for (const packEntry of Object.keys(installed)) {
+				const folder = join(cacheDir, packEntry);
+				const entries = await Promises.readdir(folder);
+				for (const entry of entries) {
+					if (entry === 'tcf.json') {
+						continue;
+					}
+
+					const candidate = join(folder, entry);
+					const stat = await Promises.stat(candidate);
+					if (stat.isDirectory() && (now - stat.mtime.getTime()) > this._DataMaxAge) {
+						this.logService.trace(`[language pack cache cleanup]: Removing language pack cache folder: ${join(packEntry, entry)}`);
+
+						await Promises.rm(candidate);
+					}
+				}
+			}
+		} catch (error) {
+			onUnexpectedError(error);
+		}
+	}
+}

src/vs/code/node/sharedProcess/contrib/localizationsUpdater.ts

@@ -0,0 +1,23 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable } from 'vs/base/common/lifecycle';
+import { ILanguagePackService } from 'vs/platform/languagePacks/common/languagePacks';
+import { NativeLanguagePackService } from 'vs/platform/languagePacks/node/languagePacks';
+
+export class LocalizationsUpdater extends Disposable {
+
+	constructor(
+		@ILanguagePackService private readonly localizationsService: NativeLanguagePackService
+	) {
+		super();
+
+		this.updateLocalizations();
+	}
+
+	private updateLocalizations(): void {
+		this.localizationsService.update();
+	}
+}

src/vs/code/node/sharedProcess/contrib/logsDataCleaner.ts

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { RunOnceScheduler } from 'vs/base/common/async';
+import { onUnexpectedError } from 'vs/base/common/errors';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { basename, dirname, join } from 'vs/base/common/path';
+import { Promises } from 'vs/base/node/pfs';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { ILogService } from 'vs/platform/log/common/log';
+
+export class LogsDataCleaner extends Disposable {
+
+	constructor(
+		@IEnvironmentService private readonly environmentService: IEnvironmentService,
+		@ILogService private readonly logService: ILogService
+	) {
+		super();
+
+		const scheduler = this._register(new RunOnceScheduler(() => {
+			this.cleanUpOldLogs();
+		}, 10 * 1000 /* after 10s */));
+		scheduler.schedule();
+	}
+
+	private async cleanUpOldLogs(): Promise<void> {
+		this.logService.trace('[logs cleanup]: Starting to clean up old logs.');
+
+		try {
+			const currentLog = basename(this.environmentService.logsPath);
+			const logsRoot = dirname(this.environmentService.logsPath);
+
+			const logFiles = await Promises.readdir(logsRoot);
+
+			const allSessions = logFiles.filter(logFile => /^\d{8}T\d{6}$/.test(logFile));
+			const oldSessions = allSessions.sort().filter(session => session !== currentLog);
+			const sessionsToDelete = oldSessions.slice(0, Math.max(0, oldSessions.length - 9));
+
+			if (sessionsToDelete.length > 0) {
+				this.logService.trace(`[logs cleanup]: Removing log folders '${sessionsToDelete.join(', ')}'`);
+
+				await Promise.all(sessionsToDelete.map(sessionToDelete => Promises.rm(join(logsRoot, sessionToDelete))));
+			}
+		} catch (error) {
+			onUnexpectedError(error);
+		}
+	}
+}

src/vs/code/node/sharedProcess/contrib/storageDataCleaner.ts

@@ -0,0 +1,74 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { RunOnceScheduler } from 'vs/base/common/async';
+import { onUnexpectedError } from 'vs/base/common/errors';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { join } from 'vs/base/common/path';
+import { Promises } from 'vs/base/node/pfs';
+import { INativeEnvironmentService } from 'vs/platform/environment/common/environment';
+import { ILogService } from 'vs/platform/log/common/log';
+import { StorageClient } from 'vs/platform/storage/common/storageIpc';
+import { EXTENSION_DEVELOPMENT_EMPTY_WINDOW_WORKSPACE } from 'vs/platform/workspace/common/workspace';
+import { NON_EMPTY_WORKSPACE_ID_LENGTH } from 'vs/platform/workspaces/node/workspaces';
+
+/* eslint-disable local/code-layering, local/code-import-patterns */
+// TODO@bpasero layer is not allowed in utility process
+import { IMainProcessService } from 'vs/platform/ipc/electron-sandbox/services';
+import { INativeHostService } from 'vs/platform/native/electron-sandbox/native';
+
+export class UnusedWorkspaceStorageDataCleaner extends Disposable {
+
+	constructor(
+		@INativeEnvironmentService private readonly environmentService: INativeEnvironmentService,
+		@ILogService private readonly logService: ILogService,
+		@INativeHostService private readonly nativeHostService: INativeHostService,
+		@IMainProcessService private readonly mainProcessService: IMainProcessService
+	) {
+		super();
+
+		const scheduler = this._register(new RunOnceScheduler(() => {
+			this.cleanUpStorage();
+		}, 30 * 1000 /* after 30s */));
+		scheduler.schedule();
+	}
+
+	private async cleanUpStorage(): Promise<void> {
+		this.logService.trace('[storage cleanup]: Starting to clean up workspace storage folders for unused empty workspaces.');
+
+		try {
+			const workspaceStorageFolders = await Promises.readdir(this.environmentService.workspaceStorageHome.fsPath);
+			const storageClient = new StorageClient(this.mainProcessService.getChannel('storage'));
+
+			await Promise.all(workspaceStorageFolders.map(async workspaceStorageFolder => {
+				const workspaceStoragePath = join(this.environmentService.workspaceStorageHome.fsPath, workspaceStorageFolder);
+
+				if (workspaceStorageFolder.length === NON_EMPTY_WORKSPACE_ID_LENGTH) {
+					return; // keep workspace storage for folders/workspaces that can be accessed still
+				}
+
+				if (workspaceStorageFolder === EXTENSION_DEVELOPMENT_EMPTY_WINDOW_WORKSPACE.id) {
+					return; // keep workspace storage for empty extension development workspaces
+				}
+
+				const windows = await this.nativeHostService.getWindows();
+				if (windows.some(window => window.workspace?.id === workspaceStorageFolder)) {
+					return; // keep workspace storage for empty workspaces opened as window
+				}
+
+				const isStorageUsed = await storageClient.isUsed(workspaceStoragePath);
+				if (isStorageUsed) {
+					return; // keep workspace storage for empty workspaces that are in use
+				}
+
+				this.logService.trace(`[storage cleanup]: Deleting workspace storage folder ${workspaceStorageFolder} as it seems to be an unused empty workspace.`);
+
+				await Promises.rm(workspaceStoragePath);
+			}));
+		} catch (error) {
+			onUnexpectedError(error);
+		}
+	}
+}

src/vs/code/node/sharedProcess/contrib/userDataProfilesCleaner.ts

@@ -0,0 +1,22 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { RunOnceScheduler } from 'vs/base/common/async';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { IUserDataProfilesService } from 'vs/platform/userDataProfile/common/userDataProfile';
+
+export class UserDataProfilesCleaner extends Disposable {
+
+	constructor(
+		@IUserDataProfilesService userDataProfilesService: IUserDataProfilesService
+	) {
+		super();
+
+		const scheduler = this._register(new RunOnceScheduler(() => {
+			userDataProfilesService.cleanUp();
+		}, 10 * 1000 /* after 10s */));
+		scheduler.schedule();
+	}
+}