fs: implement mkdir recursive (mkdirp)

Implements mkdirp functionality in node_file.cc. The Benefit of implementing in C++ layer is that the logic is more easily shared between the Promise and callback implementation and there are notable performance improvements. This commit is part of the Tooling Group Initiative. Refs: nodejs/user-feedback#70 PR-URL: #21875 Reviewed-By: Anna Henningsen <[email protected]> Reviewed-By: Matteo Collina <[email protected]> Reviewed-By: Jon Moss <[email protected]> Reviewed-By: Ron Korving <[email protected]> Reviewed-By: James M Snell <[email protected]> Reviewed-By: Michael Dawson <[email protected]> Reviewed-By: Anatoli Papirovski <[email protected]> Reviewed-By: Sam Ruby <[email protected]> Reviewed-By: Joyee Cheung <[email protected]>

Author: Benjamin Coe

benchmark/fs/bench-mkdirp.js

@@ -0,0 +1,23 @@
+'use strict';
+
+constcommon=require('../common');
+constfs=require('fs');
+consttmpdir=require('../../test/common/tmpdir');
+tmpdir.refresh();
+letdirc=0;
+
+constbench=common.createBenchmark(main,{
+n: [1e4],
+});
+
+functionmain({ n }){
+bench.start();
+(functionr(cntr){
+if(cntr--<=0)
+returnbench.end(n);
+constpathname=`${tmpdir.path}/${++dirc}/${++dirc}/${++dirc}/${++dirc}`;
+fs.mkdir(pathname,{createParents: true},(err)=>{
+r(cntr);
+});
+}(n));
+}

doc/api/fs.md

@@ -2042,7 +2042,7 @@ changes:
 
 Synchronous lstat(2).
 
-## fs.mkdir(path[, mode], callback)
+## fs.mkdir(path[, options], callback)
 <!-- YAML
 added: v0.1.8
 changes:
@@ -2061,16 +2061,29 @@ changes:
 -->
 
 *`path`{string|Buffer|URL}
-*`mode`{integer} Not supported on Windows. **Default:**`0o777`.
+*`options`{Object|integer}
+*`recursive`{boolean} **Default:**`false`
+*`mode`{integer} Not supported on Windows. **Default:**`0o777`.
 *`callback`{Function}
 *`err`{Error}
 
 Asynchronously creates a directory. No arguments other than a possible exception
 are given to the completion callback.
 
+The optional `options` argument can be an integer specifying mode (permission
+and sticky bits), or an object with a `mode` property and a `recursive`
+property indicating whether parent folders should be created.
+
+```js
+// Creates /tmp/a/apple, regardless of whether `/tmp` and /tmp/a exist.
+fs.mkdir('/tmp/a/apple',{recursive:true }, (err) =>{
+if (err) throw err;
+});
+```
+
 See also: mkdir(2).
 
-## fs.mkdirSync(path[, mode])
+## fs.mkdirSync(path[, options])
 <!-- YAML
 added: v0.1.21
 changes:
@@ -2081,7 +2094,9 @@ changes:
 -->
 
 *`path`{string|Buffer|URL}
-*`mode`{integer} Not supported on Windows. **Default:**`0o777`.
+*`options`{Object|integer}
+*`recursive`{boolean} **Default:**`false`
+*`mode`{integer} Not supported on Windows. **Default:**`0o777`.
 
 Synchronously creates a directory. Returns `undefined`.
 This is the synchronous version of [`fs.mkdir()`][].
@@ -3974,18 +3989,24 @@ changes:
 Asynchronous lstat(2). The `Promise` is resolved with the [`fs.Stats`][] object
 for the given symbolic link `path`.
 
-### fsPromises.mkdir(path[, mode])
+### fsPromises.mkdir(path[, options])
 <!-- YAML
 added: v10.0.0
 -->
 
 *`path`{string|Buffer|URL}
-*`mode`{integer} **Default:**`0o777`
+*`options`{Object|integer}
+*`recursive`{boolean} **Default:**`false`
+*`mode`{integer} Not supported on Windows. **Default:**`0o777`.
 * Returns:{Promise}
 
 Asynchronously creates a directory then resolves the `Promise` with no
 arguments upon success.
 
+The optional `options` argument can be an integer specifying mode (permission
+and sticky bits), or an object with a `mode` property and a `recursive`
+property indicating whether parent folders should be created.
+
 ### fsPromises.mkdtemp(prefix[, options])
 <!-- YAML
 added: v10.0.0
@@ -4622,7 +4643,7 @@ the file contents.
 [`fs.ftruncate()`]: #fs_fs_ftruncate_fd_len_callback
 [`fs.futimes()`]: #fs_fs_futimes_fd_atime_mtime_callback
 [`fs.lstat()`]: #fs_fs_lstat_path_options_callback
-[`fs.mkdir()`]: #fs_fs_mkdir_path_mode_callback
+[`fs.mkdir()`]: #fs_fs_mkdir_path_options_callback
 [`fs.mkdtemp()`]: #fs_fs_mkdtemp_prefix_options_callback
 [`fs.open()`]: #fs_fs_open_path_flags_mode_callback
 [`fs.read()`]: #fs_fs_read_fd_buffer_offset_length_position_callback

