debt - use file service based configuration file service

src/vs/workbench/electron-browser/main.ts

@@ -47,10 +47,10 @@ import { IChannel } from 'vs/base/parts/ipc/common/ipc';
 import { REMOTE_FILE_SYSTEM_CHANNEL_NAME, RemoteExtensionsFileSystemProvider } from 'vs/platform/remote/common/remoteAgentFileSystemChannel';
 import { DefaultConfigurationExportHelper } from 'vs/workbench/services/configuration/node/configurationExportHelper';
 import { ConfigurationCache } from 'vs/workbench/services/configuration/node/configurationCache';
-import { ConfigurationFileService } from 'vs/workbench/services/configuration/node/configurationFileService';
 import { SpdLogService } from 'vs/platform/log/node/spdlogService';
 import { SignService } from 'vs/platform/sign/node/signService';
 import { ISignService } from 'vs/platform/sign/common/sign';
+import { ConfigurationFileService } from '../services/configuration/common/configuration';
 
 class CodeRendererMain extends Disposable {
 
@@ -306,8 +306,7 @@ class CodeRendererMain extends Disposable {
 	}
 
 	private async createWorkspaceService(payload: IWorkspaceInitializationPayload, environmentService: IWorkbenchEnvironmentService, fileService: FileService, remoteAgentService: IRemoteAgentService, logService: ILogService): Promise<WorkspaceService> {
-		const configurationFileService = new ConfigurationFileService();
-		configurationFileService.fileService = fileService;
+		const configurationFileService = new ConfigurationFileService(fileService);
 
 		const workspaceService = new WorkspaceService({ userSettingsResource: environmentService.settingsResource, remoteAuthority: this.configuration.remoteAuthority, configurationCache: new ConfigurationCache(environmentService) }, configurationFileService, remoteAgentService);
 

src/vs/workbench/services/configuration/browser/configuration.ts

@@ -20,7 +20,7 @@ import { ConfigurationScope } from 'vs/platform/configuration/common/configurati
 import { extname, join } from 'vs/base/common/path';
 import { equals } from 'vs/base/common/objects';
 import { Schemas } from 'vs/base/common/network';
-import { IConfigurationModel, compare } from 'vs/platform/configuration/common/configuration';
+import { IConfigurationModel } from 'vs/platform/configuration/common/configuration';
 import { IRemoteAgentService } from 'vs/workbench/services/remote/common/remoteAgentService';
 import { hash } from 'vs/base/common/hash';
 
@@ -138,11 +138,7 @@ export class UserConfiguration extends Disposable {
 	async initialize(): Promise<ConfigurationModel> {
 		const exists = await this.configurationFileService.exists(this.configurationResource);
 		this.onResourceExists(exists);
-		const configuraitonModel = await this.reload();
-		if (!this.configurationFileService.isWatching) {
-			this.configurationFileService.whenWatchingStarted.then(() => this.onWatchStarted(configuraitonModel));
-		}
-		return configuraitonModel;
+		return this.reload();
 	}
 
 	async reload(): Promise<ConfigurationModel> {
@@ -160,14 +156,6 @@ export class UserConfiguration extends Disposable {
 		return this.parser.configurationModel;
 	}
 
-	private async onWatchStarted(currentModel: ConfigurationModel): Promise<void> {
-		const configuraitonModel = await this.reload();
-		const { added, removed, updated } = compare(currentModel, configuraitonModel);
-		if (added.length || removed.length || updated.length) {
-			this._onDidChangeConfiguration.fire(configuraitonModel);
-		}
-	}
-
 	private async handleFileEvents(event: FileChangesEvent): Promise<void> {
 		const events = event.changes;
 
@@ -378,10 +366,6 @@ class FileServiceBasedWorkspaceConfiguration extends Disposable implements IWork
 		this._register(configurationFileService.onFileChanges(e => this.handleWorkspaceFileEvents(e)));
 		this.reloadConfigurationScheduler = this._register(new RunOnceScheduler(() => this._onDidChange.fire(), 50));
 		this.workspaceConfigWatcher = this._register(this.watchWorkspaceConfigurationFile());
-
-		if (!this.configurationFileService.isWatching) {
-			this.configurationFileService.whenWatchingStarted.then(() => this.onWatchStarted());
-		}
 	}
 
 	get workspaceIdentifier(): IWorkspaceIdentifier | null {
@@ -426,18 +410,6 @@ class FileServiceBasedWorkspaceConfiguration extends Disposable implements IWork
 		return this.getWorkspaceSettings();
 	}
 
-	private async onWatchStarted(): Promise<void> {
-		if (this.workspaceIdentifier) {
-			const currentModel = this.getConfigurationModel();
-			await this.load(this.workspaceIdentifier);
-			const newModel = this.getConfigurationModel();
-			const { added, removed, updated } = compare(currentModel, newModel);
-			if (added.length || removed.length || updated.length) {
-				this._onDidChange.fire();
-			}
-		}
-	}
-
 	private consolidate(): void {
 		this.workspaceSettings = this.workspaceConfigurationModelParser.settingsModel.merge(this.workspaceConfigurationModelParser.launchModel);
 	}
@@ -557,9 +529,6 @@ class FileServiceBasedFolderConfiguration extends Disposable implements IFolderC
 
 		this.changeEventTriggerScheduler = this._register(new RunOnceScheduler(() => this._onDidChange.fire(), 50));
 		this._register(configurationFileService.onFileChanges(e => this.handleWorkspaceFileEvents(e)));
-		if (!this.configurationFileService.isWatching) {
-			this.configurationFileService.whenWatchingStarted.then(() => this.onWatchStarted());
-		}
 	}
 
 	async loadConfiguration(): Promise<ConfigurationModel> {
@@ -611,15 +580,6 @@ class FileServiceBasedFolderConfiguration extends Disposable implements IFolderC
 		this._cache = this._folderSettingsModelParser.configurationModel.merge(...this._standAloneConfigurations);
 	}
 
-	private async onWatchStarted(): Promise<void> {
-		const currentModel = this._cache;
-		const newModel = await this.loadConfiguration();
-		const { added, removed, updated } = compare(currentModel, newModel);
-		if (added.length || removed.length || updated.length) {
-			this._onDidChange.fire();
-		}
-	}
-
 	private handleWorkspaceFileEvents(event: FileChangesEvent): void {
 		const events = event.changes;
 		let affectedByChanges = false;

src/vs/workbench/services/configuration/common/configuration.ts

@@ -43,10 +43,7 @@ export interface IConfigurationCache {
 }
 
 export interface IConfigurationFileService {
-	fileService: IFileService | null;
 	readonly onFileChanges: Event<FileChangesEvent>;
-	readonly isWatching: boolean;
-	readonly whenWatchingStarted: Promise<void>;
 	whenProviderRegistered(scheme: string): Promise<void>;
 	watch(resource: URI): IDisposable;
 	exists(resource: URI): Promise<boolean>;
@@ -55,11 +52,9 @@ export interface IConfigurationFileService {
 
 export class ConfigurationFileService implements IConfigurationFileService {
 
-	constructor(public fileService: IFileService) { }
+	constructor(private readonly fileService: IFileService) { }
 
 	get onFileChanges() { return this.fileService.onFileChanges; }
-	readonly whenWatchingStarted: Promise<void> = Promise.resolve();
-	readonly isWatching: boolean = true;
 
 	whenProviderRegistered(scheme: string): Promise<void> {
 		if (this.fileService.canHandleResource(URI.from({ scheme }))) {

src/vs/workbench/services/configuration/node/configurationFileService.ts

-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import * as pfs from 'vs/base/node/pfs';
-import { IConfigurationFileService, ConfigurationFileService as FileServiceBasedConfigurationFileService } from 'vs/workbench/services/configuration/common/configuration';
-import { URI } from 'vs/base/common/uri';
-import { Event, Emitter } from 'vs/base/common/event';
-import { FileChangesEvent, IFileService } from 'vs/platform/files/common/files';
-import { Disposable, IDisposable, toDisposable } from 'vs/base/common/lifecycle';
-import { Schemas } from 'vs/base/common/network';
-
-export class ConfigurationFileService extends Disposable implements IConfigurationFileService {
-
-	private _fileServiceBasedConfigurationFileService: FileServiceBasedConfigurationFileService | null = null;
-	private _fileServiceBasedConfigurationFileServiceCallback: (fileServiceBasedConfigurationFileService: FileServiceBasedConfigurationFileService) => void;
-	private _whenFileServiceBasedConfigurationFileServiceAvailable: Promise<FileServiceBasedConfigurationFileService> = new Promise((c) => this._fileServiceBasedConfigurationFileServiceCallback = c);
-	private _watchResources: { resource: URI, disposable: { disposable: IDisposable | null } }[] = [];
-	readonly whenWatchingStarted: Promise<void> = this._whenFileServiceBasedConfigurationFileServiceAvailable.then(() => undefined);
-
-	private readonly _onFileChanges: Emitter<FileChangesEvent> = this._register(new Emitter<FileChangesEvent>());
-	readonly onFileChanges: Event<FileChangesEvent> = this._onFileChanges.event;
-
-	get isWatching(): boolean {
-		return this._fileServiceBasedConfigurationFileService ? this._fileServiceBasedConfigurationFileService.isWatching : false;
-	}
-
-	watch(resource: URI): IDisposable {
-		if (this._fileServiceBasedConfigurationFileService) {
-			return this._fileServiceBasedConfigurationFileService.watch(resource);
-		}
-		const disposable: { disposable: IDisposable | null } = { disposable: null };
-		this._watchResources.push({ resource, disposable });
-		return toDisposable(() => {
-			if (disposable.disposable) {
-				disposable.disposable.dispose();
-			}
-		});
-	}
-
-	whenProviderRegistered(scheme: string): Promise<void> {
-		if (scheme === Schemas.file) {
-			return Promise.resolve();
-		}
-		return this._whenFileServiceBasedConfigurationFileServiceAvailable
-			.then(fileServiceBasedConfigurationFileService => fileServiceBasedConfigurationFileService.whenProviderRegistered(scheme));
-	}
-
-	exists(resource: URI): Promise<boolean> {
-		return this._fileServiceBasedConfigurationFileService ? this._fileServiceBasedConfigurationFileService.exists(resource) : pfs.exists(resource.fsPath);
-	}
-
-	async readFile(resource: URI): Promise<string> {
-		if (this._fileServiceBasedConfigurationFileService) {
-			return this._fileServiceBasedConfigurationFileService.readFile(resource);
-		} else {
-			const contents = await pfs.readFile(resource.fsPath);
-			return contents.toString();
-		}
-	}
-
-	private _fileService: IFileService | null;
-	get fileService(): IFileService | null {
-		return this._fileService;
-	}
-
-	set fileService(fileService: IFileService | null) {
-		if (fileService && !this._fileServiceBasedConfigurationFileService) {
-			this._fileServiceBasedConfigurationFileService = new FileServiceBasedConfigurationFileService(fileService);
-			this._fileService = fileService;
-			this._register(this._fileServiceBasedConfigurationFileService.onFileChanges(e => this._onFileChanges.fire(e)));
-			for (const { resource, disposable } of this._watchResources) {
-				disposable.disposable = this._fileServiceBasedConfigurationFileService.watch(resource);
-			}
-			this._fileServiceBasedConfigurationFileServiceCallback(this._fileServiceBasedConfigurationFileService);
-		}
-	}
-}

src/vs/workbench/services/configuration/test/electron-browser/configurationEditingService.test.ts

@@ -19,7 +19,7 @@ import * as uuid from 'vs/base/common/uuid';
 import { IConfigurationRegistry, Extensions as ConfigurationExtensions } from 'vs/platform/configuration/common/configurationRegistry';
 import { WorkspaceService } from 'vs/workbench/services/configuration/browser/configurationService';
 import { ConfigurationEditingService, ConfigurationEditingError, ConfigurationEditingErrorCode, EditableConfigurationTarget } from 'vs/workbench/services/configuration/common/configurationEditingService';
-import { WORKSPACE_STANDALONE_CONFIGURATIONS } from 'vs/workbench/services/configuration/common/configuration';
+import { WORKSPACE_STANDALONE_CONFIGURATIONS, ConfigurationFileService } from 'vs/workbench/services/configuration/common/configuration';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { TestInstantiationService } from 'vs/platform/instantiation/test/common/instantiationServiceMock';
 import { ITextFileService } from 'vs/workbench/services/textfile/common/textfiles';
@@ -39,7 +39,6 @@ import { Schemas } from 'vs/base/common/network';
 import { DiskFileSystemProvider } from 'vs/workbench/services/files/node/diskFileSystemProvider';
 import { IFileService } from 'vs/platform/files/common/files';
 import { ConfigurationCache } from 'vs/workbench/services/configuration/node/configurationCache';
-import { ConfigurationFileService } from 'vs/workbench/services/configuration/node/configurationFileService';
 
 class SettingsTestEnvironmentService extends EnvironmentService {
 
@@ -104,14 +103,14 @@ suite('ConfigurationEditingService', () => {
 		const environmentService = new SettingsTestEnvironmentService(parseArgs(process.argv), process.execPath, globalSettingsFile);
 		instantiationService.stub(IEnvironmentService, environmentService);
 		const remoteAgentService = instantiationService.createInstance(RemoteAgentService, {});
+		const fileService = new FileService(new NullLogService());
+		fileService.registerProvider(Schemas.file, new DiskFileSystemProvider(new NullLogService()));
+		instantiationService.stub(IFileService, fileService);
 		instantiationService.stub(IRemoteAgentService, remoteAgentService);
-		const workspaceService = new WorkspaceService({ userSettingsResource: environmentService.settingsResource, configurationCache: new ConfigurationCache(environmentService) }, new ConfigurationFileService(), remoteAgentService);
+		const workspaceService = new WorkspaceService({ userSettingsResource: environmentService.settingsResource, configurationCache: new ConfigurationCache(environmentService) }, new ConfigurationFileService(fileService), remoteAgentService);
 		instantiationService.stub(IWorkspaceContextService, workspaceService);
 		return workspaceService.initialize(noWorkspace ? { id: '' } : { folder: URI.file(workspaceDir), id: createHash('md5').update(URI.file(workspaceDir).toString()).digest('hex') }).then(() => {
 			instantiationService.stub(IConfigurationService, workspaceService);
-			const fileService = new FileService(new NullLogService());
-			fileService.registerProvider(Schemas.file, new DiskFileSystemProvider(new NullLogService()));
-			instantiationService.stub(IFileService, fileService);
 			instantiationService.stub(ITextFileService, instantiationService.createInstance(TestTextFileService));
 			instantiationService.stub(ITextModelService, <ITextModelService>instantiationService.createInstance(TextModelResolverService));
 			instantiationService.stub(ICommandService, CommandService);

src/vs/workbench/services/configuration/test/electron-browser/configurationService.test.ts

@@ -41,9 +41,8 @@ import { FileService } from 'vs/workbench/services/files/common/fileService';
 import { NullLogService } from 'vs/platform/log/common/log';
 import { DiskFileSystemProvider } from 'vs/workbench/services/files/node/diskFileSystemProvider';
 import { ConfigurationCache } from 'vs/workbench/services/configuration/node/configurationCache';
-import { ConfigurationFileService } from 'vs/workbench/services/configuration/node/configurationFileService';
 import { IRemoteAgentEnvironment } from 'vs/platform/remote/common/remoteAgentEnvironment';
-import { IConfigurationCache } from 'vs/workbench/services/configuration/common/configuration';
+import { IConfigurationCache, ConfigurationFileService } from 'vs/workbench/services/configuration/common/configuration';
 import { VSBuffer } from 'vs/base/common/buffer';
 import { SignService } from 'vs/platform/sign/browser/signService';
 
@@ -104,7 +103,7 @@ suite('WorkspaceContextService - Folder', () => {
 				workspaceResource = folderDir;
 				const globalSettingsFile = path.join(parentDir, 'settings.json');
 				const environmentService = new SettingsTestEnvironmentService(parseArgs(process.argv), process.execPath, globalSettingsFile);
-				workspaceContextService = new WorkspaceService({ userSettingsResource: environmentService.settingsResource, configurationCache: new ConfigurationCache(environmentService) }, new ConfigurationFileService(), new RemoteAgentService(<IWindowConfiguration>{}, environmentService, new RemoteAuthorityResolverService(), new SignService()));
+				workspaceContextService = new WorkspaceService({ userSettingsResource: environmentService.settingsResource, configurationCache: new ConfigurationCache(environmentService) }, new ConfigurationFileService(new FileService(new NullLogService())), new RemoteAgentService(<IWindowConfiguration>{}, environmentService, new RemoteAuthorityResolverService(), new SignService()));
 				return (<WorkspaceService>workspaceContextService).initialize(convertToWorkspacePayload(URI.file(folderDir)));
 			});
 	});
@@ -166,7 +165,7 @@ suite('WorkspaceContextService - Workspace', () => {
 				const environmentService = new SettingsTestEnvironmentService(parseArgs(process.argv), process.execPath, path.join(parentDir, 'settings.json'));
 				const remoteAgentService = instantiationService.createInstance(RemoteAgentService, {});
 				instantiationService.stub(IRemoteAgentService, remoteAgentService);
-				const workspaceService = new WorkspaceService({ userSettingsResource: environmentService.settingsResource, configurationCache: new ConfigurationCache(environmentService) }, new ConfigurationFileService(), remoteAgentService);
+				const workspaceService = new WorkspaceService({ userSettingsResource: environmentService.settingsResource, configurationCache: new ConfigurationCache(environmentService) }, new ConfigurationFileService(new FileService(new NullLogService())), remoteAgentService);
 
 				instantiationService.stub(IWorkspaceContextService, workspaceService);
 				instantiationService.stub(IConfigurationService, workspaceService);
@@ -224,8 +223,7 @@ suite('WorkspaceContextService - Workspace Editing', () => {
 				instantiationService.stub(IRemoteAgentService, remoteAgentService);
 				const fileService = new FileService(new NullLogService());
 				fileService.registerProvider(Schemas.file, new DiskFileSystemProvider(new NullLogService()));
-				const configurationFileService = new ConfigurationFileService();
-				configurationFileService.fileService = fileService;
+				const configurationFileService = new ConfigurationFileService(fileService);
 				const workspaceService = new WorkspaceService({ userSettingsResource: environmentService.settingsResource, configurationCache: new ConfigurationCache(environmentService) }, configurationFileService, remoteAgentService);
 
 				instantiationService.stub(IWorkspaceContextService, workspaceService);
@@ -485,8 +483,7 @@ suite('WorkspaceService - Initialization', () => {
 				instantiationService.stub(IRemoteAgentService, remoteAgentService);
 				const fileService = new FileService(new NullLogService());
 				fileService.registerProvider(Schemas.file, new DiskFileSystemProvider(new NullLogService()));
-				const configurationFileService = new ConfigurationFileService();
-				configurationFileService.fileService = fileService;
+				const configurationFileService = new ConfigurationFileService(fileService);
 				const workspaceService = new WorkspaceService({ userSettingsResource: environmentService.settingsResource, configurationCache: new ConfigurationCache(environmentService) }, configurationFileService, remoteAgentService);
 				instantiationService.stub(IWorkspaceContextService, workspaceService);
 				instantiationService.stub(IConfigurationService, workspaceService);
@@ -749,8 +746,7 @@ suite('WorkspaceConfigurationService - Folder', () => {
 				instantiationService.stub(IRemoteAgentService, remoteAgentService);
 				const fileService = new FileService(new NullLogService());
 				fileService.registerProvider(Schemas.file, new DiskFileSystemProvider(new NullLogService()));
-				const configurationFileService = new ConfigurationFileService();
-				configurationFileService.fileService = fileService;
+				const configurationFileService = new ConfigurationFileService(fileService);
 				const workspaceService = new WorkspaceService({ userSettingsResource: environmentService.settingsResource, configurationCache: new ConfigurationCache(environmentService) }, configurationFileService, remoteAgentService);
 				instantiationService.stub(IWorkspaceContextService, workspaceService);
 				instantiationService.stub(IConfigurationService, workspaceService);
@@ -1077,8 +1073,7 @@ suite('WorkspaceConfigurationService-Multiroot', () => {
 				instantiationService.stub(IRemoteAgentService, remoteAgentService);
 				const fileService = new FileService(new NullLogService());
 				fileService.registerProvider(Schemas.file, new DiskFileSystemProvider(new NullLogService()));
-				const configurationFileService = new ConfigurationFileService();
-				configurationFileService.fileService = fileService;
+				const configurationFileService = new ConfigurationFileService(fileService);
 				const workspaceService = new WorkspaceService({ userSettingsResource: environmentService.settingsResource, configurationCache: new ConfigurationCache(environmentService) }, configurationFileService, remoteAgentService);
 
 				instantiationService.stub(IWorkspaceContextService, workspaceService);
@@ -1479,8 +1474,7 @@ suite('WorkspaceConfigurationService - Remote Folder', () => {
 				const remoteAgentService = instantiationService.stub(IRemoteAgentService, <Partial<IRemoteAgentService>>{ getEnvironment: () => remoteEnvironmentPromise });
 				const fileService = new FileService(new NullLogService());
 				fileService.registerProvider(Schemas.file, diskFileSystemProvider);
-				const configurationFileService = new ConfigurationFileService();
-				configurationFileService.fileService = fileService;
+				const configurationFileService = new ConfigurationFileService(fileService);
 				const configurationCache: IConfigurationCache = { read: () => Promise.resolve(''), write: () => Promise.resolve(), remove: () => Promise.resolve() };
 				testObject = new WorkspaceService({ userSettingsResource: environmentService.settingsResource, configurationCache, remoteAuthority }, configurationFileService, remoteAgentService);
 				instantiationService.stub(IWorkspaceContextService, testObject);