def _config(self, hosts, node_parameters):
Print.info('Generating configuration files...')
# Cleanup all local configuration files.
cmd = CommandMaker.cleanup()
subprocess.run([cmd], shell=True, stderr=subprocess.DEVNULL)
# Recompile the latest code.
cmd = CommandMaker.compile().split()
subprocess.run(cmd, check=True, cwd=PathMaker.node_crate_path())
# Create alias for the client and nodes binary.
cmd = CommandMaker.alias_binaries(PathMaker.binary_path())
subprocess.run([cmd], shell=True)
# Generate configuration files.
keys = []
key_files = [PathMaker.key_file(i) for i in range(len(hosts))]
for filename in key_files:
cmd = CommandMaker.generate_key(filename).split()
subprocess.run(cmd, check=True)
keys += [Key.from_file(filename)]
# Generate threshold signature files.
nodes = len(hosts)
cmd = './node threshold_keys'
for i in range(nodes):
cmd += ' --filename ' + PathMaker.threshold_key_file(i)
cmd = cmd.split()
subprocess.run(cmd, capture_output=True, check=True)
names = [x.name for x in keys]
consensus_addr = [f'{x}:{self.settings.consensus_port}' for x in hosts]
front_addr = [f'{x}:{self.settings.front_port}' for x in hosts]
tss_keys = []
for i in range(nodes):
tss_keys += [TSSKey.from_file(PathMaker.threshold_key_file(i))]
ids = [x.id for x in tss_keys]
mempool_addr = [f'{x}:{self.settings.mempool_port}' for x in hosts]
committee = Committee(names, ids, consensus_addr, front_addr,
mempool_addr)
committee.print(PathMaker.committee_file())
node_parameters.print(PathMaker.parameters_file())
# Cleanup all nodes.
cmd = f'{CommandMaker.cleanup()} || true'
g = Group(*hosts, user='******', connect_kwargs=self.connect)
g.run(cmd, hide=True)
# Upload configuration files.
progress = progress_bar(hosts, prefix='Uploading config files:')
for i, host in enumerate(progress):
c = Connection(host, user='******', connect_kwargs=self.connect)
c.put(PathMaker.committee_file(), '.')
c.put(PathMaker.key_file(i), '.')
c.put(PathMaker.threshold_key_file(i), '.')
c.put(PathMaker.parameters_file(), '.')
return committee
def install(self):
Print.info('Installing rust and cloning the repo...')
cmd = [
'sudo apt-get update',
'sudo apt-get -y upgrade',
'sudo apt-get -y autoremove',
# The following dependencies prevent the error: [error: linker `cc` not found].
'sudo apt-get -y install build-essential',
'sudo apt-get -y install cmake',
# Install rust (non-interactive).
'curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y',
'source $HOME/.cargo/env',
'rustup default stable',
# This is missing from the Rocksdb installer (needed for Rocksdb).
'sudo apt-get install -y clang',
# Clone the repo.
f'(git clone {self.settings.repo_url} || (cd {self.settings.repo_name} ; git pull))'
]
hosts = self.manager.hosts(flat=True)
try:
g = Group(*hosts, user='******', connect_kwargs=self.connect)
g.run(' && '.join(cmd), hide=True)
Print.heading(f'Initialized testbed of {len(hosts)} nodes')
except (GroupException, ExecutionError) as e:
e = FabricError(e) if isinstance(e, GroupException) else e
raise BenchError('Failed to install repo on testbed', e)
def plot(ctx):
''' Plot performance using the logs generated by "fab remote" '''
LogAggregator().print()
try:
Ploter.plot_robustness(Ploter.nodes)
Ploter.plot_latency(Ploter.nodes)
Ploter.plot_tps(Ploter.max_latency)
except PlotError as e:
Print.error(BenchError('Failed to plot performance', e))
def stop_instances(self):
try:
ids, _ = self._get(['pending', 'running'])
for region, client in self.clients.items():
if ids[region]:
client.stop_instances(InstanceIds=ids[region])
size = sum(len(x) for x in ids.values())
Print.heading(f'Stopping {size} instances')
except ClientError as e:
raise BenchError(AWSError(e))
def plot(ctx):
''' Plot performance using the logs generated by "fab remote" '''
plot_params = {
'nodes': [10, 20, 50],
'tx_size': 512,
'faults': [0],
'max_latency': [3_000, 6_000]
}
try:
Ploter.plot(plot_params)
except PlotError as e:
Print.error(BenchError('Failed to plot performance', e))
def _run_single(self,
hosts,
rate,
bench_parameters,
node_parameters,
debug=False):
Print.info('Booting testbed...')
# Kill any potentially unfinished run and delete logs.
self.kill(hosts=hosts, delete_logs=True)
Print.info('Killed previous instances')
sleep(10)
# Run the clients (they will wait for the nodes to be ready).
# Filter all faulty nodes from the client addresses (or they will wait
# for the faulty nodes to be online).
committee = Committee.load(PathMaker.committee_file())
addresses = [f'{x}:{self.settings.front_port}' for x in hosts]
rate_share = ceil(rate / committee.size()) # Take faults into account.
timeout = node_parameters.timeout_delay
client_logs = [PathMaker.client_log_file(i) for i in range(len(hosts))]
for host, addr, log_file in zip(hosts, addresses, client_logs):
cmd = CommandMaker.run_client(addr,
bench_parameters.tx_size,
rate_share,
timeout,
nodes=addresses)
self._background_run(host, cmd, log_file)
Print.info('Clients boosted...')
sleep(10)
# Run the nodes.
key_files = [PathMaker.key_file(i) for i in range(len(hosts))]
dbs = [PathMaker.db_path(i) for i in range(len(hosts))]
node_logs = [PathMaker.node_log_file(i) for i in range(len(hosts))]
threshold_key_files = [
PathMaker.threshold_key_file(i) for i in range(len(hosts))
]
for host, key_file, threshold_key_file, db, log_file in zip(
hosts, key_files, threshold_key_files, dbs, node_logs):
cmd = CommandMaker.run_node(key_file,
threshold_key_file,
PathMaker.committee_file(),
db,
PathMaker.parameters_file(),
debug=debug)
self._background_run(host, cmd, log_file)
# Wait for the nodes to synchronize
Print.info('Waiting for the nodes to synchronize...')
sleep(node_parameters.timeout_delay / 1000)
# Wait for all transactions to be processed.
duration = bench_parameters.duration
for _ in progress_bar(range(100),
prefix=f'Running benchmark ({duration} sec):'):
sleep(ceil(duration / 100))
self.kill(hosts=hosts, delete_logs=False)
def create_instances(self, instances):
assert isinstance(instances, int) and instances > 0
# Create the security group in every region.
for client in self.clients.values():
try:
self._create_security_group(client)
except ClientError as e:
error = AWSError(e)
if error.code != 'InvalidGroup.Duplicate':
raise BenchError('Failed to create security group', error)
try:
# Create all instances.
size = instances * len(self.clients)
progress = progress_bar(
self.clients.values(), prefix=f'Creating {size} instances'
)
for client in progress:
client.run_instances(
ImageId=self._get_ami(client),
InstanceType=self.settings.instance_type,
KeyName=self.settings.key_name,
MaxCount=instances,
MinCount=instances,
SecurityGroups=[self.SECURITY_GROUP_NAME],
TagSpecifications=[{
'ResourceType': 'instance',
'Tags': [{
'Key': 'Name',
'Value': self.INSTANCE_NAME
}]
}],
EbsOptimized=True,
BlockDeviceMappings=[{
'DeviceName': '/dev/sda1',
'Ebs': {
'VolumeType': 'gp2',
'VolumeSize': 200,
'DeleteOnTermination': True
}
}],
)
# Wait for the instances to boot.
Print.info('Waiting for all instances to boot...')
self._wait(['pending'])
Print.heading(f'Successfully created {size} new instances')
except ClientError as e:
raise BenchError('Failed to create AWS instances', AWSError(e))
def _update(self, hosts):
Print.info(
f'Updating {len(hosts)} nodes (branch "{self.settings.branch}")...'
)
cmd = [
f'(cd {self.settings.repo_name} && git fetch -f)',
f'(cd {self.settings.repo_name} && git checkout -f {self.settings.branch})',
f'(cd {self.settings.repo_name} && git pull -f)',
'source $HOME/.cargo/env',
f'(cd {self.settings.repo_name}/node && {CommandMaker.compile()})',
CommandMaker.alias_binaries(
f'./{self.settings.repo_name}/target/release/')
]
g = Group(*hosts, user='******', connect_kwargs=self.connect)
g.run(' && '.join(cmd), hide=True)
def _run_single(self,
hosts,
rate,
bench_parameters,
node_parameters,
debug=False):
Print.info('Booting testbed...')
# Kill any potentially unfinished run and delete logs.
self.kill(hosts=hosts, delete_logs=True)
# Run the clients (they will wait for the nodes to be ready).
committee = Committee.load(PathMaker.committee_file())
addresses = committee.front_addresses()
rate_share = ceil(rate / committee.size())
timeout = node_parameters.timeout_delay
client_logs = [PathMaker.client_log_file(i) for i in range(len(hosts))]
for host, addr, log_file in zip(hosts, addresses, client_logs):
cmd = CommandMaker.run_client(addr,
bench_parameters.tx_size,
rate_share,
timeout,
nodes=addresses)
self._background_run(host, cmd, log_file)
# Run the nodes.
key_files = [PathMaker.key_file(i) for i in range(len(hosts))]
dbs = [PathMaker.db_path(i) for i in range(len(hosts))]
node_logs = [PathMaker.node_log_file(i) for i in range(len(hosts))]
for host, key_file, db, log_file in zip(hosts, key_files, dbs,
node_logs):
cmd = CommandMaker.run_node(key_file,
PathMaker.committee_file(),
db,
PathMaker.parameters_file(),
debug=debug)
self._background_run(host, cmd, log_file)
# Wait for the nodes to synchronize
Print.info('Waiting for the nodes to synchronize...')
sleep(2 * node_parameters.timeout_delay / 1000)
# Wait for all transactions to be processed.
duration = bench_parameters.duration
for _ in progress_bar(range(20),
prefix=f'Running benchmark ({duration} sec):'):
sleep(ceil(duration / 20))
self.kill(hosts=hosts, delete_logs=False)
def _logs(self, hosts):
# Delete local logs (if any).
cmd = CommandMaker.clean_logs()
subprocess.run([cmd], shell=True, stderr=subprocess.DEVNULL)
# Download log files.
progress = progress_bar(hosts, prefix='Downloading logs:')
for i, host in enumerate(progress):
c = Connection(host, user='******', connect_kwargs=self.connect)
c.get(PathMaker.node_log_file(i), local=PathMaker.node_log_file(i))
c.get(PathMaker.client_log_file(i),
local=PathMaker.client_log_file(i))
# Parse logs and return the parser.
Print.info('Parsing logs and computing performance...')
return LogParser.process(PathMaker.logs_path())
def __init__(self, clients, nodes, faults, protocol, ddos):
inputs = [clients, nodes]
assert all(isinstance(x, list) for x in inputs)
assert all(isinstance(x, str) for y in inputs for x in y)
assert all(x for x in inputs)
self.protocol = protocol
self.ddos = ddos
self.faults = faults
self.committee_size = len(nodes) + faults
# Parse the clients logs.
try:
with Pool() as p:
results = p.map(self._parse_clients, clients)
except (ValueError, IndexError) as e:
raise ParseError(f'Failed to parse client logs: {e}')
self.size, self.rate, self.start, misses, self.sent_samples \
= zip(*results)
self.misses = sum(misses)
# Parse the nodes logs.
try:
with Pool() as p:
results = p.map(self._parse_nodes, nodes)
except (ValueError, IndexError) as e:
raise ParseError(f'Failed to parse node logs: {e}')
proposals, commits, sizes, self.received_samples, timeouts, self.configs \
= zip(*results)
self.proposals = self._merge_results([x.items() for x in proposals])
self.commits = self._merge_results([x.items() for x in commits])
self.sizes = {
k: v
for x in sizes for k, v in x.items() if k in self.commits
}
self.timeouts = max(timeouts)
# Check whether clients missed their target rate.
if self.misses != 0:
Print.warn(
f'Clients missed their target rate {self.misses:,} time(s)')
# Check whether the nodes timed out.
# Note that nodes are expected to time out once at the beginning.
if self.timeouts > 1:
Print.warn(f'Nodes timed out {self.timeouts:,} time(s)')
def terminate_instances(self):
try:
ids, _ = self._get(['pending', 'running', 'stopping', 'stopped'])
size = sum(len(x) for x in ids.values())
if size == 0:
Print.heading(f'All instances are shut down')
return
# Terminate instances.
for region, client in self.clients.items():
if ids[region]:
client.terminate_instances(InstanceIds=ids[region])
# Wait for all instances to properly shut down.
Print.info('Waiting for all instances to shut down...')
self._wait(['shutting-down'])
for client in self.clients.values():
client.delete_security_group(
GroupName=self.SECURITY_GROUP_NAME
)
Print.heading(f'Testbed of {size} instances destroyed')
except ClientError as e:
raise BenchError('Failed to terminate instances', AWSError(e))
def destroy(ctx):
''' Destroy the testbed '''
try:
InstanceManager.make().terminate_instances()
except BenchError as e:
Print.error(e)
def stop(ctx):
''' Stop all machines '''
try:
InstanceManager.make().stop_instances()
except BenchError as e:
Print.error(e)
def logs(ctx):
''' Print a summary of the logs '''
try:
print(LogParser.process('./logs').result())
except ParseError as e:
Print.error(BenchError('Failed to parse logs', e))
def create(ctx, nodes=2):
''' Create a testbed'''
try:
InstanceManager.make().create_instances(nodes)
except BenchError as e:
Print.error(e)
def run(self, bench_parameters_dict, node_parameters_dict, debug=False):
assert isinstance(debug, bool)
Print.heading('Starting remote benchmark')
try:
bench_parameters = BenchParameters(bench_parameters_dict)
node_parameters = NodeParameters(node_parameters_dict)
except ConfigError as e:
raise BenchError('Invalid nodes or bench parameters', e)
# Select which hosts to use.
selected_hosts = self._select_hosts(bench_parameters)
if not selected_hosts:
Print.warn('There are not enough instances available')
return
# Update nodes.
try:
self._update(selected_hosts)
except (GroupException, ExecutionError) as e:
e = FabricError(e) if isinstance(e, GroupException) else e
raise BenchError('Failed to update nodes', e)
# Run benchmarks.
for n in bench_parameters.nodes:
for r in bench_parameters.rate:
Print.heading(f'\nRunning {n} nodes (input rate: {r:,} tx/s)')
hosts = selected_hosts[:n]
# Upload all configuration files.
try:
self._config(hosts, node_parameters)
except (subprocess.SubprocessError, GroupException) as e:
e = FabricError(e) if isinstance(e, GroupException) else e
Print.error(BenchError('Failed to configure nodes', e))
continue
# Run the benchmark.
for i in range(bench_parameters.runs):
Print.heading(f'Run {i+1}/{bench_parameters.runs}')
try:
self._run_single(hosts, r, bench_parameters,
node_parameters, debug)
self._logs(hosts).print(
PathMaker.result_file(n, r,
bench_parameters.tx_size))
except (subprocess.SubprocessError, GroupException,
ParseError) as e:
self.kill(hosts=hosts)
if isinstance(e, GroupException):
e = FabricError(e)
Print.error(BenchError('Benchmark failed', e))
continue
def kill(ctx):
''' Stop any HotStuff execution on all machines '''
try:
Bench(ctx).kill()
except BenchError as e:
Print.error(e)
'sync_retry_delay': 10_000,
'max_payload_size': 500,
'min_block_delay': 0
},
'mempool': {
'queue_capacity': 10_000,
'sync_retry_delay': 100_000,
'max_payload_size': 15_000,
'min_block_delay': 0
}
}
try:
ret = LocalBench(bench_params, node_params).run(debug=False).result()
print(ret)
except BenchError as e:
Print.error(e)
@task
def create(ctx, nodes=2):
''' Create a testbed'''
try:
InstanceManager.make().create_instances(nodes)
except BenchError as e:
Print.error(e)
@task
def destroy(ctx):
''' Destroy the testbed '''
try:
def start(ctx, max=10):
''' Start at most `max` machines per data center '''
try:
InstanceManager.make().start_instances(max)
except BenchError as e:
Print.error(e)
def run(self, bench_parameters_dict, node_parameters_dict, debug=False):
assert isinstance(debug, bool)
Print.heading('Starting remote benchmark')
try:
bench_parameters = BenchParameters(bench_parameters_dict)
node_parameters = NodeParameters(node_parameters_dict)
except ConfigError as e:
raise BenchError('Invalid nodes or bench parameters', e)
# Select which hosts to use.
selected_hosts = self._select_hosts(bench_parameters)
if not selected_hosts:
Print.warn('There are not enough instances available')
return
# Update nodes.
try:
self._update(selected_hosts)
except (GroupException, ExecutionError) as e:
e = FabricError(e) if isinstance(e, GroupException) else e
raise BenchError('Failed to update nodes', e)
if node_parameters.protocol == 0:
Print.info('Running HotStuff')
elif node_parameters.protocol == 1:
Print.info('Running AsyncHotStuff')
elif node_parameters.protocol == 2:
Print.info('Running TwoChainVABA')
else:
Print.info('Wrong protocol type!')
return
Print.info(f'{bench_parameters.faults} faults')
Print.info(
f'Timeout {node_parameters.timeout_delay} ms, Network delay {node_parameters.network_delay} ms'
)
Print.info(f'DDOS attack {node_parameters.ddos}')
hosts = selected_hosts[:bench_parameters.nodes[0]]
# Upload all configuration files.
try:
self._config(hosts, node_parameters)
except (subprocess.SubprocessError, GroupException) as e:
e = FabricError(e) if isinstance(e, GroupException) else e
Print.error(BenchError('Failed to configure nodes', e))
# Run benchmarks.
for n in bench_parameters.nodes:
for r in bench_parameters.rate:
Print.heading(f'\nRunning {n} nodes (input rate: {r:,} tx/s)')
hosts = selected_hosts[:n]
# # Upload all configuration files.
# try:
# self._config(hosts, node_parameters)
# except (subprocess.SubprocessError, GroupException) as e:
# e = FabricError(e) if isinstance(e, GroupException) else e
# Print.error(BenchError('Failed to configure nodes', e))
# continue
# Do not boot faulty nodes.
faults = bench_parameters.faults
hosts = hosts[:n - faults]
protocol = node_parameters.protocol
ddos = node_parameters.ddos
# Run the benchmark.
for i in range(bench_parameters.runs):
Print.heading(f'Run {i+1}/{bench_parameters.runs}')
try:
self._run_single(hosts, r, bench_parameters,
node_parameters, debug)
self._logs(hosts, faults, protocol, ddos).print(
PathMaker.result_file(n, r,
bench_parameters.tx_size,
faults))
except (subprocess.SubprocessError, GroupException,
ParseError) as e:
self.kill(hosts=hosts)
if isinstance(e, GroupException):
e = FabricError(e)
Print.error(BenchError('Benchmark failed', e))
continue
def run(self, debug=False):
assert isinstance(debug, bool)
Print.heading('Starting local benchmark')
# Kill any previous testbed.
self._kill_nodes()
try:
Print.info('Setting up testbed...')
nodes, rate = self.nodes[0], self.rate[0]
# Cleanup all files.
cmd = f'{CommandMaker.clean_logs()} ; {CommandMaker.cleanup()}'
subprocess.run([cmd], shell=True, stderr=subprocess.DEVNULL)
sleep(0.5) # Removing the store may take time.
# Recompile the latest code.
cmd = CommandMaker.compile().split()
subprocess.run(cmd, check=True, cwd=PathMaker.node_crate_path())
# Create alias for the client and nodes binary.
cmd = CommandMaker.alias_binaries(PathMaker.binary_path())
subprocess.run([cmd], shell=True)
# Generate configuration files.
keys = []
key_files = [PathMaker.key_file(i) for i in range(nodes)]
for filename in key_files:
cmd = CommandMaker.generate_key(filename).split()
subprocess.run(cmd, check=True)
keys += [Key.from_file(filename)]
names = [x.name for x in keys]
committee = LocalCommittee(names, self.BASE_PORT)
committee.print(PathMaker.committee_file())
self.node_parameters.print(PathMaker.parameters_file())
# Run the clients (they will wait for the nodes to be ready).
addresses = committee.front_addresses()
rate_share = ceil(rate / nodes)
timeout = self.node_parameters.timeout_delay
client_logs = [PathMaker.client_log_file(i) for i in range(nodes)]
for addr, log_file in zip(addresses, client_logs):
cmd = CommandMaker.run_client(addr, self.tx_size, rate_share,
timeout)
self._background_run(cmd, log_file)
# Run the nodes.
dbs = [PathMaker.db_path(i) for i in range(nodes)]
node_logs = [PathMaker.node_log_file(i) for i in range(nodes)]
for key_file, db, log_file in zip(key_files, dbs, node_logs):
cmd = CommandMaker.run_node(key_file,
PathMaker.committee_file(),
db,
PathMaker.parameters_file(),
debug=debug)
self._background_run(cmd, log_file)
# Wait for the nodes to synchronize
Print.info('Waiting for the nodes to synchronize...')
sleep(2 * self.node_parameters.timeout_delay / 1000)
# Wait for all transactions to be processed.
Print.info(f'Running benchmark ({self.duration} sec)...')
sleep(self.duration)
self._kill_nodes()
# Parse logs and return the parser.
Print.info('Parsing logs...')
return LogParser.process('./logs')
except (subprocess.SubprocessError, ParseError) as e:
self._kill_nodes()
raise BenchError('Failed to run benchmark', e)
def info(ctx):
''' Display connect information about all the available machines '''
try:
InstanceManager.make().print_info()
except BenchError as e:
Print.error(e)
def install(ctx):
''' Install HotStuff on all machines '''
try:
Bench(ctx).install()
except BenchError as e:
Print.error(e)
def run(self, debug=False):
assert isinstance(debug, bool)
Print.heading('Starting local benchmark')
# Kill any previous testbed.
self._kill_nodes()
try:
Print.info('Setting up testbed...')
nodes, rate = self.nodes[0], self.rate[0]
# Cleanup all files.
cmd = f'{CommandMaker.clean_logs()} ; {CommandMaker.cleanup()}'
subprocess.run([cmd], shell=True, stderr=subprocess.DEVNULL)
sleep(0.5) # Removing the store may take time.
# Recompile the latest code.
cmd = CommandMaker.compile().split()
subprocess.run(cmd, check=True, cwd=PathMaker.node_crate_path())
# Create alias for the client and nodes binary.
cmd = CommandMaker.alias_binaries(PathMaker.binary_path())
subprocess.run([cmd], shell=True)
# Generate configuration files.
keys = []
key_files = [PathMaker.key_file(i) for i in range(nodes)]
for filename in key_files:
cmd = CommandMaker.generate_key(filename).split()
subprocess.run(cmd, check=True)
keys += [Key.from_file(filename)]
# Generate threshold signature files.
cmd = './node threshold_keys'
for i in range(nodes):
cmd += ' --filename ' + PathMaker.threshold_key_file(i)
# print(cmd)
cmd = cmd.split()
subprocess.run(cmd, capture_output=True, check=True)
names = [x.name for x in keys]
tss_keys = []
for i in range(nodes):
tss_keys += [TSSKey.from_file(PathMaker.threshold_key_file(i))]
ids = [x.id for x in tss_keys]
committee = LocalCommittee(names, ids, self.BASE_PORT)
committee.print(PathMaker.committee_file())
self.node_parameters.print(PathMaker.parameters_file())
# Do not boot faulty nodes.
nodes = nodes - self.faults
# Run the clients (they will wait for the nodes to be ready).
addresses = committee.front
rate_share = ceil(rate / nodes)
timeout = self.node_parameters.timeout_delay
client_logs = [PathMaker.client_log_file(i) for i in range(nodes)]
for addr, log_file in zip(addresses, client_logs):
cmd = CommandMaker.run_client(addr, self.tx_size, rate_share,
timeout)
self._background_run(cmd, log_file)
if self.node_parameters.protocol == 0:
Print.info('Running HotStuff')
elif self.node_parameters.protocol == 1:
Print.info('Running Async HotStuff')
elif self.node_parameters.protocol == 2:
Print.info('Running TwoChainVABA')
else:
Print.info('Wrong protocol type!')
return
Print.info(f'{self.faults} faults')
Print.info(
f'Timeout {self.node_parameters.timeout_delay} ms, Network delay {self.node_parameters.network_delay} ms'
)
Print.info(f'DDOS attack {self.node_parameters.ddos}')
# Run the nodes.
dbs = [PathMaker.db_path(i) for i in range(nodes)]
node_logs = [PathMaker.node_log_file(i) for i in range(nodes)]
threshold_key_files = [
PathMaker.threshold_key_file(i) for i in range(nodes)
]
for key_file, threshold_key_file, db, log_file in zip(
key_files, threshold_key_files, dbs, node_logs):
cmd = CommandMaker.run_node(key_file,
threshold_key_file,
PathMaker.committee_file(),
db,
PathMaker.parameters_file(),
debug=debug)
self._background_run(cmd, log_file)
# Wait for the nodes to synchronize
Print.info('Waiting for the nodes to synchronize...')
sleep(2 * self.node_parameters.timeout_delay / 1000)
# Wait for all transactions to be processed.
Print.info(f'Running benchmark ({self.duration} sec)...')
sleep(self.duration)
self._kill_nodes()
# Parse logs and return the parser.
Print.info('Parsing logs...')
return LogParser.process('./logs', self.faults,
self.node_parameters.protocol,
self.node_parameters.ddos)
except (subprocess.SubprocessError, ParseError) as e:
self._kill_nodes()
raise BenchError('Failed to run benchmark', e)
