Implemented Host that includes a routing system. Explicitly separating different Host types as in Go implementation

libp2p/host/basic_host.py

@@ -13,9 +13,7 @@ from libp2p.protocol_muxer.exceptions import MultiselectClientError, Multiselect
 from libp2p.protocol_muxer.multiselect import Multiselect
 from libp2p.protocol_muxer.multiselect_client import MultiselectClient
 from libp2p.protocol_muxer.multiselect_communicator import MultiselectCommunicator
-from libp2p.routing.kademlia.kademlia_peer_router import KadmeliaPeerRouter
 from libp2p.typing import StreamHandlerFn, TProtocol
-
 from .host_interface import IHost
 
 # Upon host creation, host takes in options,
@@ -34,16 +32,14 @@ class BasicHost(IHost):
     """
 
     _network: INetwork
-    _router: KadmeliaPeerRouter
     peerstore: IPeerStore
 
     multiselect: Multiselect
     multiselect_client: MultiselectClient
 
-    def __init__(self, network: INetwork, router: KadmeliaPeerRouter = None) -> None:
+    def __init__(self, network: INetwork) -> None:
         self._network = network
         self._network.set_stream_handler(self._swarm_stream_handler)
-        self._router = router
         self.peerstore = self._network.peerstore
         # Protocol muxing
         self.multiselect = Multiselect()
@@ -87,7 +83,7 @@ class BasicHost(IHost):
         return addrs
 
     def set_stream_handler(
-        self, protocol_id: TProtocol, stream_handler: StreamHandlerFn
+            self, protocol_id: TProtocol, stream_handler: StreamHandlerFn
     ) -> None:
         """
         set stream handler for given `protocol_id`
@@ -97,7 +93,7 @@ class BasicHost(IHost):
         self.multiselect.add_handler(protocol_id, stream_handler)
 
     async def new_stream(
-        self, peer_id: ID, protocol_ids: Sequence[TProtocol]
+            self, peer_id: ID, protocol_ids: Sequence[TProtocol]
     ) -> INetStream:
         """
         :param peer_id: peer_id that host is connecting

libp2p/host/routed_host.py

@@ -0,0 +1,36 @@
+from libp2p.host.basic_host import BasicHost
+from libp2p.network.network_interface import INetwork
+from libp2p.peer.peerinfo import PeerInfo
+from libp2p.routing.interfaces import IPeerRouting
+
+
+# RoutedHost is a p2p Host that includes a routing system.
+# This allows the Host to find the addresses for peers when it does not have them.
+class RoutedHost(BasicHost):
+    _router: IPeerRouting
+
+    def __init__(self, network: INetwork, router: IPeerRouting):
+        super().__init__(network)
+        self._router = router
+
+    async def connect(self, peer_info: PeerInfo) -> None:
+        """
+        connect ensures there is a connection between this host and the peer with
+        given `peer_info.peer_id`. See (basic_host).connect for more information.
+
+        RoutedHost's Connect differs in that if the host has no addresses for a
+        given peer, it will use its routing system to try to find some.
+
+        :param peer_info: peer_info of the peer we want to connect to
+        :type peer_info: peer.peerinfo.PeerInfo
+        """
+        # check if we were given some addresses, otherwise, find some with the routing system.
+        if not peer_info.addrs:
+            peer_info.addrs = (await self._router.find_peer(peer_info.peer_id)).addrs
+        self.peerstore.add_addrs(peer_info.peer_id, peer_info.addrs, 10)
+
+        # there is already a connection to this peer
+        if peer_info.peer_id in self._network.connections:
+            return
+
+        await self._network.dial_peer(peer_info.peer_id)