Monaco with real file system

[vivekaccelq]

Hi, so far I understood that monaco cannot interact with real file system directly. When I try to use the same example setup for a Gopls project it fails with "Unable to read / write file C:\path\to\golang\file.go ". And all the examples shown are using Virtual memory.

So for my case I've created a LocalFileSystemProvider.js to perform IO operations using a Golang backend Server as code shown below. Now there are 2 questions.

1. Is it the right way?
2. How to register this LocalFileSystemProvider to vscode and monaco api's?. Like vscode.workspace.openTextDocument

import {Disposable, DisposableStore} from 'vscode/vscode/vs/base/common/lifecycle';
import {Event, Emitter} from 'vscode/vscode/vs/base/common/event';
import {newWriteableStream} from 'vscode/vscode/vs/base/common/stream';
import {VSBuffer} from 'vscode/vscode/vs/base/common/buffer';
import {
 FileSystemProviderErrorCode,
 FileSystemProviderError,
 FileType,
 FilePermission,
} from 'vscode/vscode/vs/platform/files/common/files';
import FileIOService from 'api/fileioService';
import { extractErrorMsg } from 'util/helper';

function createFileSystemProviderError(error, code) {
    return FileSystemProviderError.create(error, code);
}
class RegisterFile {
 constructor(uri, readonly=false) {
        this.uri = uri;
        this.readonly = readonly;
        this.type = FileType.File;
        this._onDidChange = new Emitter();
        this.onDidChange = this._onDidChange.event;
        this._onDidDelete = new Emitter();
        this.onDidDelete = this._onDidDelete.event;
        this.ctime = Date.now();
        this.mtime = Date.now();
  this.size = 0;
        // this.onDidChange(() => {
        //     this.mtime = Date.now();
        // });
    }
    async stats() {
        return {
            ctime: this.ctime,
            mtime: this.mtime,
            size: await this.getSize(),
            type: FileType.File,
            permissions: this.readonly ? FilePermission.Readonly : undefined
        };
    }
    async delete() {
        if (this.readonly) {
            throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.FileWriteLocked);
        }
        this._onDidDelete.fire();
    }
 async getSize() {
  try {
   const resposne = await FileIOService.getSize(this.uri.toString());
   return parseInt(resposne.headers['content-length'] || '0', 10);
  }catch(e){
   return 0;
  }
 }
}
class LocalFileSystemProvider extends Disposable {
 constructor() {
  super();
  this._onDidChangeFile = new Emitter();
  this.onDidChangeFile = this._onDidChangeFile.event;
  this.capabilities = 2 | 1024 | 16; //fileReadwrite | pathcasesensitive
  this.onDidChangeCapabilities = Event.None;
  this._registeredFiles = new Map();
  this._fileDescriptors = new Map();
  this._fdCounter = 0;
 }
 async registerFile(uri, options={readonly: false}) {
  const file = new RegisterFile(uri, options.readonly);
  const disposableStore = new DisposableStore();
  disposableStore.add(file.onDidDelete(() => {
   this._registeredFiles.delete(uri.toString());
   this._onDidChangeFile.fire([{
    type: 2, // deleted
    resource: uri
   }]);
  }));
  disposableStore.add(file.onDidChange(() => {
   this._onDidChangeFile.fire([{
    type: 0, // changed
    resource: uri
   }]);
  }));
  this._registeredFiles.set(uri.toString(), file);
  this._onDidChangeFile.fire([{
   type: 1, //created
   resource: uri
  }]);
  return disposableStore;
 }
 async open(resource) {
  try {
   await this.stat(resource);
   const fd = this._fdCounter++;
   this._fileDescriptors.set(fd, {
    resource,
    position: 0
   });
   return fd;
  }catch(e) {
   throw this.handleError(extractErrorMsg(e));
  }
 }
 async close(fd) {
  this._fileDescriptors.delete(fd);
 }
 async read(fd, pos, data, offset, length) {
  const handle = this._fileDescriptors.get(fd);
  if (!handle) {
   throw createFileSystemProviderError('Invalid file descriptor', FileSystemProviderErrorCode.Unavailable);
  }
  try {
   const response = await FileIOService.read({
    path: handle.resource.path,
    position: pos === -1 ? handle.position : pos,
    length: length
   });
   const buffer = new Uint8Array(response.data);
   data.set(buffer, offset);
   if (pos === -1) {
    handle.position += buffer.length;
   }
   return buffer.length;
  }catch(e) {
   throw this.handleError(extractErrorMsg(e));
  }
 }
 async stat(resource) {
  try {
   const response = await FileIOService.getFileStat(resource.path);
   if (!response.status) {
    throw this.handleHttpError(response);
   }
   return response.data;
  }catch(e) {
   throw this.handleError(extractErrorMsg(e));
  }
 }
 async readdir(resource) {
  try {
   const response = await FileIOService.readDirectory(resource.path);
   if (!response.status) {
    throw this.handleHttpError(response);
   }
   return response.data;
  }catch(e) {
   throw this.handleError(extractErrorMsg(e));
  }
 }
 async readFile(resource) {
  const file = this._registeredFiles.get(resource.toString());
  if (!file) {
   throw createFileSystemProviderError('File not found', FileSystemProviderErrorCode.FileNotFound);
  }
  try {
   const response = await FileIOService.readFile(resource.path);
   const buffer = new Uint8Array(response.data);
   if (file) {
    file.mtime = Date.now();
   }
   return buffer;
  }catch(e) {
   throw this.handleError(extractErrorMsg(e));
  }
 }
 readFileStream(resource, opts, token) {
  const stream = newWriteableStream(data => VSBuffer.concat(data.map(d => VSBuffer.wrap(d))).buffer);
  const func = async () => {
   try {
    const response = await FileIOService.readFileStream(resource.path, (progressEvent) => {
     if (token.isCancellationRequested) {
      stream.end();
      return;
     }
    });
    response.data.on('data', chunk => {
     if (token.isCancellationRequested) {
      response.data.destroy();
      return;
     }
     stream.write(chunk);
    });
    response.data.on('end', chunk => {
     stream.end();
    });
    response.data.on('error', (e) => {
     stream.error(this.handleError(extractErrorMsg(e)));
     stream.end();
    });
   }catch(e) {
    stream.error(this.handleError(extractErrorMsg(e)));
    stream.end();
   } 
  }
  func();
  return stream;
 }
 async writeFile(resource, content, opts) {
  const file = this._registeredFiles.get(resource.toString());
  if (!file) {
   throw createFileSystemProviderError('File not found', FileSystemProviderErrorCode.FileNotFound);
  }
  try {
   await FileIOService.writeFile(resource.path, content);
   if (file) {
    file._onDidChange.fire();
   }
   if (!file && opts.create) {
    await this.registerFile(resource);
   }
  }catch(e) {
   throw this.handleError(extractErrorMsg(e));
  }
 }
 async mkdir(resource) {} // this is not needed
 async delete(resource, opts) {} // this is not needed
 async rename(resource, opts) {} // this is not needed
 watch(resource, opts){
  // const file = this._registeredFiles.get(resource.toString());
  // if (!file) {
  //  return Disposable.None;
  // }
  // const disposables = new DisposableStore();
  // disposables.add(file.onDidChange(() => {
  //  this._onDidChangeFile.fire([{
  //   type: 0,
  //   resource
  //  }]);
  // }));
  // disposables.add(file.onDidDelete(() => {
  //  this._onDidChangeFile.fire([{
  //   type: 2,
  //   resource
  //  }]);
  // }));
  // return disposables;
  return Disposable.None;

 }
 handleError(response) {
  switch(response.status) {
   case 404:
    return createFileSystemProviderError('File not found', FileSystemProviderErrorCode.FileNotFound);
   case 403:
    return createFileSystemProviderError('Permission deined', FileSystemProviderErrorCode.NoPermissions);
   case 409:
    return createFileSystemProviderError('File exists', FileSystemProviderErrorCode.FileExists);
   default:
    return createFileSystemProviderError('Unkown error', FileSystemProviderErrorCode.Unknown);
  }
 }
}

export {
 LocalFileSystemProvider,
 RegisterFile
};

[CGNonofr]

Is it the right way?

It looks like it

How to register this LocalFileSystemProvider to vscode and monaco api's?. Like vscode.workspace.openTextDocument

You're supposed to implement IFileSystemProviderWithFileReadWriteCapability then either call registerFileSystemOverlay or registerCustomProvider with it before initializating the services