| 'use strict' |
| |
| // tar -r |
| const hlo = require('./high-level-opt.js') |
| const Pack = require('./pack.js') |
| const fs = require('fs') |
| const fsm = require('fs-minipass') |
| const t = require('./list.js') |
| const path = require('path') |
| |
| // starting at the head of the file, read a Header |
| // If the checksum is invalid, that's our position to start writing |
| // If it is, jump forward by the specified size (round up to 512) |
| // and try again. |
| // Write the new Pack stream starting there. |
| |
| const Header = require('./header.js') |
| |
| module.exports = (opt_, files, cb) => { |
| const opt = hlo(opt_) |
| |
| if (!opt.file) |
| throw new TypeError('file is required') |
| |
| if (opt.gzip) |
| throw new TypeError('cannot append to compressed archives') |
| |
| if (!files || !Array.isArray(files) || !files.length) |
| throw new TypeError('no files or directories specified') |
| |
| files = Array.from(files) |
| |
| return opt.sync ? replaceSync(opt, files) |
| : replace(opt, files, cb) |
| } |
| |
| const replaceSync = (opt, files) => { |
| const p = new Pack.Sync(opt) |
| |
| let threw = true |
| let fd |
| let position |
| |
| try { |
| try { |
| fd = fs.openSync(opt.file, 'r+') |
| } catch (er) { |
| if (er.code === 'ENOENT') |
| fd = fs.openSync(opt.file, 'w+') |
| else |
| throw er |
| } |
| |
| const st = fs.fstatSync(fd) |
| const headBuf = Buffer.alloc(512) |
| |
| POSITION: for (position = 0; position < st.size; position += 512) { |
| for (let bufPos = 0, bytes = 0; bufPos < 512; bufPos += bytes) { |
| bytes = fs.readSync( |
| fd, headBuf, bufPos, headBuf.length - bufPos, position + bufPos |
| ) |
| |
| if (position === 0 && headBuf[0] === 0x1f && headBuf[1] === 0x8b) |
| throw new Error('cannot append to compressed archives') |
| |
| if (!bytes) |
| break POSITION |
| } |
| |
| const h = new Header(headBuf) |
| if (!h.cksumValid) |
| break |
| const entryBlockSize = 512 * Math.ceil(h.size / 512) |
| if (position + entryBlockSize + 512 > st.size) |
| break |
| // the 512 for the header we just parsed will be added as well |
| // also jump ahead all the blocks for the body |
| position += entryBlockSize |
| if (opt.mtimeCache) |
| opt.mtimeCache.set(h.path, h.mtime) |
| } |
| threw = false |
| |
| streamSync(opt, p, position, fd, files) |
| } finally { |
| if (threw) { |
| try { |
| fs.closeSync(fd) |
| } catch (er) {} |
| } |
| } |
| } |
| |
| const streamSync = (opt, p, position, fd, files) => { |
| const stream = new fsm.WriteStreamSync(opt.file, { |
| fd: fd, |
| start: position, |
| }) |
| p.pipe(stream) |
| addFilesSync(p, files) |
| } |
| |
| const replace = (opt, files, cb) => { |
| files = Array.from(files) |
| const p = new Pack(opt) |
| |
| const getPos = (fd, size, cb_) => { |
| const cb = (er, pos) => { |
| if (er) |
| fs.close(fd, _ => cb_(er)) |
| else |
| cb_(null, pos) |
| } |
| |
| let position = 0 |
| if (size === 0) |
| return cb(null, 0) |
| |
| let bufPos = 0 |
| const headBuf = Buffer.alloc(512) |
| const onread = (er, bytes) => { |
| if (er) |
| return cb(er) |
| bufPos += bytes |
| if (bufPos < 512 && bytes) { |
| return fs.read( |
| fd, headBuf, bufPos, headBuf.length - bufPos, |
| position + bufPos, onread |
| ) |
| } |
| |
| if (position === 0 && headBuf[0] === 0x1f && headBuf[1] === 0x8b) |
| return cb(new Error('cannot append to compressed archives')) |
| |
| // truncated header |
| if (bufPos < 512) |
| return cb(null, position) |
| |
| const h = new Header(headBuf) |
| if (!h.cksumValid) |
| return cb(null, position) |
| |
| const entryBlockSize = 512 * Math.ceil(h.size / 512) |
| if (position + entryBlockSize + 512 > size) |
| return cb(null, position) |
| |
| position += entryBlockSize + 512 |
| if (position >= size) |
| return cb(null, position) |
| |
| if (opt.mtimeCache) |
| opt.mtimeCache.set(h.path, h.mtime) |
| bufPos = 0 |
| fs.read(fd, headBuf, 0, 512, position, onread) |
| } |
| fs.read(fd, headBuf, 0, 512, position, onread) |
| } |
| |
| const promise = new Promise((resolve, reject) => { |
| p.on('error', reject) |
| let flag = 'r+' |
| const onopen = (er, fd) => { |
| if (er && er.code === 'ENOENT' && flag === 'r+') { |
| flag = 'w+' |
| return fs.open(opt.file, flag, onopen) |
| } |
| |
| if (er) |
| return reject(er) |
| |
| fs.fstat(fd, (er, st) => { |
| if (er) |
| return fs.close(fd, () => reject(er)) |
| |
| getPos(fd, st.size, (er, position) => { |
| if (er) |
| return reject(er) |
| const stream = new fsm.WriteStream(opt.file, { |
| fd: fd, |
| start: position, |
| }) |
| p.pipe(stream) |
| stream.on('error', reject) |
| stream.on('close', resolve) |
| addFilesAsync(p, files) |
| }) |
| }) |
| } |
| fs.open(opt.file, flag, onopen) |
| }) |
| |
| return cb ? promise.then(cb, cb) : promise |
| } |
| |
| const addFilesSync = (p, files) => { |
| files.forEach(file => { |
| if (file.charAt(0) === '@') { |
| t({ |
| file: path.resolve(p.cwd, file.substr(1)), |
| sync: true, |
| noResume: true, |
| onentry: entry => p.add(entry), |
| }) |
| } else |
| p.add(file) |
| }) |
| p.end() |
| } |
| |
| const addFilesAsync = (p, files) => { |
| while (files.length) { |
| const file = files.shift() |
| if (file.charAt(0) === '@') { |
| return t({ |
| file: path.resolve(p.cwd, file.substr(1)), |
| noResume: true, |
| onentry: entry => p.add(entry), |
| }).then(_ => addFilesAsync(p, files)) |
| } else |
| p.add(file) |
| } |
| p.end() |
| } |