def main(args):
"""Entry point.
:param args: Parsed CLI arguments.
"""
# Pull.
network_id = factory.create_network_id(args.network)
network = cache.infra.get_network(network_id)
if network is None:
raise ValueError("Unregistered network.")
# Set key pair.
pvk, pbk = crypto.get_key_pair_from_pvk_pem_file(
args.pem_path,
crypto.KeyAlgorithm.ED25519,
crypto.KeyEncoding.HEX,
)
# Set faucet.
network.faucet = factory.create_account(
network=network.name,
typeof=AccountType.NETWORK_FAUCET,
index=0,
key_algo=crypto.KeyAlgorithm.ED25519,
private_key=pvk,
public_key=pbk,
)
# Push.
cache.infra.set_network(network)
# Inform.
utils.log(f"Network {args.network} faucet key was successfully registered")
def get_network_node(src: typing.Union[ExecutionContext, NodeIdentifier],
node_index=None) -> typing.Tuple[Network, Node]:
"""Returns the network and node to which deploy(s) will be dispatched.
:param src: Source from which targets will be derived.
:returns: 2 member tuple -> (network, node).
"""
if isinstance(src, ExecutionContext):
network_id = factory.create_network_id(src.network)
network = cache.infra.get_network(network_id)
if node_index is not None:
node_id = factory.create_node_id(network_id, node_index)
node = cache.infra.get_node(node_id)
elif src.node_index != 0:
node_id = factory.create_node_id(network_id, src.node_index)
node = cache.infra.get_node(node_id)
else:
node = cache.infra.get_node_by_network(network)
elif isinstance(src, NodeIdentifier):
network = cache.infra.get_network(src.network_id)
node = cache.infra.get_node(src)
else:
raise ValueError("Cannot derive network & node from source")
return network, node
def main(args):
"""Entry point.
:param args: Parsed CLI arguments.
"""
# Unpack.
host = args.hostname
index = int(args.node)
network = args.network
port_rest = int(args.port_rest)
port_rpc = int(args.port_rpc)
port_event = int(args.port_event)
typeof = NodeType[args.typeof.upper()]
# Instantiate.
node = factory.create_node(group=NodeGroup.UNKNOWN,
host=host,
index=index,
network_id=factory.create_network_id(network),
port_rest=port_rest,
port_rpc=port_rpc,
port_event=port_event,
typeof=typeof)
# Push.
cache.infra.set_node(node)
# Notify.
utils.log(f"Node {args.network}:{args.node} was successfully registered")
def main(args):
"""Entry point.
:param args: Parsed CLI arguments.
"""
# Unpack.
network_id = factory.create_network_id(args.network)
node_id = factory.create_node_id(network_id, int(args.node))
# 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.
utils.log(
f"Node {args.network}:{args.node} status was updated --> {node.status}"
)
def start_generator(meta: typing.Any):
"""Entry point.
:param meta: Generator meta-data.
"""
# Parse cli args.
args = meta.ARGS.parse_args()
# Import worker to setup upstream services / actors.
_import_actors()
# Import dramatiq actor used to ping message to broker.
from stests.core.orchestration.run import do_run
# Unpack args.
network_id = factory.create_network_id(args.network_name)
node_id = factory.create_node_id(network_id, args.node_index)
# Start generator(s).
ctx_list = _get_context_list(meta, args, network_id, node_id)
for ctx in ctx_list:
do_run.send(ctx)
# Notify.
if len(ctx_list) == 1:
log_event(EventType.WFLOW_GENERATOR_LAUNCHED,
f"{ctx.run_type} :: run {ctx.run_index}", ctx)
else:
log_event(
EventType.WFLOW_GENERATORS_LAUNCHED,
f"{ctx.run_type} :: runs {ctx_list[0].run_index} -> {ctx_list[-1].run_index}",
ctx)
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:
utils.log("No run information found.")
return
# Filter by status.
if args.status not in (None, "*"):
for status in ExecutionStatus:
if status.name.lower().startswith(args.status.lower()):
data = [i for i in data if i.status == status]
break
# Associate info with execution context.
ctx_list = cache.orchestration.get_context_list(network_id, args.run_type)
for i in data:
i.ctx = _get_ctx(i, ctx_list)
# Associate info with deploy count.
keys, counts = cache.orchestration.get_deploy_count_list(
network_id, args.run_type)
counts = dict(zip(keys, counts))
for i in data:
i.deploy_count = _get_deploy_count(i, counts)
# Sort data.
data = sorted(data, key=lambda i: f"{i.run_type}.{i.label_index}")
# Set cols/rows.
cols = [i for i, _ in COLS]
rows = map(lambda i: _get_row(i, counts), data)
# Set table.
t = utils.get_table(cols, rows)
# Set table alignments.
for key, aligmnent in COLS:
t.column_alignments[key] = aligmnent
# Render.
print(t)
print(
"----------------------------------------------------------------------------------------------------------------------------"
)
print(f"{network_id.name} - total runs = {len(data)}.")
print(
"----------------------------------------------------------------------------------------------------------------------------"
)
def do_start_monitoring():
"""Starts monitoring of registered networks.
"""
for network in cache.infra.get_networks():
network_id = factory.create_network_id(network.name)
for node in cache.infra.get_nodes_for_monitoring(network, _MAX_NODES):
do_monitor_node.send(
factory.create_node_id(network_id, node.index), )
time.sleep(float(1))
def get_network(args) -> Network:
"""Maps input args to a target network node.
"""
network_id = factory.create_network_id(args.network)
network = cache.infra.get_network(network_id)
if network is None:
raise ValueError("Unregistered network.")
return network
def __init__(self, info: NodeEventInfo):
self.block = None
self.block_hash = info.block_hash
self.deploy = None
self.deploy_hash = None
self.info = info
self.network_id = factory.create_network_id(info.network)
self.network = cache.infra.get_network(self.network_id)
self.node_id = factory.create_node_id(self.network_id, info.node_index)
self.node = cache.infra.get_node(self.node_id)
self.on_chain_block = None
self.on_chain_deploy = None
def _register_node(
network: Network,
index: int,
info: typing.Tuple[str, int, pathlib.Path]
):
"""Register a network node.
"""
# Destructure node info.
host, weight, path_sk_pem = info
# Set default ports.
port_rpc = 7777
port_rest = 8888
port_sse = 9999
# Set node.
node = factory.create_node(
group=NodeGroup.UNKNOWN,
host=host,
index=index,
network_id=factory.create_network_id(network.name_raw),
port_rest=port_rest,
port_rpc=port_rpc,
port_event=port_sse,
typeof=NodeType.VALIDATOR,
weight=weight,
)
# Set bonding key pair.
private_key, public_key = crypto.get_key_pair_from_pvk_pem_file(
path_sk_pem,
algo=crypto.KeyAlgorithm.ED25519,
encoding=crypto.KeyEncoding.HEX,
)
# Set bonding account.
node.account = factory.create_account(
network=network.name,
typeof=AccountType.VALIDATOR_BOND,
index=index,
key_algo=crypto.KeyAlgorithm.ED25519,
private_key=private_key,
public_key=public_key,
)
# Push.
cache.infra.set_node(node)
# Inform.
utils.log(f"registered {network.name_raw} - {node.address_rpc} : {node.typeof.name}")
def get_network_nodeset(args) -> typing.Tuple[Network, typing.List[Node]]:
"""Maps input args to a target network node.
"""
network_id = factory.create_network_id(args.network)
network = cache.infra.get_network(network_id)
if network is None:
raise ValueError("Unregistered network.")
nodeset = cache.infra.get_nodes_for_dispatch(network)
if nodeset is None or len(nodeset) == 0:
raise ValueError("Unregistered nodeset.")
return network, sorted(nodeset, key=lambda i: i.index)
def get_network_node(args) -> typing.Tuple[Network, Node]:
"""Maps input args to a target network node.
"""
network_id = factory.create_network_id(args.network)
network = cache.infra.get_network(network_id)
if network is None:
raise ValueError("Unregistered network.")
node_id = factory.create_node_id(network_id, int(args.node))
node = cache.infra.get_node(node_id)
if node is None:
raise ValueError("Unregistered node.")
return network, node
def _register_node(network: Network, accounts: dict, index: int,
info: typing.Tuple[str, dict, pathlib.Path]):
"""Register a network node.
"""
host, cfg, path_to_pvk, is_boostrap = info
# Set bonding key pair.
private_key, public_key = crypto.get_key_pair_from_pvk_pem_file(
path_to_pvk, crypto.DEFAULT_KEY_ALGO, crypto.KeyEncoding.HEX)
# Set staking weight.
_, _, _, stake_weight = _get_account(accounts, public_key,
crypto.DEFAULT_KEY_ALGO)
# Set group.
group = NodeGroup.BOOTSTRAP if is_boostrap else NodeGroup.GENESIS
# Set node.
node = factory.create_node(
group=group,
host=host,
index=index,
network_id=factory.create_network_id(network.name_raw),
port_rest=8888,
port_rpc=7777,
port_event=9999,
typeof=NodeType.VALIDATOR,
use_to_dispatch=True,
use_to_monitor=random.choice(range(4)) == 0,
use_to_query=True,
weight=stake_weight,
)
# Set bonding account.
node.account = factory.create_account(
network=network.name,
typeof=AccountType.VALIDATOR_BOND,
index=index,
key_algo=crypto.KeyAlgorithm.ED25519,
private_key=private_key,
public_key=public_key,
)
# Push.
cache.infra.set_node(node)
utils.log(f"Registered {node.label}")
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:
utils.log("No run deploys found.")
return
# Sort data.
data = sorted(data, key=lambda i: i.dispatch_timestamp)
# Render views.
_render_table(args, network_id, data)
_render_finalization_stats(data)
def main(args):
"""Entry point.
:param args: Parsed CLI arguments.
"""
# Set run 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:
utils.log("No run information found.")
return
# Set sorted data.
data = sorted(data, key=lambda i: i.label_index)
# Set deploy counts.
keys, counts = cache.orchestration.get_deploy_count_list(
network_id, args.run_type, args.run_index)
keys = [i.split(":") for i in keys]
keys = [f"{i[3]}.{i[5]}" if i[5] != "-" else i[3] for i in keys]
counts = dict(zip(keys, counts))
# Set table.
t = utils.get_table(
[i for i, _ in COLS],
map(lambda i: _get_row(i, counts), data),
)
for key, aligmnent in COLS:
t.column_alignments[key] = aligmnent
# Render.
print(t)
print(
"--------------------------------------------------------------------------------------------------------------------"
)
print(f"{network_id.name} - {args.run_type} - Run {args.run_index}")
print(
"--------------------------------------------------------------------------------------------------------------------"
)
def main(args):
"""Entry point.
:param args: Parsed CLI arguments.
"""
# Pull.
network_id = factory.create_network_id(args.network)
network = cache.infra.get_network(network_id)
if network is None:
raise ValueError("Unregistered network.")
# Update.
network.status = NetworkStatus[args.status.upper()]
# Push.
cache.infra.set_network(network)
# Notify.
utils.log(
f"Network {args.network} status was updated --> {network.status}")
def main(args):
"""Entry point.
:param args: Parsed CLI arguments.
"""
# Unpack.
network_id = factory.create_network_id(args.network)
node_id = factory.create_node_id(network_id, int(args.node))
# Pull.
node = cache.infra.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,
algo=crypto.KeyAlgorithm.ED25519,
encoding=crypto.KeyEncoding.HEX)
# Set bonding account.
node.account = factory.create_account(
network=network_id.name,
typeof=AccountType.VALIDATOR_BOND,
index=-node_id.index,
key_algo=crypto.KeyAlgorithm.ED25519,
private_key=pvk,
public_key=pbk,
)
# Push.
cache.infra.set_node(node)
# Inform.
utils.log(
f"Node {args.network}:{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)
if cache.infra.get_network(network_id) is None:
utils.log_warning(f"Network {args.network} is unregistered.")
return
data = cache.infra.get_named_keys(network_id)
if not data:
utils.log_warning(f"Network {args.network} has no registered contracts.")
return
# Sort data.
data = sorted(data, key=lambda i: f"{i.contract_type}.{i.name}")
# Set table cols/rows.
cols = [i for i, _ in COLS]
rows = map(lambda i: [
network_id.name,
i.contract_type,
i.name,
i.hash,
], data)
# Set table.
t = utils.get_table(cols, rows)
# Set table alignments.
for key, aligmnent in COLS:
t.column_alignments[key] = aligmnent
# Render.
print(t)
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:
utils.log_warning(f"Network {args.network} is unregistered.")
return
data = cache.infra.get_nodes(network_id)
if not data:
utils.log_warning(f"Network {args.network} has no nodes.")
return
# Set cols/rows.
cols = [i for i, _ in COLS]
rows = map(
lambda i: [
i.label_index,
f"{i.host}:{i.port_rpc}",
i.typeof.name,
], sorted(data, key=lambda i: i.index))
# Set table.
t = utils.get_table(cols, rows)
# Set table alignments.
for key, aligmnent in COLS:
t.column_alignments[key] = aligmnent
# Render.
print(t)
print(f"{network_id.name} node count = {len(data)}")
def _register_node(network: Network, accounts: dict,
info: typing.Tuple[int, dict, pathlib.Path]):
"""Register a network node.
"""
# Destructure node info.
index, cfg, path_pvk_pem = info
# Set bonding key pair.
private_key, public_key = crypto.get_key_pair_from_pvk_pem_file(
path_pvk_pem, crypto.DEFAULT_KEY_ALGO, crypto.KeyEncoding.HEX)
# Set entry in accounts.toml.
account_info = _get_account(accounts, public_key, crypto.DEFAULT_KEY_ALGO)
if account_info is None:
return
# Set staking weight.
_, _, _, stake_weight = account_info
# Set node addrress.
node_address_event = cfg['event_stream_server']['address']
node_address_rest = cfg['rest_server']['address']
node_address_rpc = cfg['rpc_server']['address']
# Set node host.
node_host_event = node_address_event.split(":")[0]
node_host_rest = node_address_rest.split(":")[0]
node_host_rpc = node_address_rpc.split(":")[0]
assert node_host_event == node_host_rest == node_host_rpc, "hostname mismatch"
node_host = node_host_event
# Set node ports - derived.
node_port_event = _get_node_port("event", network.index, index)
node_port_rpc = _get_node_port("rpc", network.index, index)
node_port_rest = _get_node_port("rest", network.index, index)
# Set node group.
if index <= network.count_of_bootstrap_nodes:
group = NodeGroup.BOOTSTRAP
elif index <= network.count_of_genesis_nodes:
group = NodeGroup.GENESIS
else:
group = NodeGroup.OTHER
# Set function flags - initially only interact with genesis nodes.
use_to_dispatch = group in (NodeGroup.BOOTSTRAP, NodeGroup.GENESIS)
use_to_monitor = group in (NodeGroup.BOOTSTRAP, NodeGroup.GENESIS)
use_to_query = group in (NodeGroup.BOOTSTRAP, NodeGroup.GENESIS)
# Set node.
node = factory.create_node(
group=group,
host=node_host,
index=index,
network_id=factory.create_network_id(network.name_raw),
port_rest=node_port_rest,
port_rpc=node_port_rpc,
port_event=node_port_event,
typeof=NodeType.VALIDATOR,
use_to_dispatch=use_to_dispatch,
use_to_monitor=use_to_monitor,
use_to_query=use_to_query,
weight=stake_weight,
)
# Set bonding account.
node.account = factory.create_account(
network=network.name,
typeof=AccountType.VALIDATOR_BOND,
index=index,
key_algo=crypto.KeyAlgorithm.ED25519,
private_key=private_key,
public_key=public_key,
)
# Push.
cache.infra.set_node(node)
# Inform.
utils.log(f"Registered {node.label}")
def create_network_id() -> types.infra.NetworkIdentifier:
return factory.create_network_id("lrt1")
