Enum NonUtf8HeaderHandling 

#[non_exhaustive]
pub enum NonUtf8HeaderHandling {
    Reject,
    Skip,
}

What to do when a response header value bound to a modeled member is not valid UTF-8

An HTTP header value may contain any octet in 0x80..=0xFF (obs-text, RFC 7230), and an arbitrary sequence of those is not necessarily valid UTF-8, so a service may send a value that cannot be represented as a Rust String. Headers stores such a value as received, but the modeled member it is bound to is a String, so something has to give when the member is deserialized.

The default is Reject. To choose otherwise, put this in the config bag from an interceptor that runs before deserialization. Skip does not remove the header, so the same interceptor can read the octets from any hook that sees the response, using Headers::get_bytes or iter_bytes:

#[derive(Clone, Debug, Default)]
struct SkipNonUtf8Headers {
    seen: Arc<Mutex<Vec<(String, Vec<u8>)>>>,
}

impl Intercept for SkipNonUtf8Headers {
    fn name(&self) -> &'static str {
        "SkipNonUtf8Headers"
    }

    fn read_before_execution(
        &self,
        _context: &BeforeSerializationInterceptorContextRef<'_>,
        cfg: &mut ConfigBag,
    ) -> Result<(), BoxError> {
        cfg.interceptor_state()
            .store_put(NonUtf8HeaderHandling::Skip);
        Ok(())
    }

    fn read_before_deserialization(
        &self,
        context: &BeforeDeserializationInterceptorContextRef<'_>,
        _runtime_components: &RuntimeComponents,
        _cfg: &mut ConfigBag,
    ) -> Result<(), BoxError> {
        // Runs once per attempt, so overwrite rather than append.
        *self.seen.lock().unwrap() = context
            .response()
            .headers()
            .iter_bytes()
            .filter(|(_, value)| std::str::from_utf8(value).is_err())
            .map(|(name, value)| (name.to_owned(), value.to_vec()))
            .collect();
        Ok(())
    }
}

This applies only to values bound to a modeled member. A header bound to nothing is never an error regardless of encoding.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Reject

Fail the operation, reporting the member and header that could not be parsed.

This is the default: a value the service sent is not silently discarded.

Skip

Deserialize the member as if the header were absent.

The header itself is left in place, so the octets stay readable through Headers::get_bytes.

Note this drops the whole member, not just the offending value: for a member bound to a list-valued header, one unreadable value makes the entire member None.

Trait Implementations

impl Clone for NonUtf8HeaderHandling

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NonUtf8HeaderHandling

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

Formats the value using the given formatter.

impl Default for NonUtf8HeaderHandling

fn default() -> Self

Returns the “default value” for a type.

impl Eq for NonUtf8HeaderHandling

impl PartialEq for NonUtf8HeaderHandling

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Storable for NonUtf8HeaderHandling

type Storer = StoreReplace<NonUtf8HeaderHandling>

Specify how an item is stored in the config bag, e.g. StoreReplace and StoreAppend

impl StructuralPartialEq for NonUtf8HeaderHandling