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)