Struct Keepalive 

struct Keepalive {
    sent: Mutex<Option<Instant>>,
}

One connection’s keepalive: the ping it has out, if any.

A silent read is not evidence of a dead peer until something has been asked of it. A connection can spend longer than the bound in a single write - a 3.5 MB snapshot to a slow client was measured at 31.6 s - and through that stall no beat runs and no ping goes out, so a rule that counted “no frame read” as silence would kill a live client on the first tick after the write. What is tracked here is the one thing the peer was actually asked for: an unanswered ping.

Fields

sent: Mutex<Option<Instant>>

When the outstanding ping was sent, None when none is out. Any inbound frame clears it, because any frame is the peer answering in some form. A lock rather than a cell: Keepalive::ping holds &self across its send, and a cell is not Sync, which would make the connection’s future not Send for the sake of a stamp.

Implementations

impl Keepalive

fn sent(&self) -> Option<Instant>

The outstanding ping’s send time, if one is out.

fn heard(&self)

A frame arrived, so whatever was asked, the peer is answering.

fn beat(&self, now: Instant, dead: Duration) -> Beat

What this beat should do. Asking does not stamp the deadline: a send that queues behind a full buffer reaches the peer late, and a deadline taken before it would have expired before the peer saw it.

async fn ping<S>(&self, sink: &mut S) -> Result<()>

where S: Sink<Message, Error = Error> + Unpin + Send,

Send the ping and start its deadline, in that order.

The stamp is taken here, only once the send answers, so no caller can stamp it early: a ping still held in a full buffer owes nothing until it reaches the peer. The send is a Sink rather than a closure so a test can hold it and watch the state at each side of the await.

Trait Implementations

impl Debug for Keepalive

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

Formats the value using the given formatter.

impl Default for Keepalive

fn default() -> Self

Returns the “default value” for a type.