Merge from vscode a234f13c45b40a0929777cb440ee011b7549eed2 (#8911)

* Merge from vscode a234f13c45b40a0929777cb440ee011b7549eed2 * update distro * fix layering * update distro * fix tests
2026-02-14 12:08:36 -05:00 · 2020-01-22 13:42:37 -08:00
parent 977111eb21
commit bd7aac8ee0
895 changed files with 24651 additions and 14520 deletions
--- a/src/vs/platform/userDataSync/common/settingsSync.ts
+++ b/src/vs/platform/userDataSync/common/settingsSync.ts
@@ -3,9 +3,8 @@
 *  Licensed under the Source EULA. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

-import { Disposable } from 'vs/base/common/lifecycle';
-import { IFileService, FileSystemProviderErrorCode, FileSystemProviderError, IFileContent } from 'vs/platform/files/common/files';
-import { IUserData, UserDataSyncStoreError, UserDataSyncStoreErrorCode, ISynchroniser, SyncStatus, IUserDataSyncStoreService, DEFAULT_IGNORED_SETTINGS, IUserDataSyncLogService, IUserDataSyncUtilService } from 'vs/platform/userDataSync/common/userDataSync';
+import { IFileService, FileSystemProviderErrorCode, FileSystemProviderError, IFileContent, FileOperationError, FileOperationResult } from 'vs/platform/files/common/files';
+import { IUserData, UserDataSyncStoreError, UserDataSyncStoreErrorCode, SyncStatus, IUserDataSyncStoreService, DEFAULT_IGNORED_SETTINGS, IUserDataSyncLogService, IUserDataSyncUtilService, IConflictSetting, ISettingsSyncService, CONFIGURATION_SYNC_STORE_KEY, SyncSource } from 'vs/platform/userDataSync/common/userDataSync';
 import { VSBuffer } from 'vs/base/common/buffer';
 import { parse, ParseError } from 'vs/base/common/json';
 import { localize } from 'vs/nls';
@@ -17,18 +16,25 @@ import { joinPath, dirname } from 'vs/base/common/resources';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { startsWith } from 'vs/base/common/strings';
 import { CancellationToken } from 'vs/base/common/cancellation';
-import { computeRemoteContent, merge } from 'vs/platform/userDataSync/common/settingsMerge';
+import { updateIgnoredSettings, merge } from 'vs/platform/userDataSync/common/settingsMerge';
 import { FormattingOptions } from 'vs/base/common/jsonFormatter';
+import * as arrays from 'vs/base/common/arrays';
+import * as objects from 'vs/base/common/objects';
+import { isEmptyObject } from 'vs/base/common/types';
+import { edit } from 'vs/platform/userDataSync/common/content';
+import { AbstractSynchroniser } from 'vs/platform/userDataSync/common/abstractSynchronizer';

 interface ISyncPreviewResult {
 	readonly fileContent: IFileContent | null;
-	readonly remoteUserData: IUserData;
+	readonly remoteUserData: IUserData | null;
 	readonly hasLocalChanged: boolean;
 	readonly hasRemoteChanged: boolean;
-	readonly hasConflicts: boolean;
+	readonly conflicts: IConflictSetting[];
 }

-export class SettingsSynchroniser extends Disposable implements ISynchroniser {
+export class SettingsSynchroniser extends AbstractSynchroniser implements ISettingsSyncService {
+
+	_serviceBrand: any;

 	private static EXTERNAL_USER_DATA_SETTINGS_KEY: string = 'settings';

@@ -39,20 +45,25 @@ export class SettingsSynchroniser extends Disposable implements ISynchroniser {
 	private _onDidChangStatus: Emitter<SyncStatus> = this._register(new Emitter<SyncStatus>());
 	readonly onDidChangeStatus: Event<SyncStatus> = this._onDidChangStatus.event;

+	private _conflicts: IConflictSetting[] = [];
+	get conflicts(): IConflictSetting[] { return this._conflicts; }
+	private _onDidChangeConflicts: Emitter<IConflictSetting[]> = this._register(new Emitter<IConflictSetting[]>());
+	readonly onDidChangeConflicts: Event<IConflictSetting[]> = this._onDidChangeConflicts.event;
+
 	private _onDidChangeLocal: Emitter<void> = this._register(new Emitter<void>());
 	readonly onDidChangeLocal: Event<void> = this._onDidChangeLocal.event;

 	private readonly lastSyncSettingsResource: URI;

 	constructor(
-		@IFileService private readonly fileService: IFileService,
+		@IFileService fileService: IFileService,
 		@IEnvironmentService private readonly environmentService: IEnvironmentService,
 		@IUserDataSyncStoreService private readonly userDataSyncStoreService: IUserDataSyncStoreService,
 		@IUserDataSyncLogService private readonly logService: IUserDataSyncLogService,
 		@IUserDataSyncUtilService private readonly userDataSyncUtilService: IUserDataSyncUtilService,
 		@IConfigurationService private readonly configurationService: IConfigurationService,
 	) {
-		super();
+		super(SyncSource.Settings, fileService, environmentService);
 		this.lastSyncSettingsResource = joinPath(this.environmentService.userRoamingDataHome, '.lastSyncSettings.json');
 		this._register(this.fileService.watch(dirname(this.environmentService.settingsResource)));
 		this._register(Event.filter(this.fileService.onFileChanges, e => e.contains(this.environmentService.settingsResource))(() => this._onDidChangeLocal.fire()));
@@ -63,6 +74,103 @@ export class SettingsSynchroniser extends Disposable implements ISynchroniser {
 			this._status = status;
 			this._onDidChangStatus.fire(status);
 		}
+		if (this._status !== SyncStatus.HasConflicts) {
+			this.setConflicts([]);
+		}
+	}
+
+	private setConflicts(conflicts: IConflictSetting[]): void {
+		if (!arrays.equals(this.conflicts, conflicts,
+			(a, b) => a.key === b.key && objects.equals(a.localValue, b.localValue) && objects.equals(a.remoteValue, b.remoteValue))
+		) {
+			this._conflicts = conflicts;
+			this._onDidChangeConflicts.fire(conflicts);
+		}
+	}
+
+	async pull(): Promise<void> {
+		if (!this.configurationService.getValue<boolean>('sync.enableSettings')) {
+			this.logService.info('Settings: Skipped pulling settings as it is disabled.');
+			return;
+		}
+
+		this.stop();
+
+		try {
+			this.logService.info('Settings: Started pulling settings...');
+			this.setStatus(SyncStatus.Syncing);
+
+			const remoteUserData = await this.getRemoteUserData();
+
+			if (remoteUserData.content !== null) {
+				const fileContent = await this.getLocalFileContent();
+				const formatUtils = await this.getFormattingOptions();
+				// Update ignored settings
+				const content = updateIgnoredSettings(remoteUserData.content, fileContent ? fileContent.value.toString() : '{}', getIgnoredSettings(this.configurationService), formatUtils);
+				await this.fileService.writeFile(this.environmentService.settingsSyncPreviewResource, VSBuffer.fromString(content));
+
+				this.syncPreviewResultPromise = createCancelablePromise(() => Promise.resolve<ISyncPreviewResult>({
+					conflicts: [],
+					fileContent,
+					hasLocalChanged: true,
+					hasRemoteChanged: false,
+					remoteUserData
+				}));
+
+				await this.apply();
+			}
+
+			// No remote exists to pull
+			else {
+				this.logService.info('Settings: Remote settings does not exist.');
+			}
+
+			this.logService.info('Settings: Finished pulling settings.');
+		} finally {
+			this.setStatus(SyncStatus.Idle);
+		}
+	}
+
+	async push(): Promise<void> {
+		if (!this.configurationService.getValue<boolean>('sync.enableSettings')) {
+			this.logService.info('Settings: Skipped pushing settings as it is disabled.');
+			return;
+		}
+
+		this.stop();
+
+		try {
+			this.logService.info('Settings: Started pushing settings...');
+			this.setStatus(SyncStatus.Syncing);
+
+			const fileContent = await this.getLocalFileContent();
+
+			if (fileContent !== null) {
+				const formatUtils = await this.getFormattingOptions();
+				// Remove ignored settings
+				const content = updateIgnoredSettings(fileContent.value.toString(), '{}', getIgnoredSettings(this.configurationService), formatUtils);
+				await this.fileService.writeFile(this.environmentService.settingsSyncPreviewResource, VSBuffer.fromString(content));
+
+				this.syncPreviewResultPromise = createCancelablePromise(() => Promise.resolve<ISyncPreviewResult>({
+					conflicts: [],
+					fileContent,
+					hasLocalChanged: false,
+					hasRemoteChanged: true,
+					remoteUserData: null
+				}));
+
+				await this.apply();
+			}
+
+			// No local exists to push
+			else {
+				this.logService.info('Settings: Local settings does not exist.');
+			}
+
+			this.logService.info('Settings: Finished pushing settings.');
+		} finally {
+			this.setStatus(SyncStatus.Idle);
+		}
 	}

 	async sync(_continue?: boolean): Promise<boolean> {
@@ -83,16 +191,77 @@ export class SettingsSynchroniser extends Disposable implements ISynchroniser {

 		this.logService.trace('Settings: Started synchronizing settings...');
 		this.setStatus(SyncStatus.Syncing);
+		return this.doSync([]);
+	}

+	stop(): void {
+		if (this.syncPreviewResultPromise) {
+			this.syncPreviewResultPromise.cancel();
+			this.syncPreviewResultPromise = null;
+			this.logService.info('Settings: Stopped synchronizing settings.');
+		}
+		this.fileService.del(this.environmentService.settingsSyncPreviewResource);
+		this.setStatus(SyncStatus.Idle);
+	}
+
+	async hasPreviouslySynced(): Promise<boolean> {
+		const lastSyncData = await this.getLastSyncUserData();
+		return !!lastSyncData;
+	}
+
+	async hasRemoteData(): Promise<boolean> {
+		const remoteUserData = await this.getRemoteUserData();
+		return remoteUserData.content !== null;
+	}
+
+	async hasLocalData(): Promise<boolean> {
 		try {
-			const result = await this.getPreview();
-			if (result.hasConflicts) {
+			const localFileContent = await this.getLocalFileContent();
+			if (localFileContent) {
+				const formatUtils = await this.getFormattingOptions();
+				const content = edit(localFileContent.value.toString(), [CONFIGURATION_SYNC_STORE_KEY], undefined, formatUtils);
+				const settings = parse(content);
+				if (!isEmptyObject(settings)) {
+					return true;
+				}
+			}
+		} catch (error) {
+			if ((<FileOperationError>error).fileOperationResult !== FileOperationResult.FILE_NOT_FOUND) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	async resolveConflicts(resolvedConflicts: { key: string, value: any | undefined }[]): Promise<void> {
+		if (this.status === SyncStatus.HasConflicts) {
+			this.syncPreviewResultPromise!.cancel();
+			this.syncPreviewResultPromise = null;
+			await this.doSync(resolvedConflicts);
+		}
+	}
+
+	async resetLocal(): Promise<void> {
+		try {
+			await this.fileService.del(this.lastSyncSettingsResource);
+		} catch (e) { /* ignore */ }
+	}
+
+	private async doSync(resolvedConflicts: { key: string, value: any | undefined }[]): Promise<boolean> {
+		try {
+			const result = await this.getPreview(resolvedConflicts);
+			if (result.conflicts.length) {
 				this.logService.info('Settings: Detected conflicts while synchronizing settings.');
 				this.setStatus(SyncStatus.HasConflicts);
 				return false;
 			}
-			await this.apply();
-			return true;
+			try {
+				await this.apply();
+				this.logService.trace('Settings: Finished synchronizing settings.');
+				return true;
+			} finally {
+				this.setStatus(SyncStatus.Idle);
+			}
 		} catch (e) {
 			this.syncPreviewResultPromise = null;
 			this.setStatus(SyncStatus.Idle);
@@ -110,19 +279,10 @@ export class SettingsSynchroniser extends Disposable implements ISynchroniser {
 		}
 	}

-	stop(): void {
-		if (this.syncPreviewResultPromise) {
-			this.syncPreviewResultPromise.cancel();
-			this.syncPreviewResultPromise = null;
-			this.logService.info('Settings: Stopped synchronizing settings.');
-		}
-		this.fileService.del(this.environmentService.settingsSyncPreviewResource);
-		this.setStatus(SyncStatus.Idle);
-	}
-
 	private async continueSync(): Promise<boolean> {
 		if (this.status === SyncStatus.HasConflicts) {
 			await this.apply();
+			this.setStatus(SyncStatus.Idle);
 		}
 		return true;
 	}
@@ -151,12 +311,12 @@ export class SettingsSynchroniser extends Disposable implements ISynchroniser {
 			}
 			if (hasRemoteChanged) {
 				const formatUtils = await this.getFormattingOptions();
-				const remoteContent = remoteUserData.content ? computeRemoteContent(content, remoteUserData.content, this.getIgnoredSettings(content), formatUtils) : content;
+				const remoteContent = remoteUserData?.content ? updateIgnoredSettings(content, remoteUserData.content, getIgnoredSettings(this.configurationService, content), formatUtils) : content;
 				this.logService.info('Settings: Updating remote settings');
-				const ref = await this.writeToRemote(remoteContent, remoteUserData.ref);
+				const ref = await this.writeToRemote(remoteContent, remoteUserData ? remoteUserData.ref : null);
 				remoteUserData = { ref, content };
 			}
-			if (remoteUserData.content) {
+			if (remoteUserData?.content) {
 				this.logService.info('Settings: Updating last synchronised sttings');
 				await this.updateLastSyncValue(remoteUserData);
 			}
@@ -167,9 +327,7 @@ export class SettingsSynchroniser extends Disposable implements ISynchroniser {
 			this.logService.trace('Settings: No changes found during synchronizing settings.');
 		}

-		this.logService.trace('Settings: Finised synchronizing settings.');
 		this.syncPreviewResultPromise = null;
-		this.setStatus(SyncStatus.Idle);
 	}

 	private hasErrors(content: string): boolean {
@@ -178,43 +336,44 @@ export class SettingsSynchroniser extends Disposable implements ISynchroniser {
 		return parseErrors.length > 0;
 	}

-	private getPreview(): Promise<ISyncPreviewResult> {
+	private getPreview(resolvedConflicts: { key: string, value: any }[]): Promise<ISyncPreviewResult> {
 		if (!this.syncPreviewResultPromise) {
-			this.syncPreviewResultPromise = createCancelablePromise(token => this.generatePreview(token));
+			this.syncPreviewResultPromise = createCancelablePromise(token => this.generatePreview(resolvedConflicts, token));
 		}
 		return this.syncPreviewResultPromise;
 	}

-	private async generatePreview(token: CancellationToken): Promise<ISyncPreviewResult> {
+	private async generatePreview(resolvedConflicts: { key: string, value: any }[], token: CancellationToken): Promise<ISyncPreviewResult> {
 		const lastSyncData = await this.getLastSyncUserData();
-		const remoteUserData = await this.userDataSyncStoreService.read(SettingsSynchroniser.EXTERNAL_USER_DATA_SETTINGS_KEY, lastSyncData);
+		const remoteUserData = await this.getRemoteUserData(lastSyncData);
 		const remoteContent: string | null = remoteUserData.content;
 		// Get file content last to get the latest
 		const fileContent = await this.getLocalFileContent();
 		let hasLocalChanged: boolean = false;
 		let hasRemoteChanged: boolean = false;
-		let hasConflicts: boolean = false;
+		let conflicts: IConflictSetting[] = [];
 		let previewContent = null;

 		if (remoteContent) {
 			const localContent: string = fileContent ? fileContent.value.toString() : '{}';
+
+			// No action when there are errors
 			if (this.hasErrors(localContent)) {
 				this.logService.error('Settings: Unable to sync settings as there are errors/warning in settings file.');
-				return { fileContent, remoteUserData, hasLocalChanged, hasRemoteChanged, hasConflicts };
 			}

-			if (!lastSyncData // First time sync
+			else if (!lastSyncData // First time sync
 				|| lastSyncData.content !== localContent // Local has forwarded
 				|| lastSyncData.content !== remoteContent // Remote has forwarded
 			) {
 				this.logService.trace('Settings: Merging remote settings with local settings...');
 				const formatUtils = await this.getFormattingOptions();
-				const result = merge(localContent, remoteContent, lastSyncData ? lastSyncData.content : null, this.getIgnoredSettings(), formatUtils);
+				const result = merge(localContent, remoteContent, lastSyncData ? lastSyncData.content : null, getIgnoredSettings(this.configurationService), resolvedConflicts, formatUtils);
 				// Sync only if there are changes
 				if (result.hasChanges) {
 					hasLocalChanged = result.mergeContent !== localContent;
 					hasRemoteChanged = result.mergeContent !== remoteContent;
-					hasConflicts = result.hasConflicts;
+					conflicts = result.conflicts;
 					previewContent = result.mergeContent;
 				}
 			}
@@ -231,7 +390,8 @@ export class SettingsSynchroniser extends Disposable implements ISynchroniser {
 			await this.fileService.writeFile(this.environmentService.settingsSyncPreviewResource, VSBuffer.fromString(previewContent));
 		}

-		return { fileContent, remoteUserData, hasLocalChanged, hasRemoteChanged, hasConflicts };
+		this.setConflicts(conflicts);
+		return { fileContent, remoteUserData, hasLocalChanged, hasRemoteChanged, conflicts };
 	}

 	private _formattingOptions: Promise<FormattingOptions> | undefined = undefined;
@@ -242,29 +402,6 @@ export class SettingsSynchroniser extends Disposable implements ISynchroniser {
 		return this._formattingOptions;
 	}

-	private getIgnoredSettings(settingsContent?: string): string[] {
-		let value: string[] = [];
-		if (settingsContent) {
-			const setting = parse(settingsContent);
-			if (setting) {
-				value = setting['sync.ignoredSettings'];
-			}
-		} else {
-			value = this.configurationService.getValue<string[]>('sync.ignoredSettings');
-		}
-		const added: string[] = [], removed: string[] = [];
-		if (Array.isArray(value)) {
-			for (const key of value) {
-				if (startsWith(key, '-')) {
-					removed.push(key.substring(1));
-				} else {
-					added.push(key);
-				}
-			}
-		}
-		return [...DEFAULT_IGNORED_SETTINGS, ...added].filter(setting => removed.indexOf(setting) === -1);
-	}
-
 	private async getLastSyncUserData(): Promise<IUserData | null> {
 		try {
 			const content = await this.fileService.readFile(this.lastSyncSettingsResource);
@@ -282,6 +419,10 @@ export class SettingsSynchroniser extends Disposable implements ISynchroniser {
 		}
 	}

+	private getRemoteUserData(lastSyncData?: IUserData | null): Promise<IUserData> {
+		return this.userDataSyncStoreService.read(SettingsSynchroniser.EXTERNAL_USER_DATA_SETTINGS_KEY, lastSyncData || null);
+	}
+
 	private async writeToRemote(content: string, ref: string | null): Promise<string> {
 		return this.userDataSyncStoreService.write(SettingsSynchroniser.EXTERNAL_USER_DATA_SETTINGS_KEY, content, ref);
 	}
@@ -289,6 +430,7 @@ export class SettingsSynchroniser extends Disposable implements ISynchroniser {
 	private async writeToLocal(newContent: string, oldContent: IFileContent | null): Promise<void> {
 		if (oldContent) {
 			// file exists already
+			await this.backupLocal(oldContent.value);
 			await this.fileService.writeFile(this.environmentService.settingsResource, VSBuffer.fromString(newContent), oldContent);
 		} else {
 			// file does not exist
@@ -301,3 +443,26 @@ export class SettingsSynchroniser extends Disposable implements ISynchroniser {
 	}

 }
+
+export function getIgnoredSettings(configurationService: IConfigurationService, settingsContent?: string): string[] {
+	let value: string[] = [];
+	if (settingsContent) {
+		const setting = parse(settingsContent);
+		if (setting) {
+			value = setting['sync.ignoredSettings'];
+		}
+	} else {
+		value = configurationService.getValue<string[]>('sync.ignoredSettings');
+	}
+	const added: string[] = [], removed: string[] = [];
+	if (Array.isArray(value)) {
+		for (const key of value) {
+			if (startsWith(key, '-')) {
+				removed.push(key.substring(1));
+			} else {
+				added.push(key);
+			}
+		}
+	}
+	return [...DEFAULT_IGNORED_SETTINGS, ...added].filter(setting => removed.indexOf(setting) === -1);
+}