WIP

Author: CMCDragonkai

src/EncryptedFS.ts

@@ -1,4 +1,4 @@
-import type { DBTransaction } from '@matrixai/db';
+import type { Crypto, DBTransaction } from '@matrixai/db';
 import type {
   Navigated,
   ParsedPath,
@@ -93,17 +93,22 @@ class EncryptedFS {
     logger?: Logger;
     fresh?: boolean;
   }): Promise<EncryptedFS> {
+    let crypto: {
+      key: Buffer,
+      ops: Crypto
+    } | undefined;
     if (db == null) {
+      crypto = {
+        key: dbKey!,
+        ops: {
+          encrypt: utils.encrypt,
+          decrypt: utils.decrypt,
+        },
+      };
       try {
         db = await DB.createDB({
           dbPath: dbPath!,
-          crypto: {
-            key: dbKey!,
-            ops: {
-              encrypt: utils.encrypt,
-              decrypt: utils.decrypt,
-            },
-          },
+          crypto,
           logger: logger.getChild(DB.name),
           fresh,
         });
@@ -158,6 +163,7 @@ class EncryptedFS {
     fdMgr = fdMgr ?? new FileDescriptorManager(iNodeMgr);
     const efs = new this({
       db,
+      crypto,
       iNodeMgr,
       fdMgr,
       rootIno,
@@ -175,6 +181,14 @@ class EncryptedFS {
   public readonly blockSize: number;
 
   protected db: DB;
+  /**
+   * If crypto is created and passed in.
+   * This means the DB object was created by ourselves.
+   * This means EFS will manage the lifecycle of the encapsulated DB.
+   * However if the DB was passed in from the outside.
+   * Then EFS will not manage the lifecycle of the DB.
+   */
+  protected crypto?: { key: Buffer; ops: Crypto };
   protected iNodeMgr: INodeManager;
   protected fdMgr: FileDescriptorManager;
   protected logger: Logger;
@@ -186,6 +200,7 @@ class EncryptedFS {
 
   constructor({
     db,
+    crypto,
     iNodeMgr,
     fdMgr,
     rootIno,
@@ -196,6 +211,10 @@ class EncryptedFS {
     chrootParent,
   }: {
     db: DB;
+    crypto?: {
+      key: Buffer;
+      ops: Crypto;
+    };
     iNodeMgr: INodeManager;
     fdMgr: FileDescriptorManager;
     rootIno: INodeIndex;
@@ -207,6 +226,7 @@ class EncryptedFS {
   }) {
     this.logger = logger;
     this.db = db;
+    this.crypto = crypto;
     this.iNodeMgr = iNodeMgr;
     this.fdMgr = fdMgr;
     this.rootIno = rootIno;
@@ -236,7 +256,9 @@ class EncryptedFS {
   } = {}): Promise<void> {
     this.logger.info(`Starting ${this.constructor.name}`);
     if (this.chrootParent == null) {
-      await this.db.start({ fresh });
+      if (this.crypto != null)  {
+        await this.db.start({ crypto: this.crypto, fresh });
+      }
       await this.iNodeMgr.start({ fresh });
     } else {
       // If chrooted instance, add itself to the chroots set
@@ -252,7 +274,9 @@ class EncryptedFS {
         await efsChrooted.stop();
       }
       await this.iNodeMgr.stop();
-      await this.db.stop();
+      if (this.crypto != null) {
+        await this.db.stop();
+      }
     } else {
       // If chrooted instance, delete itself from the chroots set
       this.chroots.delete(this);
@@ -263,10 +287,13 @@ class EncryptedFS {
   public async destroy(): Promise<void> {
     this.logger.info(`Destroying ${this.constructor.name}`);
     if (this.chrootParent == null) {
-      // No need to destroy with `this.iNodeMgr.destroy()`
-      // It would require restarting the DB
-      // It is sufficient to only destroy the database
-      await this.db.destroy();
+      if (this.crypto != null) {
+        await this.db.destroy();
+      } else {
+        // If it is not an encapsulated DB instance,
+        // then we only clear the inodes
+        await this.iNodeMgr.destroy();
+      }
     }
     // No destruction procedures for chrooted instances
     this.logger.info(`Destroyed ${this.constructor.name}`);
@@ -1985,9 +2012,6 @@ class EncryptedFS {
         throw e;
       }
     };
-
-    console.log('WHAT IS THIS?', path);
-
     let navigated = await this.navigate(path, false);
     // Mutable transaction contexts may be inherited across loop iterations
     // During concurrent open calls with `O_CREAT`, calls may race to create the inode
@@ -2415,7 +2439,6 @@ class EncryptedFS {
         let totalBuffer = Buffer.alloc(0);
         let bytesRead: number | undefined = undefined;
         if (typeof file !== 'number') {
-          console.log('I AM HERE', file, options.flag);
           fdIndex = await this.open(file, options.flag);
           file = fdIndex;
         }
@@ -3427,7 +3450,6 @@ class EncryptedFS {
           pathStack: [],
         };
       } else {
-        console.log('....');
         return await this.navigateFrom(
           this.rootIno,
           pathS,
@@ -3438,11 +3460,6 @@ class EncryptedFS {
         );
       }
     } else {
-      // ATO thing didn't work
-      // Signed license didn't work
-      // Not sure I really care about the qantas points
-      // The ATO portal thing is a bit more important
-      console.log('!!!!', this._cwd.ino, pathS, resolveLastLink, activeSymlinks, this._cwd.pathStack, origPathS);
       return await this.navigateFrom(
         this._cwd.ino,
         pathS,
@@ -3496,9 +3513,6 @@ class EncryptedFS {
         DBTransaction,
       ];
     }
-
-    console.log('HERE', curdir);
-
     const curDirData = await this.iNodeMgr.get(curdir, tran);
     if (curDirData == null) {
       throw new errors.ErrorEncryptedFSError({

src/inodes/INodeManager.ts

@@ -375,7 +375,6 @@ class INodeManager {
       }
       nlink = 1;
     }
-    console.log('CREATING INODE');
     await this.iNodeCreate(
       'Directory',
       {
@@ -423,9 +422,6 @@ class INodeManager {
     params: INodeParams,
     tran: DBTransaction,
   ): Promise<void> {
-
-    console.log('CREATING INODE', type, params);
-
     const statPath = [...this.statsDbPath, params.ino.toString()];
     params.dev = params.dev ?? 0;
     params.nlink = params.nlink ?? 0;
@@ -584,20 +580,10 @@ class INodeManager {
     if (tran == null) {
       return this.withTransactionF(ino, async (tran) => this.get(ino, tran));
     }
-
-    console.log(
-      'WHAT IS THIS?',
-      this.iNodesDbPath,
-      inodesUtils.iNodeId(ino as INodeIndex),
-    );
-
     const type = await tran.get<INodeType>([
       ...this.iNodesDbPath,
       inodesUtils.iNodeId(ino as INodeIndex),
     ]);
-
-    console.log('Acquired type', type);
-
     if (type == null) {
       return;
     }

tests/EncryptedFS.concurrent.test.ts

@@ -4037,7 +4037,11 @@ describe(`${EncryptedFS.name} Concurrency`, () => {
         results.every((result) => {
           return (
             result.status === 'fulfilled' &&
-            (result.value === [] || result.value === undefined)
+            (
+              (Array.isArray(result.value) && result.value.length === 0)
+              ||
+              result.value === undefined
+            )
           );
         })
       ) {

tests/EncryptedFS.test.ts

@@ -42,24 +42,18 @@ describe(EncryptedFS.name, () => {
       await efs.chdir('.');
     }).rejects.toThrow(errors.ErrorEncryptedFSNotRunning);
   });
-  test.only('efs is persistent across restarts', async () => {
+  test('efs is persistent across restarts', async () => {
     const efs1 = await EncryptedFS.createEncryptedFS({
       dbPath: dataDir,
       dbKey,
       logger,
     });
-    console.log('1');
     await efs1.writeFile('testfile', 'hello world');
-    console.log('------------READFILE', await efs1.readFile('testfile', { encoding: 'utf-8' }));
-    console.log('2');
     await efs1.stop();
-    console.log('3');
     await efs1.start();
-    console.log('4');
     expect(await efs1.readFile('testfile', { encoding: 'utf-8' })).toBe(
       'hello world',
     );
-    console.log('5');
     await efs1.stop();
     const efs2 = await EncryptedFS.createEncryptedFS({
       dbPath: dataDir,