chore: rename copyDirectory to moveDirectory

Reflects the change in functionality

Assisted-by: Claude Opus 4.6

Author: dsanders11

lib/copy-directory.js

@@ -6,7 +6,7 @@ const path = require('path')
 
 const RACE_ERRORS = ['ENOTEMPTY', 'EEXIST', 'EBUSY', 'EPERM']
 
-async function copyDirectory (src, dest) {
+async function moveDirectory (src, dest) {
   try {
     await fs.stat(src)
   } catch {
@@ -55,4 +55,4 @@ async function copyDirectory (src, dest) {
   }
 }
 
-module.exports = copyDirectory
+module.exports = moveDirectory

lib/install.js

@@ -8,7 +8,7 @@ const { Transform, promises: { pipeline } } = require('stream')
 const crypto = require('crypto')
 const log = require('./log')
 const semver = require('semver')
-const copyDirectory = require('./copy-directory')
+const moveDirectory = require('./move-directory')
 const { download } = require('./download')
 const processRelease = require('./process-release')
 
@@ -243,7 +243,7 @@ async function install (gyp, argv) {
       }
 
       // copy over the files from the temp tarball extract directory to devDir
-      await copyDirectory(tarExtractDir, devDir)
+      await moveDirectory(tarExtractDir, devDir)
     } finally {
       try {
         // try to cleanup temp dir

lib/move-directory.js

@@ -0,0 +1,58 @@
+'use strict'
+
+const { promises: fs } = require('graceful-fs')
+const crypto = require('crypto')
+const path = require('path')
+
+const RACE_ERRORS = ['ENOTEMPTY', 'EEXIST', 'EBUSY', 'EPERM']
+
+async function moveDirectory (src, dest) {
+  try {
+    await fs.stat(src)
+  } catch {
+    throw new Error(`Missing source directory for move: ${src}`)
+  }
+  await fs.mkdir(dest, { recursive: true })
+  const entries = await fs.readdir(src, { withFileTypes: true })
+  for (const entry of entries) {
+    if (!entry.isDirectory() && !entry.isFile()) {
+      throw new Error('Unexpected file directory entry type')
+    }
+
+    // With parallel installs, multiple processes race to place the same
+    // entry. Use fs.rename for an atomic move so no process ever sees a
+    // partially written file. For cross-filesystem (EXDEV), copy to a
+    // temp path in the dest directory first, then rename within the
+    // same filesystem to keep it atomic.
+    //
+    // When another process wins the race, rename may fail with one of
+    // these codes — all mean the destination was already placed and
+    // are safe to ignore since every process extracts identical content.
+    const srcPath = path.join(src, entry.name)
+    const destPath = path.join(dest, entry.name)
+    try {
+      await fs.rename(srcPath, destPath)
+    } catch (err) {
+      if (RACE_ERRORS.includes(err.code)) {
+        // Another parallel process already placed this entry — ignore
+      } else if (err.code === 'EXDEV') {
+        // Cross-filesystem: copy to a uniquely named temp path in the
+        // dest directory, then rename into place atomically
+        const tmpPath = `${destPath}.tmp.${crypto.randomBytes(6).toString('hex')}`
+        try {
+          await fs.cp(srcPath, tmpPath, { recursive: true })
+          await fs.rename(tmpPath, destPath)
+        } catch (e) {
+          await fs.rm(tmpPath, { recursive: true, force: true }).catch(() => {})
+          if (!RACE_ERRORS.includes(e.code)) {
+            throw e
+          }
+        }
+      } else {
+        throw err
+      }
+    }
+  }
+}
+
+module.exports = moveDirectory

test/test-copy-directory.js

@@ -7,9 +7,9 @@ const fs = require('fs')
 const { promises: fsp } = fs
 const os = require('os')
 const { FULL_TEST, platformTimeout } = require('./common')
-const copyDirectory = require('../lib/copy-directory')
+const moveDirectory = require('../lib/move-directory')
 
-describe('copyDirectory', function () {
+describe('moveDirectory', function () {
   let timer
   let tmpDir
 
@@ -48,7 +48,7 @@ describe('copyDirectory', function () {
     await handle.close()
 
     // Tight synchronous poll: stat the destination on every event-loop
-    // turn while copyDirectory runs concurrently.
+    // turn while moveDirectory runs concurrently.
     let polls = 0
     const violations = []
 
@@ -64,7 +64,7 @@ describe('copyDirectory', function () {
       }
     }, 0)
 
-    await copyDirectory(srcDir, destDir)
+    await moveDirectory(srcDir, destDir)
 
     clearInterval(timer)
     timer = undefined

test/test-move-directory.js

@@ -0,0 +1,80 @@
+'use strict'
+
+const { describe, it, afterEach } = require('mocha')
+const assert = require('assert')
+const path = require('path')
+const fs = require('fs')
+const { promises: fsp } = fs
+const os = require('os')
+const { FULL_TEST, platformTimeout } = require('./common')
+const moveDirectory = require('../lib/move-directory')
+
+describe('moveDirectory', function () {
+  let timer
+  let tmpDir
+
+  afterEach(async () => {
+    if (tmpDir) {
+      await fsp.rm(tmpDir, { recursive: true, force: true })
+      tmpDir = null
+    }
+    clearInterval(timer)
+  })
+
+  it('large file appears atomically (no partial writes visible)', async function () {
+    if (!FULL_TEST) {
+      return this.skip('Skipping due to test environment configuration')
+    }
+
+    this.timeout(platformTimeout(5, { win32: 10 }))
+
+    tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'node-gyp-move-test-'))
+    const srcDir = path.join(tmpDir, 'src')
+    const destDir = path.join(tmpDir, 'dest')
+    await fsp.mkdir(srcDir)
+
+    const fileName = 'large.bin'
+    const srcFile = path.join(srcDir, fileName)
+    const destFile = path.join(destDir, fileName)
+
+    // Create a 5 GB sparse file — instant to create, consumes no real
+    // disk, but fs.copyFile still has to process the full extent map so
+    // the destination file is visible at size 0 and grows over time.
+    // fs.rename() is atomic at the VFS level: the file either does not
+    // exist at the destination or appears at its full size in one step.
+    const fileSize = 5 * 1024 * 1024 * 1024
+    const handle = await fsp.open(srcFile, 'w')
+    await handle.truncate(fileSize)
+    await handle.close()
+
+    // Tight synchronous poll: stat the destination on every event-loop
+    // turn while moveDirectory runs concurrently.
+    let polls = 0
+    const violations = []
+
+    timer = setInterval(() => {
+      try {
+        const stat = fs.statSync(destFile)
+        polls++
+        if (stat.size !== fileSize) {
+          violations.push({ poll: polls, size: stat.size })
+        }
+      } catch (err) {
+        if (err.code !== 'ENOENT') throw err
+      }
+    }, 0)
+
+    await moveDirectory(srcDir, destDir)
+
+    clearInterval(timer)
+    timer = undefined
+
+    console.log(`        ${polls} stats observed the file during the operation`)
+
+    assert.strictEqual(violations.length, 0, 'file must never be observed at a partial size')
+
+    const finalStat = await fsp.stat(destFile)
+    assert.strictEqual(finalStat.size, fileSize,
+      'destination file should have the correct final size')
+  })
+})