cacache 12.0.3 → 14.0.0

package/lib/content/read.js

@@ -1,86 +1,109 @@
 'use strict'
 
-const BB = require('bluebird')
+const util = require('util')
 
-const contentPath = require('./path')
 const figgyPudding = require('figgy-pudding')
 const fs = require('graceful-fs')
-const PassThrough = require('stream').PassThrough
-const pipe = BB.promisify(require('mississippi').pipe)
+const fsm = require('fs-minipass')
 const ssri = require('ssri')
-const Y = require('../util/y.js')
+const contentPath = require('./path')
+const Pipeline = require('minipass-pipeline')
 
-const lstatAsync = BB.promisify(fs.lstat)
-const readFileAsync = BB.promisify(fs.readFile)
+const lstat = util.promisify(fs.lstat)
+const readFile = util.promisify(fs.readFile)
 
 const ReadOpts = figgyPudding({
   size: {}
 })
 
 module.exports = read
+
+const MAX_SINGLE_READ_SIZE = 64 * 1024 * 1024
 function read (cache, integrity, opts) {
   opts = ReadOpts(opts)
   return withContentSri(cache, integrity, (cpath, sri) => {
-    return readFileAsync(cpath, null).then(data => {
-      if (typeof opts.size === 'number' && opts.size !== data.length) {
-        throw sizeError(opts.size, data.length)
-      } else if (ssri.checkData(data, sri)) {
-        return data
-      } else {
+    // get size
+    return lstat(cpath).then(stat => ({ stat, cpath, sri }))
+  }).then(({ stat, cpath, sri }) => {
+    if (typeof opts.size === 'number' && stat.size !== opts.size) {
+      throw sizeError(opts.size, stat.size)
+    }
+    if (stat.size > MAX_SINGLE_READ_SIZE) {
+      return readPipeline(cpath, stat.size, sri, new Pipeline()).concat()
+    }
+
+    return readFile(cpath, null).then((data) => {
+      if (!ssri.checkData(data, sri)) {
         throw integrityError(sri, cpath)
       }
+      return data
     })
   })
 }
 
+const readPipeline = (cpath, size, sri, stream) => {
+  stream.push(
+    new fsm.ReadStream(cpath, {
+      size,
+      readSize: MAX_SINGLE_READ_SIZE
+    }),
+    ssri.integrityStream({
+      integrity: sri,
+      size
+    })
+  )
+  return stream
+}
+
 module.exports.sync = readSync
+
 function readSync (cache, integrity, opts) {
   opts = ReadOpts(opts)
   return withContentSriSync(cache, integrity, (cpath, sri) => {
     const data = fs.readFileSync(cpath)
     if (typeof opts.size === 'number' && opts.size !== data.length) {
       throw sizeError(opts.size, data.length)
-    } else if (ssri.checkData(data, sri)) {
+    }
+
+    if (ssri.checkData(data, sri)) {
       return data
-    } else {
-      throw integrityError(sri, cpath)
     }
+
+    throw integrityError(sri, cpath)
   })
 }
 
 module.exports.stream = readStream
 module.exports.readStream = readStream
+
 function readStream (cache, integrity, opts) {
   opts = ReadOpts(opts)
-  const stream = new PassThrough()
+
+  const stream = new Pipeline()
   withContentSri(cache, integrity, (cpath, sri) => {
-    return lstatAsync(cpath).then(stat => ({ cpath, sri, stat }))
-  }).then(({ cpath, sri, stat }) => {
-    return pipe(
-      fs.createReadStream(cpath),
-      ssri.integrityStream({
-        integrity: sri,
-        size: opts.size
-      }),
-      stream
-    )
-  }).catch(err => {
-    stream.emit('error', err)
-  })
+    // just lstat to ensure it exists
+    return lstat(cpath).then((stat) => ({ stat, cpath, sri }))
+  }).then(({ stat, cpath, sri }) => {
+    if (typeof opts.size === 'number' && opts.size !== stat.size) {
+      return stream.emit('error', sizeError(opts.size, stat.size))
+    }
+    readPipeline(cpath, stat.size, sri, stream)
+  }, er => stream.emit('error', er))
+
   return stream
 }
 
-let copyFileAsync
+let copyFile
 if (fs.copyFile) {
   module.exports.copy = copy
   module.exports.copy.sync = copySync
-  copyFileAsync = BB.promisify(fs.copyFile)
+  copyFile = util.promisify(fs.copyFile)
 }
 
 function copy (cache, integrity, dest, opts) {
   opts = ReadOpts(opts)
   return withContentSri(cache, integrity, (cpath, sri) => {
-    return copyFileAsync(cpath, dest)
+    return copyFile(cpath, dest)
   })
 }
 
@@ -92,13 +115,19 @@ function copySync (cache, integrity, dest, opts) {
 }
 
 module.exports.hasContent = hasContent
+
 function hasContent (cache, integrity) {
-  if (!integrity) { return BB.resolve(false) }
+  if (!integrity) {
+    return Promise.resolve(false)
+  }
   return withContentSri(cache, integrity, (cpath, sri) => {
-    return lstatAsync(cpath).then(stat => ({ size: stat.size, sri, stat }))
-  }).catch(err => {
-    if (err.code === 'ENOENT') { return false }
+    return lstat(cpath).then((stat) => ({ size: stat.size, sri, stat }))
+  }).catch((err) => {
+    if (err.code === 'ENOENT') {
+      return false
+    }
     if (err.code === 'EPERM') {
+      /* istanbul ignore else */
       if (process.platform !== 'win32') {
         throw err
       } else {
@@ -109,15 +138,21 @@ function hasContent (cache, integrity) {
 }
 
 module.exports.hasContent.sync = hasContentSync
+
 function hasContentSync (cache, integrity) {
-  if (!integrity) { return false }
+  if (!integrity) {
+    return false
+  }
   return withContentSriSync(cache, integrity, (cpath, sri) => {
     try {
       const stat = fs.lstatSync(cpath)
       return { size: stat.size, sri, stat }
     } catch (err) {
-      if (err.code === 'ENOENT') { return false }
+      if (err.code === 'ENOENT') {
+        return false
+      }
       if (err.code === 'EPERM') {
+        /* istanbul ignore else */
         if (process.platform !== 'win32') {
           throw err
         } else {
@@ -129,30 +164,58 @@ function hasContentSync (cache, integrity) {
 }
 
 function withContentSri (cache, integrity, fn) {
-  return BB.try(() => {
+  const tryFn = () => {
     const sri = ssri.parse(integrity)
     // If `integrity` has multiple entries, pick the first digest
     // with available local data.
     const algo = sri.pickAlgorithm()
     const digests = sri[algo]
+
     if (digests.length <= 1) {
       const cpath = contentPath(cache, digests[0])
       return fn(cpath, digests[0])
     } else {
-      return BB.any(sri[sri.pickAlgorithm()].map(meta => {
-        return withContentSri(cache, meta, fn)
-      }, { concurrency: 1 }))
-        .catch(err => {
-          if ([].some.call(err, e => e.code === 'ENOENT')) {
-            throw Object.assign(
-              new Error('No matching content found for ' + sri.toString()),
-              { code: 'ENOENT' }
-            )
-          } else {
-            throw err[0]
+      // Can't use race here because a generic error can happen before a ENOENT error, and can happen before a valid result
+      return Promise
+        .all(digests.map((meta) => {
+          return withContentSri(cache, meta, fn)
+            .catch((err) => {
+              if (err.code === 'ENOENT') {
+                return Object.assign(
+                  new Error('No matching content found for ' + sri.toString()),
+                  { code: 'ENOENT' }
+                )
+              }
+              return err
+            })
+        }))
+        .then((results) => {
+          // Return the first non error if it is found
+          const result = results.find((r) => !(r instanceof Error))
+          if (result) {
+            return result
+          }
+
+          // Throw the No matching content found error
+          const enoentError = results.find((r) => r.code === 'ENOENT')
+          if (enoentError) {
+            throw enoentError
           }
+
+          // Throw generic error
+          throw results.find((r) => r instanceof Error)
         })
     }
+  }
+
+  return new Promise((resolve, reject) => {
+    try {
+      tryFn()
+        .then(resolve)
+        .catch(reject)
+    } catch (err) {
+      reject(err)
+    }
   })
 }
 
@@ -167,19 +230,19 @@ function withContentSriSync (cache, integrity, fn) {
     return fn(cpath, digests[0])
   } else {
     let lastErr = null
-    for (const meta of sri[sri.pickAlgorithm()]) {
+    for (const meta of digests) {
       try {
         return withContentSriSync(cache, meta, fn)
       } catch (err) {
         lastErr = err
       }
     }
-    if (lastErr) { throw lastErr }
+    throw lastErr
   }
 }
 
 function sizeError (expected, found) {
-  var err = new Error(Y`Bad data size: expected inserted data to be ${expected} bytes, but got ${found} instead`)
+  const err = new Error(`Bad data size: expected inserted data to be ${expected} bytes, but got ${found} instead`)
   err.expected = expected
   err.found = found
   err.code = 'EBADSIZE'
@@ -187,7 +250,7 @@ function sizeError (expected, found) {
 }
 
 function integrityError (sri, path) {
-  var err = new Error(Y`Integrity verification failed for ${sri} (${path})`)
+  const err = new Error(`Integrity verification failed for ${sri} (${path})`)
   err.code = 'EINTEGRITY'
   err.sri = sri
   err.path = path

package/lib/content/rm.js

@@ -1,19 +1,18 @@
 'use strict'
 
-const BB = require('bluebird')
+const util = require('util')
 
 const contentPath = require('./path')
-const hasContent = require('./read').hasContent
-const rimraf = BB.promisify(require('rimraf'))
+const { hasContent } = require('./read')
+const rimraf = util.promisify(require('rimraf'))
 
 module.exports = rm
+
 function rm (cache, integrity) {
-  return hasContent(cache, integrity).then(content => {
-    if (content) {
-      const sri = content.sri
-      if (sri) {
-        return rimraf(contentPath(cache, sri)).then(() => true)
-      }
+  return hasContent(cache, integrity).then((content) => {
+    // ~pretty~ sure we can't end up with a content lacking sri, but be safe
+    if (content && content.sri) {
+      return rimraf(contentPath(cache, content.sri)).then(() => true)
     } else {
       return false
     }

package/lib/content/write.js

@@ -1,152 +1,175 @@
 'use strict'
 
-const BB = require('bluebird')
+const util = require('util')
 
 const contentPath = require('./path')
 const fixOwner = require('../util/fix-owner')
 const fs = require('graceful-fs')
 const moveFile = require('../util/move-file')
-const PassThrough = require('stream').PassThrough
+const Minipass = require('minipass')
+const Pipeline = require('minipass-pipeline')
+const Flush = require('minipass-flush')
 const path = require('path')
-const pipe = BB.promisify(require('mississippi').pipe)
-const rimraf = BB.promisify(require('rimraf'))
+const rimraf = util.promisify(require('rimraf'))
 const ssri = require('ssri')
-const to = require('mississippi').to
 const uniqueFilename = require('unique-filename')
-const Y = require('../util/y.js')
+const { disposer } = require('./../util/disposer')
+const fsm = require('fs-minipass')
 
-const writeFileAsync = BB.promisify(fs.writeFile)
+const writeFile = util.promisify(fs.writeFile)
 
 module.exports = write
+
 function write (cache, data, opts) {
   opts = opts || {}
   if (opts.algorithms && opts.algorithms.length > 1) {
-    throw new Error(
-      Y`opts.algorithms only supports a single algorithm for now`
-    )
+    throw new Error('opts.algorithms only supports a single algorithm for now')
   }
   if (typeof opts.size === 'number' && data.length !== opts.size) {
-    return BB.reject(sizeError(opts.size, data.length))
+    return Promise.reject(sizeError(opts.size, data.length))
   }
   const sri = ssri.fromData(data, {
     algorithms: opts.algorithms
   })
   if (opts.integrity && !ssri.checkData(data, opts.integrity, opts)) {
-    return BB.reject(checksumError(opts.integrity, sri))
+    return Promise.reject(checksumError(opts.integrity, sri))
   }
-  return BB.using(makeTmp(cache, opts), tmp => (
-    writeFileAsync(
-      tmp.target, data, { flag: 'wx' }
-    ).then(() => (
-      moveToDestination(tmp, cache, sri, opts)
-    ))
-  )).then(() => ({ integrity: sri, size: data.length }))
+
+  return disposer(makeTmp(cache, opts), makeTmpDisposer,
+    (tmp) => {
+      return writeFile(tmp.target, data, { flag: 'wx' })
+        .then(() => moveToDestination(tmp, cache, sri, opts))
+    })
+    .then(() => ({ integrity: sri, size: data.length }))
 }
 
 module.exports.stream = writeStream
-function writeStream (cache, opts) {
-  opts = opts || {}
-  const inputStream = new PassThrough()
-  let inputErr = false
-  function errCheck () {
-    if (inputErr) { throw inputErr }
+
+// writes proxied to the 'inputStream' that is passed to the Promise
+// 'end' is deferred until content is handled.
+class CacacheWriteStream extends Flush {
+  constructor (cache, opts) {
+    super()
+    this.opts = opts
+    this.cache = cache
+    this.inputStream = new Minipass()
+    this.inputStream.on('error', er => this.emit('error', er))
+    this.inputStream.on('drain', () => this.emit('drain'))
+    this.handleContentP = null
   }
 
-  let allDone
-  const ret = to((c, n, cb) => {
-    if (!allDone) {
-      allDone = handleContent(inputStream, cache, opts, errCheck)
+  write (chunk, encoding, cb) {
+    if (!this.handleContentP) {
+      this.handleContentP = handleContent(
+        this.inputStream,
+        this.cache,
+        this.opts
+      )
     }
-    inputStream.write(c, n, cb)
-  }, cb => {
-    inputStream.end(() => {
-      if (!allDone) {
-        const e = new Error(Y`Cache input stream was empty`)
+    return this.inputStream.write(chunk, encoding, cb)
+  }
+
+  flush (cb) {
+    this.inputStream.end(() => {
+      if (!this.handleContentP) {
+        const e = new Error('Cache input stream was empty')
         e.code = 'ENODATA'
-        return ret.emit('error', e)
+        // empty streams are probably emitting end right away.
+        // defer this one tick by rejecting a promise on it.
+        return Promise.reject(e).catch(cb)
       }
-      allDone.then(res => {
-        res.integrity && ret.emit('integrity', res.integrity)
-        res.size !== null && ret.emit('size', res.size)
-        cb()
-      }, e => {
-        ret.emit('error', e)
-      })
+      this.handleContentP.then(
+        (res) => {
+          res.integrity && this.emit('integrity', res.integrity)
+          res.size !== null && this.emit('size', res.size)
+          cb()
+        },
+        (er) => cb(er)
+      )
     })
-  })
-  ret.once('error', e => {
-    inputErr = e
-  })
-  return ret
+  }
 }
 
-function handleContent (inputStream, cache, opts, errCheck) {
-  return BB.using(makeTmp(cache, opts), tmp => {
-    errCheck()
-    return pipeToTmp(
-      inputStream, cache, tmp.target, opts, errCheck
-    ).then(res => {
-      return moveToDestination(
-        tmp, cache, res.integrity, opts, errCheck
-      ).then(() => res)
-    })
+function writeStream (cache, opts) {
+  opts = opts || {}
+  return new CacacheWriteStream(cache, opts)
+}
+
+function handleContent (inputStream, cache, opts) {
+  return disposer(makeTmp(cache, opts), makeTmpDisposer, (tmp) => {
+    return pipeToTmp(inputStream, cache, tmp.target, opts)
+      .then((res) => {
+        return moveToDestination(
+          tmp,
+          cache,
+          res.integrity,
+          opts
+        ).then(() => res)
+      })
   })
 }
 
-function pipeToTmp (inputStream, cache, tmpTarget, opts, errCheck) {
-  return BB.resolve().then(() => {
-    let integrity
-    let size
-    const hashStream = ssri.integrityStream({
-      integrity: opts.integrity,
-      algorithms: opts.algorithms,
-      size: opts.size
-    }).on('integrity', s => {
-      integrity = s
-    }).on('size', s => {
-      size = s
-    })
-    const outStream = fs.createWriteStream(tmpTarget, {
-      flags: 'wx'
-    })
-    errCheck()
-    return pipe(inputStream, hashStream, outStream).then(() => {
-      return { integrity, size }
-    }).catch(err => {
-      return rimraf(tmpTarget).then(() => { throw err })
-    })
+function pipeToTmp (inputStream, cache, tmpTarget, opts) {
+  let integrity
+  let size
+  const hashStream = ssri.integrityStream({
+    integrity: opts.integrity,
+    algorithms: opts.algorithms,
+    size: opts.size
+  })
+  hashStream.on('integrity', i => { integrity = i })
+  hashStream.on('size', s => { size = s })
+
+  const outStream = new fsm.WriteStream(tmpTarget, {
+    flags: 'wx'
   })
+
+  // NB: this can throw if the hashStream has a problem with
+  // it, and the data is fully written.  but pipeToTmp is only
+  // called in promisory contexts where that is handled.
+  const pipeline = new Pipeline(
+    inputStream,
+    hashStream,
+    outStream
+  )
+
+  return pipeline.promise()
+    .then(() => ({ integrity, size }))
+    .catch(er => rimraf(tmpTarget).then(() => { throw er }))
 }
 
 function makeTmp (cache, opts) {
   const tmpTarget = uniqueFilename(path.join(cache, 'tmp'), opts.tmpPrefix)
-  return fixOwner.mkdirfix(
-    cache, path.dirname(tmpTarget)
-  ).then(() => ({
+  return fixOwner.mkdirfix(cache, path.dirname(tmpTarget)).then(() => ({
     target: tmpTarget,
     moved: false
-  })).disposer(tmp => (!tmp.moved && rimraf(tmp.target)))
+  }))
+}
+
+function makeTmpDisposer (tmp) {
+  if (tmp.moved) {
+    return Promise.resolve()
+  }
+  return rimraf(tmp.target)
 }
 
-function moveToDestination (tmp, cache, sri, opts, errCheck) {
-  errCheck && errCheck()
+function moveToDestination (tmp, cache, sri, opts) {
   const destination = contentPath(cache, sri)
   const destDir = path.dirname(destination)
 
-  return fixOwner.mkdirfix(
-    cache, destDir
-  ).then(() => {
-    errCheck && errCheck()
-    return moveFile(tmp.target, destination)
-  }).then(() => {
-    errCheck && errCheck()
-    tmp.moved = true
-    return fixOwner.chownr(cache, destination)
-  })
+  return fixOwner
+    .mkdirfix(cache, destDir)
+    .then(() => {
+      return moveFile(tmp.target, destination)
+    })
+    .then(() => {
+      tmp.moved = true
+      return fixOwner.chownr(cache, destination)
+    })
 }
 
 function sizeError (expected, found) {
-  var err = new Error(Y`Bad data size: expected inserted data to be ${expected} bytes, but got ${found} instead`)
+  const err = new Error(`Bad data size: expected inserted data to be ${expected} bytes, but got ${found} instead`)
   err.expected = expected
   err.found = found
   err.code = 'EBADSIZE'
@@ -154,7 +177,7 @@ function sizeError (expected, found) {
 }
 
 function checksumError (expected, found) {
-  var err = new Error(Y`Integrity check failed:
+  const err = new Error(`Integrity check failed:
   Wanted: ${expected}
    Found: ${found}`)
   err.code = 'EINTEGRITY'