var Kued = function (options) {
var level = require('level');
var ttl = require('level-ttl');
var uuid = require('uuid');
var Sublevel = require('level-sublevel');
var concat = require('concat-stream');
var self = this;
var TTL = 60000;
options = options || {};
this.queueDBPath = options.queueDB || './db/queued-db';
this.pairDBPath = options.pairDB || './db/paired-db';
this.itemsDBPath = options.itemsDB || './db/items-db';
this.queueTTL = parseInt(options.queueTTL, 10) || TTL;
this.pairTTL = parseInt(options.pairTTL, 10) || TTL;
this.limit = parseInt(options.limit, 10) || 2;
if (this.limit < 2) {
throw new Error('You need a limit greater than 1');
}
this.queued = Sublevel(level(this.queueDBPath, {
createIfMissing: true,
valueEncoding: 'json'
}));
this.paired = Sublevel(level(this.pairDBPath, {
createIfMissing: true,
valueEncoding: 'json'
}));
this.items = Sublevel(level(this.itemsDBPath, {
createIfMissing: true,
valueEncoding: 'json'
}));
var getQueued = function (next) {
var rs = self.queued.createReadStream();
rs.pipe(concat(function (q) {
next(null, {
queued: q
});
}));
rs.on('error', function (err) {
next(err);
});
};
var setPairKey = function (key, item) {
self.items.put('pairKey!' + item.key, key, { ttl: self.pairTTL }, function (err) {
if (err) {
throw err;
}
self.queued.del(item.key);
});
};
var addPair = function (origKey, items, next) {
var key = uuid.v4();
self.paired.put(key, items, { ttl: self.pairTTL }, function (err) {
if (err) {
next(err);
return;
}
items.forEach(function (item) {
setPairKey(key, item);
});
next(null, {
origKey: origKey,
pairKey: key
});
});
};
var getKey = function (key, next) {
getQueued(function (err, q) {
if (err) {
next(err);
return;
}
if (q.queued.length >= self.limit) {
addPair(key, q.queued, next);
} else {
next(null, false);
}
});
};
this.add = function (value, next) {
var key = uuid.v4();
self.queued.put(key, value, { ttl: self.queueTTL }, function (err) {
if (err) {
next(err);
return;
}
getKey(key, next);
});
};
this.getPair = function (key, next) {
this.items.get('pairKey!' + key, function (err, pairKey) {
if (err || !pairKey) {
next(new Error('No pairing found'));
return;
}
self.paired.get(pairKey, function (err, pair) {
if (err || !pair) {
next(new Error('No pairing found'));
return;
}
next(null, pair);
});
});
};
};
var level = require('level')
var levelPromise = require('level-promise')
var sublevel = require('sublevel')
var db = level('./db/bigdata', {
createIfMissing: true,
valueEncoding: 'json'
})
// db.createKeyStream().on('data', console.log.bind(console,'k'))
module.exports = levelPromise(sublevel(db, 'schools'))
var http = require('http')
var fs = require('fs')
var ecstatic = require('ecstatic')
var st = ecstatic('public')
var router = require('./router.js')
var hyperstream = require('hyperstream')
var createElement = require('virtual-dom/create-element')
var body = require('body/any')
var level = require('level')
var db = level('students.db', { valueEncoding: 'json' })
var collect = require('collect-stream')
var sorthash = require('./lib/sorthash.js')
var wsock = require('websocket-stream')
var server = http.createServer(function (req, res) {
var m = router.match(req.url)
if (req.url === '/apply' && req.method === 'POST') {
body(req, res, function (err, params) {
var key = 'student!' + params.name
var house = sorthash(params.name)
db.batch([
{ type: 'put', key: key, value: {
house: house
} },
{ type: 'put',
key: 'house!' + house + '!' + params.name,
value: 0
}
], function (err) {
if (err) res.end('error: ' + err)
else res.end('ok!')
var level = require('level')
var db = level(process.argv[2])
var file = process.argv[3]
var fs = require('fs')
var commands = []
fs.readFile(file, 'utf8', function(err,data) {
if(err) throw err
var array = data.toString().split('\n')
for (i in array) {
var x = array[i].split(',')
if (x[0] === 'put') {
var y = ('{ ' + "type: 'put', key: '" + x[1] + "', value: '" + x[2] + "' }")
commands.push(y)
}
else if (x[0] === 'del') {
var z = ('{ ' + "type: 'del', key: '" + x[1] + "' }")
commands.push(z)
}
}
console.log(commands)
db.batch(commands, function (err) {
if (err) throw err
console.log("Woot!")
})
})
//db.get('@izs', function (err, value) {
// console.log('This is @izs value:', value)
// db.close()
//})
function makeCached (transform, name) {
var cache = level("./cache/" + name);
return cacheify(transform, cache);
}
var levelup = require('level')
//var SubLevel = require('level-sublevel')
var pull = require('pull-stream')
var path = '/tmp/pull-level-read-live'
require('rimraf').sync(path)
var db = levelup(path)
var l = require('../')
var all = []
var h = require('./helper')
require('tape')('live', function (t) {
var second = false
h.timestamps(db, 10, function (err, all) {
var i = 0
var sync = false
pull(
l.read(db, {tail: true, onSync: function () {
console.log('SYNC')
sync = true
}}),
h.exactly(20),
pull.collect(function (err, ary) {
process.nextTick(function () {
t.notOk(err)
const rapid = require('rapid-stream')
const sort = require('sort-stream2')
const json = require('JSONStream')
const through = require('through2')
const request = require('request')
const ghauth = require('ghauth')
const level = require('level')
const path = require('path')
const url = require('url')
const fs = require('fs')
const WEEK = 1000 * 60 * 60 * 24 * 7
const dat = require('dat')(__dirname, kickOff)
const dbdir = path.join(__dirname, '.stars')
const db = sublevel(level(dbdir, {
valueEncoding: 'json'
}))
const counts = db.sublevel('counts')
const dates = db.sublevel('dates')
var token = null
function kickOff(err) {
if (err) throw err
ghauth({
configName: 'unpm',
scopes: ['user'],
note: 'npm data aggregation project',
userAgent: 'unpm'
var expect = require('chai').expect;
var level = require('level');
var db = level('testdb', {valueEncoding: 'json'});
var _ = require('lodash');
var PersonDomain = require('../')({
db: db,
});
describe("#Person", function () {
it("should CRUD person model", function (done) {
var newPerson = PersonDomain.create({
name: "Bob Loblaw",
email: "*****@*****.**",
});
newPerson.save(function (err) {
expect(err).to.not.exist;
var id = newPerson.id;
expect(id).to.exist;
expect(newPerson.type).to.equal("Person");
PersonDomain.get(id, function (err, getPerson) {
expect(err).to.not.exist;
expect(getPerson.toJSON()).to.deep.equal(newPerson.toJSON());
var updates = { name: "Bob" };
PersonDomain.update(id, updates, function (err, updatePerson) {
expect(err).to.not.exist;
expect(updatePerson.toJSON())
.to.deep.equal(_.extend(newPerson.toJSON(), updates));
done();
});
});
var fs = require('fs');
var level = require('level');
// read file and split into an array of lines
var file = fs.readFileSync(process.argv[3], 'utf8');
var lines = file.split('\n');
level(process.argv[2], function (err, db) {
// uses batch chained: https://github.com/rvagg/node-levelup#batch_chained
var batch = db.batch();
lines.forEach(function (line) {
var d = line.split(',');
if (d[0] == 'del') {
return batch.del(d[1]);
} else {
batch.put(d[1], d[2]);
}
});
batch.write();
});
module.exports = function(dir,opts){
var db, sep = 'ÿ';
if(dir && dir.createReadStream){
db = dir;
} else {
db = level(dir,{valueEncoding:'json'});
db = sublevel(db);
}
if(!db.createWriteStream) {
db.createWriteStream = LevelWriteStream(db)
}
opts = opts||{};
var o = {
db:db,
// a database always has a uuid that identifies it
// whenever a db is referenced from some place outside it will need this uuid.
_dbid:[],
getId:function(cb){
var z = this;
if(opts.id) return setImmediate(function(){
cb(false,opts.id);
});
if(z._dbid.length) return z._dbid.push(cb);
z._dbid.push(cb);
var cbs = function(err,data){
var a = z._dbid;
z._dbid = [];
while(a.length) a.shift()(err,data);
}
db.get('id',function(err,id){
if(err) {
if((err+'').indexOf('NotFoundError') > -1){
id = uuid.v4();
db.put('id',id,function(err){
if(err) return cbs(err);
opts.id = id;
cbs(false,id);
});
} else return cbs(err,id);
}
return cbs(false,id);
});
},
getTroopData:function(id,cb){
var z = this;
if(!id) return process.nextTick(function(){
var e = new Error('id or key required to get troop');
e.code = z.errors.noid;
cb(e);
});
if(id.length == 32) {
z.getTroopIdFromKey(id,function(err,id){
if(err) return cb(err);
db.get("troops"+sep+id,cb);
});
return;
}
db.get("troops"+sep+id,function(err,data){
if(err && (err+'').indexOf('NotFoundError') > -1){
err.code = z.errors.notroop;
}
cb(err,data);
});
},
writeTroop:function(obj,cb){
// create and or update a troop.
obj = obj||{};
console.log('writing new troop',obj);
var z = this;
var prefix = "troops"+sep;
var id = obj.troop||obj.id;
if(!id) {
// make troop
z.getNextId('troops',function(err,id){
if(err) return cb(err);
obj.id = obj.troop = id;
var afterKey = function(err,key){
obj.key = key;
if(err) return cb(err);
z.db.put(prefix+obj.id,obj,function(err){
if(err) return cb(err);
cb(false,obj);
console.log('cb with ',obj);
});
}
// the key was provided.
if(obj.key && obj.key.length === 32){
console.log('key passed in!',obj.key);
return afterKey(false,obj.key);
}
z.assignTroopKey({id:obj.id},afterKey);
});
} else {
z.getTroopData(id,function(err,data){
if(err){
if(err.code != z.errors.notroop) return cb(err);
// if id is manually provided.
obj.neverConnected = true;
obj.troop = obj.id = id;
// if key is present is gets force assigned to this mystery troop.
z.assignTroopKey({id:obj.id,key:obj.key},function(err,key){
if(err) return cb(err);
obj.key = key;
z.db.put(prefix+obj.id,obj,function(err){
if(err) return cb(err);
cb(false,obj);
});
});
return;
}
obj = xtend(data||{},obj);
// i dont care if this troop id is the next increment just save a troop at this id.
obj.troop = obj.id = id;
z.db.put(prefix+obj.id,obj,function(err){
if(err) cb(err);
cb(false,obj);
});
});
}
},
_deletes:{},
deleteTroop:function(id,cb){
// i make sure the troop exists and all i do is set a deleted flag to the time on the troop's object.
var z = this;
var prefix = "troops"+sep;
if(z._deletes[id]) return z._deletes[id].push(cb);
z._deletes[id] = [cb];
z.getTroopData(id,function(err,data){
if(err) return cbs(err)
// if it's deleted already do nothing.
if(data.deleted) return cbs(false,data);
data.deleted = Date.now();
z.db.put(prefix+data.id,data,function(err){
cbs(err,data);
});
});
function cbs(err,data){
var a = z._deletes[id];
delete z._deletes[id];
while(a.length) a.shift()(err,data);
}
},
writeScout:function(troop,obj,cb){
var z = this;
var prefix = "troops"+sep+troop+sep;
z.getTroopData(troop,function(err,troop){
if(err) return cb(err);
// get troop supports key as weel as id so make sure i pass on id.
troop = troop.id;
if(!obj.id) {
z.getNextId("troops"+sep+troop,function(err,id){
if(err) return cb(err);
obj.id = id;
obj.troop = troop;
db.put(prefix+id,obj,function(err,data){
cb(err,obj);
});
})
} else {
z.getScoutData(troop,obj.id,function(err,data){
if(err && err.code !== z.errors.noscout) {
return cb(err);
}
obj = xtend(data||{},obj);
obj.troop = troop;
db.put(prefix+obj.id,obj,function(err,data){
cb(err,obj);
});
});
}
});
},
deleteScout:function(troop,id,cb){
var z = this;
var prefix = "troops"+sep+troop+sep;
z.getScoutData(troop,id,function(err,obj){
if(err) return cb(err);
obj.deleted = Date.now();
db.put(prefix+id,obj,function(err){
cb(err,obj);
})
})
},
getScoutData:function(troop,id,cb){
var z = this;
var prefix = "troops"+sep+troop+sep;
if(!id || !troop) return process.nextTick(function(){
var e = new Error('troop and id required to get scout');
e.code = z.errors.noid;
cb(e);
});
z.db.get(prefix+id,function(err,data){
if(err && (err+'').indexOf('NotFoundError') > -1){
err.code = z.errors.noscout;
}
cb(err,data);
});
},
// generic get any current data for troops, a troop, scouts, a scout
get:function(/*troop,scout,*/cb){
var z = this;
var args = [].slice.call(arguments);
var cb = args.pop();
var troop = args.shift();
var scout = args.shift();
var result = {};
var range = "";
if(scout) range = troop+sep+scout;
else if (troop) range = ''+troop;
z.sync({range:range}).on('data',function(data){
if(data.report == "troop-data"){
if(data.deleted) return;
if(!result[data.troop]) result[data.troop] = data.data;
data.data.scouts = {};
data.data.reports = {};
} else if(data.report == "scout-data"){
if(!result[data.troop]) return;
if(!result[data.troop].scouts[data.scout]) result[data.troop].scouts[data.scout] = data.data;
data.data.reports = {};
} else if(data.report) {
if(!result[data.troop]) return;
if(!result[data.troop].scouts[data.scout]) return;
if(data.scout){
result[data.troop].scouts[data.scout].reports[data.report] = data;
} else {
result[data.troop].reports[data.report] = data;
}
}
}).on('end',function(){
if(troop){
result = result[troop];
if(scout && result){
result = result.scouts[scout];
}
}
cb(false,result);
cb = function(){};
}).on('error',function(err){
cb(err);
cb = function(){};
});
},
sync:function(options){
var z = this;
var deletes = {};
var range = options.range||'';
if(range.join) range = range.join(sep);
var opts = {start:"troops"+sep+range,end:"troops"+sep+range+sep+sep};
var stream;
if(options.tail) {
opts.old = true;
stream = livestream(z.db,opts).on('sync',function(){
this.emit('data',{sync:true});
// this event lets you know when this stream has sent all of the events that have happened...
// and is starting to wait for new events to happen
});
} else {
stream = z.db.createReadStream(opts);
}
var s = through2.obj(function(data,enc,cb){
// sync event from live stream.
if(data.sync){
this.push(data);
return cb()
}
var chunks = data.key.split(sep);
var troop = chunks[1];
var scout = chunks[2];
var report = chunks[4];
// filter deleted troops and scouts. yeah i need to do this. it's the only reason you would delete troops.
if(report){
data = data.value;
// a report.
if(deletes[troop] || deletes[troop+sep+scout]){
return cb();
}
} else if(scout) {
// scout data object
if(deletes[troop]) {
return cb();
}
if(data.value.deleted) {
deletes[troop+sep+scout] = 1;
return cb();
} else if(deletes[troop+sep+scout]) {
// un-delete
delete deletes[troop+sep+scout];
}
// make this a scout report
data = {report:"scout-data",data:data.value,t:ts(),scout:scout,troop:troop};
} else if(troop) {
// troop data object
if(data.value.deleted) {
deletes[troop] = 1;
return cb();
} else if(deletes[troop]) {
// un-delete
delete deletes[troop];
}
// make this a troop report.
data = {report:"troop-data",data:data.value,t:ts(),troop:troop};
} else {
return cb();
}
// filter stale? no. if i can do it from this data they can.
this.push(data);
cb();
})
// can't leave errors unbound
stream.on('error',function(err){
s.emit('error',err);
});
return stream.pipe(s);
},
stats:function(troop,scout,options){
if(typeof options == "string") options = {report:options};
options = options||{};
var report = options.report; // the report or reports you want to stream.
var start = options.start||0; // the time t start streaming historical data.
var end = options.end; // the time to stop sending historical data.
var tail = options.end?false:options.tail;// keep streaming live after end has been reached.
if(!end) end = sep;
else end = bte(+end);
var prefix = "tlog"+sep+troop+sep+scout+sep+report+sep;
var opts = {start:prefix+bte(+start),end:prefix+end};
// do this.
var z = this;
var stream;
if(tail) {
opts.old = true;
stream = livestream(z.db,opts).on('sync',function(){
this.emit('data',{value:{sync:true}});
});
} else {
stream = z.db.createReadStream(opts)
}
var s = through2.obj(function(data,enc,cb){
this.push(data.value);
cb();
});
// can't leave errors unbound
stream.on('error',function(err){
s.emit('error',err);
});
return stream.pipe(s);
},
validateReport:function(report){
// a report needs.
if(!report.troop) return false;
if(!report.scout) return false;
if(!report.report) return false;
return true;
},
saveReportsStream:function(){
var z = this;
var s = through2.obj(function(data,enc,cb){
if(!data) return cb();// skip empty events.
if(!z.validateReport(data)) {
var e = new Error('invalid report object. missing required troop,scout or report '+JSON.stringify(report));
e.code = z.errors.invalidreport;
return this.emit('error',e);
}
// insert into sync section and stats section
// {troop:,report:,scout:,data:,_t:}
//
// We want to find a way to use the board's internal event timestamp for absolute ordering/deduping but
// i have a few parts to make before that can be true.
// without that you can never compare samples that have a greater rate than the latency to get to the server
//
data.t = ts();
var key = "troops"+sep+data.troop+sep+data.scout+sep+'r'+sep+data.report;
var history = "tlog"+sep+data.troop+sep+data.scout+sep+data.report+sep+bte(data.t);
// update the live view
this.push({type:"put",key:key,value:data});
// update the history log
this.push({type:"put",key:history,value:data});
cb();
});
s.pipe(db.createWriteStream()).on('error',function(err){
s.emit('error',err);
});
return s;
},
assignTroopKey:function(obj,cb){
obj = obj||{};
var z = this;
if(!obj.id) return process.nextTick(function(){
var e = new Error("missing required troop id assigning troop key");
e.code = z.errors.key;
cb(e);
});
var key = crypto.createHash('md5').update(crypto.randomBytes(210)).digest().toString('hex');
if(obj.key) key = obj.key;
z.db.put("key"+sep+key,obj.id,function(err){
if(err) return cb(err);
cb(false,key);
});
},
getTroopIdFromKey:function(key,cb){
this.db.get('key'+sep+key,cb);
},
getNextId:function fn(key,cb){
key = 'ids'+sep+key;
if(!fn.running) fn.running = {};
if(fn.running[key]) return fn.running[key].push(cb);
fn.running[key] = [];
db.get(key,function(err,value){
if(err) {
if((err+'').indexOf('NotFoundError') === -1){
return cb(err);
} else {
value = 0;
}
}
putKey(value+1,cb);
function putKey (value,cb){
db.put(key,value,function(err){
if(fn.running[key].length){
putKey(1+value,fn.running[key].shift());
} else {
delete fn.running[key];
}
cb(err,value);
});
}
});
},
errors:{notroop:"NoTroop",key:"NoKeyId",noid:"MissingId",noscout:"NoScout",invalidreport:"InvalidReportObject"}
}
return o;
}
var Personality = function (options) {
var self = this;
if (!options) {
options = {};
}
this.dbPath = options.db;
this.db = Sublevel(level(this.dbPath, {
createIfMissing: true,
valueEncoding: 'json'
}));
this.profile = {
meta: options.meta || {},
systemData: {}
};
this.get = function (email, callback) {
self.db.get(KEY + email, function (err, profile) {
if (err || !profile) {
callback(new Error('Not found'));
} else {
if (typeof profile === 'object') {
callback(null, profile);
} else {
callback(new Error('Invalid JSON'));
}
}
});
};
var validateProperties = function (userProfile, callback) {
if (!userProfile) {
callback(new Error('Profile non-existent'));
} else if (!userProfile.hash) {
callback(new Error('Invalid - email is missing'));
} else if (!userProfile.display) {
callback(new Error('Invalid - display name can not be empty'));
} else {
userProfile.hash = require('crypto').createHash('sha1').update(userProfile.hash).digest('hex');
self.get(userProfile.hash, function (err, profile) {
if (!err) {
if (userProfile.hash === profile.hash) {
callback(new Error('Invalid - user already registered'));
} else if (userProfile.display === profile.display) {
callback(new Error('Invalid - display name in use'));
}
} else {
callback(null, userProfile);
}
});
}
};
var setAll = function (profile, callback, isNew) {
if (!profile.meta) {
profile.meta = {};
}
for (var attr in self.profile.meta) {
if (!profile.meta[attr]) {
console.log(profile.meta[attr]);
profile.meta[attr] = null;
}
}
for (var attr in profile) {
if (WHITELIST.indexOf(attr) === -1) {
delete profile[attr];
}
}
profile.systemData = self.profile.systemData;
if (isNew) {
profile.systemData.joined = Math.round(new Date() / 1000);
}
profile.systemData.updated = Math.round(new Date() / 1000);
self.db.put(KEY + profile.hash, profile, function (err) {
if (err) {
callback(err);
} else {
callback(null, profile);
}
})
};
this.create = function (newProfile, callback) {
validateProperties(newProfile, function (err, profile) {
if (err) {
callback(err);
} else {
setAll(profile, callback, true);
}
});
};
var validateUpdate = function (profile, hash, callback) {
if (!profile) {
callback(new Error('Invalid - no profile'));
} else if (!profile.hash) {
callback(new Error('Invalid - no email'));
} else if (!profile.display) {
callback(new Error('Invalid - no display'));
} else {
self.get(hash, function (err, exProfile) {
if (err) {
callback(err);
} else {
console.log(profile);
console.log(exProfile);
if (!profile.meta) {
profile.meta = {};
}
for (var attr in exProfile.meta) {
if (!profile.meta[attr]) {
profile.meta[attr] = exProfile.meta[attr];
}
}
callback(null, profile);
}
});
}
};
this.update = function (profile, hash, callback) {
validateUpdate(profile, hash, function (error, vProfile) {
if (error) {
callback(error);
} else {
setAll(vProfile, callback, false);
}
});
};
this.del = function (email, callback) {
self.db.del(KEY + email);
callback(null);
};
};
// Example of LevelDB for Node.js
// Loading Module
var levelup = require('level');
var db = levelup('./testdb');
// Set values
db.put('Apple', 'red', function(err) {
if (err) { console.log('Error', err); return; }
testGet();
});
function testGet () {
db.get ('Apple', function (err, value) {
if (err) { console.log('Error', err); return; }
console.log('Apple =' + value);
testBatch();
});
}
function testBatch() {
db.batch()
.put('Mango', 'yellow')
.put('Banana', 'yellow')
.put('Kiwi', 'green')
.write(function() { testGet2(); });
}
function testGet2 () {
db.get('Banana', function(err, value) {
var level = require('level')
var db = level('posts.db', { valueEncoding: 'json' })
var to = require('to2')
var opts = {
gt: 'post-time!',
lt: 'post-time!~'
}
db.createReadStream(opts)
.pipe(to.obj(function (row, enc, next) {
var id = row.key.split('!').slice(-1)[0]
db.get('post!' + id, function (err, doc) {
var name = doc.name
var time = doc.time
var body = doc.body
console.log(time + ' <' + name + '> ' + body)
next()
})
}))
test('api', function (t) {
t.plan(8);
var db = level(path.join(tmpdir, 'db'));
var compute = batchdb(db, {
path: path.join(tmpdir, 'blob'),
run: function () {
var input = concat(function (body) {
if (body.toString('utf8') === 'fail') {
dup.emit('error', new Error('yo'));
return;
}
t.equal(body.toString('utf8'), 'robot');
output.end('beep boop\n');
});
var output = through();
var dup = duplexer(input, output);
return dup;
}
});
compute.on('result', function (key, id) {
compute.get(key).pipe(concat(function (body) {
t.equal(body.toString('utf8'), 'robot');
}));
compute.get(id).pipe(concat(function (body) {
t.equal(body.toString('utf8'), 'beep boop\n');
}));
var results = [];
compute.list('result').pipe(through.obj(
function (row, enc, next) {
results.push(row);
next();
},
function () {
t.equal(results.length, 1);
t.equal(results[0].value.hash, id);
}
));
});
compute.add().end('robot');
compute.add().end('fail');
compute.on('fail', function (err) {
t.equal(err.message, 'yo');
var results = [];
compute.list('fail').pipe(through.obj(write, end));
function write (row, enc, next) {
results.push(row);
next();
}
function end () {
t.equal(results.length, 1);
t.deepEqual(results[0].value, { message: 'yo' });
}
});
compute.run();
});
init: function (name) {
db = sublevel(levelup(name, { valueEncoding: 'json' }))
},
'use strict';
var uuid = require('uuid');
var Boom = require('boom');
var nconf = require('nconf');
var level = require('level');
var ttl = require('level-ttl');
var profile = require('./profile');
var utils = require('./utils');
var ban = require('./ban');
nconf.argv().env().file({ file: 'local.json' });
var db = ttl(level('./db/logins', {
createIfMissing: true,
valueEncoding: 'json'
}));
var addNewUser = function (uid, phone, request, reply) {
profile.db().put('uid!' + uid, phone, function (err) {
if (err) {
return reply(Boom.wrap(err, 400));
}
profile.db().put('user!' + phone, {
uid: uid,
phone: phone,
secondary: {}
}, function (err) {
if (err) {
return reply(Boom.wrap(err, 400));
var VeryLevelModel = require('../index.js');
var level = require('level');
var db = level(__dirname + '/testdb.db', {valueEncoding: 'json', errorIfExists: true});
var async = require('async');
var verymodel = require('verymodel');
var dbstreams = require('../lib/streams');
process.on('uncaughtException', function (err) {
console.trace();
console.error(err.stack);
process.exit();
});
module.exports = {
'Create multiple children': function (test) {
var TM = new VeryLevelModel({idx: {}}, {db: db, prefix: 'TM'});
var TMC = new VeryLevelModel({cidx: {}}, {db: db, prefix: 'RC'});
var tm = TM.create({idx: 1});
tm.save(function (err) {
var cidx = 0;
async.whilst(function () {
cidx++;
return cidx <= 10;
},
function (acb) {
var tmc = tm.createChild(TMC, {cidx: cidx});
tmc.save(function (err) {
acb(err);
});
},
function (err) {
const levelup = require('level');
const db = levelup('./db');
const crypto = require('crypto');
const appio = require('./app.js').io;
let location = 'http://localhost:3000';
if (1 === process.env.PROD) {
location = 'http://expresspolls.com';
}
const getId = () => {
let randInt = getRandomInt(1, 999999999999999);
let diffRandInt = getRandomInt(1, 999999999999999);
const randStringLength = getRandomInt(1, 40);
randInt = randInt.toString();
diffRandInt = diffRandInt.toString();
let randString = 'v84by0cmomcmw0-amckajapsodc9qj].dcq3785$';
randString = randString.substring(1, randStringLength);
randInt = randInt + randString + diffRandInt;
const sha512 = crypto.createHash('sha512');
sha512.update(randInt);
const resultHash = sha512.digest("hex");
const result = resultHash;
const length = 32;
const trimmedResult = result.substring(0, length);
return trimmedResult;
};
const getRandomInt = (min, max) => {
return Math.floor(Math.random() * (max - min + 1)) + min;
var fs = require('fs')
, level = require('level')
, s3sync = require('s3-sync')
, readdirp = require('readdirp')
// To cache the S3 HEAD results and speed up the
// upload process. Usage is optional.
var db = level(__dirname + '/cache')
var creds = JSON.parse(fs.readFileSync('aws.json', 'utf8'))
var files = readdirp({
root: 'public'
, directoryFilter: ['!.git', '!cache']
})
// Takes the same options arguments as `knox`,
// plus some additional options listed above
var uploader = s3sync(db, {
key: creds.accessKeyId
, secret: creds.secretAccessKey
, bucket: creds.bucketName
, concurrency: 16
}).on('data', function(file) {
console.log(file.fullPath + ' -> ' + file.url)
}).on('end', function() {
console.log('Upload successfully!');
})
files.pipe(uploader)
var fs = require('fs');
var cities = require('cities1000');
var split = require('split');
var through = require('through');
var level = require('level');
var db = level(__dirname + '/data', { encoding: 'json' });
fs.createReadStream(cities.file)
.pipe(split())
.pipe(through(function (line) {
var row = line.split('\t').reduce(function (acc, x, ix) {
var key = cities.fields[ix];
acc[key] = x;
return acc;
}, {});
db.put(row.id, row);
db.put(row.name.toLowerCase() + '!' + row.id, 0);
row.alternativeNames.split(',').forEach(function (alt) {
db.put(alt.toLowerCase() + '!' + row.id, 0);
});
console.log(row.name);
}))
;
// 120.js
'use strict';
var level = require('level')
, updates = require('../../npm/updates')
, util = require('../util')
, db = {}
;
db.packages = level('./db', {
valueEncoding: 'json'
});
// find all objects match the search object search criteria
// and present a summary view
exports.all = function (done) {
var stream = db.packages.createReadStream();
var docs = {};
stream.on('data', function (data) {
var doc = data.value; // quick reference
// delete excessive fields
delete doc._id;
delete doc.readme;
delete doc._attachments;
// replace all verions with the latest, and strip all metadata
import resource from 'resource-router-middleware';
import Pili from 'pili';
import level from 'level';
const db = level('./mydb');
const credentials = new Pili.Credentials("exempwg0U6rl1yL_2G4A_00weNY5kEdMeG7oYH04", "8dhh34fcyMD3tDobvwSrsWbhX-GC6GKvykOikmLm");
const hub = new Pili.Hub(credentials, "wantplus-1");
let pilipilis = [];
db.get("pilipili", function (err, value) {
if (err) {
if (err.notFound) {
}
}else{
pilipilis = JSON.parse(value);
}
});
export default ({ config }) => resource({
/** Property name to store preloaded entity on `request`. */
id : 'pilipili',
/** For requests with an `id`, you can auto-load the entity.
* Errors terminate the request, success sets `req[id] = data`.
*/
load(req, id, callback) {
let pilipili = pilipilis.find( pilipili => pilipili.id===id ),
var VError = require('verror');
var level = require('level');
var config = require('../common/config');
var readTransactions = require('./readTransactions');
var generateStats = require('./generateStats');
var domain = require('domain');
var sublevel = require('level-sublevel');
var serverDomain = domain.create();
serverDomain.on('error', function (err) {
console.error(err && err.stack);
process.exit(1);
});
serverDomain.run(run);
var db = sublevel(level(config.dbPath, config.levelOptions));
// setup sublevels
var sublevels = {};
_(config.subLevels).each(function(sublevelName) {
sublevels[sublevelName] = db.sublevel(sublevelName);
});
function run() {
var transactions = [];
var stats = [];
console.log("Starting transaction file recovery");
async.series([
function (sCb) {
readTransactions({
'use strict';
var data = require('./src/data');
var renderer = require('./src/renderer');
var nav = require('./src/navigation');
var notification = require('./src/notification');
var config = require('./src/config');
var flags = require('./src/watchflags');
var _ = require('./src/localization');
var level = require('level');
var utils = require('./src/utils');
var open = require('open');
var db = level('./jsnews-cache');
var currentGroup = -1;
var currentPost = null;
var STATE_LOADING = -1;
var caches = {
group: STATE_LOADING,
groupLike: STATE_LOADING,
groupComment: STATE_LOADING,
postLike: STATE_LOADING,
postComment: STATE_LOADING,
postCommentLike: STATE_LOADING
};
var cacheKeys = Object.keys(caches);
var lastCreatedPosts = [];
var FB = null;
var stopRender = false;
var follows = [];
var level = require('level');
var db = level('/tmp/build-server.db', {
keyEncoding: require('bytewise'),
valueEncoding: 'json'
});
var store = require('content-addressable-blob-store')({
path: '/tmp/build-server.blob'
});
var ASSERT = require('assert').ok
var logger = require('..')
var level = require('level')
var db = level(__dirname + '/db1', { valueEncoding: 'json' })
describe('the client', function() {
it('should be enabled and disabled on SIGUSR2', function(done) {
var client = logger.createClient()
var server = logger.createServer({ db: db })
var count = 0
server.on('log', function(data) {
++count
})
client.next = { foo: 100 }
process.kill(process.pid, 'SIGUSR2')
setTimeout(function() {
client.next = { foo: 100 }
ASSERT(count == 1)
done()
}, 100)
})
})
var level = require('level');
var db = level('/tmp/build-server.db');
var compute = require('batchdb-shell')(db, { path: '/tmp/build-server.blob' });
compute.run();
var http = require('http');
var api = require('batchdb-web-api')(compute);
var ui = require('batchdb-web-ui')(compute);
var server = http.createServer(function (req, res) {
if (api.exec(req, res)) return;
res.statusCode = 404;
res.end('not found\n');
});
server.listen(5000);
'use strict';
var path = require('path')
, type = require('../lib/type')
, printKey = require('../lib/print-key')
, key = require('../lib/key-by-values')
, vehicles = require('./sample-data').vehicles
var level = require('level')
, dblocation = path.join(__dirname, '..', 'data/index-keywords.db');
var db = level(dblocation, { valueEncoding: 'utf8' }, function () {
var indexes = key(vehicles);
db.batch(
type.del(indexes).concat(type.put(indexes))
, function () {
db.createReadStream({
keys : true
, values : false
, start : 'slow'
, end : 'slow\xff'
})
.on('data', printKey)
.on('close', function () { db.close() })
}
)
})
module.exports = function () {
return level(
__dirname + '/../data/skills.db',
{ valueEncoding: 'json' }
);
};
const level = require('level');
const chainDB = './validation';
const db = level(chainDB);
// Add data to levelDB with key/value pair
exports.addLevelDBData = function (key, data) {
return new Promise(function (resolve, reject) {
db.put(key, data, function (error) {
if (error) {
reject('Block ' + key + ' submission failed', error);
} else {
resolve(data);
}
});
});
};
// Get data from levelDB with key
exports.getLevelDBData = function (key) {
return new Promise(function (resolve, reject) {
db.get(key, function (error, response) {
if (error) {
reject('Not found!', error);
} else {
resolve(JSON.parse(response));
}
});
});
};