def _get_state(self):
args = [
'docker',
'ps',
'-a',
'--no-trunc',
'--format',
'{{.Names}},{{.ID}},{{.Status}},'
'{{.Command}}',
'--filter',
'network={}'.format(self._prefix)]
try:
output = subprocess.check_output(args)
except subprocess.CalledProcessError as e:
raise CliException(str(e))
except OSError as e:
if e.errno == 2:
raise CliException("{}:{}".format(str(e),
args[0]))
entries = []
for line in output.split('\n'):
if len(line) < 1:
continue
parts = line.split(',')
entries.append(_StateEntry(
name=parts[0].replace(self._prefix + '-', ''),
identifier=parts[1],
status=parts[2],
command=parts[3]))
return entries
def do_cluster_stats(args):
# pylint: disable=redefined-variable-type
file_name = \
os.path.join(os.path.expanduser("~"), '.sawtooth', 'cluster',
"state.yaml")
# Get current expected state
if os.path.isfile(file_name):
with open(file_name, 'r') as state_file:
state = yaml.load(state_file)
else:
raise CliException("Missing state file")
node_controller = get_node_controller(state, args)
node_command_generator = SimpleNodeCommandGenerator()
vnm = ValidatorNetworkManager(
node_controller=node_controller,
node_command_generator=node_command_generator)
nodes = state["Nodes"]
for node_name in nodes:
try:
node_ip = vnm.get_ip(node_name)
node_name_stats = node_name
break
except ManagementError as e:
raise CliException(str(e))
node_url = "http://" + node_ip.strip(' \t\n\r') + ":" + \
nodes[node_name_stats]["HttpPort"]
run_stats(node_url)
def do_cluster_stop(args):
state = load_state()
node_controller = get_node_controller(state, args)
node_command_generator = SimpleNodeCommandGenerator()
vnm = ValidatorNetworkManager(
node_controller=node_controller,
node_command_generator=node_command_generator)
if len(args.node_names) > 0:
node_names = args.node_names
else:
node_names = vnm.get_node_names()
nodes = state["Nodes"]
for node_name in node_names:
if node_name not in nodes:
raise CliException("{} is not a known node name".format(node_name))
if nodes[node_name]['Status'] == 'Stopped':
raise CliException('{} already stopped'.format(node_name))
print("Stopping: {}".format(node_name))
node_command_generator.stop(node_name)
# Update status of Nodes
if node_name in nodes:
nodes[node_name]["Status"] = "Stopped"
else:
nodes[node_name] = {"Status": "Unknown"}
if len(args.node_names) == 0 and len(node_names) == 0:
for node_name in nodes:
nodes[node_name]["Status"] = "Unknown"
# If none of the nodes are running set overall State to Stopped
state["DesiredState"] = "Stopped"
for node in nodes:
if nodes[node]["Status"] == "Running":
state["DesiredState"] = "Running"
# Update state of nodes
state["Nodes"] = nodes
save_state(state)
vnm.update()
# Wait up to 16 seconds for our targeted nodes to gracefully shut down
def find_still_up(targeted_nodes):
return set(vnm.get_node_names()).intersection(set(targeted_nodes))
timeout = 16
mark = time.time()
while len(find_still_up(node_names)) > 0:
if time.time() - mark > timeout:
break
time.sleep(1)
# Force kill any targeted nodes that are still up
for node_name in find_still_up(node_names):
print("Node name still up: killling {}".format(node_name))
node_controller.kill(node_name)
def start(self, node_config):
node_name = node_config.node_name
http_port = node_config.http_port
args = self._construct_start_args(node_name)
LOGGER.debug('starting %s: %s', node_name, self._join_args(args))
compose_dir = tempfile.mkdtemp()
compose_dict = {
'version': '2',
'services': {
'validator': {
'image': 'sawtooth-validator',
'expose': ['40000'],
'networks': ['sawtooth-tng-cluster0', 'default'],
'volumes': ['/project:/project'],
'container_name': 'sawtooth-tng-cluster-0-' + node_name
}
},
'networks': {'sawtooth-tng-cluster0': {'external': True}}
}
state_file_path = os.path.join(self._state_dir, 'state.yaml')
state = yaml.load(file(state_file_path))
# add the processors
node_num = node_name[len('validator-'):]
for proc in state['Processors']:
service_name = proc[len('sawtooth-'):]
compose_dict['services'][service_name] = {
'image': proc,
'expose': ['40000'],
'links': ['validator'],
'volumes': ['/project:/project'],
'container_name': 'sawtooth-tng-cluster-0-'
+ service_name + node_num
}
# add the host:container port mapping for validator
tng_http_port = http_port + 31200
compose_dict['services']['validator']['ports'] = \
[str(tng_http_port) + ":" + str(40000)]
yaml.dump(compose_dict,
file(os.path.join(compose_dir, 'docker-compose.yaml'),
mode='w'))
try:
os.chdir(compose_dir)
output = subprocess.check_output(args)
except subprocess.CalledProcessError as e:
raise CliException(str(e)
+ "\nPossibly misspelled processor name")
except OSError as e:
if e.errno == 2:
raise CliException("{}:{}".format(str(e), args[0]))
else:
raise e
for line in output.split('\n'):
if len(line) < 1:
continue
LOGGER.debug("command output: %s", str(line))
def stop(self, node_name):
args = ['docker', 'stop', node_name]
LOGGER.debug('stopping %s: %s', node_name, ' '.join(args))
try:
output = subprocess.check_output(args)
except subprocess.CalledProcessError as e:
raise CliException(str(e))
for line in output.split('\n'):
if len(line) < 1:
continue
LOGGER.debug("command output: %s", str(line))
args = ['docker', 'rm', node_name]
LOGGER.debug('stopping %s: %s', node_name, ' '.join(args))
try:
output = subprocess.check_output(args)
except subprocess.CalledProcessError as e:
raise CliException(str(e))
for line in output.split('\n'):
if len(line) < 1:
continue
LOGGER.debug("command output: %s", str(line))
def _construct_start_args(self, node_name):
try:
network_ls_args = [
'docker', 'network', 'ls', '--filter',
'NAME=sawtooth-tng-cluster0', '-q'
]
network_output = subprocess.check_output(
network_ls_args).splitlines()
except subprocess.CalledProcessError as e:
raise CliException(str(e))
if len(network_output) == 0:
try:
network_args = [
'docker', 'network', 'create', '-d', 'bridge',
'sawtooth-tng-cluster0'
]
n_output = subprocess.check_output(network_args)
for l in n_output.splitlines():
LOGGER.info(l)
except subprocess.CalledProcessError as e:
raise CliException(str(e))
args = [
'docker-compose', '-p', 'sawtoothtngcluster0' + node_name, 'up',
'-d'
]
return args
def _construct_start_args(self, node_name):
try:
network_ls_args = [
'docker', 'network', 'ls', '--filter',
'NAME={}'.format(self._prefix), '-q'
]
network_output = subprocess.check_output(
network_ls_args).splitlines()
except subprocess.CalledProcessError as e:
raise CliException(str(e))
if len(network_output) == 0:
try:
network_args = [
'docker', 'network', 'create', '-d', 'bridge', self._prefix
]
n_output = subprocess.check_output(network_args)
for l in n_output.splitlines():
LOGGER.info(l)
except subprocess.CalledProcessError as e:
raise CliException(str(e))
args = [
'docker-compose', '-p',
self._prefix.replace('-', '') + node_name, 'up', '-d'
]
return args
def do_cluster_stop(args):
# pylint: disable=redefined-variable-type
file_name = \
os.path.join(os.path.expanduser("~"), '.sawtooth', 'cluster',
"state.yaml")
# Get current state of Nodes
if os.path.isfile(file_name):
with open(file_name, 'r') as state_file:
state = yaml.load(state_file)
else:
raise CliException("Missing state file")
if state['Manage'] is None or state['Manage'] == 'docker':
node_controller = DockerNodeController()
elif state['Manage'] == 'daemon':
node_controller = DaemonNodeController()
else:
raise CliException('invalid management'
' type: {}'.format(state['Manage']))
node_command_generator = SimpleNodeCommandGenerator()
vnm = ValidatorNetworkManager(
node_controller=node_controller,
node_command_generator=node_command_generator)
if len(args.node_names) > 0:
node_names = args.node_names
else:
node_names = vnm.get_node_names()
nodes = state["Nodes"]
for node_name in node_names:
print "Stopping: {}".format(node_name)
node_command_generator.stop(node_name)
# Update status of Nodes
if node_name in nodes:
nodes[node_name]["Status"] = "Stopped"
else:
nodes[node_name] = {"Status": "Unknown"}
if len(args.node_names) == 0 and len(node_names) == 0:
for node_name in nodes:
nodes[node_name]["Status"] = "Unknown"
# If none of the nodes are running set overall State to Stopped
state["DesiredState"] = "Stopped"
for node in nodes:
if nodes[node]["Status"] == "Running":
state["DesiredState"] = "Running"
# Update state of nodes
state["Nodes"] = nodes
with open(file_name, 'w') as state_file:
yaml.dump(state, state_file, default_flow_style=False)
vnm.update()
def _construct_start_args(self, node_name, http_port, gossip_port,
genesis):
# only create 'genesis' ledger if there is not existing network
if len(self.get_node_names()) > 0:
genesis = False
# Check for running the network sawtooth and get the subnet
subnet_arg = ['docker', 'network', 'inspect', 'sawtooth']
try:
output = yaml.load(subprocess.check_output(subnet_arg))
subnet = unicode(output[0]['IPAM']['Config'][0]['Subnet'])
subnet_list = list(ipaddr.IPv4Network(subnet))
except subprocess.CalledProcessError as e:
raise CliException(str(e))
num = int(node_name[len('validator-'):]) + 3
if num < len(subnet_list) - 1:
ip_addr = str(subnet_list[num])
else:
raise CliException("Out of Usable IP Addresses")
local_project_dir = '/project'
args = ['docker', 'run', '-t', '-d', '--network', 'sawtooth']
args.extend(['--name', node_name])
args.extend(['--label', 'sawtooth.cluster=default'])
args.extend(['--ip', ip_addr])
args.extend(['-p', str(http_port)])
args.extend(['-p', '{}/udp'.format(gossip_port)])
args.extend(['-e', 'CURRENCYHOME=/project/sawtooth-core/validator'])
args.extend(['-v', '{}:/project'.format(local_project_dir)])
args.append('sawtooth-build-ubuntu-xenial')
args.extend(['bash', '-c'])
cmd = []
bin_path = '/project/sawtooth-core/bin'
initial_connectivity = 0 if genesis else 1
cmd.append('echo "{\\\"InitialConnectivity\\\": %d}"' %
initial_connectivity)
cmd.append('> ${CURRENCYHOME}/data/%s.json;' % node_name)
if genesis:
cmd.append('%s/sawtooth keygen %s; ' % (bin_path, node_name))
cmd.append('%s/sawtooth admin' % bin_path)
cmd.append('poet1-genesis -vv --node %s; exec' % node_name)
cmd.append('%s/txnvalidator' % bin_path)
cmd.extend(['--node', node_name])
cmd.append('-vv')
cmd.append("--listen '{}:{}/UDP gossip'".format(ip_addr, gossip_port))
cmd.append("--listen '{}:{}/TCP http'".format(ip_addr, http_port))
# Set Ledger Url
cmd.append("--url 'http://{}:8800'".format(str(subnet_list[3])))
cmd.append('--config ${CURRENCYHOM}}/data/%s.json' % node_name)
args.append(' '.join(cmd))
return args
def do_cluster_extend(args):
state = load_state()
node_controller = get_node_controller(state, args)
node_command_generator = SimpleNodeCommandGenerator()
vnm = ValidatorNetworkManager(
node_controller=node_controller,
node_command_generator=node_command_generator)
existing_nodes = state["Nodes"]
desired_stated = state["DesiredState"]
if desired_stated != "Running":
raise CliException(
"You must have a running network.\n" +
"Use the cluster start command to start a validator network.")
print("Extending network by {} nodes.".format(args.count))
index_offset = len(existing_nodes)
for i in xrange(0, args.count):
j = i + index_offset
node_name = "validator-{:0>3}".format(j)
if node_name in existing_nodes and vnm.is_running(node_name):
print("Already running: {}".format(node_name))
continue
# genesis is true for the first node
genesis = (j == 0)
gossip_port = 5500 + j
http_port = 8800 + j
node_args = NodeArguments(node_name,
http_port=http_port,
gossip_port=gossip_port,
genesis=genesis)
node_command_generator.start(node_args)
state["Nodes"][node_name] = {
"Status": "Running",
"Index": i,
"HttpPort": str(http_port),
"GossipPort": str(gossip_port)
}
save_state(state)
try:
vnm.update()
except ManagementError as e:
raise CliException(str(e))
def get_node_controller(state, args):
# Get base controller:
manage_type = state['Manage']
node_controller_types = {
'docker': DockerNodeController,
'subprocess': SubprocessNodeController,
'subprocess-legacy': SubprocessLegacyNodeController,
'docker-legacy': DockerLegacyNodeController,
'daemon-legacy': DaemonLegacyNodeController,
}
try:
node_controller_type = node_controller_types[manage_type]
except:
# manage_type hasn't been added to node_controller_types
if manage_type in ALL_MANAGE_TYPES:
error_msg = '{} manamgement type not implemented'
else:
error_msg = 'Invalid management type: {}'
raise CliException(error_msg.format(manage_type))
node_controller = node_controller_type()
# 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:
wrappable_types = SubprocessLegacyNodeController,
if not isinstance(node_controller, wrappable_types):
msg = '--wrap currently only implemented for {} management types'
raise CliException(msg.format(wrappable_types))
# 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 stop(self, node_name):
state_file_path = os.path.join(self._state_dir, 'state.yaml')
state = yaml.load(file(state_file_path))
node_num = node_name[len('validator-'):]
processes = state['Processors'] + ['validator']
containers = [
'-'.join([self._prefix, proc, node_num]) for proc in processes
]
for c_name in containers:
args = ['docker', 'stop', c_name]
LOGGER.debug('stopping %s: %s', c_name, ' '.join(args))
try:
output = subprocess.check_output(args)
except subprocess.CalledProcessError as e:
raise CliException(str(e))
for line in output.split('\n'):
if len(line) < 1:
continue
LOGGER.debug("command output: %s", str(line))
args = ['docker', 'rm', c_name]
LOGGER.debug('stopping %s: %s', c_name, ' '.join(args))
try:
output = subprocess.check_output(args)
except subprocess.CalledProcessError as e:
raise CliException(str(e))
for line in output.split('\n'):
if len(line) < 1:
continue
LOGGER.debug("command output: %s", str(line))
if 'validator' in c_name:
network = c_name.replace('-', '') + '_default'
args = ['docker', 'network', 'rm', network]
try:
output = subprocess.check_output(args)
except subprocess.CalledProcessError as e:
raise CliException(str(e))
for line in output.splitlines():
if len(line) < 1:
continue
LOGGER.debug("command output: %s", str(line))
def do_cluster_status(args):
# pylint: disable=redefined-variable-type
file_name = \
os.path.join(os.path.expanduser("~"), '.sawtooth', 'cluster',
"state.yaml")
# Get current expected state
if os.path.isfile(file_name):
with open(file_name, 'r') as state_file:
state = yaml.load(state_file)
else:
raise CliException("Missing state file")
if state['Manage'] is None or state['Manage'] == 'docker':
node_controller = DockerNodeController()
elif state['Manage'] == 'daemon':
node_controller = DaemonNodeController()
else:
raise CliException('invalid management'
' type: {}'.format(state['Manage']))
node_command_generator = SimpleNodeCommandGenerator()
vnm = ValidatorNetworkManager(
node_controller=node_controller,
node_command_generator=node_command_generator)
if len(args.node_names) > 0:
node_names = args.node_names
else:
node_names = vnm.get_node_names()
# Check expected status of nodes vs what is returned from vnm
print "NodeName Expected Current"
nodes = state["Nodes"]
for node_name in nodes:
if node_name not in node_names and \
(nodes[node_name]["Status"] == "Running" or
nodes[node_name]["Status"] == "No Response"):
print "{} {} {}".format(node_name, nodes[node_name]["Status"],
"Not Running")
else:
status = vnm.status(node_name)
if status == "UNKNOWN" and \
nodes[node_name]["Status"] == "Stopped":
print "{} {} {}".format(node_name, nodes[node_name]["Status"],
status)
else:
print "{} {} {}".format(node_name, nodes[node_name]["Status"],
status)
def do_cluster_logs(args):
state_file = os.path.join(os.path.expanduser('~'), '.sawtooth', 'cluster',
'state.yaml')
state = yaml.load(file(state_file))
if state['Manage'] == 'docker-tng':
for node_name in args.node_names:
try:
node_num = node_name[len('validator-'):]
processors = [
p[len('sawtooth-'):] for p in state['Processors']
]
containers = [
'sawtooth-tng-cluster-0-' + p + node_num
for p in processors
]
containers += ['sawtooth-tng-cluster-0-validator-' + node_num]
for c in containers:
print "Logs for container: " + c + "of node: " + node_name
cmd = ['docker', 'logs', c]
handle = subprocess.Popen(cmd)
while handle.returncode is None:
handle.poll()
except subprocess.CalledProcessError as cpe:
raise CliException(str(cpe))
else:
print "logs not implemented for {}".format(state['Manage'])
def _get_state(self):
args = [
'docker', 'ps', '-a', '--no-trunc', '--format',
'{{.Names}},{{.ID}},{{.Status}},'
'{{.Command}}', '--filter', 'network=sawtooth-tng-cluster0'
]
try:
output = subprocess.check_output(args)
except subprocess.CalledProcessError as e:
raise CliException(str(e))
entries = []
for line in output.split('\n'):
if len(line) < 1:
continue
parts = line.split(',')
entries.append(
_StateEntry(name=parts[0].replace('sawtooth-tng-cluster-0-',
''),
identifier=parts[1],
status=parts[2],
command=parts[3]))
return entries
def do_admin(args):
if args.admin_cmd == 'poet0-genesis':
do_poet0_genesis(args)
elif args.admin_cmd == 'poet1-genesis':
do_poet1_genesis(args)
else:
raise CliException("invalid command: {}".format(args.command))
def do_cluster_logs(args):
state = load_state()
if state['Manage'] == 'docker-tng':
prefix = 'sawtooth-tng-cluster-0'
for node_name in args.node_names:
try:
node_num = node_name[len('validator-'):]
processes = state['Processors'] + ['validator']
containers = [
'-'.join([prefix, proc, node_num]) for proc in processes
]
for c in containers:
print("Logs for container: " + c + "of node: " + node_name)
cmd = ['docker', 'logs', c]
handle = subprocess.Popen(cmd)
while handle.returncode is None:
handle.poll()
except subprocess.CalledProcessError as cpe:
raise CliException(str(cpe))
else:
print("logs not implemented for {}".format(state['Manage']))
def do_clean(args):
# Intercept the config
# Set default config file if not specified by user
if args.config is None:
args.config = ['txnvalidator.js']
# Convert any comma-delimited argument strings to list elements
for arglist in [args.config]:
if arglist is not None:
for arg in arglist:
if ',' in arg:
loc = arglist.index(arg)
arglist.pop(loc)
for element in reversed(arg.split(',')):
arglist.insert(loc, element)
options_config = ArgparseOptionsConfig([('conf_dir', 'ConfigDirectory'),
('data_dir', 'DataDirectory'),
('log_config', 'LogConfigFile'),
('key_dir', 'KeyDirectory'),
('verbose', 'Verbose')], args)
cfg = get_validator_configuration(args.config, options_config)
if args.state is True:
do_clean_state(cfg, args)
if args.keys is True:
do_delete_keys(cfg, args)
if args.state is False and args.keys is False:
raise CliException("Please specify at least one object to clean.")
def do_store(args):
subcommands = ['list', 'show']
if args.subcommand not in subcommands:
print('Unknown sub-command, expecting one of {0}'.format(subcommands))
return
if args.url is not None:
url = args.url
else:
url = 'http://localhost:8800'
web_client = SawtoothClient(url)
try:
if args.subcommand == 'list':
transaction_type_name = web_client.get_store_list()
print(pretty_print_dict(transaction_type_name))
return
elif args.subcommand == 'show':
store_info = \
web_client.get_store_by_name(
txn_type_or_name=args.transactionTypeName,
key=args.key,
block_id=args.blockID,
delta=args.incremental)
print(pretty_print_dict(store_info))
return
except MessageException as e:
raise CliException(e)
def do_block(args):
subcommands = ['list', 'show']
if args.subcommand not in subcommands:
print 'Unknown sub-command, expecting one of {0}'.format(subcommands)
return
if args.url is not None:
url = args.url
else:
url = 'http://localhost:8800'
web_client = LedgerWebClient(url)
try:
if args.subcommand == 'list':
if args.all:
blockids = web_client.get_block_list()
else:
blockids = web_client.get_block_list(args.blockcount)
for block_id in blockids:
print block_id
return
elif args.subcommand == 'show':
if args.key is not None:
block_info = web_client.get_block(args.blockID, args.key)
else:
block_info = web_client.get_block(args.blockID)
print pretty_print_dict(block_info)
return
except MessageException as e:
raise CliException(e)
def main(prog_name=os.path.basename(sys.argv[0]), args=sys.argv[1:],
with_loggers=True):
parser = create_parser(prog_name)
args = parser.parse_args(args)
if with_loggers is True:
if args.verbose is None:
verbose_level = 0
else:
verbose_level = args.verbose
setup_loggers(verbose_level=verbose_level)
if args.command == 'keygen':
do_keygen(args)
elif args.command == 'cluster':
do_cluster(args)
elif args.command == 'docker':
do_docker(args)
elif args.command == 'submit':
do_submit(args)
elif args.command == 'block':
do_block(args)
elif args.command == 'transaction':
do_transaction(args)
elif args.command == 'store':
do_store(args)
elif args.command == 'admin':
do_admin(args)
elif args.command == 'stats':
do_stats(args)
elif args.command == 'monitor':
do_monitor(args)
else:
raise CliException("invalid command: {}".format(args.command))
def do_submit(args):
if args.key is not None:
key_name = args.key
else:
key_name = getpass.getuser()
if args.url is not None:
url = args.url
else:
url = 'http://localhost:8800'
filename = args.filename
family_name = args.family
# If we have a '/' in the key name, treat it as the full path to
# a priv file, without modification. If it does not, then assume
# it is in ~/.sawtooth/keys/.
if '/' in key_name:
key_file = key_name
else:
key_dir = os.path.join(os.path.expanduser('~'), '.sawtooth', 'keys')
key_file = os.path.join(key_dir, key_name + '.priv')
if not os.path.exists(key_file):
raise ClientException('no such file: {}'.format(key_file))
try:
if filename == '-':
json_content = sys.stdin.read()
else:
with open(filename) as fd:
json_content = fd.read()
except IOError, e:
raise CliException(str(e))
def check_for_chain(data_dir, node_name, store_type):
block_store = Journal.get_store_file(node_name,
'block',
data_dir,
store_type=store_type)
if os.path.isfile(block_store):
msg = 'block store: %s exists; ' % block_store
msg += 'skipping genesis block creation.'
raise CliException(msg)
def _build_docker_image(image):
image_src = os.path.join(os.path.dirname(__file__), "data", image)
tmpdir = tempfile.mkdtemp(prefix='sawtooth-docker-')
try:
try:
shutil.copyfile(image_src, os.path.join(tmpdir, "Dockerfile"))
except IOError as e:
raise CliException("Failed to copy Dockerfile: {}".format(str(e)))
args = ['docker', 'build', '-t', image, tmpdir]
try:
subprocess.check_call(args)
except OSError as e:
raise CliException("Failed to run '{}': {}".format(
" ".join(args), str(e)))
finally:
shutil.rmtree(tmpdir)
def load_state(start=False):
file_name = get_state_file_name()
if os.path.isfile(file_name):
with open(file_name, 'r') as state_file:
state = yaml.load(state_file)
elif start is True:
state = {'DesiredState': 'Stopped'}
else:
raise CliException("Missing state file")
return state
def do_cluster(args):
if args.cluster_command == 'start':
do_cluster_start(args)
elif args.cluster_command == 'status':
do_cluster_status(args)
elif args.cluster_command == 'stop':
do_cluster_stop(args)
else:
raise CliException("invalid cluster command: {}".format(
args.cluster_command))
def _find_peers(self):
peers = []
args = ['docker', 'inspect', self._prefix, '--format',
'{{range .Containers }}{{.IPv4Address}}{{end}}']
try:
output = subprocess.check_output(args)
peers = output.split(b"/16")
except subprocess.CalledProcessError as e:
raise CliException(str(e))
return ['tcp://' + str(p) + ':8800' for p in peers if len(p) > 4]
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()
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:
if not isinstance(node_controller, SubprocessNodeController):
raise CliException("--wrap currently only implemented for "
"'subprocess' management type")
# 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 _construct_start_args(self, node_name, http_port, gossip_port,
genesis):
# Check for running the network sawtooth and get the subnet
subnet_arg = ['docker', 'network', 'inspect', 'sawtooth']
try:
output = yaml.load(subprocess.check_output(subnet_arg))
subnet = unicode(output[0]['IPAM']['Config'][0]['Subnet'])
subnet_list = list(ipaddr.IPv4Network(subnet))
LOGGER.debug(subnet_list)
except subprocess.CalledProcessError as e:
raise CliException(str(e))
num = int(node_name[len('validator-'):]) + 3
if num < len(subnet_list) - 1:
ip_addr = str(subnet_list[num])
else:
raise CliException("Out of Usable IP Addresses")
local_project_dir = '/project'
args = ['docker', 'run', '-t', '-d', '--network', 'sawtooth']
args.extend(['--name', node_name])
args.extend(['--label', 'sawtooth.cluster=default'])
args.extend(['--ip', ip_addr])
args.extend(['-p', str(http_port)])
args.extend(['-p', '{}/udp'.format(gossip_port)])
args.extend(['-e', 'CURRENCYHOME=/project/sawtooth-core/validator'])
args.extend(['-v', '{}:/project'.format(local_project_dir)])
args.append('sawtooth-build-ubuntu-trusty')
args.append('/project/sawtooth-core/bin/txnvalidator')
args.extend(['--node', node_name])
if genesis:
args.append('--genesis')
args.append('-vv')
args.extend(
['--listen', '{}:{}/UDP gossip'.format(ip_addr, gossip_port)])
args.extend(['--listen', '{}:{}/TCP http'.format(ip_addr, http_port)])
# Set Genesis Url
args.extend(['--url', 'http://{}:8800'.format(str(subnet_list[3]))])
return args
def do_admin(args):
if args.admin_cmd == 'dev-mode-genesis':
do_dev_mode_genesis(args)
elif args.admin_cmd == 'poet1-genesis':
do_poet1_genesis(args)
elif args.admin_cmd == 'validator-registry':
do_validator_registry(args)
elif args.admin_cmd == 'clean':
do_clean(args)
else:
raise CliException("invalid command: {}".format(args.command))
