fs/memory-provider: move

Author: XiaochenCui

src/backend/src/filesystem/FSNodeContext.js

@@ -298,6 +298,12 @@ module.exports = class FSNodeContext {
             console.error('entry is undefined');
             this.found = false;
             this.entry = false;
+            let entry_1 = await this.provider.stat({
+                selector: this.selector,
+                options: fetch_entry_options,
+                node: this,
+                controls,
+            });
             return;
         }
 
@@ -377,6 +383,9 @@ module.exports = class FSNodeContext {
     async fetchOwner (force) {
         if ( this.isRoot ) return;
         const owner = await get_user({ id: this.entry.user_id });
+        if ( ! owner ) {
+            console.error('owner is undefined', this.entry);
+        }
         this.entry.owner = {
             username: owner.username,
             email: owner.email,
@@ -746,9 +755,17 @@ module.exports = class FSNodeContext {
         }
         await this.fetchEntry(fetch_options);
 
+        if ( this.entry.id === 123 ) {
+            console.log('this.entry', this.entry);
+        }
+
         const res = this.entry;
         const fsentry = {};
 
+        if ( this.entry === false ) {
+            console.log('this.entry is false', this.entry);
+        }
+
         // This property will not be serialized, but it can be checked
         // by other code to verify that API calls do not send
         // unsanitized filsystem entries.
@@ -761,6 +778,10 @@ module.exports = class FSNodeContext {
             fsentry[k] = res[k];
         }
 
+        if ( this.entry === false ) {
+            console.log('this.entry is false', this.entry);
+        }
+
         let actor; try {
             actor = Context.get('actor');
         } catch (e) {}

src/backend/src/filesystem/hl_operations/hl_move.js

@@ -182,6 +182,9 @@ class HLMove extends HLFilesystemOperation {
         const old_path = await source.get('path');
 
         const ll_move = new LLMove();
+
+        console.log(`source: ${JSON.stringify(source.entry)}`);
+
         const source_new = await ll_move.run({
             source,
             parent,
@@ -190,6 +193,8 @@ class HLMove extends HLFilesystemOperation {
             metadata: metadata,
         });
 
+        console.log(`source_new: ${JSON.stringify(source_new.entry)}`);
+
         await source_new.awaitStableEntry();
         await source_new.fetchSuggestedApps();
         await source_new.fetchOwner();

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

@@ -19,8 +19,14 @@
 const _path = require('path');
 const { PuterPath } = require('../lib/PuterPath');
 
-class NodePathSelector {
+class NodeSelector {
+    path = null;
+    uid = null;
+}
+
+class NodePathSelector extends NodeSelector {
     constructor (path) {
+        super();
         this.value = path;
     }
 
@@ -34,8 +40,9 @@ class NodePathSelector {
     }
 }
 
-class NodeUIDSelector {
+class NodeUIDSelector extends NodeSelector {
     constructor (uid) {
+        super();
         this.value = uid;
     }
 
@@ -58,8 +65,9 @@ class NodeUIDSelector {
     }
 }
 
-class NodeInternalIDSelector {
+class NodeInternalIDSelector extends NodeSelector {
     constructor (service, id, debugInfo) {
+        super();
         this.service = service;
         this.id = id;
         this.debugInfo = debugInfo;
@@ -81,8 +89,9 @@ class NodeInternalIDSelector {
     }
 }
 
-class NodeChildSelector {
+class NodeChildSelector extends NodeSelector {
     constructor (parent, name) {
+        super();
         this.parent = parent;
         this.name = name;
     }
@@ -133,7 +142,7 @@ class NodeChildSelector {
     }
 }
 
-class RootNodeSelector {
+class RootNodeSelector extends NodeSelector {
     static entry = {
         is_dir: true,
         is_root: true,
@@ -146,6 +155,7 @@ class RootNodeSelector {
         node.uid = PuterPath.NULL_UUID;
     }
     constructor () {
+        super();
         this.entry = this.constructor.entry;
     }
 
@@ -154,8 +164,9 @@ class RootNodeSelector {
     }
 }
 
-class NodeRawEntrySelector {
+class NodeRawEntrySelector extends NodeSelector {
     constructor (entry) {
+        super();
         // Fix entries from get_descendants
         if ( ! entry.uuid && entry.uid ) {
             entry.uuid = entry.uid;
@@ -186,7 +197,7 @@ class NodeRawEntrySelector {
  * - path
  * - uid
  *
- * @param {NodePathSelector|NodeUIDSelector|NodeChildSelector|RootNodeSelector} selector
+ * @param {NodeSelector} selector
  */
 function try_infer_attributes (selector) {
     if ( selector instanceof NodePathSelector ) {
@@ -222,6 +233,7 @@ const relativeSelector = (parent, path) => {
 }
 
 module.exports = {
+    NodeSelector,
     NodePathSelector,
     NodeUIDSelector,
     NodeInternalIDSelector,

src/backend/src/helpers.js

@@ -972,7 +972,42 @@ const body_parser_error_handler = (err, req, res, next) => {
     next();
 }
 
+/**
+ * Given a uid, returns a file node.
+ * 
+ * TODO (xiaochen): It only works for MemoryFSProvider currently.
+ * 
+ * @param {string} uid - The uid of the file to get.
+ * @returns {Promise<FileInfo|null>} The file node, or null if the file does not exist.
+ */
+async function get_entry(uid) {
+    const svc_mountpoint = Context.get('services').get('mountpoint');
+    const uid_selector = new NodeUIDSelector(uid);
+    const provider = await svc_mountpoint.get_provider(uid_selector);
+
+    // NB: We cannot import MemoryFSProvider here because it will cause a circular dependency.
+    if ( provider.constructor.name !== 'MemoryFSProvider' ) {
+        return null;
+    }
+
+    return provider.stat({
+        selector: uid_selector,
+    });
+}
+
 async function is_ancestor_of(ancestor_uid, descendant_uid){
+    console.log('is_ancestor_of', ancestor_uid, descendant_uid);
+
+    const ancestor = await get_entry(ancestor_uid);
+    const descendant = await get_entry(descendant_uid);
+
+    if ( ancestor && descendant ) {
+        console.log('ancestor', ancestor);
+        console.log('descendant', descendant);
+        return descendant.path.startsWith(ancestor.path);
+    }
+
+
     /** @type BaseDatabaseAccessService */
     const db = services.get('database').get(DB_READ, 'filesystem');
 

src/backend/src/modules/puterfs/customfs/MemoryFSProvider.js

@@ -22,12 +22,12 @@ const _path = require('path');
 const { Context } = require("../../../util/context");
 const { v4: uuidv4 } = require('uuid');
 const config = require("../../../config");
-const { try_infer_attributes, NodeChildSelector, NodePathSelector } = require("../../../filesystem/node/selectors");
+const { try_infer_attributes, NodeChildSelector, NodePathSelector, NodeSelector } = require("../../../filesystem/node/selectors");
 
 const path = require('path');
 const APIError = require("../../../api/APIError");
 
-class FileInfo {
+class MemoryFile {
     /**
      * @param {Object} param
      * @param {string} param.full_path
@@ -65,6 +65,8 @@ class FileInfo {
         this.created = 123;
         this.accessed = 123;
         this.modified = 123;
+
+        this.own
     }
 }
 
@@ -83,7 +85,7 @@ class MemoryFSProvider {
         // We declare 2 maps to support 2 lookup apis: by-path/by-uuid.
         this.entriesByUUID = new Map();
 
-        const root = new FileInfo({
+        const root = new MemoryFile({
             full_path: '/',
             is_dir: true,
             content: null,
@@ -117,28 +119,25 @@ class MemoryFSProvider {
     /**
      * Check the integrity of the whole memory filesystem and the input. Throws error if any violation is found.
      * 
-     * @param {FSNodeContext} node - The node to check.
+     * @param {MemoryFile} entry - The entry to check.
      * @returns {Promise<void>}
      */
-    _integrity_check (node) {
+    _integrity_check (entry) {
         if ( config.env !== 'dev' ) {
             // only check in debug mode since it's expensive
             return;
         }
 
-        // check the node's provider is "memory-fs"
-        if ( node.provider !== this ) {
-            throw new Error('Node provider mismatch');
-        }
-
-        // check all directories along the path are valid
-        const inner_path = this._inner_path(node.path);
-        const path_components = inner_path.split('/');
-        for ( let i = 2; i < path_components.length; i++ ) {
-            const path_component = path_components.slice(0, i).join('/');
-            const entry_uuid = this.entriesByPath.get(path_component);
-            if ( ! entry_uuid ) {
-                throw new Error(`Directory ${path_component} does not exist`);
+        if ( entry ) {
+            // check all directories along the path are valid
+            const inner_path = this._inner_path(entry.path);
+            const path_components = inner_path.split('/');
+            for ( let i = 2; i < path_components.length; i++ ) {
+                const path_component = path_components.slice(0, i).join('/');
+                const entry_uuid = this.entriesByPath.get(path_component);
+                if ( ! entry_uuid ) {
+                    throw new Error(`Directory ${path_component} does not exist`);
+                }
             }
         }
 
@@ -158,12 +157,11 @@ class MemoryFSProvider {
      * Performs a stat operation on the given FSNode.
      *
      * @param {Object} param
-     * @param {FSNodeContext} param.node - The node to stat.
-     * @returns {Promise<FileInfo|null>} - The result of the stat operation, or `null` if the node doesn't exist.
+     * @param {NodeSelector} param.selector - The selector to stat.
+     * @returns {Promise<MemoryFile|null>} - The result of the stat operation, or `null` if the node doesn't exist.
      */
     async stat ({
         selector,
-        node,
     }) {
         let entry_uuid = null;
 
@@ -226,7 +224,7 @@ class MemoryFSProvider {
         const full_path = _path.join(parent.path, name);
         const inner_path = this._inner_path(full_path);
 
-        const entry = new FileInfo({
+        const entry = new MemoryFile({
             full_path: full_path,
             is_dir: true,
             content: null,
@@ -284,6 +282,42 @@ class MemoryFSProvider {
         this.entriesByUUID.delete(node.uid);
     }
 
+    /**
+     * Move a file.
+     * 
+     * @param {Object} param
+     * @param {Context} param.context
+     * @param {FSNodeContext} param.node: The file to move.
+     * @param {FSNodeContext} param.new_parent: The new parent directory of the file.   
+     * @param {string} param.new_name: The new name of the file.
+     * @param {Object} param.metadata: The metadata of the file.
+     * @returns {Promise<MemoryFile>}
+     */
+    async move({ context, node, new_parent, new_name, metadata }) {
+        this._integrity_check(null);
+
+        // create the new entry
+        const new_full_path = _path.join(new_parent.path, new_name);
+        const new_inner_path = this._inner_path(new_full_path);
+        const entry = new MemoryFile({
+            full_path: new_full_path,
+            is_dir: false,
+            content: node.entry.content,
+        });
+        entry.uuid = node.entry.uuid;
+        this.entriesByPath.set(new_inner_path, entry.uuid);
+        this.entriesByUUID.set(entry.uuid, entry);
+
+        // remove the old entry
+        const inner_path = this._inner_path(node.path);
+        this.entriesByPath.delete(inner_path);
+        // should not delete the entry by uuid because it's the same
+
+        this._integrity_check(entry);
+
+        return entry;
+    }
+
     /**
      * Write a new file to the filesystem. Throws an error if the destination
      * already exists.
@@ -299,7 +333,7 @@ class MemoryFSProvider {
         const full_path = _path.join(parent.path, name);
         const inner_path = this._inner_path(full_path);
 
-        const entry = new FileInfo({
+        const entry = new MemoryFile({
             full_path: full_path,
             is_dir: false,
             content: file.stream.readableBuffer,