New feature: cloudevents-actix

Conditionally compile actix module when enabled

Mostly straightforward, though I don't particularly love that dev-deps
can't be optional: rust-lang/cargo#1596

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

Author: jcrossley3

Cargo.toml

@@ -16,6 +16,9 @@ categories = ["web-programming", "encoding", "data-structures"]
 [lib]
 name = "cloudevents"
 
+[features]
+cloudevents-actix = ["actix-web", "async-trait", "lazy_static", "bytes", "futures"]
+
 [dependencies]
 serde = { version = "^1.0", features = ["derive"] }
 serde_json = "^1.0"
@@ -26,6 +29,13 @@ url = { version = "^2.1", features = ["serde"] }
 snafu = "^0.6"
 bitflags = "^1.2"
 
+# actix optional deps
+actix-web = { version = "^3", default-features = false, optional = true }
+async-trait = { version = "^0.1.33", optional = true }
+lazy_static = { version = "1.4.0", optional = true }
+bytes = { version = "^1.0", optional = true }
+futures = { version = "^0.3", optional = true }
+
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies]
 hostname = "^0.3"
 uuid = { version = "^0.8", features = ["v4"] }
@@ -40,13 +50,19 @@ claim = "0.3.1"
 version-sync = "^0.9"
 serde_yaml = "0.8"
 
+# actix dev-deps
+actix-rt = { version = "^1" }
+url = { version = "^2.1", features = ["serde"] }
+serde_json = { version = "^1.0" }
+chrono = { version = "^0.4", features = ["serde"] }
+
 [workspace]
 members = [
   ".",
   "cloudevents-sdk-actix-web",
   "cloudevents-sdk-reqwest",
   "cloudevents-sdk-rdkafka",
-  "cloudevents-sdk-warp"
+  "cloudevents-sdk-warp",
 ]
 exclude = [
   "example-projects/actix-web-example",

cloudevents-sdk-actix-web/Cargo.toml

@@ -17,7 +17,7 @@ cloudevents-sdk = { version = "0.3.0", path = ".." }
 actix-web = { version = "^3", default-features = false }
 async-trait = "^0.1.33"
 lazy_static = "1.4.0"
-bytes = "^0.5"
+bytes = "^1.0"
 futures = "^0.3"
 
 [dev-dependencies]

cloudevents-sdk-rdkafka/Cargo.toml

@@ -14,13 +14,13 @@ categories = ["web-programming", "encoding"]
 
 [dependencies]
 bytes = "^1.0"
-cloudevents-sdk = { version = "0.3.0", path = ".." }
+cloudevents-sdk = { path = ".." }
 lazy_static = "1.4.0"
 rdkafka = { version = "^0.25", features = ["cmake-build"] }
 
 [dev-dependencies]
 url = { version = "^2.1" }
 serde_json = "^1.0"
 chrono = { version = "^0.4", features = ["serde"] }
-futures = "0.3.5"
+futures = "^0.3"
 version-sync = "^0.9"

cloudevents-sdk-reqwest/Cargo.toml

@@ -14,7 +14,7 @@ categories = ["web-programming", "encoding", "web-programming::http-client"]
 
 [dependencies]
 async-trait = "^0.1.33"
-cloudevents-sdk = { version = "0.3.0", path = ".." }
+cloudevents-sdk = { path = ".." }
 lazy_static = "1.4.0"
 bytes = "^1.0"
 

example-projects/actix-web-example/Cargo.toml

@@ -5,8 +5,7 @@ authors = ["Francesco Guardiani <[email protected]>"]
 edition = "2018"
 
 [dependencies]
-cloudevents-sdk = { path = "../.." }
-cloudevents-sdk-actix-web = { path = "../../cloudevents-sdk-actix-web" }
+cloudevents-sdk = { path = "../..", features = ["cloudevents-actix"] }
 actix-web = "^3"
 actix-cors = "^0.5"
 lazy_static = "1.4.0"

example-projects/actix-web-example/src/main.rs

@@ -1,6 +1,6 @@
 use actix_web::{get, post, web, App, HttpRequest, HttpResponse, HttpServer};
+use cloudevents::actix::{HttpRequestExt, HttpResponseBuilderExt};
 use cloudevents::{EventBuilder, EventBuilderV10};
-use cloudevents_sdk_actix_web::{HttpResponseBuilderExt, HttpRequestExt};
 use serde_json::json;
 
 #[post("/")]

src/actix/headers.rs

@@ -0,0 +1,68 @@
+use crate::event::SpecVersion;
+use actix_web::http::header;
+use actix_web::http::{HeaderName, HeaderValue};
+use lazy_static::lazy_static;
+use std::collections::HashMap;
+use std::str::FromStr;
+
+macro_rules! unwrap_optional_header {
+    ($headers:expr, $name:expr) => {
+        $headers
+            .get::<&'static HeaderName>(&$name)
+            .map(|a| header_value_to_str!(a))
+    };
+}
+
+macro_rules! header_value_to_str {
+    ($header_value:expr) => {
+        $header_value
+            .to_str()
+            .map_err(|e| crate::message::Error::Other {
+                source: Box::new(e),
+            })
+    };
+}
+
+macro_rules! str_to_header_value {
+    ($header_value:expr) => {
+        HeaderValue::from_str($header_value).map_err(|e| crate::message::Error::Other {
+            source: Box::new(e),
+        })
+    };
+}
+
+macro_rules! str_name_to_header {
+    ($attribute:expr) => {
+        HeaderName::from_str($attribute).map_err(|e| crate::message::Error::Other {
+            source: Box::new(e),
+        })
+    };
+}
+
+macro_rules! attribute_name_to_header {
+    ($attribute:expr) => {
+        str_name_to_header!(&["ce-", $attribute].concat())
+    };
+}
+
+fn attributes_to_headers(
+    it: impl Iterator<Item = &'static str>,
+) -> HashMap<&'static str, HeaderName> {
+    it.map(|s| {
+        if s == "datacontenttype" {
+            (s, header::CONTENT_TYPE)
+        } else {
+            (s, attribute_name_to_header!(s).unwrap())
+        }
+    })
+    .collect()
+}
+
+lazy_static! {
+    pub(crate) static ref ATTRIBUTES_TO_HEADERS: HashMap<&'static str, HeaderName> =
+        attributes_to_headers(SpecVersion::all_attribute_names());
+    pub(crate) static ref SPEC_VERSION_HEADER: HeaderName =
+        HeaderName::from_static("ce-specversion");
+    pub(crate) static ref CLOUDEVENTS_JSON_HEADER: HeaderValue =
+        HeaderValue::from_static("application/cloudevents+json");
+}

