sandbox - make shared process service available on startup

bpasero · bpasero · commit 067261c03ba3 · 2021-10-14T08:34:35.000+02:00
diff --git a/src/vs/base/parts/sandbox/electron-browser/preload.js b/src/vs/base/parts/sandbox/electron-browser/preload.js
@@ -211,12 +211,11 @@
 		ipcMessagePort: {
 
 			/**
-			 * @param {string} channelRequest
 			 * @param {string} channelResponse
 			 * @param {string} requestNonce
 			 */
-			connect(channelRequest, channelResponse, requestNonce) {
-				if (validateIPC(channelRequest) && validateIPC(channelResponse)) {
+			acquire(channelResponse, requestNonce) {
+				if (validateIPC(channelResponse)) {
 					const responseListener = (/** @type {IpcRendererEvent} */ e, /** @type {string} */ responseNonce) => {
 						// validate that the nonce from the response is the same
 						// as when requested. and if so, use `postMessage` to
@@ -228,9 +227,8 @@
 						}
 					};
 
-					// request message port from main and await result
+					// handle reply from main
 					ipcRenderer.on(channelResponse, responseListener);
-					ipcRenderer.send(channelRequest, requestNonce);
 				}
 			}
 		},
diff --git a/src/vs/base/parts/sandbox/electron-sandbox/globals.ts b/src/vs/base/parts/sandbox/electron-sandbox/globals.ts
@@ -94,16 +94,15 @@ export interface ISandboxNodeProcess extends INodeProcess {
 export interface IpcMessagePort {
 
 	/**
-	 * Establish a connection via `MessagePort` to a target. The main process
-	 * will need to transfer the port over to the `channelResponse` after listening
-	 * to `channelRequest` with a payload of `requestNonce` so that the
-	 * source can correlate the response.
+	 * Acquire a `MessagePort`. The main process will transfer the port over to
+	 * the `responseChannel` with a payload of `requestNonce` so that the source can
+	 * correlate the response.
 	 *
 	 * The source should install a `window.on('message')` listener, ensuring `e.data`
-	 * matches `requestNonce`, `e.source` matches `window` and then receiving the
-	 * `MessagePort` via `e.ports[0]`.
+	 * matches `nonce`, `e.source` matches `window` and then receiving the `MessagePort`
+	 * via `e.ports[0]`.
 	 */
-	connect(channelRequest: string, channelResponse: string, requestNonce: string): void;
+	acquire(responseChannel: string, nonce: string): void;
 }
 
 export interface ISandboxContext {
diff --git a/src/vs/base/worker/workerMain.ts b/src/vs/base/worker/workerMain.ts
@@ -89,7 +89,7 @@
 						(<any>self).postMessage(msg, transfer);
 					}, null);
 
-					self.onmessage = (e: MessageEvent) => messageHandler.onmessage(e.data);
+					self.onmessage = (e: MessageEvent) => messageHandler.onmessage(e.data, e.ports);
 					while (beforeReadyMessages.length > 0) {
 						self.onmessage(beforeReadyMessages.shift()!);
 					}
diff --git 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);
 				}
diff --git 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);
 					}
diff --git 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))));
 			}
diff --git 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));
 				}
