fs: optimize fs.cpSync js calls

PR-URL: #53614
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: anonrig

lib/internal/fs/cp/cp-sync.js

@@ -2,33 +2,25 @@
 
 // This file is a modified version of the fs-extra's copySync method.
 
-const{ areIdentical, isSrcSubdir }=require('internal/fs/cp/cp');
+constfsBinding=internalBinding('fs');
+const{ isSrcSubdir }=require('internal/fs/cp/cp');
 const{codes: {
-ERR_FS_CP_DIR_TO_NON_DIR,
 ERR_FS_CP_EEXIST,
 ERR_FS_CP_EINVAL,
-ERR_FS_CP_FIFO_PIPE,
-ERR_FS_CP_NON_DIR_TO_DIR,
-ERR_FS_CP_SOCKET,
 ERR_FS_CP_SYMLINK_TO_SUBDIRECTORY,
-ERR_FS_CP_UNKNOWN,
-ERR_FS_EISDIR,
 ERR_INVALID_RETURN_VALUE,
 }}=require('internal/errors');
 const{
 os: {
 errno: {
 EEXIST,
-EISDIR,
 EINVAL,
-ENOTDIR,
 },
 },
 }=internalBinding('constants');
 const{
  chmodSync,
  copyFileSync,
- existsSync,
  lstatSync,
  mkdirSync,
  opendirSync,
@@ -42,7 +34,6 @@ const {
  dirname,
  isAbsolute,
  join,
- parse,
  resolve,
 }=require('path');
 const{ isPromise }=require('util/types');
@@ -54,152 +45,46 @@ function cpSyncFn(src, dest, opts) {
 'node is not recommended';
 process.emitWarning(warning,'TimestampPrecisionWarning');
 }
-const{ srcStat, destStat, skipped }=checkPathsSync(src,dest,opts);
-if(skipped)return;
-checkParentPathsSync(src,srcStat,dest);
-returncheckParentDir(destStat,src,dest,opts);
-}
-
-functioncheckPathsSync(src,dest,opts){
 if(opts.filter){
 constshouldCopy=opts.filter(src,dest);
 if(isPromise(shouldCopy)){
 thrownewERR_INVALID_RETURN_VALUE('boolean','filter',shouldCopy);
 }
-if(!shouldCopy)return{__proto__: null,skipped: true};
+if(!shouldCopy)return;
 }
-const{ srcStat, destStat }=getStatsSync(src,dest,opts);
 
-if(destStat){
-if(areIdentical(srcStat,destStat)){
-thrownewERR_FS_CP_EINVAL({
-message: 'src and dest cannot be the same',
-path: dest,
-syscall: 'cp',
-errno: EINVAL,
-code: 'EINVAL',
-});
-}
-if(srcStat.isDirectory()&&!destStat.isDirectory()){
-thrownewERR_FS_CP_DIR_TO_NON_DIR({
-message: `cannot overwrite non-directory ${dest} `+
-`with directory ${src}`,
-path: dest,
-syscall: 'cp',
-errno: EISDIR,
-code: 'EISDIR',
-});
-}
-if(!srcStat.isDirectory()&&destStat.isDirectory()){
-thrownewERR_FS_CP_NON_DIR_TO_DIR({
-message: `cannot overwrite directory ${dest} `+
-`with non-directory ${src}`,
-path: dest,
-syscall: 'cp',
-errno: ENOTDIR,
-code: 'ENOTDIR',
-});
-}
-}
-
-if(srcStat.isDirectory()&&isSrcSubdir(src,dest)){
-thrownewERR_FS_CP_EINVAL({
-message: `cannot copy ${src} to a subdirectory of self ${dest}`,
-path: dest,
-syscall: 'cp',
-errno: EINVAL,
-code: 'EINVAL',
-});
-}
-return{__proto__: null, srcStat, destStat,skipped: false};
-}
+fsBinding.cpSyncCheckPaths(src,dest,opts.dereference,opts.recursive);
 
-functiongetStatsSync(src,dest,opts){
-conststatFunc=opts.dereference ? statSync : lstatSync;
-constsrcStat=statFunc(src,{bigint: true,throwIfNoEntry: true});
-constdestStat=statFunc(dest,{bigint: true,throwIfNoEntry: false});
-return{ srcStat, destStat };
+returngetStats(src,dest,opts);
 }
 
