Struct Ctx 

pub struct Ctx<'a> { /* private fields */ }

What a Connection callback can do: send, close, pause, set timers, reach other threads.

Implementations

impl Ctx<'_>

pub fn send(&mut self, buf: Vec<u8>)

Queues bytes to send. Output queued in one loop turn goes out together, in order, at the end of the turn. The buffer returns to the loop’s pool once written.

pub fn send_static(&mut self, bytes: &'static [u8])

Queues static bytes to send (a fixed reply costs no copy).

Examples found in repository

examples/loadgen.rs (line 55)

    fn on_message(&mut self, cx: &mut Ctx<'_>, _msg: Message) {
        for _ in 0..self.pipeline {
            cx.send_static(REQUEST);
        }
    }

    fn on_data(&mut self, cx: &mut Ctx<'_>, data: &[u8]) -> usize {
        let mut pos = 0;
        let mut n = 0u64;
        while let Some(len) = response_len(&data[pos..]) {
            pos += len;
            n += 1;
            cx.send_static(REQUEST);
        }
        DONE.with(|c| c.set(c.get() + n));
        pos
    }

examples/raw_http.rs (line 52)

    fn on_data(&mut self, cx: &mut Ctx<'_>, data: &[u8]) -> usize {
        let (n, end) = heads(data);
        for _ in 0..n {
            cx.send_static(RESPONSE);
        }
        SERVED.with(|c| c.set(c.get() + n as u64));
        // `Connection: close` (a connection per request, S5): close once the reply is written,
        // as an HTTP server does.
        if n > 0 && data[..end].windows(17).any(|w| w.eq_ignore_ascii_case(b"connection: close")) {
            cx.close();
        }
        end
    }

pub fn send_buf(&mut self, buf: OutBuf)

Queues an OutBuf.

pub fn buffer(&mut self, min: usize) -> Vec<u8>

An empty buffer from the loop’s pool with room for at least min bytes, to build output in. Hand it to Ctx::send or back with Ctx::recycle.

pub fn recycle(&mut self, buf: Vec<u8>)

Returns a buffer to the loop’s pool.

pub fn queued(&mut self) -> usize

Bytes queued and not yet written.

pub fn pause_reading(&mut self)

Stops calling Connection::on_data and stops reading from the socket (backpressure, for example while a request is processed elsewhere).

pub fn resume_reading(&mut self)

Undoes Ctx::pause_reading. Input that arrived meanwhile is offered to Connection::on_data right after the current callback.

pub fn redeliver(&mut self)

Offers input that is still unconsumed to Connection::on_data again right after the current callback, for a connection that left input unconsumed without pausing (it was busy) and can take it now.

pub fn notify_drain(&mut self)

Asks for Connection::on_drain once the queued output is at or below the low-water mark (right after this callback if it already is).

pub fn close(&mut self)

Closes gracefully: queued output is written first, then the socket is closed. Nothing more is delivered except Connection::on_close.

Examples found in repository

examples/raw_http.rs (line 58)

    fn on_data(&mut self, cx: &mut Ctx<'_>, data: &[u8]) -> usize {
        let (n, end) = heads(data);
        for _ in 0..n {
            cx.send_static(RESPONSE);
        }
        SERVED.with(|c| c.set(c.get() + n as u64));
        // `Connection: close` (a connection per request, S5): close once the reply is written,
        // as an HTTP server does.
        if n > 0 && data[..end].windows(17).any(|w| w.eq_ignore_ascii_case(b"connection: close")) {
            cx.close();
        }
        end
    }

pub fn abort(&mut self)

Closes at once, discarding queued output.

pub fn is_closing(&mut self) -> bool

Whether Ctx::close or Ctx::abort was called.

pub fn set_timer(&mut self, after: Duration, token: u64) -> TimerId

Calls Connection::on_timer with token after after (rounded up to the loop’s timer tick). The timers of a connection are cancelled when it is closed.

pub fn cancel_timer(&mut self, id: TimerId) -> bool

Cancels a timer. Returns whether it was still pending.

pub fn handle(&mut self) -> ConnHandle

A handle for reaching this connection from other threads.

pub fn offload<F>(&mut self, job: F) -> Result<(), Rejected>

where F: FnOnce() -> Message + Send + 'static,

Runs job on the shared offload pool and delivers its result to Connection::on_message. Fails at once when the pool is full or overloaded.

pub fn offload_pool(&mut self) -> &OffloadPool

The offload pool, for callers that manage their own completion.

pub fn now_ns(&mut self) -> u64

The loop’s clock in nanoseconds (read once per loop turn).

pub fn peer_addr(&mut self) -> Result<SocketAddr>

The peer’s address.

pub fn local_addr(&mut self) -> Result<SocketAddr>

The local address.

pub fn socket(&mut self) -> Option<&Socket>

The socket, for options the runtime doesn’t wrap.

pub fn loop_index(&mut self) -> usize

The index of the loop running this connection.

pub fn connection_pressure(&mut self) -> bool

Whether open connections passed three quarters of what the server can hold (its max_connections, and on Linux its file descriptor limit): time to shed connections that hold a slot without doing anything useful (K6). Asked only when a slow request head reaches its deadline, so the descriptor limit is read then (one getrlimit), not kept per loop.

Trait Implementations

impl Debug for Ctx<'_>

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

Formats the value using the given formatter.