def test_multiaddr_from_string(): """Test multiaddress from string""" maddr_str = "/dns4/" + HOST + "/tcp/" + str(PORT) + "/p2p/" maddr = MultiAddr.from_string(maddr_str + PEER_ID) assert maddr.host == HOST and maddr.port == PORT and maddr.peer_id == PEER_ID with pytest.raises(ValueError): MultiAddr.from_string("") with pytest.raises(ValueError): MultiAddr.from_string(maddr_str + "wrong-peer-id")
def get_libp2p_node_multiaddrs(self) -> Sequence[MultiAddr]: """ Get the node's multiaddresses. :return: a list of multiaddresses """ LIST_START = "MULTIADDRS_LIST_START" LIST_END = "MULTIADDRS_LIST_END" multiaddrs = [] # type: List[MultiAddr] lines = [] with open(self.log_file, "r") as f: lines = f.readlines() found = False for line in lines: if LIST_START in line: found = True multiaddrs = [] continue if found: elem = line.strip() if elem != LIST_END and len(elem) != 0: multiaddrs.append(MultiAddr.from_string(elem)) else: found = False return multiaddrs
def _try_get_peerid(crypto: Crypto) -> str: """Try to get the peer id.""" try: peer_id = MultiAddr("", 0, crypto.public_key).peer_id return peer_id except Exception as e: raise ClickException(str(e))
def test_multiaddr_consistency(): """Test multiaddress consistency.""" key = make_crypto(DEFAULT_LEDGER) maddr1 = MultiAddr(HOST, PORT, key.public_key) tmpdir = tempfile.mkdtemp() key_file = tmpdir + "/key" with open(key_file, "wb+") as k: key.dump(k) key2 = make_crypto(DEFAULT_LEDGER, private_key_path=key_file) maddr2 = MultiAddr(HOST, PORT, key2.public_key) rmtree(tmpdir) assert str(maddr1) == str(maddr2) assert maddr1.public_key == maddr2.public_key assert maddr1.peer_id == maddr2.peer_id
def _try_get_connection_multiaddress( click_context, crypto: Crypto, connection_id: PublicId, host_field: Optional[str], port_field: Optional[str], uri_field: str, ) -> str: """ Try to get the connection multiaddress. The host and the port options have the precedence over the uri option. :param click_context: the click context object. :param crypto: the crypto. :param connection_id: the connection id. :param host_field: the host field. :param port_field: the port field. :param uri_field: the uri field. :return: the multiaddress. """ ctx = cast(Context, click_context.obj) if connection_id not in ctx.agent_config.connections: raise ValueError(f"Cannot find connection with the public id {connection_id}.") package_path = Path( get_package_path_unified(ctx.cwd, ctx.agent_config, CONNECTION, connection_id) ) connection_config = cast( ConnectionConfig, load_item_config(CONNECTION, package_path) ) host, port = _read_host_and_port_from_config( connection_config, uri_field, host_field, port_field ) try: multiaddr = MultiAddr(host, port, crypto.public_key) return multiaddr.format() except Exception as e: raise ClickException(f"An error occurred while creating the multiaddress: {e}")
def test_multiaddr_correctness(): """Test multiaddress correctness.""" tmpdir = tempfile.mkdtemp() key_file = tmpdir + "/key" with open(key_file, "w+") as k: k.write(PRIV_KEY) key = make_crypto(DEFAULT_LEDGER, private_key_path=key_file) maddr = MultiAddr(HOST, PORT, key.public_key) rmtree(tmpdir) assert maddr._peerid == PEER_ID
def __init__(self, **kwargs: Any) -> None: """Initialize a p2p libp2p connection.""" super().__init__(**kwargs) ledger_id = self.configuration.config.get("ledger_id", DEFAULT_LEDGER) if ledger_id not in SUPPORTED_LEDGER_IDS: raise ValueError( # pragma: nocover "Ledger id '{}' is not supported. Supported ids: '{}'".format( ledger_id, SUPPORTED_LEDGER_IDS)) libp2p_local_uri: Optional[str] = self.configuration.config.get( "local_uri") libp2p_public_uri: Optional[str] = self.configuration.config.get( "public_uri") libp2p_delegate_uri: Optional[str] = self.configuration.config.get( "delegate_uri") libp2p_monitoring_uri: Optional[str] = self.configuration.config.get( "monitoring_uri") libp2p_entry_peers = self.configuration.config.get("entry_peers") if libp2p_entry_peers is None: libp2p_entry_peers = [] libp2p_entry_peers = list(cast(List, libp2p_entry_peers)) log_file: Optional[str] = self.configuration.config.get("log_file") env_file: Optional[str] = self.configuration.config.get("env_file") peer_registration_delay: Optional[str] = self.configuration.config.get( "peer_registration_delay") records_storage_path: Optional[str] = self.configuration.config.get( "storage_path") node_connection_timeout: Optional[ float] = self.configuration.config.get("node_connection_timeout") if (self.has_crypto_store and self.crypto_store.crypto_objects.get( ledger_id, None) is not None): # pragma: no cover key = self.crypto_store.crypto_objects[ledger_id] else: raise ValueError( f"Couldn't find connection key for {str(ledger_id)} in connections keys. " "Please ensure agent private key is added with `aea add-key`.") uri = None if libp2p_local_uri is not None: uri = Uri(libp2p_local_uri) public_uri = None if libp2p_public_uri is not None: public_uri = Uri(libp2p_public_uri) delegate_uri = None if libp2p_delegate_uri is not None: delegate_uri = Uri(libp2p_delegate_uri) monitoring_uri = None if libp2p_monitoring_uri is not None: monitoring_uri = Uri(libp2p_monitoring_uri) # pragma: nocover entry_peers = [ MultiAddr.from_string(str(maddr)) for maddr in libp2p_entry_peers ] delay = None if peer_registration_delay is not None: try: delay = float(peer_registration_delay) except ValueError: raise ValueError( f"peer_registration_delay {peer_registration_delay} must be a float number in seconds" ) if public_uri is None: # node will be run as a ClientDHT # requires entry peers to use as relay if entry_peers is None or len(entry_peers) == 0: raise ValueError( # pragma: no cover "At least one Entry Peer should be provided when node is run in relayed mode" ) if delegate_uri is not None: # pragma: no cover self.logger.warning( "Ignoring Delegate Uri configuration as node is run in relayed mode" ) else: # node will be run as a full NodeDHT if uri is None: raise ValueError( # pragma: no cover "Local Uri must be set when Public Uri is provided. " "Hint: they are the same for local host/network deployment" ) # check if node's public host and entry peers hosts are either # both private or both public if not _ip_all_private_or_all_public( [public_uri.host] + [maddr.host for maddr in entry_peers]): raise ValueError( # pragma: nocover "Node's public ip and entry peers ip addresses are not in the same ip address space (private/public)" ) cert_requests = self.configuration.cert_requests if cert_requests is None or len(cert_requests) != 1: raise ValueError( # pragma: no cover "cert_requests field must be set and contain exactly one entry!" ) cert_request = cert_requests[0] agent_record = AgentRecord.from_cert_request(cert_request, self.address, key.public_key, Path(self.data_dir)) # libp2p local node self.logger.debug("Public key used by libp2p node: {}".format( key.public_key)) module_dir = self._check_node_built() self.node = Libp2pNode( agent_record, key, module_dir, self.data_dir, LIBP2P_NODE_CLARGS, uri, public_uri, delegate_uri, monitoring_uri, entry_peers, log_file, env_file, self.logger, delay, records_storage_path, node_connection_timeout, max_restarts=self.configuration.config.get( "max_node_restarts", self.DEFAULT_MAX_RESTARTS), ) self._in_queue = None # type: Optional[asyncio.Queue] self._receive_from_node_task = None # type: Optional[asyncio.Future]
def __init__(self, **kwargs): """Initialize a p2p libp2p connection.""" self._check_go_installed() # we put it here so below we can access the address super().__init__(**kwargs) ledger_id = self.configuration.config.get("ledger_id", DEFAULT_LEDGER) if ledger_id not in SUPPORTED_LEDGER_IDS: raise ValueError( # pragma: nocover "Ledger id '{}' is not supported. Supported ids: '{}'".format( ledger_id, SUPPORTED_LEDGER_IDS)) libp2p_key_file = self.configuration.config.get( "node_key_file") # Optional[str] libp2p_local_uri = self.configuration.config.get( "local_uri") # Optional[str] libp2p_public_uri = self.configuration.config.get( "public_uri") # Optional[str] libp2p_delegate_uri = self.configuration.config.get( "delegate_uri") # Optional[str] libp2p_monitoring_uri = self.configuration.config.get( "monitoring_uri") # Optional[str] libp2p_entry_peers = self.configuration.config.get("entry_peers") if libp2p_entry_peers is None: libp2p_entry_peers = [] libp2p_entry_peers = list(cast(List, libp2p_entry_peers)) log_file = self.configuration.config.get("log_file") # Optional[str] env_file = self.configuration.config.get("env_file") # Optional[str] if (self.has_crypto_store and self.crypto_store.crypto_objects.get( ledger_id, None) is not None): # pragma: no cover key = self.crypto_store.crypto_objects[ledger_id] elif libp2p_key_file is not None: key = make_crypto(ledger_id, private_key_path=libp2p_key_file) else: key = make_crypto(ledger_id) uri = None if libp2p_local_uri is not None: uri = Uri(libp2p_local_uri) public_uri = None if libp2p_public_uri is not None: public_uri = Uri(libp2p_public_uri) delegate_uri = None if libp2p_delegate_uri is not None: delegate_uri = Uri(libp2p_delegate_uri) monitoring_uri = None if libp2p_monitoring_uri is not None: monitoring_uri = Uri(libp2p_monitoring_uri) # pragma: nocover entry_peers = [ MultiAddr.from_string(str(maddr)) for maddr in libp2p_entry_peers ] if public_uri is None: # node will be run as a ClientDHT # requires entry peers to use as relay if entry_peers is None or len(entry_peers) == 0: raise ValueError( "At least one Entry Peer should be provided when node is run in relayed mode" ) if delegate_uri is not None: # pragma: no cover self.logger.warning( "Ignoring Delegate Uri configuration as node is run in relayed mode" ) else: # node will be run as a full NodeDHT if uri is None: raise ValueError( "Local Uri must be set when Public Uri is provided. " "Hint: they are the same for local host/network deployment" ) # check if node's public host and entry peers hosts are either # both private or both public if not _ip_all_private_or_all_public( [public_uri.host] + [maddr.host for maddr in entry_peers]): raise ValueError( # pragma: nocover "Node's public ip and entry peers ip addresses are not in the same ip address space (private/public)" ) # libp2p local node self.logger.debug("Public key used by libp2p node: {}".format( key.public_key)) temp_dir = tempfile.mkdtemp() self.libp2p_workdir = os.path.join(temp_dir, "libp2p_workdir") shutil.copytree(LIBP2P_NODE_MODULE, self.libp2p_workdir) self.node = Libp2pNode( self.address, key, self.libp2p_workdir, LIBP2P_NODE_CLARGS, uri, public_uri, delegate_uri, monitoring_uri, entry_peers, log_file, env_file, self.logger, ) self._in_queue = None # type: Optional[asyncio.Queue] self._receive_from_node_task = None # type: Optional[asyncio.Future]