'call open twice, should emit "open" once': function (done) {
var location = common.nextLocation()
var n = 0
var m = 0
var db
var close = function () {
var closing = this.spy()
db.on('closing', closing)
db.on('closed', function () {
assert.equals(closing.callCount, 1)
assert.equals(closing.getCall(0).args, [])
done()
})
// close needs to be idempotent too.
db.close()
process.nextTick(db.close.bind(db))
}.bind(this)
this.cleanupDirs.push(location)
db = levelup(leveldown(location), function () {
assert.equals(n++, 0, 'callback should fire only once')
if (n && m) { close() }
})
db.on('open', function () {
assert.equals(m++, 0, 'callback should fire only once')
if (n && m) { close() }
})
db.open()
}
var createLevelDB = function (location) {
var backend = levelBackend(location)
backend._destroy = function(cb) {
levelBackend.destroy(location, cb)
}
return backend
}
this.runTest = function (testData, assertType, done) {
var location = common.nextLocation()
this.cleanupDirs.push(location)
levelup(encDown(leveldown(location), {
valueEncoding: {
encode: msgpack.encode,
decode: msgpack.decode,
buffer: true,
type: 'msgpack'
}
}), function (err, db) {
refute(err)
if (err) return
this.closeableDatabases.push(db)
var PUT = testData.map(function (d) { return db.put.bind(db, d.key, d.value) })
async.parallel(PUT, function (err) {
refute(err)
async.forEach(testData, function (d, callback) {
db.get(d.key, function (err, value) {
if (err) console.error(err.stack)
refute(err)
assert[assertType](d.value, value)
callback()
})
}, done)
})
}.bind(this))
}
loadConfig(pathToConfig, function(err, config) {
if (err) throw err;
var dbFilePath = path.resolve(path.dirname(pathToConfig), config.dbPath);
var db = leveldown(dbFilePath);
db.open(function(err) {
if (err) throw err;
if (deleteAllUsers) {
// this will call process.exit when done
PlayerServer.deleteAllUsers(db);
return;
}
var app = express();
var pend = new Pend();
pend.go(function(cb) {
var options = {
dir: path.join(__dirname, "../public"),
aliases: [],
};
createGzipStatic(options, function(err, middleware) {
if (err) return cb(err);
app.use(middleware);
cb();
});
});
pend.go(function(cb) {
createGzipStatic({dir: path.join(__dirname, "../src/public")}, function(err, middleware) {
if (err) return cb(err);
app.use(middleware);
cb();
});
});
pend.wait(function(err) {
if (err) throw err;
var player = new Player(db, config.musicDirectory, config.encodeQueueDuration);
player.initialize(function(err) {
if (err) throw err;
log.debug("Player initialization complete.");
startServer(app, db, player, config);
});
});
});
});
var execute = function () {
var db = leveldown(this.location)
db.open(this._options, function (err) {
if (err) {
err = new errors.OpenError(err)
return dispatchError(err, callback)
} else {
this._db = db
status = 'open'
if (callback)
callback(null, this)
this.emit('open')
this.emit('ready')
}
}.bind(this))
}.bind(this)
'serializes value': function (done) {
var location = common.nextLocation()
var down = leveldown(location)
down._serializeValue = function (value) {
return value.toUpperCase()
}
var db = levelup(down)
this.closeableDatabases.push(db)
this.cleanupDirs.push(location)
db.put('key', 'value', function (err) {
refute(err)
db.get('key', { asBuffer: false }, function (err, value) {
refute(err)
assert.same(value, 'VALUE')
done()
})
})
}
this.runTest = function (testData, assertType, done) {
var location = common.nextLocation()
this.cleanupDirs.push(location)
levelup(encDown(leveldown(location), {
keyEncoding: 'json',
valueEncoding: 'json'
}), function (err, db) {
refute(err)
if (err) return
this.closeableDatabases.push(db)
var PUT = testData.map(function (d) { return db.put.bind(db, d.key, d.value) })
async.parallel(PUT, function (err) {
refute(err)
async.parallel([testGet, testStream], done)
})
function testGet (next) {
async.forEach(testData, function (d, callback) {
db.get(d.key, function (err, value) {
if (err) console.error(err.stack)
refute(err)
assert[assertType](d.value, value)
callback()
})
}, next)
}
function testStream (next) {
db.createReadStream().pipe(concat(function (result) {
assert.equals(result, testData)
next()
}))
}
}.bind(this))
}
var async = require('async');
var leveldown = require('leveldown');
var key = require('..');
var db = leveldown(__dirname + '/data');
// initialise a few test versions
var testVersions = [
'0.0.1',
'204.3.2',
'1.4.0',
'5.3.2',
'10.34.2',
'8.2.3',
'3.2.4',
'5.34.234'
];
function findLatest() {
var iterator = db.iterator({ key: 'foo', limit: 1 });
iterator.next(function(err, key, value) {
console.log('the latest version of foo found was: ' + value);
});
}
function insertItems(err) {
if (err) {
return console.error('could not open db');
};
async.forEach(testVersions, insertVersion, function(err) {
loadConfig(pathToConfig, function(err, config) {
if (err) throw err;
if (browserExe || printUrl) {
spawnBrowserOrPrintUrl(config, browserExe, browserArgs);
return;
}
var dbFilePath = path.resolve(path.dirname(pathToConfig), config.dbPath);
var db = leveldown(dbFilePath);
db.open(function(err) {
if (err) {
if (exitGracefullyIfRunning &&
/^IO error: lock.*: Resource temporarily unavailable$/.test(err.message))
{
return;
} else {
throw err;
}
}
if (deleteAllUsers || deleteAllEvents) {
// this will call process.exit when done
PlayerServer.deleteUsersAndEvents(db, deleteAllUsers);
return;
}
var app = express();
var sslEnabled = !!(config.sslKey && config.sslCert);
if (sslEnabled) {
app.use(redirectHttpToHttps);
}
var pend = new Pend();
pend.go(function(cb) {
var options = {
dir: path.join(__dirname, "../public"),
aliases: [],
};
createGzipStatic(options, function(err, middleware) {
if (err) return cb(err);
app.use(middleware);
cb();
});
});
pend.go(function(cb) {
createGzipStatic({dir: path.join(__dirname, "../src/public")}, function(err, middleware) {
if (err) return cb(err);
app.use(middleware);
cb();
});
});
pend.wait(function(err) {
if (err) throw err;
var player = new Player(db, config.musicDirectory,
config.encodeQueueDuration, config.googleApiKey);
player.initialize(function(err) {
if (err) throw err;
log.debug("Player initialization complete.");
startServer(app, db, player, config, sslEnabled);
});
});
});
});
var httpPort = process.env.NETHACK_HTTP_PORT || 21119;
var httpHost = process.env.NETHACK_HTTP_HOST || '0.0.0.0';
var dbFilePath = process.env.NETHACK_DB_PATH || 'nethack.db';
var USERS_KEY_PREFIX = "Users.Username.";
var NETHACK_DIR = path.join(__dirname, '../../');
var validateUsernameRegex = /^[a-zA-Z0-9_~]*$/;
var MIN_USERNAME_LENGTH = 1;
var MAX_USERNAME_LENGTH = 32;
var MIN_PASSWORD_LENGTH = 1;
var MAX_PASSWORD_LENGTH = 1024;
var db = leveldown(dbFilePath);
var httpServer;
var users = {};
boot();
function Session(ws) {
this.ws = ws;
this.user = null;
this.netHackProcess = null;
}
Session.prototype.end = function() {
this.killChildProcess();
};
'use strict'
const es = require('event-stream')
const fs = require('fs')
const levelup = require('levelup')
const lr = require('./')
const rimraf = require('rimraf')
const test = require('tap').test
const leveldown = require('leveldown')
const loc = '/tmp/level-random-' + Math.floor(Math.random() * (1 << 24))
const store = leveldown(loc)
const db = levelup(store)
function puts () {
return ['a', 'b', 'c'].map(key => {
return { type: 'put', key: key, value: key.toUpperCase() }
})
}
test('setup', t => {
db.batch(puts(), er => {
t.end()
})
})
test('defaults', t => {
t.ok(!lr({db: db}).opts.fillCache)
t.ok(lr({db: db, fillCache: true}).opts.fillCache)
t.ok(!lr({db: db}).errorIfNotFound)
t.ok(lr({db: db, errorIfNotFound: true}).errorIfNotFound)
var createDb = function (location, callback) {
levelup(leveldown(location), function (err, db) {
setTimeout(callback.bind(null, err, db), 50)
})
}
var leveldown = require('leveldown'); // database
var Settings = require('./lib/settings').Settings;
if (process.argv.length <= 2) {
console.log('No key given');
process.exit(1);
}
var rawKey = process.argv[2];
cfg = new Settings();
var dataDir = cfg.getDataDir();
storageUri = dataDir + '/leveldb/';
hMain = leveldown(storageUri+'main.db');
var defaultCreateOpts = {
createIfMissing: true,
cacheSize: 100 * 1024 * 1024,
keyEncoding: 'json',
valueEncoding: 'json'
};
var dataLoop = function dataLoop(i, limit) {
//console.log('loop', limit);
if (limit > 10000) return false; // runaway process trap
i.next(function(err, key, value) {
if (err !== null) {
console.log('err:', err);
return false;
}
console.log('key:', key, 'value:', value);
import {errorHandler} from '../lib/utils';
const BP = require('bluebird');
const levelup = require('levelup');
const leveldown = require('leveldown');
const uuid = require('node-uuid');
const db = BP.promisifyAll(levelup(leveldown(process.env.DB_PATH || './db')));
import {sendToken} from '../lib/emailService';
async function processOrderAsync(req, res) {
const token = uuid.v1();
await db.putAsync(token, JSON.stringify({...req.body.appState, token}));
const matchHost = /^https?:\/\/.*\//;
let host = '';
if (req.headers && req.headers.referer) {
host = matchHost.exec(req.headers.referer)[0];
} else {
host = req.get ? req.get('host') : '';
}
sendToken({to: req.body.email, host, token}, console.log);
res.send({token});
}
async function getOrderAsync(req, res) {
const value = await db.getAsync(req.query.token);
res.send(JSON.parse(value || '{}'));
}
export const processOrder = (req, res) =>
processOrderAsync(req, res)