From 5ca3e09eb6bc09ef8785aa666bde38b660946c34 Mon Sep 17 00:00:00 2001 From: Sandeep Somavarapu Date: Wed, 17 Jun 2020 09:59:09 +0200 Subject: [PATCH] Fix #99102 --- .../common/userDataAutoSyncService.ts | 115 ++++++++++++++++-- .../userDataSync/common/userDataSync.ts | 2 +- .../userDataSync/common/userDataSyncIpc.ts | 2 +- .../common/userDataSyncService.ts | 38 +----- .../userDataAutoSyncService.ts | 6 +- .../common/userDataAutoSyncService.test.ts | 26 ++-- .../test/common/userDataSyncService.test.ts | 10 -- .../browser/userDataAutoSyncService.ts | 6 +- .../browser/userDataSync.contribution.ts | 1 + .../userDataAutoSyncService.ts | 4 +- .../userDataSync.contribution.ts | 1 + .../browser/userDataSyncWorkbenchService.ts | 11 +- 12 files changed, 148 insertions(+), 74 deletions(-) diff --git a/src/vs/platform/userDataSync/common/userDataAutoSyncService.ts b/src/vs/platform/userDataSync/common/userDataAutoSyncService.ts index a00b3c9240e..bad5e25c6d3 100644 --- a/src/vs/platform/userDataSync/common/userDataAutoSyncService.ts +++ b/src/vs/platform/userDataSync/common/userDataAutoSyncService.ts @@ -3,7 +3,7 @@ * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ -import { Delayer, disposableTimeout, CancelablePromise, createCancelablePromise } from 'vs/base/common/async'; +import { Delayer, disposableTimeout, CancelablePromise, createCancelablePromise, timeout } from 'vs/base/common/async'; import { Event, Emitter } from 'vs/base/common/event'; import { Disposable, toDisposable, MutableDisposable, IDisposable } from 'vs/base/common/lifecycle'; import { IUserDataSyncLogService, IUserDataSyncService, IUserDataAutoSyncService, UserDataSyncError, UserDataSyncErrorCode, IUserDataSyncResourceEnablementService, IUserDataSyncStoreService } from 'vs/platform/userDataSync/common/userDataSync'; @@ -13,6 +13,10 @@ import { isPromiseCanceledError } from 'vs/base/common/errors'; import { CancellationToken } from 'vs/base/common/cancellation'; import { IStorageService, StorageScope, IWorkspaceStorageChangeEvent } from 'vs/platform/storage/common/storage'; import { IEnvironmentService } from 'vs/platform/environment/common/environment'; +import { IUserDataSyncMachine, IUserDataSyncMachinesService } from 'vs/platform/userDataSync/common/userDataSyncMachines'; +import { PlatformToString, isWeb, Platform, platform } from 'vs/base/common/platform'; +import { escapeRegExpCharacters } from 'vs/base/common/strings'; +import { IProductService } from 'vs/platform/product/common/productService'; type AutoSyncClassification = { sources: { classification: 'SystemMetaData', purpose: 'FeatureInsight', isMeasurement: true }; @@ -23,6 +27,7 @@ type AutoSyncEnablementClassification = { }; const enablementKey = 'sync.enable'; +const disableMachineEventuallyKey = 'sync.disableMachineEventually'; export class UserDataAutoSyncEnablementService extends Disposable { @@ -80,6 +85,8 @@ export class UserDataAutoSyncService extends UserDataAutoSyncEnablementService i @IUserDataSyncLogService private readonly logService: IUserDataSyncLogService, @IUserDataSyncAccountService private readonly authTokenService: IUserDataSyncAccountService, @ITelemetryService private readonly telemetryService: ITelemetryService, + @IUserDataSyncMachinesService private readonly userDataSyncMachinesService: IUserDataSyncMachinesService, + @IProductService private readonly productService: IProductService, @IStorageService storageService: IStorageService, @IEnvironmentService environmentService: IEnvironmentService ) { @@ -88,6 +95,14 @@ export class UserDataAutoSyncService extends UserDataAutoSyncEnablementService i if (userDataSyncStoreService.userDataSyncStore) { this.updateAutoSync(); + + // Update machine if sync is enabled + if (this.isEnabled()) { + this.updateMachine(true); + } else if (this.hasToDisableMachineEventually()) { + this.disableMachineEventually(); + } + this._register(authTokenService.onDidChangeAccount(() => this.updateAutoSync())); this._register(Event.debounce(userDataSyncService.onDidChangeLocal, (last, source) => last ? [...last, source] : [source], 1000)(sources => this.triggerSync(sources, false))); this._register(Event.filter(this.userDataSyncResourceEnablementService.onDidChangeResourceEnablement, ([, enabled]) => enabled)(() => this.triggerSync(['resourceEnablement'], false))); @@ -128,6 +143,8 @@ export class UserDataAutoSyncService extends UserDataAutoSyncEnablementService i } async turnOn(pullFirst: boolean): Promise { + await this.updateMachine(true); + if (pullFirst) { await this.userDataSyncService.pull(); } else { @@ -137,8 +154,27 @@ export class UserDataAutoSyncService extends UserDataAutoSyncEnablementService i this.setEnablement(true); } - async turnOff(): Promise { - this.setEnablement(false); + async turnOff(everywhere: boolean, softTurnOffOnError?: boolean, donotDisableMachine?: boolean): Promise { + try { + if (!donotDisableMachine) { + await this.updateMachine(false); + } + this.setEnablement(false); + + if (everywhere) { + this.telemetryService.publicLog2('sync/turnOffEveryWhere'); + await this.userDataSyncService.reset(); + } else { + await this.userDataSyncService.resetLocal(); + } + } catch (error) { + if (softTurnOffOnError) { + this.logService.error(error); + this.setEnablement(false); + } else { + throw error; + } + } } private setEnablement(enabled: boolean): void { @@ -149,6 +185,44 @@ export class UserDataAutoSyncService extends UserDataAutoSyncEnablementService i } } + private async updateMachine(enable: boolean): Promise { + if (!this.authTokenService.account) { + return; + } + + const machines = await this.userDataSyncMachinesService.getMachines(); + const currentMachine = machines.find(machine => machine.isCurrent); + if (enable) { + this.stopDisableMachineEventually(); + // Add or enable current machine + if (!currentMachine) { + const name = this.computeDefaultMachineName(machines); + await this.userDataSyncMachinesService.addCurrentMachine(name); + this.logService.debug('Auto Sync: Added current machine to sync'); + } else if (currentMachine.disabled) { + await this.userDataSyncMachinesService.setEnablement(currentMachine.id, true); + this.logService.debug('Auto Sync: Enabled current machine to sync'); + } + } else if (currentMachine && !currentMachine.disabled) { + await this.userDataSyncMachinesService.setEnablement(currentMachine.id, false); + this.logService.debug('Auto Sync: Disabled current machine to sync'); + } + } + + private computeDefaultMachineName(machines: IUserDataSyncMachine[]): string { + const namePrefix = `${this.productService.nameLong} (${PlatformToString(isWeb ? Platform.Web : platform)})`; + const nameRegEx = new RegExp(`${escapeRegExpCharacters(namePrefix)}\\s#(\\d)`); + + let nameIndex = 0; + for (const machine of machines) { + const matches = nameRegEx.exec(machine.name); + const index = matches ? parseInt(matches[1]) : 0; + nameIndex = index > nameIndex ? index : nameIndex; + } + + return `${namePrefix} #${nameIndex + 1}`; + } + private async onDidFinishSync(error: Error | undefined): Promise { if (!error) { // Sync finished without errors @@ -159,12 +233,12 @@ export class UserDataAutoSyncService extends UserDataAutoSyncEnablementService i // Error while syncing const userDataSyncError = UserDataSyncError.toUserDataSyncError(error); if (userDataSyncError.code === UserDataSyncErrorCode.TurnedOff || userDataSyncError.code === UserDataSyncErrorCode.SessionExpired) { - this.logService.info('Auto Sync: Sync is turned off in the cloud.'); - await this.userDataSyncService.resetLocal(); - this.turnOff(); + await this.turnOff(false, true /* force soft turnoff on error */); this.logService.info('Auto Sync: Turned off sync because sync is turned off in the cloud'); - } else if (userDataSyncError.code === UserDataSyncErrorCode.LocalTooManyRequests) { - this.turnOff(); + } else if (userDataSyncError.code === UserDataSyncErrorCode.LocalTooManyRequests || userDataSyncError.code === UserDataSyncErrorCode.TooManyRequests) { + await this.turnOff(false, true /* force soft turnoff on error */, + true /* do not disable machine because disabling a machine makes request to server and can fail with TooManyRequests */); + this.disableMachineEventually(); this.logService.info('Auto Sync: Turned off sync because of making too many requests to server'); } else { this.logService.error(userDataSyncError); @@ -173,6 +247,31 @@ export class UserDataAutoSyncService extends UserDataAutoSyncEnablementService i this._onError.fire(userDataSyncError); } + private async disableMachineEventually(): Promise { + this.storageService.store(disableMachineEventuallyKey, true, StorageScope.GLOBAL); + await timeout(1000 * 60 * 10); + + // Return if got stopped meanwhile. + if (!this.hasToDisableMachineEventually()) { + return; + } + + this.stopDisableMachineEventually(); + + // disable only if sync is disabled + if (!this.isEnabled()) { + return this.updateMachine(false); + } + } + + private hasToDisableMachineEventually(): boolean { + return this.storageService.getBoolean(disableMachineEventuallyKey, StorageScope.GLOBAL, false); + } + + private stopDisableMachineEventually(): void { + this.storageService.remove(disableMachineEventuallyKey, StorageScope.GLOBAL); + } + private sources: string[] = []; async triggerSync(sources: string[], skipIfSyncedRecently: boolean): Promise { if (this.autoSync.value === undefined) { diff --git a/src/vs/platform/userDataSync/common/userDataSync.ts b/src/vs/platform/userDataSync/common/userDataSync.ts index a98d8ef6613..85eb2399cff 100644 --- a/src/vs/platform/userDataSync/common/userDataSync.ts +++ b/src/vs/platform/userDataSync/common/userDataSync.ts @@ -381,7 +381,7 @@ export interface IUserDataAutoSyncService { isEnabled(): boolean; canToggleEnablement(): boolean; turnOn(pullFirst: boolean): Promise; - turnOff(): Promise; + turnOff(everywhere: boolean): Promise; triggerSync(sources: string[], hasToLimitSync: boolean): Promise; } diff --git a/src/vs/platform/userDataSync/common/userDataSyncIpc.ts b/src/vs/platform/userDataSync/common/userDataSyncIpc.ts index 33962117c9d..c3d1ccdcf85 100644 --- a/src/vs/platform/userDataSync/common/userDataSyncIpc.ts +++ b/src/vs/platform/userDataSync/common/userDataSyncIpc.ts @@ -77,7 +77,7 @@ export class UserDataAutoSyncChannel implements IServerChannel { switch (command) { case 'triggerSync': return this.service.triggerSync(args[0], args[1]); case 'turnOn': return this.service.turnOn(args[0]); - case 'turnOff': return this.service.turnOff(); + case 'turnOff': return this.service.turnOff(args[0]); } throw new Error('Invalid call'); } diff --git a/src/vs/platform/userDataSync/common/userDataSyncService.ts b/src/vs/platform/userDataSync/common/userDataSyncService.ts index c1f669efd36..3877a837cda 100644 --- a/src/vs/platform/userDataSync/common/userDataSyncService.ts +++ b/src/vs/platform/userDataSync/common/userDataSyncService.ts @@ -19,10 +19,7 @@ import { URI } from 'vs/base/common/uri'; import { SettingsSynchroniser } from 'vs/platform/userDataSync/common/settingsSync'; import { isEqual } from 'vs/base/common/resources'; import { SnippetsSynchroniser } from 'vs/platform/userDataSync/common/snippetsSync'; -import { IUserDataSyncMachinesService, IUserDataSyncMachine } from 'vs/platform/userDataSync/common/userDataSyncMachines'; -import { IProductService } from 'vs/platform/product/common/productService'; -import { platform, PlatformToString, isWeb, Platform } from 'vs/base/common/platform'; -import { escapeRegExpCharacters } from 'vs/base/common/strings'; +import { IUserDataSyncMachinesService } from 'vs/platform/userDataSync/common/userDataSyncMachines'; import { CancellationToken } from 'vs/base/common/cancellation'; import { generateUuid } from 'vs/base/common/uuid'; import { IHeaders } from 'vs/base/parts/request/common/request'; @@ -74,7 +71,6 @@ export class UserDataSyncService extends Disposable implements IUserDataSyncServ @ITelemetryService private readonly telemetryService: ITelemetryService, @IStorageService private readonly storageService: IStorageService, @IUserDataSyncMachinesService private readonly userDataSyncMachinesService: IUserDataSyncMachinesService, - @IProductService private readonly productService: IProductService ) { super(); this.settingsSynchroniser = this._register(this.instantiationService.createInstance(SettingsSynchroniser)); @@ -175,17 +171,14 @@ export class UserDataSyncService extends Disposable implements IUserDataSyncServ } const machines = await this.userDataSyncMachinesService.getMachines(manifest || undefined); - const currentMachine = machines.find(machine => machine.isCurrent); - // Return if cancellation is requested if (token.isCancellationRequested) { return; } + const currentMachine = machines.find(machine => machine.isCurrent); // Check if sync was turned off from other machine if (currentMachine?.disabled) { - // Unset the current machine - await this.userDataSyncMachinesService.removeCurrentMachine(manifest || undefined); // Throw TurnedOff error throw new UserDataSyncError(localize('turned off machine', "Cannot sync because syncing is turned off on this machine from another machine."), UserDataSyncErrorCode.TurnedOff); } @@ -223,12 +216,6 @@ export class UserDataSyncService extends Disposable implements IUserDataSyncServ return; } - // Add current machine - if (!currentMachine) { - const name = this.computeDefaultMachineName(machines); - await this.userDataSyncMachinesService.addCurrentMachine(name, manifest || undefined); - } - // Return if cancellation is requested if (token.isCancellationRequested) { return; @@ -346,16 +333,13 @@ export class UserDataSyncService extends Disposable implements IUserDataSyncServ async reset(): Promise { await this.checkEnablement(); await this.resetRemote(); - await this.resetLocal(true); + await this.resetLocal(); } - async resetLocal(donotUnsetMachine?: boolean): Promise { + async resetLocal(): Promise { await this.checkEnablement(); this.storageService.remove(SESSION_ID_KEY, StorageScope.GLOBAL); this.storageService.remove(LAST_SYNC_TIME_KEY, StorageScope.GLOBAL); - if (!donotUnsetMachine) { - await this.userDataSyncMachinesService.removeCurrentMachine(); - } for (const synchroniser of this.synchronisers) { try { await synchroniser.resetLocal(); @@ -455,20 +439,6 @@ export class UserDataSyncService extends Disposable implements IUserDataSyncServ .map(s => ({ syncResource: s.resource, conflicts: s.conflicts })); } - private computeDefaultMachineName(machines: IUserDataSyncMachine[]): string { - const namePrefix = `${this.productService.nameLong} (${PlatformToString(isWeb ? Platform.Web : platform)})`; - const nameRegEx = new RegExp(`${escapeRegExpCharacters(namePrefix)}\\s#(\\d)`); - - let nameIndex = 0; - for (const machine of machines) { - const matches = nameRegEx.exec(machine.name); - const index = matches ? parseInt(matches[1]) : 0; - nameIndex = index > nameIndex ? index : nameIndex; - } - - return `${namePrefix} #${nameIndex + 1}`; - } - getSynchroniser(source: SyncResource): IUserDataSynchroniser { return this.synchronisers.filter(s => s.resource === source)[0]; } diff --git a/src/vs/platform/userDataSync/electron-browser/userDataAutoSyncService.ts b/src/vs/platform/userDataSync/electron-browser/userDataAutoSyncService.ts index 440f2c7a52e..3da88e478d1 100644 --- a/src/vs/platform/userDataSync/electron-browser/userDataAutoSyncService.ts +++ b/src/vs/platform/userDataSync/electron-browser/userDataAutoSyncService.ts @@ -11,6 +11,8 @@ import { IUserDataSyncAccountService } from 'vs/platform/userDataSync/common/use import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry'; import { IStorageService } from 'vs/platform/storage/common/storage'; import { IEnvironmentService } from 'vs/platform/environment/common/environment'; +import { IUserDataSyncMachinesService } from 'vs/platform/userDataSync/common/userDataSyncMachines'; +import { IProductService } from 'vs/platform/product/common/productService'; export class UserDataAutoSyncService extends BaseUserDataAutoSyncService { @@ -22,10 +24,12 @@ export class UserDataAutoSyncService extends BaseUserDataAutoSyncService { @IUserDataSyncLogService logService: IUserDataSyncLogService, @IUserDataSyncAccountService authTokenService: IUserDataSyncAccountService, @ITelemetryService telemetryService: ITelemetryService, + @IUserDataSyncMachinesService userDataSyncMachinesService: IUserDataSyncMachinesService, + @IProductService productService: IProductService, @IStorageService storageService: IStorageService, @IEnvironmentService environmentService: IEnvironmentService, ) { - super(userDataSyncStoreService, userDataSyncResourceEnablementService, userDataSyncService, logService, authTokenService, telemetryService, storageService, environmentService); + super(userDataSyncStoreService, userDataSyncResourceEnablementService, userDataSyncService, logService, authTokenService, telemetryService, userDataSyncMachinesService, productService, storageService, environmentService); this._register(Event.debounce(Event.any( Event.map(electronService.onWindowFocus, () => 'windowFocus'), diff --git a/src/vs/platform/userDataSync/test/common/userDataAutoSyncService.test.ts b/src/vs/platform/userDataSync/test/common/userDataAutoSyncService.test.ts index 1366b5f55a4..db0606bb8d1 100644 --- a/src/vs/platform/userDataSync/test/common/userDataAutoSyncService.test.ts +++ b/src/vs/platform/userDataSync/test/common/userDataAutoSyncService.test.ts @@ -36,8 +36,11 @@ suite('UserDataAutoSyncService', () => { // Trigger auto sync with settings change await testObject.triggerSync([SyncResource.Settings], false); - // Make sure only one request is made - assert.deepEqual(target.requests, [{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} }]); + // Filter out machine requests + const actual = target.requests.filter(request => !request.url.startsWith(`${target.url}/v1/resource/machines`)); + + // Make sure only one manifest request is made + assert.deepEqual(actual, [{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} }]); }); test('test auto sync with sync resource change triggers sync for every change', async () => { @@ -57,7 +60,10 @@ suite('UserDataAutoSyncService', () => { await testObject.triggerSync([SyncResource.Settings], false); } - assert.deepEqual(target.requests, [ + // Filter out machine requests + const actual = target.requests.filter(request => !request.url.startsWith(`${target.url}/v1/resource/machines`)); + + assert.deepEqual(actual, [ { type: 'GET', url: `${target.url}/v1/manifest`, headers: {} }, { type: 'GET', url: `${target.url}/v1/manifest`, headers: {} } ]); @@ -78,8 +84,11 @@ suite('UserDataAutoSyncService', () => { // Trigger auto sync with window focus once await testObject.triggerSync(['windowFocus'], true); - // Make sure only one request is made - assert.deepEqual(target.requests, [{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} }]); + // Filter out machine requests + const actual = target.requests.filter(request => !request.url.startsWith(`${target.url}/v1/resource/machines`)); + + // Make sure only one manifest request is made + assert.deepEqual(actual, [{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} }]); }); test('test auto sync with non sync resource change does not trigger continuous syncs', async () => { @@ -99,8 +108,11 @@ suite('UserDataAutoSyncService', () => { await testObject.triggerSync(['windowFocus'], true); } - // Make sure only one request is made - assert.deepEqual(target.requests, [{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} }]); + // Filter out machine requests + const actual = target.requests.filter(request => !request.url.startsWith(`${target.url}/v1/resource/machines`)); + + // Make sure only one manifest request is made + assert.deepEqual(actual, [{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} }]); }); diff --git a/src/vs/platform/userDataSync/test/common/userDataSyncService.test.ts b/src/vs/platform/userDataSync/test/common/userDataSyncService.test.ts index 6e9639bcc33..9625a6ab0e6 100644 --- a/src/vs/platform/userDataSync/test/common/userDataSyncService.test.ts +++ b/src/vs/platform/userDataSync/test/common/userDataSyncService.test.ts @@ -50,8 +50,6 @@ suite('UserDataSyncService', () => { { type: 'GET', url: `${target.url}/v1/resource/extensions/latest`, headers: {} }, // Manifest { type: 'GET', url: `${target.url}/v1/manifest`, headers: {} }, - // Machines - { type: 'POST', url: `${target.url}/v1/resource/machines`, headers: { 'If-Match': '0' } }, ]); }); @@ -83,8 +81,6 @@ suite('UserDataSyncService', () => { { type: 'GET', url: `${target.url}/v1/resource/extensions/latest`, headers: {} }, // Manifest { type: 'GET', url: `${target.url}/v1/manifest`, headers: {} }, - // Machines - { type: 'POST', url: `${target.url}/v1/resource/machines`, headers: { 'If-Match': '0' } }, ]); }); @@ -194,7 +190,6 @@ suite('UserDataSyncService', () => { { type: 'GET', url: `${target.url}/v1/resource/snippets/latest`, headers: {} }, { type: 'GET', url: `${target.url}/v1/resource/globalState/latest`, headers: {} }, { type: 'GET', url: `${target.url}/v1/resource/extensions/latest`, headers: {} }, - { type: 'POST', url: `${target.url}/v1/resource/machines`, headers: { 'If-Match': '1' } }, ]); }); @@ -239,7 +234,6 @@ suite('UserDataSyncService', () => { { type: 'POST', url: `${target.url}/v1/resource/snippets`, headers: { 'If-Match': '1' } }, { type: 'GET', url: `${target.url}/v1/resource/globalState/latest`, headers: {} }, { type: 'GET', url: `${target.url}/v1/resource/extensions/latest`, headers: {} }, - { type: 'POST', url: `${target.url}/v1/resource/machines`, headers: { 'If-Match': '1' } }, ]); }); @@ -379,8 +373,6 @@ suite('UserDataSyncService', () => { assert.deepEqual(target.requests, [ // Manifest { type: 'GET', url: `${target.url}/v1/manifest`, headers: {} }, - // Machines - { type: 'GET', url: `${target.url}/v1/resource/machines/latest`, headers: { 'If-None-Match': '1' } }, // Settings { type: 'GET', url: `${target.url}/v1/resource/settings/latest`, headers: {} }, { type: 'POST', url: `${target.url}/v1/resource/settings`, headers: { 'If-Match': '0' } }, @@ -397,8 +389,6 @@ suite('UserDataSyncService', () => { { type: 'GET', url: `${target.url}/v1/resource/extensions/latest`, headers: {} }, // Manifest { type: 'GET', url: `${target.url}/v1/manifest`, headers: {} }, - // Machines - { type: 'POST', url: `${target.url}/v1/resource/machines`, headers: { 'If-Match': '0' } }, ]); }); diff --git a/src/vs/workbench/contrib/userDataSync/browser/userDataAutoSyncService.ts b/src/vs/workbench/contrib/userDataSync/browser/userDataAutoSyncService.ts index 9f51276201d..baff3ffea12 100644 --- a/src/vs/workbench/contrib/userDataSync/browser/userDataAutoSyncService.ts +++ b/src/vs/workbench/contrib/userDataSync/browser/userDataAutoSyncService.ts @@ -13,6 +13,8 @@ import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry'; import { UserDataSyncTrigger } from 'vs/workbench/contrib/userDataSync/browser/userDataSyncTrigger'; import { IStorageService } from 'vs/platform/storage/common/storage'; import { IEnvironmentService } from 'vs/platform/environment/common/environment'; +import { IUserDataSyncMachinesService } from 'vs/platform/userDataSync/common/userDataSyncMachines'; +import { IProductService } from 'vs/platform/product/common/productService'; export class UserDataAutoSyncService extends BaseUserDataAutoSyncService { @@ -25,10 +27,12 @@ export class UserDataAutoSyncService extends BaseUserDataAutoSyncService { @IInstantiationService instantiationService: IInstantiationService, @IHostService hostService: IHostService, @ITelemetryService telemetryService: ITelemetryService, + @IUserDataSyncMachinesService userDataSyncMachinesService: IUserDataSyncMachinesService, + @IProductService productService: IProductService, @IStorageService storageService: IStorageService, @IEnvironmentService environmentService: IEnvironmentService, ) { - super(userDataSyncStoreService, userDataSyncResourceEnablementService, userDataSyncService, logService, authTokenService, telemetryService, storageService, environmentService); + super(userDataSyncStoreService, userDataSyncResourceEnablementService, userDataSyncService, logService, authTokenService, telemetryService, userDataSyncMachinesService, productService, storageService, environmentService); this._register(Event.debounce(Event.any( Event.map(hostService.onDidChangeFocus, () => 'windowFocus'), diff --git a/src/vs/workbench/contrib/userDataSync/browser/userDataSync.contribution.ts b/src/vs/workbench/contrib/userDataSync/browser/userDataSync.contribution.ts index 7c7aa24f106..ef0e9e8afb3 100644 --- a/src/vs/workbench/contrib/userDataSync/browser/userDataSync.contribution.ts +++ b/src/vs/workbench/contrib/userDataSync/browser/userDataSync.contribution.ts @@ -26,6 +26,7 @@ class UserDataSyncReportIssueContribution extends Disposable implements IWorkben private onAutoSyncError(error: UserDataSyncError): void { switch (error.code) { case UserDataSyncErrorCode.LocalTooManyRequests: + case UserDataSyncErrorCode.TooManyRequests: this.notificationService.notify({ severity: Severity.Error, message: localize('too many requests', "Turned off syncing preferences on this device because it is making too many requests."), diff --git a/src/vs/workbench/contrib/userDataSync/electron-browser/userDataAutoSyncService.ts b/src/vs/workbench/contrib/userDataSync/electron-browser/userDataAutoSyncService.ts index c86ff9ffd24..fb778ec18af 100644 --- a/src/vs/workbench/contrib/userDataSync/electron-browser/userDataAutoSyncService.ts +++ b/src/vs/workbench/contrib/userDataSync/electron-browser/userDataAutoSyncService.ts @@ -39,8 +39,8 @@ export class UserDataAutoSyncService extends UserDataAutoSyncEnablementService i return this.channel.call('turnOn', [pullFirst]); } - turnOff(): Promise { - return this.channel.call('turnOff'); + turnOff(everywhere: boolean): Promise { + return this.channel.call('turnOff', [everywhere]); } } diff --git a/src/vs/workbench/contrib/userDataSync/electron-browser/userDataSync.contribution.ts b/src/vs/workbench/contrib/userDataSync/electron-browser/userDataSync.contribution.ts index 5c7c757451f..3ae332cdd7d 100644 --- a/src/vs/workbench/contrib/userDataSync/electron-browser/userDataSync.contribution.ts +++ b/src/vs/workbench/contrib/userDataSync/electron-browser/userDataSync.contribution.ts @@ -47,6 +47,7 @@ class UserDataSyncReportIssueContribution extends Disposable implements IWorkben private onAutoSyncError(error: UserDataSyncError): void { switch (error.code) { case UserDataSyncErrorCode.LocalTooManyRequests: + case UserDataSyncErrorCode.TooManyRequests: this.notificationService.notify({ severity: Severity.Error, message: localize('too many requests', "Turned off syncing preferences on this device because it is making too many requests. Please report an issue by providing the sync logs."), diff --git a/src/vs/workbench/services/userDataSync/browser/userDataSyncWorkbenchService.ts b/src/vs/workbench/services/userDataSync/browser/userDataSyncWorkbenchService.ts index f2e782442e2..a2b39520076 100644 --- a/src/vs/workbench/services/userDataSync/browser/userDataSyncWorkbenchService.ts +++ b/src/vs/workbench/services/userDataSync/browser/userDataSyncWorkbenchService.ts @@ -224,15 +224,8 @@ export class UserDataSyncWorkbenchService extends Disposable implements IUserDat this.notificationService.info(localize('sync turned on', "Preferences sync is turned on")); } - async turnoff(everywhere: boolean): Promise { - await this.userDataAutoSyncService.turnOff(); - - if (everywhere) { - this.telemetryService.publicLog2('sync/turnOffEveryWhere'); - await this.userDataSyncService.reset(); - } else { - await this.userDataSyncService.resetLocal(); - } + turnoff(everywhere: boolean): Promise { + return this.userDataAutoSyncService.turnOff(everywhere); } private async handleFirstTimeSync(): Promise { -- GitLab