503 lines
11 KiB
JavaScript
503 lines
11 KiB
JavaScript
/**
|
|
* chaindb.js - blockchain data management for bcoin
|
|
* Copyright (c) 2014-2015, Fedor Indutny (MIT License)
|
|
* https://github.com/indutny/bcoin
|
|
*/
|
|
|
|
var inherits = require('inherits');
|
|
var EventEmitter = require('events').EventEmitter;
|
|
|
|
var bcoin = require('../bcoin');
|
|
var bn = require('bn.js');
|
|
var constants = bcoin.protocol.constants;
|
|
var network = bcoin.protocol.network;
|
|
var utils = bcoin.utils;
|
|
var assert = utils.assert;
|
|
var fs = bcoin.fs;
|
|
|
|
var BLOCK_SIZE = bcoin.chainblock.BLOCK_SIZE;
|
|
|
|
/**
|
|
* ChainDB
|
|
*/
|
|
|
|
function ChainDB(chain, options) {
|
|
if (!(this instanceof ChainDB))
|
|
return new ChainDB(chain, options);
|
|
|
|
if (!options)
|
|
options = {};
|
|
|
|
this.options = options;
|
|
this.chain = chain;
|
|
this.file = options.file;
|
|
|
|
if (!this.file)
|
|
this.file = process.env.HOME + '/bcoin-chain-' + network.type + '.db';
|
|
|
|
this._queue = [];
|
|
this._cache = {};
|
|
this._bufferPool = { used: {} };
|
|
this._nullBlock = new Buffer(BLOCK_SIZE);
|
|
this._nullBlock.fill(0);
|
|
this.tip = -1;
|
|
this.size = 0;
|
|
this.fd = null;
|
|
|
|
// Need to cache up to the retarget interval
|
|
// if we're going to be checking the damn
|
|
// target all the time.
|
|
if (network.powAllowMinDifficultyBlocks)
|
|
this._cacheWindow = network.powDiffInterval + 1;
|
|
else
|
|
this._cacheWindow = network.block.majorityWindow + 1;
|
|
|
|
this._init();
|
|
}
|
|
|
|
ChainDB.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();
|
|
|
|
if (this.size % BLOCK_SIZE !== 0) {
|
|
utils.debug('Blockchain is at an odd length. Truncating.');
|
|
fs.truncateSync(this.file, this.size - (this.size % BLOCK_SIZE));
|
|
this.size = this.getSize();
|
|
assert(this.size % BLOCK_SIZE === 0);
|
|
}
|
|
|
|
this.fd = fs.openSync(this.file, 'r+');
|
|
};
|
|
|
|
ChainDB.prototype._malloc = function(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];
|
|
};
|
|
|
|
ChainDB.prototype._free = function(buf) {
|
|
if (this._bufferPool.used[buf.length] === buf) {
|
|
assert(this._bufferPool[buf.length] === buf);
|
|
delete this._bufferPool.used[buf.length];
|
|
}
|
|
};
|
|
|
|
ChainDB.prototype.exists = function exists() {
|
|
if (!bcoin.fs)
|
|
return true;
|
|
|
|
try {
|
|
fs.statSync(this.file);
|
|
return true;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
ChainDB.prototype.getSize = function getSize() {
|
|
if (!bcoin.fs)
|
|
return this.ramdisk.size;
|
|
|
|
try {
|
|
return fs.statSync(this.file).size;
|
|
} catch (e) {
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
ChainDB.prototype.count = function count() {
|
|
var len = this.size / BLOCK_SIZE;
|
|
assert(len % 1 === 0);
|
|
return len;
|
|
};
|
|
|
|
ChainDB.prototype.cache = function cache(entry) {
|
|
if (entry.height > this.tip) {
|
|
this.tip = entry.height;
|
|
delete this._cache[entry.height - this._cacheWindow];
|
|
this._cache[entry.height] = entry;
|
|
assert(Object.keys(this._cache).length <= this._cacheWindow);
|
|
}
|
|
};
|
|
|
|
ChainDB.prototype.get = function get(height) {
|
|
return this.getSync(height);
|
|
};
|
|
|
|
ChainDB.prototype.getSync = function getSync(height) {
|
|
var data, entry;
|
|
|
|
if (this._cache[height])
|
|
return this._cache[height];
|
|
|
|
if (this._queue[height])
|
|
return this._queue[height];
|
|
|
|
if (height < 0 || height == null)
|
|
return;
|
|
|
|
if ((height + 1) * BLOCK_SIZE > this.size)
|
|
return;
|
|
|
|
data = this._readSync(BLOCK_SIZE, height * BLOCK_SIZE);
|
|
|
|
if (!data)
|
|
return;
|
|
|
|
// Ignore if it is a null block.
|
|
if (utils.read32(data, 0) === 0)
|
|
return;
|
|
|
|
entry = bcoin.chainblock.fromRaw(this.chain, height, data);
|
|
|
|
// Cache the past 1001 blocks in memory
|
|
// (necessary for isSuperMajority)
|
|
this.cache(entry);
|
|
|
|
return entry;
|
|
};
|
|
|
|
ChainDB.prototype.getAsync = function getAsync(height, callback) {
|
|
var self = this;
|
|
|
|
callback = utils.asyncify(callback);
|
|
|
|
if (this._cache[height])
|
|
return callback(null, this._cache[height]);
|
|
|
|
if (this._queue[height])
|
|
return callback(null, this._queue[height]);
|
|
|
|
if (height < 0 || height == null)
|
|
return callback();
|
|
|
|
if ((height + 1) * BLOCK_SIZE > this.size)
|
|
return callback();
|
|
|
|
return this._readAsync(BLOCK_SIZE, height * BLOCK_SIZE, function(err, data) {
|
|
var entry;
|
|
|
|
// We can't ensure the integrity of
|
|
// the chain if we get an error.
|
|
// Just throw.
|
|
if (err)
|
|
throw err;
|
|
|
|
if (!data)
|
|
return callback();
|
|
|
|
// Ignore if it is a null block.
|
|
if (utils.read32(data, 0) === 0)
|
|
return callback();
|
|
|
|
entry = bcoin.chainblock.fromRaw(self.chain, height, data);
|
|
|
|
// Cache the past 1001 blocks in memory
|
|
// (necessary for isSuperMajority)
|
|
self.cache(entry);
|
|
|
|
return callback(null, entry);
|
|
});
|
|
};
|
|
|
|
ChainDB.prototype.save = function save(entry, callback) {
|
|
return this.saveAsync(entry, callback);
|
|
};
|
|
|
|
ChainDB.prototype.saveSync = function saveSync(entry) {
|
|
var self = this;
|
|
var raw, offset;
|
|
|
|
// Cache the past 1001 blocks in memory
|
|
// (necessary for isSuperMajority)
|
|
this.cache(entry);
|
|
|
|
raw = entry.toRaw();
|
|
offset = entry.height * BLOCK_SIZE;
|
|
|
|
return this._writeSync(raw, offset);
|
|
};
|
|
|
|
ChainDB.prototype.saveAsync = function saveAsync(entry, callback) {
|
|
var self = this;
|
|
var raw, offset;
|
|
|
|
callback = utils.asyncify(callback);
|
|
|
|
// Cache the past 1001 blocks in memory
|
|
// (necessary for isSuperMajority)
|
|
this.cache(entry);
|
|
|
|
// Something is already writing. Cancel it
|
|
// and synchronously write the data after
|
|
// it cancels.
|
|
if (this._queue[entry.height]) {
|
|
this._queue[entry.height] = entry;
|
|
return callback();
|
|
}
|
|
|
|
// Speed up writes by doing them asynchronously
|
|
// and keeping the data to be written in memory.
|
|
this._queue[entry.height] = entry;
|
|
|
|
// Write asynchronously to the db.
|
|
raw = entry.toRaw();
|
|
offset = entry.height * BLOCK_SIZE;
|
|
|
|
return this._writeAsync(raw, offset, function(err, success) {
|
|
// We can't ensure the integrity of
|
|
// the chain if we get an error.
|
|
// Just throw.
|
|
if (err)
|
|
throw err;
|
|
|
|
var item = self._queue[entry.height];
|
|
|
|
// Something tried to write here but couldn't.
|
|
// Synchronously write it and get it over with.
|
|
try {
|
|
if (item && item !== entry)
|
|
success = self._writeSync(item.toRaw(), offset);
|
|
} catch (e) {
|
|
err = e;
|
|
}
|
|
|
|
delete self._queue[entry.height];
|
|
|
|
return callback(null, success);
|
|
});
|
|
};
|
|
|
|
ChainDB.prototype.remove = function remove(height) {
|
|
assert(height >= 0);
|
|
|
|
// Potential race condition here. Not sure how
|
|
// to handle this.
|
|
if (this._queue[height]) {
|
|
utils.debug('Warning: write job in progress.');
|
|
delete this._queue[height];
|
|
}
|
|
|
|
this._writeSync(this._nullBlock, height * BLOCK_SIZE);
|
|
delete this._cache[height];
|
|
|
|
// If we deleted several blocks at the end, go back
|
|
// to the last non-null block and truncate the file
|
|
// beyond that point.
|
|
if ((height + 1) * BLOCK_SIZE === this.size) {
|
|
while (this.isNull(height))
|
|
height--;
|
|
|
|
assert(height >= 0);
|
|
|
|
this.truncate(height);
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
ChainDB.prototype.truncate = function truncate(height) {
|
|
this.size = (height + 1) * BLOCK_SIZE;
|
|
this.tip = height;
|
|
|
|
if (!bcoin.fs) {
|
|
this.ramdisk.truncate(this.size);
|
|
return;
|
|
}
|
|
|
|
fs.ftruncateSync(this.fd, this.size);
|
|
};
|
|
|
|
ChainDB.prototype.isNull = function isNull(height) {
|
|
var data = this._readSync(4, height * BLOCK_SIZE);
|
|
if (!data)
|
|
return false;
|
|
return utils.read32(data, 0) === 0;
|
|
};
|
|
|
|
ChainDB.prototype.has = function has(height) {
|
|
var data;
|
|
|
|
if (this._queue[height] || this._cache[height])
|
|
return true;
|
|
|
|
if (height < 0 || height == null)
|
|
return false;
|
|
|
|
if ((height + 1) * BLOCK_SIZE > this.size)
|
|
return false;
|
|
|
|
data = this._readSync(4, height * BLOCK_SIZE);
|
|
|
|
if (!data)
|
|
return false;
|
|
|
|
return utils.read32(data, 0) !== 0;
|
|
};
|
|
|
|
ChainDB.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.');
|
|
};
|
|
|
|
ChainDB.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();
|
|
});
|
|
})();
|
|
};
|
|
|
|
ChainDB.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.');
|
|
};
|
|
|
|
ChainDB.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 = ChainDB;
|