From 11db313b17235fef8f39bf85b61b2b13e74619fa Mon Sep 17 00:00:00 2001 From: Alex Stokes Date: Mon, 28 Oct 2019 18:43:59 +0900 Subject: [PATCH 1/9] A mux can provide the protocols it responds to --- libp2p/protocol_muxer/multiselect_muxer_interface.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/libp2p/protocol_muxer/multiselect_muxer_interface.py b/libp2p/protocol_muxer/multiselect_muxer_interface.py index 66e0392a..935545f6 100644 --- a/libp2p/protocol_muxer/multiselect_muxer_interface.py +++ b/libp2p/protocol_muxer/multiselect_muxer_interface.py @@ -22,6 +22,9 @@ class IMultiselectMuxer(ABC): :param handler: handler function """ + def get_protocols(self) -> Tuple[TProtocol, ...]: + return tuple(self.handlers.keys()) + @abstractmethod async def negotiate( self, communicator: IMultiselectCommunicator From 32c55bcaf23be165acab97a0d77fe3ba97809d69 Mon Sep 17 00:00:00 2001 From: Alex Stokes Date: Mon, 28 Oct 2019 18:44:55 +0900 Subject: [PATCH 2/9] hosts track their public key --- libp2p/__init__.py | 4 ++-- libp2p/host/basic_host.py | 5 +++++ libp2p/host/host_interface.py | 6 ++++++ libp2p/host/routed_host.py | 5 +++-- 4 files changed, 16 insertions(+), 4 deletions(-) diff --git a/libp2p/__init__.py b/libp2p/__init__.py index 88ae3b54..5c738ed7 100644 --- a/libp2p/__init__.py +++ b/libp2p/__init__.py @@ -154,9 +154,9 @@ async def new_node( # TODO routing unimplemented host: IHost # If not explicitly typed, MyPy raises error if disc_opt: - host = RoutedHost(swarm_opt, disc_opt) + host = RoutedHost(key_pair.public_key, swarm_opt, disc_opt) else: - host = BasicHost(swarm_opt) + host = BasicHost(key_pair.public_key, swarm_opt) # Kick off cleanup job asyncio.ensure_future(cleanup_done_tasks()) diff --git a/libp2p/host/basic_host.py b/libp2p/host/basic_host.py index 0a5dae7b..73218d32 100644 --- a/libp2p/host/basic_host.py +++ b/libp2p/host/basic_host.py @@ -46,9 +46,11 @@ class BasicHost(IHost): def __init__( self, + public_key: PublicKey, network: INetwork, default_protocols: "OrderedDict[TProtocol, StreamHandlerFn]" = None, ) -> None: + self._public_key = public_key self._network = network self._network.set_stream_handler(self._swarm_stream_handler) self.peerstore = self._network.peerstore @@ -63,6 +65,9 @@ class BasicHost(IHost): """ return self._network.get_peer_id() + def get_public_key(self) -> PublicKey: + return self._public_key + def get_network(self) -> INetwork: """ :return: network instance of host diff --git a/libp2p/host/host_interface.py b/libp2p/host/host_interface.py index 6a326b97..9e557969 100644 --- a/libp2p/host/host_interface.py +++ b/libp2p/host/host_interface.py @@ -17,6 +17,12 @@ class IHost(ABC): :return: peer_id of host """ + @abstractmethod + def get_public_key(self) -> PublicKey: + """ + :return: the public key belonging to the peer + """ + @abstractmethod def get_network(self) -> INetwork: """ diff --git a/libp2p/host/routed_host.py b/libp2p/host/routed_host.py index 78b6fa54..e253ce1c 100644 --- a/libp2p/host/routed_host.py +++ b/libp2p/host/routed_host.py @@ -1,3 +1,4 @@ +from libp2p.crypto.keys import PublicKey from libp2p.host.basic_host import BasicHost from libp2p.host.exceptions import ConnectionFailure from libp2p.network.network_interface import INetwork @@ -10,8 +11,8 @@ from libp2p.routing.interfaces import IPeerRouting class RoutedHost(BasicHost): _router: IPeerRouting - def __init__(self, network: INetwork, router: IPeerRouting): - super().__init__(network) + def __init__(self, public_key: PublicKey, network: INetwork, router: IPeerRouting): + super().__init__(public_key, network) self._router = router async def connect(self, peer_info: PeerInfo) -> None: From e0a94b6092cb31c30677cf3ed2f2fefb8c174d6a Mon Sep 17 00:00:00 2001 From: Alex Stokes Date: Mon, 28 Oct 2019 18:47:10 +0900 Subject: [PATCH 3/9] identify handler reads data on request from the host --- libp2p/identity/identify/protocol.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/libp2p/identity/identify/protocol.py b/libp2p/identity/identify/protocol.py index 75a7ba31..0fc65baf 100644 --- a/libp2p/identity/identify/protocol.py +++ b/libp2p/identity/identify/protocol.py @@ -4,6 +4,7 @@ from typing import Sequence from multiaddr import Multiaddr from libp2p.crypto.keys import PublicKey +from libp2p.host.host_interface import IHost from libp2p.network.stream.net_stream_interface import INetStream from libp2p.typing import StreamHandlerFn, TProtocol @@ -20,13 +21,15 @@ def _multiaddr_to_bytes(maddr: Multiaddr) -> bytes: return maddr.to_bytes() -def identify_handler_for( - public_key: PublicKey, laddrs: Sequence[Multiaddr], protocols: Sequence[TProtocol] -) -> StreamHandlerFn: +def identify_handler_for(host: IHost) -> StreamHandlerFn: async def handle_identify(stream: INetStream) -> None: peer_id = stream.muxed_conn.peer_id logger.debug("received a request for %s from %s", ID, peer_id) + public_key = host.get_public_key() + laddrs = host.get_addrs() + protocols = host.get_mux().get_protocols() + protobuf = Identify( protocol_version=PROTOCOL_VERSION, agent_version=AGENT_VERSION, From 693a8cf99ae1365b2da45294c2ce4eb30597d21a Mon Sep 17 00:00:00 2001 From: Alex Stokes Date: Mon, 28 Oct 2019 18:48:00 +0900 Subject: [PATCH 4/9] Default protocols are constructed using a reference to the host --- libp2p/host/basic_host.py | 2 +- libp2p/host/defaults.py | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/libp2p/host/basic_host.py b/libp2p/host/basic_host.py index 73218d32..013c62b2 100644 --- a/libp2p/host/basic_host.py +++ b/libp2p/host/basic_host.py @@ -55,7 +55,7 @@ class BasicHost(IHost): self._network.set_stream_handler(self._swarm_stream_handler) self.peerstore = self._network.peerstore # Protocol muxing - default_protocols = default_protocols or get_default_protocols() + default_protocols = default_protocols or get_default_protocols(self) self.multiselect = Multiselect(default_protocols) self.multiselect_client = MultiselectClient() diff --git a/libp2p/host/defaults.py b/libp2p/host/defaults.py index ab5952fc..a311132c 100644 --- a/libp2p/host/defaults.py +++ b/libp2p/host/defaults.py @@ -1,11 +1,11 @@ from collections import OrderedDict from typing import TYPE_CHECKING +from libp2p.host.host_interface import IHost + if TYPE_CHECKING: from libp2p.typing import TProtocol, StreamHandlerFn -DEFAULT_HOST_PROTOCOLS: "OrderedDict[TProtocol, StreamHandlerFn]" = OrderedDict() - -def get_default_protocols() -> "OrderedDict[TProtocol, StreamHandlerFn]": - return DEFAULT_HOST_PROTOCOLS.copy() +def get_default_protocols(host: IHost) -> "OrderedDict[TProtocol, StreamHandlerFn]": + return OrderedDict() From 0ca3e835401c7e9751665d5f523525031d876408 Mon Sep 17 00:00:00 2001 From: Alex Stokes Date: Mon, 28 Oct 2019 19:09:47 +0900 Subject: [PATCH 5/9] lintroll --- libp2p/host/basic_host.py | 1 + libp2p/host/host_interface.py | 1 + libp2p/identity/identify/protocol.py | 4 +--- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/libp2p/host/basic_host.py b/libp2p/host/basic_host.py index 013c62b2..1b10c2cb 100644 --- a/libp2p/host/basic_host.py +++ b/libp2p/host/basic_host.py @@ -3,6 +3,7 @@ from typing import TYPE_CHECKING, List, Sequence import multiaddr +from libp2p.crypto.keys import PublicKey from libp2p.host.defaults import get_default_protocols from libp2p.host.exceptions import StreamFailure from libp2p.network.network_interface import INetwork diff --git a/libp2p/host/host_interface.py b/libp2p/host/host_interface.py index 9e557969..cfba82c8 100644 --- a/libp2p/host/host_interface.py +++ b/libp2p/host/host_interface.py @@ -3,6 +3,7 @@ from typing import Any, List, Sequence import multiaddr +from libp2p.crypto.keys import PublicKey from libp2p.network.network_interface import INetwork from libp2p.network.stream.net_stream_interface import INetStream from libp2p.peer.id import ID diff --git a/libp2p/identity/identify/protocol.py b/libp2p/identity/identify/protocol.py index 0fc65baf..b42e51a9 100644 --- a/libp2p/identity/identify/protocol.py +++ b/libp2p/identity/identify/protocol.py @@ -1,12 +1,10 @@ import logging -from typing import Sequence from multiaddr import Multiaddr -from libp2p.crypto.keys import PublicKey from libp2p.host.host_interface import IHost from libp2p.network.stream.net_stream_interface import INetStream -from libp2p.typing import StreamHandlerFn, TProtocol +from libp2p.typing import StreamHandlerFn from .pb.identify_pb2 import Identify From 3deccac2da11cd5024b01a9a4e65f9fd35efabce Mon Sep 17 00:00:00 2001 From: Alex Stokes Date: Mon, 28 Oct 2019 20:38:43 +0900 Subject: [PATCH 6/9] fix tests --- tests/host/test_basic_host.py | 4 ++-- tests/network/test_notify.py | 3 ++- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/tests/host/test_basic_host.py b/tests/host/test_basic_host.py index 5718b6de..4d22222d 100644 --- a/tests/host/test_basic_host.py +++ b/tests/host/test_basic_host.py @@ -7,8 +7,8 @@ from libp2p.host.defaults import get_default_protocols def test_default_protocols(): key_pair = create_new_key_pair() swarm = initialize_default_swarm(key_pair) - host = BasicHost(swarm) + host = BasicHost(key_pair.public_key, swarm) mux = host.get_mux() handlers = mux.handlers - assert handlers == get_default_protocols() + assert handlers == get_default_protocols(host) diff --git a/tests/network/test_notify.py b/tests/network/test_notify.py index 78e407e9..6c72bb2b 100644 --- a/tests/network/test_notify.py +++ b/tests/network/test_notify.py @@ -14,6 +14,7 @@ import enum import pytest +from libp2p.crypto.rsa import create_new_key_pair from libp2p.network.notifee_interface import INotifee from tests.configs import LISTEN_MADDR from tests.factories import SwarmFactory @@ -56,7 +57,7 @@ class MyNotifee(INotifee): @pytest.mark.asyncio async def test_notify(is_host_secure): - swarms = [SwarmFactory(is_host_secure) for _ in range(2)] + swarms = [SwarmFactory(is_host_secure, create_new_key_pair()) for _ in range(2)] events_0_0 = [] events_1_0 = [] From a07c3b0fb0c45cb379f9feb0fe405a354bcc7a44 Mon Sep 17 00:00:00 2001 From: Alex Stokes Date: Mon, 28 Oct 2019 20:38:50 +0900 Subject: [PATCH 7/9] modify factories to fix tests --- tests/factories.py | 34 ++++++++++++++++++++++------------ tests/network/test_swarm.py | 10 ++++++++-- 2 files changed, 30 insertions(+), 14 deletions(-) diff --git a/tests/factories.py b/tests/factories.py index b4e8be23..b65b918d 100644 --- a/tests/factories.py +++ b/tests/factories.py @@ -37,8 +37,9 @@ def security_transport_factory( return {secio.ID: secio.Transport(key_pair)} -def SwarmFactory(is_secure: bool, muxer_opt: TMuxerOptions = None) -> Swarm: - key_pair = generate_new_rsa_identity() +def SwarmFactory( + is_secure: bool, key_pair: KeyPair, muxer_opt: TMuxerOptions = None +) -> Swarm: sec_opt = security_transport_factory(is_secure, key_pair) return initialize_default_swarm(key_pair, sec_opt=sec_opt, muxer_opt=muxer_opt) @@ -50,15 +51,16 @@ class ListeningSwarmFactory(factory.Factory): @classmethod async def create_and_listen( cls, is_secure: bool, muxer_opt: TMuxerOptions = None - ) -> Swarm: - swarm = SwarmFactory(is_secure, muxer_opt=muxer_opt) + ) -> Tuple[Swarm, KeyPair]: + key_pair = generate_new_rsa_identity() + swarm = SwarmFactory(is_secure, key_pair, muxer_opt=muxer_opt) await swarm.listen(LISTEN_MADDR) - return swarm + return swarm, key_pair @classmethod async def create_batch_and_listen( cls, is_secure: bool, number: int, muxer_opt: TMuxerOptions = None - ) -> Tuple[Swarm, ...]: + ) -> Tuple[Tuple[Swarm, KeyPair], ...]: return await asyncio.gather( *[ cls.create_and_listen(is_secure, muxer_opt=muxer_opt) @@ -74,19 +76,26 @@ class HostFactory(factory.Factory): class Params: is_secure = False - network = factory.LazyAttribute(lambda o: SwarmFactory(o.is_secure)) + network = factory.LazyAttribute(lambda o: SwarmFactory(o.is_secure, o.key_pair)) @classmethod async def create_and_listen(cls, is_secure: bool) -> BasicHost: - swarms = await ListeningSwarmFactory.create_batch_and_listen(is_secure, 1) - return BasicHost(swarms[0]) + swarms_and_keys = await ListeningSwarmFactory.create_batch_and_listen( + is_secure, 1 + ) + swarm, key_pair = swarms_and_keys[0] + return BasicHost(key_pair.public_key, swarm) @classmethod async def create_batch_and_listen( cls, is_secure: bool, number: int ) -> Tuple[BasicHost, ...]: - swarms = await ListeningSwarmFactory.create_batch_and_listen(is_secure, number) - return tuple(BasicHost(swarm) for swarm in range(swarms)) + swarms_and_keys = await ListeningSwarmFactory.create_batch_and_listen( + is_secure, number + ) + return tuple( + BasicHost(key_pair.public_key, swarm) for swarm, key_pair in swarms_and_keys + ) class FloodsubFactory(factory.Factory): @@ -123,9 +132,10 @@ class PubsubFactory(factory.Factory): async def swarm_pair_factory( is_secure: bool, muxer_opt: TMuxerOptions = None ) -> Tuple[Swarm, Swarm]: - swarms = await ListeningSwarmFactory.create_batch_and_listen( + swarms_and_keys = await ListeningSwarmFactory.create_batch_and_listen( is_secure, 2, muxer_opt=muxer_opt ) + swarms = tuple(swarm for swarm, _key_pair in swarms_and_keys) await connect_swarm(swarms[0], swarms[1]) return swarms[0], swarms[1] diff --git a/tests/network/test_swarm.py b/tests/network/test_swarm.py index cf8eadfa..3d63d6b6 100644 --- a/tests/network/test_swarm.py +++ b/tests/network/test_swarm.py @@ -9,7 +9,10 @@ from tests.utils import connect_swarm @pytest.mark.asyncio async def test_swarm_dial_peer(is_host_secure): - swarms = await ListeningSwarmFactory.create_batch_and_listen(is_host_secure, 3) + swarms_and_keys = await ListeningSwarmFactory.create_batch_and_listen( + is_host_secure, 3 + ) + swarms = tuple(swarm for swarm, _key_pair in swarms_and_keys) # Test: No addr found. with pytest.raises(SwarmException): await swarms[0].dial_peer(swarms[1].get_peer_id()) @@ -41,7 +44,10 @@ async def test_swarm_dial_peer(is_host_secure): @pytest.mark.asyncio async def test_swarm_close_peer(is_host_secure): - swarms = await ListeningSwarmFactory.create_batch_and_listen(is_host_secure, 3) + swarms_and_keys = await ListeningSwarmFactory.create_batch_and_listen( + is_host_secure, 3 + ) + swarms = tuple(swarm for swarm, _key_pair in swarms_and_keys) # 0 <> 1 <> 2 await connect_swarm(swarms[0], swarms[1]) await connect_swarm(swarms[1], swarms[2]) From 9500bdbf55a149a8d100aa5f4529bc159b451fb1 Mon Sep 17 00:00:00 2001 From: Alex Stokes Date: Wed, 6 Nov 2019 11:50:50 -0800 Subject: [PATCH 8/9] Add class attribute for additional property --- libp2p/host/basic_host.py | 1 + 1 file changed, 1 insertion(+) diff --git a/libp2p/host/basic_host.py b/libp2p/host/basic_host.py index 1b10c2cb..d12d6721 100644 --- a/libp2p/host/basic_host.py +++ b/libp2p/host/basic_host.py @@ -39,6 +39,7 @@ class BasicHost(IHost): right after a stream is initialized. """ + _public_key: PublicKey _network: INetwork peerstore: IPeerStore From 10dd9978051f851e82706ba33e09001ac006a896 Mon Sep 17 00:00:00 2001 From: mhchia Date: Fri, 1 Nov 2019 17:34:03 +0800 Subject: [PATCH 9/9] Reorganize factories --- libp2p/__init__.py | 3 -- tests/factories.py | 84 ++++++++++++++++++++---------------- tests/network/test_notify.py | 3 +- tests/network/test_swarm.py | 12 ++---- 4 files changed, 52 insertions(+), 50 deletions(-) diff --git a/libp2p/__init__.py b/libp2p/__init__.py index 5c738ed7..9294502c 100644 --- a/libp2p/__init__.py +++ b/libp2p/__init__.py @@ -77,7 +77,6 @@ def initialize_default_swarm( muxer_opt: TMuxerOptions = None, sec_opt: TSecurityOptions = None, peerstore_opt: IPeerStore = None, - disc_opt: IPeerRouting = None, ) -> Swarm: """ initialize swarm when no swarm is passed in. @@ -87,7 +86,6 @@ def initialize_default_swarm( :param muxer_opt: optional choice of stream muxer :param sec_opt: optional choice of security upgrade :param peerstore_opt: optional peerstore - :param disc_opt: optional discovery :return: return a default swarm instance """ @@ -147,7 +145,6 @@ async def new_node( muxer_opt=muxer_opt, sec_opt=sec_opt, peerstore_opt=peerstore_opt, - disc_opt=disc_opt, ) # TODO enable support for other host type diff --git a/tests/factories.py b/tests/factories.py index b65b918d..d59f2278 100644 --- a/tests/factories.py +++ b/tests/factories.py @@ -3,12 +3,13 @@ from typing import Dict, Tuple import factory -from libp2p import generate_new_rsa_identity, initialize_default_swarm +from libp2p import generate_new_rsa_identity, generate_peer_id_from from libp2p.crypto.keys import KeyPair from libp2p.host.basic_host import BasicHost from libp2p.network.connection.swarm_connection import SwarmConn from libp2p.network.stream.net_stream_interface import INetStream from libp2p.network.swarm import Swarm +from libp2p.peer.peerstore import PeerStore from libp2p.pubsub.floodsub import FloodSub from libp2p.pubsub.gossipsub import GossipSub from libp2p.pubsub.pubsub import Pubsub @@ -17,7 +18,9 @@ from libp2p.security.insecure.transport import PLAINTEXT_PROTOCOL_ID, InsecureTr import libp2p.security.secio.transport as secio from libp2p.stream_muxer.mplex.mplex import MPLEX_PROTOCOL_ID, Mplex from libp2p.stream_muxer.mplex.mplex_stream import MplexStream +from libp2p.transport.tcp.tcp import TCP from libp2p.transport.typing import TMuxerOptions +from libp2p.transport.upgrader import TransportUpgrader from libp2p.typing import TProtocol from tests.configs import LISTEN_MADDR from tests.pubsub.configs import ( @@ -37,33 +40,47 @@ def security_transport_factory( return {secio.ID: secio.Transport(key_pair)} -def SwarmFactory( - is_secure: bool, key_pair: KeyPair, muxer_opt: TMuxerOptions = None -) -> Swarm: - sec_opt = security_transport_factory(is_secure, key_pair) - return initialize_default_swarm(key_pair, sec_opt=sec_opt, muxer_opt=muxer_opt) - - -class ListeningSwarmFactory(factory.Factory): +class SwarmFactory(factory.Factory): class Meta: model = Swarm + class Params: + is_secure = False + key_pair = factory.LazyFunction(generate_new_rsa_identity) + muxer_opt = {MPLEX_PROTOCOL_ID: Mplex} + + peer_id = factory.LazyAttribute(lambda o: generate_peer_id_from(o.key_pair)) + peerstore = factory.LazyFunction(PeerStore) + upgrader = factory.LazyAttribute( + lambda o: TransportUpgrader( + security_transport_factory(o.is_secure, o.key_pair), o.muxer_opt + ) + ) + transport = factory.LazyFunction(TCP) + @classmethod async def create_and_listen( - cls, is_secure: bool, muxer_opt: TMuxerOptions = None - ) -> Tuple[Swarm, KeyPair]: - key_pair = generate_new_rsa_identity() - swarm = SwarmFactory(is_secure, key_pair, muxer_opt=muxer_opt) + cls, is_secure: bool, key_pair: KeyPair = None, muxer_opt: TMuxerOptions = None + ) -> Swarm: + # `factory.Factory.__init__` does *not* prepare a *default value* if we pass + # an argument explicitly with `None`. If an argument is `None`, we don't pass it to + # `factory.Factory.__init__`, in order to let the function initialize it. + optional_kwargs = {} + if key_pair is not None: + optional_kwargs["key_pair"] = key_pair + if muxer_opt is not None: + optional_kwargs["muxer_opt"] = muxer_opt + swarm = cls(is_secure=is_secure, **optional_kwargs) await swarm.listen(LISTEN_MADDR) - return swarm, key_pair + return swarm @classmethod async def create_batch_and_listen( cls, is_secure: bool, number: int, muxer_opt: TMuxerOptions = None - ) -> Tuple[Tuple[Swarm, KeyPair], ...]: + ) -> Tuple[Swarm, ...]: return await asyncio.gather( *[ - cls.create_and_listen(is_secure, muxer_opt=muxer_opt) + cls.create_and_listen(is_secure=is_secure, muxer_opt=muxer_opt) for _ in range(number) ] ) @@ -75,26 +92,27 @@ class HostFactory(factory.Factory): class Params: is_secure = False + key_pair = factory.LazyFunction(generate_new_rsa_identity) - network = factory.LazyAttribute(lambda o: SwarmFactory(o.is_secure, o.key_pair)) - - @classmethod - async def create_and_listen(cls, is_secure: bool) -> BasicHost: - swarms_and_keys = await ListeningSwarmFactory.create_batch_and_listen( - is_secure, 1 - ) - swarm, key_pair = swarms_and_keys[0] - return BasicHost(key_pair.public_key, swarm) + public_key = factory.LazyAttribute(lambda o: o.key_pair.public_key) + network = factory.LazyAttribute( + lambda o: SwarmFactory(is_secure=o.is_secure, key_pair=o.key_pair) + ) @classmethod async def create_batch_and_listen( cls, is_secure: bool, number: int ) -> Tuple[BasicHost, ...]: - swarms_and_keys = await ListeningSwarmFactory.create_batch_and_listen( - is_secure, number + key_pairs = [generate_new_rsa_identity() for _ in range(number)] + swarms = await asyncio.gather( + *[ + SwarmFactory.create_and_listen(is_secure, key_pair) + for key_pair in key_pairs + ] ) return tuple( - BasicHost(key_pair.public_key, swarm) for swarm, key_pair in swarms_and_keys + BasicHost(key_pair.public_key, swarm) + for key_pair, swarm in zip(key_pairs, swarms) ) @@ -132,21 +150,15 @@ class PubsubFactory(factory.Factory): async def swarm_pair_factory( is_secure: bool, muxer_opt: TMuxerOptions = None ) -> Tuple[Swarm, Swarm]: - swarms_and_keys = await ListeningSwarmFactory.create_batch_and_listen( + swarms = await SwarmFactory.create_batch_and_listen( is_secure, 2, muxer_opt=muxer_opt ) - swarms = tuple(swarm for swarm, _key_pair in swarms_and_keys) await connect_swarm(swarms[0], swarms[1]) return swarms[0], swarms[1] async def host_pair_factory(is_secure) -> Tuple[BasicHost, BasicHost]: - hosts = await asyncio.gather( - *[ - HostFactory.create_and_listen(is_secure), - HostFactory.create_and_listen(is_secure), - ] - ) + hosts = await HostFactory.create_batch_and_listen(is_secure, 2) await connect(hosts[0], hosts[1]) return hosts[0], hosts[1] diff --git a/tests/network/test_notify.py b/tests/network/test_notify.py index 6c72bb2b..cc7fcda4 100644 --- a/tests/network/test_notify.py +++ b/tests/network/test_notify.py @@ -14,7 +14,6 @@ import enum import pytest -from libp2p.crypto.rsa import create_new_key_pair from libp2p.network.notifee_interface import INotifee from tests.configs import LISTEN_MADDR from tests.factories import SwarmFactory @@ -57,7 +56,7 @@ class MyNotifee(INotifee): @pytest.mark.asyncio async def test_notify(is_host_secure): - swarms = [SwarmFactory(is_host_secure, create_new_key_pair()) for _ in range(2)] + swarms = [SwarmFactory(is_secure=is_host_secure) for _ in range(2)] events_0_0 = [] events_1_0 = [] diff --git a/tests/network/test_swarm.py b/tests/network/test_swarm.py index 3d63d6b6..68a3c7db 100644 --- a/tests/network/test_swarm.py +++ b/tests/network/test_swarm.py @@ -3,16 +3,13 @@ import asyncio import pytest from libp2p.network.exceptions import SwarmException -from tests.factories import ListeningSwarmFactory +from tests.factories import SwarmFactory from tests.utils import connect_swarm @pytest.mark.asyncio async def test_swarm_dial_peer(is_host_secure): - swarms_and_keys = await ListeningSwarmFactory.create_batch_and_listen( - is_host_secure, 3 - ) - swarms = tuple(swarm for swarm, _key_pair in swarms_and_keys) + swarms = await SwarmFactory.create_batch_and_listen(is_host_secure, 3) # Test: No addr found. with pytest.raises(SwarmException): await swarms[0].dial_peer(swarms[1].get_peer_id()) @@ -44,10 +41,7 @@ async def test_swarm_dial_peer(is_host_secure): @pytest.mark.asyncio async def test_swarm_close_peer(is_host_secure): - swarms_and_keys = await ListeningSwarmFactory.create_batch_and_listen( - is_host_secure, 3 - ) - swarms = tuple(swarm for swarm, _key_pair in swarms_and_keys) + swarms = await SwarmFactory.create_batch_and_listen(is_host_secure, 3) # 0 <> 1 <> 2 await connect_swarm(swarms[0], swarms[1]) await connect_swarm(swarms[1], swarms[2])