249 lines
6.5 KiB
JavaScript
249 lines
6.5 KiB
JavaScript
'use strict';
|
|
|
|
require('classtool');
|
|
|
|
|
|
function spec() {
|
|
var mongoose = require('mongoose');
|
|
var util = require('util');
|
|
var RpcClient = require('bitcore/RpcClient').class();
|
|
var networks = require('bitcore/networks');
|
|
var async = require('async');
|
|
var config = require('../config/config');
|
|
var Block = require('../app/models/Block');
|
|
var Transaction = require('../app/models/Transaction');
|
|
var TransactionItem = require('../app/models/TransactionItem');
|
|
var Sync = require('./Sync').class();
|
|
var sockets = require('../app/controllers/socket.js');
|
|
var CONCURRENCY = 5;
|
|
|
|
|
|
function HistoricSync(opts) {
|
|
this.block_count= 0;
|
|
this.block_total= 0;
|
|
this.network = config.network === 'testnet' ? networks.testnet: networks.livenet;
|
|
this.sync = new Sync(opts);
|
|
}
|
|
|
|
function p() {
|
|
var params = Array.prototype.slice.call(arguments);
|
|
|
|
params.unshift('[historic_sync]');
|
|
console.log.apply(this,params);
|
|
}
|
|
|
|
var progress_bar = function(string, current, total) {
|
|
p(util.format('%s %d/%d [%d%%]', string, current, total, parseInt(100 * current / total)));
|
|
};
|
|
|
|
HistoricSync.prototype.init = function(opts,cb) {
|
|
this.rpc = new RpcClient(config.bitcoind);
|
|
this.opts = opts;
|
|
this.sync.init(opts, cb);
|
|
};
|
|
|
|
HistoricSync.prototype.close = function() {
|
|
this.sync.close();
|
|
};
|
|
|
|
HistoricSync.prototype.getPrevNextBlock = function(blockHash, blockEnd, opts, cb) {
|
|
|
|
var that = this;
|
|
|
|
// recursion end.
|
|
if (!blockHash || (blockEnd && blockEnd === blockHash) ) {
|
|
return cb();
|
|
}
|
|
|
|
var existed = 0;
|
|
var blockInfo;
|
|
var blockObj;
|
|
|
|
async.series([
|
|
// Already got it?
|
|
function(c) {
|
|
Block.findOne({hash:blockHash}, function(err,block){
|
|
if (err) { p(err); return c(err); };
|
|
if (block) {
|
|
existed = 1;
|
|
blockObj = block;
|
|
}
|
|
|
|
return c();
|
|
});
|
|
},
|
|
//show some (inacurate) status
|
|
function(c) {
|
|
if (that.block_count++ % 1000 === 0) {
|
|
progress_bar('sync status:', that.block_count, that.block_total);
|
|
}
|
|
return c();
|
|
},
|
|
//get Info from RPC
|
|
function(c) {
|
|
|
|
// TODO: if we store prev/next, no need to go to RPC
|
|
// if (blockObj && blockObj.nextBlockHash) return c();
|
|
|
|
that.rpc.getBlock(blockHash, function(err, ret) {
|
|
if (err) return c(err);
|
|
|
|
blockInfo = ret;
|
|
return c();
|
|
});
|
|
},
|
|
//store it
|
|
function(c) {
|
|
if (existed) return c();
|
|
|
|
that.sync.storeBlock(blockInfo.result, function(err, block) {
|
|
existed = err && err.toString().match(/E11000/);
|
|
if (err && ! existed) return c(err);
|
|
return c();
|
|
});
|
|
},
|
|
/* TODO: Should Start to sync backwards? (this is for partial syncs)
|
|
function(c) {
|
|
|
|
if (blockInfo.result.prevblockhash != current.blockHash) {
|
|
p("reorg?");
|
|
opts.prev = 1;
|
|
}
|
|
return c();
|
|
}
|
|
*/
|
|
],
|
|
function (err){
|
|
|
|
if (err)
|
|
p('ERROR: @%s: %s [count: block_count: %d]', blockHash, err, that.block_count);
|
|
|
|
if (blockInfo && blockInfo.result) {
|
|
if (opts.prev && blockInfo.result.previousblockhash) {
|
|
return that.getPrevNextBlock(blockInfo.result.previousblockhash, blockEnd, opts, cb);
|
|
}
|
|
|
|
if (opts.next && blockInfo.result.nextblockhash)
|
|
return that.getPrevNextBlock(blockInfo.result.nextblockhash, blockEnd, opts, cb);
|
|
}
|
|
return cb(err);
|
|
});
|
|
};
|
|
|
|
HistoricSync.prototype.syncBlocks = function(start, end, isForward, cb) {
|
|
var that = this;
|
|
|
|
p('Syncing Blocks, starting from: %s end: %s isForward:',
|
|
start, end, isForward);
|
|
|
|
|
|
return that.getPrevNextBlock( start, end,
|
|
isForward ? { next: 1 } : { prev: 1}, cb);
|
|
};
|
|
|
|
HistoricSync.prototype.do_import_history = function(opts, next) {
|
|
var that = this;
|
|
|
|
var retry_attemps = 100;
|
|
var retry_secs = 2;
|
|
|
|
var block_best;
|
|
var block_height;
|
|
|
|
async.series([
|
|
function(cb) {
|
|
if (opts.destroy) {
|
|
p('Deleting Blocks...');
|
|
that.db.collections.blocks.drop(cb);
|
|
} else {
|
|
return cb();
|
|
}
|
|
},
|
|
function(cb) {
|
|
if (opts.destroy) {
|
|
p('Deleting TXs...');
|
|
that.db.collections.transactions.drop(cb);
|
|
} else {
|
|
return cb();
|
|
}
|
|
},
|
|
function(cb) {
|
|
if (opts.destroy) {
|
|
p('Deleting TXItems...');
|
|
that.db.collections.transactionitems.drop(cb);
|
|
} else {
|
|
return cb();
|
|
}
|
|
},
|
|
function(cb) {
|
|
that.rpc.getInfo(function(err, res) {
|
|
if (err) cb(err);
|
|
|
|
that.block_total = res.result.blocks;
|
|
return cb();
|
|
});
|
|
},
|
|
// We are not using getBestBlockHash, because is not available in all clients
|
|
function(cb) {
|
|
if (!opts.reverse) return cb();
|
|
|
|
that.rpc.getBlockCount(function(err, res) {
|
|
if (err) cb(err);
|
|
block_height = res.result;
|
|
return cb();
|
|
});
|
|
},
|
|
function(cb) {
|
|
if (!opts.reverse) return cb();
|
|
|
|
that.rpc.getBlockHash(block_height, function(err, res) {
|
|
if (err) cb(err);
|
|
|
|
block_best = res.result;
|
|
return cb();
|
|
});
|
|
},
|
|
],
|
|
function(err) {
|
|
|
|
function sync() {
|
|
var start, end, isForward;
|
|
|
|
if (opts.reverse) {
|
|
start = block_best;
|
|
end = that.network.genesisBlock.hash.reverse().toString('hex');
|
|
isForward = false;
|
|
}
|
|
else {
|
|
start = that.network.genesisBlock.hash.reverse().toString('hex');
|
|
end = null;
|
|
isForward = true;
|
|
}
|
|
|
|
that.syncBlocks(start, end, isForward, function(err) {
|
|
|
|
if (err && err.message.match(/ECONNREFUSED/) && retry_attemps--){
|
|
setTimeout(function() {
|
|
p("Retrying in %d secs ", retry_secs);
|
|
sync();
|
|
}, retry_secs * 1000);
|
|
}
|
|
else
|
|
return next(err, that.block_count);
|
|
});
|
|
}
|
|
sync();
|
|
});
|
|
}
|
|
|
|
HistoricSync.prototype.import_history = function(opts, next) {
|
|
var that = this;
|
|
that.do_import_history(opts, next);
|
|
};
|
|
|
|
|
|
return HistoricSync;
|
|
}
|
|
module.defineClass(spec);
|
|
|