lib/fs.js

@@ -703,29 +703,48 @@ function fsyncSync(fd){
 handleErrorFromBinding(ctx);
 }
 
-functionmkdir(path,mode,callback){
+functionmkdir(path,options,callback){
+if(typeofoptions==='function'){
+callback=options;
+options={};
+}elseif(typeofoptions==='number'||typeofoptions==='string'){
+options={mode: options};
+}
+const{
+ recursive =false,
+ mode =0o777
+}=options||{};
+callback=makeCallback(callback);
 path=getPathFromURL(path);
-validatePath(path);
 
-if(arguments.length<3){
-callback=makeCallback(mode);
-mode=0o777;
-}else{
-callback=makeCallback(callback);
-mode=validateMode(mode,'mode',0o777);
-}
+validatePath(path);
+if(typeofrecursive!=='boolean')
+thrownewERR_INVALID_ARG_TYPE('recursive','boolean',recursive);
 
 constreq=newFSReqWrap();
 req.oncomplete=callback;
-binding.mkdir(pathModule.toNamespacedPath(path),mode,req);
+binding.mkdir(pathModule.toNamespacedPath(path),
+validateMode(mode,'mode',0o777),recursive,req);
 }
 
-functionmkdirSync(path,mode){
+functionmkdirSync(path,options){
+if(typeofoptions==='number'||typeofoptions==='string'){
+options={mode: options};
+}
 path=getPathFromURL(path);
+const{
+ recursive =false,
+ mode =0o777
+}=options||{};
+
 validatePath(path);
-mode=validateMode(mode,'mode',0o777);
+if(typeofrecursive!=='boolean')
+thrownewERR_INVALID_ARG_TYPE('recursive','boolean',recursive);
+
 constctx={ path };
-binding.mkdir(pathModule.toNamespacedPath(path),mode,undefined,ctx);
+binding.mkdir(pathModule.toNamespacedPath(path),
+validateMode(mode,'mode',0o777),recursive,undefined,
+ctx);
 handleErrorFromBinding(ctx);
 }
 

lib/internal/fs/promises.js

@@ -283,11 +283,23 @@ async function fsync(handle){
 returnbinding.fsync(handle.fd,kUsePromises);
 }
 
-asyncfunctionmkdir(path,mode){
+asyncfunctionmkdir(path,options){
+if(typeofoptions==='number'||typeofoptions==='string'){
+options={mode: options};
+}
+const{
+ recursive =false,
+ mode =0o777
+}=options||{};
 path=getPathFromURL(path);
+
 validatePath(path);
-mode=validateMode(mode,'mode',0o777);
-returnbinding.mkdir(pathModule.toNamespacedPath(path),mode,kUsePromises);
+if(typeofrecursive!=='boolean')
+thrownewERR_INVALID_ARG_TYPE('recursive','boolean',recursive);
+
+returnbinding.mkdir(pathModule.toNamespacedPath(path),
+validateMode(mode,'mode',0o777),recursive,
+kUsePromises);
 }
 
 asyncfunctionreaddir(path,options){

src/node_file.cc

@@ -76,6 +76,16 @@ using v8::Value;
 # defineMIN(a, b) ((a) < (b) ? (a) : (b))
 #endif
 
+#ifndef S_ISDIR
+# defineS_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
+#endif
+
+#ifdef __POSIX__
+constchar* kPathSeparator = "/";
+#else
+constchar* kPathSeparator = "\\/";
+#endif
+
 #defineGET_OFFSET(a) ((a)->IsNumber() ? (a).As<Integer>()->Value() : -1)
 #defineTRACE_NAME(name) "fs.sync." #name
 #defineGET_TRACE_ENABLED \
@@ -1148,28 +1158,162 @@ static void RMDir(const FunctionCallbackInfo<Value>& args){
  }
 }
 
+intMKDirpSync(uv_loop_t* loop, uv_fs_t* req, const std::string& path, int mode,
+ uv_fs_cb cb = nullptr){
+ FSContinuationData continuation_data(req, mode, cb);
+ continuation_data.PushPath(std::move(path));
+
+while (continuation_data.paths.size() > 0){
+ std::string next_path = continuation_data.PopPath();
+int err = uv_fs_mkdir(loop, req, next_path.c_str(), mode, nullptr);
+while (true){
+switch (err){
+case0:
+if (continuation_data.paths.size() == 0){
+return0;
+ }
+break;
+case UV_ENOENT:{
+ std::string dirname = next_path.substr(0,
+ next_path.find_last_of(kPathSeparator));
+if (dirname != next_path){
+ continuation_data.PushPath(std::move(next_path));
+ continuation_data.PushPath(std::move(dirname));
+ } elseif (continuation_data.paths.size() == 0){
+ err = UV_EEXIST;
+continue;
+ }
+break;
+ }
+case UV_EPERM:{
+return err;
+ }
+default:
+uv_fs_req_cleanup(req);
+ err = uv_fs_stat(loop, req, next_path.c_str(), nullptr);
+if (err == 0 && !S_ISDIR(req->statbuf.st_mode)) return UV_EEXIST;
+if (err < 0) return err;
+break;
+ }
+break;
+ }
+uv_fs_req_cleanup(req);
+ }
+
+return0;
+}
+
+intMKDirpAsync(uv_loop_t* loop,
+uv_fs_t* req,
+constchar* path,
+int mode,
+ uv_fs_cb cb){
+ FSReqBase* req_wrap = FSReqBase::from_req(req);
+// on the first iteration of algorithm, stash state information.
+if (req_wrap->continuation_data == nullptr){
+ req_wrap->continuation_data = std::unique_ptr<FSContinuationData>{
+newFSContinuationData(req, mode, cb)};
+ req_wrap->continuation_data->PushPath(std::move(path));
+ }
+
+// on each iteration of algorithm, mkdir directory on top of stack.
+ std::string next_path = req_wrap->continuation_data->PopPath();
+int err = uv_fs_mkdir(loop, req, next_path.c_str(), mode,
+uv_fs_callback_t{[](uv_fs_t* req){
+ FSReqBase* req_wrap = FSReqBase::from_req(req);
+ Environment* env = req_wrap->env();
+uv_loop_t* loop = env->event_loop();
+ std::string path = req->path;
+int err = req->result;
+
+while (true){
+switch (err){
+case0:{
+if (req_wrap->continuation_data->paths.size() == 0){
+ req_wrap->continuation_data->Done(0);
+ } else{
+uv_fs_req_cleanup(req);
+MKDirpAsync(loop, req, path.c_str(),
+ req_wrap->continuation_data->mode, nullptr);
+ }
+break;
+ }
+case UV_ENOENT:{
+ std::string dirname = path.substr(0,
+ path.find_last_of(kPathSeparator));
+if (dirname != path){
+ req_wrap->continuation_data->PushPath(std::move(path));
+ req_wrap->continuation_data->PushPath(std::move(dirname));
+ } elseif (req_wrap->continuation_data->paths.size() == 0){
+ err = UV_EEXIST;
+continue;
+ }
+uv_fs_req_cleanup(req);
+MKDirpAsync(loop, req, path.c_str(),
+ req_wrap->continuation_data->mode, nullptr);
+break;
+ }
+case UV_EPERM:{
+ req_wrap->continuation_data->Done(err);
+break;
+ }
+default:
+if (err == UV_EEXIST &&
+ req_wrap->continuation_data->paths.size() > 0){
+uv_fs_req_cleanup(req);
+MKDirpAsync(loop, req, path.c_str(),
+ req_wrap->continuation_data->mode, nullptr);
+ } else{
+// verify that the path pointed to is actually a directory.
+uv_fs_req_cleanup(req);
+int err = uv_fs_stat(loop, req, path.c_str(),
+uv_fs_callback_t{[](uv_fs_t* req){
+ FSReqBase* req_wrap = FSReqBase::from_req(req);
+int err = req->result;
+if (err == 0 && !S_ISDIR(req->statbuf.st_mode)) err = UV_EEXIST;
+ req_wrap->continuation_data->Done(err);
+ }});
+if (err < 0) req_wrap->continuation_data->Done(err);
+ }
+break;
+ }
+break;
+ }
+ }});
+
+return err;
+}
+
 staticvoidMKDir(const FunctionCallbackInfo<Value>& args){
  Environment* env = Environment::GetCurrent(args);
 
 constint argc = args.Length();
-CHECK_GE(argc, 3);
+CHECK_GE(argc, 4);
 
  BufferValue path(env->isolate(), args[0]);
 CHECK_NOT_NULL(*path);
 
 CHECK(args[1]->IsInt32());
 constint mode = args[1].As<Int32>()->Value();
 
- FSReqBase* req_wrap_async = GetReqWrap(env, args[2]);
+CHECK(args[2]->IsBoolean());
+bool mkdirp = args[2]->IsTrue();
+
+ FSReqBase* req_wrap_async = GetReqWrap(env, args[3]);
 if (req_wrap_async != nullptr){// mkdir(path, mode, req)
-AsyncCall(env, req_wrap_async, args, "mkdir", UTF8, AfterNoArgs,
- uv_fs_mkdir, *path, mode);
+AsyncCall(env, req_wrap_async, args, "mkdir", UTF8,
+AfterNoArgs, mkdirp ? MKDirpAsync : uv_fs_mkdir, *path, mode);
  } else{// mkdir(path, mode, undefined, ctx)
-CHECK_EQ(argc, 4);
+CHECK_EQ(argc, 5);
  FSReqWrapSync req_wrap_sync;
 FS_SYNC_TRACE_BEGIN(mkdir);
-SyncCall(env, args[3], &req_wrap_sync, "mkdir",
- uv_fs_mkdir, *path, mode);
+if (mkdirp){
+SyncCall(env, args[4], &req_wrap_sync, "mkdir",
+ MKDirpSync, *path, mode);
+ } else{
+SyncCall(env, args[4], &req_wrap_sync, "mkdir",
+ uv_fs_mkdir, *path, mode);
+ }
 FS_SYNC_TRACE_END(mkdir);
  }
 }