def _do_setup(self):
# give defaults to teardown vars
self._node_ctrl = None
self._currency_home = None
self._old_currency_home = os.getenv('CURRENCYHOME')
print 'creating', str(self.__class__.__name__)
# We're not wrapped, so set up a temp CURRENCYHOME we can delete
self._currency_home = tempfile.mkdtemp()
for directory in ['data', 'keys', 'logs']:
os.makedirs(os.path.join(self._currency_home, directory))
os.environ['CURRENCYHOME'] = self._currency_home
# set up our nodes (suite-internal interface)
self._nodes = [
NodeConfig('v%s' % i, 8800 + i, 9000 + i) for i in range(2)
]
# set up our urls (external interface)
self.urls = ['http://localhost:%s' % x.http_port for x in self._nodes]
# Make genesis block
print 'creating genesis block...'
self._nodes[0].genesis = True
self._node_ctrl = SubprocessNodeController()
self._node_ctrl.do_genesis(self._nodes[0])
# Launch network (node zero will trigger bootstrapping)
print 'launching network...'
for x in self._nodes:
self._node_ctrl.start(x)
def _do_setup(self, cfg, node_count=5):
# give defaults to teardown vars
self._node_ctrl = None
print 'creating', str(self.__class__.__name__)
# set up our nodes (suite-internal interface)
self._node_ctrl = WrappedNodeController(SubprocessNodeController())
temp_dir = self._node_ctrl.get_data_dir()
file_name = os.path.join(temp_dir, "config.js")
with open(file_name, 'w') as config:
config.write(json.dumps(cfg))
self._nodes = [
NodeArguments('v%s' % i,
8800 + i,
9000 + i,
config_files=[file_name],
ledger_type=cfg["LedgerType"])
for i in range(node_count)
]
# set up our urls (external interface)
self.urls = ['http://localhost:%s' % x.http_port for x in self._nodes]
# Make genesis block
print 'creating genesis block...'
self._nodes[0].genesis = True
self._node_ctrl.create_genesis_block(self._nodes[0])
# Launch network (node zero will trigger bootstrapping)
print 'launching network...'
for x in self._nodes:
self._node_ctrl.start(x)
def _do_setup(self):
# give defaults to teardown vars
self._node_ctrl = None
print 'creating', str(self.__class__.__name__)
# set up our nodes (suite-internal interface)
self._nodes = [
NodeArguments('v%s' % i, 8800 + i, 9000 + i) for i in range(2)
]
# set up our urls (external interface)
self.urls = ['http://localhost:%s' % x.http_port for x in self._nodes]
# Make genesis block
print 'creating genesis block...'
self._nodes[0].genesis = True
self._node_ctrl = WrappedNodeController(SubprocessNodeController())
self._node_ctrl.create_genesis_block(self._nodes[0])
# Launch network (node zero will trigger bootstrapping)
print 'launching network...'
for x in self._nodes:
self._node_ctrl.start(x)
def get_node_controller(state, args):
# pylint: disable=redefined-variable-type
# Get base controller:
node_controller = None
if state['Manage'] == 'subprocess':
node_controller = SubprocessNodeController()
elif state['Manage'] == 'docker':
node_controller = DockerNodeController()
elif state['Manage'] == 'daemon':
node_controller = DaemonNodeController()
elif state['Manage'] == 'docker-tng':
node_controller = DockerTNGNodeController()
else:
raise CliException('invalid management type:'
' {}'.format(state['Manage']))
# Optionally decorate with WrappedNodeController
args_wrap = False if not hasattr(args, 'wrap') else args.wrap
if 'Wrap' not in state.keys():
# if wrap has not been set in state, set it
state['Wrap'] = args_wrap
else:
# state already knows about a wrapper
if args_wrap is not False and args_wrap != state['Wrap']:
raise CliException("Already wrapped to %s." % state["Wrap"])
if state['Wrap'] is not False:
# either args or state have indicated a WrappedNodeController
if 'ManageWrap' not in state.keys():
state['ManageWrap'] = None
node_controller = WrappedNodeController(
node_controller,
data_dir=state['Wrap'],
clean_data_dir=state['ManageWrap'])
if state['Wrap'] is None:
state['Wrap'] = node_controller.get_data_dir()
state['ManageWrap'] = True
print '{} wrapped to {}'.format(args.cluster_command, state['Wrap'])
# Return out construction:
return node_controller
def main():
node_ctrl = None
try:
opts = configure(sys.argv[1:])
except Exception as e:
print(str(e), file=sys.stderr)
sys.exit(1)
try:
count = opts['count']
# log_config = NEED
currency_home = opts['data_dir']
http_port = int(opts['http_port'])
gossip_port = int(opts['port'])
try:
ledger_type = opts["validator_config"]["LedgerType"]
except KeyError:
# None defaults to poet1
ledger_type = None
node_ctrl = WrappedNodeController(SubprocessNodeController(),
data_dir=currency_home)
nodes = []
for idx in range(count):
node = NodeArguments("validator-{:0>3}".format(idx),
http_port=http_port + idx,
gossip_port=gossip_port + idx,
ledger_type=ledger_type)
nodes.append(node)
currency_home = node_ctrl.get_data_dir()
if opts['log_config_dict']:
file_name = 'launcher_cli_global_log_config.js'
full_name = '{}/etc/{}'.format(currency_home, file_name)
with open(full_name, 'w') as f:
f.write(json.dumps(opts['log_config_dict'], indent=4))
opts['validator_config']['LogConfigFile'] = full_name
if opts['validator_config']:
file_name = 'launcher_cli_global_validator_config.js'
with open('{}/etc/{}'.format(currency_home, file_name), 'w') as f:
f.write(json.dumps(opts['validator_config'], indent=4))
for nd in nodes:
nd.config_files.append(file_name)
# set up our urls (external interface)
urls = ['http://localhost:%s' % x.http_port for x in nodes]
# Make genesis block
print('creating genesis block...')
nodes[0].genesis = True
node_ctrl.create_genesis_block(nodes[0])
# Launch network (node zero will trigger bootstrapping)
batch_size = 8
print('staged-launching network (batch_size: {})...'
.format(batch_size))
lower_bound = 0
while lower_bound < count:
upper_bound = lower_bound + min(count - lower_bound, batch_size)
for idx in range(lower_bound, upper_bound):
print("launching {}".format(nodes[idx].node_name))
node_ctrl.start(nodes[idx])
_poll_for_convergence(urls[lower_bound:upper_bound])
lower_bound = upper_bound
run_stats(urls[0])
except KeyboardInterrupt:
print("\nExiting")
except ExitError as e:
# this is an expected error/exit, don't print stack trace -
# the code raising this exception is expected to have printed the error
# details
print("\nFailed!\nExiting: {}".format(e))
except:
traceback.print_exc()
print("\nFailed!\nExiting: {}".format(sys.exc_info()[0]))
finally:
if node_ctrl is not None:
# stop all nodes
for node_name in node_ctrl.get_node_names():
node_ctrl.stop(node_name)
with Progress("terminating network") as p:
to = TimeOut(16)
while len(node_ctrl.get_node_names()) > 0:
if to.is_timed_out():
break
time.sleep(1)
p.step()
# force kill anything left over
for node_name in node_ctrl.get_node_names():
print("%s still 'up'; sending kill..." % node_name)
node_ctrl.kill(node_name)
node_ctrl.archive('launcher')
node_ctrl.clean()
def extend_genesis_util(self, overrides):
print()
vnm = None
try:
self._node_ctrl = None
print('creating', str(self.__class__.__name__))
# set up our nodes (suite-internal interface)
self._node_ctrl = WrappedNodeController(SubprocessNodeController())
cfg = overrides
temp_dir = self._node_ctrl.get_data_dir()
file_name = os.path.join(temp_dir, "config.js")
with open(file_name, 'w') as config:
config.write(json.dumps(cfg))
data_dir = os.path.join(temp_dir, "data")
gblock_file = genesis_info_file_name(data_dir)
self._nodes = [
NodeArguments('v%s' % i, 8800 + i, 9000 + i,
config_files=[file_name],
ledger_type=overrides["LedgerType"])
for i in range(2)]
# set up our urls (external interface)
self.urls = [
'http://localhost:%s' % x.http_port for x in self._nodes]
# Make genesis block
print('creating genesis block...')
self.assertFalse(os.path.exists(gblock_file))
self._nodes[0].genesis = True
self._node_ctrl.create_genesis_block(self._nodes[0])
# Test genesis util
self.assertTrue(os.path.exists(gblock_file))
genesis_dat = None
with open(gblock_file, 'r') as f:
genesis_dat = json.load(f)
self.assertTrue('GenesisId' in genesis_dat.keys())
head = genesis_dat['GenesisId']
# Verify genesis tool efficacy on a minimal network
# Launch network (node zero will trigger bootstrapping)
print('launching network...')
for x in self._nodes:
self._node_ctrl.start(x)
# ...verify validator is extending tgt_block
to = TimeOut(64)
blk_lists = None
prog_str = 'testing root extension (expect root: %s)' % head
with Progress(prog_str) as p:
print()
while not to.is_timed_out() and blk_lists is None:
try:
blk_lists = get_blocklists(['http://localhost:8800'])
print('block_lists: %s' % blk_lists)
if len(blk_lists) < 1 or len(blk_lists[0]) < 2:
blk_lists = None
except MessageException as e:
pass
time.sleep(2)
p.step()
self.assertIsNotNone(blk_lists)
root = blk_lists[0][0]
self.assertEqual(head, root)
# ...verify general convergence
to = TimeOut(32)
with Progress('testing root convergence') as p:
print()
while (is_convergent(self.urls, tolerance=1, standard=1)
is False and not to.is_timed_out()):
time.sleep(2)
p.step()
# ...verify convergence on the genesis block
blk_lists = get_blocklists(['http://localhost:8800'])
root = blk_lists[0][0]
self.assertEqual(head, root)
print('network converged on root: %s' % root)
finally:
print('destroying', str(self.__class__.__name__))
if hasattr(self, '_node_ctrl') and self._node_ctrl is not None:
# Shut down the network
with Progress("terminating network") as p:
for node_name in self._node_ctrl.get_node_names():
self._node_ctrl.stop(node_name)
to = TimeOut(16)
while len(self._node_ctrl.get_node_names()) > 0:
if to.is_timed_out():
break
time.sleep(1)
p.step()
# force kill anything left over
for node_name in self._node_ctrl.get_node_names():
try:
print("%s still 'up'; sending kill..." % node_name)
self._node_ctrl.kill(node_name)
except Exception as e:
print(e.message)
self._node_ctrl.archive(self.__class__.__name__)
self._node_ctrl.clean()
class SawtoothVnmTestSuite(unittest.TestCase):
def _do_teardown(self):
print 'destroying', str(self.__class__.__name__)
if hasattr(self, '_node_ctrl') and self._node_ctrl is not None:
# Shut down the network
with Progress("terminating network") as p:
for node_name in self._node_ctrl.get_node_names():
self._node_ctrl.stop(node_name)
to = TimeOut(16)
while len(self._node_ctrl.get_node_names()) > 0:
if to.is_timed_out():
break
time.sleep(1)
p.step()
# force kill anything left over
for node_name in self._node_ctrl.get_node_names():
try:
print "%s still 'up'; sending kill..." % node_name
self._node_ctrl.kill(node_name)
except Exception as e:
print e.message
# Clean temp dir
print 'deleting temp directory'
tmp_dir = hasattr(self, '_currency_home')
tmp_dir = None if tmp_dir is False else self._currency_home
if tmp_dir is not None and os.path.isdir(tmp_dir):
shutil.rmtree(tmp_dir)
# Restore environmental vars
if hasattr(self, '_old_currency_home'):
print 'restoring environmental variables'
if self._old_currency_home is None:
os.unsetenv('CURRENCYHOME')
else:
os.environ['CURRENCYHOME'] = self._old_currency_home
def _do_setup(self):
# give defaults to teardown vars
self._node_ctrl = None
self._currency_home = None
self._old_currency_home = os.getenv('CURRENCYHOME')
print 'creating', str(self.__class__.__name__)
# We're not wrapped, so set up a temp CURRENCYHOME we can delete
self._currency_home = tempfile.mkdtemp()
for directory in ['data', 'keys', 'logs']:
os.makedirs(os.path.join(self._currency_home, directory))
os.environ['CURRENCYHOME'] = self._currency_home
# set up our nodes (suite-internal interface)
self._nodes = [
NodeConfig('v%s' % i, 8800 + i, 9000 + i) for i in range(2)
]
# set up our urls (external interface)
self.urls = ['http://localhost:%s' % x.http_port for x in self._nodes]
# Make genesis block
print 'creating genesis block...'
self._nodes[0].genesis = True
self._node_ctrl = SubprocessNodeController()
self._node_ctrl.do_genesis(self._nodes[0])
# Launch network (node zero will trigger bootstrapping)
print 'launching network...'
for x in self._nodes:
self._node_ctrl.start(x)
def test_suite(self):
success = False
try:
print
self._do_setup()
urls = self.urls
suite = unittest.TestSuite()
suite.addTest(TestConvergence('test_bootstrap', urls))
runner = unittest.TextTestRunner()
result = runner.run(suite)
if len(result.failures) == 0 and len(result.errors) == 0:
success = True
except:
traceback.print_exc()
raise
finally:
self._do_teardown()
if success is False:
self.fail(self.__class__.__name__)