@codingame/monaco-vscode-user-data-profile-service-override 5.3.0

package/vscode/src/vs/workbench/services/userDataSync/browser/userDataSyncInit.js

@@ -0,0 +1,448 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { AbstractExtensionsInitializer } from '../../../../platform/userDataSync/common/extensionsSync.js';
+import { UserDataSyncStoreTypeSynchronizer, GlobalStateInitializer } from '../../../../platform/userDataSync/common/globalStateSync.js';
+import { KeybindingsInitializer } from '../../../../platform/userDataSync/common/keybindingsSync.js';
+import { SettingsInitializer } from '../../../../platform/userDataSync/common/settingsSync.js';
+import { SnippetsInitializer } from '../../../../platform/userDataSync/common/snippetsSync.js';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { UserDataSyncStoreClient } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSyncStoreService';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
+import { IRequestService } from 'vscode/vscode/vs/platform/request/common/request.service';
+import { IUserDataSyncStoreManagementService, IUserDataSyncLogService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync.service';
+import { getCurrentAuthenticationSessionInfo } from 'vscode/vscode/vs/workbench/services/authentication/browser/authenticationService';
+import { getSyncAreaLabel } from 'vscode/vscode/vs/workbench/services/userDataSync/common/userDataSync';
+import { isWeb } from 'vscode/vscode/vs/base/common/platform';
+import { Barrier, Promises } from 'vscode/vscode/vs/base/common/async';
+import { IExtensionManagementService, IGlobalExtensionEnablementService, IExtensionGalleryService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement.service';
+import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment.service';
+import { toExtensionDescription } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { IIgnoredExtensionsManagementService } from 'vscode/vscode/vs/platform/userDataSync/common/ignoredExtensions.service';
+import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { isEqual } from 'vscode/vscode/vs/base/common/resources';
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { IExtensionStorageService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionStorage.service';
+import { TasksInitializer } from '../../../../platform/userDataSync/common/tasksSync.js';
+import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService.service';
+import { ISecretStorageService } from 'vscode/vscode/vs/platform/secrets/common/secrets.service';
+
+let UserDataSyncInitializer = class UserDataSyncInitializer {
+    constructor(environmentService, secretStorageService, userDataSyncStoreManagementService, fileService, userDataProfilesService, storageService, productService, requestService, logService, uriIdentityService) {
+        this.environmentService = environmentService;
+        this.secretStorageService = secretStorageService;
+        this.userDataSyncStoreManagementService = userDataSyncStoreManagementService;
+        this.fileService = fileService;
+        this.userDataProfilesService = userDataProfilesService;
+        this.storageService = storageService;
+        this.productService = productService;
+        this.requestService = requestService;
+        this.logService = logService;
+        this.uriIdentityService = uriIdentityService;
+        this.initialized = [];
+        this.initializationFinished = ( new Barrier());
+        this.globalStateUserData = null;
+        this.createUserDataSyncStoreClient().then(userDataSyncStoreClient => {
+            if (!userDataSyncStoreClient) {
+                this.initializationFinished.open();
+            }
+        });
+    }
+    createUserDataSyncStoreClient() {
+        if (!this._userDataSyncStoreClientPromise) {
+            this._userDataSyncStoreClientPromise = (async () => {
+                try {
+                    if (!isWeb) {
+                        this.logService.trace(`Skipping initializing user data in desktop`);
+                        return;
+                    }
+                    if (!this.storageService.isNew(-1 )) {
+                        this.logService.trace(`Skipping initializing user data as application was opened before`);
+                        return;
+                    }
+                    if (!this.storageService.isNew(1 )) {
+                        this.logService.trace(`Skipping initializing user data as workspace was opened before`);
+                        return;
+                    }
+                    if (this.environmentService.options?.settingsSyncOptions?.authenticationProvider && !this.environmentService.options.settingsSyncOptions.enabled) {
+                        this.logService.trace(`Skipping initializing user data as settings sync is disabled`);
+                        return;
+                    }
+                    let authenticationSession;
+                    try {
+                        authenticationSession = await getCurrentAuthenticationSessionInfo(this.secretStorageService, this.productService);
+                    }
+                    catch (error) {
+                        this.logService.error(error);
+                    }
+                    if (!authenticationSession) {
+                        this.logService.trace(`Skipping initializing user data as authentication session is not set`);
+                        return;
+                    }
+                    await this.initializeUserDataSyncStore(authenticationSession);
+                    const userDataSyncStore = this.userDataSyncStoreManagementService.userDataSyncStore;
+                    if (!userDataSyncStore) {
+                        this.logService.trace(`Skipping initializing user data as sync service is not provided`);
+                        return;
+                    }
+                    const userDataSyncStoreClient = ( new UserDataSyncStoreClient(
+                        userDataSyncStore.url,
+                        this.productService,
+                        this.requestService,
+                        this.logService,
+                        this.environmentService,
+                        this.fileService,
+                        this.storageService
+                    ));
+                    userDataSyncStoreClient.setAuthToken(authenticationSession.accessToken, authenticationSession.providerId);
+                    const manifest = await userDataSyncStoreClient.manifest(null);
+                    if (manifest === null) {
+                        userDataSyncStoreClient.dispose();
+                        this.logService.trace(`Skipping initializing user data as there is no data`);
+                        return;
+                    }
+                    this.logService.info(`Using settings sync service ${( userDataSyncStore.url.toString())} for initialization`);
+                    return userDataSyncStoreClient;
+                }
+                catch (error) {
+                    this.logService.error(error);
+                    return;
+                }
+            })();
+        }
+        return this._userDataSyncStoreClientPromise;
+    }
+    async initializeUserDataSyncStore(authenticationSession) {
+        const userDataSyncStore = this.userDataSyncStoreManagementService.userDataSyncStore;
+        if (!userDataSyncStore?.canSwitch) {
+            return;
+        }
+        const disposables = ( new DisposableStore());
+        try {
+            const userDataSyncStoreClient = disposables.add(( new UserDataSyncStoreClient(
+                userDataSyncStore.url,
+                this.productService,
+                this.requestService,
+                this.logService,
+                this.environmentService,
+                this.fileService,
+                this.storageService
+            )));
+            userDataSyncStoreClient.setAuthToken(authenticationSession.accessToken, authenticationSession.providerId);
+            this.globalStateUserData = await userDataSyncStoreClient.readResource("globalState" , null);
+            if (this.globalStateUserData) {
+                const userDataSyncStoreType = ( new UserDataSyncStoreTypeSynchronizer(
+                    userDataSyncStoreClient,
+                    this.storageService,
+                    this.environmentService,
+                    this.fileService,
+                    this.logService
+                )).getSyncStoreType(this.globalStateUserData);
+                if (userDataSyncStoreType) {
+                    await this.userDataSyncStoreManagementService.switch(userDataSyncStoreType);
+                    if (!isEqual(userDataSyncStore.url, this.userDataSyncStoreManagementService.userDataSyncStore?.url)) {
+                        this.logService.info('Switched settings sync store');
+                        this.globalStateUserData = null;
+                    }
+                }
+            }
+        }
+        finally {
+            disposables.dispose();
+        }
+    }
+    async whenInitializationFinished() {
+        await this.initializationFinished.wait();
+    }
+    async requiresInitialization() {
+        this.logService.trace(`UserDataInitializationService#requiresInitialization`);
+        const userDataSyncStoreClient = await this.createUserDataSyncStoreClient();
+        return !!userDataSyncStoreClient;
+    }
+    async initializeRequiredResources() {
+        this.logService.trace(`UserDataInitializationService#initializeRequiredResources`);
+        return this.initialize(["settings" , "globalState" ]);
+    }
+    async initializeOtherResources(instantiationService) {
+        try {
+            this.logService.trace(`UserDataInitializationService#initializeOtherResources`);
+            await Promise.allSettled([this.initialize(["keybindings" , "snippets" , "tasks" ]), this.initializeExtensions(instantiationService)]);
+        }
+        finally {
+            this.initializationFinished.open();
+        }
+    }
+    async initializeExtensions(instantiationService) {
+        try {
+            await Promise.all([this.initializeInstalledExtensions(instantiationService), this.initializeNewExtensions(instantiationService)]);
+        }
+        finally {
+            this.initialized.push("extensions" );
+        }
+    }
+    async initializeInstalledExtensions(instantiationService) {
+        if (!this.initializeInstalledExtensionsPromise) {
+            this.initializeInstalledExtensionsPromise = (async () => {
+                this.logService.trace(`UserDataInitializationService#initializeInstalledExtensions`);
+                const extensionsPreviewInitializer = await this.getExtensionsPreviewInitializer(instantiationService);
+                if (extensionsPreviewInitializer) {
+                    await instantiationService.createInstance(InstalledExtensionsInitializer, extensionsPreviewInitializer).initialize();
+                }
+            })();
+        }
+        return this.initializeInstalledExtensionsPromise;
+    }
+    async initializeNewExtensions(instantiationService) {
+        if (!this.initializeNewExtensionsPromise) {
+            this.initializeNewExtensionsPromise = (async () => {
+                this.logService.trace(`UserDataInitializationService#initializeNewExtensions`);
+                const extensionsPreviewInitializer = await this.getExtensionsPreviewInitializer(instantiationService);
+                if (extensionsPreviewInitializer) {
+                    await instantiationService.createInstance(NewExtensionsInitializer, extensionsPreviewInitializer).initialize();
+                }
+            })();
+        }
+        return this.initializeNewExtensionsPromise;
+    }
+    getExtensionsPreviewInitializer(instantiationService) {
+        if (!this.extensionsPreviewInitializerPromise) {
+            this.extensionsPreviewInitializerPromise = (async () => {
+                const userDataSyncStoreClient = await this.createUserDataSyncStoreClient();
+                if (!userDataSyncStoreClient) {
+                    return null;
+                }
+                const userData = await userDataSyncStoreClient.readResource("extensions" , null);
+                return instantiationService.createInstance(ExtensionsPreviewInitializer, userData);
+            })();
+        }
+        return this.extensionsPreviewInitializerPromise;
+    }
+    async initialize(syncResources) {
+        const userDataSyncStoreClient = await this.createUserDataSyncStoreClient();
+        if (!userDataSyncStoreClient) {
+            return;
+        }
+        await Promises.settled(( syncResources.map(async (syncResource) => {
+            try {
+                if (this.initialized.includes(syncResource)) {
+                    this.logService.info(`${getSyncAreaLabel(syncResource)} initialized already.`);
+                    return;
+                }
+                this.initialized.push(syncResource);
+                this.logService.trace(`Initializing ${getSyncAreaLabel(syncResource)}`);
+                const initializer = this.createSyncResourceInitializer(syncResource);
+                const userData = await userDataSyncStoreClient.readResource(syncResource, syncResource === "globalState"  ? this.globalStateUserData : null);
+                await initializer.initialize(userData);
+                this.logService.info(`Initialized ${getSyncAreaLabel(syncResource)}`);
+            }
+            catch (error) {
+                this.logService.info(`Error while initializing ${getSyncAreaLabel(syncResource)}`);
+                this.logService.error(error);
+            }
+        })));
+    }
+    createSyncResourceInitializer(syncResource) {
+        switch (syncResource) {
+            case "settings" : return ( new SettingsInitializer(
+                this.fileService,
+                this.userDataProfilesService,
+                this.environmentService,
+                this.logService,
+                this.storageService,
+                this.uriIdentityService
+            ));
+            case "keybindings" : return ( new KeybindingsInitializer(
+                this.fileService,
+                this.userDataProfilesService,
+                this.environmentService,
+                this.logService,
+                this.storageService,
+                this.uriIdentityService
+            ));
+            case "tasks" : return ( new TasksInitializer(
+                this.fileService,
+                this.userDataProfilesService,
+                this.environmentService,
+                this.logService,
+                this.storageService,
+                this.uriIdentityService
+            ));
+            case "snippets" : return ( new SnippetsInitializer(
+                this.fileService,
+                this.userDataProfilesService,
+                this.environmentService,
+                this.logService,
+                this.storageService,
+                this.uriIdentityService
+            ));
+            case "globalState" : return ( new GlobalStateInitializer(
+                this.storageService,
+                this.fileService,
+                this.userDataProfilesService,
+                this.environmentService,
+                this.logService,
+                this.uriIdentityService
+            ));
+        }
+        throw ( new Error(`Cannot create initializer for ${syncResource}`));
+    }
+};
+UserDataSyncInitializer = ( __decorate([
+    ( __param(0, IBrowserWorkbenchEnvironmentService)),
+    ( __param(1, ISecretStorageService)),
+    ( __param(2, IUserDataSyncStoreManagementService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IUserDataProfilesService)),
+    ( __param(5, IStorageService)),
+    ( __param(6, IProductService)),
+    ( __param(7, IRequestService)),
+    ( __param(8, ILogService)),
+    ( __param(9, IUriIdentityService))
+], UserDataSyncInitializer));
+let ExtensionsPreviewInitializer = class ExtensionsPreviewInitializer extends AbstractExtensionsInitializer {
+    constructor(extensionsData, extensionManagementService, ignoredExtensionsManagementService, fileService, userDataProfilesService, environmentService, logService, storageService, uriIdentityService) {
+        super(extensionManagementService, ignoredExtensionsManagementService, fileService, userDataProfilesService, environmentService, logService, storageService, uriIdentityService);
+        this.extensionsData = extensionsData;
+        this.preview = null;
+    }
+    getPreview() {
+        if (!this.previewPromise) {
+            this.previewPromise = super.initialize(this.extensionsData).then(() => this.preview);
+        }
+        return this.previewPromise;
+    }
+    initialize() {
+        throw ( new Error('should not be called directly'));
+    }
+    async doInitialize(remoteUserData) {
+        const remoteExtensions = await this.parseExtensions(remoteUserData);
+        if (!remoteExtensions) {
+            this.logService.info('Skipping initializing extensions because remote extensions does not exist.');
+            return;
+        }
+        const installedExtensions = await this.extensionManagementService.getInstalled();
+        this.preview = this.generatePreview(remoteExtensions, installedExtensions);
+    }
+};
+ExtensionsPreviewInitializer = ( __decorate([
+    ( __param(1, IExtensionManagementService)),
+    ( __param(2, IIgnoredExtensionsManagementService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IUserDataProfilesService)),
+    ( __param(5, IEnvironmentService)),
+    ( __param(6, IUserDataSyncLogService)),
+    ( __param(7, IStorageService)),
+    ( __param(8, IUriIdentityService))
+], ExtensionsPreviewInitializer));
+let InstalledExtensionsInitializer = class InstalledExtensionsInitializer {
+    constructor(extensionsPreviewInitializer, extensionEnablementService, extensionStorageService, logService) {
+        this.extensionsPreviewInitializer = extensionsPreviewInitializer;
+        this.extensionEnablementService = extensionEnablementService;
+        this.extensionStorageService = extensionStorageService;
+        this.logService = logService;
+    }
+    async initialize() {
+        const preview = await this.extensionsPreviewInitializer.getPreview();
+        if (!preview) {
+            return;
+        }
+        for (const installedExtension of preview.installedExtensions) {
+            const syncExtension = preview.remoteExtensions.find(({ identifier }) => areSameExtensions(identifier, installedExtension.identifier));
+            if (syncExtension?.state) {
+                const extensionState = this.extensionStorageService.getExtensionState(installedExtension, true) || {};
+                ( Object.keys(syncExtension.state)).forEach(key => extensionState[key] = syncExtension.state[key]);
+                this.extensionStorageService.setExtensionState(installedExtension, extensionState, true);
+            }
+        }
+        if (preview.disabledExtensions.length) {
+            for (const identifier of preview.disabledExtensions) {
+                this.logService.trace(`Disabling extension...`, identifier.id);
+                await this.extensionEnablementService.disableExtension(identifier);
+                this.logService.info(`Disabling extension`, identifier.id);
+            }
+        }
+    }
+};
+InstalledExtensionsInitializer = ( __decorate([
+    ( __param(1, IGlobalExtensionEnablementService)),
+    ( __param(2, IExtensionStorageService)),
+    ( __param(3, IUserDataSyncLogService))
+], InstalledExtensionsInitializer));
+let NewExtensionsInitializer = class NewExtensionsInitializer {
+    constructor(extensionsPreviewInitializer, extensionService, extensionStorageService, galleryService, extensionManagementService, logService) {
+        this.extensionsPreviewInitializer = extensionsPreviewInitializer;
+        this.extensionService = extensionService;
+        this.extensionStorageService = extensionStorageService;
+        this.galleryService = galleryService;
+        this.extensionManagementService = extensionManagementService;
+        this.logService = logService;
+    }
+    async initialize() {
+        const preview = await this.extensionsPreviewInitializer.getPreview();
+        if (!preview) {
+            return;
+        }
+        const newlyEnabledExtensions = [];
+        const targetPlatform = await this.extensionManagementService.getTargetPlatform();
+        const galleryExtensions = await this.galleryService.getExtensions(preview.newExtensions, { targetPlatform, compatible: true }, CancellationToken.None);
+        for (const galleryExtension of galleryExtensions) {
+            try {
+                const extensionToSync = preview.remoteExtensions.find(({ identifier }) => areSameExtensions(identifier, galleryExtension.identifier));
+                if (!extensionToSync) {
+                    continue;
+                }
+                if (extensionToSync.state) {
+                    this.extensionStorageService.setExtensionState(galleryExtension, extensionToSync.state, true);
+                }
+                this.logService.trace(`Installing extension...`, galleryExtension.identifier.id);
+                const local = await this.extensionManagementService.installFromGallery(galleryExtension, {
+                    isMachineScoped: false,
+                    donotIncludePackAndDependencies: true,
+                    installGivenVersion: !!extensionToSync.version,
+                    installPreReleaseVersion: extensionToSync.preRelease
+                });
+                if (!( preview.disabledExtensions.some(identifier => areSameExtensions(identifier, galleryExtension.identifier)))) {
+                    newlyEnabledExtensions.push(local);
+                }
+                this.logService.info(`Installed extension.`, galleryExtension.identifier.id);
+            }
+            catch (error) {
+                this.logService.error(error);
+            }
+        }
+        const canEnabledExtensions = newlyEnabledExtensions.filter(e => this.extensionService.canAddExtension(toExtensionDescription(e)));
+        if (!(await this.areExtensionsRunning(canEnabledExtensions))) {
+            await ( new Promise((c, e) => {
+                const disposable = this.extensionService.onDidChangeExtensions(async () => {
+                    try {
+                        if (await this.areExtensionsRunning(canEnabledExtensions)) {
+                            disposable.dispose();
+                            c();
+                        }
+                    }
+                    catch (error) {
+                        e(error);
+                    }
+                });
+            }));
+        }
+    }
+    async areExtensionsRunning(extensions) {
+        await this.extensionService.whenInstalledExtensionsRegistered();
+        const runningExtensions = this.extensionService.extensions;
+        return extensions.every(e => ( runningExtensions.some(r => areSameExtensions({ id: r.identifier.value }, e.identifier))));
+    }
+};
+NewExtensionsInitializer = ( __decorate([
+    ( __param(1, IExtensionService)),
+    ( __param(2, IExtensionStorageService)),
+    ( __param(3, IExtensionGalleryService)),
+    ( __param(4, IExtensionManagementService)),
+    ( __param(5, IUserDataSyncLogService))
+], NewExtensionsInitializer));
+
+export { UserDataSyncInitializer };