Struct RequestContext 

pub struct RequestContext { /* private fields */ }

Context passed to request handlers.

Provides methods for sending responses back to the parent. All response methods handle serialization and frame building internally.

Thread Safety

RequestContext is Clone and can be safely shared across async tasks. The underlying writer uses a channel-based architecture that eliminates lock contention.

Cancellation

Each context has a CancellationToken that is triggered when the parent sends an ABORT signal. Handlers should check is_cancelled() periodically or use cancelled().await with tokio::select! for immediate response.

Implementations

impl RequestContext

pub fn new(method_id: u16, request_id: u32) -> Self

Create a new request context (for testing without writer).

pub fn with_writer( method_id: u16, request_id: u32, writer: WriterHandle, ) -> Self

Create a new request context with a writer.

pub fn method_id(&self) -> u16

Get the method ID.

pub fn request_id(&self) -> u32

Get the request ID.

pub fn is_cancelled(&self) -> bool

Check if this request has been cancelled.

Handlers should check this periodically during long operations.

Example

for i in 0..1000 {
    if ctx.is_cancelled() {
        tracing::info!("Request cancelled at step {}", i);
        return Ok(());
    }
    do_step(i).await;
}

pub fn cancelled(&self) -> WaitForCancellationFuture<'_>

Wait for cancellation.

Use with tokio::select! to handle cancellation immediately:

Example

tokio::select! {
    _ = ctx.cancelled() => {
        // Request was cancelled, clean up
        return Ok(());
    }
    result = do_work() => {
        ctx.respond(&result).await
    }
}

pub fn cancellation_token(&self) -> CancellationToken

Get the cancellation token for advanced use cases.

Useful when you need to pass the token to child tasks.

Example

let token = ctx.cancellation_token();
let handle = tokio::spawn(async move {
    tokio::select! {
        _ = token.cancelled() => None,
        result = do_work() => Some(result),
    }
});

pub async fn respond<T: Serialize>(&self, payload: &T) -> Result<()>

Send a response with the given payload.

Serializes the payload using MsgPack and sends a response frame.

pub async fn respond_raw(&self, payload: &[u8]) -> Result<()>

Send a response with raw bytes (zero-copy).

pub async fn respond_bytes(&self, payload: Bytes) -> Result<()>

Send a response with pre-allocated Bytes (zero-copy).

pub async fn ack(&self) -> Result<()>

Send an acknowledgment (empty payload).

pub async fn chunk<T: Serialize>(&self, payload: &T) -> Result<()>

Send a stream chunk.

Serializes the payload using MsgPack and sends a stream chunk frame.

pub async fn chunk_raw(&self, payload: &[u8]) -> Result<()>

Send a stream chunk with raw bytes.

pub async fn chunk_bytes(&self, payload: Bytes) -> Result<()>

Send a stream chunk with pre-allocated Bytes (zero-copy).

pub async fn end(&self) -> Result<()>

End a stream.

Sends a stream end frame with empty payload. IMPORTANT: STREAM_END frames always have empty payload!

pub async fn error(&self, message: &str) -> Result<()>

Send an error response.

Serializes the error message and sends an error frame.

Trait Implementations

impl Clone for RequestContext

fn clone(&self) -> RequestContext

Returns a duplicate of the value.

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

Performs copy-assignment from source.