src/actix/mod.rs

@@ -0,0 +1,57 @@
+//! This crate integrates the [cloudevents-sdk](https://docs.rs/cloudevents-sdk) with [Actix web](https://docs.rs/actix-web/) to easily send and receive CloudEvents.
+//!
+//! To deserialize an HTTP request as CloudEvent:
+//!
+//! ```
+//! use cloudevents::actix::HttpRequestExt;
+//! use actix_web::{HttpRequest, web, post};
+//!
+//! #[post("/")]
+//! async fn post_event(req: HttpRequest, payload: web::Payload) -> Result<String, actix_web::Error> {
+//!     let event = req.to_event(payload).await?;
+//!     println!("Received Event: {:?}", event);
+//!     Ok(format!("{:?}", event))
+//! }
+//! ```
+//!
+//! To serialize a CloudEvent to an HTTP response:
+//!
+//! ```
+//! use cloudevents::actix::HttpResponseBuilderExt;
+//! use actix_web::{HttpRequest, web, get, HttpResponse};
+//! use cloudevents::{EventBuilderV10, EventBuilder};
+//! use serde_json::json;
+//!
+//! #[get("/")]
+//! async fn get_event() -> Result<HttpResponse, actix_web::Error> {
+//!     Ok(HttpResponse::Ok()
+//!         .event(
+//!             EventBuilderV10::new()
+//!                 .id("0001")
+//!                 .ty("example.test")
+//!                 .source("http://localhost/")
+//!                 .data("application/json", json!({"hello": "world"}))
+//!                 .build()
+//!                 .expect("No error while building the event"),
+//!         )
+//!         .await?
+//!     )
+//! }
+//! ```
+//!
+//! Check out the [cloudevents-sdk](https://docs.rs/cloudevents-sdk) docs for more details on how to use [`cloudevents::Event`]
+
+#![doc(html_root_url = "https://docs.rs/cloudevents-sdk/0.3.1")]
+#![deny(broken_intra_doc_links)]
+
+#[macro_use]
+mod headers;
+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;
+pub use server_response::HttpResponseSerializer;