async def make_p2pd_pair_unix(
daemon_executable: str,
enable_control: bool,
enable_connmgr: bool,
enable_dht: bool,
enable_pubsub: bool,
) -> AsyncIterator[DaemonTuple]:
name = str(uuid.uuid4())[:8]
control_maddr = Multiaddr(f"/unix/tmp/test_p2pd_control_{name}.sock")
listen_maddr = Multiaddr(f"/unix/tmp/test_p2pd_listen_{name}.sock")
# Remove the existing unix socket files if they are existing
try:
os.unlink(control_maddr.value_for_protocol(protocols.P_UNIX))
except FileNotFoundError:
pass
try:
os.unlink(listen_maddr.value_for_protocol(protocols.P_UNIX))
except FileNotFoundError:
pass
async with make_p2pd_pair(
daemon_executable=daemon_executable,
control_maddr=control_maddr,
listen_maddr=listen_maddr,
enable_control=enable_control,
enable_connmgr=enable_connmgr,
enable_dht=enable_dht,
enable_pubsub=enable_pubsub,
) as pair:
yield pair
async def make_p2pd_pair_ip4(
id_generator, enable_control, enable_connmgr, enable_dht, enable_pubsub):
control_maddr = Multiaddr(f"/ip4/127.0.0.1/tcp/{id_generator()}")
listen_maddr = Multiaddr(f"/ip4/127.0.0.1/tcp/{id_generator()}")
return await _make_p2pd_pair(
control_maddr=control_maddr,
listen_maddr=listen_maddr,
enable_control=enable_control,
enable_connmgr=enable_connmgr,
enable_dht=enable_dht,
enable_pubsub=enable_pubsub,
)
async def make_p2pd_pair_ip4(enable_control, enable_connmgr, enable_dht, enable_pubsub):
control_maddr = Multiaddr(f"/ip4/127.0.0.1/tcp/{find_open_port()}")
listen_maddr = Multiaddr(f"/ip4/127.0.0.1/tcp/{find_open_port()}")
async with _make_p2pd_pair(
control_maddr=control_maddr,
listen_maddr=listen_maddr,
enable_control=enable_control,
enable_connmgr=enable_connmgr,
enable_dht=enable_dht,
enable_pubsub=enable_pubsub,
) as pair:
yield pair
def _initialize(self, proc_args: List[str]) -> None:
proc_args = deepcopy(proc_args)
proc_args.extend(self._make_process_args(
hostAddrs=f'/ip4/0.0.0.0/tcp/{self._host_port},/ip4/0.0.0.0/udp/{self._host_port}/quic',
listen=f'/ip4/127.0.0.1/tcp/{self._daemon_listen_port}'
))
self._child = Popen(args=proc_args, encoding="utf8")
self._alive = True
self._client_listen_port = find_open_port()
self._client = p2pclient.Client(
Multiaddr(f'/ip4/127.0.0.1/tcp/{self._daemon_listen_port}'),
Multiaddr(f'/ip4/127.0.0.1/tcp/{self._client_listen_port}'))
async def test_swarm_multiaddr(is_host_secure):
swarms = await SwarmFactory.create_batch_and_listen(is_host_secure, 3)
def clear():
swarms[0].peerstore.clear_addrs(swarms[1].get_peer_id())
clear()
# No addresses
with pytest.raises(SwarmException):
await swarms[0].dial_peer(swarms[1].get_peer_id())
clear()
# Wrong addresses
swarms[0].peerstore.add_addrs(swarms[1].get_peer_id(),
[Multiaddr("/ip4/0.0.0.0/tcp/9999")], 10000)
with pytest.raises(SwarmException):
await swarms[0].dial_peer(swarms[1].get_peer_id())
clear()
# Multiple wrong addresses
swarms[0].peerstore.add_addrs(
swarms[1].get_peer_id(),
[
Multiaddr("/ip4/0.0.0.0/tcp/9999"),
Multiaddr("/ip4/0.0.0.0/tcp/9998")
],
10000,
)
with pytest.raises(SwarmException):
await swarms[0].dial_peer(swarms[1].get_peer_id())
# Test one address
addrs = tuple(addr for transport in swarms[1].listeners.values()
for addr in transport.get_addrs())
swarms[0].peerstore.add_addrs(swarms[1].get_peer_id(), addrs[:1], 10000)
await swarms[0].dial_peer(swarms[1].get_peer_id())
# Test multiple addresses
addrs = tuple(addr for transport in swarms[1].listeners.values()
for addr in transport.get_addrs())
swarms[0].peerstore.add_addrs(swarms[1].get_peer_id(), addrs + addrs,
10000)
await swarms[0].dial_peer(swarms[1].get_peer_id())
for swarm in swarms:
await swarm.close()
def from_parser_args(cls, args: argparse.Namespace,
trinity_config: TrinityConfig) -> 'BaseAppConfig':
"""
Initialize from the namespace object produced by
an ``argparse.ArgumentParser`` and the :class:`~trinity.config.TrinityConfig`
"""
if args is not None:
# This is quick and dirty way to get bootstrap_nodes
trinity_config.bootstrap_nodes = tuple(
Multiaddr(maddr) for maddr in args.bootstrap_nodes.split(
',')) if args.bootstrap_nodes is not None else tuple()
trinity_config.preferred_nodes = tuple(
Multiaddr(maddr) for maddr in args.preferred_nodes.split(
',')) if args.preferred_nodes is not None else tuple()
return cls(trinity_config)
async def test_tcp_dial(nursery):
transport = TCP()
raw_conn_other_side = None
event = trio.Event()
async def handler(tcp_stream):
nonlocal raw_conn_other_side
raw_conn_other_side = RawConnection(tcp_stream, False)
event.set()
await trio.sleep_forever()
# Test: `OpenConnectionError` is raised when trying to dial to a port which
# no one is not listening to.
with pytest.raises(OpenConnectionError):
await transport.dial(Multiaddr("/ip4/127.0.0.1/tcp/1"))
listener = transport.create_listener(handler)
await listener.listen(LISTEN_MADDR, nursery)
addrs = listener.get_addrs()
assert len(addrs) == 1
listen_addr = addrs[0]
raw_conn = await transport.dial(listen_addr)
await event.wait()
data = b"123"
await raw_conn_other_side.write(data)
assert (await raw_conn.read(len(data))) == data
def _factory(seed, block_pool):
key_pair = node_key_pair(seed)
peer_id = node_peer_id(key_pair)
listen_maddr = Multiaddr(
f"/ip4/127.0.0.1/tcp/13{ord(seed[:1]) % 1000}/p2p/{peer_id}"
)
def _block_by_slot(slot):
for block in block_pool:
if block.slot == slot:
return block
return None
def _block_by_root(root):
for block in block_pool:
if block.message.hash_tree_root == root:
return block
return None
host = Host(
key_pair,
peer_id,
_null_peer_updates,
lambda: Status.create(),
lambda _epoch: genesis_block.hash_tree_root,
_block_by_slot,
_block_by_root,
lambda: MetaData.create(seq_number=SeqNumber(ord(seed[:1]))),
lambda: ForkDigest(b"\x00\x00\x00\x00"),
eth2_config,
)
return host, listen_maddr
def main():
(opts, args) = parse_opts()
maddr = Multiaddr('/ip4/{}/tcp/{}/http'.format(opts.host, opts.port))
ip = IpfsPinner(maddr)
# by default use STDIN
hashes_input = sys.stdin
if opts.input:
with open(opts.input) as f:
hashes_input = f.readlines()
hashes = [rhash.rstrip() for rhash in hashes_input]
states_counter = []
for chash in hashes:
state, statuses = ip.is_pinned(chash)
print('{} - STATUS: {}'.format(chash, statuses))
if opts.action == 'pin' and state != 'pinned':
ip.pin(chash)
state = 'pinning'
print('{} - PINNING'.format(chash))
elif opts.action == 'unpin' and state in [
'pinned', 'pinning', 'pin_queue'
]:
ip.unpin(chash)
state = 'unpinning'
print('{} - UNPINNING'.format(chash))
states_counter.append(state)
print('States: {}'.format(dict(Counter(states_counter))))
def from_pb(cls, pb_msg: p2pd_pb2.StreamInfo) -> 'StreamInfo':
stream_info = cls(
peer_id=PeerID(pb_msg.peer),
addr=Multiaddr(binascii.hexlify(pb_msg.addr)),
proto=pb_msg.proto,
)
return stream_info
def __init__(self,
daemon_connector: DaemonConnector,
listen_maddr: Multiaddr = None) -> None:
if listen_maddr is None:
listen_maddr = Multiaddr(config.listen_maddr_str)
self.listen_maddr = listen_maddr
self.daemon_connector = daemon_connector
self.handlers = {}
def connect(self, peer):
req = Request()
req.type = Request.CONNECT
req.connect.peer = bitcoin.base58.decode(peer['id'])
req.connect.addrs.extend(
[Multiaddr(addr).to_bytes() for addr in peer['addrs']])
req.connect.timeout = 100
return self.__send_request(req, Response)
def identify(self):
req = Request()
req.type = Request.IDENTIFY
resp = self.__send_request(req, Response)
return {
'id': bitcoin.base58.encode(resp.identify.id),
'addrs':
[str(Multiaddr(addr)) for addr in resp.identify.addrs[1:]]
}
async def make_p2pd_pair_ip4(
daemon_executable: str,
enable_control: bool,
enable_connmgr: bool,
enable_dht: bool,
enable_pubsub: bool,
) -> AsyncIterator[DaemonTuple]:
control_maddr = Multiaddr(f"/ip4/127.0.0.1/tcp/{get_unused_tcp_port()}")
listen_maddr = Multiaddr(f"/ip4/127.0.0.1/tcp/{get_unused_tcp_port()}")
async with make_p2pd_pair(
daemon_executable=daemon_executable,
control_maddr=control_maddr,
listen_maddr=listen_maddr,
enable_control=enable_control,
enable_connmgr=enable_connmgr,
enable_dht=enable_dht,
enable_pubsub=enable_pubsub,
) as pair:
yield pair
async def replicate(cls, daemon_listen_port: int, host_port: int):
"""
Connect to existing p2p daemon
:param daemon_listen_port: port for connection daemon and client binding
:param host_port: port for p2p network
:return: new wrapper for existing p2p daemon
"""
self = cls()
# There is no child under control
# Use external already running p2pd
self._child = None
self._alive = True
self._assign_daemon_ports(host_port, daemon_listen_port)
self._client_listen_port = find_open_port()
self._client = p2pclient.Client(
Multiaddr(f'/ip4/127.0.0.1/tcp/{self._daemon_listen_port}'),
Multiaddr(f'/ip4/127.0.0.1/tcp/{self._client_listen_port}'))
await self._wait_for_client()
return self
def create_kad_peerinfo(raw_node_id=None, sender_ip=None, sender_port=None):
node_id = ID(raw_node_id) if raw_node_id else ID(
digest(random.getrandbits(255)))
peer_data = None
if sender_ip and sender_port:
peer_data = PeerData() #pylint: disable=no-value-for-parameter
addr = [Multiaddr("/"+ P_IP +"/" + str(sender_ip) + "/"\
+ P_UDP + "/" + str(sender_port))]
peer_data.add_addrs(addr)
return KadPeerInfo(node_id, peer_data)
async def test_client_connect_failure(p2pcs):
peer_id_1, maddrs_1 = await p2pcs[1].identify()
await p2pcs[0].identify()
# test case: `peer_id` mismatches
with pytest.raises(ControlFailure):
await p2pcs[0].connect(PEER_ID_RANDOM, maddrs_1)
# test case: empty maddrs
with pytest.raises(ControlFailure):
await p2pcs[0].connect(peer_id_1, [])
# test case: wrong maddrs
with pytest.raises(ControlFailure):
await p2pcs[0].connect(peer_id_1, [Multiaddr("/ip4/127.0.0.1/udp/0")])
def _get_peer_info(node: TDaemonOrHost) -> PeerInfo:
peer_info: PeerInfo
if isinstance(node, Daemon):
peer_info = node.peer_info
else: # isinstance(node, IHost)
peer_id = node.get_id()
maddrs = [
node.get_addrs()[0].decapsulate(
Multiaddr(f"/p2p/{peer_id.to_string()}"))
]
peer_info = PeerInfo(peer_id, maddrs)
return peer_info
async def make_p2pd(
daemon_control_port: int,
client_callback_port: int,
security_protocol: TProtocol,
is_pubsub_enabled: bool = True,
is_gossipsub: bool = True,
is_pubsub_signing: bool = False,
is_pubsub_signing_strict: bool = False,
) -> AsyncIterator[Daemon]:
control_maddr = Multiaddr(f"/ip4/{LOCALHOST_IP}/tcp/{daemon_control_port}")
p2pd_proc = P2PDProcess(
control_maddr,
security_protocol,
is_pubsub_enabled,
is_gossipsub,
is_pubsub_signing,
is_pubsub_signing_strict,
)
await p2pd_proc.start()
client_callback_maddr = Multiaddr(
f"/ip4/{LOCALHOST_IP}/tcp/{client_callback_port}")
p2pc = Client(control_maddr, client_callback_maddr)
async with p2pc.listen():
peer_id, maddrs = await p2pc.identify()
listen_maddr: Multiaddr = None
for maddr in maddrs:
try:
ip = maddr.value_for_protocol(multiaddr.protocols.P_IP4)
# NOTE: Check if this `maddr` uses `tcp`.
maddr.value_for_protocol(multiaddr.protocols.P_TCP)
except multiaddr.exceptions.ProtocolLookupError:
continue
if ip == LOCALHOST_IP:
listen_maddr = maddr
break
assert listen_maddr is not None, "no loopback maddr is found"
peer_info = info_from_p2p_addr(
listen_maddr.encapsulate(Multiaddr(f"/p2p/{peer_id.to_string()}")))
yield Daemon(p2pd_proc, p2pc, peer_info)
def create_kad_peerinfo(node_id_bytes=None, sender_ip=None, sender_port=None):
node_id = (ID(node_id_bytes) if node_id_bytes else ID(
digest(random.getrandbits(255))))
addrs: List[Multiaddr]
if sender_ip and sender_port:
addrs = [
Multiaddr("/" + P_IP + "/" + str(sender_ip) + "/" + P_UDP + "/" +
str(sender_port))
]
else:
addrs = []
return KadPeerInfo(node_id, addrs)
async def make_p2pd_pair_unix(
id_generator, enable_control, enable_connmgr, enable_dht, enable_pubsub):
socket_id = id_generator()
control_maddr = Multiaddr(f"/unix/tmp/test_p2pd_control_{socket_id}.sock")
listen_maddr = Multiaddr(f"/unix/tmp/test_p2pd_listen_{socket_id}.sock")
# remove the existing unix socket files if they are existing
try:
os.unlink(control_maddr.value_for_protocol(protocols.P_UNIX))
except FileNotFoundError:
pass
try:
os.unlink(listen_maddr.value_for_protocol(protocols.P_UNIX))
except FileNotFoundError:
pass
return await _make_p2pd_pair(
control_maddr=control_maddr,
listen_maddr=listen_maddr,
enable_control=enable_control,
enable_connmgr=enable_connmgr,
enable_dht=enable_dht,
enable_pubsub=enable_pubsub,
)
async def test_control_client_connect_failure(peer_id_random, p2pds):
c0, c1 = p2pds[0].control, p2pds[1].control
peer_id_1, maddrs_1 = await c1.identify()
await c0.identify()
# test case: `peer_id` mismatches
with pytest.raises(ControlFailure):
await c0.connect(peer_id_random, maddrs_1)
# test case: empty maddrs
with pytest.raises(ControlFailure):
await c0.connect(peer_id_1, [])
# test case: wrong maddrs
with pytest.raises(ControlFailure):
await c0.connect(peer_id_1, [Multiaddr("/ip4/127.0.0.1/udp/0")])
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 peer_info(self) -> None:
if self._peer_info is not None:
return self._peer_info
if not self.event_ready.is_set():
raise Exception("process is not ready yet. failed to parse the peer info")
# Example:
# b"I am /ip4/127.0.0.1/tcp/56171/ipfs/QmU41TRPs34WWqa1brJEojBLYZKrrBcJq9nyNfVvSrbZUJ\n"
m = re.search(br"I am ([\w\./]+)", self.bytes_read)
if m is None:
raise Exception("failed to find the pattern for the listening multiaddr")
maddr_bytes_str_ipfs = m.group(1)
maddr_str = maddr_bytes_str_ipfs.decode().replace("ipfs", "p2p")
maddr = Multiaddr(maddr_str)
self._peer_info = info_from_p2p_addr(maddr)
return self._peer_info
def multiAddrTcp4(maddr):
ipaddr, port = None, 0
try:
multi = Multiaddr(maddr)
except BaseException:
return ipaddr, port
for proto in multi.protocols():
if proto.name == 'ip4':
ipaddr = multi.value_for_protocol(proto.code)
if proto.name == 'tcp':
port = int(multi.value_for_protocol(proto.code))
return ipaddr, port
def multiAddrTcp4(maddr):
ipaddr, port = None, 0
try:
multi = Multiaddr(maddr)
except BaseException as err:
log.debug(f'Invalid multiaddr {maddr}, error: {err}')
return ipaddr, port
for proto in multi.protocols():
if proto.name == 'ip4':
ipaddr = multi.value_for_protocol(proto.code)
if proto.name == 'tcp':
port = int(multi.value_for_protocol(proto.code))
return ipaddr, port
async def identify(self) -> Tuple[ID, Tuple[Multiaddr, ...]]:
stream = await self.daemon_connector.open_connection()
req = p2pd_pb.Request(type=p2pd_pb.Request.IDENTIFY)
await write_pbmsg(stream, req)
resp = p2pd_pb.Response()
await read_pbmsg_safe(stream, resp)
await stream.close()
raise_if_failed(resp)
peer_id_bytes = resp.identify.id
maddrs_bytes = resp.identify.addrs
maddrs = tuple(Multiaddr(maddr_bytes) for maddr_bytes in maddrs_bytes)
peer_id = ID(peer_id_bytes)
return peer_id, maddrs
async def make_echo_proc(
proc_factory, port: int, is_secure: bool, destination: Multiaddr = None
):
args = [f"-l={port}"]
if not is_secure:
args.append("-insecure")
if destination is not None:
args.append(f"-d={str(destination)}")
echo_proc = proc_factory(str(ECHO_PATH), args)
await echo_proc.expect(r"I am ([\w\./]+)" + PEXPECT_NEW_LINE, async_=True)
maddr_str_ipfs = echo_proc.match.group(1)
maddr_str = maddr_str_ipfs.replace("ipfs", "p2p")
maddr = Multiaddr(maddr_str)
go_pinfo = info_from_p2p_addr(maddr)
if destination is None:
await echo_proc.expect("listening for connections", async_=True)
return echo_proc, go_pinfo
def transform(di):
for k, v in di.items():
if isinstance(v, dict):
di[k] = transform(v)
if LINK_SYMBOL in di:
link = di.pop(LINK_SYMBOL)
try:
link = Multiaddr(link).to_bytes()
except ValueError:
pass
if di:
raise KeyError('Links must not have siblings')
return Tag(LINK_TAG, link)
return di
def __init__(self, url: str = "http://localhost", port: int = 5001):
http_protocol, host = url.split('://')
if http_protocol not in ('http', 'https'):
raise ValueError(f"Invalid protocol: {http_protocol}")
if not isinstance(host, str):
ValueError(f"Invalid url: {url}")
try:
# method returns either IPv4Address or IPv6Address (or raises ValueError)
addr = ipaddress.ip_address(host)
ip_protocol = 'ip4' if isinstance(addr,
ipaddress.IPv4Address) else 'ip6'
except ValueError:
ip_protocol = 'dns'
addr = Multiaddr(f"/{ip_protocol}/{host}/tcp/{port}/{http_protocol}")
self._client = ipfshttpclient.connect(addr)
