1124 lines
24 KiB
JavaScript
1124 lines
24 KiB
JavaScript
/**
|
|
* db.js - db object for bcoin
|
|
* Copyright (c) 2014-2015, Fedor Indutny (MIT License)
|
|
* https://github.com/indutny/bcoin
|
|
*/
|
|
|
|
var bcoin = require('../bcoin');
|
|
var utils = bcoin.utils;
|
|
var assert = utils.assert;
|
|
var levelup = require('levelup');
|
|
var inherits = require('inherits');
|
|
var EventEmitter = require('events').EventEmitter;
|
|
var network = bcoin.protocol.network;
|
|
var fs = bcoin.fs;
|
|
|
|
/**
|
|
* BlockDB
|
|
*/
|
|
|
|
function BlockDB(options) {
|
|
var self = this;
|
|
|
|
if (!(this instanceof BlockDB))
|
|
return new BlockDB(options);
|
|
|
|
EventEmitter.call(this);
|
|
|
|
if (!options)
|
|
options = {};
|
|
|
|
this.file = options.indexFile;
|
|
|
|
if (!this.file)
|
|
this.file = process.env.HOME + '/bcoin-index-' + network.type + '.db';
|
|
|
|
this.options = options;
|
|
|
|
this.parser = new bcoin.protocol.parser();
|
|
|
|
this.data = new BlockData(options);
|
|
|
|
this.cache = {
|
|
unspent: new bcoin.lru(32 * 1024 * 1024),
|
|
tx: new bcoin.lru(32 * 1024 * 1024)
|
|
};
|
|
|
|
this.index = new levelup(this.file, {
|
|
keyEncoding: 'ascii',
|
|
valueEncoding: 'binary',
|
|
createIfMissing: true,
|
|
errorIfExists: false,
|
|
compression: true,
|
|
cacheSize: 16 * 1024 * 1024,
|
|
writeBufferSize: 8 * 1024 * 1024,
|
|
// blockSize: 4 * 1024,
|
|
maxOpenFiles: 8192,
|
|
// blockRestartInterval: 16,
|
|
db: bcoin.isBrowser
|
|
? require('memdown')
|
|
: require('level' + 'down')
|
|
});
|
|
}
|
|
|
|
inherits(BlockDB, EventEmitter);
|
|
|
|
BlockDB.prototype.migrate = function migrate(blockSize, compression, callback) {
|
|
var options, db, pending, stream, total, done;
|
|
|
|
options = utils.merge({}, this.index.options);
|
|
|
|
if (blockSize != null)
|
|
options.blockSize = blockSize;
|
|
|
|
if (compression != null)
|
|
options.compression = compression;
|
|
|
|
options.maxOpenFiles = 60000;
|
|
|
|
utils.print('Migrating DB with options:');
|
|
utils.print(options);
|
|
|
|
db = levelup(this.file + '.migrated', options);
|
|
|
|
stream = this.index.createReadStream();
|
|
|
|
pending = 0;
|
|
total = 0;
|
|
|
|
function onPut(err) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (++total % 10000 === 0)
|
|
utils.print('%d written.', total);
|
|
|
|
pending--;
|
|
|
|
if (done && !pending)
|
|
callback();
|
|
}
|
|
|
|
stream.on('data', function(data) {
|
|
pending++;
|
|
db.put(data.key, data.value, onPut);
|
|
});
|
|
|
|
stream.on('error', function(err) {
|
|
callback(err);
|
|
});
|
|
|
|
stream.on('end', function() {
|
|
done = true;
|
|
if (!pending)
|
|
callback();
|
|
});
|
|
};
|
|
|
|
BlockDB.prototype.createOffset = function createOffset(size, offset, height) {
|
|
var buf = new Buffer(16);
|
|
utils.writeU32(buf, size, 0);
|
|
utils.writeU64(buf, offset, 4);
|
|
utils.writeU32(buf, height, 12);
|
|
return buf;
|
|
};
|
|
|
|
BlockDB.prototype.parseOffset = function parseOffset(data) {
|
|
// Avoid using bignumbers here to increase performance.
|
|
// This is safe because this number will never exceed
|
|
// 53 bits (up to 8.3 petabytes).
|
|
var hi = utils.readU32(data, 8);
|
|
var lo = utils.readU32(data, 4);
|
|
return {
|
|
size: utils.readU32(data, 0),
|
|
offset: (hi * 0x100000000) + lo,
|
|
height: utils.readU32(data, 12)
|
|
};
|
|
};
|
|
|
|
BlockDB.prototype.saveBlock = function saveBlock(block, callback) {
|
|
var self = this;
|
|
|
|
this.data.saveAsync(block._raw, function(err, data) {
|
|
var batch, blockOffset;
|
|
|
|
if (err)
|
|
return callback(err);
|
|
|
|
batch = self.index.batch();
|
|
|
|
blockOffset = self.createOffset(data.size, data.offset, block.height);
|
|
|
|
batch.put('b/b/' + block.hash('hex'), blockOffset);
|
|
batch.put('b/h/' + block.height, blockOffset);
|
|
|
|
block.txs.forEach(function(tx, i) {
|
|
var hash = tx.hash('hex');
|
|
var uniq = {};
|
|
var txOffset;
|
|
|
|
txOffset = self.createOffset(
|
|
tx._size,
|
|
data.offset + tx._offset,
|
|
block.height
|
|
);
|
|
|
|
batch.put('t/t/' + hash, txOffset);
|
|
|
|
tx.inputs.forEach(function(input) {
|
|
var type = input.getType();
|
|
var address = input.getAddress();
|
|
var uaddr;
|
|
|
|
if (type === 'pubkey' || type === 'multisig')
|
|
address = null;
|
|
|
|
uaddr = address;
|
|
|
|
if (uaddr) {
|
|
if (!uniq[uaddr])
|
|
uniq[uaddr] = true;
|
|
else
|
|
uaddr = null;
|
|
}
|
|
|
|
if (uaddr)
|
|
batch.put('t/a/' + uaddr + '/' + hash, txOffset);
|
|
|
|
if (address) {
|
|
batch.del(
|
|
'u/a/' + address
|
|
+ '/' + input.prevout.hash
|
|
+ '/' + input.prevout.index);
|
|
}
|
|
|
|
batch.del('u/t/' + input.prevout.hash + '/' + input.prevout.index);
|
|
|
|
if (self.options.cache)
|
|
self.cache.unspent.remove(input.prevout.hash + '/' + input.prevout.index);
|
|
});
|
|
|
|
tx.outputs.forEach(function(output) {
|
|
var type = output.getType();
|
|
var address = output.getAddress();
|
|
var uaddr, coinOffset;
|
|
|
|
if (type === 'pubkey' || type === 'multisig')
|
|
address = null;
|
|
|
|
uaddr = address;
|
|
|
|
if (uaddr) {
|
|
if (!uniq[uaddr])
|
|
uniq[uaddr] = true;
|
|
else
|
|
uaddr = null;
|
|
}
|
|
|
|
coinOffset = self.createOffset(
|
|
output._size,
|
|
data.offset + tx._offset + output._offset,
|
|
block.height
|
|
);
|
|
|
|
if (uaddr)
|
|
batch.put('t/a/' + uaddr + '/' + hash, txOffset);
|
|
|
|
if (address)
|
|
batch.put('u/a/' + address + '/' + hash + '/' + i, coinOffset);
|
|
|
|
batch.put('u/t/' + hash + '/' + i, coinOffset);
|
|
});
|
|
});
|
|
|
|
batch.write(callback);
|
|
});
|
|
};
|
|
|
|
BlockDB.prototype.removeBlock = function removeBlock(hash, callback) {
|
|
var self = this;
|
|
|
|
this.getBlock(hash, function(err, block) {
|
|
var batch, pending;
|
|
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (!block)
|
|
return callback();
|
|
|
|
pending = block.txs.length;
|
|
|
|
batch = self.index.batch();
|
|
|
|
batch.del('b/b/' + hash);
|
|
batch.del('b/h/' + block.height);
|
|
|
|
function done() {
|
|
batch.write(function(err) {
|
|
if (err)
|
|
return callback(err);
|
|
return callback(null, block);
|
|
});
|
|
}
|
|
|
|
if (!pending)
|
|
return done();
|
|
|
|
block.txs.forEach(function(tx, i) {
|
|
var hash = tx.hash('hex');
|
|
var uniq = {};
|
|
|
|
batch.del('t/t/' + hash);
|
|
|
|
self.fillTX(tx, function(err) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
tx.inputs.forEach(function(input) {
|
|
var type = input.getType();
|
|
var address = input.getAddress();
|
|
var uaddr, coinOffset;
|
|
|
|
if (type === 'pubkey' || type === 'multisig')
|
|
address = null;
|
|
|
|
uaddr = address;
|
|
|
|
if (uaddr) {
|
|
if (!uniq[uaddr])
|
|
uniq[uaddr] = true;
|
|
else
|
|
uaddr = null;
|
|
}
|
|
|
|
if (uaddr)
|
|
batch.del('t/a/' + uaddr + '/' + hash);
|
|
|
|
coinOffset = self.createOffset(
|
|
input.output._size,
|
|
block._fileOffset + tx._offset + input.output._offset,
|
|
block.height
|
|
);
|
|
|
|
if (address) {
|
|
batch.put('u/a/' + address
|
|
+ '/' + input.output.hash
|
|
+ '/' + input.output.index,
|
|
coinOffset);
|
|
}
|
|
|
|
batch.put('u/t/'
|
|
+ input.output.hash
|
|
+ '/' + input.output.index,
|
|
coinOffset);
|
|
});
|
|
|
|
tx.outputs.forEach(function(output) {
|
|
var type = output.getType();
|
|
var address = output.getAddress();
|
|
var uaddr;
|
|
|
|
if (type === 'pubkey' || type === 'multisig')
|
|
address = null;
|
|
|
|
uaddr = address;
|
|
|
|
if (uaddr) {
|
|
if (!uniq[uaddr])
|
|
uniq[uaddr] = true;
|
|
else
|
|
uaddr = null;
|
|
}
|
|
|
|
if (uaddr)
|
|
batch.del('t/a/' + uaddr + '/' + hash);
|
|
|
|
if (address)
|
|
batch.del('u/a/' + address + '/' + hash + '/' + i);
|
|
|
|
batch.del('u/t/' + hash + '/' + i);
|
|
});
|
|
|
|
if (!--pending)
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
};
|
|
|
|
BlockDB.prototype.fillCoins = function fillCoins(txs, callback) {
|
|
var self = this;
|
|
var pending = txs.length;
|
|
|
|
callback = utils.asyncify(callback);
|
|
|
|
if (!pending)
|
|
return callback();
|
|
|
|
txs.forEach(function(tx) {
|
|
self.fillCoin(tx, function(err) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (!--pending)
|
|
callback();
|
|
});
|
|
});
|
|
};
|
|
|
|
BlockDB.prototype.fillTXs = function fillTXs(txs, callback) {
|
|
var self = this;
|
|
var pending = txs.length;
|
|
|
|
callback = utils.asyncify(callback);
|
|
|
|
if (!pending)
|
|
return callback();
|
|
|
|
txs.forEach(function(tx) {
|
|
self.fillTX(tx, function(err) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (!--pending)
|
|
callback();
|
|
});
|
|
});
|
|
};
|
|
|
|
BlockDB.prototype.fillCoin = function fillCoin(tx, callback) {
|
|
var self = this;
|
|
var pending = tx.inputs.length;
|
|
|
|
callback = utils.asyncify(callback);
|
|
|
|
if (!pending)
|
|
return callback();
|
|
|
|
tx.inputs.forEach(function(input) {
|
|
if (input.output) {
|
|
if (!--pending)
|
|
callback(null, tx);
|
|
return;
|
|
}
|
|
self.getCoin(input.prevout.hash, input.prevout.index, function(err, coin) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (coin)
|
|
input.output = coin;
|
|
|
|
if (!--pending)
|
|
callback(null, tx);
|
|
});
|
|
});
|
|
};
|
|
|
|
BlockDB.prototype.fillTX = function fillTX(tx, callback) {
|
|
var self = this;
|
|
var pending = tx.inputs.length;
|
|
|
|
callback = utils.asyncify(callback);
|
|
|
|
if (!pending)
|
|
return callback();
|
|
|
|
tx.inputs.forEach(function(input) {
|
|
if (input.output) {
|
|
if (!--pending)
|
|
callback(null, tx);
|
|
return;
|
|
}
|
|
self.getTX(input.prevout.hash, function(err, tx) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (tx)
|
|
input.output = bcoin.coin(tx, input.prevout.index);
|
|
|
|
if (!--pending)
|
|
callback(null, tx);
|
|
});
|
|
});
|
|
};
|
|
|
|
BlockDB.prototype.getCoinsByAddress = function getCoinsByAddress(addresses, callback) {
|
|
var self = this;
|
|
var coins = [];
|
|
var pending;
|
|
|
|
if (typeof addresses === 'string')
|
|
addresses = [addresses];
|
|
|
|
addresses = utils.uniqs(addresses);
|
|
|
|
pending = addresses.length;
|
|
|
|
addresses.forEach(function(address) {
|
|
self._getCoinsByAddress(address, function(err, coin) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (coin)
|
|
coins = coins.concat(coin);
|
|
|
|
if (!--pending)
|
|
return callback(null, coins);
|
|
});
|
|
});
|
|
};
|
|
|
|
BlockDB.prototype._getCoinsByAddress = function _getCoinsByAddress(address, callback) {
|
|
var self = this;
|
|
var pending = 0;
|
|
var coins = [];
|
|
var done = false;
|
|
var stream;
|
|
|
|
callback = utils.asyncify(callback);
|
|
|
|
/*
|
|
stream = this.index.createKeyStream({
|
|
start: 'u/a/' + address,
|
|
end: 'u/a/' + address + '~'
|
|
});
|
|
|
|
stream.on('data', function(key) {
|
|
var parts = key.split('/').slice(3);
|
|
var hash = parts[0];
|
|
var index = +parts[1];
|
|
pending++;
|
|
self.index.get('u/t/' + hash + '/' + index, function(err, data) {
|
|
if (err && err.type !== 'NotFoundError')
|
|
return callback(err);
|
|
if (data)
|
|
coins.push(data);
|
|
pending--;
|
|
if (done) {
|
|
if (!pending)
|
|
return callback(null, coins);
|
|
}
|
|
});
|
|
});
|
|
*/
|
|
|
|
stream = this.index.createReadStream({
|
|
start: 'u/a/' + address,
|
|
end: 'u/a/' + address + '~'
|
|
});
|
|
|
|
stream.on('data', function(data) {
|
|
var parts = data.key.split('/').slice(3);
|
|
var hash = parts[0];
|
|
var index = +parts[1];
|
|
var id = hash + '/' + index;
|
|
var record = self.parseOffset(data.value);
|
|
|
|
pending++;
|
|
|
|
if (self.options.cache && self.cache.unspent.has(id)) {
|
|
coins.push(self.cache.unspent.get(id));
|
|
pending--;
|
|
if (done) {
|
|
if (!pending)
|
|
return callback(null, coins);
|
|
}
|
|
return;
|
|
}
|
|
|
|
self.data.getAsync(record.size, record.offset, function(err, data) {
|
|
var coin;
|
|
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (data) {
|
|
try {
|
|
data = self.parser.parseTXOut(data);
|
|
} catch (e) {
|
|
return callback(e);
|
|
}
|
|
|
|
coin = bcoin.coin({
|
|
version: 1,
|
|
hash: hash,
|
|
index: index,
|
|
height: record.height,
|
|
script: data.script,
|
|
value: data.value,
|
|
spent: false
|
|
});
|
|
|
|
if (self.options.cache)
|
|
self.cache.unspent.set(id, coin);
|
|
|
|
coins.push(coin);
|
|
}
|
|
|
|
pending--;
|
|
|
|
if (done) {
|
|
if (!pending)
|
|
return callback(null, coins);
|
|
}
|
|
});
|
|
});
|
|
|
|
stream.on('error', function(err) {
|
|
return callback(err);
|
|
});
|
|
|
|
stream.on('end', function() {
|
|
done = true;
|
|
if (!pending)
|
|
return callback(null, coins);
|
|
});
|
|
};
|
|
|
|
BlockDB.prototype.getCoin = function getCoin(hash, index, callback) {
|
|
var self = this;
|
|
var id = 'u/t/' + hash + '/' + index;
|
|
|
|
this.index.get(id, function(err, record) {
|
|
if (err) {
|
|
if (err.type === 'NotFoundError')
|
|
return callback();
|
|
return callback(err);
|
|
}
|
|
|
|
record = self.parseOffset(record);
|
|
|
|
self.data.getAsync(record.size, record.offset, function(err, data) {
|
|
var coin;
|
|
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (data) {
|
|
try {
|
|
data = self.parser.parseTXOut(data);
|
|
} catch (e) {
|
|
return callback(e);
|
|
}
|
|
coin = bcoin.coin({
|
|
version: 1,
|
|
hash: hash,
|
|
index: index,
|
|
height: record.height,
|
|
script: data.script,
|
|
value: data.value,
|
|
spent: false
|
|
});
|
|
}
|
|
|
|
return callback(null, coin);
|
|
});
|
|
});
|
|
};
|
|
|
|
BlockDB.prototype.getTXByAddress = function getTXByAddress(addresses, callback) {
|
|
var self = this;
|
|
var txs = [];
|
|
var pending;
|
|
|
|
if (typeof addresses === 'string')
|
|
addresses = [addresses];
|
|
|
|
addresses = utils.uniqs(addresses);
|
|
|
|
pending = addresses.length;
|
|
|
|
if (!pending)
|
|
return callback(null, txs);
|
|
|
|
addresses.forEach(function(address) {
|
|
self._getTXByAddress(address, function(err, tx) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (tx)
|
|
txs = txs.concat(tx);
|
|
|
|
if (!--pending)
|
|
return callback(null, txs);
|
|
});
|
|
});
|
|
};
|
|
|
|
BlockDB.prototype._getTXByAddress = function _getTXByAddress(address, callback) {
|
|
var self = this;
|
|
var pending = 0;
|
|
var txs = [];
|
|
var done = false;
|
|
var stream;
|
|
|
|
callback = utils.asyncify(callback);
|
|
|
|
stream = this.index.createReadStream({
|
|
start: 't/a/' + address,
|
|
end: 't/a/' + address + '~'
|
|
});
|
|
|
|
stream.on('data', function(data) {
|
|
var parts = data.key.split('/').slice(3);
|
|
var hash = parts[0];
|
|
var record = self.parseOffset(data.value);
|
|
|
|
pending++;
|
|
|
|
if (self.options.cache && self.cache.tx.has(hash)) {
|
|
coins.push(self.cache.tx.get(hash));
|
|
pending--;
|
|
if (done) {
|
|
if (!pending)
|
|
return callback(null, coins);
|
|
}
|
|
return;
|
|
}
|
|
|
|
self.data.getAsync(record.size, record.offset, function(err, data) {
|
|
var tx, entry;
|
|
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (data) {
|
|
try {
|
|
tx = bcoin.tx.fromRaw(data);
|
|
entry = bcoin.chain.global.db.get(record.height);
|
|
assert(entry);
|
|
} catch (e) {
|
|
return callback(e);
|
|
}
|
|
|
|
tx.height = record.height;
|
|
tx.ts = entry.ts;
|
|
tx.block = entry.hash;
|
|
txs.push(tx);
|
|
|
|
if (self.options.cache)
|
|
self.cache.tx.set(hash, tx);
|
|
|
|
if (self.options.paranoid && tx.hash('hex') !== hash)
|
|
return callback(new Error('BlockDB is corrupt. All is lost.'));
|
|
}
|
|
|
|
pending--;
|
|
|
|
if (done) {
|
|
if (!pending)
|
|
return callback(null, txs);
|
|
}
|
|
});
|
|
});
|
|
|
|
stream.on('error', function(err) {
|
|
return callback(err);
|
|
});
|
|
|
|
stream.on('end', function() {
|
|
done = true;
|
|
if (!pending)
|
|
return callback(null, txs);
|
|
});
|
|
};
|
|
|
|
BlockDB.prototype.getTX = function getTX(hash, callback) {
|
|
var self = this;
|
|
var id = 't/t/' + hash;
|
|
|
|
this.index.get(id, function(err, record) {
|
|
if (err) {
|
|
if (err.type === 'NotFoundError')
|
|
return callback();
|
|
return callback(err);
|
|
}
|
|
|
|
record = self.parseOffset(record);
|
|
|
|
self.data.getAsync(record.size, record.offset, function(err, data) {
|
|
var tx, entry;
|
|
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (data) {
|
|
try {
|
|
tx = bcoin.tx.fromRaw(data);
|
|
entry = bcoin.chain.global.db.get(record.height);
|
|
assert(entry);
|
|
} catch (e) {
|
|
return callback(e);
|
|
}
|
|
tx.height = record.height;
|
|
tx.ts = entry.ts;
|
|
tx.block = entry.hash;
|
|
if (self.options.paranoid && tx.hash('hex') !== hash)
|
|
return callback(new Error('BlockDB is corrupt. All is lost.'));
|
|
}
|
|
|
|
return callback(null, tx);
|
|
});
|
|
});
|
|
};
|
|
|
|
BlockDB.prototype.getBlock = function getBlock(hash, callback) {
|
|
var self = this;
|
|
var id = 'b/b/' + value;
|
|
|
|
if (typeof hash === 'number')
|
|
id = 'b/h/' + value;
|
|
|
|
this.index.get(id, function(err, record) {
|
|
if (err) {
|
|
if (err.type === 'NotFoundError')
|
|
return callback();
|
|
return callback(err);
|
|
}
|
|
|
|
record = self.parseOffset(record);
|
|
|
|
self.data.getAsync(record.size, record.offset, function(err, data) {
|
|
var block;
|
|
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (data) {
|
|
try {
|
|
block = bcoin.block.fromRaw(data);
|
|
} catch (e) {
|
|
return callback(e);
|
|
}
|
|
block._fileOffset = record.offset;
|
|
block.height = record.height;
|
|
if (self.options.paranoid) {
|
|
if (typeof hash === 'number') {
|
|
hash = bcoin.chain.global.get(hash);
|
|
if (!hash)
|
|
return callback(null, block);
|
|
hash = hash.hash;
|
|
}
|
|
if (block.hash('hex') !== hash)
|
|
return callback(new Error('BlockDB is corrupt. All is lost.'));
|
|
}
|
|
}
|
|
|
|
return callback(null, block);
|
|
});
|
|
});
|
|
};
|
|
|
|
BlockDB.prototype.hasCoin = function hasCoin(hash, index, callback) {
|
|
var id = 'u/t/' + hash + '/' + index;
|
|
|
|
this.index.get(id, function(err, record) {
|
|
if (err && err.type !== 'NotFoundError')
|
|
return callback(err);
|
|
|
|
return callback(null, record ? true : false);
|
|
});
|
|
};
|
|
|
|
BlockDB.prototype.hasTX = function hasTX(hash, callback) {
|
|
var id = 't/t/' + hash;
|
|
|
|
this.index.get(id, function(err, record) {
|
|
if (err && err.type !== 'NotFoundError')
|
|
return callback(err);
|
|
|
|
return callback(null, record ? true : false);
|
|
});
|
|
};
|
|
|
|
BlockDB.prototype.isSpent = function isSpent(hash, index, callback) {
|
|
return this.hasCoin(hash, index, function(err, result) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
return callback(null, !result);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* BlockData
|
|
*/
|
|
|
|
function BlockData(options) {
|
|
if (!(this instanceof BlockData))
|
|
return new BlockData(options);
|
|
|
|
if (!options)
|
|
options = {};
|
|
|
|
this.options = options;
|
|
this.file = options.blockFile;
|
|
|
|
if (!this.file)
|
|
this.file = process.env.HOME + '/bcoin-block-' + network.type + '.db';
|
|
|
|
this._bufferPool = { used: {} };
|
|
this.size = 0;
|
|
this.fd = null;
|
|
|
|
this._init();
|
|
}
|
|
|
|
BlockData.prototype._init = function _init() {
|
|
if (!bcoin.fs) {
|
|
utils.debug('`fs` module not available. Falling back to ramdisk.');
|
|
this.ramdisk = new bcoin.ramdisk(40 * 1024 * 1024);
|
|
return;
|
|
}
|
|
|
|
if (+process.env.BCOIN_FRESH === 1) {
|
|
try {
|
|
fs.unlinkSync(this.file);
|
|
} catch (e) {
|
|
;
|
|
}
|
|
}
|
|
|
|
if (!this.exists())
|
|
fs.writeFileSync(this.file, new Buffer([]));
|
|
|
|
this.size = this.getSize();
|
|
|
|
this.fd = fs.openSync(this.file, 'r+');
|
|
};
|
|
|
|
BlockData.prototype._malloc = function(size) {
|
|
if (size > 500)
|
|
return new Buffer(size);
|
|
|
|
if (!this._bufferPool[size])
|
|
this._bufferPool[size] = new Buffer(size);
|
|
|
|
if (this._bufferPool.used[size] === this._bufferPool[size])
|
|
return new Buffer(size);
|
|
|
|
this._bufferPool.used[size] = this._bufferPool[size];
|
|
|
|
return this._bufferPool[size];
|
|
};
|
|
|
|
BlockData.prototype._free = function(buf) {
|
|
if (this._bufferPool.used[buf.length] === buf) {
|
|
assert(this._bufferPool[buf.length] === buf);
|
|
delete this._bufferPool.used[buf.length];
|
|
}
|
|
};
|
|
|
|
BlockData.prototype.exists = function exists() {
|
|
if (!bcoin.fs)
|
|
return true;
|
|
|
|
try {
|
|
fs.statSync(this.file);
|
|
return true;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
BlockData.prototype.getSize = function getSize() {
|
|
if (!bcoin.fs)
|
|
return this.ramdisk.size;
|
|
|
|
try {
|
|
return fs.statSync(this.file).size;
|
|
} catch (e) {
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
BlockData.prototype.getSync = function getSync(size, offset) {
|
|
return this._readSync(size, offset);
|
|
};
|
|
|
|
BlockData.prototype.getAsync = function getAsync(size, offset, callback) {
|
|
var self = this;
|
|
|
|
callback = utils.asyncify(callback);
|
|
|
|
return this._readAsync(size, offset, callback);
|
|
};
|
|
|
|
BlockData.prototype.saveSync = function saveSync(data) {
|
|
var self = this;
|
|
var offset = this.size;
|
|
|
|
this._writeSync(data, offset);
|
|
|
|
return { size: data.length, offset: offset };
|
|
};
|
|
|
|
BlockData.prototype.saveAsync = function saveAsync(data, callback) {
|
|
var self = this;
|
|
var offset = this.size;
|
|
|
|
callback = utils.asyncify(callback);
|
|
|
|
return this._writeAsync(data, offset, function(err, success) {
|
|
if (err)
|
|
return callback(err);
|
|
return callback(null, { size: data.length, offset: offset });
|
|
});
|
|
};
|
|
|
|
BlockData.prototype.truncate = function truncate(size) {
|
|
this.size = size;
|
|
|
|
if (!bcoin.fs) {
|
|
this.ramdisk.truncate(this.size);
|
|
return;
|
|
}
|
|
|
|
fs.ftruncateSync(this.fd, this.size);
|
|
};
|
|
|
|
BlockData.prototype._readSync = function _readSync(size, offset) {
|
|
var index = 0;
|
|
var data, bytes;
|
|
|
|
if (offset < 0 || offset == null)
|
|
return;
|
|
|
|
if (!bcoin.fs)
|
|
return this.ramdisk.read(size, offset);
|
|
|
|
data = this._malloc(size);
|
|
|
|
try {
|
|
while (bytes = fs.readSync(this.fd, data, index, size, offset)) {
|
|
index += bytes;
|
|
size -= bytes;
|
|
offset += bytes;
|
|
if (index === data.length) {
|
|
this._free(data);
|
|
return data;
|
|
}
|
|
}
|
|
} catch (e) {
|
|
this._free(data);
|
|
throw e;
|
|
}
|
|
|
|
this._free(data);
|
|
|
|
throw new Error('_readSync() failed.');
|
|
};
|
|
|
|
BlockData.prototype._readAsync = function _readAsync(size, offset, callback) {
|
|
var self = this;
|
|
var index = 0;
|
|
var data, bytes;
|
|
|
|
callback = utils.asyncify(callback);
|
|
|
|
if (offset < 0 || offset == null)
|
|
return callback();
|
|
|
|
if (!bcoin.fs)
|
|
return callback(null, this.ramdisk.read(size, offset));
|
|
|
|
data = this._malloc(size);
|
|
|
|
(function next() {
|
|
fs.read(self.fd, data, index, size, offset, function(err, bytes) {
|
|
if (err) {
|
|
self._free(data);
|
|
return callback(err);
|
|
}
|
|
|
|
index += bytes;
|
|
size -= bytes;
|
|
offset += bytes;
|
|
|
|
if (index === data.length) {
|
|
self._free(data);
|
|
return callback(null, data);
|
|
}
|
|
|
|
next();
|
|
});
|
|
})();
|
|
};
|
|
|
|
BlockData.prototype._writeSync = function _writeSync(data, offset) {
|
|
var size = data.length;
|
|
var added = Math.max(0, (offset + data.length) - this.size);
|
|
var index = 0;
|
|
var bytes;
|
|
|
|
if (offset < 0 || offset == null)
|
|
return false;
|
|
|
|
if (!bcoin.fs) {
|
|
this.size += added;
|
|
this.ramdisk.write(data, offset);
|
|
return;
|
|
}
|
|
|
|
try {
|
|
while (bytes = fs.writeSync(this.fd, data, index, size, offset)) {
|
|
index += bytes;
|
|
size -= bytes;
|
|
offset += bytes;
|
|
if (index === data.length) {
|
|
this.size += added;
|
|
return true;
|
|
}
|
|
}
|
|
} catch (e) {
|
|
throw e;
|
|
}
|
|
|
|
throw new Error('_writeSync() failed.');
|
|
};
|
|
|
|
BlockData.prototype._writeAsync = function _writeAsync(data, offset, callback) {
|
|
var self = this;
|
|
var added = Math.max(0, (offset + data.length) - this.size);
|
|
var size = data.length;
|
|
var index = 0;
|
|
|
|
callback = utils.asyncify(callback);
|
|
|
|
if (offset < 0 || offset == null)
|
|
return callback(null, false);
|
|
|
|
if (!bcoin.fs) {
|
|
this.size += added;
|
|
this.ramdisk.write(data, offset);
|
|
return callback(null, true);
|
|
}
|
|
|
|
this.size += added;
|
|
|
|
(function next() {
|
|
fs.write(self.fd, data, index, size, offset, function(err, bytes) {
|
|
if (err) {
|
|
self.size -= (added - index);
|
|
return callback(err);
|
|
}
|
|
|
|
index += bytes;
|
|
size -= bytes;
|
|
offset += bytes;
|
|
|
|
if (index === data.length)
|
|
return callback(null, true);
|
|
|
|
next();
|
|
});
|
|
})();
|
|
};
|
|
|
|
/**
|
|
* Expose
|
|
*/
|
|
|
|
module.exports = BlockDB;
|