development/vscode
development/vscode
1
0
Fork 0
mirror of https://github.com/Microsoft/vscode synced 2024-09-19 18:48:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

simplify user data sync service

Browse source
This commit is contained in:
Sandeep Somavarapu 2020-02-09 15:33:52 +01:00
parent d022bb76a9
commit 51a956b87f
6 changed files with 49 additions and 51 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/vs/platform/userDataSync/common/userDataAutoSyncService.ts
View file

@ -60,7 +60,7 @@ export class UserDataAutoSyncService extends Disposable implements IUserDataAuto
if (this.enabled) {
try {
if (auto) {
if (await this.isTurnedOffEverywhere()) {
if (await this.userDataSyncService.isTurnedOffEverywhere()) {
// Turned off everywhere. Reset & Stop Sync.
this.logService.info('Auto Sync: Turning off sync as it is turned off everywhere.');
await this.userDataSyncService.resetLocal();
@ -88,12 +88,6 @@ export class UserDataAutoSyncService extends Disposable implements IUserDataAuto
}
}
private async isTurnedOffEverywhere(): Promise<boolean> {
const hasRemote = await this.userDataSyncService.hasRemoteData();
const hasPreviouslySynced = await this.userDataSyncService.hasPreviouslySynced();
return !hasRemote && hasPreviouslySynced;
}
private async isAutoSyncEnabled(): Promise<boolean> {
return this.configurationService.getValue<boolean>('sync.enable')
&& this.userDataSyncService.status !== SyncStatus.Uninitialized

30
src/vs/platform/userDataSync/common/userDataSync.ts
View file

@ -201,36 +201,50 @@ export const enum SyncStatus {
HasConflicts = 'hasConflicts',
}
export interface ISynchroniser {
export interface IUserDataSynchroniser {
readonly source: SyncSource;
readonly status: SyncStatus;
readonly onDidChangeStatus: Event<SyncStatus>;
readonly onDidChangeLocal: Event<void>;
pull(): Promise<void>;
push(): Promise<void>;
sync(): Promise<void>;
stop(): Promise<void>;
hasPreviouslySynced(): Promise<boolean>
hasRemoteData(): Promise<boolean>;
hasLocalData(): Promise<boolean>;
resetLocal(): Promise<void>;
}
export interface IUserDataSynchroniser extends ISynchroniser {
readonly source: SyncSource;
getRemoteContent(preivew?: boolean): Promise<string | null>;
accept(content: string): Promise<void>;
}
export const IUserDataSyncService = createDecorator<IUserDataSyncService>('IUserDataSyncService');
export interface IUserDataSyncService extends ISynchroniser {
export interface IUserDataSyncService {
_serviceBrand: any;
readonly status: SyncStatus;
readonly onDidChangeStatus: Event<SyncStatus>;
readonly conflictsSources: SyncSource[];
readonly onDidChangeConflicts: Event<SyncSource[]>;
isFirstTimeSyncAndHasUserData(): Promise<boolean>;
reset(): Promise<void>;
resetLocal(): Promise<void>;
readonly onDidChangeLocal: Event<void>;
pull(): Promise<void>;
sync(): Promise<void>;
stop(): Promise<void>;
getRemoteContent(source: SyncSource, preview: boolean): Promise<string | null>;
accept(source: SyncSource, content: string): Promise<void>;
isFirstTimeSyncWithMerge(): Promise<boolean>;
isTurnedOffEverywhere(): Promise<boolean>;
reset(): Promise<void>;
resetLocal(): Promise<void>;
}
export const IUserDataAutoSyncService = createDecorator<IUserDataAutoSyncService>('IUserDataAutoSyncService');

7
src/vs/platform/userDataSync/common/userDataSyncIpc.ts
View file

@ -29,15 +29,12 @@ export class UserDataSyncChannel implements IServerChannel {
case 'sync': return this.service.sync();
case 'accept': return this.service.accept(args[0], args[1]);
case 'pull': return this.service.pull();
case 'push': return this.service.push();
case 'stop': this.service.stop(); return Promise.resolve();
case 'reset': return this.service.reset();
case 'resetLocal': return this.service.resetLocal();
case 'hasPreviouslySynced': return this.service.hasPreviouslySynced();
case 'hasRemoteData': return this.service.hasRemoteData();
case 'hasLocalData': return this.service.hasLocalData();
case 'isTurnedOffEverywhere': return this.service.isTurnedOffEverywhere();
case 'getRemoteContent': return this.service.getRemoteContent(args[0], args[1]);
case 'isFirstTimeSyncAndHasUserData': return this.service.isFirstTimeSyncAndHasUserData();
case 'isFirstTimeSyncWithMerge': return this.service.isFirstTimeSyncWithMerge();
}
throw new Error('Invalid call');
}

27
src/vs/platform/userDataSync/common/userDataSyncService.ts
View file

@ -143,13 +143,7 @@ export class UserDataSyncService extends Disposable implements IUserDataSyncServ
return false;
}
async hasRemoteData(): Promise<boolean> {
if (!this.userDataSyncStoreService.userDataSyncStore) {
throw new Error('Not enabled');
}
if (!(await this.userDataAuthTokenService.getToken())) {
throw new Error('Not Authenticated. Please sign in to start sync.');
}
private async hasRemoteData(): Promise<boolean> {
for (const synchroniser of this.synchronisers) {
if (await synchroniser.hasRemoteData()) {
return true;
@ -158,7 +152,7 @@ export class UserDataSyncService extends Disposable implements IUserDataSyncServ
return false;
}
async hasLocalData(): Promise<boolean> {
private async hasLocalData(): Promise<boolean> {
if (!this.userDataSyncStoreService.userDataSyncStore) {
throw new Error('Not enabled');
}
@ -182,19 +176,34 @@ export class UserDataSyncService extends Disposable implements IUserDataSyncServ
return null;
}
async isFirstTimeSyncAndHasUserData(): Promise<boolean> {
async isFirstTimeSyncWithMerge(): Promise<boolean> {
if (!this.userDataSyncStoreService.userDataSyncStore) {
throw new Error('Not enabled');
}
if (!(await this.userDataAuthTokenService.getToken())) {
throw new Error('Not Authenticated. Please sign in to start sync.');
}
if (!await this.hasRemoteData()) {
return false;
}
if (await this.hasPreviouslySynced()) {
return false;
}
return await this.hasLocalData();
}
async isTurnedOffEverywhere(): Promise<boolean> {
if (!this.userDataSyncStoreService.userDataSyncStore) {
throw new Error('Not enabled');
}
if (!(await this.userDataAuthTokenService.getToken())) {
throw new Error('Not Authenticated. Please sign in to start sync.');
}
const hasRemote = await this.hasRemoteData();
const hasPreviouslySynced = await this.hasPreviouslySynced();
return !hasRemote && hasPreviouslySynced;
}
async reset(): Promise<void> {
await this.resetRemote();
await this.resetLocal();

8
src/vs/workbench/contrib/userDataSync/browser/userDataSync.ts
View file

@ -444,12 +444,8 @@ export class UserDataSyncWorkbenchContribution extends Disposable implements IWo
}
private async handleFirstTimeSync(): Promise<void> {
const hasRemote = await this.userDataSyncService.hasRemoteData();
if (!hasRemote) {
return;
}
const isFirstSyncAndHasUserData = await this.userDataSyncService.isFirstTimeSyncAndHasUserData();
if (!isFirstSyncAndHasUserData) {
const isFirstSyncWithMerge = await this.userDataSyncService.isFirstTimeSyncWithMerge();
if (!isFirstSyncWithMerge) {
return;
}
const result = await this.dialogService.show(

20
src/vs/workbench/services/userDataSync/electron-browser/userDataSyncService.ts
View file

@ -55,10 +55,6 @@ export class UserDataSyncService extends Disposable implements IUserDataSyncServ
return this.channel.call('pull');
}
push(): Promise<void> {
return this.channel.call('push');
}
sync(): Promise<void> {
return this.channel.call('sync');
}
@ -79,24 +75,16 @@ export class UserDataSyncService extends Disposable implements IUserDataSyncServ
return this.channel.call('stop');
}
hasPreviouslySynced(): Promise<boolean> {
return this.channel.call('hasPreviouslySynced');
}
hasRemoteData(): Promise<boolean> {
return this.channel.call('hasRemoteData');
}
hasLocalData(): Promise<boolean> {
return this.channel.call('hasLocalData');
isTurnedOffEverywhere(): Promise<boolean> {
return this.channel.call('isTurnedOffEverywhere');
}
getRemoteContent(source: SyncSource, preview: boolean): Promise<string | null> {
return this.channel.call('getRemoteContent', [source, preview]);
}
isFirstTimeSyncAndHasUserData(): Promise<boolean> {
return this.channel.call('isFirstTimeSyncAndHasUserData');
isFirstTimeSyncWithMerge(): Promise<boolean> {
return this.channel.call('isFirstTimeSyncWithMerge');
}
private async updateStatus(status: SyncStatus): Promise<void> {