Struct darkfi::net::session::outbound_session::Slot

struct Slot {
    slot: u32,
    process: StoppableTaskPtr,
    wakeup_self: CondVar,
    session: Weak<OutboundSession>,
    connector: Connector,
    channel_id: AtomicU32,
}

Fields

slot: u32

process: StoppableTaskPtr

wakeup_self: CondVar

session: Weak<OutboundSession>

connector: Connector

channel_id: AtomicU32

Implementations

impl Slot

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

async fn start(self: Arc<Self>)

async fn stop(self: Arc<Self>)

async fn fetch_addrs(&self) -> Option<(Url, u64)>

Address selection algorithm that works as follows: up to gold_count, select from the goldlist. Up to white_count, select from the whitelist. For all other slots, select from the greylist. If none of these preferences are satisfied, do peer discovery.

Selecting from the greylist for some % of the slots is necessary and healthy since we require the network retains some unreliable connections. A network that purely favors uptime over unreliable connections may be vulnerable to sybil by attackers with good uptime.

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

async fn try_connect( &self, addr: Url, last_seen: u64, ) -> Result<(Url, ChannelPtr)>

Start making an outbound connection, using provided Connector. Tries to find a valid address to connect to, otherwise does peer discovery. The peer discovery loops until some peer we can connect to is found. Once connected, registers the channel, removes it from the list of pending channels, and starts sending messages across the channel. In case of any failures, a network error is returned and the main connect loop (parent of this function) will iterate again.

fn notify(&self)

fn session(&self) -> OutboundSessionPtr

fn p2p(&self) -> P2pPtr