def create_cl_network(self):
kp = self.get_key()
config = DockerConfig(
self.docker_client,
node_private_key=kp.private_key,
node_public_key=kp.public_key,
network=self.create_docker_network(),
node_account=kp,
grpc_encryption=self.grpc_encryption,
behind_proxy=True,
)
self.add_bootstrap(config)
self.add_new_node_to_network(
(
lambda kp: DockerConfig(
self.docker_client,
node_private_key=kp.private_key,
node_public_key=kp.public_key,
network=self.create_docker_network(),
node_account=kp,
grpc_encryption=self.grpc_encryption,
behind_proxy=True,
)
)
)
def create_cl_network(self):
kp = self.get_key()
config = DockerConfig(
self.docker_client,
node_private_key=kp.private_key,
node_public_key=kp.public_key,
network=self.create_docker_network(),
node_account=kp,
grpc_encryption=self.grpc_encryption,
command_timeout=30,
)
self.add_bootstrap(config)
# Create accounts.csv of the second node with different bond amounts.
self.add_new_node_to_network(
(
lambda kp: DockerConfig(
self.docker_client,
node_private_key=kp.private_key,
node_account=kp,
grpc_encryption=self.grpc_encryption,
behind_proxy=self.behind_proxy,
bond_amount=lambda i, n: n + 3 * i,
)
)
)
def create_cl_network(
self, node_count: int = 3, network_connections: List[List[int]] = None
) -> None:
"""
Allow creation of a network where all nodes are not connected to node-0's network and therefore each other.
Ex: Star Network
node3
|
node1 -- node0 -- node2
create_cl_network(node_count=4, network_connections=[[0, 1], [0, 2], [0, 3]])
:param node_count: Number of nodes to create.
:param network_connections: A list of lists of node indexes that should be joined.
"""
self.network_names = {}
kp = self.get_key()
config = DockerConfig(
self.docker_client,
node_private_key=kp.private_key,
node_public_key=kp.public_key,
network=self.create_docker_network(),
node_account=kp,
)
self.add_bootstrap(config)
for i in range(1, node_count):
kp = self.get_key()
config = DockerConfig(
self.docker_client,
node_private_key=kp.private_key,
network=self.create_docker_network(),
node_account=kp,
)
self.add_cl_node(config, network_with_bootstrap=False)
for network_members in network_connections:
self.connect(network_members)
for node_number in range(1, node_count):
self.wait_method(
wait_for_approved_block_received_handler_state, node_number
)
# Calculate how many peers should be connected to each node.
# Assumes duplicate network connections are not given, else wait_for_peers will time out.
peer_counts = [0] * node_count
for network in network_connections:
for node_num in network:
peer_counts[node_num] += len(network) - 1
timeout = self.docker_nodes[0].timeout
for node_num, peer_count in enumerate(peer_counts):
if peer_count > 0:
wait_for_peers_count_at_least(
self.docker_nodes[node_num], peer_count, timeout
)
def add_cl_node(
self, config: DockerConfig, network_with_bootstrap: bool = True
) -> None:
with self._lock:
if self.node_count == 0:
raise Exception("Must create bootstrap first")
config.bootstrap_address = self.cl_nodes[0].node.address
if network_with_bootstrap:
config.network = self.cl_nodes[0].node.config.network
self._add_cl_node(config)
def __init__(self, cl_network, config: DockerConfig):
self.cl_network = cl_network
super().__init__(config)
self.graphql = GraphQL(self)
def local_path(p):
return str(
testing_root_path()
/ "resources"
/ "bootstrap_certificate"
/ p.split("/")[-1]
)
self.proxy_server = None
self.proxy_kademlia = None
if config.behind_proxy:
# Set up proxy of incoming connections: this node is server, the other one client.
server_certificate_path = local_path(config.tls_certificate_path())
server_key_path = local_path(config.tls_key_path())
client_certificate_path = server_certificate_path.replace("0", "1")
client_key_path = server_key_path.replace("0", "1")
logging.info(
f"SETUP PROXIES: client_certificate_path {client_certificate_path} client_key_path {client_key_path}"
)
logging.info(
f"SETUP PROXIES: server_certificate_path {server_certificate_path} server_key_path {server_key_path}"
)
node_host = (
os.environ.get("TAG_NAME") and self.container_name or "localhost"
)
self.proxy_server = grpc_proxy.proxy_server(
node_port=self.GRPC_SERVER_PORT + 10000,
node_host=node_host,
proxy_port=self.server_proxy_port,
server_certificate_file=server_certificate_path,
server_key_file=server_key_path,
client_certificate_file=server_certificate_path,
client_key_file=server_key_path,
)
self.proxy_kademlia = grpc_proxy.proxy_kademlia(
node_port=self.KADEMLIA_PORT + 10000,
node_host=node_host,
proxy_port=self.kademlia_proxy_port,
)
self._client = self.DOCKER_CLIENT
self.p_client = PythonClient(self)
self.d_client = DockerClient(self)
self.join_client_network()
def add_bootstrap(self, config: DockerConfig) -> None:
if self.node_count > 0:
raise Exception("There can be only one bootstrap")
config.is_bootstrap = True
self._add_cl_node(config)
self.wait_method(wait_for_node_started, 0)
wait_for_genesis_block(self.docker_nodes[0])
def __init__(self, cl_network, config: DockerConfig):
self.cl_network = cl_network
super().__init__(config)
self.graphql = GraphQL(self)
self.proxy_server = None
self.proxy_kademlia = None
if config.behind_proxy:
# Set up proxy of incoming connections: this node is server, the other one client.
self.server_certificate_path = config.tls_certificate_local_path()
self.server_key_path = config.tls_key_local_path()
self.set_proxy_server()
self.set_kademlia_proxy()
self._client = self.DOCKER_CLIENT
self.p_client = PythonClient(self)
self.d_client = DockerClient(self)
self.join_client_network()
def create_cl_network(self):
kp = self.get_key()
config = DockerConfig(self.docker_client,
node_private_key=kp.private_key,
node_public_key=kp.public_key,
network=self.create_docker_network(),
initial_motes=self.initial_motes,
node_account=kp,
grpc_encryption=self.grpc_encryption,
command_timeout=30)
self.add_bootstrap(config)
def docker_config(self, account):
config = DockerConfig(
self.docker_client,
node_private_key=account.private_key,
node_public_key=account.public_key,
network=self.create_docker_network(),
initial_motes=self.initial_motes,
node_account=account,
grpc_encryption=self.grpc_encryption,
)
return config
def create_cl_network(self, node_count=2):
kp = self.get_key()
config = DockerConfig(
self.docker_client,
node_private_key=kp.private_key,
node_public_key=kp.public_key,
network=self.create_docker_network(),
node_account=kp,
grpc_encryption=self.grpc_encryption,
)
self.add_bootstrap(config)
config = DockerConfig(
self.docker_client,
node_private_key=kp.private_key,
node_public_key=kp.public_key,
network=self.create_docker_network(),
node_account=kp,
grpc_encryption=self.grpc_encryption,
custom_docker_tag="dev",
)
self.add_cl_node(config)
def create_cl_network(self, node_count=10):
kp = self.get_key()
config = DockerConfig(
self.docker_client,
node_private_key=kp.private_key,
node_public_key=kp.public_key,
network=self.create_docker_network(),
node_account=kp,
)
self.add_bootstrap(config)
for _ in range(1, node_count):
kp = self.get_key()
config = DockerConfig(
self.docker_client, node_private_key=kp.private_key, node_account=kp
)
self.add_cl_node(config)
for node_number in range(1, node_count):
self.wait_method(
wait_for_approved_block_received_handler_state, node_number
)
self.wait_for_peers()
def add_new_node_to_network(self, generate_config=None) -> None:
kp = self.get_key()
config = (
generate_config
and generate_config(kp)
or DockerConfig(
self.docker_client,
node_private_key=kp.private_key,
node_account=kp,
grpc_encryption=self.grpc_encryption,
behind_proxy=self.behind_proxy,
)
)
self.add_cl_node(config)
self.wait_method(wait_for_approved_block_received_handler_state, 1)
self.wait_for_peers()
def add_new_node_to_network(
self, generate_config=None, account: Account = None
) -> Account:
if account is None:
account = self.get_key()
if generate_config is not None:
config = generate_config(account)
else:
config = DockerConfig(
self.docker_client,
node_private_key=account.private_key,
node_account=account,
grpc_encryption=self.grpc_encryption,
behind_proxy=self.behind_proxy,
)
self.add_cl_node(config)
self.wait_method(wait_for_approved_block_received_handler_state, 1)
self.wait_for_peers()
return account
def _add_cl_node(self, config: DockerConfig) -> None:
with self._lock:
config.number = self.node_count
cl_node = CasperLabsNode(self, config)
self.cl_nodes.append(cl_node)
