Struct libp2p_request_response::Behaviour

pub struct Behaviour<TCodec>
where
    TCodec: Codec + Clone + Send + 'static,
{ /* private fields */ }

A request/response protocol for some message codec.

Implementations

impl<TCodec> Behaviour<TCodec>

where TCodec: Codec + Default + Clone + Send + 'static,

pub fn new<I>(protocols: I, cfg: Config) -> Self

where I: IntoIterator<Item = (TCodec::Protocol, ProtocolSupport)>,

Creates a new Behaviour for the given protocols and configuration, using Default to construct the codec.

impl<TCodec> Behaviour<TCodec>

where TCodec: Codec + Clone + Send + 'static,

pub fn with_codec<I>(codec: TCodec, protocols: I, cfg: Config) -> Self

where I: IntoIterator<Item = (TCodec::Protocol, ProtocolSupport)>,

Creates a new Behaviour for the given protocols, codec and configuration.

pub fn send_request( &mut self, peer: &PeerId, request: TCodec::Request ) -> OutboundRequestId

Initiates sending a request.

If the targeted peer is currently not connected, a dialing attempt is initiated and the request is sent as soon as a connection is established.

Note: In order for such a dialing attempt to succeed, the RequestResonse protocol must either be embedded in another NetworkBehaviour that provides peer and address discovery, or known addresses of peers must be managed via Behaviour::add_address and Behaviour::remove_address.

pub fn send_response( &mut self, ch: ResponseChannel<TCodec::Response>, rs: TCodec::Response ) -> Result<(), TCodec::Response>

Initiates sending a response to an inbound request.

If the ResponseChannel is already closed due to a timeout or the connection being closed, the response is returned as an Err for further handling. Once the response has been successfully sent on the corresponding connection, Event::ResponseSent is emitted. In all other cases Event::InboundFailure will be or has been emitted.

The provided ResponseChannel is obtained from an inbound Message::Request.

pub fn add_address(&mut self, peer: &PeerId, address: Multiaddr) -> bool

👎Deprecated: Use Swarm::add_peer_address instead.

Adds a known address for a peer that can be used for dialing attempts by the Swarm, i.e. is returned by NetworkBehaviour::handle_pending_outbound_connection.

Addresses added in this way are only removed by remove_address.

Returns true if the address was added, false otherwise (i.e. if the address is already in the list).

pub fn remove_address(&mut self, peer: &PeerId, address: &Multiaddr)

👎Deprecated: Will be removed with the next breaking release and won’t be replaced.

Removes an address of a peer previously added via Behaviour::add_address.

pub fn is_connected(&self, peer: &PeerId) -> bool

Checks whether a peer is currently connected.

pub fn is_pending_outbound( &self, peer: &PeerId, request_id: &OutboundRequestId ) -> bool

Checks whether an outbound request to the peer with the provided PeerId initiated by Behaviour::send_request is still pending, i.e. waiting for a response.

pub fn is_pending_inbound( &self, peer: &PeerId, request_id: &InboundRequestId ) -> bool

Checks whether an inbound request from the peer with the provided PeerId is still pending, i.e. waiting for a response by the local node through Behaviour::send_response.

Trait Implementations

impl<TCodec> NetworkBehaviour for Behaviour<TCodec>

where TCodec: Codec + Send + Clone + 'static,

type ConnectionHandler = Handler<TCodec>

Handler for all the protocols the network behaviour supports.

type ToSwarm = Event<<TCodec as Codec>::Request, <TCodec as Codec>::Response>

Event generated by the NetworkBehaviour and that the swarm will report back.

fn handle_established_inbound_connection( &mut self, connection_id: ConnectionId, peer: PeerId, _: &Multiaddr, _: &Multiaddr ) -> Result<THandler<Self>, ConnectionDenied>

Callback that is invoked for every established inbound connection.

fn handle_pending_outbound_connection( &mut self, _connection_id: ConnectionId, maybe_peer: Option<PeerId>, _addresses: &[Multiaddr], _effective_role: Endpoint ) -> Result<Vec<Multiaddr>, ConnectionDenied>

Callback that is invoked for every outbound connection attempt.

fn handle_established_outbound_connection( &mut self, connection_id: ConnectionId, peer: PeerId, remote_address: &Multiaddr, _: Endpoint ) -> Result<THandler<Self>, ConnectionDenied>

Callback that is invoked for every established outbound connection.

fn on_swarm_event(&mut self, event: FromSwarm<'_>)

Informs the behaviour about an event from the Swarm.

fn on_connection_handler_event( &mut self, peer: PeerId, connection: ConnectionId, event: THandlerOutEvent<Self> )

Informs the behaviour about an event generated by the ConnectionHandler dedicated to the peer identified by peer_id. for the behaviour.

fn poll( &mut self, _: &mut Context<'_> ) -> Poll<ToSwarm<Self::ToSwarm, THandlerInEvent<Self>>>

Polls for things that swarm should do.

fn handle_pending_inbound_connection( &mut self, _connection_id: ConnectionId, _local_addr: &Multiaddr, _remote_addr: &Multiaddr ) -> Result<(), ConnectionDenied>

Callback that is invoked for every new inbound connection.