diff --git a/src/vs/platform/ipc/electron-sandbox/services.ts b/src/vs/platform/ipc/electron-sandbox/services.ts
@@ -72,9 +72,13 @@ export function registerMainProcessRemoteService<T>(id: ServiceIdentifier<T>, ch
 export const ISharedProcessService = createDecorator<ISharedProcessService>('sharedProcessService');
 
 export interface ISharedProcessService {
+
 	readonly _serviceBrand: undefined;
+
 	getChannel(channelName: string): IChannel;
 	registerChannel(channelName: string, channel: IServerChannel<string>): void;
+
+	notifyRestored(): void;
 }
 
 class SharedProcessRemoteServiceStub<T> extends RemoteServiceStub<T> {
diff --git a/src/vs/workbench/electron-browser/desktop.main.ts b/src/vs/workbench/electron-browser/desktop.main.ts
@@ -13,6 +13,7 @@ import { DiskFileSystemProvider } from 'vs/platform/files/electron-browser/diskF
 import { FileUserDataProvider } from 'vs/workbench/services/userData/common/fileUserDataProvider';
 import { INativeHostService } from 'vs/platform/native/electron-sandbox/native';
 import { SharedDesktopMain } from 'vs/workbench/electron-sandbox/shared.desktop.main';
+import { IMainProcessService } from 'vs/platform/ipc/electron-sandbox/services';
 
 class DesktopMain extends SharedDesktopMain {
 
@@ -23,7 +24,13 @@ class DesktopMain extends SharedDesktopMain {
 		gracefulify(fs);
 	}
 
-	protected registerFileSystemProviders(environmentService: INativeWorkbenchEnvironmentService, fileService: IFileService, logService: ILogService, nativeHostService: INativeHostService): void {
+	protected registerFileSystemProviders(
+		mainProcessService: IMainProcessService,
+		environmentService: INativeWorkbenchEnvironmentService,
+		fileService: IFileService,
+		logService: ILogService,
+		nativeHostService: INativeHostService
+	): void {
 
 		// Local Files
 		const diskFileSystemProvider = this._register(new DiskFileSystemProvider(logService, nativeHostService, { legacyWatcher: this.configuration.legacyWatcher }));
diff --git a/src/vs/workbench/electron-sandbox/desktop.main.ts b/src/vs/workbench/electron-sandbox/desktop.main.ts
@@ -10,14 +10,22 @@ import { IFileService } from 'vs/platform/files/common/files';
 import { FileUserDataProvider } from 'vs/workbench/services/userData/common/fileUserDataProvider';
 import { initFileSystem, simpleFileSystemProvider, simpleWorkspaceDir } from 'vs/workbench/electron-sandbox/sandbox.simpleservices';
 import { SharedDesktopMain } from 'vs/workbench/electron-sandbox/shared.desktop.main';
+import { IMainProcessService } from 'vs/platform/ipc/electron-sandbox/services';
+import { INativeHostService } from 'vs/platform/native/electron-sandbox/native';
 
 class DesktopMain extends SharedDesktopMain {
 
 	constructor(configuration: INativeWorkbenchConfiguration) {
 		super({ ...configuration, workspace: { id: configuration.workspace?.id ?? '4064f6ec-cb38-4ad0-af64-ee6467e63c82', uri: simpleWorkspaceDir } });
 	}
 
-	protected registerFileSystemProviders(environmentService: INativeWorkbenchEnvironmentService, fileService: IFileService, logService: ILogService): Promise<void> {
+	protected registerFileSystemProviders(
+		mainProcessService: IMainProcessService,
+		environmentService: INativeWorkbenchEnvironmentService,
+		fileService: IFileService,
+		logService: ILogService,
+		nativeHostService: INativeHostService
+	): Promise<void> {
 
 		// Local Files
 		fileService.registerProvider(Schemas.file, simpleFileSystemProvider);
diff --git a/src/vs/workbench/electron-sandbox/shared.desktop.main.ts b/src/vs/workbench/electron-sandbox/shared.desktop.main.ts
@@ -22,7 +22,8 @@ import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace
 import { IWorkbenchConfigurationService } from 'vs/workbench/services/configuration/common/configuration';
 import { IStorageService } from 'vs/platform/storage/common/storage';
 import { Disposable } from 'vs/base/common/lifecycle';
-import { IMainProcessService } from 'vs/platform/ipc/electron-sandbox/services';
+import { IMainProcessService, ISharedProcessService } from 'vs/platform/ipc/electron-sandbox/services';
+import { SharedProcessService } from 'vs/workbench/services/ipc/electron-sandbox/sharedProcessService';
 import { RemoteAuthorityResolverService } from 'vs/platform/remote/electron-sandbox/remoteAuthorityResolverService';
 import { IRemoteAuthorityResolverService } from 'vs/platform/remote/common/remoteAuthorityResolver';
 import { RemoteAgentService } from 'vs/workbench/services/remote/electron-sandbox/remoteAgentServiceImpl';
@@ -130,7 +131,13 @@ export abstract class SharedDesktopMain extends Disposable {
 		this._register(workbench.onDidShutdown(() => this.dispose()));
 	}
 
-	protected abstract registerFileSystemProviders(environmentService: INativeWorkbenchEnvironmentService, fileService: IFileService, logService: ILogService, nativeHostService: INativeHostService): void | Promise<void>;
+	protected abstract registerFileSystemProviders(
+		mainProcessService: IMainProcessService,
+		environmentService: INativeWorkbenchEnvironmentService,
+		fileService: IFileService,
+		logService: ILogService,
+		nativeHostService: INativeHostService
+	): void | Promise<void>;
 
 	private async initServices(): Promise<{ serviceCollection: ServiceCollection, logService: ILogService, storageService: NativeStorageService }> {
 		const serviceCollection = new ServiceCollection();
@@ -170,6 +177,10 @@ export abstract class SharedDesktopMain extends Disposable {
 		const logService = this._register(new NativeLogService(`renderer${this.configuration.windowId}`, environmentService.configuration.logLevel, loggerService, logLevelChannelClient, environmentService));
 		serviceCollection.set(ILogService, logService);
 
+		// Shared Process
+		const sharedProcessService = new SharedProcessService(this.configuration.windowId, logService);
+		serviceCollection.set(ISharedProcessService, sharedProcessService);
+
 		// Remote
 		const remoteAuthorityResolverService = new RemoteAuthorityResolverService();
 		serviceCollection.set(IRemoteAuthorityResolverService, remoteAuthorityResolverService);
@@ -204,7 +215,7 @@ export abstract class SharedDesktopMain extends Disposable {
 		const fileService = this._register(new FileService(logService));
 		serviceCollection.set(IFileService, fileService);
 
-		const result = this.registerFileSystemProviders(environmentService, fileService, logService, nativeHostService);
+		const result = this.registerFileSystemProviders(mainProcessService, environmentService, fileService, logService, nativeHostService);
 		if (result instanceof Promise) {
 			await result;
 		}
diff --git a/src/vs/workbench/electron-sandbox/window.ts b/src/vs/workbench/electron-sandbox/window.ts
@@ -60,6 +60,7 @@ import { AuthInfo } from 'vs/base/parts/sandbox/electron-sandbox/electronTypes';
 import { ILogService } from 'vs/platform/log/common/log';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { whenEditorClosed } from 'vs/workbench/browser/editor';
+import { ISharedProcessService } from 'vs/platform/ipc/electron-sandbox/services';
 
 export class NativeWindow extends Disposable {
 
@@ -109,7 +110,8 @@ export class NativeWindow extends Disposable {
 		@IDialogService private readonly dialogService: IDialogService,
 		@IStorageService private readonly storageService: IStorageService,
 		@ILogService private readonly logService: ILogService,
-		@IInstantiationService private readonly instantiationService: IInstantiationService
+		@IInstantiationService private readonly instantiationService: IInstantiationService,
+		@ISharedProcessService private readonly sharedProcessService: ISharedProcessService
 	) {
 		super();
 
@@ -448,8 +450,9 @@ export class NativeWindow extends Disposable {
 		// Handle open calls
 		this.setupOpenHandlers();
 
-		// Notify main side when window ready
+		// Notify some services about lifecycle phases
 		this.lifecycleService.when(LifecyclePhase.Ready).then(() => this.nativeHostService.notifyReady());
+		this.lifecycleService.when(LifecyclePhase.Restored).then(() => this.sharedProcessService.notifyRestored());
 
 		// Integrity warning
 		this.integrityService.isPure().then(({ isPure }) => this.titleService.updateProperties({ isPure }));
diff --git a/src/vs/workbench/services/ipc/electron-sandbox/sharedProcessService.ts b/src/vs/workbench/services/ipc/electron-sandbox/sharedProcessService.ts
@@ -4,29 +4,27 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { Event } from 'vs/base/common/event';
-import { ipcMessagePort } from 'vs/base/parts/sandbox/electron-sandbox/globals';
+import { ipcMessagePort, ipcRenderer } from 'vs/base/parts/sandbox/electron-sandbox/globals';
 import { Client as MessagePortClient } from 'vs/base/parts/ipc/common/ipc.mp';
 import { IChannel, IServerChannel, getDelayedChannel } from 'vs/base/parts/ipc/common/ipc';
-import { INativeHostService } from 'vs/platform/native/electron-sandbox/native';
 import { generateUuid } from 'vs/base/common/uuid';
 import { ILogService } from 'vs/platform/log/common/log';
 import { Disposable } from 'vs/base/common/lifecycle';
 import { ISharedProcessService } from 'vs/platform/ipc/electron-sandbox/services';
 import { mark } from 'vs/base/common/performance';
-import { ILifecycleService, LifecyclePhase } from 'vs/workbench/services/lifecycle/common/lifecycle';
-import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
-import { timeout } from 'vs/base/common/async';
+import { Barrier, timeout } from 'vs/base/common/async';
 
 export class SharedProcessService extends Disposable implements ISharedProcessService {
 
 	declare readonly _serviceBrand: undefined;
 
 	private readonly withSharedProcessConnection: Promise<MessagePortClient>;
 
+	private readonly restoredBarrier = new Barrier();
+
 	constructor(
-		@INativeHostService private readonly nativeHostService: INativeHostService,
-		@ILogService private readonly logService: ILogService,
-		@ILifecycleService private readonly lifecycleService: ILifecycleService
+		readonly windowId: number,
+		@ILogService private readonly logService: ILogService
 	) {
 		super();
 
@@ -44,14 +42,15 @@ export class SharedProcessService extends Disposable implements ISharedProcessSe
 		// timeout to be safe against possible deadlocks.
 		// TODO@sandbox revisit this when the shared process connection
 		// is more cruicial.
-		await Promise.race([this.lifecycleService.when(LifecyclePhase.Restored), timeout(2000)]);
+		await Promise.race([this.restoredBarrier.wait(), timeout(2000)]);
 
 		mark('code/willConnectSharedProcess');
 
 		// Ask to create message channel inside the window
 		// and send over a UUID to correlate the response
 		const nonce = generateUuid();
-		ipcMessagePort.connect('vscode:createSharedProcessMessageChannel', 'vscode:createSharedProcessMessageChannelResult', nonce);
+		ipcMessagePort.acquire('vscode:createSharedProcessMessageChannelResult', nonce);
+		ipcRenderer.send('vscode:createSharedProcessMessageChannel', nonce);
 
 		// Wait until the main side has returned the `MessagePort`
 		// We need to filter by the `nonce` to ensure we listen
@@ -62,7 +61,13 @@ export class SharedProcessService extends Disposable implements ISharedProcessSe
 		mark('code/didConnectSharedProcess');
 		this.logService.trace('Renderer->SharedProcess#connect: connection established');
 
-		return this._register(new MessagePortClient(port, `window:${this.nativeHostService.windowId}`));
+		return this._register(new MessagePortClient(port, `window:${this.windowId}`));
+	}
+
+	notifyRestored(): void {
+		if (!this.restoredBarrier.isOpen()) {
+			this.restoredBarrier.open();
+		}
 	}
 
 	getChannel(channelName: string): IChannel {
@@ -73,5 +78,3 @@ export class SharedProcessService extends Disposable implements ISharedProcessSe
 		this.withSharedProcessConnection.then(connection => connection.registerChannel(channelName, channel));
 	}
 }
-
-registerSingleton(ISharedProcessService, SharedProcessService, true);
diff --git a/src/vs/workbench/test/electron-browser/workbenchTestServices.ts b/src/vs/workbench/test/electron-browser/workbenchTestServices.ts
@@ -163,6 +163,8 @@ export class TestSharedProcessService implements ISharedProcessService {
 	getChannel(channelName: string): any { return undefined; }
 
 	registerChannel(channelName: string, channel: any): void { }
+
+	notifyRestored(): void { }
 }
 
 export class TestNativeHostService implements INativeHostService {
diff --git a/src/vs/workbench/workbench.sandbox.main.ts b/src/vs/workbench/workbench.sandbox.main.ts
@@ -60,7 +60,6 @@ import 'vs/workbench/services/userDataSync/electron-sandbox/userDataSyncService'
 import 'vs/workbench/services/userDataSync/electron-sandbox/userDataSyncAccountService';
 import 'vs/workbench/services/userDataSync/electron-sandbox/userDataSyncStoreManagementService';
 import 'vs/workbench/services/userDataSync/electron-sandbox/userDataAutoSyncService';
-import 'vs/workbench/services/ipc/electron-sandbox/sharedProcessService';
 import 'vs/workbench/services/timer/electron-sandbox/timerService';
 import 'vs/workbench/services/environment/electron-sandbox/shellEnvironmentService';
 import 'vs/workbench/services/integrity/electron-sandbox/integrityService';

Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@`
`89`	`89`	`(<any>self).postMessage(msg, transfer);`
`90`	`90`	`}, null);`
`91`	`91`
`92`		`- self.onmessage = (e: MessageEvent) => messageHandler.onmessage(e.data);`
	`92`	`+ self.onmessage = (e: MessageEvent) => messageHandler.onmessage(e.data, e.ports);`
`93`	`93`	`while (beforeReadyMessages.length > 0) {`
`94`	`94`	`self.onmessage(beforeReadyMessages.shift()!);`
`95`	`95`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ export class CodeCacheCleaner extends Disposable {`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`private async cleanUpCodeCaches(currentCodeCachePath: string): Promise<void> {`
`39`		`- this.logService.info('[code cache cleanup]: Starting to clean up old code cache folders.');`
	`39`	`+ this.logService.trace('[code cache cleanup]: Starting to clean up old code cache folders.');`
`40`	`40`
`41`	`41`	`try {`
`42`	`42`	`const now = Date.now();`
`@@ -56,7 +56,7 @@ export class CodeCacheCleaner extends Disposable {`
`56`	`56`	`const codeCacheEntryPath = join(codeCacheRootPath, codeCache);`
`57`	`57`	`const codeCacheEntryStat = await Promises.stat(codeCacheEntryPath);`
`58`	`58`	`if (codeCacheEntryStat.isDirectory() && (now - codeCacheEntryStat.mtime.getTime()) > this._DataMaxAge) {`
`59`		- this.logService.info(`[code cache cleanup]: Removing code cache folder ${codeCache}.`);
	`59`	+ this.logService.trace(`[code cache cleanup]: Removing code cache folder ${codeCache}.`);
`60`	`60`
`61`	`61`	`return Promises.rm(codeCacheEntryPath);`
`62`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ export class LogsDataCleaner extends Disposable {`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`private async cleanUpOldLogs(): Promise<void> {`
`29`		`- this.logService.info('[logs cleanup]: Starting to clean up old logs.');`
	`29`	`+ this.logService.trace('[logs cleanup]: Starting to clean up old logs.');`
`30`	`30`
`31`	`31`	`try {`
`32`	`32`	`const currentLog = basename(this.environmentService.logsPath);`
`@@ -39,7 +39,7 @@ export class LogsDataCleaner extends Disposable {`
`39`	`39`	`const sessionsToDelete = oldSessions.slice(0, Math.max(0, oldSessions.length - 9));`
`40`	`40`
`41`	`41`	`if (sessionsToDelete.length > 0) {`
`42`		- this.logService.info(`[logs cleanup]: Removing log folders '${sessionsToDelete.join(', ')}'`);
	`42`	+ this.logService.trace(`[logs cleanup]: Removing log folders '${sessionsToDelete.join(', ')}'`);
`43`	`43`
`44`	`44`	`await Promise.all(sessionsToDelete.map(sessionToDelete => Promises.rm(join(logsRoot, sessionToDelete))));`
`45`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ export class StorageDataCleaner extends Disposable {`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`private async cleanUpStorage(): Promise<void> {`
`34`		`- this.logService.info('[storage cleanup]: Starting to clean up storage folders.');`
	`34`	`+ this.logService.trace('[storage cleanup]: Starting to clean up storage folders.');`
`35`	`35`
`36`	`36`	`try {`
`37`	`37`
`@@ -50,7 +50,7 @@ export class StorageDataCleaner extends Disposable {`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`if (emptyWorkspaces.indexOf(storageFolder) === -1) {`
`53`		- this.logService.info(`[storage cleanup]: Deleting storage folder ${storageFolder}.`);
	`53`	+ this.logService.trace(`[storage cleanup]: Deleting storage folder ${storageFolder}.`);
`54`	`54`
`55`	`55`	`await Promises.rm(join(this.environmentService.workspaceStorageHome.fsPath, storageFolder));`
`56`	`56`	`}`