use std::str::{self, FromStr};
use http::HeaderValue;
pub trait HeaderValueExt {
fn to_utf8_str(&self) -> Result<&str, std::str::Utf8Error>;
}
impl HeaderValueExt for HeaderValue {
fn to_utf8_str(&self) -> Result<&str, std::str::Utf8Error> {
std::str::from_utf8(self.as_bytes())
}
}
#[derive(Debug, Copy, Clone, Hash, Eq, PartialEq)]
pub enum MetaKey {
TraceParent,
TraceState,
XCorrelationId,
Version,
UserId,
UserData,
Caller,
Callee,
SvcAuthMethod,
SvcAuthEncoreAuthHash,
SvcAuthEncoreAuthDate,
Service,
Gateway,
Frontend,
ClientIp,
ForwardedHost,
RelayId,
}
impl MetaKey {
pub fn header_key(&self) -> &'static str {
use MetaKey::*;
match self {
TraceParent => "traceparent",
TraceState => "tracestate",
XCorrelationId => "x-correlation-id",
Version => "x-encore-meta-version",
UserId => "x-encore-meta-userid",
UserData => "x-encore-meta-authdata",
Caller => "x-encore-meta-caller",
Callee => "x-encore-meta-callee",
SvcAuthMethod => "x-encore-meta-svc-auth-method",
SvcAuthEncoreAuthHash => "x-encore-meta-svc-auth",
SvcAuthEncoreAuthDate => "x-encore-meta-date",
Service => "x-encore-service",
Gateway => "x-encore-gateway",
Frontend => "x-encore-frontend",
ClientIp => "x-encore-client-ip",
ForwardedHost => "x-forwarded-host",
RelayId => "x-encore-relay-id",
}
}
}
pub struct NotMetaKey;
impl FromStr for MetaKey {
type Err = NotMetaKey;
fn from_str(value: &str) -> Result<Self, Self::Err> {
use MetaKey::*;
Ok(match value {
"traceparent" => TraceParent,
"tracestate" => TraceState,
"x-correlation-id" => XCorrelationId,
"x-encore-meta-version" => Version,
"x-encore-meta-userid" => UserId,
"x-encore-meta-authdata" => UserData,
"x-encore-meta-caller" => Caller,
"x-encore-meta-callee" => Callee,
"x-encore-meta-svc-auth-method" => SvcAuthMethod,
"x-encore-meta-svc-auth" => SvcAuthEncoreAuthHash,
"x-encore-meta-date" => SvcAuthEncoreAuthDate,
"x-encore-service" => Service,
"x-encore-gateway" => Gateway,
"x-encore-frontend" => Frontend,
"x-encore-client-ip" => ClientIp,
"x-forwarded-host" => ForwardedHost,
"x-encore-relay-id" => RelayId,
_ => return Err(NotMetaKey),
})
}
}
pub trait MetaMapMut: MetaMap {
fn set(&mut self, key: MetaKey, value: String) -> anyhow::Result<()>;
}
pub trait MetaMap {
fn get_meta(&self, key: MetaKey) -> Option<&str>;
fn meta_values<'a>(&'a self, key: MetaKey) -> Box<dyn Iterator<Item = &'a str> + 'a>;
fn sorted_meta_keys(&self) -> Vec<MetaKey>;
fn ctx_fields(&self) -> Vec<(&str, &[u8])>;
}
fn ctx_fields_of(headers: &http::HeaderMap) -> Vec<(&str, &[u8])> {
headers
.iter()
.filter(|(name, _)| crate::reqctx::is_field_header(name.as_str()))
.map(|(name, value)| (name.as_str(), value.as_bytes()))
.collect()
}
impl MetaMapMut for http::HeaderMap {
fn set(&mut self, key: MetaKey, value: String) -> anyhow::Result<()> {
self.insert(key.header_key(), value.parse()?);
Ok(())
}
}
impl MetaMap for http::HeaderMap {
fn get_meta(&self, key: MetaKey) -> Option<&str> {
self.get(key.header_key())
.and_then(|val| val.to_utf8_str().ok())
}
fn meta_values<'a>(&'a self, key: MetaKey) -> Box<dyn Iterator<Item = &'a str> + 'a> {
Box::new(
self.get_all(key.header_key())
.iter()
.filter_map(|v| v.to_utf8_str().ok()),
)
}
fn sorted_meta_keys(&self) -> Vec<MetaKey> {
let mut keys: Vec<_> = self
.keys()
.filter_map(|k| MetaKey::from_str(k.as_str()).ok())
.collect();
keys.sort_by_key(|k| k.header_key());
keys
}
fn ctx_fields(&self) -> Vec<(&str, &[u8])> {
ctx_fields_of(self)
}
}
#[cfg(feature = "pingora")]
impl MetaMapMut for pingora_http::RequestHeader {
fn set(&mut self, key: MetaKey, value: String) -> anyhow::Result<()> {
self.insert_header(key.header_key(), value)?;
Ok(())
}
}
#[cfg(feature = "pingora")]
impl MetaMap for pingora_http::RequestHeader {
fn get_meta(&self, key: MetaKey) -> Option<&str> {
self.headers
.get(key.header_key())
.and_then(|v| v.to_utf8_str().ok())
}
fn meta_values<'a>(&'a self, key: MetaKey) -> Box<dyn Iterator<Item = &'a str> + 'a> {
Box::new(
self.headers
.get_all(key.header_key())
.iter()
.filter_map(|v| v.to_utf8_str().ok()),
)
}
fn sorted_meta_keys(&self) -> Vec<MetaKey> {
let mut keys: Vec<_> = self
.headers
.keys()
.filter_map(|k| MetaKey::from_str(k.as_str()).ok())
.collect();
keys.sort_by_key(|k| k.header_key());
keys
}
fn ctx_fields(&self) -> Vec<(&str, &[u8])> {
ctx_fields_of(&self.headers)
}
}