Fix #104496

src/vs/platform/userDataSync/common/userDataAutoSyncService.ts

@@ -131,8 +131,8 @@ export class UserDataAutoSyncService extends UserDataAutoSyncEnablementService i
 
  this._register(userDataSyncAccountService.onDidChangeAccount(() => this.updateAutoSync()));
  this._register(userDataSyncStoreService.onDidChangeDonotMakeRequestsUntil(() => this.updateAutoSync()));
- this._register(Event.debounce<string, string[]>(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)));
+ this._register(Event.debounce<string, string[]>(userDataSyncService.onDidChangeLocal, (last, source) => last ? [...last, source] : [source], 1000)(sources => this.triggerSync(sources, false, false)));
+ this._register(Event.filter(this.userDataSyncResourceEnablementService.onDidChangeResourceEnablement, ([, enabled]) => enabled)(() => this.triggerSync(['resourceEnablement'], false, false)));
  }
  }
 
@@ -320,7 +320,7 @@ export class UserDataAutoSyncService extends UserDataAutoSyncEnablementService i
  }
 
  private sources: string[] = [];
- async triggerSync(sources: string[], skipIfSyncedRecently: boolean): Promise<void> {
+ async triggerSync(sources: string[], skipIfSyncedRecently: boolean, disableCache: boolean): Promise<void> {
  if (this.autoSync.value === undefined) {
  return this.syncTriggerDelayer.cancel();
  }
@@ -337,7 +337,7 @@ export class UserDataAutoSyncService extends UserDataAutoSyncEnablementService i
  this.telemetryService.publicLog2<{ sources: string[] }, AutoSyncClassification>('sync/triggered', { sources: this.sources });
  this.sources = [];
  if (this.autoSync.value) {
- await this.autoSync.value.sync('Activity');
+ await this.autoSync.value.sync('Activity', disableCache);
  }
  }, this.successiveFailures
  ? this.getSyncTriggerDelayTime() * 1 * Math.min(Math.pow(2, this.successiveFailures), 60) /* Delay exponentially until max 1 minute */
@@ -393,14 +393,14 @@ class AutoSync extends Disposable {
  this.logService.info('Auto Sync: Stopped');
  }));
  this.logService.info('Auto Sync: Started');
- this.sync(AutoSync.INTERVAL_SYNCING);
+ this.sync(AutoSync.INTERVAL_SYNCING, false);
  }
 
  private waitUntilNextIntervalAndSync(): void {
- this.intervalHandler.value = disposableTimeout(() => this.sync(AutoSync.INTERVAL_SYNCING), this.interval);
+ this.intervalHandler.value = disposableTimeout(() => this.sync(AutoSync.INTERVAL_SYNCING, false), this.interval);
  }
 
