Microsoft/vscode
1
0
Fork 0
mirror of https://github.com/microsoft/vscode.git synced 2026-04-22 09:38:38 +01:00
Code Issues Packages Projects Releases Wiki Activity

settings sync using remote user data service

Browse Source
This commit is contained in:
Sandeep Somavarapu
2019-09-10 15:16:57 +02:00
parent 6706c1792d
commit c26e198c9c
12 changed files with 575 additions and 511 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
src/vs/workbench/api/common/extHost.protocol.ts
View File

@@ -47,7 +47,7 @@ import { ExtensionActivationError } from 'vs/workbench/services/extensions/commo
import { createExtHostContextProxyIdentifier as createExtId, createMainContextProxyIdentifier as createMainId, IRPCProtocol } from 'vs/workbench/services/extensions/common/proxyIdentifier';
import * as search from 'vs/workbench/services/search/common/search';
import { SaveReason } from 'vs/workbench/services/textfile/common/textfiles';
import { IUserDataProvider } from 'vs/workbench/services/userData/common/userData';
import { IUserData } from 'vs/workbench/services/userData/common/userData';
export interface IEnvironment {
isExtensionDevelopmentDebug: boolean;
@@ -142,9 +142,8 @@ export interface MainThreadConfigurationShape extends IDisposable {
}
export interface MainThreadUserDataShape extends IDisposable {
$registerUserLoginProvider(identitiy: string, loggedIn: boolean): void;
$updateLoggedIn(identitiy: string, loggedIn: boolean): void;
$registerUserDataProvider(identitiy: string, userDataProvider: IUserDataProvider): void;
$registerUserDataProvider(name: string): void;
$deregisterUserDataProvider(): void;
}
export interface MainThreadDiagnosticsShape extends IDisposable {
@@ -753,8 +752,8 @@ export interface ExtHostConfigurationShape {
}
export interface ExtHostUserDataShape {
$logIn(identity: string): Promise<void>;
$logOut(identity: string): Promise<void>;
$read(key: string): Promise<IUserData | null>;
$write(key: string, version: number, content: string): Promise<void>;
}
export interface ExtHostDiagnosticsShape {

55
src/vs/workbench/api/common/extHostUserData.ts
View File

@@ -4,50 +4,45 @@
*--------------------------------------------------------------------------------------------*/
import { ExtHostUserDataShape, MainThreadUserDataShape } from './extHost.protocol';
import { ExtHostFileSystem } from 'vs/workbench/api/common/extHostFileSystem';
import * as vscode from 'vscode';
import { DisposableStore, toDisposable } from 'vs/base/common/lifecycle';
import { toDisposable, Disposable } from 'vs/base/common/lifecycle';
import { ILogService } from 'vs/platform/log/common/log';
import { IUserData } from 'vs/workbench/services/userData/common/userData';
export class ExtHostUserData implements ExtHostUserDataShape {
private readonly loginProviders: Map<string, vscode.UserLoginProvider> = new Map<string, vscode.UserLoginProvider>();
private name: string | null = null;
private userDataProvider: vscode.UserDataProvider | null = null;
constructor(
private readonly proxy: MainThreadUserDataShape,
private readonly extHostFileSystem: ExtHostFileSystem
private readonly logService: ILogService,
) {
}
registerUserDataProvider(identity: string, userDataProvider: vscode.UserDataProvider): vscode.Disposable {
const userDataScheme = `vscode-userdata-${identity}`;
const disposable = this.extHostFileSystem.registerFileSystemProvider(userDataScheme, userDataProvider.dataProvider);
this.proxy.$registerUserDataProvider(identity, { userDataScheme });
return disposable;
}
registerUserLoginProvider(identity: string, loginProvider: vscode.UserLoginProvider): vscode.Disposable {
this.loginProviders.set(identity, loginProvider);
this.proxy.$registerUserLoginProvider(identity, loginProvider.isLoggedin());
const disposable = new DisposableStore();
disposable.add(loginProvider.onDidChange(() => this.proxy.$updateLoggedIn(identity, loginProvider.isLoggedin())));
disposable.add(toDisposable(() => this.loginProviders.delete(identity)));
return disposable;
}
async $logIn(identity: string): Promise<void> {
const loginProvider = this.loginProviders.get(identity);
if (!loginProvider) {
return Promise.reject(new Error(`No login provider found for ${identity}`));
registerUserDataProvider(name: string, userDataProvider: vscode.UserDataProvider): vscode.Disposable {
if (this.userDataProvider) {
this.logService.warn(`A user data provider '${this.name}' already exists hence ignoring the remote user data provider '${name}'.`);
return Disposable.None;
}
await loginProvider.login();
this.userDataProvider = userDataProvider;
this.name = name;
this.proxy.$registerUserDataProvider(name);
return toDisposable(() => this.proxy.$deregisterUserDataProvider());
}
$logOut(identity: string): Promise<void> {
const loginProvider = this.loginProviders.get(identity);
if (!loginProvider) {
return Promise.reject(new Error(`No login provider found for ${identity}`));
$read(key: string): Promise<IUserData | null> {
if (!this.userDataProvider) {
throw new Error('No remote user data provider exists.');
}
return Promise.resolve();
return this.userDataProvider.read(key);
}
$write(key: string, version: number, content: string): Promise<void> {
if (!this.userDataProvider) {
throw new Error('No remote user data provider exists.');
}
return this.userDataProvider.write(key, version, content);
}
}

113
src/vs/workbench/api/common/userDataExtensionPoint.ts
View File

@@ -1,113 +0,0 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { localize } from 'vs/nls';
import { IJSONSchema } from 'vs/base/common/jsonSchema';
import { ExtensionMessageCollector, ExtensionsRegistry, IExtensionPoint, IExtensionPointUser } from 'vs/workbench/services/extensions/common/extensionsRegistry';
import { IWorkbenchContributionsRegistry, Extensions as WorkbenchExtensions, IWorkbenchContribution } from 'vs/workbench/common/contributions';
import { LifecyclePhase } from 'vs/platform/lifecycle/common/lifecycle';
import { Registry } from 'vs/platform/registry/common/platform';
import { IUserIdentityService, IUserIdentity } from 'vs/workbench/services/userData/common/userData';
export interface IUserFriendlyUserIdentityDescriptor {
id: string;
title: string;
iconText: string;
}
export const userIdentityContribution: IJSONSchema = {
description: localize('vscode.extension.contributes.userIdentity', 'Contributes user identity to the editor'),
type: 'object',
properties: {
id: {
description: localize({ key: 'vscode.extension.contributes.user.identity.id', comment: ['Contribution refers to those that an extension contributes to VS Code through an extension/contribution point. '] }, "Unique id to identify the user user identity"),
type: 'string',
pattern: '^[a-zA-Z0-9_-]+$'
},
title: {
description: localize('vscode.extension.contributes.views.containers.title', 'Human readable string used to render the user identity'),
type: 'string'
},
iconText: {
description: localize('vscode.extension.contributes.views.containers.icon', "Path to the user identity icon."),
type: 'string'
}
}
};
const viewsContainersExtensionPoint: IExtensionPoint<IUserFriendlyUserIdentityDescriptor> = ExtensionsRegistry.registerExtensionPoint<IUserFriendlyUserIdentityDescriptor>({
extensionPoint: 'userData',
jsonSchema: userIdentityContribution
});
class UserIdentityExtensionHandler implements IWorkbenchContribution {
constructor(
@IUserIdentityService private readonly userIdentityService: IUserIdentityService
) {
this.handleAndRegisterUserIdentities();
}
private handleAndRegisterUserIdentities() {
viewsContainersExtensionPoint.setHandler((extensions, { added, removed }) => {
if (removed.length) {
this.removeUserIdentities(removed);
}
if (added.length) {
this.addUserIdentities(added);
}
});
}
private addUserIdentities(extensionPoints: readonly IExtensionPointUser<IUserFriendlyUserIdentityDescriptor>[]) {
const userIdentities: IUserIdentity[] = [];
for (let { value, collector } of extensionPoints) {
if (!this.isValidUserIdentity(value, collector)) {
return;
}
userIdentities.push({
identity: value.id,
title: value.title,
iconText: `$(${value.iconText})`
});
}
if (userIdentities.length) {
this.userIdentityService.registerUserIdentities(userIdentities);
}
}
private removeUserIdentities(extensionPoints: readonly IExtensionPointUser<IUserFriendlyUserIdentityDescriptor>[]) {
const identities = extensionPoints.map(({ value }) => value.id);
if (identities.length) {
this.userIdentityService.deregisterUserIdentities(identities);
}
}
private isValidUserIdentity(userIdentityDescriptor: IUserFriendlyUserIdentityDescriptor, collector: ExtensionMessageCollector): boolean {
if (typeof userIdentityDescriptor.id !== 'string') {
collector.error(localize('requireidstring', "property `{0}` is mandatory and must be of type `string`. Only alphanumeric characters, '_', and '-' are allowed.", 'id'));
return false;
}
if (!(/^[a-z0-9_-]+$/i.test(userIdentityDescriptor.id))) {
collector.error(localize('requireidstring', "property `{0}` is mandatory and must be of type `string`. Only alphanumeric characters, '_', and '-' are allowed.", 'id'));
return false;
}
if (typeof userIdentityDescriptor.title !== 'string') {
collector.error(localize('requirestring', "property `{0}` is mandatory and must be of type `string`", 'title'));
return false;
}
if (typeof userIdentityDescriptor.iconText !== 'string') {
collector.error(localize('requirestring', "property `{0}` is mandatory and must be of type `string`", 'icon'));
return false;
}
return true;
}
}
const workbenchRegistry = Registry.as<IWorkbenchContributionsRegistry>(WorkbenchExtensions.Workbench);
workbenchRegistry.registerWorkbenchContribution(UserIdentityExtensionHandler, LifecyclePhase.Starting);