file service - add event for listening to capability changes

src/vs/platform/files/common/fileService.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { Disposable, IDisposable, toDisposable, dispose, DisposableStore } from 'vs/base/common/lifecycle';
-import { IFileService, IResolveFileOptions, FileChangesEvent, FileOperationEvent, IFileSystemProviderRegistrationEvent, IFileSystemProvider, IFileStat, IResolveFileResult, ICreateFileOptions, IFileSystemProviderActivationEvent, FileOperationError, FileOperationResult, FileOperation, FileSystemProviderCapabilities, FileType, toFileSystemProviderErrorCode, FileSystemProviderErrorCode, IStat, IFileStatWithMetadata, IResolveMetadataFileOptions, etag, hasReadWriteCapability, hasFileFolderCopyCapability, hasOpenReadWriteCloseCapability, toFileOperationResult, IFileSystemProviderWithOpenReadWriteCloseCapability, IFileSystemProviderWithFileReadWriteCapability, IResolveFileResultWithMetadata, IWatchOptions, IWriteFileOptions, IReadFileOptions, IFileStreamContent, IFileContent, ETAG_DISABLED, hasFileReadStreamCapability, IFileSystemProviderWithFileReadStreamCapability, ensureFileSystemProviderError } from 'vs/platform/files/common/files';
+import { IFileService, IResolveFileOptions, FileChangesEvent, FileOperationEvent, IFileSystemProviderRegistrationEvent, IFileSystemProvider, IFileStat, IResolveFileResult, ICreateFileOptions, IFileSystemProviderActivationEvent, FileOperationError, FileOperationResult, FileOperation, FileSystemProviderCapabilities, FileType, toFileSystemProviderErrorCode, FileSystemProviderErrorCode, IStat, IFileStatWithMetadata, IResolveMetadataFileOptions, etag, hasReadWriteCapability, hasFileFolderCopyCapability, hasOpenReadWriteCloseCapability, toFileOperationResult, IFileSystemProviderWithOpenReadWriteCloseCapability, IFileSystemProviderWithFileReadWriteCapability, IResolveFileResultWithMetadata, IWatchOptions, IWriteFileOptions, IReadFileOptions, IFileStreamContent, IFileContent, ETAG_DISABLED, hasFileReadStreamCapability, IFileSystemProviderWithFileReadStreamCapability, ensureFileSystemProviderError, IFileSystemProviderCapabilitiesChangeEvent } from 'vs/platform/files/common/files';
 import { URI } from 'vs/base/common/uri';
 import { Event, Emitter } from 'vs/base/common/event';
 import { isAbsolutePath, dirname, basename, joinPath, isEqual, isEqualOrParent } from 'vs/base/common/resources';