- sync(reason: string): Promise<void> {
+ sync(reason: string, disableCache: boolean): Promise<void> {
  const syncPromise = createCancelablePromise(async token => {
  if (this.syncPromise) {
  try {
@@ -414,7 +414,7 @@ class AutoSync extends Disposable {
  }
  }
  }
- return this.doSync(reason, token);
+ return this.doSync(reason, disableCache, token);
  });
  this.syncPromise = syncPromise;
  this.syncPromise.finally(() => this.syncPromise = undefined);
@@ -435,12 +435,12 @@ class AutoSync extends Disposable {
  !isEqual(current.stableUrl, previous.stableUrl));
  }
 
- private async doSync(reason: string, token: CancellationToken): Promise<void> {
+ private async doSync(reason: string, disableCache: boolean, token: CancellationToken): Promise<void> {
  this.logService.info(`Auto Sync: Triggered by ${reason}`);
  this._onDidStartSync.fire();
  let error: Error | undefined;
  try {
- this.syncTask = await this.userDataSyncService.createSyncTask();
+ this.syncTask = await this.userDataSyncService.createSyncTask(disableCache);
  if (token.isCancellationRequested) {
  return;
  }

src/vs/platform/userDataSync/common/userDataSync.ts

@@ -437,7 +437,7 @@ export interface IUserDataSyncService {
  readonly onDidResetRemote: Event<void>;
  readonly onDidResetLocal: Event<void>;
 
- createSyncTask(): Promise<ISyncTask>;
+ createSyncTask(disableCache?: boolean): Promise<ISyncTask>;
  createManualSyncTask(): Promise<IManualSyncTask>;
 
  replace(uri: URI): Promise<void>;
@@ -465,7 +465,7 @@ export interface IUserDataAutoSyncService {
  canToggleEnablement(): boolean;
  turnOn(): Promise<void>;
  turnOff(everywhere: boolean): Promise<void>;
- triggerSync(sources: string[], hasToLimitSync: boolean): Promise<void>;
+ triggerSync(sources: string[], hasToLimitSync: boolean, disableCache: boolean): Promise<void>;
 }
 
 export const IUserDataSyncUtilService = createDecorator<IUserDataSyncUtilService>('IUserDataSyncUtilService');

src/vs/platform/userDataSync/common/userDataSyncIpc.ts

@@ -128,7 +128,7 @@ export class UserDataAutoSyncChannel implements IServerChannel {
 
  call(context: any, command: string, args?: any): Promise<any> {
  switch (command) {
- case 'triggerSync': return this.service.triggerSync(args[0], args[1]);
+ case 'triggerSync': return this.service.triggerSync(args[0], args[1], args[2]);
  case 'turnOn': return this.service.turnOn();
  case 'turnOff': return this.service.turnOff(args[0]);
  }

src/vs/platform/userDataSync/common/userDataSyncService.ts

@@ -106,13 +106,17 @@ export class UserDataSyncService extends Disposable implements IUserDataSyncServ
  this.onDidChangeLocal = Event.any(...this.synchronisers.map(s => Event.map(s.onDidChangeLocal, () => s.resource)));
  }
 
- async createSyncTask(): Promise<ISyncTask> {
+ async createSyncTask(disableCache?: boolean): Promise<ISyncTask> {
  await this.checkEnablement();
 
  const executionId = generateUuid();
  let manifest: IUserDataManifest | null;
  try {
- manifest = await this.userDataSyncStoreService.manifest(createSyncHeaders(executionId));
+ const syncHeaders = createSyncHeaders(executionId);
+ if (disableCache) {
+ syncHeaders['Cache-Control'] = 'no-cache';
+ }
+ manifest = await this.userDataSyncStoreService.manifest(syncHeaders);
  } catch (error) {
  error = UserDataSyncError.toUserDataSyncError(error);
  this.telemetryService.publicLog2<{ code: string, service: string, resource?: string, executionId?: string }, SyncErrorClassification>('sync/error', { code: error.code, resource: error.resource, executionId, service: this.userDataSyncStoreManagementService.userDataSyncStore!.url.toString() });

src/vs/platform/userDataSync/electron-browser/userDataAutoSyncService.ts

@@ -33,7 +33,7 @@ export class UserDataAutoSyncService extends BaseUserDataAutoSyncService {
  this._register(Event.debounce<string, string[]>(Event.any<string>(
  Event.map(electronService.onWindowFocus, () => 'windowFocus'),
  Event.map(electronService.onWindowOpen, () => 'windowOpen'),
- ), (last, source) => last ? [...last, source] : [source], 1000)(sources => this.triggerSync(sources, true)));
+ ), (last, source) => last ? [...last, source] : [source], 1000)(sources => this.triggerSync(sources, true, false)));
  }
 
 }

src/vs/platform/userDataSync/test/common/userDataAutoSyncService.test.ts

@@ -20,7 +20,7 @@ class TestUserDataAutoSyncService extends UserDataAutoSyncService {
  protected getSyncTriggerDelayTime(): number { return 50; }
 
  sync(): Promise<void> {
- return this.triggerSync(['sync'], false);
+ return this.triggerSync(['sync'], false, false);
  }
 }
 
@@ -43,7 +43,7 @@ suite('UserDataAutoSyncService', () => {
  const testObject: UserDataAutoSyncService = client.instantiationService.createInstance(TestUserDataAutoSyncService);
 
  // Trigger auto sync with settings change
- await testObject.triggerSync([SyncResource.Settings], false);
+ await testObject.triggerSync([SyncResource.Settings], false, false);
 
  // Filter out machine requests
  const actual = target.requests.filter(request => !request.url.startsWith(`${target.url}/v1/resource/machines`));
@@ -66,7 +66,7 @@ suite('UserDataAutoSyncService', () => {
 
  // Trigger auto sync with settings change multiple times
  for (let counter = 0; counter < 2; counter++) {
- await testObject.triggerSync([SyncResource.Settings], false);
+ await testObject.triggerSync([SyncResource.Settings], false, false);
  }
 
  // Filter out machine requests
@@ -91,7 +91,7 @@ suite('UserDataAutoSyncService', () => {
  const testObject: UserDataAutoSyncService = client.instantiationService.createInstance(TestUserDataAutoSyncService);
 
  // Trigger auto sync with window focus once
- await testObject.triggerSync(['windowFocus'], true);
+ await testObject.triggerSync(['windowFocus'], true, false);
 
  // Filter out machine requests
  const actual = target.requests.filter(request => !request.url.startsWith(`${target.url}/v1/resource/machines`));
@@ -114,7 +114,7 @@ suite('UserDataAutoSyncService', () => {
 
  // Trigger auto sync with window focus multiple times
  for (let counter = 0; counter < 2; counter++) {
- await testObject.triggerSync(['windowFocus'], true);
+ await testObject.triggerSync(['windowFocus'], true, false);
  }
 
  // Filter out machine requests
@@ -401,4 +401,28 @@ suite('UserDataAutoSyncService', () => {
  assert.deepEqual(target.requests, []);
  });
 
+ test('test cache control header with no cache is sent when triggered with disable cache option', async () => {
+ const target = new UserDataSyncTestServer(5, 1);
+
+ // Set up and sync from the test client
+ const testClient = disposableStore.add(new UserDataSyncClient(target));
+ await testClient.setUp();
+ const testObject: TestUserDataAutoSyncService = testClient.instantiationService.createInstance(TestUserDataAutoSyncService);
+
+ await testObject.triggerSync(['some reason'], true, true);
+ assert.equal(target.requestsWithAllHeaders[0].headers!['Cache-Control'], 'no-cache');
+ });
+
+ test('test cache control header is not sent when triggered without disable cache option', async () => {
+ const target = new UserDataSyncTestServer(5, 1);
+
+ // Set up and sync from the test client
+ const testClient = disposableStore.add(new UserDataSyncClient(target));
+ await testClient.setUp();
+ const testObject: TestUserDataAutoSyncService = testClient.instantiationService.createInstance(TestUserDataAutoSyncService);
+
+ await testObject.triggerSync(['some reason'], true, false);
+ assert.equal(target.requestsWithAllHeaders[0].headers!['Cache-Control'], undefined);
+ });
+
 });

src/vs/workbench/contrib/userDataSync/browser/userDataAutoSyncService.ts

@@ -36,7 +36,7 @@ export class UserDataAutoSyncService extends BaseUserDataAutoSyncService {
  this._register(Event.debounce<string, string[]>(Event.any<string>(
  Event.map(hostService.onDidChangeFocus, () => 'windowFocus'),
  instantiationService.createInstance(UserDataSyncTrigger).onDidTriggerSync,
- ), (last, source) => last ? [...last, source] : [source], 1000)(sources => this.triggerSync(sources, true)));
+ ), (last, source) => last ? [...last, source] : [source], 1000)(sources => this.triggerSync(sources, true, false)));
  }
 
 }

src/vs/workbench/contrib/userDataSync/browser/userDataSync.ts

@@ -1031,7 +1031,7 @@ export class UserDataSyncWorkbenchContribution extends Disposable implements IWo
  });
  }
  run(accessor: ServicesAccessor): Promise<any> {
- return that.userDataAutoSyncService.triggerSync([syncNowCommand.id], false);
+ return that.userDataAutoSyncService.triggerSync([syncNowCommand.id], false, true);
  }
  }));
  }

