Encapsulate shared event deserialization behind a Headers trait

Both warp and reqwest use the HeaderMap from the http crate. Actix has
its own. Fortunately, both contain (HeaderName, HeaderValue) tuples.

Further, actix uses a conflicting version of the bytes crate, so I
store a Vec<u8> instead of a Bytes member in the Deserializer
struct. Not sure if that's a problem, but the tests pass. :)

We use an associated type in the Headers trait to facilitate static
dispatch for warp/reqwest since their concrete iterator is public, but
the actix Iter struct is private, so we use a Box for its impl.

We're using AsHeaderName for the get() param to avoid having to call
as_str() on any header constants, but of course actix uses its own
AsName trait, which isn't public, so we must call as_str() for the
passed header name in its impl.

Signed-off-by: Jim Crossley <[email protected]>

Author: jcrossley3

Cargo.toml

@@ -18,7 +18,7 @@ name = "cloudevents"
 
 [features]
 actix = ["actix-web", "async-trait", "bytes", "futures", "http"]
-reqwest = ["reqwest-lib", "async-trait", "bytes"]
+reqwest = ["reqwest-lib", "async-trait", "bytes", "http"]
 rdkafka = ["rdkafka-lib", "bytes", "futures"]
 warp = ["warp-lib", "bytes", "http", "hyper"]
 

src/binding/actix/mod.rs

@@ -45,7 +45,6 @@ mod server_request;
 mod server_response;
 
 pub use server_request::request_to_event;
-pub use server_request::HttpRequestDeserializer;
 pub use server_request::HttpRequestExt;
 pub use server_response::event_to_response;
 pub use server_response::HttpResponseBuilderExt;

src/binding/actix/server_request.rs

@@ -1,99 +1,20 @@
-use crate::binding::http::SPEC_VERSION_HEADER;
-use crate::event::SpecVersion;
-use crate::message::{
-    BinaryDeserializer, BinarySerializer, Encoding, MessageAttributeValue, MessageDeserializer,
-    Result, StructuredDeserializer, StructuredSerializer,
-};
-use crate::{header_value_to_str, message, Event};
-use actix_web::web::{Bytes, BytesMut};
-use actix_web::{web, HttpMessage, HttpRequest};
+use crate::binding::http::{to_event, Headers};
+use crate::Event;
+use actix_web::web::BytesMut;
+use actix_web::{web, HttpRequest};
 use async_trait::async_trait;
 use futures::future::LocalBoxFuture;
 use futures::{FutureExt, StreamExt};
-use std::convert::TryFrom;
+use http::header::{AsHeaderName, HeaderName, HeaderValue};
 
