'use strict'
|
|
const util = require('util')
|
|
const fs = require('fs')
|
const fsm = require('fs-minipass')
|
const ssri = require('ssri')
|
const contentPath = require('./path')
|
const Pipeline = require('minipass-pipeline')
|
|
const lstat = util.promisify(fs.lstat)
|
const readFile = util.promisify(fs.readFile)
|
|
module.exports = read
|
|
const MAX_SINGLE_READ_SIZE = 64 * 1024 * 1024
|
function read (cache, integrity, opts = {}) {
|
const { size } = opts
|
return withContentSri(cache, integrity, (cpath, sri) => {
|
// get size
|
return lstat(cpath).then(stat => ({ stat, cpath, sri }))
|
}).then(({ stat, cpath, sri }) => {
|
if (typeof size === 'number' && stat.size !== size)
|
throw sizeError(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 = {}) {
|
const { size } = opts
|
return withContentSriSync(cache, integrity, (cpath, sri) => {
|
const data = fs.readFileSync(cpath)
|
if (typeof size === 'number' && size !== data.length)
|
throw sizeError(size, data.length)
|
|
if (ssri.checkData(data, sri))
|
return data
|
|
throw integrityError(sri, cpath)
|
})
|
}
|
|
module.exports.stream = readStream
|
module.exports.readStream = readStream
|
|
function readStream (cache, integrity, opts = {}) {
|
const { size } = opts
|
const stream = new Pipeline()
|
withContentSri(cache, integrity, (cpath, sri) => {
|
// just lstat to ensure it exists
|
return lstat(cpath).then((stat) => ({ stat, cpath, sri }))
|
}).then(({ stat, cpath, sri }) => {
|
if (typeof size === 'number' && size !== stat.size)
|
return stream.emit('error', sizeError(size, stat.size))
|
|
readPipeline(cpath, stat.size, sri, stream)
|
}, er => stream.emit('error', er))
|
|
return stream
|
}
|
|
let copyFile
|
if (fs.copyFile) {
|
module.exports.copy = copy
|
module.exports.copy.sync = copySync
|
copyFile = util.promisify(fs.copyFile)
|
}
|
|
function copy (cache, integrity, dest) {
|
return withContentSri(cache, integrity, (cpath, sri) => {
|
return copyFile(cpath, dest)
|
})
|
}
|
|
function copySync (cache, integrity, dest) {
|
return withContentSriSync(cache, integrity, (cpath, sri) => {
|
return fs.copyFileSync(cpath, dest)
|
})
|
}
|
|
module.exports.hasContent = hasContent
|
|
function hasContent (cache, integrity) {
|
if (!integrity)
|
return Promise.resolve(false)
|
|
return withContentSri(cache, integrity, (cpath, sri) => {
|
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
|
return false
|
}
|
})
|
}
|
|
module.exports.hasContent.sync = hasContentSync
|
|
function hasContentSync (cache, integrity) {
|
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 === 'EPERM') {
|
/* istanbul ignore else */
|
if (process.platform !== 'win32')
|
throw err
|
else
|
return false
|
}
|
}
|
})
|
}
|
|
function withContentSri (cache, integrity, fn) {
|
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 {
|
// 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)
|
}
|
})
|
}
|
|
function withContentSriSync (cache, integrity, fn) {
|
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 {
|
let lastErr = null
|
for (const meta of digests) {
|
try {
|
return withContentSriSync(cache, meta, fn)
|
} catch (err) {
|
lastErr = err
|
}
|
}
|
throw lastErr
|
}
|
}
|
|
function sizeError (expected, found) {
|
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'
|
return err
|
}
|
|
function integrityError (sri, path) {
|
const err = new Error(`Integrity verification failed for ${sri} (${path})`)
|
err.code = 'EINTEGRITY'
|
err.sri = sri
|
err.path = path
|
return err
|
}
|
