logo

Trait libp2p::swarm::ConnectionHandler

source · [−]
pub trait ConnectionHandler: 'static + Send {
    type InEvent: 'static + Debug + Send;
    type OutEvent: 'static + Debug + Send;
    type Error: 'static + Error + Debug + Send;
    type InboundProtocol: InboundUpgradeSend;
    type OutboundProtocol: OutboundUpgradeSend;
    type InboundOpenInfo: 'static + Send;
    type OutboundOpenInfo: 'static + Send;
    fn listen_protocol(
        &self
    ) -> SubstreamProtocol<Self::InboundProtocol, Self::InboundOpenInfo>;
    fn inject_fully_negotiated_inbound(
        &mut self, 
        protocol: <Self::InboundProtocol as InboundUpgradeSend>::Output, 
        info: Self::InboundOpenInfo
    );
    fn inject_fully_negotiated_outbound(
        &mut self, 
        protocol: <Self::OutboundProtocol as OutboundUpgradeSend>::Output, 
        info: Self::OutboundOpenInfo
    );
    fn inject_event(&mut self, event: Self::InEvent);
    fn inject_dial_upgrade_error(
        &mut self, 
        info: Self::OutboundOpenInfo, 
        error: ConnectionHandlerUpgrErr<<Self::OutboundProtocol as OutboundUpgradeSend>::Error>
    );
    fn connection_keep_alive(&self) -> KeepAlive;
    fn poll(
        &mut self, 
        cx: &mut Context<'_>
    ) -> Poll<ConnectionHandlerEvent<Self::OutboundProtocol, Self::OutboundOpenInfo, Self::OutEvent, Self::Error>>;

    fn inject_address_change(&mut self, _new_address: &Multiaddr) { ... }
    fn inject_listen_upgrade_error(
        &mut self, 
        Self::InboundOpenInfo, 
        ConnectionHandlerUpgrErr<<Self::InboundProtocol as InboundUpgradeSend>::Error>
    ) { ... }
    fn map_in_event<TNewIn, TMap>(
        self, 
        map: TMap
    ) -> MapInEvent<Self, TNewIn, TMap>
    where
        TMap: Fn(&TNewIn) -> Option<&Self::InEvent>,
    { ... }
    fn map_out_event<TMap, TNewOut>(self, map: TMap) -> MapOutEvent<Self, TMap>
    where
        TMap: FnMut(Self::OutEvent) -> TNewOut,
    { ... }
    fn select<TProto2>(
        self, 
        other: TProto2
    ) -> ConnectionHandlerSelect<Self, TProto2> { ... }
}
Expand description

A handler for a set of protocols used on a connection with a remote.

This trait should be implemented for a type that maintains the state for the execution of a specific protocol with a remote.

Handling a protocol

Communication with a remote over a set of protocols is initiated in one of two ways:

  1. Dialing by initiating a new outbound substream. In order to do so, ConnectionHandler::poll() must return an ConnectionHandlerEvent::OutboundSubstreamRequest, providing an instance of libp2p_core::upgrade::OutboundUpgrade that is used to negotiate the protocol(s). Upon success, ConnectionHandler::inject_fully_negotiated_outbound is called with the final output of the upgrade.

  2. Listening by accepting a new inbound substream. When a new inbound substream is created on a connection, ConnectionHandler::listen_protocol is called to obtain an instance of libp2p_core::upgrade::InboundUpgrade that is used to negotiate the protocol(s). Upon success, ConnectionHandler::inject_fully_negotiated_inbound is called with the final output of the upgrade.

Connection Keep-Alive

A ConnectionHandler can influence the lifetime of the underlying connection through ConnectionHandler::connection_keep_alive. That is, the protocol implemented by the handler can include conditions for terminating the connection. The lifetime of successfully negotiated substreams is fully controlled by the handler.

Implementors of this trait should keep in mind that the connection can be closed at any time. When a connection is closed gracefully, the substreams used by the handler may still continue reading data until the remote closes its side of the connection.

Associated Types

Custom event that can be received from the outside.

Custom event that can be produced by the handler and that will be returned to the outside.

The type of errors returned by ConnectionHandler::poll.

The inbound upgrade for the protocol(s) used by the handler.

The outbound upgrade for the protocol(s) used by the handler.

The type of additional information returned from listen_protocol.

The type of additional information passed to an OutboundSubstreamRequest.

Required methods

The InboundUpgrade to apply on inbound substreams to negotiate the desired protocols.

Note: The returned InboundUpgrade should always accept all the generally supported protocols, even if in a specific context a particular one is not supported, (eg. when only allowing one substream at a time for a protocol). This allows a remote to put the list of supported protocols in a cache.

Injects the output of a successful upgrade on a new inbound substream.

Injects the output of a successful upgrade on a new outbound substream.

The second argument is the information that was previously passed to ConnectionHandlerEvent::OutboundSubstreamRequest.

Injects an event coming from the outside in the handler.

Indicates to the handler that upgrading an outbound substream to the given protocol has failed.

Returns until when the connection should be kept alive.

This method is called by the Swarm after each invocation of ConnectionHandler::poll to determine if the connection and the associated ConnectionHandlers should be kept alive as far as this handler is concerned and if so, for how long.

Returning KeepAlive::No indicates that the connection should be closed and this handler destroyed immediately.

Returning KeepAlive::Until indicates that the connection may be closed and this handler destroyed after the specified Instant.

Returning KeepAlive::Yes indicates that the connection should be kept alive until the next call to this method.

Note: The connection is always closed and the handler destroyed when ConnectionHandler::poll returns an error. Furthermore, the connection may be closed for reasons outside of the control of the handler.

Should behave like Stream::poll().

Provided methods

Notifies the handler of a change in the address of the remote.

Indicates to the handler that upgrading an inbound substream to the given protocol has failed.

Adds a closure that turns the input event into something else.

Adds a closure that turns the output event into something else.

Creates a new ConnectionHandler that selects either this handler or other by delegating methods calls appropriately.

Note: The largest KeepAlive returned by the two handlers takes precedence, i.e. is returned from ConnectionHandler::connection_keep_alive by the returned handler.

Implementations on Foreign Types

Implementation of a ConnectionHandler that represents either of two ConnectionHandler implementations.

Implementors