shared process - register channels when IPC ready

Author: bpasero

src/vs/code/electron-browser/sharedProcess/sharedProcessMain.ts

@@ -61,6 +61,9 @@ import { KeytarCredentialsService } from 'vs/platform/credentials/node/credentia
 import { UserDataAutoSyncService } from 'vs/platform/userDataSync/electron-browser/userDataAutoSyncService';
 import { SettingsSynchroniser } from 'vs/platform/userDataSync/common/settingsSync';
 import { UserDataAuthTokenService } from 'vs/platform/userDataSync/common/userDataAuthTokenService';
+import { NativeStorageService } from 'vs/platform/storage/node/storageService';
+import { GlobalStorageDatabaseChannelClient } from 'vs/platform/storage/node/storageIpc';
+import { IStorageService } from 'vs/platform/storage/common/storage';
 
 export interface ISharedProcessConfiguration {
 	readonly machineId: string;
@@ -119,6 +122,11 @@ async function main(server: Server, initData: ISharedProcessInitData, configurat
 	disposables.add(configurationService);
 	await configurationService.initialize();
 
+	const storageService = new NativeStorageService(new GlobalStorageDatabaseChannelClient(mainProcessService.getChannel('storage')), logService, environmentService);
+	await storageService.initialize();
+	services.set(IStorageService, storageService);
+	disposables.add(toDisposable(() => storageService.flush()));
+
 	services.set(IEnvironmentService, environmentService);
 	services.set(IProductService, { _serviceBrand: undefined, ...product });
 	services.set(ILogService, logService);

src/vs/code/electron-main/app.ts

@@ -364,8 +364,14 @@ export class CodeApplication extends Disposable {
 
 		// Spawn shared process after the first window has opened and 3s have passed
 		const sharedProcess = this.instantiationService.createInstance(SharedProcess, machineId, this.userEnv);
-		const sharedProcessClient = sharedProcess.whenIpcReady().then(() => connect(this.environmentService.sharedIPCHandle, 'main'));
-		const sharedProcessReady = sharedProcess.whenReady().then(() => sharedProcessClient);
+		const sharedProcessClient = sharedProcess.whenIpcReady().then(() => {
+			this.logService.trace('Shared process: IPC ready');
+			return connect(this.environmentService.sharedIPCHandle, 'main');
+		});
+		const sharedProcessReady = sharedProcess.whenReady().then(() => {
+			this.logService.trace('Shared process: init ready');
+			return sharedProcessClient;
+		});
 		this.lifecycleMainService.when(LifecycleMainPhase.AfterWindowOpen).then(() => {
 			this._register(new RunOnceScheduler(async () => {
 				const userEnv = await getShellEnvironment(this.logService, this.environmentService);
@@ -389,7 +395,7 @@ export class CodeApplication extends Disposable {
 		this._register(new ProxyAuthHandler());
 
 		// Open Windows
-		const windows = appInstantiationService.invokeFunction(accessor => this.openFirstWindow(accessor, electronIpcServer, sharedProcessReady));
+		const windows = appInstantiationService.invokeFunction(accessor => this.openFirstWindow(accessor, electronIpcServer, sharedProcessClient));
 
 		// Post Open Windows Tasks
 		this.afterWindowOpen();
@@ -425,7 +431,7 @@ export class CodeApplication extends Disposable {
 		return { machineId, trueMachineId };
 	}
 
-	private async createServices(machineId: string, trueMachineId: string | undefined, sharedProcess: SharedProcess, sharedProcessClient: Promise<Client<string>>): Promise<IInstantiationService> {
+	private async createServices(machineId: string, trueMachineId: string | undefined, sharedProcess: SharedProcess, sharedProcessReady: Promise<Client<string>>): Promise<IInstantiationService> {
 		const services = new ServiceCollection();
 
 		const fileService = this._register(new FileService(this.logService));
@@ -457,7 +463,7 @@ export class CodeApplication extends Disposable {
 		services.set(ISharedProcessMainService, new SyncDescriptor(SharedProcessMainService, [sharedProcess]));
 		services.set(ILaunchMainService, new SyncDescriptor(LaunchMainService));
 
-		const diagnosticsChannel = getDelayedChannel(sharedProcessClient.then(client => client.getChannel('diagnostics')));
+		const diagnosticsChannel = getDelayedChannel(sharedProcessReady.then(client => client.getChannel('diagnostics')));
 		services.set(IDiagnosticsService, new SyncDescriptor(DiagnosticsService, [diagnosticsChannel]));
 
 		services.set(IIssueService, new SyncDescriptor(IssueMainService, [machineId, this.userEnv]));
@@ -478,7 +484,7 @@ export class CodeApplication extends Disposable {
 
 		// Telemetry
 		if (!this.environmentService.isExtensionDevelopment && !this.environmentService.args['disable-telemetry'] && !!product.enableTelemetry) {
-			const channel = getDelayedChannel(sharedProcessClient.then(client => client.getChannel('telemetryAppender')));
+			const channel = getDelayedChannel(sharedProcessReady.then(client => client.getChannel('telemetryAppender')));
 			const appender = combinedAppender(new TelemetryAppenderClient(channel), new LogAppender(this.logService));
 			const commonProperties = resolveCommonProperties(product.commit, product.version, machineId, product.msftInternalDomains, this.environmentService.installSourcePath);
 			const piiPaths = this.environmentService.extensionsPath ? [this.environmentService.appRoot, this.environmentService.extensionsPath] : [this.environmentService.appRoot];
@@ -572,6 +578,7 @@ export class CodeApplication extends Disposable {
 		const storageMainService = accessor.get(IStorageMainService);
 		const storageChannel = this._register(new GlobalStorageDatabaseChannel(this.logService, storageMainService));
 		electronIpcServer.registerChannel('storage', storageChannel);
+		sharedProcessClient.then(client => client.registerChannel('storage', storageChannel));
 
 		const loggerChannel = new LoggerChannel(accessor.get(ILogService));
 		electronIpcServer.registerChannel('logger', loggerChannel);