@@ -33,11 +33,14 @@ export class FileService extends Disposable implements IFileService {
 
 	//#region File System Provider
 
-	private _onDidChangeFileSystemProviderRegistrations: Emitter<IFileSystemProviderRegistrationEvent> = this._register(new Emitter<IFileSystemProviderRegistrationEvent>());
-	readonly onDidChangeFileSystemProviderRegistrations: Event<IFileSystemProviderRegistrationEvent> = this._onDidChangeFileSystemProviderRegistrations.event;
+	private _onDidChangeFileSystemProviderRegistrations = this._register(new Emitter<IFileSystemProviderRegistrationEvent>());
+	readonly onDidChangeFileSystemProviderRegistrations = this._onDidChangeFileSystemProviderRegistrations.event;
 
-	private _onWillActivateFileSystemProvider: Emitter<IFileSystemProviderActivationEvent> = this._register(new Emitter<IFileSystemProviderActivationEvent>());
-	readonly onWillActivateFileSystemProvider: Event<IFileSystemProviderActivationEvent> = this._onWillActivateFileSystemProvider.event;
+	private _onWillActivateFileSystemProvider = this._register(new Emitter<IFileSystemProviderActivationEvent>());
+	readonly onWillActivateFileSystemProvider = this._onWillActivateFileSystemProvider.event;
+
+	private _onDidChangeFileSystemProviderCapabilities = this._register(new Emitter<IFileSystemProviderCapabilitiesChangeEvent>());
+	readonly onDidChangeFileSystemProviderCapabilities = this._onDidChangeFileSystemProviderCapabilities.event;
 
 	private readonly provider = new Map<string, IFileSystemProvider>();
 
@@ -53,6 +56,7 @@ export class FileService extends Disposable implements IFileService {
 		// Forward events from provider
 		const providerDisposables = new DisposableStore();
 		providerDisposables.add(provider.onDidChangeFile(changes => this._onFileChanges.fire(new FileChangesEvent(changes))));
+		providerDisposables.add(provider.onDidChangeCapabilities(() => this._onDidChangeFileSystemProviderCapabilities.fire({ provider })));
 		if (typeof provider.onDidErrorOccur === 'function') {
 			providerDisposables.add(provider.onDidErrorOccur(error => this._onError.fire(new Error(error))));
 		}

src/vs/platform/files/common/files.ts

@@ -28,6 +28,11 @@ export interface IFileService {
 	 */
 	readonly onDidChangeFileSystemProviderRegistrations: Event<IFileSystemProviderRegistrationEvent>;
 
+	/**
+	 * An even that is fired when a registered file system provider changes it's capabilities.
+	 */
+	readonly onDidChangeFileSystemProviderCapabilities: Event<IFileSystemProviderCapabilitiesChangeEvent>;
+
 	/**
 	 * An event that is fired when a file system provider is about to be activated. Listeners
 	 * can join this event with a long running promise to help in the activation process.
@@ -409,6 +414,10 @@ export interface IFileSystemProviderRegistrationEvent {
 	provider?: IFileSystemProvider;
 }
 
+export interface IFileSystemProviderCapabilitiesChangeEvent {
+	provider: IFileSystemProvider;
+}
+
 export interface IFileSystemProviderActivationEvent {
 	scheme: string;
 	join(promise: Promise<void>): void;

src/vs/platform/files/test/browser/fileService.test.ts

@@ -6,7 +6,7 @@
 import * as assert from 'assert';
 import { FileService } from 'vs/platform/files/common/fileService';
 import { URI } from 'vs/base/common/uri';
-import { IFileSystemProviderRegistrationEvent, FileSystemProviderCapabilities } from 'vs/platform/files/common/files';
+import { IFileSystemProviderRegistrationEvent, FileSystemProviderCapabilities, IFileSystemProviderCapabilitiesChangeEvent } from 'vs/platform/files/common/files';
 import { IDisposable, toDisposable } from 'vs/base/common/lifecycle';
 import { NullLogService } from 'vs/platform/log/common/log';
 import { timeout } from 'vs/base/common/async';
@@ -17,6 +17,7 @@ suite('File Service', () => {
 	test('provider registration', async () => {
 		const service = new FileService(new NullLogService());
 		const resource = URI.parse('test://foo/bar');
+		const provider = new NullFileSystemProvider();
 
 		assert.equal(service.canHandleResource(resource), false);
 
@@ -25,6 +26,11 @@ suite('File Service', () => {
 			registrations.push(e);
 		});
 
+		const capabilityChanges: IFileSystemProviderCapabilitiesChangeEvent[] = [];
+		service.onDidChangeFileSystemProviderCapabilities(e => {
+			capabilityChanges.push(e);
+		});
+
 		let registrationDisposable: IDisposable | undefined = undefined;
 		let callCount = 0;
 		service.onWillActivateFileSystemProvider(e => {
@@ -32,7 +38,7 @@ suite('File Service', () => {
 
 			if (e.scheme === 'test' && callCount === 1) {
 				e.join(new Promise(resolve => {
-					registrationDisposable = service.registerProvider('test', new NullFileSystemProvider());
+					registrationDisposable = service.registerProvider('test', provider);
 
 					resolve();
 				}));
@@ -48,6 +54,13 @@ suite('File Service', () => {
 		assert.equal(registrations[0].added, true);
 		assert.ok(registrationDisposable);
 
+		assert.equal(capabilityChanges.length, 0);
+
+		provider.setCapabilities(FileSystemProviderCapabilities.FileFolderCopy);
+		assert.equal(capabilityChanges.length, 1);
+		provider.setCapabilities(FileSystemProviderCapabilities.Readonly);
+		assert.equal(capabilityChanges.length, 2);
+
 		await service.activateProvider('test');
 		assert.equal(callCount, 2); // activation is called again
 
@@ -109,4 +122,4 @@ suite('File Service', () => {
 		watcher3Disposable2.dispose();
 		assert.equal(disposeCounter, 2);
 	});
-});
\ No newline at end of file
+});

src/vs/platform/files/test/common/nullFileSystemProvider.ts

@@ -6,14 +6,22 @@
 import { URI } from 'vs/base/common/uri';
 import { FileSystemProviderCapabilities, IFileSystemProvider, IWatchOptions, IStat, FileType, FileDeleteOptions, FileOverwriteOptions, FileWriteOptions, FileOpenOptions, IFileChange } from 'vs/platform/files/common/files';
 import { IDisposable, Disposable } from 'vs/base/common/lifecycle';
-import { Event } from 'vs/base/common/event';
+import { Emitter, Event } from 'vs/base/common/event';
 
 export class NullFileSystemProvider implements IFileSystemProvider {
 
 	capabilities: FileSystemProviderCapabilities = FileSystemProviderCapabilities.Readonly;
 
-	onDidChangeCapabilities: Event<void> = Event.None;
-	onDidChangeFile: Event<readonly IFileChange[]> = Event.None;
+	private readonly _onDidChangeCapabilities = new Emitter<void>();
+	readonly onDidChangeCapabilities: Event<void> = this._onDidChangeCapabilities.event;
+
+	setCapabilities(capabilities: FileSystemProviderCapabilities): void {
+		this.capabilities = capabilities;
+
+		this._onDidChangeCapabilities.fire();
+	}
+
+	readonly onDidChangeFile: Event<readonly IFileChange[]> = Event.None;
 
 	constructor(private disposableFactory: () => IDisposable = () => Disposable.None) { }
 

src/vs/workbench/test/workbenchTestServices.ts

@@ -966,6 +966,7 @@ export class TestFileService implements IFileService {
 	private readonly _onAfterOperation: Emitter<FileOperationEvent>;
 
 	readonly onWillActivateFileSystemProvider = Event.None;
+	readonly onDidChangeFileSystemProviderCapabilities = Event.None;
 	readonly onError: Event<Error> = Event.None;
 
 	private content = 'Hello Html';