file-disk

Handles reads / writes on disk image files.

API

Warning: The API exposed by this library is still forming and can change at any time!

FileDisk

new FileDisk(fd, readOnly, recordWrites, recordReads, discardIsZero=true)

• fd is a file descriptor returned by fs.open
• readOnly a boolean (default false)
• recordWrites, a boolean (default false); if you use readOnly without recordWrites, all write requests will be lost.
• recordReads, a boolean (default false): cache reads in memory
• discardIsZero, a boolean (default true): don't read discarded regions, return zero filled buffers instead.

FileDisk.getCapacity(): Promise<Number>

FileDisk.read(buffer, bufferOffset, length, fileOffset): Promise<{ bytesRead: Number, buffer: Buffer }>

• behaves like fs.read

FileDisk.write(buffer, bufferOffset, length, fileOffset): Promise<{ bytesWritten: Number, buffer: Buffer }>

• behaves like fs.write

FileDisk.flush(): Promise<void>

• behaves like fs.fdatasync

FileDisk.discard(offset, length): Promise<void>

FileDisk.getStream([position, [length, [highWaterMark]]]): Promise<stream.Readable>

• position start reading from this offset (defaults to 0)
• length read that amount of bytes (defaults to (disk capacity - position))
• highWaterMark (defaults to 16384, minimum 16) is the size of chunks that will be read

FileDisk.getDiscardedChunks() returns the list of discarded chunks. Each chunk has a start and end properties. end position is inclusive.

FileDisk.getRanges(blockSize): Promise<Range[]>

• using the disk's discarded chunks and the given blockSize, it returns a Promise of an array of Ranges: { offset: number, length: number }.

S3Disk

S3Disk has been moved to a separate repository.

Examples

Read 1024 first bytes, write them starting at position 1024 then flush.

 
const filedisk = require('file-disk');
 
await filedisk.withOpenFile('/path/to/some/file', 'r+', async (handle) => {
    const disk = new filedisk.FileDisk(handle)
 
    // get file size
    const size = await disk.getCapacity();
    console.log("size:", size);
    const buf = Buffer.alloc(1024);
    // read `buf.length` bytes starting at 0 from the file into `buf`
    const { bytesRead, buffer } = await disk.read(buf, 0, buf.length, 0);
    // write `buffer` into file starting at `buffer.length` (in the file)
    await disk.write(buf, 0, buf.length, buf.length);
    // flush
    await disk.flush();
});
 
 

Open a file readOnly, use the recordWrites mode, then stream the contents somewhere.

 
const filedisk = require('file-disk');
 
const BUF = Buffer.alloc(1024);
 
await filedisk.withOpenFile('/path/to/some/file', 'r', async (handle) => {
    const disk = new filedisk.FileDisk(handle, true, true);
    let bytesRead, bytesWritten, buffer;
 
    // read `BUF.length` bytes starting at 0 from the file into `BUF`
    { bytesRead, buffer } = await disk.read(BUF, 0, BUF.length, 0);
    // write `buffer` into file starting at `buffer.length` (in the file)
    { bytesWritten, buffer } = await disk.write(buffer, 0, buffer.length, buffer.length);
    const buf2 = Buffer.alloc(1024);
    // read what we've just written
    { bytesRead, buffer } = await disk.read(buf2, 0, buffer.length, 0);
    // writes are stored in memory
    assert(BUF.equals(buffer));
    const stream = await disk.getStream();
    // pipe the stream somewhere
    await new Promise((resolve, reject) => {
        stream.pipe(someWritableStream)
        .on('close', resolve)
        .on('error', reject);
    });
});