fs/memory-provider: rmdir

Author: XiaochenCui

src/backend/src/filesystem/ll_operations/ll_rmdir.js

@@ -17,21 +17,22 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 const APIError = require("../../api/APIError");
+const { MemoryFSProvider } = require("../../modules/puterfs/customfs/MemoryFSProvider");
 const { ParallelTasks } = require("../../util/otelutil");
 const FSNodeContext = require("../FSNodeContext");
 const { NodeUIDSelector } = require("../node/selectors");
 const { LLFilesystemOperation } = require("./definitions");
 const { LLRmNode } = require('./ll_rmnode');
 
 class LLRmDir extends LLFilesystemOperation {
-    async _run () {
+    async _run() {
         const {
             target,
             user,
             actor,
             descendants_only,
             recursive,
-            
+
             // internal use only - not for clients
             ignore_not_empty,
 
@@ -48,12 +49,12 @@ class LLRmDir extends LLFilesystemOperation {
             this.checkpoint('remove :: access control');
 
             // Check write access to target
-            if ( ! await svc_acl.check(actor, target, 'write') ) {
+            if (! await svc_acl.check(actor, target, 'write')) {
                 throw await svc_acl.get_safe_acl_error(actor, target, 'write');
             }
         }
 
-        if ( await target.get('immutable') && ! descendants_only ) {
+        if (await target.get('immutable') && !descendants_only) {
             throw APIError.create('immutable');
         }
 
@@ -64,20 +65,20 @@ class LLRmDir extends LLFilesystemOperation {
             await target.get('uid')
         );
 
-        if ( children.length > 0 && ! recursive && ! ignore_not_empty ) {
+        if (children.length > 0 && !recursive && !ignore_not_empty) {
             throw APIError.create('not_empty');
         }
 
         const tracer = svc.get('traceService').tracer;
         const tasks = new ParallelTasks({ tracer, max: max_tasks });
 
-        for ( const child_uuid of children ) {
+        for (const child_uuid of children) {
             tasks.add(`fs:rm:rm-child`, async () => {
                 const child_node = await fs.node(
                     new NodeUIDSelector(child_uuid)
                 );
                 const type = await child_node.get('type');
-                if ( type === FSNodeContext.TYPE_DIRECTORY ) {
+                if (type === FSNodeContext.TYPE_DIRECTORY) {
                     const ll_rm = new LLRmDir();
                     await ll_rm.run({
                         target: await fs.node(
@@ -102,14 +103,25 @@ class LLRmDir extends LLFilesystemOperation {
         }
 
         await tasks.awaitAll();
-        if ( ! descendants_only ) {
+        if (target.provider instanceof MemoryFSProvider) {
             await target.provider.rmdir({
                 context,
                 node: target,
                 options: {
-                    ignore_not_empty: true,
+                    recursive,
+                    descendants_only,
                 },
             });
+        } else {
+            if (!descendants_only) {
+                await target.provider.rmdir({
+                    context,
+                    node: target,
+                    options: {
+                        ignore_not_empty: true,
+                    },
+                });
+            }
         }
     }
 }

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

@@ -296,17 +296,39 @@ class MemoryFSProvider {
     async rmdir({ context, node, options = {} }) {
         const inner_path = this._inner_path(node.path);
 
-        // remove all children
+        if ( inner_path.includes('del') ) {
+            console.log('inner_path: ', inner_path);
+        }
+
+        // for mode: non-recursive
+        if ( ! options.recursive ) {
+            const children = await this.readdir({ context, node });
+            if ( children.length > 0 ) {
+                throw APIError.create('not_empty');
+            }
+        }
+
+        // remove all descendants
         for ( const [other_inner_path, other_entry_uuid] of this.entriesByPath ) {
+            if ( other_entry_uuid === node.uid ) {
+                // skip the directory itself
+                continue;
+            }
+
+            console.log('other_inner_path: ', other_inner_path);
+
             if ( other_inner_path.startsWith(inner_path) ) {
                 this.entriesByPath.delete(other_inner_path);
                 this.entriesByUUID.delete(other_entry_uuid);
             }
         }
 
-        // remove the directory itself
-        this.entriesByPath.delete(inner_path);
-        this.entriesByUUID.delete(node.uid);
+        // for mode: non-descendants-only
+        if ( ! options.descendants_only ) {
+            // remove the directory itself
+            this.entriesByPath.delete(inner_path);
+            this.entriesByUUID.delete(node.uid);
+        }
 
         this._integrity_check(node);
     }