src/vs/workbench/contrib/userDataSync/electron-browser/userDataAutoSyncService.ts

@@ -29,11 +29,11 @@ export class UserDataAutoSyncService extends UserDataAutoSyncEnablementService i
  ) {
  super(storageService, environmentService, userDataSyncStoreManagementService);
  this.channel = sharedProcessService.getChannel('userDataAutoSync');
- this._register(instantiationService.createInstance(UserDataSyncTrigger).onDidTriggerSync(source => this.triggerSync([source], true)));
+ this._register(instantiationService.createInstance(UserDataSyncTrigger).onDidTriggerSync(source => this.triggerSync([source], true, false)));
  }
 
- triggerSync(sources: string[], hasToLimitSync: boolean): Promise<void> {
- return this.channel.call('triggerSync', [sources, hasToLimitSync]);
+ triggerSync(sources: string[], hasToLimitSync: boolean, disableCache: boolean): Promise<void> {
+ return this.channel.call('triggerSync', [sources, hasToLimitSync, disableCache]);
  }
 
  turnOn(): Promise<void> {

src/vs/workbench/electron-sandbox/sandbox.simpleservices.ts

@@ -718,7 +718,7 @@ class SimpleUserDataAutoSyncAccountService implements IUserDataAutoSyncService {
  canToggleEnablement(): boolean { return false; }
  async turnOn(): Promise<void> { }
  async turnOff(everywhere: boolean): Promise<void> { }
- async triggerSync(sources: string[], hasToLimitSync: boolean): Promise<void> { }
+ async triggerSync(sources: string[], hasToLimitSync: boolean, disableCache: boolean): Promise<void> { }
 }
 
 registerSingleton(IUserDataAutoSyncService, SimpleUserDataAutoSyncAccountService);