def test_transform_cbor_to_dict_with_multiaddr():
addr1 = Multiaddr('/ip4/127.0.0.1/udp/1234')
addr2 = Multiaddr('/ipfs/Qmafmh1Cw3H1bwdYpaaj5AbCW4LkYyUWaM7Nykpn5NZoYL')
src = dumps({
'data': 'hello world',
'size': 11,
'l1': Tag(LINK_TAG, addr1.to_bytes()),
'l2': Tag(LINK_TAG, addr2.to_bytes()),
}, sort_keys=True)
expected = {
'data': 'hello world',
'size': 11,
'l1': {
'/': str(addr1),
},
'l2': {
'/': str(addr2),
}
}
assert unmarshal(src) == expected
def __init__(self, client: Client, listen_maddr: Multiaddr = None) -> None:
if listen_maddr is None:
listen_maddr = Multiaddr(config.listen_maddr_str)
self.listen_maddr = listen_maddr
self.client = client
self.handlers = {}
from multiaddr import Multiaddr
from libp2p import Libp2p
l = Libp2p('/tmp/p2pd.sock')
[i, a] = l.identify()
print("Identity: ", i)
print("Multiaddrs: ", a)
ma = Multiaddr(string_addr='/ip4/104.131.131.82/tcp/4001')
l.connect('QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ', [ma])
def p2p_maddr():
return Multiaddr("/ip4/127.0.0.1/tcp/13000")
def from_protobuf(cls, pb_msg: p2pd_pb2.StreamInfo) -> "StreamInfo":
stream_info = cls(peer_id=PeerID(pb_msg.peer),
addr=Multiaddr(pb_msg.addr),
proto=pb_msg.proto)
return stream_info
def maddr(self) -> Multiaddr:
return Multiaddr(
f"/ip4/127.0.0.1/tcp/{self.port}/p2p/{self.peer_id.to_base58()}")
def listen_maddr_with_peer_id(self) -> Multiaddr:
return self.listen_maddr.encapsulate(Multiaddr(f"/p2p/{self.peer_id.to_base58()}"))
def from_pb(cls, peer_info_pb: p2pd_pb2.PeerInfo) -> PeerInfoLibP2P:
peer_id = ID(peer_info_pb.id)
addrs = [Multiaddr(addr) for addr in peer_info_pb.addrs]
return PeerInfoLibP2P(peer_id, addrs)
def test_client_ctor_default_control_maddr():
c = Client()
assert c.control_maddr == Multiaddr(config.control_maddr_str)
def test_client_ctor_control_maddr(control_maddr_str):
c = Client(Multiaddr(control_maddr_str))
assert c.control_maddr == Multiaddr(control_maddr_str)
def test_parse_conn_protocol_invalid(maddr_str):
maddr = Multiaddr(maddr_str)
with pytest.raises(ValueError):
parse_conn_protocol(maddr)
def test_parse_conn_protocol_valid(maddr_str, expected_proto):
assert parse_conn_protocol(Multiaddr(maddr_str)) == expected_proto
def _derive_port(maddr: Multiaddr, orchestration_profile: str) -> Multiaddr:
offset = ord(orchestration_profile[:1]) - ord("a")
port = int(maddr.value_for_protocol("tcp")) + offset
return Multiaddr.join(f"/ip4/{maddr.value_for_protocol('ip4')}",
f"/tcp/{port}")
def __init__(
self,
local_node_key: PrivateKey,
eth2_config: Eth2Config,
clock: Clock,
chain: BaseBeaconChain,
validator_api_port: int,
client_identifier: str,
p2p_maddr: Multiaddr,
preferred_nodes: Collection[Multiaddr],
bootstrap_nodes: Collection[Multiaddr],
) -> None:
self._local_key_pair = create_new_key_pair(local_node_key.to_bytes())
self._eth2_config = eth2_config
self._clock = clock
self._chain = chain
self._block_pool: Set[SignedBeaconBlock] = set()
self._slashable_block_pool: Set[SignedBeaconBlock] = set()
# FIXME: can we provide `p2p_maddr` as a default listening interface for `_mk_host`?
peer_id = PeerID.from_pubkey(self._local_key_pair.public_key)
if "p2p" in p2p_maddr:
existing_peer_id = p2p_maddr.value_for_protocol("p2p")
existing_p2p_maddr = Multiaddr(f"/p2p/{existing_peer_id}")
self.logger.warning(
"peer identity derived from local key pair %s overriding given identity %s",
peer_id,
existing_peer_id,
)
p2p_maddr = p2p_maddr.decapsulate(existing_p2p_maddr)
self._p2p_maddr = p2p_maddr.encapsulate(Multiaddr(f"/p2p/{peer_id}"))
# TODO: persist metadata and handle updates...
self._metadata_provider = lambda: MetaData.create()
self._peer_updater, self._peer_updates = trio.open_memory_channel[
Tuple[PeerID, Any]](0)
self._host = Host(
self._local_key_pair,
peer_id,
self._accept_peer_updates,
self._get_status,
self._get_finalized_root_by_epoch,
self._get_block_by_slot,
self._get_block_by_root,
self._metadata_provider,
self._get_fork_digest,
self._eth2_config,
)
self._preferred_nodes = preferred_nodes
self._bootstrap_nodes = bootstrap_nodes
self._sync_notifier, self._sync_requests = trio.open_memory_channel[
SyncRequest](0)
self._syncer = _mk_syncer()
api_context = Context(
client_identifier,
eth2_config,
self._syncer,
self._chain,
self._clock,
_mk_block_broadcaster(self),
)
self.validator_api_port = validator_api_port
self._validator_api_server = _mk_validator_api_server(
self.validator_api_port, api_context)
def test_control_client_ctor_listen_maddr(listen_maddr_str):
c = ControlClient(client=Client(),
listen_maddr=Multiaddr(listen_maddr_str))
assert c.listen_maddr == Multiaddr(listen_maddr_str)
def _multiaddr_from_socket(socket: socket) -> Multiaddr:
return Multiaddr("/ip4/%s/tcp/%s" % socket.getsockname())
def test_control_client_ctor_default_listen_maddr():
c = ControlClient(client=Client())
assert c.listen_maddr == Multiaddr(config.listen_maddr_str)
def _multiaddr_from_socket(socket: trio.socket.SocketType) -> Multiaddr:
ip, port = socket.getsockname() # type: ignore
return Multiaddr(f"/ip4/{ip}/tcp/{port}")
def __init__(self, addr:str,port:int):
self.client=Client(Multiaddr(addr))
log("Adresse du client IPFS: " + addr)
def _parse_multiaddrs_from_args(multiaddrs: str) -> Iterable[Multiaddr]:
for multiaddr in multiaddrs.split(","):
yield Multiaddr(multiaddr.strip())
def from_pb(cls, peer_info_pb: p2pd_pb2.PeerInfo) -> 'PeerInfo':
peer_id = PeerID(peer_info_pb.id)
addrs = [
Multiaddr(binascii.hexlify(addr)) for addr in peer_info_pb.addrs
]
return cls(peer_id, addrs)
def __init__(self, control_maddr: Multiaddr = None) -> None:
if control_maddr is None:
control_maddr = Multiaddr(config.control_maddr_str)
self.control_maddr = control_maddr
def _multiaddr_to_bytes(maddr: Multiaddr) -> bytes:
return maddr.to_bytes()
def from_protobuf(cls, peer_info_pb: p2pd_pb2.PeerInfo) -> "PeerInfo":
peer_id = PeerID(peer_info_pb.id)
addrs = [Multiaddr(addr) for addr in peer_info_pb.addrs]
return PeerInfo(peer_id, addrs)
def make_tcp_ip_maddr(ip: str, port: int) -> Multiaddr:
return Multiaddr(f"/ip4/{ip}/tcp/{port}")
def maddr():
return Multiaddr('/unix/123')
def maddr():
return Multiaddr("/unix/123")
