Microsoft/vscode
1
0
Fork 0
mirror of https://github.com/microsoft/vscode.git synced 2026-04-27 20:13:32 +01:00
Code Issues Packages Projects Releases Wiki Activity

add FileSystemProvider2 for rapid changes, add readFile/writeFile, simplify delete, #47475

Browse Source
This commit is contained in:
Johannes Rieken
2018-04-09 11:35:20 +02:00
parent 317bf2e647
commit 534d10d37d
7 changed files with 159 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
src/vs/workbench/api/electron-browser/mainThreadFileSystem.ts
View File

@@ -11,7 +11,6 @@ import { IFileService, IFileSystemProvider, IStat, IFileChange } from 'vs/platfo
import { IDisposable, dispose } from 'vs/base/common/lifecycle';
import { Event, Emitter } from 'vs/base/common/event';
import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
import { IProgress } from 'vs/platform/progress/common/progress';
import { ISearchResultProvider, ISearchQuery, ISearchComplete, ISearchProgressItem, QueryType, IFileMatch, ISearchService, ILineMatch } from 'vs/platform/search/common/search';
import { values } from 'vs/base/common/map';
import { isFalsyOrEmpty } from 'vs/base/common/arrays';
@@ -55,11 +54,6 @@ export class MainThreadFileSystem implements MainThreadFileSystemShape {
$onFileSystemChange(handle: number, changes: IFileChangeDto[]): void {
this._fileProvider.get(handle).$onFileSystemChange(changes);
}
$reportFileChunk(handle: number, session: number, base64Chunk: string): void {
this._fileProvider.get(handle).reportFileChunk(session, base64Chunk);
}
// --- search
$handleFindMatch(handle: number, session, data: UriComponents | [UriComponents, ILineMatch]): void {
@@ -67,23 +61,10 @@ export class MainThreadFileSystem implements MainThreadFileSystemShape {
}
}
class FileReadOperation {
private static _idPool = 0;
constructor(
readonly progress: IProgress<Uint8Array>,
readonly id: number = ++FileReadOperation._idPool
) {
//
}
}
class RemoteFileSystemProvider implements IFileSystemProvider {
private readonly _onDidChange = new Emitter<IFileChange[]>();
private readonly _registrations: IDisposable[];
private readonly _reads = new Map<number, FileReadOperation>();
readonly onDidChange: Event<IFileChange[]> = this._onDidChange.event;
@@ -118,25 +99,19 @@ class RemoteFileSystemProvider implements IFileSystemProvider {
stat(resource: URI): TPromise<IStat, any> {
return this._proxy.$stat(this._handle, resource);
}
read(resource: URI, offset: number, count: number, progress: IProgress<Uint8Array>): TPromise<number, any> {
const read = new FileReadOperation(progress);
this._reads.set(read.id, read);
return this._proxy.$read(this._handle, read.id, offset, count, resource).then(value => {
this._reads.delete(read.id);
return value;
readFile(resource: URI): TPromise<Uint8Array, any> {
return this._proxy.$readFile(this._handle, resource).then(encoded => {
return Buffer.from(encoded, 'base64');
});
}
reportFileChunk(session: number, encodedChunk: string): void {
this._reads.get(session).progress.report(Buffer.from(encodedChunk, 'base64'));
}
write(resource: URI, content: Uint8Array): TPromise<void, any> {
writeFile(resource: URI, content: Uint8Array): TPromise<void, any> {
let encoded = Buffer.isBuffer(content)
? content.toString('base64')
: Buffer.from(content.buffer, content.byteOffset, content.byteLength).toString('base64');
return this._proxy.$write(this._handle, resource, encoded);
return this._proxy.$writeFile(this._handle, resource, encoded);
}
unlink(resource: URI): TPromise<void, any> {
return this._proxy.$unlink(this._handle, resource);
delete(resource: URI): TPromise<void, any> {
return this._proxy.$delete(this._handle, resource);
}
move(resource: URI, target: URI): TPromise<IStat, any> {
return this._proxy.$move(this._handle, resource, target);
@@ -149,9 +124,6 @@ class RemoteFileSystemProvider implements IFileSystemProvider {
return data.map(tuple => <[URI, IStat]>[URI.revive(tuple[0]), tuple[1]]);
});
}
rmdir(resource: URI): TPromise<void, any> {
return this._proxy.$rmdir(this._handle, resource);
}
}
class SearchOperation {

4
src/vs/workbench/api/node/extHost.api.impl.ts
View File

@@ -538,8 +538,8 @@ export function createApiFactory(
onDidEndTask: (listeners, thisArgs?, disposables?) => {
return extHostTask.onDidEndTask(listeners, thisArgs, disposables);
},
registerFileSystemProvider: proposedApiFunction(extension, (scheme, provider) => {
return extHostFileSystem.registerFileSystemProvider(scheme, provider);
registerFileSystemProvider: proposedApiFunction(extension, (scheme, provider, newProvider?) => {
return extHostFileSystem.registerFileSystemProvider(scheme, provider, newProvider);
}),
registerSearchProvider: proposedApiFunction(extension, (scheme, provider) => {
return extHostFileSystem.registerSearchProvider(scheme, provider);

12
src/vs/workbench/api/node/extHost.protocol.ts
View File

@@ -387,7 +387,6 @@ export interface MainThreadFileSystemShape extends IDisposable {
$unregisterProvider(handle: number): void;
$onFileSystemChange(handle: number, resource: IFileChangeDto[]): void;
$reportFileChunk(handle: number, session: number, base64Encoded: string | null): void;
$handleFindMatch(handle: number, session, data: UriComponents | [UriComponents, ILineMatch]): void;
}
@@ -568,13 +567,16 @@ export interface ExtHostWorkspaceShape {
export interface ExtHostFileSystemShape {
$utimes(handle: number, resource: UriComponents, mtime: number, atime: number): TPromise<IStat>;
$stat(handle: number, resource: UriComponents): TPromise<IStat>;
$read(handle: number, session: number, offset: number, count: number, resource: UriComponents): TPromise<number>;
$write(handle: number, resource: UriComponents, base64Encoded: string): TPromise<void>;
$unlink(handle: number, resource: UriComponents): TPromise<void>;
$readFile(handle: number, resource: UriComponents): TPromise<string>;
$writeFile(handle: number, resource: UriComponents, base64Encoded: string): TPromise<void>;
$move(handle: number, resource: UriComponents, target: UriComponents): TPromise<IStat>;
$mkdir(handle: number, resource: UriComponents): TPromise<IStat>;
$readdir(handle: number, resource: UriComponents): TPromise<[UriComponents, IStat][]>;
$rmdir(handle: number, resource: UriComponents): TPromise<void>;
$delete(handle: number, resource: UriComponents): TPromise<void>;
$provideFileSearchResults(handle: number, session: number, query: string): TPromise<void>;
$provideTextSearchResults(handle: number, session: number, pattern: IPatternInfo, options: { includes: string[], excludes: string[] }): TPromise<void>;
}

112
src/vs/workbench/api/node/extHostFileSystem.ts
View File

@@ -13,9 +13,8 @@ import { IDisposable } from 'vs/base/common/lifecycle';
import { asWinJsPromise } from 'vs/base/common/async';
import { IPatternInfo } from 'vs/platform/search/common/search';
import { values } from 'vs/base/common/map';
import { Range } from 'vs/workbench/api/node/extHostTypes';
import { Range, FileType } from 'vs/workbench/api/node/extHostTypes';
import { ExtHostLanguageFeatures } from 'vs/workbench/api/node/extHostLanguageFeatures';
import { IProgress } from 'vs/platform/progress/common/progress';
class FsLinkProvider implements vscode.DocumentLinkProvider {
@@ -56,10 +55,70 @@ class FsLinkProvider implements vscode.DocumentLinkProvider {
}
}
class FileSystemProviderShim implements vscode.FileSystemProvider2 {
_version: 2;
onDidChange?: vscode.Event<vscode.FileChange[]>;
constructor(private readonly _delegate: vscode.FileSystemProvider) {
this.onDidChange = this._delegate.onDidChange;
}
utimes(resource: vscode.Uri, mtime: number, atime: number): Thenable<vscode.FileStat> {
return this._delegate.utimes(resource, mtime, atime);
}
stat(resource: vscode.Uri): Thenable<vscode.FileStat> {
return this._delegate.stat(resource);
}
move(resource: vscode.Uri, target: vscode.Uri): Thenable<vscode.FileStat> {
return this.move(resource, target);
}
readdir(resource: vscode.Uri): Thenable<[vscode.Uri, vscode.FileStat][]> {
return this._delegate.readdir(resource);
}
// --- delete/create file or folder
delete(resource: vscode.Uri, options: { recursive: boolean; }): Thenable<void> {
return this.stat(resource).then(stat => {
if (stat.type === FileType.Dir) {
return this._delegate.rmdir(resource);
} else {
return this._delegate.unlink(resource);
}
});
}
create(resource: vscode.Uri, options: { type: vscode.FileType; }): Thenable<vscode.FileStat> {
if (options.type === FileType.Dir) {
return this._delegate.mkdir(resource);
} else {
return this._delegate.write(resource, Buffer.from([])).then(() => this._delegate.stat(resource));
}
}
// --- read/write
readFile(resource: vscode.Uri): Thenable<Uint8Array> {
let chunks: Buffer[] = [];
return this._delegate.read(resource, 0, -1, {
report(data) {
chunks.push(Buffer.from(data));
}
}).then(() => {
return Buffer.concat(chunks);
});
}
writeFile(resource: vscode.Uri, content: Uint8Array): Thenable<void> {
return this._delegate.write(resource, content);
}
}
export class ExtHostFileSystem implements ExtHostFileSystemShape {
private readonly _proxy: MainThreadFileSystemShape;
private readonly _fsProvider = new Map<number, vscode.FileSystemProvider>();
private readonly _fsProvider = new Map<number, vscode.FileSystemProvider2>();
private readonly _searchProvider = new Map<number, vscode.SearchProvider>();
private readonly _linkProvider = new FsLinkProvider();
@@ -70,7 +129,15 @@ export class ExtHostFileSystem implements ExtHostFileSystemShape {
extHostLanguageFeatures.registerDocumentLinkProvider('*', this._linkProvider);
}
registerFileSystemProvider(scheme: string, provider: vscode.FileSystemProvider) {
registerFileSystemProvider(scheme: string, provider: vscode.FileSystemProvider, newProvider: vscode.FileSystemProvider2) {
if (newProvider && newProvider._version === 2) {
return this._doRegisterFileSystemProvider(scheme, newProvider);
} else {
return this._doRegisterFileSystemProvider(scheme, new FileSystemProviderShim(provider));
}
}
private _doRegisterFileSystemProvider(scheme: string, provider: vscode.FileSystemProvider2) {
const handle = this._handlePool++;
this._linkProvider.add(scheme);
this._fsProvider.set(handle, provider);
@@ -109,36 +176,29 @@ export class ExtHostFileSystem implements ExtHostFileSystemShape {
$stat(handle: number, resource: UriComponents): TPromise<IStat, any> {
return asWinJsPromise(token => this._fsProvider.get(handle).stat(URI.revive(resource)));
}
$read(handle: number, session: number, offset: number, count: number, resource: UriComponents): TPromise<number> {
const progress: IProgress<Uint8Array> = {
report: chunk => {
let base64Chunk = Buffer.isBuffer(chunk)
? chunk.toString('base64')
: Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength).toString('base64');
this._proxy.$reportFileChunk(handle, session, base64Chunk);
}
};
return asWinJsPromise(token => this._fsProvider.get(handle).read(URI.revive(resource), offset, count, progress));
$readdir(handle: number, resource: UriComponents): TPromise<[UriComponents, IStat][], any> {
return asWinJsPromise(token => this._fsProvider.get(handle).readdir(URI.revive(resource)));
}
$write(handle: number, resource: UriComponents, base64Content: string): TPromise<void, any> {
return asWinJsPromise(token => this._fsProvider.get(handle).write(URI.revive(resource), Buffer.from(base64Content, 'base64')));
$readFile(handle: number, resource: UriComponents): TPromise<string> {
return asWinJsPromise(token => {
return this._fsProvider.get(handle).readFile(URI.revive(resource), token);
}).then(data => {
return Buffer.isBuffer(data) ? data.toString('base64') : Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString('base64');
});
}
$unlink(handle: number, resource: UriComponents): TPromise<void, any> {
return asWinJsPromise(token => this._fsProvider.get(handle).unlink(URI.revive(resource)));
$writeFile(handle: number, resource: UriComponents, base64Content: string): TPromise<void, any> {
return asWinJsPromise(token => this._fsProvider.get(handle).writeFile(URI.revive(resource), Buffer.from(base64Content, 'base64'), token));
}
$delete(handle: number, resource: UriComponents): TPromise<void, any> {
return asWinJsPromise(token => this._fsProvider.get(handle).delete(URI.revive(resource), { recursive: true }));
}
$move(handle: number, resource: UriComponents, target: UriComponents): TPromise<IStat, any> {
return asWinJsPromise(token => this._fsProvider.get(handle).move(URI.revive(resource), URI.revive(target)));
}
$mkdir(handle: number, resource: UriComponents): TPromise<IStat, any> {
return asWinJsPromise(token => this._fsProvider.get(handle).mkdir(URI.revive(resource)));
}
$readdir(handle: number, resource: UriComponents): TPromise<[UriComponents, IStat][], any> {
return asWinJsPromise(token => this._fsProvider.get(handle).readdir(URI.revive(resource)));
}
$rmdir(handle: number, resource: UriComponents): TPromise<void, any> {
return asWinJsPromise(token => this._fsProvider.get(handle).rmdir(URI.revive(resource)));
return asWinJsPromise(token => this._fsProvider.get(handle).create(URI.revive(resource), { type: FileType.Dir }));
}
$provideFileSearchResults(handle: number, session: number, query: string): TPromise<void> {
const provider = this._searchProvider.get(handle);
if (!provider.provideFileSearchResults) {