Struct KademliaDiscovery 

pub struct KademliaDiscovery {
    table: Arc<RoutingTable>,
    lookup_service: Arc<LookupService>,
    refresh_service: Arc<RefreshService>,
    peer_queue: Arc<AsyncQueue<DiscoveredPeer>>,
    task_group: TaskGroup,
    config: Arc<Config>,
    bloom: BloomRef,
}

Fields

table: Arc<RoutingTable>

Routing table

lookup_service: Arc<LookupService>

Lookup Service

refresh_service: Arc<RefreshService>

Refresh Service

peer_queue: Arc<AsyncQueue<DiscoveredPeer>>

Discovered peers queued for the Node to dial. Producers (connect_loop, manual peer_endpoints) push; the Node’s connect_discovered_peers task drains via recv().

task_group: TaskGroup

Managing spawned tasks.

config: Arc<Config>

Holds the configuration for the P2P network.

bloom: BloomRef

Shared local bloom. Snapshotted on every connect-loop iteration to filter routing-table entries (and stamped on outgoing PeerMsgs via the lookup service).

Implementations

impl KademliaDiscovery

pub fn new( key_pair: &KeyPair, peer_id: &PeerID, config: Arc<Config>, monitor: Arc<Monitor>, bloom: BloomRef, ex: Executor, ) -> Arc<Self>

Creates a new KademliaDiscovery

async fn connect_loop(self: Arc<Self>) -> Result<()>

This method will attempt to find a peer in the routing table and send it as a DiscoveredPeer for the Node to connect to. If the routing table is empty, it will start the seeding process.

async fn start_seeding(&self)

Starts seeding process.

This method randomly selects a peer from the routing table and attempts to connect to that peer for the initial lookup. If the routing table doesn’t have an available entry, it will connect to one of the provided bootstrap endpoints in the Config and initiate the lookup.

Trait Implementations

impl Discovery for KademliaDiscovery

fn start<'async_trait>( self: Arc<Self>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait,

Start the discovery service. Listen endpoints, if needed by the implementation, must be provided at construction time.

fn shutdown<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Shutdown the discovery service.

fn recv<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = DiscoveredPeer> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Await the next discovered peer. The Node calls this in a loop; on shutdown the surrounding task is cancelled.

fn on_event(&self, event: PeerConnectionEvent)

Receive a peer connection event from the Node.

fn find_peers_with(&self, item: &[u8]) -> Vec<DiscoveredPeer>

Return peers in the routing table whose advertised bloom may contain item. Used by application layers (e.g. Swarm) to find candidates for protocol- or swarm-targeted dials. Implementations without a routing table may return an empty vector.