-functioncheckParentPathsSync(src,srcStat,dest){
-constsrcParent=resolve(dirname(src));
-constdestParent=resolve(dirname(dest));
-if(destParent===srcParent||destParent===parse(destParent).root)return;
-constdestStat=statSync(destParent,{bigint: true,throwIfNoEntry: false});
-
-if(destStat===undefined){
-return;
-}
-
-if(areIdentical(srcStat,destStat)){
-thrownewERR_FS_CP_EINVAL({
-message: `cannot copy ${src} to a subdirectory of self ${dest}`,
-path: dest,
-syscall: 'cp',
-errno: EINVAL,
-code: 'EINVAL',
-});
-}
-returncheckParentPathsSync(src,srcStat,destParent);
-}
-
-functioncheckParentDir(destStat,src,dest,opts){
-constdestParent=dirname(dest);
-if(!existsSync(destParent))mkdirSync(destParent,{recursive: true});
-returngetStats(destStat,src,dest,opts);
-}
-
-functiongetStats(destStat,src,dest,opts){
+functiongetStats(src,dest,opts){
+// TODO(@anonrig): Avoid making two stat calls.
 conststatSyncFn=opts.dereference ? statSync : lstatSync;
 constsrcStat=statSyncFn(src);
+constdestStat=statSyncFn(dest,{bigint: true,throwIfNoEntry: false});
 
 if(srcStat.isDirectory()&&opts.recursive){
 returnonDir(srcStat,destStat,src,dest,opts);
-}elseif(srcStat.isDirectory()){
-thrownewERR_FS_EISDIR({
-message: `${src} is a directory (not copied)`,
-path: src,
-syscall: 'cp',
-errno: EINVAL,
-code: 'EISDIR',
-});
 }elseif(srcStat.isFile()||
 srcStat.isCharacterDevice()||
 srcStat.isBlockDevice()){
 returnonFile(srcStat,destStat,src,dest,opts);
 }elseif(srcStat.isSymbolicLink()){
-returnonLink(destStat,src,dest,opts);
-}elseif(srcStat.isSocket()){
-thrownewERR_FS_CP_SOCKET({
-message: `cannot copy a socket file: ${dest}`,
-path: dest,
-syscall: 'cp',
-errno: EINVAL,
-code: 'EINVAL',
-});
-}elseif(srcStat.isFIFO()){
-thrownewERR_FS_CP_FIFO_PIPE({
-message: `cannot copy a FIFO pipe: ${dest}`,
-path: dest,
-syscall: 'cp',
-errno: EINVAL,
-code: 'EINVAL',
-});
+returnonLink(destStat,src,dest,opts.verbatimSymlinks);
 }
-thrownewERR_FS_CP_UNKNOWN({
-message: `cannot copy an unknown file type: ${dest}`,
-path: dest,
-syscall: 'cp',
-errno: EINVAL,
-code: 'EINVAL',
-});
+
+// It is not possible to get here because all possible cases are handled above.
+constassert=require('internal/assert');
+assert.fail('Unreachable code');
 }
 
 functiononFile(srcStat,destStat,src,dest,opts){
 if(!destStat)returncopyFile(srcStat,src,dest,opts);
 returnmayCopyFile(srcStat,src,dest,opts);
 }
 
+// TODO(@anonrig): Move this function to C++.
 functionmayCopyFile(srcStat,src,dest,opts){
 if(opts.force){
 unlinkSync(dest);
@@ -249,6 +134,7 @@ function setDestTimestamps(src, dest) {
 returnutimesSync(dest,updatedSrcStat.atime,updatedSrcStat.mtime);
 }
 
+// TODO(@anonrig): Move this function to C++.
 functiononDir(srcStat,destStat,src,dest,opts){
 if(!destStat)returnmkDirAndCopy(srcStat.mode,src,dest,opts);
 returncopyDir(src,dest,opts);
@@ -260,6 +146,7 @@ function mkDirAndCopy(srcMode, src, dest, opts) {
 returnsetDestMode(dest,srcMode);
 }
 
+// TODO(@anonrig): Move this function to C++.
 functioncopyDir(src,dest,opts){
 constdir=opendirSync(src);
 
@@ -270,17 +157,28 @@ function copyDir(src, dest, opts) {
 const{ name }=dirent;
 constsrcItem=join(src,name);
 constdestItem=join(dest,name);
-const{ destStat, skipped }=checkPathsSync(srcItem,destItem,opts);
-if(!skipped)getStats(destStat,srcItem,destItem,opts);
+letshouldCopy=true;
+
+if(opts.filter){
+shouldCopy=opts.filter(srcItem,destItem);
+if(isPromise(shouldCopy)){
+thrownewERR_INVALID_RETURN_VALUE('boolean','filter',shouldCopy);
+}
+}
+
+if(shouldCopy){
+getStats(srcItem,destItem,opts);
+}
 }
 }finally{
 dir.closeSync();
 }
 }
 
-functiononLink(destStat,src,dest,opts){
+// TODO(@anonrig): Move this function to C++.
+functiononLink(destStat,src,dest,verbatimSymlinks){
 letresolvedSrc=readlinkSync(src);
-if(!opts.verbatimSymlinks&&!isAbsolute(resolvedSrc)){
+if(!verbatimSymlinks&&!isAbsolute(resolvedSrc)){
 resolvedSrc=resolve(dirname(src),resolvedSrc);
 }
 if(!destStat){

src/node_errors.h

@@ -70,6 +70,13 @@ void OOMErrorHandler(const char* location, const v8::OOMDetails& details);
 V(ERR_DLOPEN_FAILED, Error) \
 V(ERR_ENCODING_INVALID_ENCODED_DATA, TypeError) \
 V(ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE, Error) \
+V(ERR_FS_CP_EINVAL, Error) \
+V(ERR_FS_CP_DIR_TO_NON_DIR, Error) \
+V(ERR_FS_CP_NON_DIR_TO_DIR, Error) \
+V(ERR_FS_EISDIR, Error) \
+V(ERR_FS_CP_SOCKET, Error) \
+V(ERR_FS_CP_FIFO_PIPE, Error) \
+V(ERR_FS_CP_UNKNOWN, Error) \
 V(ERR_ILLEGAL_CONSTRUCTOR, Error) \
 V(ERR_INVALID_ADDRESS, Error) \
 V(ERR_INVALID_ARG_VALUE, TypeError) \