fs/memory-provider: stat, mkdir

Author: XiaochenCui

src/backend/src/api/APIError.js

@@ -17,6 +17,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 const { URLSearchParams } = require("node:url");
+const config = require("../config");
 const { quot } = require('@heyputer/putility').libs.string;
 
 /**
@@ -518,14 +519,19 @@ module.exports = class APIError {
      * is set to null. The first argument is used as the status code.
      *
      * @static
-     * @param {number} status
-     * @param {string|Error} message_or_source one of the following:
+     * @param {number|string} status
+     * @param {object} source
+     * @param {string|Error|object} fields one of the following:
      * - a string to use as the error message
      * - an Error object to use as the source of the error
      * - an object with a message property to use as the error message
      * @returns
      */
     static create (status, source, fields = {}) {
+        if ( config.env === 'dev' ) {
+            console.trace('APIError.create', status, source, fields);
+        }
+
         // Just the error code
         if ( typeof status === 'string' ) {
             const code = this.codes[status];

src/backend/src/filesystem/FSNodeContext.js

@@ -121,6 +121,12 @@ module.exports = class FSNodeContext {
                 return result;
             }
         }
+
+        if ( (! this.path) && (! this.uid) ) {
+            console.log('no path or uid');
+            selector.setPropertiesKnownBySelector(this);
+            console.log('no path or uid');
+        }
     }
 
     set selector (new_selector) {
@@ -288,10 +294,18 @@ module.exports = class FSNodeContext {
             controls,
         });
 
