def main(args):
"""Entry point.
:param args: Parsed CLI arguments.
"""
# Pull data.
network_id = factory.create_network_id(args.network)
data = cache.orchestration.get_info_list(network_id, args.run_type, args.run_index)
if not data:
logger.log("No run information found.")
return
# Set cols/rows.
cols = ["Phase / Step", "Start Time", "Duration (s)", "Action", "Status"]
rows = map(lambda i: [
i.index_label,
i.ts_start,
i.tp_elapsed_label,
i.step_label if i.step_label else '--' ,
i.status.name,
], sorted(data, key=lambda i: i.index_label))
# Set table.
t = get_table(cols, rows)
t.column_alignments['Phase / Step'] = BeautifulTable.ALIGN_LEFT
t.column_alignments['Start Time'] = BeautifulTable.ALIGN_LEFT
t.column_alignments['Duration (s)'] = BeautifulTable.ALIGN_RIGHT
t.column_alignments['Action'] = BeautifulTable.ALIGN_RIGHT
t.column_alignments['Status'] = BeautifulTable.ALIGN_RIGHT
# Render.
print(t)
print(f"{network_id.name} - {args.run_type} - Run {args.run_index}")
def main(args: argparse.Namespace):
"""Entry point.
"""
# Import initialiser to setup upstream services / actors.
import stests.initialiser
# Unpack args.
network_id = factory.create_network_id(args.network_name)
node_id = factory.create_node_id(network_id, args.node_index)
# Set execution context.
ctx = factory.create_run_info(args=Arguments.create(args),
loop_count=args.loop_count,
loop_interval=args.loop_interval,
network_id=network_id,
node_id=node_id,
run_index=args.run_index,
run_type=constants.TYPE,
use_stored_contracts=True)
# Abort if a run lock cannot be acquired.
if is_run_locked(ctx):
logger.log_warning(
f"{constants.TYPE} :: run {args.run_index} aborted as it is currently executing."
)
# Start run.
else:
from stests.orchestration.actors import do_run
do_run.send(ctx)
logger.log(f"{constants.TYPE} :: run {args.run_index} started")
def main(args: argparse.Namespace):
"""Entry point.
"""
# Set run context.
network_id = factory.create_network_id(args.network)
node_id = factory.create_node_id(network_id, args.node)
ctx = factory.create_run_context(args=Arguments.create(args),
network_id=network_id,
node_id=node_id,
run=args.run,
run_type=constants.TYPE)
# Flush previous cache data.
cache.flush_run(ctx)
# Initialise MQ broker.
mq.initialise()
# Import actors.
import stests.generators.correlator
import stests.generators.wg_100.phase_1
import stests.generators.wg_100.phase_2
import stests.generators.wg_100.step_incrementor
# Start workflow.
logger.log("... workload generator begins")
# Execute first actor in pipeline.
from stests.generators.wg_100.step_incrementor import PIPELINE
PIPELINE[0].send(ctx)
def main(args):
"""Entry point.
:param args: Parsed CLI arguments.
"""
# Unpack.
host = args.address.split(':')[0]
index = int(args.node.split(':')[-1])
network = args.node.split(':')[0]
port = int(args.address.split(':')[-1])
typeof = NodeType[args.typeof.upper()]
# Instantiate.
node = factory.create_node(host=host,
index=index,
network_id=factory.create_network_id(network),
port=port,
typeof=typeof)
# Push.
cache.set_network_node(node)
# Notify.
logger.log(f"Node {args.node} was successfully registered")
def main(args):
"""Entry point.
:param args: Parsed CLI arguments.
"""
# Pull data.
network_id = factory.create_network_id(args.network)
network = cache.infra.get_network(network_id)
if network is None:
logger.log_warning(f"Network {args.network} is unregistered.")
return
data = cache.infra.get_nodes(network_id)
if not data:
logger.log_warning(f"Network {args.network} has no nodes.")
return
# Set cols/rows.
cols = ["ID", "Host:Port", "Type", "Status"]
rows = map(
lambda i: [
i.index_label,
f"{i.host}:{i.port}",
i.typeof.name,
i.status.name,
], sorted(data, key=lambda i: i.index))
# Set table.
t = get_table(cols, rows)
t.column_alignments['Host:Port'] = BeautifulTable.ALIGN_LEFT
# Render.
print(t)
print(f"{network_id.name} node count = {len(data)}")
def main(args):
"""Entry point.
:param args: Parsed CLI arguments.
"""
# Unpack.
network_id = factory.create_network_id(args.node.split(':')[0])
node_id = factory.create_node_id(network_id, int(args.node.split(':')[-1]))
# Pull.
node = cache.get_node(node_id)
if node is None:
raise ValueError("Unregistered node.")
# Set key pair.
pvk, pbk = crypto.get_key_pair_from_pvk_pem_file(args.pem_path,
crypto.KeyEncoding.HEX)
# Set bonding account.
node.account = factory.create_account(index=-node_id.index,
private_key=pvk,
public_key=pbk,
status=AccountStatus.ACTIVE,
typeof=AccountType.BOND)
# Push.
cache.set_network_node(node)
# Inform.
logger.log(f"Node {args.node} bonding key was successfully registered")
def main(args):
"""Entry point.
:param args: Parsed CLI arguments.
"""
# Pull data.
network_id = factory.create_network_id(args.network)
data = cache.state.get_deploys(network_id, args.run_type, args.run_index)
if not data:
logger.log("No run deploys found.")
return
# Set table cols/rows.
cols = [i for i, _ in COLS]
rows = map(lambda i: [
i.deploy_hash,
i.typeof.name,
i.status.name,
i.dispatch_node,
i.dispatch_ts,
i.label_finalization_time,
i.block_hash or "--"
], sorted(data, key=lambda i: i.dispatch_ts))
# Set table.
t = get_table(cols, rows, max_width=1080)
# Set table alignments.
for key, aligmnent in COLS:
t.column_alignments[key] = aligmnent
# Render.
print(t)
print(f"{network_id.name} - {args.run_type} - Run {args.run_index}")
def main(args):
"""Entry point.
:param args: Parsed CLI arguments.
"""
# Pull data.
network_id = factory.create_network_id(args.network)
data = cache.orchestration.get_info_list(network_id, args.run_type)
data = [i for i in data if i.aspect == ExecutionAspect.RUN]
if not data:
logger.log("No run information found.")
return
# Set cols/rows.
cols = ["Network", "Type", "ID", "Start Time", "Duration (s)", "Status"]
rows = map(
lambda i: [
network_id.name, i.run_type,
i.index_label.strip(), i.ts_start, i.tp_elapsed_label, i.
status_label
], sorted(data, key=lambda i: f"{i.run_type}.{i.index_label}"))
# Set table.
t = get_table(cols, rows)
t.column_alignments['Start Time'] = BeautifulTable.ALIGN_LEFT
t.column_alignments['Duration (s)'] = BeautifulTable.ALIGN_RIGHT
# Render.
print(t)
print(f"total runs = {len(data)}")
def get_network_by_name(name: str) -> Network:
"""Decaches domain object: Network.
:param name: Name of a registered network.
:returns: A registered network.
"""
return get_network(factory.create_network_id(name))
def get_run_network(ctx: RunContext) -> Network:
"""Decaches domain object: Network.
:param ctx: Generator run contextual information.
:returns: A registered network.
"""
network_id = factory.create_network_id(ctx.network)
return get_network(network_id)
def do_start_monitoring():
"""Starts monitoring of registered networks.
"""
# Reset all stream locks.
cache.monitoring.flush_stream_locks()
# Monitor each network.
for network in cache.infra.get_networks():
network_id = factory.create_network_id(network.name)
do_monitor_network.send(network_id)
def get_run_network(ctx: ExecutionContext) -> Network:
"""Decaches domain object: Network.
:param ctx: Execution context information.
:returns: A registered network.
"""
network_id = factory.create_network_id(ctx.network)
return infra.get_network(network_id)
def main(args):
"""Entry point.
:param args: Parsed CLI arguments.
"""
network_id = factory.create_network_id(args.network)
network = cache.infra.get_network(network_id)
if network is None:
logger.log_warning(f"Network {args.network} is unregistered.")
return
logger.log(
f"""NETWORK: {network.name} -> faucet pvk {network.faucet.private_key}"""
)
logger.log(
f"""NETWORK: {network.name} -> faucet pbk {network.faucet.public_key}"""
)
def main(args):
"""Entry point.
:param args: Parsed CLI arguments.
"""
# Unpack.
network_id = factory.create_network_id(args.node.split(':')[0])
node_id = factory.create_node_id(network_id, int(args.node.split(':')[-1]))
# Pull.
node = cache.infra.get_node(node_id)
if node is None:
raise ValueError("Unregistered node.")
# Inform.
logger.log(
f"""NODE: {node.label} -> bonding pvk {node.account.private_key}""")
logger.log(
f"""NODE: {node.label} -> bonding pbk {node.account.public_key}""")
def main(args):
"""Entry point.
:param args: Parsed CLI arguments.
"""
# Unpack.
network_id = factory.create_network_id(args.node.split(':')[0])
node_id = factory.create_node_id(network_id, int(args.node.split(':')[-1]))
# Pull.
node = cache.infra.get_node(node_id)
if node is None:
raise ValueError("Unregistered node.")
# Update.
node.status = NodeStatus[args.status.upper()]
# Push.
cache.infra.set_node(node)
# Notify.
logger.log(f"Node {args.node} status was updated --> {node.status}")
def get_run_node(ctx: RunContext) -> Node:
"""Decaches domain object: Node.
:param ctx: Generator run contextual information.
:returns: A registered node.
"""
# Pull healthy nodes.
network_id = factory.create_network_id(ctx.network)
nodes = [i for i in get_nodes(network_id) if i.status == NodeStatus.HEALTHY]
if not nodes:
raise ValueError(f"Network {network_id.name} has no registered healthy nodes.")
# Select random if node index unspecified.
if ctx.node <= 0 or ctx.node is None:
return random.choice(nodes)
# Select specific with fallback to random.
try:
return nodes[ctx.node - 1]
except IndexError:
return random.choice(nodes)
def get_node_by_run_context(ctx: ExecutionContext) -> Node:
"""Decaches domain object: Node.
:param ctx: Execution context information.
:returns: A registered node.
"""
# Pull operational nodes.
network_id = factory.create_network_id(ctx.network)
nodeset = get_nodes_operational(network_id)
if not nodeset:
raise ValueError(
f"Network {network_id.name} has no registered operational nodes.")
# Select random if node index unspecified.
if ctx.node_index <= 0 or ctx.node_index is None:
return random.choice(nodeset)
# Select specific with fallback to random.
try:
return nodeset[ctx.node_index - 1]
except IndexError:
return random.choice(nodeset)
from stests.core import cache
from stests.core import mq
from stests.core.utils import factory
# Initialise MQ sub-package.
mq.initialise(mq.BrokerMode.MONITORS)
from stests.monitoring.chain import do_monitor_blocks
# Iterate networks & wire upto streaming events.
for network in cache.get_networks():
network_id = factory.create_network_id(network.name)
do_monitor_blocks.send(network_id)
def create_network_id() -> NetworkIdentifier:
return factory.create_network_id("lrt1")
