fix: allow changing 'backend' during 'init' (#65)

Author: billiegoose

README.md

@@ -251,6 +251,12 @@ interface IBackend {
   // bonus - not part of the standard `fs` module
   backFile(filepath: string, opts: any): void;
   du(filepath: string): Awaited<number>;
+
+  // lifecycle - useful if your backend needs setup and teardown
+  init?(name: string, opts: any): Awaited<void>; // passes initialization options
+  activate?(): Awaited<void>; // called before fs operations are started
+  deactivate?(): Awaited<void>; // called after fs has been idle for a while
+  destroy?(): Awaited<void>; // called before hotswapping backends
 }
 ```
 

src/PromisifiedFS.js

@@ -57,8 +57,6 @@ module.exports = class PromisifiedFS {
     this.backFile = this._wrap(this.backFile, cleanParamsFilepathOpts, true)
     this.du = this._wrap(this.du, cleanParamsFilepathOpts, false);
 
-    this._backend = options.backend || new DefaultBackend();
-
     this._deactivationPromise = null
     this._deactivationTimeout = null
     this._activationPromise = null
@@ -76,8 +74,15 @@ module.exports = class PromisifiedFS {
   }
   async _init (name, options = {}) {
     await this._gracefulShutdown();
+    if (this._activationPromise) await this._deactivate()
 
-    await this._backend.init(name, options);
+    if (this._backend && this._backend.destroy) {
+      await this._backend.destroy();
+    }
+    this._backend = options.backend || new DefaultBackend();
+    if (this._backend.init) {
+      await this._backend.init(name, options);
+    }
 
     if (this._initPromiseResolve) {
       this._initPromiseResolve();
@@ -130,12 +135,17 @@ module.exports = class PromisifiedFS {
     }
     if (this._deactivationPromise) await this._deactivationPromise
     this._deactivationPromise = null
-    if (!this._activationPromise) this._activationPromise = this._backend.activate();
+    if (!this._activationPromise) {
+      this._activationPromise = this._backend.activate ? this._backend.activate() : Promise.resolve();
+    }
     await this._activationPromise
   }
   async _deactivate() {
     if (this._activationPromise) await this._activationPromise
-    if (!this._deactivationPromise) this._deactivationPromise = this._backend.deactivate();
+
+    if (!this._deactivationPromise) {
+      this._deactivationPromise = this._backend.deactivate ? this._backend.deactivate() : Promise.resolve();
+    }
     this._activationPromise = null
     if (this._gracefulShutdownResolve) this._gracefulShutdownResolve()
     return this._deactivationPromise

src/__tests__/hotswap-backends-1.spec.js

@@ -0,0 +1,26 @@
+import FS from "../index.js";
+
+const fs = new FS();
+const pfs = fs.promises;
+
+describe("hotswap backends", () => {
+
+  it("re-init with new backend", async () => {
+    // write a file
+    fs.init("testfs-1", { wipe: true })
+    await pfs.writeFile('/a.txt', 'HELLO');
+    expect(await pfs.readFile('/a.txt', 'utf8')).toBe('HELLO');
+
+    // we swap backends. file is gone
+    fs.init('testfs-2', { wipe: true })
+    let err = null
+    try {
+      await pfs.readFile('/a.txt', 'utf8')
+    } catch (e) {
+      err = e
+    }
+    expect(err).not.toBeNull();
+    expect(err.code).toBe('ENOENT');
+  });
+
+});

src/__tests__/hotswap-backends-2.spec.js

@@ -0,0 +1,36 @@
+import FS from "../index.js";
+
+const fs = new FS();
+const pfs = fs.promises;
+
+describe("hotswap backends", () => {
+
+  it("swap back and forth between two backends", async () => {
+    // write a file to backend A
+    fs.init('testfs-A', { wipe: true });
+    await pfs.writeFile('/a.txt', 'HELLO');
+    expect(await pfs.readFile('/a.txt', 'utf8')).toBe('HELLO');
+
+    // write a file to backend B
+    fs.init('testfs-B', { wipe: true })
+    await pfs.writeFile('/a.txt', 'WORLD');
+    expect(await pfs.readFile('/a.txt', 'utf8')).toBe('WORLD');
+
+    // read a file from backend A
+    fs.init('testfs-A');
+    expect(await pfs.readFile('/a.txt', 'utf8')).toBe('HELLO');
+
+    // read a file from backend B
+    fs.init('testfs-B');
+    expect(await pfs.readFile('/a.txt', 'utf8')).toBe('WORLD');
+
+    // read a file from backend A
+    fs.init('testfs-A');
+    expect(await pfs.readFile('/a.txt', 'utf8')).toBe('HELLO');
+  
+    // read a file from backend B
+    fs.init('testfs-B');
+    expect(await pfs.readFile('/a.txt', 'utf8')).toBe('WORLD');
+  });
+
+});

src/__tests__/hotswap-backends-3.spec.js

@@ -0,0 +1,34 @@
+import FS from "../index.js";
+
+const fs = new FS();
+const pfs = fs.promises;
+
+describe("hotswap backends", () => {
+
+  it("a custom backend", async () => {
+    // we started with a default backend.
+    fs.init('testfs-default', { wipe: true })
+    await pfs.writeFile('/a.txt', 'HELLO');
+    expect(await pfs.readFile('/a.txt', 'utf8')).toBe('HELLO');
+
+    // we swap backends.
+    let ranInit = false;
+    let ranDestroy = false;
+    fs.init('testfs-custom', {
+      backend: {
+        init() { ranInit = true },
+        readFile() { return 'dummy' },
+        destroy() { ranDestroy = true },
+      }
+    });
+    expect(await pfs.readFile('/a.txt', 'utf8')).toBe('dummy');
+    expect(ranInit).toBe(true);
+    expect(ranDestroy).toBe(false);
+
+    // we swap back
+    fs.init('testfs-default');
+    expect(await pfs.readFile('/a.txt', 'utf8')).toBe('HELLO');
+    expect(ranDestroy).toBe(true);
+  });
+
+});

src/__tests__/hotswap-backends-4.spec.js

@@ -0,0 +1,59 @@
+import FS from "../index.js";
+
+const fs = new FS();
+const pfs = fs.promises;
+
+// IDK it's broke. It's time to rewrite LightningFS basically.
+
+xdescribe("hotswap backends", () => {
+
+  it("graceful transition", async () => {
+    const N = 1
+    class MockBackend {
+      constructor() {
+        this.count = 0
+        this.writeFile = this.writeFile.bind(this);
+      }
+      async writeFile () {
+        await new Promise(r => setTimeout(r, 100 * Math.random()))
+        this.count++
+      }
+      async readFile () {
+        return 'foo'
+      }
+    }
+
+    const b1 = new MockBackend();
+    const b2 = new MockBackend();
+
+    // write N files to mock backend 1
+    await fs.init('testfs-custom-1', { backend: b1, defer: true });
+    for (let i = 0; i < N; i++) {
+      // we don't await
+      pfs.writeFile('hello', 'foo');
+    }
+
+    // swap backends without waiting
+    await fs.init('testfs-custom-2', { backend: b2, defer: true });
+    expect(pfs._operations.size).toBe(N);
+
+    // write N files to mock backend 2
+    for (let i = 0; i < N; i++) {
+      // we don't await
+      pfs.writeFile('hello', 'foo');
+    }
+
+    // swap backend back without waiting
+    fs.init('testfs-custom-1', { backend: b1, defer: true });
+    expect(pfs._operations.size).toBe(N);
+
+    // but now we have to wait. because we're dumb and the hotswapping isn't perfect
+    await new Promise(r => setTimeout(r, 250));
+    expect(pfs._operations.size).toBe(0);
+
+    // everything should be synced now
+    expect(b1.count).toBe(N)
+    expect(b2.count).toBe(N)
+  });
+
+});

src/index.js

@@ -31,7 +31,7 @@ module.exports = class FS {
     this.du = this.du.bind(this)
   }
   init(name, options) {
-    this.promises.init(name, options)
+    return this.promises.init(name, options)
   }
   readFile(filepath, opts, cb) {
     const [resolve, reject] = wrapCallback(opts, cb);