Struct Connection 

pub(super) struct Connection {
    streams: Receiver<Stream>,
    shared: Arc<Shared>,
}

A connection a client upgraded to SPDY/3.1.

Fields

streams: Receiver<Stream>

shared: Arc<Shared>

Implementations

impl Connection

pub(super) fn serve<T, F>( io: T, idle_timeout: Option<Duration>, ping_interval: Option<Duration>, accept: F, ) -> Self

where T: AsyncRead + AsyncWrite + Send + 'static, F: Fn(&Headers) -> Result<()> + Send + 'static,

Serve SPDY on the connection. The client opens streams, accept decides about each by its headers, rejected ones get reset. The connection ends when the client closes it, violates the protocol, a write fails, like of a ping, or when it was idle for the timeout. Nothing waits for the echoes of the pings. Only the frames of the client keep the connection active, except for these echoes, and the data of the server, not its control frames, see Self::is_activity.

pub(super) async fn accept(&mut self) -> Option<Stream>

The next stream the client opened, None once the connection ended.

pub(super) fn activity(&self) -> Activity

When the connection was active the last time, for an idle timeout which its user applies instead of Connection::serve, see there.

pub(super) fn handle(&self) -> ConnectionHandle

A handle to close the connection, while the connection itself still accepts streams.

async fn ping(shared: Arc<Shared>, interval: Duration)

Ping the client until the connection ends. The pings of the server have even IDs, the client echoes them.

fn is_activity(frame: &Frame) -> bool

Whether a frame of the client keeps the connection from being idle, which its answers to the pings of the server do not. Of the frames of the server only data counts, see Self::write.

async fn write<T>( shared: Arc<Shared>, writer: WriteHalf<T>, encoder: Encoder, control_rx: Receiver<Frame>, data_rx: Receiver<QueuedData>, )

where T: AsyncWrite,

Write the queued frames: control frames first, then the resets of streams without queued data, then data. The data frames of a stream keep their order, its FIN goes through the same queue, and a reset of a stream with queued data follows its last frame. A reset follows the SYN_REPLY of its stream, which is queued before the stream exists.

async fn write_buf<W>( writer: &mut W, buf: &[u8], written: &Activity, ) -> Result<()>

where W: AsyncWrite + Unpin,

Write all of buf, written gets touched by every part which went out, so that the end of the connection waits for a client which takes the frames slowly, see ConnectionHandle::written.

fn encode_data( encoder: &mut Encoder, data: &QueuedData, buf: &mut BytesMut, ) -> Result<()>

Encode a data frame, followed by the reset of its stream if it was the last data the stream queued before its reset.

fn reset_frame(stream_id: u32) -> Frame