Repository: juliangruber/multilevel
Branch: master
Commit: 3fcd263fa39f
Files: 39
Total size: 41.8 KB

Directory structure:
gitextract_a116bzdg/

├── .gitignore
├── .travis.yml
├── History.md
├── Makefile
├── README.md
├── bench/
│   ├── client.js
│   ├── index.js
│   └── write.js
├── example/
│   └── simple.js
├── index.js
├── lib/
│   ├── client.js
│   ├── server.js
│   └── write-manifest.js
├── msgpack.js
├── package.json
└── test/
    ├── access.js
    ├── async-emit-error.js
    ├── async.js
    ├── auth.js
    ├── binary.js
    ├── disabled/
    │   └── events.js
    ├── disconnect.js
    ├── duplex.js
    ├── event.js
    ├── functionInObject.js
    ├── isOpenClosed.js
    ├── live-stream.js
    ├── nested-async.js
    ├── nested-batch.js
    ├── nested-stream.js
    ├── nested.js
    ├── node/
    │   └── manifest.js
    ├── pipe.js
    ├── plugin.js
    ├── reconnect.js
    ├── stream-error.js
    ├── stream.js
    ├── sync.js
    └── util.js

================================================
FILE CONTENTS
================================================

================================================
FILE: .gitignore
================================================
node_modules
test/db
*.sw*
example/.db
test/node/manifest.json

================================================
FILE: .travis.yml
================================================
sudo: false

language: node_js

node_js:
  - "4.0"
  - "3.0"
  - "2.4"
  - "1.8"
  - "1.0"
  - "0.12"


================================================
FILE: History.md
================================================

6.0.1 / 2014-08-18 
==================

 * use npm version of rpc-stream
 * docs
 * make benchmarks runnable
 * add history
 * assert read stream close immediately after conn error
 * close read/write streams on connection failure

6.0.0 / 2014-04-28 
==================

 * add event specialcasing
 * docs


================================================
FILE: Makefile
================================================

BIN=node_modules/.bin

test:
	@$(BIN)/tape test/*.js test/node/*.js

test-browser:
	@echo "open http://localhost:9000/"
	@$(BIN)/browserify test/*.js | $(BIN)/browser-run --port 9000"

.PHONY: test test-browser



================================================
FILE: README.md
================================================
# multilevel

Expose a levelDB over the network, to be used by multiple processes,
with [levelUp](https://github.com/rvagg/node-levelup)'s API.

[![Build Status](https://travis-ci.org/juliangruber/multilevel.svg?branch=master)](https://travis-ci.org/juliangruber/multilevel)
[![downloads](https://img.shields.io/npm/dm/multilevel.svg)](https://www.npmjs.org/package/multilevel)

## Usage

Expose a db on the server:

```js
var multilevel = require('multilevel');
var net = require('net');
var level = require('level');

var db = level('/my/db');

net.createServer(function (con) {
  con.pipe(multilevel.server(db)).pipe(con);
}).listen(3000);
```

And connect to it from the client:

```js
var multilevel = require('multilevel');
var net = require('net');

var db = multilevel.client();
var con = net.connect(3000);
con.pipe(db.createRpcStream()).pipe(con);

// asynchronous methods
db.get('foo', function () { /* */ });

// streams
db.createReadStream().on('data', function () { /* */ });
```

## Compatibility and binary data

multilevel works in the browser too - via
[browserify](https://github.com/substack/node-browserify) - and has full
support for binary data. For getting a connection between browser and server I
recommend either
[websocket-stream](https://github.com/maxogden/websocket-stream), which treats
binary data well, or
[engine.io-stream](https://github.com/Raynos/engine.io-stream), which has
websocket fallbacks.

When using a binary capable transport, require multilevel like this:

```js
var multilevel = require('multilevel/msgpack');
```

This way it uses [msgpack-stream](https://github.com/dominictarr/msgpack-stream)
instead of [json-buffer](https://github.com/dominictarr/json-buffer) which uses
way less bandwidth - but needs a binary capable transport.

## Plugins

You can also expose custom methods and [sublevels](https://github.com/dominictarr/level-sublevel)
with `multilevel`!

When using plugins, you must generate a manifest and require it in the client.

Here's an example:

``` js
// server.js
// create `db`
var level = require('level');
var multilevel = require('multilevel');
var db = level(PATH);

// extend `db` with a foo(cb) method
db.methods = db.methods || {};
db.methods['foo'] = { type: 'async' };
db.foo = function (cb) {
  cb(null, 'bar');
};

// now write the manifest to a file
multilevel.writeManifest(db, __dirname + '/manifest.json');

// then expose `db` via shoe or any other streaming transport.
var shoe = require('shoe');
var sock = shoe(function (stream) {
  stream.pipe(multilevel.server(db)).pipe(stream);
});
sock.install(http.createServer(/* ... */), '/websocket');
```

Manifests are generated using
[level-manifest](https://github.com/dominictarr/level-manifest), which doesn't
only support async functions but e.g. streams as well. For more, check its README.

Then require the manifest on the client when bundling with browserify or in
any other nodejs compatible environment.

``` js
// client.js
// instantiate a multilevel client with the `manifest.json` we just generated
var multilevel = require('multilevel');
var manifest = require('./manifest.json');
var db = multilevel.client(manifest);

// now pipe the db to the server
var stream = shoe('/websocket');
stream.pipe(db.createRpcStream()).pipe(stream);

// and you can call the custom `foo` method!
db.foo(function (err, res) {
  console.log(res); // => "bar"
});
```

## Authentication

You do not want to expose every database feature to every user, you might e.g.
only want to provide read-only access to some users.

Auth controls may be injected when creating the server stream.

In this example, allow read only access, unless logged in as root.

```js
//server.js
var db = require('./setup-db'); //all your database customizations
var multilevel = require('multilevel');