-/// Wrapper for [`HttpRequest`] that implements [`MessageDeserializer`] trait.
-pub struct HttpRequestDeserializer<'a> {
-    req: &'a HttpRequest,
-    body: Bytes,
-}
-
-impl HttpRequestDeserializer<'_> {
-    pub fn new(req: &HttpRequest, body: Bytes) -> HttpRequestDeserializer {
-        HttpRequestDeserializer { req, body }
-    }
-}
-
-impl<'a> BinaryDeserializer for HttpRequestDeserializer<'a> {
-    fn deserialize_binary<R: Sized, V: BinarySerializer<R>>(self, mut visitor: V) -> Result<R> {
-        if self.encoding() != Encoding::BINARY {
-            return Err(message::Error::WrongEncoding {});
-        }
-
-        let spec_version = SpecVersion::try_from(
-            self.req
-                .headers()
-                .get(SPEC_VERSION_HEADER)
-                .map(|a| header_value_to_str!(a))
-                .unwrap()?,
-        )?;
-
-        visitor = visitor.set_spec_version(spec_version.clone())?;
-
-        let attributes = spec_version.attribute_names();
-
-        for (hn, hv) in self.req.headers().iter().filter(|(hn, _)| {
-            let key = hn.as_str();
-            SPEC_VERSION_HEADER.ne(key) && key.starts_with("ce-")
-        }) {
-            let name = &hn.as_str()["ce-".len()..];
-
-            if attributes.contains(&name) {
-                visitor = visitor.set_attribute(
-                    name,
-                    MessageAttributeValue::String(String::from(header_value_to_str!(hv)?)),
-                )?
-            } else {
-                visitor = visitor.set_extension(
-                    name,
-                    MessageAttributeValue::String(String::from(header_value_to_str!(hv)?)),
-                )?
-            }
-        }
-
-        if let Some(hv) = self.req.headers().get("content-type") {
-            visitor = visitor.set_attribute(
-                "datacontenttype",
-                MessageAttributeValue::String(String::from(header_value_to_str!(hv)?)),
-            )?
-        }
-
-        if !self.body.is_empty() {
-            visitor.end_with_data(self.body.to_vec())
-        } else {
-            visitor.end()
-        }
+/// Implement Headers for the actix HeaderMap
+impl<'a> Headers<'a> for actix_web::http::HeaderMap {
+    type Iterator = Box<dyn Iterator<Item = (&'a HeaderName, &'a HeaderValue)> + 'a>;
+    fn get<K: AsHeaderName>(&self, key: K) -> Option<&HeaderValue> {
+        self.get(key.as_str())
     }
-}
-
-impl<'a> StructuredDeserializer for HttpRequestDeserializer<'a> {
-    fn deserialize_structured<R: Sized, V: StructuredSerializer<R>>(self, visitor: V) -> Result<R> {
-        if self.encoding() != Encoding::STRUCTURED {
-            return Err(message::Error::WrongEncoding {});
-        }
-        visitor.set_structured_event(self.body.to_vec())
-    }
-}
-
-impl<'a> MessageDeserializer for HttpRequestDeserializer<'a> {
-    fn encoding(&self) -> Encoding {
-        if self.req.content_type() == "application/cloudevents+json" {
-            Encoding::STRUCTURED
-        } else if self.req.headers().get(SPEC_VERSION_HEADER).is_some() {
-            Encoding::BINARY
-        } else {
-            Encoding::UNKNOWN
-        }
+    fn iter(&'a self) -> Self::Iterator {
+        Box::new(self.iter())
     }
 }
 
@@ -106,8 +27,7 @@ pub async fn request_to_event(
     while let Some(item) = payload.next().await {
         bytes.extend_from_slice(&item?);
     }
-    MessageDeserializer::into_event(HttpRequestDeserializer::new(req, bytes.freeze()))
-        .map_err(actix_web::error::ErrorBadRequest)
+    to_event(req.headers(), bytes.to_vec()).map_err(actix_web::error::ErrorBadRequest)
 }
 
 /// So that an actix-web handler may take an Event parameter

src/binding/warp/server_request.rs renamed to src/binding/http/deserializer.rs

@@ -1,28 +1,27 @@
-use bytes::Bytes;
-use http::HeaderMap;
-
-use crate::binding::http::SPEC_VERSION_HEADER;
-use crate::event::SpecVersion;
-use crate::header_value_to_str;
-use crate::message::{
-    BinaryDeserializer, BinarySerializer, Encoding, Error, MessageAttributeValue,
-    MessageDeserializer, Result, StructuredDeserializer, StructuredSerializer,
+use super::{Headers, SPEC_VERSION_HEADER};
+use crate::{
+    binding::CLOUDEVENTS_JSON_HEADER,
+    event::SpecVersion,
+    header_value_to_str, message,
+    message::{
+        BinaryDeserializer, BinarySerializer, Encoding, MessageAttributeValue, MessageDeserializer,
+        Result, StructuredDeserializer, StructuredSerializer,
+    },
 };
-use crate::{message, Event};
 use std::convert::TryFrom;
 
-pub struct RequestDeserializer {
-    headers: HeaderMap,
-    body: Bytes,
+pub struct Deserializer<'a, T: Headers<'a>> {
+    headers: &'a T,
+    body: Vec<u8>,
 }
 
-impl RequestDeserializer {
-    pub fn new(headers: HeaderMap, body: Bytes) -> RequestDeserializer {
-        RequestDeserializer { headers, body }
+impl<'a, T: Headers<'a>> Deserializer<'a, T> {
+    pub fn new(headers: &'a T, body: Vec<u8>) -> Deserializer<'a, T> {
+        Deserializer { headers, body }
     }
 }
 
-impl BinaryDeserializer for RequestDeserializer {
+impl<'a, T: Headers<'a>> BinaryDeserializer for Deserializer<'a, T> {
     fn deserialize_binary<R: Sized, V: BinarySerializer<R>>(self, mut visitor: V) -> Result<R> {
         if self.encoding() != Encoding::BINARY {
             return Err(message::Error::WrongEncoding {});
@@ -58,48 +57,44 @@ impl BinaryDeserializer for RequestDeserializer {
             }
         }
 
-        if let Some(hv) = self.headers.get("content-type") {
+        if let Some(hv) = self.headers.get(http::header::CONTENT_TYPE) {
             visitor = visitor.set_attribute(
                 "datacontenttype",
                 MessageAttributeValue::String(String::from(header_value_to_str!(hv)?)),
             )?
         }
 
         if !self.body.is_empty() {
-            visitor.end_with_data(self.body.to_vec())
+            visitor.end_with_data(self.body)
         } else {
             visitor.end()
         }
     }
 }
 
-impl StructuredDeserializer for RequestDeserializer {
+impl<'a, T: Headers<'a>> StructuredDeserializer for Deserializer<'a, T> {
     fn deserialize_structured<R: Sized, V: StructuredSerializer<R>>(self, visitor: V) -> Result<R> {
         if self.encoding() != Encoding::STRUCTURED {
             return Err(message::Error::WrongEncoding {});
         }
-        visitor.set_structured_event(self.body.to_vec())
+        visitor.set_structured_event(self.body)
     }
 }
 
-impl MessageDeserializer for RequestDeserializer {
+impl<'a, T: Headers<'a>> MessageDeserializer for Deserializer<'a, T> {
     fn encoding(&self) -> Encoding {
         if self
             .headers
-            .get("content-type")
-            .map(|v| v.to_str().unwrap_or(""))
-            .unwrap_or("")
-            == "application/cloudevents+json"
+            .get(http::header::CONTENT_TYPE)
+            .and_then(|v| v.to_str().ok())
+            .filter(|&v| v.starts_with(CLOUDEVENTS_JSON_HEADER))
+            .is_some()
         {
             Encoding::STRUCTURED
-        } else if self.headers.contains_key(SPEC_VERSION_HEADER) {
+        } else if self.headers.get(SPEC_VERSION_HEADER).is_some() {
             Encoding::BINARY
         } else {
             Encoding::UNKNOWN
         }
     }
 }
-
-pub fn request_to_event(req: HeaderMap, bytes: bytes::Bytes) -> std::result::Result<Event, Error> {
-    MessageDeserializer::into_event(RequestDeserializer::new(req, bytes))
-}

src/binding/http/headers.rs

@@ -0,0 +1,21 @@
+use http::header::{AsHeaderName, HeaderMap, HeaderName, HeaderValue};
+
+/// Any http library should be able to use the
+/// [`to_event`](super::to_event) function with an implementation of
+/// this trait.
+pub trait Headers<'a> {
+    type Iterator: Iterator<Item = (&'a HeaderName, &'a HeaderValue)>;
+    fn get<K: AsHeaderName>(&self, name: K) -> Option<&HeaderValue>;
+    fn iter(&'a self) -> Self::Iterator;
+}
+
+/// Implemention for the HeaderMap used by warp/reqwest
+impl<'a> Headers<'a> for HeaderMap<HeaderValue> {
+    type Iterator = http::header::Iter<'a, HeaderValue>;
+    fn get<K: AsHeaderName>(&self, name: K) -> Option<&HeaderValue> {
+        self.get(name)
+    }
+    fn iter(&'a self) -> Self::Iterator {
+        self.iter()
+    }
+}

src/binding/http/mod.rs

@@ -1,5 +1,23 @@
+mod deserializer;
+mod headers;
+
+use crate::{
+    message::{Error, MessageDeserializer},
+    Event,
+};
+use deserializer::Deserializer;
+pub use headers::Headers;
+
 pub static SPEC_VERSION_HEADER: &str = "ce-specversion";
 
+/// Turn a pile of HTTP headers and a body into a CloudEvent
+pub fn to_event<'a, T: Headers<'a>>(
+    headers: &'a T,
+    body: Vec<u8>,
+) -> std::result::Result<Event, Error> {
+    MessageDeserializer::into_event(Deserializer::new(headers, body))
+}
+
 pub fn header_prefix(name: &str) -> String {
     super::header_prefix("ce-", name)
 }