Struct libp2p_ping::protocol::Ping

pub struct Ping;

The Ping protocol upgrade.

The ping protocol sends 32 bytes of random data in configurable intervals over a single outbound substream, expecting to receive the same bytes as a response. At the same time, incoming pings on inbound substreams are answered by sending back the received bytes.

At most a single inbound and outbound substream is kept open at any time. In case of a ping timeout or another error on a substream, the substream is dropped. If a configurable number of consecutive outbound pings fail, the connection is closed.

Successful pings report the round-trip time.

Note: The round-trip time of a ping may be subject to delays induced by the underlying transport, e.g. in the case of TCP there is Nagle’s algorithm, delayed acks and similar configuration options which can affect latencies especially on otherwise low-volume connections.

Trait Implementations

impl Clone for Ping

fn clone(&self) -> Ping

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Ping

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Ping

fn default() -> Ping

Returns the “default value” for a type.

impl InboundUpgrade<Negotiated<SubstreamRef<Arc<StreamMuxerBox>>>> for Ping

type Output = NegotiatedSubstream

Output after the upgrade has been successfully negotiated and the handshake performed.

type Error = Void

Possible error during the handshake.

type Future = Ready<Result<Self::Output, Self::Error>>

Future that performs the handshake with the remote.

fn upgrade_inbound(
    self,
    stream: NegotiatedSubstream,
    _: Self::Info
) -> Self::Future

After we have determined that the remote supports one of the protocols we support, this method is called to start the handshake.

impl OutboundUpgrade<Negotiated<SubstreamRef<Arc<StreamMuxerBox>>>> for Ping

type Output = NegotiatedSubstream

Output after the upgrade has been successfully negotiated and the handshake performed.

type Error = Void

Possible error during the handshake.

type Future = Ready<Result<Self::Output, Self::Error>>

Future that performs the handshake with the remote.

fn upgrade_outbound(
    self,
    stream: NegotiatedSubstream,
    _: Self::Info
) -> Self::Future

After we have determined that the remote supports one of the protocols we support, this method is called to start the handshake.

impl UpgradeInfo for Ping

type Info = &'static [u8]

Opaque type representing a negotiable protocol.

type InfoIter = Once<Self::Info>

Iterator returned by protocol_info.

fn protocol_info(&self) -> Self::InfoIter

Returns the list of protocols that are supported. Used during the negotiation process.

impl Copy for Ping