+        if ( entry === undefined ) {
+            console.error('entry is undefined');
+            this.found = false;
+            this.entry = false;
+            return;
+        }
+
         if ( entry === null ) {
             this.found = false;
             this.entry = false;
         } else {
+
             this.found = true;
 
             if ( ! this.uid && entry.uuid ) {

src/backend/src/filesystem/hl_operations/hl_mkdir.js

@@ -31,6 +31,7 @@ const { HLFilesystemOperation } = require('./definitions');
 const { is_valid_path } = require('../validation');
 const { HLRemove } = require('./hl_remove');
 const { LLMkdir } = require('../ll_operations/ll_mkdir');
+const { MemoryFSService } = require('../../modules/puterfs/customfs/MemoryFSService');
 
 class MkTree extends HLFilesystemOperation {
     static DESCRIPTION = `
@@ -287,7 +288,7 @@ class HLMkdir extends HLFilesystemOperation {
         // "top_parent" is the immediate parent of the target directory
         // (e.g: /home/foo/bar -> /home/foo)
         const top_parent = values.create_missing_parents
-            ? await this._create_top_parent({ top_parent: parent_node })
+            ? await this._create_dir(parent_node)
             : await this._get_existing_top_parent({ top_parent: parent_node })
             ;
 
@@ -299,6 +300,10 @@ class HLMkdir extends HLFilesystemOperation {
             });
         }
 
+        if ( values.dedupe_name ) {
+            console.log('DEDUPE NAME', values.dedupe_name);
+        }
+
         // `parent_node` becomes the parent of the last directory name
         // specified under `path`.
         parent_node = await this._create_parents({
@@ -317,6 +322,10 @@ class HLMkdir extends HLFilesystemOperation {
 
         await existing.fetchEntry();
 
+        if ( values.dedupe_name ) {
+            console.log('DEDUPE NAME', values.dedupe_name);
+        }
+
         if ( existing.found ) {
             const { overwrite, dedupe_name, create_missing_parents } = values;
             if ( overwrite ) {
@@ -331,13 +340,17 @@ class HLMkdir extends HLFilesystemOperation {
                 });
             }
             else if ( dedupe_name ) {
-                const fsEntryFetcher = context.get('services').get('fsEntryFetcher');
+                if ( parent_node.provider instanceof MemoryFSService ) {
+                    console.log('MEMORYFS DEDUPE');
+                }
+
+                const fs = context.get('services').get('filesystem');
+                const parent_selector = parent_node.selector;
                 for ( let i=1 ;; i++ ) {
                     let try_new_name = `${target_basename} (${i})`;
-                    const exists = await fsEntryFetcher.nameExistsUnderParent(
-                        existing.entry.parent_uid, try_new_name
-                    );
-                    if ( ! exists ) {
+                    const selector = new NodeChildSelector(parent_selector, try_new_name);
+                    const node = await fs.node(selector);
+                    if ( ! await node.exists() ) {
                         target_basename = try_new_name;
                         break;
                     }
@@ -468,28 +481,44 @@ class HLMkdir extends HLFilesystemOperation {
         return node;
     }
 
-    async _create_top_parent ({ top_parent }) {
-        if ( await top_parent.exists() ) {
-            if ( ! top_parent.entry.is_dir ) {
+    /**
+     * Creates a directory and all its ancestors.
+     *
+     * @param {FSNodeContext} dir - The directory to create.
+     * @returns {Promise<FSNodeContext>} The created directory.
+     */
+    async _create_dir (dir) {
+        console.log('CREATING DIR', dir.selector.describe());
+
+        if ( await dir.exists() ) {
+            if ( ! dir.entry.is_dir ) {
                 throw APIError.create('dest_is_not_a_directory');
             }
-            return top_parent;
+            return dir;
         }
 
         const maybe_path_selector =
-            top_parent.get_selector_of_type(NodePathSelector);
+            dir.get_selector_of_type(NodePathSelector);
 
         if ( ! maybe_path_selector ) {
             throw APIError.create('dest_does_not_exist');
         }
 
-        const path = maybe_path_selector.value;
+        let path = maybe_path_selector.value;
 
         const fs = this.context.get('services').get('filesystem');
 
+        let parent = await fs.node(new RootNodeSelector());
+        // if ( mountpoint && mountpoint !== '/' ) {
+        //     parent = await fs.node(new NodePathSelector(mountpoint));
+
+        //     // remove the mountpoint from the path
+        //     path = path.replace(mountpoint, '');
+        // }
+
         const tree_op = new MkTree();
         await tree_op.run({
-            parent: await fs.node(new RootNodeSelector()),
+            parent: parent,
             tree: [path],
         });
 

src/backend/src/filesystem/node/selectors.js

@@ -87,9 +87,45 @@ class NodeChildSelector {
         this.name = name;
     }
 
+    /**
+     * Try to infer the absolute path of the node.
+     *
+     * @returns {string|null} the absolute path of the node, or null if the path cannot be inferred
+     */
+    try_infer_path () {
+        // try to get the full path recursively
+        //
+        // TODO (xiaochen): this is a hack to get the absolute path and should be removed once
+        // we have a better solution. We need the absolute path so that `MountpointService`
+        // can determine the mountpoint and provider for the node.
+        const stack = [this.name];
+        let current = this.parent;
+        while ( current ) {
+            if ( current instanceof NodeChildSelector ) {
+                stack.push(current.name);
+                current = current.parent;
+            } else if ( current instanceof NodePathSelector ) {
+                stack.push(current.value);
+                current = null;
+            } else if ( current instanceof RootNodeSelector ) {
+                current = null;
+            } else {
+                // for other selectors, we can't determine the absolute path
+                return null;
+            }
+        }
+
+        let path = '/';
+        stack.reverse().forEach(item => {
+            path = _path.join(path, item);
+        });
+
+        return path;
+    }
+
     setPropertiesKnownBySelector (node) {
         node.name = this.name;
-        // no properties known
+        node.path = this.try_infer_path();
     }
 
     describe () {
@@ -145,6 +181,30 @@ class NodeRawEntrySelector {
     }
 }
 
+/**
+ * Try to infer following attributes for a selector:
+ * - path
+ * - uid
+ *
+ * @param {NodePathSelector|NodeUIDSelector|NodeChildSelector|RootNodeSelector} selector
+ */
+function try_infer_attributes (selector) {
+    if ( selector instanceof NodePathSelector ) {
+        selector.path = selector.value;
+    } else if ( selector instanceof NodeUIDSelector ) {
+        selector.uid = selector.value;
+    } else if ( selector instanceof NodeChildSelector ) {
+        try_infer_attributes(selector.parent);
+        if ( selector.parent.path ) {
+            selector.path = _path.join(selector.parent.path, selector.name);
+        }
+    } else if ( selector instanceof RootNodeSelector ) {
+        selector.path = '/';
+    } else {
+        throw new Error('invalid selector');
+    }
+}
+
 const relativeSelector = (parent, path) => {
     if ( path === '.' ) return parent;
     if ( path.startsWith('..') ) {
@@ -169,4 +229,5 @@ module.exports = {
     RootNodeSelector,
     NodeRawEntrySelector,
     relativeSelector,
+    try_infer_attributes,
 };

src/backend/src/helpers.js

@@ -97,6 +97,12 @@ async function is_user_signup_disabled() {
 }
 
 const chkperm = spanify('chkperm', async (target_fsentry, requester_user_id, action) => {
+    // TODO (xiaochen): remove this branch after the related ACL permission logic is implemented for "MemoryFSProvider".
+    if (target_fsentry.is_public) {
+        console.log('TRUE BECAUSE IS_PUBLIC')
+        // return true;
+    }
+
     // basic cases where false is the default response
     if(!target_fsentry)
         return false;

src/backend/src/modules/puterfs/MountpointService.js

@@ -19,7 +19,7 @@
  */
 // const Mountpoint = o => ({ ...o });
 
-const { RootNodeSelector, NodeUIDSelector } = require("../../filesystem/node/selectors");
+const { RootNodeSelector, NodeUIDSelector, NodeChildSelector, NodePathSelector, NodeInternalIDSelector } = require("../../filesystem/node/selectors");
 const BaseService = require("../../services/BaseService");
 
 /**
@@ -87,12 +87,39 @@ class MountpointService extends BaseService {
     }
 
     async get_provider (selector) {
+        // type check
+        if ( ! (selector instanceof RootNodeSelector) &&
+            ! (selector instanceof NodeUIDSelector) &&
+            ! (selector instanceof NodeChildSelector) &&
+            ! (selector instanceof NodePathSelector) &&
+            ! (selector instanceof NodeInternalIDSelector)
+        ) {
+            throw new Error('Invalid selector type');
+        }
+
         if ( selector instanceof RootNodeSelector ) {
             return this.mountpoints_['/'].provider;
         }
 
         if ( selector instanceof NodeUIDSelector ) {
-            return this.mountpoints_['/'].provider;
+            for ( const [path, { provider }] of Object.entries(this.mountpoints_) ) {
+                const result = await provider._stat_by_uid({
+                    uid: selector.value,
+                });
+                if ( result ) {
+                    return provider;
+                }
+            }
+            console.log('no provider found');
+        }
+
+        if ( selector instanceof NodeChildSelector ) {
+            const path = selector.try_infer_path();
+            if ( path ) {
+                return this.get_provider(new NodePathSelector(path));
+            } else {
+                return this.get_provider(selector.parent);
+            }
         }
 
         const probe = {};

src/backend/src/modules/puterfs/PuterFSModule.js

@@ -40,6 +40,9 @@ class PuterFSModule extends AdvancedBase {
 
         const DatabaseFSEntryFetcher = require("./DatabaseFSEntryFetcher");
         services.registerService('fsEntryFetcher', DatabaseFSEntryFetcher);
+
+        const { MemoryFSService } = require('./customfs/MemoryFSService');
+        services.registerService('memoryfs', MemoryFSService);
     }
 }