neo-blockchain-bin
Version:
NEO Blockchain binaries.
397 lines (357 loc) • 9.91 kB
JavaScript
import 'rxjs/add/observable/of';
import { createEndpoint, createProfile } from 'neo-blockchain-node-core';
import { dumpChain, loadChain } from 'neo-blockchain-offline';
import fullNode$ from 'neo-blockchain-full-node';
import { BehaviorSubject as BehaviorSubject$1 } from 'rxjs/BehaviorSubject';
import { main, test } from 'neo-blockchain-neo-settings';
import { createLogger, transports } from 'winston';
import os from 'os';
import path from 'path';
function _asyncToGenerator(fn) {
return function () {
var self = this,
args = arguments;
return new Promise(function (resolve, reject) {
var gen = fn.apply(self, args);
function step(key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
Promise.resolve(value).then(_next, _throw);
}
}
function _next(value) {
step("next", value);
}
function _throw(err) {
step("throw", err);
}
_next();
});
};
}
function _extends() {
_extends = Object.assign || function (target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
return target;
};
return _extends.apply(this, arguments);
}
// flowlint-next-line untyped-type-import:off
var isError = function isError(event) {
return event.toLowerCase().includes('error') || event.toLowerCase().includes('failure');
};
var explodeError = function explodeError(error) {
return {
message: [error.message || '(no error message)', error.stack].join('\n')
};
};
var createServerLogger = (function (logger) {
return function (logMessage, exitCallbackIn) {
var error = logMessage.error;
var level = logMessage.level;
if (level == null) {
level = isError(logMessage.event) || error != null ? 'error' : 'info';
}
var message = _extends({}, logMessage, {
level: level
});
if (error != null) {
message = _extends({}, message, {
error: explodeError(error)
});
}
logger.log(message);
var exitCallback = exitCallbackIn;
if (exitCallback != null) {
var numFlushes = logger.transports.length;
var numFlushed = 0;
logger.transports.forEach(function (transport) {
transport.once('finish', function () {
numFlushed += 1;
if (numFlushes === numFlushed) {
exitCallback();
}
});
transport.end();
});
}
};
});
var home = os.homedir();
var resolveHome = (function (value) {
return value.startsWith('~/') ? path.resolve(home, value.slice(2)) : value;
});
var createFullNode = (function (_ref) {
var testNet = _ref.testNet,
dataPathIn = _ref.dataPath,
chainIn = _ref.chain,
dumpPathIn = _ref.dumpPath;
var transports$$1 = [];
transports$$1.push(new transports.Console({
level: 'debug'
}));
var log = createServerLogger(createLogger({
transports: transports$$1
}));
var dataPath = resolveHome(dataPathIn);
var onCreateBlockchain;
var dumpPath = dumpPathIn;
var chain = chainIn;
if (dumpPath != null) {
onCreateBlockchain = function () {
var _ref2 = _asyncToGenerator(
/*#__PURE__*/
regeneratorRuntime.mark(function _callee(blockchain) {
return regeneratorRuntime.wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
_context.next = 2;
return dumpChain({
blockchain: blockchain,
path: dumpPath
});
case 2:
case "end":
return _context.stop();
}
}
}, _callee, this);
}));
return function onCreateBlockchain(_x) {
return _ref2.apply(this, arguments);
};
}();
} else if (chain != null) {
onCreateBlockchain = function () {
var _ref3 = _asyncToGenerator(
/*#__PURE__*/
regeneratorRuntime.mark(function _callee2(blockchain) {
return regeneratorRuntime.wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
_context2.next = 2;
return loadChain({
blockchain: blockchain,
chain: chain
});
case 2:
case "end":
return _context2.stop();
}
}
}, _callee2, this);
}));
return function onCreateBlockchain(_x2) {
return _ref3.apply(this, arguments);
};
}();
}
var settings;
var options;
var rpcEnvironment;
if (testNet) {
settings = test;
rpcEnvironment = {
http: {
host: '0.0.0.0',
port: 8081
}
};
options = {
node: {
seeds: [{
type: 'tcp',
host: 'seed1.neo.org',
port: 20333
}, {
type: 'tcp',
host: 'seed2.neo.org',
port: 20333
}, {
type: 'tcp',
host: 'seed3.neo.org',
port: 20333
}, {
type: 'tcp',
host: 'seed4.neo.org',
port: 20333
}, {
type: 'tcp',
host: 'seed5.neo.org',
port: 20333
}].map(function (value) {
return createEndpoint(value);
})
},
rpc: {
server: {
keepAliveTimeout: 65000
},
readyHealthCheck: {
rpcEndpoints: ['http://test1.cityofzion.io:8880', 'http://test2.cityofzion.io:8880', 'http://test3.cityofzion.io:8880', 'http://test4.cityofzion.io:8880', 'http://test5.cityofzion.io:8880', 'http://seed1.neo.org:20332', 'http://seed2.neo.org:20332', 'http://seed3.neo.org:20332', 'http://seed4.neo.org:20332', 'http://seed5.neo.org:20332'],
offset: 1,
timeoutMS: 5000
}
}
};
} else {
settings = main;
rpcEnvironment = {
http: {
host: '0.0.0.0',
port: 8081
}
};
options = {
node: {
seeds: [{
type: 'tcp',
host: 'seed1.neo.org',
port: 10333
}, {
type: 'tcp',
host: 'seed2.neo.org',
port: 10333
}, {
type: 'tcp',
host: 'seed3.neo.org',
port: 10333
}, {
type: 'tcp',
host: 'seed4.neo.org',
port: 10333
}, {
type: 'tcp',
host: 'seed5.neo.org',
port: 10333
}].map(function (value) {
return createEndpoint(value);
})
},
rpc: {
server: {
keepAliveTimeout: 65000
},
readyHealthCheck: {
rpcEndpoints: ['http://seed1.cityofzion.io:8080', 'http://seed2.cityofzion.io:8080', 'http://seed3.cityofzion.io:8080', 'http://seed4.cityofzion.io:8080', 'http://seed5.cityofzion.io:8080', 'http://seed1.neo.org:10332', 'http://seed2.neo.org:10332', 'http://seed3.neo.org:10332', 'http://seed4.neo.org:10332', 'http://seed5.neo.org:10332'],
offset: 1,
timeoutMS: 5000
}
}
};
}
return fullNode$({
log: log,
createLogForContext: function createLogForContext() {
return log;
},
createProfile: createProfile,
settings: settings,
environment: {
dataPath: dataPath,
rpc: rpcEnvironment
},
options$: new BehaviorSubject$1(options),
onCreateBlockchain: onCreateBlockchain
});
});
var transports$1 = [];
transports$1.push(new transports.Console({
level: 'info'
}));
var log = createServerLogger(createLogger({
transports: transports$1
}));
var setupCLI = (function () {
var shutdownFuncs = [];
var initiateShutdown = function () {
var _ref = _asyncToGenerator(
/*#__PURE__*/
regeneratorRuntime.mark(function _callee() {
return regeneratorRuntime.wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
_context.next = 2;
return Promise.all(shutdownFuncs.map(function (func) {
return func();
}));
case 2:
case "end":
return _context.stop();
}
}
}, _callee, this);
}));
return function initiateShutdown() {
return _ref.apply(this, arguments);
};
}();
var shutdownInitiated = false;
var shutdown = function shutdown(_ref2) {
var exitCode = _ref2.exitCode;
if (!shutdownInitiated) {
shutdownInitiated = true;
initiateShutdown().then(function () {
log({
event: 'SHUTDOWN_SUCCESS'
}, function () {
return process.exit(exitCode);
});
}).catch(function (error) {
log({
event: 'SHUTDOWN_ERROR',
error: error
}, function () {
return process.exit(1);
});
});
}
};
process.on('unhandledRejection', function (error) {
log({
event: 'UNHANDLED_REJECTION.',
error: error
});
shutdown({
exitCode: 1
});
});
process.on('uncaughtException', function (error) {
log({
event: 'UNCAUGHT_EXCEPTION',
error: error
});
shutdown({
exitCode: 1
});
});
process.on('SIGINT', function () {
shutdown({
exitCode: 0
});
});
return {
shutdownFuncs: shutdownFuncs,
shutdown: shutdown
};
});
export { createFullNode, createServerLogger, log, setupCLI };
//# sourceMappingURL=es.js.map