cacache 12.0.2 → 13.0.1

package/lib/entry-index.js

@@ -1,29 +1,25 @@
 'use strict'
 
-const BB = require('bluebird')
+const util = require('util')
 
-const contentPath = require('./content/path')
 const crypto = require('crypto')
 const figgyPudding = require('figgy-pudding')
-const fixOwner = require('./util/fix-owner')
 const fs = require('graceful-fs')
-const hashToSegments = require('./util/hash-to-segments')
-const ms = require('mississippi')
+const Minipass = require('minipass')
 const path = require('path')
 const ssri = require('ssri')
-const Y = require('./util/y.js')
-
+const contentPath = require('./content/path')
+const fixOwner = require('./util/fix-owner')
+const hashToSegments = require('./util/hash-to-segments')
 const indexV = require('../package.json')['cache-version'].index
 
-const appendFileAsync = BB.promisify(fs.appendFile)
-const readFileAsync = BB.promisify(fs.readFile)
-const readdirAsync = BB.promisify(fs.readdir)
-const concat = ms.concat
-const from = ms.from
+const appendFile = util.promisify(fs.appendFile)
+const readFile = util.promisify(fs.readFile)
+const readdir = util.promisify(fs.readdir)
 
 module.exports.NotFoundError = class NotFoundError extends Error {
   constructor (cache, key) {
-    super(Y`No cache entry for \`${key}\` found in \`${cache}\``)
+    super(`No cache entry for ${key} found in ${cache}`)
     this.code = 'ENOENT'
     this.cache = cache
     this.key = key
@@ -36,6 +32,7 @@ const IndexOpts = figgyPudding({
 })
 
 module.exports.insert = insert
+
 function insert (cache, key, integrity, opts) {
   opts = IndexOpts(opts)
   const bucket = bucketPath(cache, key)
@@ -46,34 +43,38 @@ function insert (cache, key, integrity, opts) {
     size: opts.size,
     metadata: opts.metadata
   }
-  return fixOwner.mkdirfix(
-    cache, path.dirname(bucket)
-  ).then(() => {
-    const stringified = JSON.stringify(entry)
-    // NOTE - Cleverness ahoy!
-    //
-    // This works because it's tremendously unlikely for an entry to corrupt
-    // another while still preserving the string length of the JSON in
-    // question. So, we just slap the length in there and verify it on read.
-    //
-    // Thanks to @isaacs for the whiteboarding session that ended up with this.
-    return appendFileAsync(
-      bucket, `\n${hashEntry(stringified)}\t${stringified}`
-    )
-  }).then(
-    () => fixOwner.chownr(cache, bucket)
-  ).catch({ code: 'ENOENT' }, () => {
-    // There's a class of race conditions that happen when things get deleted
-    // during fixOwner, or between the two mkdirfix/chownr calls.
-    //
-    // It's perfectly fine to just not bother in those cases and lie
-    // that the index entry was written. Because it's a cache.
-  }).then(() => {
-    return formatEntry(cache, entry)
-  })
+  return fixOwner
+    .mkdirfix(cache, path.dirname(bucket))
+    .then(() => {
+      const stringified = JSON.stringify(entry)
+      // NOTE - Cleverness ahoy!
+      //
+      // This works because it's tremendously unlikely for an entry to corrupt
+      // another while still preserving the string length of the JSON in
+      // question. So, we just slap the length in there and verify it on read.
+      //
+      // Thanks to @isaacs for the whiteboarding session that ended up with this.
+      return appendFile(bucket, `\n${hashEntry(stringified)}\t${stringified}`)
+    })
+    .then(() => fixOwner.chownr(cache, bucket))
+    .catch((err) => {
+      if (err.code === 'ENOENT') {
+        return undefined
+      }
+      throw err
+      // There's a class of race conditions that happen when things get deleted
+      // during fixOwner, or between the two mkdirfix/chownr calls.
+      //
+      // It's perfectly fine to just not bother in those cases and lie
+      // that the index entry was written. Because it's a cache.
+    })
+    .then(() => {
+      return formatEntry(cache, entry)
+    })
 }
 
 module.exports.insert.sync = insertSync
+
 function insertSync (cache, key, integrity, opts) {
   opts = IndexOpts(opts)
   const bucket = bucketPath(cache, key)
@@ -86,9 +87,7 @@ function insertSync (cache, key, integrity, opts) {
   }
   fixOwner.mkdirfix.sync(cache, path.dirname(bucket))
   const stringified = JSON.stringify(entry)
-  fs.appendFileSync(
-    bucket, `\n${hashEntry(stringified)}\t${stringified}`
-  )
+  fs.appendFileSync(bucket, `\n${hashEntry(stringified)}\t${stringified}`)
   try {
     fixOwner.chownr.sync(cache, bucket)
   } catch (err) {
@@ -100,26 +99,30 @@ function insertSync (cache, key, integrity, opts) {
 }
 
 module.exports.find = find
+
 function find (cache, key) {
   const bucket = bucketPath(cache, key)
-  return bucketEntries(bucket).then(entries => {
-    return entries.reduce((latest, next) => {
-      if (next && next.key === key) {
-        return formatEntry(cache, next)
+  return bucketEntries(bucket)
+    .then((entries) => {
+      return entries.reduce((latest, next) => {
+        if (next && next.key === key) {
+          return formatEntry(cache, next)
+        } else {
+          return latest
+        }
+      }, null)
+    })
+    .catch((err) => {
+      if (err.code === 'ENOENT') {
+        return null
       } else {
-        return latest
+        throw err
       }
-    }, null)
-  }).catch(err => {
-    if (err.code === 'ENOENT') {
-      return null
-    } else {
-      throw err
-    }
-  })
+    })
 }
 
 module.exports.find.sync = findSync
+
 function findSync (cache, key) {
   const bucket = bucketPath(cache, key)
   try {
@@ -140,70 +143,80 @@ function findSync (cache, key) {
 }
 
 module.exports.delete = del
+
 function del (cache, key, opts) {
   return insert(cache, key, null, opts)
 }
 
 module.exports.delete.sync = delSync
+
 function delSync (cache, key, opts) {
   return insertSync(cache, key, null, opts)
 }
 
 module.exports.lsStream = lsStream
+
 function lsStream (cache) {
   const indexDir = bucketDir(cache)
-  const stream = from.obj()
-
-  // "/cachename/*"
-  readdirOrEmpty(indexDir).map(bucket => {
-    const bucketPath = path.join(indexDir, bucket)
-
-    // "/cachename/<bucket 0xFF>/*"
-    return readdirOrEmpty(bucketPath).map(subbucket => {
-      const subbucketPath = path.join(bucketPath, subbucket)
-
-      // "/cachename/<bucket 0xFF>/<bucket 0xFF>/*"
-      return readdirOrEmpty(subbucketPath).map(entry => {
-        const getKeyToEntry = bucketEntries(
-          path.join(subbucketPath, entry)
-        ).reduce((acc, entry) => {
-          acc.set(entry.key, entry)
-          return acc
-        }, new Map())
-
-        return getKeyToEntry.then(reduced => {
-          for (let entry of reduced.values()) {
-            const formatted = formatEntry(cache, entry)
-            formatted && stream.push(formatted)
-          }
-        }).catch({ code: 'ENOENT' }, nop)
-      })
+  const stream = new Minipass({ objectMode: true })
+
+  readdirOrEmpty(indexDir).then(buckets => Promise.all(
+    buckets.map(bucket => {
+      const bucketPath = path.join(indexDir, bucket)
+      return readdirOrEmpty(bucketPath).then(subbuckets => Promise.all(
+        subbuckets.map(subbucket => {
+          const subbucketPath = path.join(bucketPath, subbucket)
+
+          // "/cachename/<bucket 0xFF>/<bucket 0xFF>./*"
+          return readdirOrEmpty(subbucketPath).then(entries => Promise.all(
+            entries.map(entry => {
+              const entryPath = path.join(subbucketPath, entry)
+              return bucketEntries(entryPath).then(entries =>
+                // using a Map here prevents duplicate keys from
+                // showing up twice, I guess?
+                entries.reduce((acc, entry) => {
+                  acc.set(entry.key, entry)
+                  return acc
+                }, new Map())
+              ).then(reduced => {
+                // reduced is a map of key => entry
+                for (const entry of reduced.values()) {
+                  const formatted = formatEntry(cache, entry)
+                  if (formatted) {
+                    stream.write(formatted)
+                  }
+                }
+              }).catch(err => {
+                if (err.code === 'ENOENT') { return undefined }
+                throw err
+              })
+            })
+          ))
+        })
+      ))
     })
-  }).then(() => {
-    stream.push(null)
-  }, err => {
-    stream.emit('error', err)
-  })
+  ))
+    .then(
+      () => stream.end(),
+      err => stream.emit('error', err)
+    )
 
   return stream
 }
 
 module.exports.ls = ls
+
 function ls (cache) {
-  return BB.fromNode(cb => {
-    lsStream(cache).on('error', cb).pipe(concat(entries => {
-      cb(null, entries.reduce((acc, xs) => {
-        acc[xs.key] = xs
-        return acc
-      }, {}))
-    }))
-  })
+  return lsStream(cache).collect().then(entries =>
+    entries.reduce((acc, xs) => {
+      acc[xs.key] = xs
+      return acc
+    }, {})
+  )
 }
 
 function bucketEntries (bucket, filter) {
-  return readFileAsync(
-    bucket, 'utf8'
-  ).then(data => _bucketEntries(data, filter))
+  return readFile(bucket, 'utf8').then((data) => _bucketEntries(data, filter))
 }
 
 function bucketEntriesSync (bucket, filter) {
@@ -212,9 +225,11 @@ function bucketEntriesSync (bucket, filter) {
 }
 
 function _bucketEntries (data, filter) {
-  let entries = []
-  data.split('\n').forEach(entry => {
-    if (!entry) { return }
+  const entries = []
+  data.split('\n').forEach((entry) => {
+    if (!entry) {
+      return
+    }
     const pieces = entry.split('\t')
     if (!pieces[1] || hashEntry(pieces[1]) !== pieces[0]) {
       // Hash is no good! Corruption or malice? Doesn't matter!
@@ -235,25 +250,30 @@ function _bucketEntries (data, filter) {
   return entries
 }
 
-module.exports._bucketDir = bucketDir
+module.exports.bucketDir = bucketDir
+
 function bucketDir (cache) {
   return path.join(cache, `index-v${indexV}`)
 }
 
-module.exports._bucketPath = bucketPath
+module.exports.bucketPath = bucketPath
+
 function bucketPath (cache, key) {
   const hashed = hashKey(key)
-  return path.join.apply(path, [bucketDir(cache)].concat(
-    hashToSegments(hashed)
-  ))
+  return path.join.apply(
+    path,
+    [bucketDir(cache)].concat(hashToSegments(hashed))
+  )
 }
 
-module.exports._hashKey = hashKey
+module.exports.hashKey = hashKey
+
 function hashKey (key) {
   return hash(key, 'sha256')
 }
 
-module.exports._hashEntry = hashEntry
+module.exports.hashEntry = hashEntry
+
 function hashEntry (str) {
   return hash(str, 'sha1')
 }
@@ -267,7 +287,9 @@ function hash (str, digest) {
 
 function formatEntry (cache, entry) {
   // Treat null digests as deletions. They'll shadow any previous entries.
-  if (!entry.integrity) { return null }
+  if (!entry.integrity) {
+    return null
+  }
   return {
     key: entry.key,
     integrity: entry.integrity,
@@ -279,10 +301,11 @@ function formatEntry (cache, entry) {
 }
 
 function readdirOrEmpty (dir) {
-  return readdirAsync(dir)
-    .catch({ code: 'ENOENT' }, () => [])
-    .catch({ code: 'ENOTDIR' }, () => [])
-}
+  return readdir(dir).catch((err) => {
+    if (err.code === 'ENOENT' || err.code === 'ENOTDIR') {
+      return []
+    }
 
-function nop () {
+    throw err
+  })
 }

package/lib/memoization.js

@@ -5,19 +5,14 @@ const LRU = require('lru-cache')
 const MAX_SIZE = 50 * 1024 * 1024 // 50MB
 const MAX_AGE = 3 * 60 * 1000
 
-let MEMOIZED = new LRU({
+const MEMOIZED = new LRU({
   max: MAX_SIZE,
   maxAge: MAX_AGE,
-  length: (entry, key) => {
-    if (key.startsWith('key:')) {
-      return entry.data.length
-    } else if (key.startsWith('digest:')) {
-      return entry.length
-    }
-  }
+  length: (entry, key) => key.startsWith('key:') ? entry.data.length : entry.length
 })
 
 module.exports.clearMemoized = clearMemoized
+
 function clearMemoized () {
   const old = {}
   MEMOIZED.forEach((v, k) => {
@@ -28,22 +23,26 @@ function clearMemoized () {
 }
 
 module.exports.put = put
+
 function put (cache, entry, data, opts) {
   pickMem(opts).set(`key:${cache}:${entry.key}`, { entry, data })
   putDigest(cache, entry.integrity, data, opts)
 }
 
 module.exports.put.byDigest = putDigest
+
 function putDigest (cache, integrity, data, opts) {
   pickMem(opts).set(`digest:${cache}:${integrity}`, data)
 }
 
 module.exports.get = get
+
 function get (cache, key, opts) {
   return pickMem(opts).get(`key:${cache}:${key}`)
 }
 
 module.exports.get.byDigest = getDigest
+
 function getDigest (cache, integrity, opts) {
   return pickMem(opts).get(`digest:${cache}:${integrity}`)
 }
@@ -52,8 +51,14 @@ class ObjProxy {
   constructor (obj) {
     this.obj = obj
   }
-  get (key) { return this.obj[key] }
-  set (key, val) { this.obj[key] = val }
+
+  get (key) {
+    return this.obj[key]
+  }
+
+  set (key, val) {
+    this.obj[key] = val
+  }
 }
 
 function pickMem (opts) {

package/lib/util/disposer.js

@@ -0,0 +1,30 @@
+'use strict'
+
+module.exports.disposer = disposer
+
+function disposer (creatorFn, disposerFn, fn) {
+  const runDisposer = (resource, result, shouldThrow = false) => {
+    return disposerFn(resource)
+      .then(
+        // disposer resolved, do something with original fn's promise
+        () => {
+          if (shouldThrow) {
+            throw result
+          }
+          return result
+        },
+        // Disposer fn failed, crash process
+        (err) => {
+          throw err
+          // Or process.exit?
+        })
+  }
+
+  return creatorFn
+    .then((resource) => {
+      // fn(resource) can throw, so wrap in a promise here
+      return Promise.resolve().then(() => fn(resource))
+        .then((result) => runDisposer(resource, result))
+        .catch((err) => runDisposer(resource, err, true))
+    })
+}

package/lib/util/fix-owner.js

@@ -1,9 +1,9 @@
 'use strict'
 
-const BB = require('bluebird')
+const util = require('util')
 
-const chownr = BB.promisify(require('chownr'))
-const mkdirp = BB.promisify(require('mkdirp'))
+const chownr = util.promisify(require('chownr'))
+const mkdirp = util.promisify(require('mkdirp'))
 const inflight = require('promise-inflight')
 const inferOwner = require('infer-owner')
 
@@ -32,32 +32,44 @@ const getSelf = () => {
 }
 
 module.exports.chownr = fixOwner
+
 function fixOwner (cache, filepath) {
   if (!process.getuid) {
     // This platform doesn't need ownership fixing
-    return BB.resolve()
+    return Promise.resolve()
+  }
+
+  getSelf()
+  if (self.uid !== 0) {
+    // almost certainly can't chown anyway
+    return Promise.resolve()
   }
-  return BB.resolve(inferOwner(cache)).then(owner => {
+
+  return Promise.resolve(inferOwner(cache)).then((owner) => {
     const { uid, gid } = owner
-    getSelf()
 
     // No need to override if it's already what we used.
     if (self.uid === uid && self.gid === gid) {
       return
     }
 
-    return inflight(
-      'fixOwner: fixing ownership on ' + filepath,
-      () => chownr(
+    return inflight('fixOwner: fixing ownership on ' + filepath, () =>
+      chownr(
         filepath,
         typeof uid === 'number' ? uid : self.uid,
         typeof gid === 'number' ? gid : self.gid
-      ).catch({ code: 'ENOENT' }, () => null)
+      ).catch((err) => {
+        if (err.code === 'ENOENT') {
+          return null
+        }
+        throw err
+      })
     )
   })
 }
 
 module.exports.chownr.sync = fixOwnerSync
+
 function fixOwnerSync (cache, filepath) {
   if (!process.getuid) {
     // This platform doesn't need ownership fixing
@@ -65,6 +77,11 @@ function fixOwnerSync (cache, filepath) {
   }
   const { uid, gid } = inferOwner.sync(cache)
   getSelf()
+  if (self.uid !== 0) {
+    // almost certainly can't chown anyway
+    return
+  }
+
   if (self.uid === uid && self.gid === gid) {
     // No need to override if it's already what we used.
     return
@@ -85,24 +102,30 @@ function fixOwnerSync (cache, filepath) {
 }
 
 module.exports.mkdirfix = mkdirfix
+
 function mkdirfix (cache, p, cb) {
   // we have to infer the owner _before_ making the directory, even though
   // we aren't going to use the results, since the cache itself might not
   // exist yet.  If we mkdirp it, then our current uid/gid will be assumed
   // to be correct if it creates the cache folder in the process.
-  return BB.resolve(inferOwner(cache)).then(() => {
-    return mkdirp(p).then(made => {
-      if (made) {
-        return fixOwner(cache, made).then(() => made)
-      }
-    }).catch({ code: 'EEXIST' }, () => {
-      // There's a race in mkdirp!
-      return fixOwner(cache, p).then(() => null)
-    })
+  return Promise.resolve(inferOwner(cache)).then(() => {
+    return mkdirp(p)
+      .then((made) => {
+        if (made) {
+          return fixOwner(cache, made).then(() => made)
+        }
+      })
+      .catch((err) => {
+        if (err.code === 'EEXIST') {
+          return fixOwner(cache, p).then(() => null)
+        }
+        throw err
+      })
   })
 }
 
 module.exports.mkdirfix.sync = mkdirfixSync
+
 function mkdirfixSync (cache, p) {
   try {
     inferOwner.sync(cache)

package/lib/util/hash-to-segments.js

@@ -3,9 +3,5 @@
 module.exports = hashToSegments
 
 function hashToSegments (hash) {
-  return [
-    hash.slice(0, 2),
-    hash.slice(2, 4),
-    hash.slice(4)
-  ]
+  return [hash.slice(0, 2), hash.slice(2, 4), hash.slice(4)]
 }

package/lib/util/move-file.js

@@ -1,13 +1,15 @@
 'use strict'
 
 const fs = require('graceful-fs')
-const BB = require('bluebird')
-const chmod = BB.promisify(fs.chmod)
-const unlink = BB.promisify(fs.unlink)
-let move
-let pinflight
+const util = require('util')
+const chmod = util.promisify(fs.chmod)
+const unlink = util.promisify(fs.unlink)
+const stat = util.promisify(fs.stat)
+const move = require('move-concurrently')
+const pinflight = require('promise-inflight')
 
 module.exports = moveFile
+
 function moveFile (src, dest) {
   // This isn't quite an fs.rename -- the assumption is that
   // if `dest` already exists, and we get certain errors while
@@ -18,34 +20,37 @@ function moveFile (src, dest) {
   // content their own way.
   //
   // Note that, as the name suggests, this strictly only supports file moves.
-  return BB.fromNode(cb => {
-    fs.link(src, dest, err => {
+  return new Promise((resolve, reject) => {
+    fs.link(src, dest, (err) => {
       if (err) {
         if (err.code === 'EEXIST' || err.code === 'EBUSY') {
           // file already exists, so whatever
         } else if (err.code === 'EPERM' && process.platform === 'win32') {
           // file handle stayed open even past graceful-fs limits
         } else {
-          return cb(err)
+          return reject(err)
         }
       }
-      return cb()
+      return resolve()
     })
-  }).then(() => {
-    // content should never change for any reason, so make it read-only
-    return BB.join(unlink(src), process.platform !== 'win32' && chmod(dest, '0444'))
-  }).catch(() => {
-    if (!pinflight) { pinflight = require('promise-inflight') }
-    return pinflight('cacache-move-file:' + dest, () => {
-      return BB.promisify(fs.stat)(dest).catch(err => {
-        if (err.code !== 'ENOENT') {
-          // Something else is wrong here. Bail bail bail
-          throw err
-        }
-        // file doesn't already exist! let's try a rename -> copy fallback
-        if (!move) { move = require('move-concurrently') }
-        return move(src, dest, { BB, fs })
+  })
+    .then(() => {
+      // content should never change for any reason, so make it read-only
+      return Promise.all([
+        unlink(src),
+        process.platform !== 'win32' && chmod(dest, '0444')
+      ])
+    })
+    .catch(() => {
+      return pinflight('cacache-move-file:' + dest, () => {
+        return stat(dest).catch((err) => {
+          if (err.code !== 'ENOENT') {
+            // Something else is wrong here. Bail bail bail
+            throw err
+          }
+          // file doesn't already exist! let's try a rename -> copy fallback
+          return move(src, dest, { Promise, fs })
+        })
       })
     })
-  })
 }