Struct DirectSession 

pub struct DirectSession {
    pub(in net) p2p: Weak<P2p>,
    connector: OnceCell<Connector>,
    retries_tasks: Arc<Mutex<HashMap<Url, Arc<StoppableTask>>>>,
    peer_discovery: Arc<PeerDiscovery>,
    channels_usage: Arc<Mutex<HashMap<u32, u32>>>,
    tasks: Arc<Mutex<HashMap<Url, Weak<ChannelTask>>>>,
}

Defines direct connections session.

Fields

p2p: Weak<P2p>

Weak pointer to parent p2p object

connector: OnceCell<Connector>

Connector to create direct connections

retries_tasks: Arc<Mutex<HashMap<Url, Arc<StoppableTask>>>>

Tasks that are trying to create a direct channel (they retry until they succeed). A task is removed once the channel is successfully created.

peer_discovery: Arc<PeerDiscovery>

Peer discovery task

channels_usage: Arc<Mutex<HashMap<u32, u32>>>

Channel ID -> usage count

tasks: Arc<Mutex<HashMap<Url, Weak<ChannelTask>>>>

Pending channel creation tasks

Implementations

impl DirectSession

pub fn new(p2p: Weak<P2p>) -> DirectSessionPtr

Create a new direct session.

pub(crate) async fn start(self: Arc<Self>)

Start the direct session.

pub async fn stop(&self)

Stops the direct session.

pub fn start_peer_discovery(&self)

Notify the peer discovery task to start it. The direct session’s peer discovery process will not start until this method is called. If there are outbound slots, peer discovery does not start even if this method is called, we let the outbound session take care of it.

pub async fn get_channel(self: Arc<Self>, addr: &Url) -> Result<ChannelPtr>

If there is an existing channel to the same address, this method will return it (even if the channel was not created by the direct session). Otherwise it will create a new channel to addr in the direct session.

pub async fn inc_channel_usage(&self, channel: &ChannelPtr, n: u32)

Increment channel usage

pub async fn get_channel_with_retries( self: Arc<Self>, addr: Url, channel_pub: PublisherPtr<ChannelPtr>, )

Try to create a new channel until it succeeds, then notify channel_pub. If it fails to create a channel, a task will sleep outbound_connect_timeout seconds and try again.

async fn new_channel(self: Arc<Self>, addr: Url) -> Result<ChannelPtr>

pub async fn cleanup_channel(self: Arc<Self>, channel: ChannelPtr) -> bool

Close a direct channel if it’s not used by anything. AsyncDrop would be great here (https://doc.rust-lang.org/std/future/trait.AsyncDrop.html) but it’s still in nightly. For now you must call this method manually once you are done with a direct channel. Returns true if the channel is stopped.

Trait Implementations

impl Session for DirectSession

fn p2p(&self) -> P2pPtr

Returns a pointer to the p2p network interface

fn type_id(&self) -> SessionBitFlag

Return the session bit flag for the session type

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

where Self: 'async_trait,

Reload settings for this session

fn register_channel<'life0, 'life1, 'async_trait>( &'life0 self, channel: ChannelPtr, executor: Arc<Executor<'life1>>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Registers a new channel with the session. Performs a network handshake and starts the channel. If we need to pass Self as an Arc we can do so like this:

fn perform_handshake_protocols<'life0, 'life1, 'async_trait>( &'life0 self, protocol_version: Arc<ProtocolVersion>, channel: ChannelPtr, executor: Arc<Executor<'life1>>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Performs network handshake to initialize channel. Adds the channel to the list of connected channels, and prepares to remove the channel when a stop signal is received.