mirror of
https://github.com/microsoft/vscode.git
synced 2026-04-25 19:18:59 +01:00
use registerSharedProcessRemoteService to register
This commit is contained in:
Sandeep Somavarapu
@@ -3,256 +3,8 @@
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
|
||||
import { SyncStatus, SyncResource, IUserDataSyncService, UserDataSyncError, ISyncResourceHandle, ISyncTask, IManualSyncTask, IUserDataManifest, ISyncResourcePreview, IResourcePreview } from 'vs/platform/userDataSync/common/userDataSync';
|
||||
import { ISharedProcessService } from 'vs/platform/ipc/electron-sandbox/services';
|
||||
import { Disposable } from 'vs/base/common/lifecycle';
|
||||
import { Emitter, Event } from 'vs/base/common/event';
|
||||
import { IChannel } from 'vs/base/parts/ipc/common/ipc';
|
||||
import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
|
||||
import { CancellationToken } from 'vs/base/common/cancellation';
|
||||
import { URI } from 'vs/base/common/uri';
|
||||
import { IUserDataSyncService } from 'vs/platform/userDataSync/common/userDataSync';
|
||||
import { registerSharedProcessRemoteService } from 'vs/platform/ipc/electron-sandbox/services';
|
||||
import { UserDataSyncChannelClient } from 'vs/platform/userDataSync/common/userDataSyncServiceIpc';
|
||||
|
||||
export class UserDataSyncService extends Disposable implements IUserDataSyncService {
|
||||
|
||||
declare readonly _serviceBrand: undefined;
|
||||
|
||||
private readonly channel: IChannel;
|
||||
|
||||
private _status: SyncStatus = SyncStatus.Uninitialized;
|
||||
get status(): SyncStatus { return this._status; }
|
||||
private _onDidChangeStatus: Emitter<SyncStatus> = this._register(new Emitter<SyncStatus>());
|
||||
readonly onDidChangeStatus: Event<SyncStatus> = this._onDidChangeStatus.event;
|
||||
|
||||
get onDidChangeLocal(): Event<SyncResource> { return this.channel.listen<SyncResource>('onDidChangeLocal'); }
|
||||
|
||||
private _conflicts: [SyncResource, IResourcePreview[]][] = [];
|
||||
get conflicts(): [SyncResource, IResourcePreview[]][] { return this._conflicts; }
|
||||
private _onDidChangeConflicts: Emitter<[SyncResource, IResourcePreview[]][]> = this._register(new Emitter<[SyncResource, IResourcePreview[]][]>());
|
||||
readonly onDidChangeConflicts: Event<[SyncResource, IResourcePreview[]][]> = this._onDidChangeConflicts.event;
|
||||
|
||||
private _lastSyncTime: number | undefined = undefined;
|
||||
get lastSyncTime(): number | undefined { return this._lastSyncTime; }
|
||||
private _onDidChangeLastSyncTime: Emitter<number> = this._register(new Emitter<number>());
|
||||
readonly onDidChangeLastSyncTime: Event<number> = this._onDidChangeLastSyncTime.event;
|
||||
|
||||
private _onSyncErrors: Emitter<[SyncResource, UserDataSyncError][]> = this._register(new Emitter<[SyncResource, UserDataSyncError][]>());
|
||||
readonly onSyncErrors: Event<[SyncResource, UserDataSyncError][]> = this._onSyncErrors.event;
|
||||
|
||||
get onDidResetLocal(): Event<void> { return this.channel.listen<void>('onDidResetLocal'); }
|
||||
get onDidResetRemote(): Event<void> { return this.channel.listen<void>('onDidResetRemote'); }
|
||||
|
||||
constructor(
|
||||
@ISharedProcessService private readonly sharedProcessService: ISharedProcessService
|
||||
) {
|
||||
super();
|
||||
const userDataSyncChannel = sharedProcessService.getChannel('userDataSync');
|
||||
this.channel = {
|
||||
call<T>(command: string, arg?: any, cancellationToken?: CancellationToken): Promise<T> {
|
||||
return userDataSyncChannel.call(command, arg, cancellationToken)
|
||||
.then(null, error => { throw UserDataSyncError.toUserDataSyncError(error); });
|
||||
},
|
||||
listen<T>(event: string, arg?: any): Event<T> {
|
||||
return userDataSyncChannel.listen(event, arg);
|
||||
}
|
||||
};
|
||||
this.channel.call<[SyncStatus, [SyncResource, IResourcePreview[]][], number | undefined]>('_getInitialData').then(([status, conflicts, lastSyncTime]) => {
|
||||
this.updateStatus(status);
|
||||
this.updateConflicts(conflicts);
|
||||
if (lastSyncTime) {
|
||||
this.updateLastSyncTime(lastSyncTime);
|
||||
}
|
||||
this._register(this.channel.listen<SyncStatus>('onDidChangeStatus')(status => this.updateStatus(status)));
|
||||
this._register(this.channel.listen<number>('onDidChangeLastSyncTime')(lastSyncTime => this.updateLastSyncTime(lastSyncTime)));
|
||||
});
|
||||
this._register(this.channel.listen<[SyncResource, IResourcePreview[]][]>('onDidChangeConflicts')(conflicts => this.updateConflicts(conflicts)));
|
||||
this._register(this.channel.listen<[SyncResource, Error][]>('onSyncErrors')(errors => this._onSyncErrors.fire(errors.map(([source, error]) => ([source, UserDataSyncError.toUserDataSyncError(error)])))));
|
||||
}
|
||||
|
||||
createSyncTask(): Promise<ISyncTask> {
|
||||
throw new Error('not supported');
|
||||
}
|
||||
|
||||
async createManualSyncTask(): Promise<IManualSyncTask> {
|
||||
const { id, manifest, status } = await this.channel.call<{ id: string, manifest: IUserDataManifest | null, status: SyncStatus }>('createManualSyncTask');
|
||||
return new ManualSyncTask(id, manifest, status, this.sharedProcessService);
|
||||
}
|
||||
|
||||
replace(uri: URI): Promise<void> {
|
||||
return this.channel.call('replace', [uri]);
|
||||
}
|
||||
|
||||
reset(): Promise<void> {
|
||||
return this.channel.call('reset');
|
||||
}
|
||||
|
||||
resetRemote(): Promise<void> {
|
||||
return this.channel.call('resetRemote');
|
||||
}
|
||||
|
||||
resetLocal(): Promise<void> {
|
||||
return this.channel.call('resetLocal');
|
||||
}
|
||||
|
||||
hasPreviouslySynced(): Promise<boolean> {
|
||||
return this.channel.call('hasPreviouslySynced');
|
||||
}
|
||||
|
||||
hasLocalData(): Promise<boolean> {
|
||||
return this.channel.call('hasLocalData');
|
||||
}
|
||||
|
||||
accept(syncResource: SyncResource, resource: URI, content: string | null, apply: boolean): Promise<void> {
|
||||
return this.channel.call('accept', [syncResource, resource, content, apply]);
|
||||
}
|
||||
|
||||
resolveContent(resource: URI): Promise<string | null> {
|
||||
return this.channel.call('resolveContent', [resource]);
|
||||
}
|
||||
|
||||
async getLocalSyncResourceHandles(resource: SyncResource): Promise<ISyncResourceHandle[]> {
|
||||
const handles = await this.channel.call<ISyncResourceHandle[]>('getLocalSyncResourceHandles', [resource]);
|
||||
return handles.map(({ created, uri }) => ({ created, uri: URI.revive(uri) }));
|
||||
}
|
||||
|
||||
async getRemoteSyncResourceHandles(resource: SyncResource): Promise<ISyncResourceHandle[]> {
|
||||
const handles = await this.channel.call<ISyncResourceHandle[]>('getRemoteSyncResourceHandles', [resource]);
|
||||
return handles.map(({ created, uri }) => ({ created, uri: URI.revive(uri) }));
|
||||
}
|
||||
|
||||
async getAssociatedResources(resource: SyncResource, syncResourceHandle: ISyncResourceHandle): Promise<{ resource: URI, comparableResource: URI }[]> {
|
||||
const result = await this.channel.call<{ resource: URI, comparableResource: URI }[]>('getAssociatedResources', [resource, syncResourceHandle]);
|
||||
return result.map(({ resource, comparableResource }) => ({ resource: URI.revive(resource), comparableResource: URI.revive(comparableResource) }));
|
||||
}
|
||||
|
||||
async getMachineId(resource: SyncResource, syncResourceHandle: ISyncResourceHandle): Promise<string | undefined> {
|
||||
return this.channel.call<string | undefined>('getMachineId', [resource, syncResourceHandle]);
|
||||
}
|
||||
|
||||
private async updateStatus(status: SyncStatus): Promise<void> {
|
||||
this._status = status;
|
||||
this._onDidChangeStatus.fire(status);
|
||||
}
|
||||
|
||||
private async updateConflicts(conflicts: [SyncResource, IResourcePreview[]][]): Promise<void> {
|
||||
// Revive URIs
|
||||
this._conflicts = conflicts.map(([syncResource, conflicts]) =>
|
||||
([
|
||||
syncResource,
|
||||
conflicts.map(r =>
|
||||
({
|
||||
...r,
|
||||
localResource: URI.revive(r.localResource),
|
||||
remoteResource: URI.revive(r.remoteResource),
|
||||
previewResource: URI.revive(r.previewResource),
|
||||
}))
|
||||
]));
|
||||
this._onDidChangeConflicts.fire(this._conflicts);
|
||||
}
|
||||
|
||||
private updateLastSyncTime(lastSyncTime: number): void {
|
||||
if (this._lastSyncTime !== lastSyncTime) {
|
||||
this._lastSyncTime = lastSyncTime;
|
||||
this._onDidChangeLastSyncTime.fire(lastSyncTime);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class ManualSyncTask implements IManualSyncTask {
|
||||
|
||||
private readonly channel: IChannel;
|
||||
|
||||
get onSynchronizeResources(): Event<[SyncResource, URI[]][]> { return this.channel.listen<[SyncResource, URI[]][]>('onSynchronizeResources'); }
|
||||
|
||||
private _status: SyncStatus;
|
||||
get status(): SyncStatus { return this._status; }
|
||||
|
||||
constructor(
|
||||
readonly id: string,
|
||||
readonly manifest: IUserDataManifest | null,
|
||||
status: SyncStatus,
|
||||
sharedProcessService: ISharedProcessService,
|
||||
) {
|
||||
const manualSyncTaskChannel = sharedProcessService.getChannel(`manualSyncTask-${id}`);
|
||||
this._status = status;
|
||||
const that = this;
|
||||
this.channel = {
|
||||
async call<T>(command: string, arg?: any, cancellationToken?: CancellationToken): Promise<T> {
|
||||
try {
|
||||
const result = await manualSyncTaskChannel.call<T>(command, arg, cancellationToken);
|
||||
that._status = await manualSyncTaskChannel.call<SyncStatus>('_getStatus');
|
||||
return result;
|
||||
} catch (error) {
|
||||
throw UserDataSyncError.toUserDataSyncError(error);
|
||||
}
|
||||
},
|
||||
listen<T>(event: string, arg?: any): Event<T> {
|
||||
return manualSyncTaskChannel.listen(event, arg);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
async preview(): Promise<[SyncResource, ISyncResourcePreview][]> {
|
||||
const previews = await this.channel.call<[SyncResource, ISyncResourcePreview][]>('preview');
|
||||
return this.deserializePreviews(previews);
|
||||
}
|
||||
|
||||
async accept(resource: URI, content?: string | null): Promise<[SyncResource, ISyncResourcePreview][]> {
|
||||
const previews = await this.channel.call<[SyncResource, ISyncResourcePreview][]>('accept', [resource, content]);
|
||||
return this.deserializePreviews(previews);
|
||||
}
|
||||
|
||||
async merge(resource?: URI): Promise<[SyncResource, ISyncResourcePreview][]> {
|
||||
const previews = await this.channel.call<[SyncResource, ISyncResourcePreview][]>('merge', [resource]);
|
||||
return this.deserializePreviews(previews);
|
||||
}
|
||||
|
||||
async discard(resource: URI): Promise<[SyncResource, ISyncResourcePreview][]> {
|
||||
const previews = await this.channel.call<[SyncResource, ISyncResourcePreview][]>('discard', [resource]);
|
||||
return this.deserializePreviews(previews);
|
||||
}
|
||||
|
||||
async discardConflicts(): Promise<[SyncResource, ISyncResourcePreview][]> {
|
||||
const previews = await this.channel.call<[SyncResource, ISyncResourcePreview][]>('discardConflicts');
|
||||
return this.deserializePreviews(previews);
|
||||
}
|
||||
|
||||
async apply(): Promise<[SyncResource, ISyncResourcePreview][]> {
|
||||
const previews = await this.channel.call<[SyncResource, ISyncResourcePreview][]>('apply');
|
||||
return this.deserializePreviews(previews);
|
||||
}
|
||||
|
||||
pull(): Promise<void> {
|
||||
return this.channel.call('pull');
|
||||
}
|
||||
|
||||
push(): Promise<void> {
|
||||
return this.channel.call('push');
|
||||
}
|
||||
|
||||
stop(): Promise<void> {
|
||||
return this.channel.call('stop');
|
||||
}
|
||||
|
||||
dispose(): void {
|
||||
this.channel.call('dispose');
|
||||
}
|
||||
|
||||
private deserializePreviews(previews: [SyncResource, ISyncResourcePreview][]): [SyncResource, ISyncResourcePreview][] {
|
||||
return previews.map(([syncResource, preview]) =>
|
||||
([
|
||||
syncResource,
|
||||
{
|
||||
isLastSyncFromCurrentMachine: preview.isLastSyncFromCurrentMachine,
|
||||
resourcePreviews: preview.resourcePreviews.map(r => ({
|
||||
...r,
|
||||
localResource: URI.revive(r.localResource),
|
||||
remoteResource: URI.revive(r.remoteResource),
|
||||
previewResource: URI.revive(r.previewResource),
|
||||
acceptedResource: URI.revive(r.acceptedResource),
|
||||
}))
|
||||
}
|
||||
]));
|
||||
}
|
||||
}
|
||||
|
||||
registerSingleton(IUserDataSyncService, UserDataSyncService);
|
||||
registerSharedProcessRemoteService(IUserDataSyncService, 'userDataSync', { channelClientCtor: UserDataSyncChannelClient });
|
||||
|
||||
@@ -5,17 +5,16 @@
|
||||
|
||||
import { IUserDataSyncStoreManagementService, UserDataSyncStoreType, IUserDataSyncStore } from 'vs/platform/userDataSync/common/userDataSync';
|
||||
import { ISharedProcessService } from 'vs/platform/ipc/electron-sandbox/services';
|
||||
import { IChannel } from 'vs/base/parts/ipc/common/ipc';
|
||||
import { IStorageService } from 'vs/platform/storage/common/storage';
|
||||
import { AbstractUserDataSyncStoreManagementService } from 'vs/platform/userDataSync/common/userDataSyncStoreService';
|
||||
import { IProductService } from 'vs/platform/product/common/productService';
|
||||
import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
|
||||
import { URI } from 'vs/base/common/uri';
|
||||
import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
|
||||
import { UserDataSyncStoreManagementServiceChannelClient } from 'vs/platform/userDataSync/common/userDataSyncIpc';
|
||||
|
||||
class UserDataSyncStoreManagementService extends AbstractUserDataSyncStoreManagementService implements IUserDataSyncStoreManagementService {
|
||||
|
||||
private readonly channel: IChannel;
|
||||
private readonly channelClient: UserDataSyncStoreManagementServiceChannelClient;
|
||||
|
||||
constructor(
|
||||
@IProductService productService: IProductService,
|
||||
@@ -24,28 +23,16 @@ class UserDataSyncStoreManagementService extends AbstractUserDataSyncStoreManage
|
||||
@ISharedProcessService sharedProcessService: ISharedProcessService,
|
||||
) {
|
||||
super(productService, configurationService, storageService);
|
||||
this.channel = sharedProcessService.getChannel('userDataSyncStoreManagement');
|
||||
this._register(this.channel.listen('onDidChangeUserDataSyncStore')(() => this.updateUserDataSyncStore()));
|
||||
this.channelClient = this._register(new UserDataSyncStoreManagementServiceChannelClient(sharedProcessService.getChannel('userDataSyncStoreManagement')));
|
||||
this._register(this.channelClient.onDidChangeUserDataSyncStore(() => this.updateUserDataSyncStore()));
|
||||
}
|
||||
|
||||
async switch(type: UserDataSyncStoreType): Promise<void> {
|
||||
return this.channel.call('switch', [type]);
|
||||
return this.channelClient.switch(type);
|
||||
}
|
||||
|
||||
async getPreviousUserDataSyncStore(): Promise<IUserDataSyncStore> {
|
||||
const userDataSyncStore = await this.channel.call<IUserDataSyncStore>('getPreviousUserDataSyncStore');
|
||||
return this.revive(userDataSyncStore);
|
||||
}
|
||||
|
||||
private revive(userDataSyncStore: IUserDataSyncStore): IUserDataSyncStore {
|
||||
return {
|
||||
url: URI.revive(userDataSyncStore.url),
|
||||
defaultUrl: URI.revive(userDataSyncStore.defaultUrl),
|
||||
insidersUrl: URI.revive(userDataSyncStore.insidersUrl),
|
||||
stableUrl: URI.revive(userDataSyncStore.stableUrl),
|
||||
canSwitch: userDataSyncStore.canSwitch,
|
||||
authenticationProviders: userDataSyncStore.authenticationProviders,
|
||||
};
|
||||
return this.channelClient.getPreviousUserDataSyncStore();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user