storage - allow to migrate to a new profile (microsoft#152317)

* storage - allow to migrate to a new profile

* reuse data migration code

* use correct profile for logging

* cleanup

* address feedback

* dont dipsose store

* lipstick

* align

* simplify

* rensmes

* pause emitters

* reuse

Author: bpasero

src/vs/editor/contrib/find/test/browser/findController.test.ts

@@ -80,8 +80,8 @@ suite('FindController', async () => {
 		isNew: () => false,
 		flush: () => { return Promise.resolve(); },
 		keys: () => [],
-		logStorage: () => { },
-		migrate: () => { throw new Error(); }
+		log: () => { },
+		switch: () => { throw new Error(); }
 	} as IStorageService);
 
 	if (platform.isMacintosh) {
@@ -511,8 +511,8 @@ suite('FindController query options persistence', async () => {
 		isNew: () => false,
 		flush: () => { return Promise.resolve(); },
 		keys: () => [],
-		logStorage: () => { },
-		migrate: () => { throw new Error(); }
+		log: () => { },
+		switch: () => { throw new Error(); }
 	} as IStorageService);
 
 	test('matchCase', async () => {

src/vs/editor/contrib/multicursor/test/browser/multicursor.test.ts

@@ -94,8 +94,8 @@ suite('Multicursor selection', () => {
 		getNumber: (key: string) => undefined!,
 		store: (key: string, value: any) => { queryState[key] = value; return Promise.resolve(); },
 		remove: (key) => undefined,
-		logStorage: () => undefined,
-		migrate: (toWorkspace) => Promise.resolve(undefined),
+		log: () => undefined,
+		switch: () => Promise.resolve(undefined),
 		flush: () => Promise.resolve(undefined),
 		isNew: () => true,
 		keys: () => []

src/vs/platform/storage/browser/storageService.ts

@@ -5,26 +5,31 @@
 
 import { isSafari } from 'vs/base/browser/browser';
 import { IndexedDB } from 'vs/base/browser/indexedDB';
-import { Promises } from 'vs/base/common/async';
+import { DeferredPromise, Promises } from 'vs/base/common/async';
 import { toErrorMessage } from 'vs/base/common/errorMessage';
 import { Emitter } from 'vs/base/common/event';
-import { Disposable, IDisposable, toDisposable } from 'vs/base/common/lifecycle';
+import { Disposable, DisposableStore, IDisposable, toDisposable } from 'vs/base/common/lifecycle';
+import { assertIsDefined } from 'vs/base/common/types';
 import { InMemoryStorageDatabase, isStorageItemsChangeEvent, IStorage, IStorageDatabase, IStorageItemsChangeEvent, IUpdateRequest, Storage } from 'vs/base/parts/storage/common/storage';
 import { ILogService } from 'vs/platform/log/common/log';
 import { AbstractStorageService, IS_NEW_KEY, StorageScope, StorageTarget } from 'vs/platform/storage/common/storage';
-import { IUserDataProfilesService } from 'vs/platform/userDataProfile/common/userDataProfile';
+import { IUserDataProfile, IUserDataProfilesService } from 'vs/platform/userDataProfile/common/userDataProfile';
 import { IAnyWorkspaceIdentifier } from 'vs/platform/workspace/common/workspace';
 
 export class BrowserStorageService extends AbstractStorageService {
 
 	private static BROWSER_DEFAULT_FLUSH_INTERVAL = 5 * 1000; // every 5s because async operations are not permitted on shutdown
 
 	private applicationStorage: IStorage | undefined;
-	private globalStorage: IStorage | undefined;
-	private workspaceStorage: IStorage | undefined;
-
 	private applicationStorageDatabase: IIndexedDBStorageDatabase | undefined;
+	private readonly applicationStoragePromise = new DeferredPromise<{ indededDb: IIndexedDBStorageDatabase; storage: IStorage }>();
+
+	private globalStorage: IStorage | undefined;
 	private globalStorageDatabase: IIndexedDBStorageDatabase | undefined;
+	private globalStorageProfile: IUserDataProfile;
+	private readonly globalStorageDisposables = this._register(new DisposableStore());
+
+	private workspaceStorage: IStorage | undefined;
 	private workspaceStorageDatabase: IIndexedDBStorageDatabase | undefined;
 
 	get hasPendingUpdate(): boolean {
@@ -38,20 +43,22 @@ export class BrowserStorageService extends AbstractStorageService {
 	constructor(
 		private readonly payload: IAnyWorkspaceIdentifier,
 		@ILogService private readonly logService: ILogService,
-		@IUserDataProfilesService private readonly userDataProfileService: IUserDataProfilesService
+		@IUserDataProfilesService userDataProfileService: IUserDataProfilesService
 	) {
 		super({ flushInterval: BrowserStorageService.BROWSER_DEFAULT_FLUSH_INTERVAL });
+
+		this.globalStorageProfile = userDataProfileService.currentProfile;
 	}
 
 	private getId(scope: StorageScope): string {
 		switch (scope) {
 			case StorageScope.APPLICATION:
 				return 'global'; // use the default profile global DB for application scope
 			case StorageScope.GLOBAL:
-				if (this.userDataProfileService.currentProfile.isDefault) {
+				if (this.globalStorageProfile.isDefault) {
 					return 'global'; // default profile DB has a fixed name for backwards compatibility
 				} else {
-					return `global-${this.userDataProfileService.currentProfile.id}`;
+					return `global-${this.globalStorageProfile.id}`;
 				}
 			case StorageScope.WORKSPACE:
 				return this.payload.id;
@@ -60,55 +67,81 @@ export class BrowserStorageService extends AbstractStorageService {
 
 	protected async doInitialize(): Promise<void> {
 
-		// Create Storage in Parallel
-		const promises: Promise<IIndexedDBStorageDatabase>[] = [];
-		promises.push(IndexedDBStorageDatabase.create({ id: this.getId(StorageScope.APPLICATION), broadcastChanges: true }, this.logService));
-		promises.push(IndexedDBStorageDatabase.create({ id: this.getId(StorageScope.WORKSPACE) }, this.logService));
-		if (!this.userDataProfileService.currentProfile.isDefault) {
+		// Init storages
+		await Promises.settled([
+			this.createApplicationStorage(),
+			this.createGlobalStorage(this.globalStorageProfile),
+			this.createWorkspaceStorage()
+		]);
+	}
+
+	private async createApplicationStorage(): Promise<void> {
+		const applicationStorageIndexedDB = await IndexedDBStorageDatabase.create({ id: this.getId(StorageScope.APPLICATION), broadcastChanges: true }, this.logService);
+
+		this.applicationStorageDatabase = this._register(applicationStorageIndexedDB);
+		this.applicationStorage = this._register(new Storage(this.applicationStorageDatabase));
+
+		this._register(this.applicationStorage.onDidChangeStorage(key => this.emitDidChangeValue(StorageScope.APPLICATION, key)));
+
+		await this.applicationStorage.init();
+
+		this.updateIsNew(this.applicationStorage);
+
+		this.applicationStoragePromise.complete({ indededDb: applicationStorageIndexedDB, storage: this.applicationStorage });
+	}
+
+	private async createGlobalStorage(profile: IUserDataProfile): Promise<void> {
+
+		// First clear any previously associated disposables
+		this.globalStorageDisposables.clear();
+
+		// Remember profile associated to global storage
+		this.globalStorageProfile = profile;
+
+		if (this.globalStorageProfile.isDefault) {
 
 			// If we are in default profile, the global storage is
 			// actually the same as application storage. As such we
 			// avoid creating the storage library a second time on
 			// the same DB.
 
-			promises.push(IndexedDBStorageDatabase.create({ id: this.getId(StorageScope.GLOBAL), broadcastChanges: true }, this.logService));
+			const { indededDb: applicationStorageIndexedDB, storage: applicationStorage } = await this.applicationStoragePromise.p;
+
+			this.globalStorageDatabase = applicationStorageIndexedDB;
+			this.globalStorage = applicationStorage;
+		} else {
+			const globalStorageIndexedDB = await IndexedDBStorageDatabase.create({ id: this.getId(StorageScope.GLOBAL), broadcastChanges: true }, this.logService);
+
+			this.globalStorageDatabase = this.globalStorageDisposables.add(globalStorageIndexedDB);
+			this.globalStorage = this.globalStorageDisposables.add(new Storage(this.globalStorageDatabase));
 		}
-		const [applicationStorageDatabase, workspaceStorageDatabase, globalStorageDatabase] = await Promises.settled(promises);
 
-		// Workspace Storage
-		this.workspaceStorageDatabase = this._register(workspaceStorageDatabase);
+		this.globalStorageDisposables.add(this.globalStorage.onDidChangeStorage(key => this.emitDidChangeValue(StorageScope.GLOBAL, key)));
+
+		await this.globalStorage.init();
+
+		this.updateIsNew(this.globalStorage);
+	}
+
+	private async createWorkspaceStorage(): Promise<void> {
+		const workspaceStorageIndexedDB = await IndexedDBStorageDatabase.create({ id: this.getId(StorageScope.WORKSPACE) }, this.logService);
+
+		this.workspaceStorageDatabase = this._register(workspaceStorageIndexedDB);
 		this.workspaceStorage = this._register(new Storage(this.workspaceStorageDatabase));
+
 		this._register(this.workspaceStorage.onDidChangeStorage(key => this.emitDidChangeValue(StorageScope.WORKSPACE, key)));
 
-		// Application Storage
-		this.applicationStorageDatabase = this._register(applicationStorageDatabase);
-		this.applicationStorage = this._register(new Storage(this.applicationStorageDatabase));
-		this._register(this.applicationStorage.onDidChangeStorage(key => this.emitDidChangeValue(StorageScope.APPLICATION, key)));
+		await this.workspaceStorage.init();
 
-		// Global Storage
-		if (globalStorageDatabase) {
-			this.globalStorageDatabase = this._register(globalStorageDatabase);
-			this.globalStorage = this._register(new Storage(this.globalStorageDatabase));
-		} else {
-			this.globalStorage = this.applicationStorage;
-		}
-		this._register(this.globalStorage.onDidChangeStorage(key => this.emitDidChangeValue(StorageScope.GLOBAL, key)));
-
-		// Init storages
-		await Promises.settled([
-			this.workspaceStorage.init(),
-			this.globalStorage.init(),
-			this.applicationStorage.init()
-		]);
+		this.updateIsNew(this.workspaceStorage);
+	}
 
-		// Apply is-new markers
-		for (const storage of [this.applicationStorage, this.globalStorage, this.workspaceStorage]) {
-			const firstOpen = storage.getBoolean(IS_NEW_KEY);
-			if (firstOpen === undefined) {
-				storage.set(IS_NEW_KEY, true);
-			} else if (firstOpen) {
-				storage.set(IS_NEW_KEY, false);
-			}
+	private updateIsNew(storage: IStorage): void {
+		const firstOpen = storage.getBoolean(IS_NEW_KEY);
+		if (firstOpen === undefined) {
+			storage.set(IS_NEW_KEY, true);
+		} else if (firstOpen) {
+			storage.set(IS_NEW_KEY, false);
 		}
 	}
 
@@ -127,7 +160,24 @@ export class BrowserStorageService extends AbstractStorageService {
 		return this.getId(scope);
 	}
 
-	async migrate(toWorkspace: IAnyWorkspaceIdentifier): Promise<void> {
+	protected async switchToProfile(toProfile: IUserDataProfile, preserveData: boolean): Promise<void> {
+		const oldGlobalStorage = assertIsDefined(this.globalStorage);
+		const oldItems = oldGlobalStorage.items;
+
+		// Close old global storage but only if this is
+		// different from application storage!
+		if (oldGlobalStorage !== this.applicationStorage) {
+			await oldGlobalStorage.close();
+		}
+
+		// Create new global storage & init
+		await this.createGlobalStorage(toProfile);
+
+		// Handle data switch and eventing
+		this.switchData(oldItems, assertIsDefined(this.globalStorage), StorageScope.GLOBAL, preserveData);
+	}
+
+	protected async switchToWorkspace(toWorkspace: IAnyWorkspaceIdentifier, preserveData: boolean): Promise<void> {
 		throw new Error('Migrating storage is currently unsupported in Web');
 	}
 

src/vs/platform/storage/common/storage.ts

@@ -10,6 +10,7 @@ import { mark } from 'vs/base/common/performance';
 import { isUndefinedOrNull } from 'vs/base/common/types';
 import { InMemoryStorageDatabase, IStorage, Storage } from 'vs/base/parts/storage/common/storage';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { isUserDataProfile, IUserDataProfile } from 'vs/platform/userDataProfile/common/userDataProfile';
 import { IAnyWorkspaceIdentifier } from 'vs/platform/workspace/common/workspace';
 
 export const IS_NEW_KEY = '__$__isNewStorageMarker';
@@ -137,12 +138,13 @@ export interface IStorageService {
 	/**
 	 * Log the contents of the storage to the console.
 	 */
-	logStorage(): void;
+	log(): void;
 
 	/**
-	 * Migrate the storage contents to another workspace.
+	 * Switch storage to another workspace or profile. Optionally preserve the
+	 * current data to the new storage.
 	 */
-	migrate(toWorkspace: IAnyWorkspaceIdentifier): Promise<void>;
+	switch(to: IAnyWorkspaceIdentifier | IUserDataProfile, preserveData: boolean): Promise<void>;
 
 	/**
 	 * Whether the storage for the given scope was created during this session or
@@ -521,7 +523,7 @@ export abstract class AbstractStorageService extends Disposable implements IStor
 		}
 	}
 
-	async logStorage(): Promise<void> {
+	async log(): Promise<void> {
 		const applicationItems = this.getStorage(StorageScope.APPLICATION)?.items ?? new Map<string, string>();
 		const globalItems = this.getStorage(StorageScope.GLOBAL)?.items ?? new Map<string, string>();
 		const workspaceItems = this.getStorage(StorageScope.WORKSPACE)?.items ?? new Map<string, string>();
@@ -536,6 +538,49 @@ export abstract class AbstractStorageService extends Disposable implements IStor
 		);
 	}
 
+	async switch(to: IAnyWorkspaceIdentifier | IUserDataProfile, preserveData: boolean): Promise<void> {
+
+		// Signal as event so that clients can store data before we switch
+		this.emitWillSaveState(WillSaveStateReason.NONE);
+
+		if (isUserDataProfile(to)) {
+			return this.switchToProfile(to, preserveData);
+		}
+
+		return this.switchToWorkspace(to, preserveData);
+	}
+
+	protected switchData(oldStorage: Map<string, string>, newStorage: IStorage, scope: StorageScope, preserveData: boolean): void {
+		this.withPausedEmitters(() => {
+
+			// Copy over previous keys if `preserveData`
+			if (preserveData) {
+				for (const [key, value] of oldStorage) {
+					newStorage.set(key, value);
+				}
+			}
+
+			// Otherwise signal storage keys that have changed
+			else {
+				const handledkeys = new Set<string>();
+				for (const [key, oldValue] of oldStorage) {
+					handledkeys.add(key);
+
+					const newValue = newStorage.get(key);
+					if (newValue !== oldValue) {
+						this.emitDidChangeValue(scope, key);
+					}
+				}
+
+				for (const [key] of newStorage.items) {
+					if (!handledkeys.has(key)) {
+						this.emitDidChangeValue(scope, key);
+					}
+				}
+			}
+		});
+	}
+
 	// --- abstract
 
 	protected abstract doInitialize(): Promise<void>;
@@ -544,7 +589,8 @@ export abstract class AbstractStorageService extends Disposable implements IStor
 
 	protected abstract getLogDetails(scope: StorageScope): string | undefined;
 
-	abstract migrate(toWorkspace: IAnyWorkspaceIdentifier): Promise<void>;
+	protected abstract switchToProfile(toProfile: IUserDataProfile, preserveData: boolean): Promise<void>;
+	protected abstract switchToWorkspace(toWorkspace: IAnyWorkspaceIdentifier | IUserDataProfile, preserveData: boolean): Promise<void>;
 }
 
 export class InMemoryStorageService extends AbstractStorageService {
@@ -585,8 +631,12 @@ export class InMemoryStorageService extends AbstractStorageService {
 
 	protected async doInitialize(): Promise<void> { }
 
-	async migrate(toWorkspace: IAnyWorkspaceIdentifier): Promise<void> {
-		// not supported
+	protected async switchToProfile(): Promise<void> {
+		// no-op when in-memory
+	}
+
+	protected async switchToWorkspace(): Promise<void> {
+		// no-op when in-memory
 	}
 }