Struct Headers 

pub struct Headers<T>(pub T);

Extractor that parses the delivery headers into a typed contract before the body runs.

Headers<T> parses the header map through the crate-internal typed-headers machinery: T is a flat struct whose fields name headers, with string-encoded values parsed into what each field expects. The handler body only runs when the whole contract parsed; a missing or unparsable header settles the delivery by the subscriber’s on_failure(decode = ..) policy (drop by default) after a WARN naming the subscription and the contract type - a header contract violation is the same class of bad external input as a payload that does not decode, so one policy covers both.

Under the asyncapi feature the #[subscriber] macro also lifts T’s schemars::JsonSchema into the message’s headers schema, so the same declaration feeds the generated document.

Examples

use ruststream::prelude::*;
use serde::Deserialize;

/// The header contract of a chunk: `task_id` and `chunk_no` parse into their fields, and an
/// absent `trace` reads as `None`.
#[derive(Deserialize)]
struct ChunkMeta {
    task_id: u64,
    chunk_no: u32,
    trace: Option<String>,
}

#[derive(Deserialized)]
struct Chunk<'a>(&'a [u8]);

#[subscriber("chunks")]
async fn store(chunk: &Chunk<'_>, Headers(meta): Headers<ChunkMeta>) -> HandlerOutcome {
    let bytes = chunk.0.len();
    tracing::info!(meta.task_id, meta.chunk_no, trace = ?meta.trace, bytes, "stored");
    HandlerOutcome::ack()
}

Tuple Fields

0: T

Trait Implementations

impl<T> Clone for Headers<T>

where T: Clone,

fn clone(&self) -> Headers<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Copy for Headers<T>

where T: Copy,

impl<T> Debug for Headers<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<C, S, T> FromContext<C, S> for Headers<T>

where T: DeserializeOwned + Send, C: Send, S: Sync,

type Rejection = HandlerOutcome

The error returned when extraction fails. It is converted into a HandlerOutcome (the reflexive conversion makes HandlerOutcome itself a valid rejection, and Infallible works for an extractor that never fails) and the delivery is settled by that outcome, skipping the handler body.

fn from_context( ctx: &mut Context<'_, C, S>, ) -> impl Future<Output = Result<Headers<T>, HandlerOutcome>> + Send

Resolves the value from the delivery context. The context is borrowed mutably so an extractor may also read broker fields or take scratch a middleware left for it.