//write out manifest
multilevel.writeManifest(db, __dirname + '/manifest.json');

shoe(function (stream) {
  stream.pipe(multilevel.server(db, {
    auth: function (user, cb) {
      if (user.name == 'root' && user.pass == 'toor') {
        //the data returned will be attached to the mulilevel stream
        //and passed to `access`
        cb(null, {name: 'root'});
      } else {
        cb(new Error('not authorized');
      }
    },
    access: function (user, db, method, args) {
      //`user` is the {name: 'root'} object that `auth`
      //returned. 

      //if not a privliged user...
      if (!user || user.name !== 'root') {
        //do not allow any write access
        if (/^put|^del|^batch|write/i.test(method)) {
          throw new Error('read-only access');
        }
      }        
    })
  })).pipe(stream);
});

// ...
```

The client authorizes by calling the auth method.

``` js
var multilevel = require('multilevel');
var shoe = require('shoe');

var stream = shoe();
var db = multilevel.client();
stream.pipe(db.createRpcStream()).pipe(stream);

db.auth({ name: 'root', pass: 'toor' }, function (err, data) {
  if (err) throw err
  //later, they can sign out, too.

  db.deauth(function (err) {
    //signed out!
  });
});
```

## API

The exposed DB has the exact same API as
[levelUp](https://github.com/rvagg/node-levelup), except

* `db#close()` closes the connection, instead of the database.
* the synchronous versions of `db#isOpen()` and `db#isClose()` tell you if you
currently have a connection to the remote db.
* events, like `db.on("put", ...)` are not emitted. If you need updates, you
can use [level-live-stream](https://github.com/dominictarr/level-live-stream).

### multilevel.server(db[, authOpts])

Returns a server-stream that exposes `db`, an instance of levelUp.
`authOpts` is optional and should be of this form:

``` js
var authOpts = {
  auth: function (userData, cb) {
    //call back an error, if the user is not authorized.
  },
  access: function (userData, db, method, args) {
    //throw if this user is not authorized for this action.
  }
}
```

It is necessary that you create _one server stream per client_.

### multilevel.writeManifest(db, path)

**Synchronoulsy** write `db`'s manifest to `path`.

Also returns the manifest as json.

### var db = multilevel.client([manifest])

Return a new client db. `manifest` may optionally be provided, which will
grant the client access to extensions and sublevels.

#### db.createRpcStream()

Pipe this into a server stream.

Listen for the `error` event on this stream to handle / swallow reconnect events.

#### db.auth(data, cb)

Authorize with the server.

#### db.deauth (cb)

Deauthorize with the server.

## Performance

On my macbook pro one multilevel server handles ~15k ops/s over a local tcp
socket.

```js
 ∴  bench (master) : node index.js 

writing "1234567890abcdef" 100 times

 native             : 2ms (50000 ops/s)
 multilevel direct  : 21ms (4762 ops/s)
 multilevel network : 14ms (7143 ops/s)

writing "1234567890abcdef" 1000 times

 native             : 12ms (83333 ops/s)
 multilevel direct  : 71ms (14085 ops/s)
 multilevel network : 77ms (12987 ops/s)

writing "1234567890abcdef" 10000 times

 native             : 88ms (113636 ops/s)
 multilevel direct  : 594ms (16835 ops/s)
 multilevel network : 590ms (16949 ops/s)

writing "1234567890abcdef" 100000 times

 native             : 927ms (107875 ops/s)
 multilevel direct  : 10925ms (9153 ops/s)
 multilevel network : 9839ms (10164 ops/s)
```

## Installation

With [npm](http://npmjs.org) do:

```bash
$ npm install multilevel
```

## Contributing

```bash
$ npm install
$ npm test
$ npm run test-browser
```

## Contributors

* [@juliangruber](https://github.com/juliangruber)
* [@dominictarr](https://github.com/dominictarr)

## Sponsors

This module is proudly supported by my [Sponsors](https://github.com/juliangruber/sponsors)!

Do you want to support modules like this to improve their quality, stability and weigh in on new features? Then please consider donating to my [Patreon](https://www.patreon.com/juliangruber). Not sure how much of my modules you're using? Try [feross/thanks](https://github.com/feross/thanks)!

## License

(MIT)

Copyright (c) 2013 Julian Gruber <julian@juliangruber.com>

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


================================================
FILE: bench/client.js
================================================
var multilevel = require('..');
var net = require('net');

var port = process.argv[2];
var num = Math.round(Number(process.argv[3]));
var str = process.argv[4];

var write = require('./write')(str);

var db = multilevel.client()
var stream = db.createRpcStream()
var con = net.connect(port)
stream.pipe(con).pipe(stream)

var start = Date.now()
write(db, num, function (err, results) {
  console.log(Date.now() - start)
  con.destroy();
  process.exit(0);
})  


================================================
FILE: bench/index.js
================================================
/**
 * Results:
 *
 * writing "1234567890abcdef" 10000 times
 *
 * native             : 124ms (80645 ops/s)
 * multilevel direct  : 601ms (16639 ops/s)
 * multilevel network : 794ms (12594 ops/s)
 */

var multilevel = require('..')
var levelup = require('levelup')
var rimraf = require('rimraf')
var net = require('net')
var spawn = require('child_process').spawn

var path = '/tmp/multilevel-test-db'
var str = '1234567890abcdef'
var clients = 5

var write = require('./write')(str);

run(1e2, function () {
  run(1e3, function () {
    run(1e4, function () {
      run(1e5)
    })
  })
})

function native (num, cb) {
  getDb(function (err, db) {
    if (err) return cb(err) 
    write(db, num, function (err, results) {
      db.close()
      cb(err, 'native             : ' + results)
    })
  })
}

function fakeNetwork (num, cb) {
  getDb(function (err, db) {
    if (err) return cb(err)

    /*var traffic = 0
    function collect (data) {
      traffic += data.length
    }*/

    var dbs = [];

    for (var i = 0; i < clients; i++) {
      var server = multilevel.server(db)
      var _db = multilevel.client()
      var stream = _db.createRpcStream()
      stream.pipe(server).pipe(stream)
      dbs.push(_db);
    }

    /*server.on('data', collect)
    client.on('data', collect)*/

    setTimeout(function () {
      write(dbs, num, function (err, results) {
        db.close();
        cb(err, 'multilevel direct  : ' + results/* + ', traffic: ' + traffic*/)
      })  
    }, 1000)
  })
}

function realNetwork (num, cb) {
  getDb(function (err, db) {
    if (err) return cb(err)

    var server = net.createServer(function (c) {
      c.pipe(multilevel.server(db)).pipe(c)
    })

    server.listen(5001, function () {
      var exited = 0;
      var duration = 0;
      for (var i = 0; i < clients; i++) {
        var start = Date.now();
        var ps = spawn('node', [__dirname + '/client.js', 5001, num/clients, str]);
        ps.stderr.pipe(process.stderr)
        ps.stdout.on('data', function (data) {
          var _num = Number(data.toString())
          if (_num > duration) duration = _num

          if (++exited == clients) {
            server.close();
            db.close();

            cb(null, 'multilevel network : '
                      + duration + 'ms ('
                      + (Math.round(num/duration*1000))
                      + ' ops/s)')
          }
        })
      }
    })
  })
}

function run (num, cb) {
  console.log('\nwriting "%s" %s times', str, num)

  native(num, function (err, results) {
    log(err, results)
    fakeNetwork(num, function (err, results) {
      log(err, results)
      realNetwork(num, function (err, results) {
        log(err, results)
        if (cb) cb()
      })
    })
  })
}


function log (err, results) {
  if (err) throw err
  console.log(results)
}

function getDb (cb) {
  rimraf.sync(path)
  levelup(path, cb)
}


================================================
FILE: bench/write.js
================================================
module.exports = function (str) {
  return function write (dbs, num, cb) {
    if (!Array.isArray(dbs)) dbs = [dbs];
    var written = 0
    var start = Date.now()

    function rand () {
      return dbs[Math.floor(Math.random() * dbs.length)]
    }

    for (var i = 0; i < num; i++) {
      rand().put(''+i, str, function (err) {
        if (err) {
          var oldCb = cb
          cb = function () {}
          return oldCb(err)
        }
        if (++written == num) {
          var duration = Date.now() - start
          cb(
            null,
            duration + 'ms (' + (Math.round(num/duration*1000)) + ' ops/s)'
          )
        }
      })
    }
  }
};


================================================
FILE: example/simple.js
================================================
var multilevel = require('..');
var level = require('level');

var DB = level(__dirname + '/.db');
var db = multilevel.client();
var server = multilevel.server(DB);
server.pipe(db.createRpcStream()).pipe(server);

db.put('foo', 'bar', function (err) {
  if (err) throw err;
  db.get('foo', function (err, val) {
    if (err) throw err;
    console.log(val);
  });
});


================================================
FILE: index.js
================================================
var MuxDemux = require('mux-demux/jsonb');

module.exports = {
  client: require('./lib/client')(MuxDemux),
  server: require('./lib/server')(MuxDemux),
  writeManifest: require('./lib/write-manifest')
};


================================================
FILE: lib/client.js
================================================
var rpc = require('rpc-stream');
var Emitter = require('events').EventEmitter;
var duplexer = require('duplexer');
var manifest = require('level-manifest');
var combine = require('stream-combiner');
var inherits = require('util').inherits;
var tmpStream = require('tmp-stream');

module.exports = function (MuxDemux) {

function Db (m) {
  if (!(this instanceof Db)) return new Db(m);
  if (!m) m = manifest({ methods: {} });
  Emitter.call(this);

  this.isClient = true;
  this._isOpen = false;
  this.methods = m.methods;

  this.mdm = null;
  this.client = null;
  var self = this;

  this._buildAll(m, this, [], null);
  this.on('pipe', deprecated);
}

inherits(Db, Emitter);

Db.prototype.sublevel = function (name) {
  if (!this.sublevels || !this.sublevels[name]) {
    throw new Error('client cannot create new sublevels');
  }
  return this.sublevels[name];
};

Db.prototype.prefix = function (key) {
  return this._prefix.slice()
};

Db.prototype.createRpcStream = function () {
  var self = this;
  self._isOpen = true;

  var mdm = self.mdm = MuxDemux({ error: true });
  mdm.on('end', function () {
    self._isOpen = false;
    self.emit('close');
  });

  var client = self.client = rpc(null, { raw: true });
  var rpcStream = mdm.createStream('rpc');
  rpcStream.on('error', function () {});
  client.pipe(rpcStream).pipe(client);

  setTimeout(function () {
    self.emit('open');
  });

  return mdm;
};

Db.prototype.close = function (cb) {
  this._isOpen = false;
  if (this.mdm) this.mdm.end();
  if (cb) process.nextTick(cb);
};

Db.prototype.destroy = function () {
  if (this.mdm) this.mdm.close();
};

Db.prototype.auth = function () {
  var args = [].slice.call(arguments);
  var cb = typeof args[args.length - 1] == 'function'
    ? args.pop()
    : function () {};
  this.client.rpc('auth', args, cb);
};

Db.prototype.deauth = function () {
  var args = [].slice.call(arguments);
  var cb = typeof args[args.length - 1] == 'function'
    ? args.pop()
    : function () {};
  this.client.rpc('deauth', args, cb);
};

// EventEmitter special casing, to prevent
// users from listening to db events
// like "put", although they are not supported

var on = Db.prototype.on;
var allowed = [
  'error',
  'pipe',
  'open',
  'close'
];

Db.prototype.addEventListener =
Db.prototype.on = function(ev, fn){
  if (allowed.indexOf(ev) == -1) throw new Error('not supported');
  return on.call(this, ev, fn);
};

Db.prototype.pipe = deprecated;

function deprecated () {
  throw new Error(
    'The API changed. Use db.createRpcStream().'
  );
}


Db.prototype._buildAll = function (_db, db, path, parent) {
  var self = this;
  var m = manifest(_db);

  for (var k in m.methods) {
    var method = m.methods[k];
    var type = method.type;
    var name = path.concat(k).join('!');

    if (type == 'error') throw new Error(method.message || 'not supported');

    if (/async|sync/.test(type)) {
      self._asyncSync(db, k, name);
    } else if (/readable|writable|duplex/.test(type)) {
      self._stream(db, k, name, type);
    } else if (type == 'object') {
      db[k] = new Emitter;
      self._buildAll(method, db[k], path.concat('.' + k));
    }
  }

  db._prefix = path;
  db._parent = parent;

  for (var name in _db.sublevels) {
    var sublevel = _db.sublevels[name];
    db.sublevels = db.sublevels || {};
    db.sublevels[name] = new Db(sublevel);
    self._buildAll(sublevel, db.sublevels[name], path.concat(name), db);
  }
};

Db.prototype._asyncSync = function (db, k, name) {
  var self = this;

  db[k] = function () {
    var args = [].slice.call(arguments);
    var cb = typeof args[args.length - 1] == 'function'
      ? args.pop()
      : null;

    if (/is(Open|Closed)/.test(k) && !cb) {
      if (k == 'isOpen') return self._isOpen;
      else return !self._isOpen;
    }

    if (!cb) cb = function (err) {
      if (err) db.emit('error', err)
    };

    self._queue(function () {
      self.client.rpc(name, args, cb);
    });
  };
};

Db.prototype._stream = function (db, k, name, type) {
  var self = this;

  db[k] = function () {
    var args = [].slice.call(arguments);
    args.unshift(name);

    var tmp = tmpStream();

    self._queue(function () {
      var mdm = self.mdm;
      var ts = (
          type === 'readable'
        ? mdm.createReadStream(args)
        : type == 'writable'
        ? mdm.createWriteStream(args)
        : type == 'duplex'
        ? mdm.createStream(args)
        : (function () { throw new Error('not supported') })()
      );
      ts.autoDestroy = false;
      tmp.replace(ts);
    });

    return tmp;
  };
};

Db.prototype._queue = function (fn) {
  if (this._isOpen) fn();
  else this.once('open', fn);
};

return Db;

};



================================================
FILE: lib/server.js
================================================
var rpc = require('rpc-stream');
var manifest = require('level-manifest');

module.exports = function (MuxDemux) {

return function (db, opts) {
  if (typeof db == 'string') throw new Error('database instance required');

  if('function' === typeof db.sublevel) {
    if(!(db.version >= '6'))
      throw new Error('expected a level-sublevel@6 or greater')
  }

  var mdm = MuxDemux({ error: true });

  opts = opts || {};

  var deauth = opts.deauth || function () {};
  var auth = opts.auth || function () {
    var cb = [].pop.call(arguments);
    cb(null, true);
  };
  var access = opts.access || function () { return true };

  var server = rpc(null, { raw: true, flattenError: flatten });
  var handlers = {};

  (function buildAll (db, path) {
    var m = manifest(db);
    for (var k in m.methods) (function (k) {
      var name = path.concat(k).join('!');
      var method = m.methods[k];

      if (method.type == 'async') {
        server.createLocalCall(name, function (args, cb) {
          access(server.sessionData, db, k, args);
          args.push(cb);
          db[k].apply(db, args);
        });
      } else if (method.type == 'sync') {
        server.createLocalCall(name, function (args, cb) {
          access(server.sessionData, db, k, args);
          var r;
          try { r = db[k].apply(db, args) }
          catch (err) { return cb(err) }
          cb(null, r);
        });
      } else if (method.type == 'object') {
        db[k].methods = method.methods;
        buildAll(db[k], path.concat('.' + k));
      } else {
        handlers[name] = function (args) {
          access(server.sessionData, db, k, args);
          return db[k].apply(db, args);
        };
      }
    })(k);

    for(var name in db.sublevels) {
      buildAll(db.sublevels[name], path.concat(name));
    }
  })(db, []);

  server.createLocalCall('auth', function (args, cb) {
    auth.apply(null, args.concat(function authCb (err, data) {
      if (err) return cb(err);
      server.sessionData = data;
      cb(null, data);
    }));
  });

  server.createLocalCall('deauth', function (args, cb) {
    server.sessionData = null;
    if (opts.deauth) opts.deauth.apply(null, args);
    else cb();
  });

  mdm.on('connection', function (con) {
    con.on('error', function () {});

    if (con.meta == 'rpc') return con.pipe(server).pipe(con);

    try {
      var stream = handlers[con.meta[0]](con.meta.slice(1));
      // prevent iterators from staying open when connection fails
      con.once('error', function () {
        var method = stream[stream.readable ? 'destroy' : 'end']
        if(method) method.call(stream)
      });
      if (stream.readable) stream.pipe(con);
      if (stream.writable) con.pipe(stream);
      stream.on('error', function (err) {
        con.error(flatten(err));
      });
    } catch (err) {
      con.error(flatten(err));
    }
  });

  return mdm;
};

};

function flatten(err){
  if(!(err instanceof Error)) return err;
  var err2 = {
    message: err.message,
    type: err.type,
    notFound: err.notFound,
    status: err.status
  };
  for (var k in err) err2[k] = err[k];
  return err2;
}


================================================
FILE: lib/write-manifest.js
================================================
var fs = require('fs');
var createManifest = require('level-manifest');

module.exports = writeManifest;

function writeManifest (db, path) {
  var manifest = createManifest(db);
  fs.writeFileSync(path, JSON.stringify(manifest, null, 2));
  return manifest;
}


================================================
FILE: msgpack.js
================================================
var MuxDemux = require('mux-demux/msgpack');

module.exports = {
  client: require('./lib/client')(MuxDemux),
  server: require('./lib/server')(MuxDemux),
  writeManifest: require('./lib/write-manifest')
};


================================================
FILE: package.json
================================================
{
  "name": "multilevel",
  "version": "7.2.3",
  "description": "Expose a leveldb over the network.",
  "main": "index.js",
  "scripts": {
    "test": "make test",
    "test-browser": "make test-browser"
  },
  "repository": "git://github.com/juliangruber/multilevel",
  "keywords": [
    "levelup",
    "leveldb",
    "rpc",
    "stream",
    "server",
    "client"
  ],
  "author": "Julian Gruber <julian@juliangruber.com>",
  "license": "MIT",
  "dependencies": {
    "duplexer": "^0.1.1",
    "level-manifest": "^1.2.0",
    "mux-demux": "^3.7.9",
    "rpc-stream": "^2.1.2",
    "stream-combiner": "^0.2.2",
    "tmp-stream": "^0.3.2"
  },
  "devDependencies": {
    "bops": "^1.0.0",
    "level-live-stream": "^1.4.11",
    "level-sublevel": "^6.5.2",
    "level-ws": "0.0.1",
    "memdb": "^1.3.1",
    "tape": "^4.2.2",
    "through": "^2.3.8"
  },
  "engines": {
    "node": ">0.6"
  },
  "testling": {
    "files": "test/*.js",
    "browsers": [
      "ie/8..latest",
      "firefox/17..latest",
      "firefox/nightly",
      "chrome/22..latest",
      "chrome/canary",
      "opera/12..latest",
      "opera/next",
      "safari/5.1..latest",
      "ipad/6.0..latest",
      "iphone/6.0..latest",
      "android-browser/4.2..latest"
    ]
  }
}


================================================
FILE: test/access.js
================================================
require('./util')(function (test, multilevel, getDb) {

  test('access error', function (t) {
    t.plan(2);

    var multilevel = require('..');
    var level = require('memdb');

    var db = level('db');

    var server = multilevel.server(db, {
      access: function () {
        throw new Error('unauthorized');
      }
    });

    var db = multilevel.client();
    server.pipe(db.createRpcStream()).pipe(server);

    db.createReadStream()
      .on('error', function (err) {
        t.ok(err);
        t.equal(err.message, 'unauthorized');
      });
  });

});



================================================
FILE: test/async-emit-error.js
================================================
require('./util')(function (test, _, getDb) {

  test('async emits error', function (t) {
    t.plan(2);
  
    getDb(function (db, dispose) {
      db.get('foo');
      db.on('error', function (err) {
        t.ok(err);
        t.equal(err.type, 'NotFoundError');
        dispose();
      });
    });
  });

});


================================================
FILE: test/async.js
================================================
var getDb = require('./util').getDb
var test = require('tape');

require('./util')(function (test, _, getDb) {

  test('async', function (t) {
    t.plan(1)
  
    getDb(function (db, dispose) {
      db.put('foo', 'bar', function (err) {
        if (err) throw err
        db.get('foo', function (err, value) {
          if (err) throw err
          t.equal(value, 'bar')
          dispose()
        })
      })
    })
  })
  
  test('async error', function (t) {
    t.plan(3)
  
    getDb(function (db, dispose) {
      db.get('foo', function (err) {
        t.ok(err)
        t.ok(err.notFound)
        t.equal(err.type, 'NotFoundError')
      })
    })
  })

})


================================================
FILE: test/auth.js
================================================
require('./util')(function (test, multilevel, getDb) {

  var sublevel = require('level-sublevel');

  var uname = 'user_' + Math.random();
  var pword = 'pw_' + Math.random();
  var opts = {
    auth: function (username, password, cb) {
      if (username == uname && password == pword) {
        cb(null, {name: uname});
      } else {
        cb(new Error('not authorized'));
      }
    },
    access: function (user, db, name, args) {
      if (!user && ~[
        'put', 'batch', 'del',
        'createWriteStream',
        'writeStream'
        ].indexOf(name)) {
        throw new Error('auth() to write');
      }
    }
  };

  test('auth', function (t) {
    t.plan(8);
    
    getDb(function (db) {
      db = sublevel(db);
      db.sublevel('foo');
      t.notOk(db.isClient);
      return {
        opts: opts,
        db: db
      };
    }, 
    function (db, dispose) {
      t.ok(db.isClient);

      db.put('foo', 'not allowed', function (err) {
        t.ok(err);

        db.auth(uname, pword, function (err, user) {
          t.notOk(err);
          t.equal(uname, user.name);

          db.put('foo', 'bar', function (err) {
            t.error(err);

            db.get('foo', function (err, value) {
              t.error(err);
              t.equal(value, 'bar');
              dispose();
            });
          });
        });
      });
    });
  });

  test('auth - nested', function (t) {
    t.plan(7);
    
    getDb(function (db) {
      db = sublevel(db);
      db.sublevel('foo');
      t.notOk(db.isClient);
      return {
        opts: opts,
        db: db
      };
    }, 
    function (db, dispose) {
      t.ok(db.isClient);
      var fooDb = db.sublevel('foo');
      
      fooDb.put('foo', 'not allowed', function (err) {
        t.ok(err, 'not authed');

        db.auth(uname, pword, function (err) {
          t.notOk(err, 'is authed');

          fooDb.put('foo', 'bar', function (err) {
            t.error(err);

            fooDb.get('foo', function (err, value) {
              t.error(err);
              t.equal(value, 'bar');
              dispose();
            });
          });
        });
      });
    });
  });
});


================================================
FILE: test/binary.js
================================================
var getDb = require('./util').getDb;
var test = require('tape');
var binary = require('bops');

require('./util')(function (test, _, getDb) {

  test('binary', function (t) {
    var opts = { valueEncoding : 'binary' };
    getDb(function (db, dispose) {
      db.put('foo', binary.from([1,2,3]), opts, function (err) {
        t.error(err);
        db.get('foo', opts, function (err, value) {
          t.error(err);
          t.ok(binary.is(value));
          t.equal(binary.to(value), binary.to(binary.from([1,2,3])));
          dispose();
          t.end();
        });
      });
    });
  });

})


================================================
FILE: test/disabled/events.js
================================================
var getDb = require('./util').getDb
var test = require('tap').test

test('events', function (t) {
  t.plan(2)
  
  getDb(function (db, dispose) {
    db.on('put', function (key, value) {
      t.equal(key, 'foo')
      t.equal(value, 'bar')
      dispose()
    })

    db.put('foo', 'bar')
  })
})


================================================
FILE: test/disconnect.js
================================================
var getLocalDb = require('./util').getLocalDb;
var through = require('through');
var multilevel = require('..');
var test = require('tape');

test('disconnect', function (t) {
  t.plan(4);

  var db = getLocalDb();
  var server = multilevel.server(db);
  var client = multilevel.client();
  var fakeConnection = through();
  var readStream = db.createReadStream;
  var stream;
  var chunks = 0;

  // get a reference to the server read stream
  db.createReadStream = function () {
    stream = readStream.apply(this, arguments);
    stream.on('data', function () { chunks++ });
    return stream
  };

  setTimeout(function () {
    server.pipe(fakeConnection).pipe(client.createRpcStream()).pipe(server);
    server.on('error',function(){
      t.fail('server emitted error');
    });
  }, 10);

  client.batch([
    { type: 'put', key: 'a', value: "1" },
    { type: 'put', key: 'b', value: "2" },
    { type: 'put', key: 'c', value: "3" }
  ], function (err) {
    t.error(err, 'batch written');

    var errored = false;
    client.createReadStream()
      .on('data',function(data){
        t.equals(data.value, '1', 'data received');
        fakeConnection.destroy();
      })
      .on('error',function (error) {
        errored = true;
        var hasDisconnect = error.message.indexOf('disconnect') > -1;
        t.ok(hasDisconnect, 'emitted disconnect error');
      });

    stream.on('close', function () {
      t.equals(chunks, 1, 'database read stream closed');
    });
  });

});


================================================
FILE: test/duplex.js
================================================
var sublevel = require('level-sublevel')
var MuxDemux = require('mux-demux')

require('./util')(function (test, _, getDb) {

  test('duplex stream exposed', function (t) {
    t.plan(1)
  
    getDb(function (db, dispose) {
      var db = sublevel(db)
      var bar = db.sublevel('bar')

      // add method so it's included in the manifest
      bar.methods['dup'] = {type: 'duplex'}

      bar.dup = MuxDemux().createStream

      return { db: db }
    },
    function (db, dispose) {
      var bar = db.sublevels['bar']
      var dStream = bar.dup()
      t.ok(dStream.write({ key : 'bar', value : 'baz' }));
    })
  })
})


================================================
FILE: test/event.js
================================================

var getDb = require('./util').getDb
var test = require('tape');

require('./util')(function (test, _, getDb) {

  test('event', function (t) {
    t.plan(1)
  
    getDb(function (db, dispose) {
      t.throws(function(){
        db.on('put', function(){});
      })
    })
  })

})


================================================
FILE: test/functionInObject.js
================================================
var getDb = require('./util').getDb;
var test = require('tape');

require('./util')(function (test, _, getDb) {

  var obj = {
    getImage: function () {},
    a: 2
  };

  test('function in json', function (t) {
    t.plan(3);
  
    getDb(function (db, dispose) {
      db.put('foo', obj, { valueEncoding: 'json' }, function (err) {
        t.error(err);
        db.get('foo', { valueEncoding: 'json' }, function (err, val) {
          t.error(err);
          t.equal(val.a, 2);
          dispose();
        });
      });
    });
  });

});


================================================
FILE: test/isOpenClosed.js
================================================
require('./util')(function (test, _, getDb) {

  test('sync isOpen / isClosed with sync close', function (t) {
    t.plan(4);

    getDb(function (db, dispose) {
      t.ok(db.isOpen());
      t.notOk(db.isClosed());

      db.close();

      t.notOk(db.isOpen());
      t.ok(db.isClosed());

      dispose();
    });
  });

  test('sync isOpen / isClosed with async close', function (t) {
    t.plan(5);

    getDb(function (db, dispose) {
      t.ok(db.isOpen());
      t.notOk(db.isClosed());

      db.close(function(err) {
        t.error(err);

        t.notOk(db.isOpen());
        t.ok(db.isClosed());

        dispose();
      });
    });
  });

});


================================================
FILE: test/live-stream.js
================================================
require('./util')(function (test, _, getDb) {

  var sublevel = require('level-sublevel');
  var LiveStream = require('level-live-stream');

  test('stream', function (t) {
    t.plan(20);
    var j = 10;

    getDb(function (db) {
      db = sublevel(db);
      LiveStream.install(db.sublevel('foo'));
      return { db: db };
    },
    function (db, dispose) {
      var foo = db.sublevel('foo');
      var ls = foo.liveStream();
      ls.on('data', function (d) {
        t.equal(j-- * 1000, Number(d.value));

        if (j) return;

        ls.destroy();
        dispose();
      });
      ls.on('error', function () {});

      setTimeout(function() {
        var i = 10;
        var id = setInterval(function () {
          foo.put(i, i*1000, function (err) {
            t.error(err);
          });
          if (--i) return;
          clearInterval(id);
        }, 0);
      }, 10);
    });
  });
});



================================================
FILE: test/nested-async.js
================================================

var sublevel = require('level-sublevel')

require('./util')(function (test, _, getDb) {
  test('async', function (t) {
    t.plan(3)
  
    getDb(function (db) {
      db = sublevel(db)
      db.sublevel('foo')
      t.notOk(db.isClient)
      return { db: db }
    }, 
    function (db, dispose) {
      t.ok(db.isClient)
      db.sublevels['foo'].put('foo', 'bar', function (err) {
        if (err) throw err
        db.sublevels['foo'].get('foo', function (err, value) {
          if (err) throw err
          t.equal(value, 'bar')
          dispose()
        })
      })
    })
  })
})


================================================
FILE: test/nested-batch.js
================================================
var getDb = require('./util').getDb
var test = require('tape')
var sublevel = require('level-sublevel')

require('./util')(function (test, _, getDb) {

  test('async', function (t) {
    t.plan(2)

    getDb(function (db) {
      db = sublevel(db)
      db.sublevel('foo')
      db.sublevel('bar')
      return { db: db }
    }, 
    function (db, dispose) {
      db.sublevel('foo').batch([
        {key:'f', value:'1', type: 'put'},
        {key:'b', value:'2', type: 'put', prefix: db.sublevel('bar').prefix()}
      ],
      function (err) {
        if (err) throw err
        db.sublevel('foo').get('f', function (err, value) {
          if (err) throw err
          t.equal(value, '1')
          db.sublevel('bar').get('b', function (err, value) {
            if (err) throw err
            t.equal(value, '2')
            dispose()
          })
        })
      })
    })
  })

})


================================================
FILE: test/nested-stream.js
================================================
var getDb = require('./util').getDb
var test = require('tape')
var sublevel = require('level-sublevel')

require('./util')(function (test, _, getDb) {

  test('nested-stream', function (t) {
    t.plan(4)

    getDb(function (db) {
      db = sublevel(db)
      db.sublevel('foo')
      return { db: db }
    },
    function (db, dispose) {
      db = db.sublevels['foo'];
      db.put('foo', 'bar', function (err) {
        if (err) throw err
        db.createReadStream()
        .on('data', function (data) {
          t.equal(data.key, 'foo')
          t.equal(data.value, 'bar')
        })
        .on('end', function () {
          db.batch([
            { key : 'bar', value : 'baz' }
          ], function (err) {
            if(err) throw err
            // temporary fix for level-js
            setTimeout(function () {
              db.get('bar', function (err, value) {
                t.notOk(err);
                t.equal(value, 'baz');
                dispose();
              });
            }, 100);
          })
        })
      })
    })
  })
})


================================================
FILE: test/nested.js
================================================
require('./util')(function (test, _, getDb) {

  var Emitter = require('events').EventEmitter;

  test('nested', function (t) {
    t.plan(10);

    getDb(function (db) {
      db.nested = {
        get: function(cb) { cb(null, 'hola') },
        deeper: {
          get: function(cb) { cb(null, 'ola') }
        }
      };
      db.methods = {
        nested: {
          type: 'object',
          methods: {
            get: { type: 'async' },
            deeper: {
              type: 'object',
              methods: {
                get: { type: 'async' }
              }
            }
          }
        }
      };
      return { db: db };
    },
    function (db, dispose) {
      t.ok(db.nested, 'has nested');
      t.ok(db.nested instanceof Emitter, 'nested is emitter');
      t.ok(db.nested.get, 'has nested.get');
      t.ok(db.nested.deeper, 'has nested.deeper');
      t.ok(db.nested.deeper instanceof Emitter, 'nested.deeper is emitter');
      t.ok(db.nested.deeper.get, 'has nested.deeper.get');
      
      db.nested.get(function(err, value) {
        t.error(err, 'nested.get without error');
        t.equal(value, 'hola', 'nested.get has value');
        
        db.nested.deeper.get(function(err, value) {
          t.error(err, 'nested.deeper.get without error');
          t.equal(value, 'ola', 'nested.deeper.get has value');
        });
      });
    });
  });
});



================================================
FILE: test/node/manifest.js
================================================
var test = require('tape');
var writeManifest = require('../..').writeManifest;
var MemDB = require('memdb');

test('write manifest', function (t) {
  var db = MemDB();
  var result = writeManifest(db, __dirname + '/manifest.json');
  var manifest = require('./manifest.json');
  t.ok(manifest);
  t.deepEqual(result, manifest);
  t.end();
});


================================================
FILE: test/pipe.js
================================================
var Stream = require('stream');

require('./util')(function (test, _, getDb) {

  test('pipe', function (t) {
    t.plan(2);
  
    getDb(function (db, dispose) {
      t.throws(function () {
        db.pipe();
      });
      t.throws(function () {
        (new Stream()).pipe(db);
      });
      dispose();
    });
  });
});


================================================
FILE: test/plugin.js
================================================
var sublevel = require('level-sublevel')

require('./util')(function (test, _, getDb) {

  test('stream', function (t) {
    t.plan(2)
  
    getDb(function (db) {
      db = sublevel(db)
      var foo = db.sublevel('foo')

      //add inc to the manifest
      foo.methods['inc'] = {type: 'async'}

      //implement it
      foo.inc = function (f, cb) {
        if(!cb) {
          cb = f
          foo.get('inc', function (err, val) {
            cb(err, val)
          })
        } else {
          foo.get('inc', function (err, val) {
            val = Number(val || 0) + Number(f)
            foo.put('inc', val, function (err) {
              if(err) cb(err)
              else    cb(null, val)
            })
          })
        }
      }

      return { db: db }
    },
    function (db, dispose) {
      var foo = db.sublevels['foo']
      foo.inc(1, function (err, val) {
        t.equal(val, 1)
        foo.inc(2, function (err, val) {
          t.equal(val, 3)
          t.end()
          dispose()
        })
      })
    })
  })

})


================================================
FILE: test/reconnect.js
================================================
var multitest = require('./util')
var getLocalDb = multitest.getLocalDb

multitest(function (test, multilevel) {

  test('reconnect', function (t) {
    t.plan(3);

    var db = getLocalDb();
    var server = multilevel.server(db);
    var client = multilevel.client();

    setTimeout(function () {
      var rpc = client.createRpcStream();
      server.pipe(client.createRpcStream()).pipe(server);
    }, 10);

    client.put('foo', 'bar', function (err) {
      t.error(err);
      client.get('foo', function (err, val) {
        t.error(err);
        t.equals(val, 'bar');
        db.close();
      });
    });
  });

});


================================================
FILE: test/stream-error.js
================================================
var multilevel = require('..');
var through = require('through');
var MemDB = require('memdb');

require('./util')(function (test) {

  test('stream error', function (t) {
    var db = {};
    db.createReadStream = function(){
      var stream = through();
      process.nextTick(function(){
        stream.emit('error', new Error('oops'));
      });
      return stream;
    };

    var server = multilevel.server(db);
    var client = multilevel.client();
    server.pipe(client.createRpcStream()).pipe(server);

    var stream = client.createReadStream();
    stream.on('error', function(err){
      t.equal(err.message, 'oops');
      t.end();
    });
  });
});



================================================
FILE: test/stream.js
================================================
var levelws = require('level-ws');

require('./util')(function (test, _, getDb) {

  test('stream', function (t) {
    t.plan(5);

    getDb(function (db, dispose) {
      levelws(db);

      db.put('foo', 'bar', function (err) {
        t.error(err);

        db.readStream()
        .on('data', function (data) {
          t.equal(data.key, 'foo');
          t.equal(data.value, 'bar');
        })
        .on('end', function () {
          var stream = db.writeStream();
          stream.write({ key : 'bar', value : 'baz' });
          stream.on('close', function () {
            // temporary fix for level-js
            setTimeout(function () {
              db.get('bar', function (err, value) {
                t.notOk(err);
                t.equal(value, 'baz');
                dispose();
              });
            }, 100);
          });
          stream.end();
        })
      })
    })
  })
})


================================================
FILE: test/sync.js
================================================
require('./util')(function (test, _, getDb) {

  test('sync', function (t) {
    t.plan(1)
  
    getDb(function (db, dispose) {
      db.isClosed(function (err, isClosed) {
        t.equal(isClosed, false)
        dispose()
      })
    })
  })
})


================================================
FILE: test/util.js
================================================
var MemDB = require('memdb');
var manifest = require('level-manifest');
var tape = require('tape');
var multilevel = require('..');
var multilevelMsgpack = require('../msgpack');

var DEBUG = process.env.DEBUG;
  
var util = module.exports = function (tests) {
  function prefix(pre) {
    return function (name, test) {
      return tape(pre + ': ' + name, test);
    };
  }

  tests(
    prefix('jsonb'),
    multilevel,
    util.createGetDb(multilevel)
  );
  tests(
    prefix('msgpack'),
    multilevelMsgpack,
    util.createGetDb(multilevelMsgpack)
  );
};

util.getLocalDb = MemDB;

util.createGetDb = function (multilevel) {
  return function (setup, cb) {
    if (!cb) {
      cb = setup;
      setup = null;
    }

    var db = util.getLocalDb();
    var opts;
    if (setup) {
      var ret = setup(db);
      opts = ret.opts;
      db = ret.db;
    }

    var m = manifest(db);

    var server = multilevel.server(db, opts);
    server.on('data', function (data) {
      DEBUG && console.log('S -> ' + data.toString());
    });
    var _db = multilevel.client(m);

    function createRpcStream () {
      var rpcStream = _db.createRpcStream();
      rpcStream.on('data', function (data) {
        DEBUG && console.log('S <- ' + data.toString());
      });
      return rpcStream;
    }

    server.pipe(createRpcStream()).pipe(server);
    cb(_db, dispose);

    function dispose () {
      db.close();
    }
  };
};

util.getDb = util.createGetDb(multilevel);