node package manager

hyperdrive

A file sharing network based on rabin file chunking and append only feeds of data verified by merkle trees.

hyperdrive

A file sharing network based on rabin file chunking and append only feeds of data verified by merkle trees.

npm install hyperdrive

First create a new feed to share

var hyperdrive = require('hyperdrive')
var level = require('level')
 
var db = level('./hyperdrive.db')
var drive = hyperdrive(db)
 
var archive = drive.createArchive()
var ws = archive.createFileWriteStream('hello.txt') // add hello.txt 
 
ws.write('hello')
ws.write('world')
ws.end()
 
archive.finalize(function () { // finalize the archive 
  var link = archive.key.toString('hex')
  console.log(link, '<-- this is your hyperdrive link')
})

Then to share it

var swarm = require('discovery-swarm')()
var hyperdrive = require('hyperdrive')
var level = require('level')
var db = level('./another-hyperdrive.db')
var drive = hyperdrive(db)
 
var link = new Buffer('your-hyperdrive-link-from-the-above-example', 'hex')
var archive = drive.createArchive(link)
 
swarm.listen()
swarm.join(link)
swarm.on('connection', function (connection) {
  connection.pipe(archive.replicate()).pipe(connection)
})

If you run this code on multiple computers you should be able to access the content in the feed by doing

var archive = drive.createArchive(link) // the link identifies/verifies the content 
 
archive.stat(0, function (errentry) { // get the first file entry 
  console.log(entry) // prints {name: 'hello.txt', ...} 
  var stream = archive.createFileReadStream(entry)
  stream.on('data', function (data) {
    console.log(data) // <-- file data 
  })
  stream.on('end', function () {
    console.log('no more data')
  })
})

If you want to write/read files to the file system provide a storage driver as the file option

var raf = require('random-access-file') // a storage driver that writes to the file system 
var archive = drive.createArchive({
  filefunction (name) {
    return raf('my-download-folder/' + name)
  }
})

Create a new hyperdrive instance. db should be a levelup instance.

Creates an archive instance. If you want to download/upload an existing archive provide the archive key as the first argument. Options include

{
  live: false, // set this to share the archive without finalizing it 
  filefunction (name) {
    // set this to determine how file data is stored. 
    // the storage instance should implement the hypercore storage api 
    // https://github.com/mafintosh/hypercore#storage-api 
    return someStorageInstance
  }
}

If you do not provide the file option all file data is stored in the leveldb.

A buffer that verifies the archive content. In live mode this is a 32 byte public key. Otherwise it is a 32 byte hash.

Append an entry to the archive. Only possible if this is an live archive you originally created or an unfinalized archive.

If you set the file option in the archive constructor you can use this method to append an already existing file to the archive.

var archive = drive.createArchive({
  filefunction (name) {
    console.log('returning storage for', name)
    return raf(name)
  }
})
 
archive.append('hello.txt', function () {
  console.log('hello.txt was read and appended')
})

Finalize the archive. You need to do this before sharing it if the archive is not live.

Reads an entry from the archive.

Fully downloads a file / entry from the archive and calls the callback afterwards.

Emitted every time a piece of data is downloaded

Emitted every time a piece of data is uploaded

Returns a readable stream of all entries in the archive.

  • opts.offset - start streaming from this offset (default: 0)
  • opts.live - keep the stream open as new updates arrive (default: false)

You can collect the results of the stream with cb(err, entries).

Returns a readable stream of the file content of an file in the archive.

Returns a writable stream that writes a new file to the archive. Only possible if the archive is live and you own it or if the archive is not finalized.

Pipe this stream together with another peer that is interested in the same archive to replicate the content.

MIT