Struct darkfi::net::session::outbound_session::PeerDiscovery

struct PeerDiscovery {
    process: StoppableTaskPtr,
    wakeup_self: CondVar,
    session: Weak<OutboundSession>,
}

Main PeerDiscovery process that loops through connected peers and sends out a GetAddrs when it is active. If there are no connected peers after two attempts, connect to our seed nodes and perform SeedSyncSession.

Fields

process: StoppableTaskPtr

wakeup_self: CondVar

session: Weak<OutboundSession>

Implementations

impl PeerDiscovery

fn new(session: Weak<OutboundSession>) -> Arc<Self>

Trait Implementations

impl PeerDiscoveryBase for PeerDiscovery

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

where Self: 'async_trait,

Activate peer discovery if not active already. For the first two attempts, this will loop through all connected P2P peers and send out a GetAddrs message to request more peers. Other parts of the P2P stack will then handle the incoming addresses and place them in the hosts list.

On the third attempt, and if we still haven’t made any connections, this function will then call p2p.seed() which triggers a SeedSyncSession that will connect to configured seeds and request peers from them.

This function will also sleep outbound_peer_discovery_attempt_time seconds after broadcasting in order to let the P2P stack receive and work through the addresses it is expecting.

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

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

Blocks execution until we receive a notification from notify(). wakeup_self.wait() resets the condition variable (CondVar) and waits for a call from notify(). Returns true if the function completed instantly (i.e. no wait occured). Returns false otherwise.

fn notify(&self)

Wakeup peer discovery by sending a notification to wakeup_self. Uses the underlying CondVar method notify(). Subsequent calls to this do nothing until wait() is called.

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

where Self: 'async_trait,

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

where Self: 'async_trait,

fn session(&self) -> OutboundSessionPtr

fn p2p(&self) -> P2pPtr