cloudevents
/
sdk-rust
mirror of https://github.com/cloudevents/sdk-rust.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

cargo fix + cargo fmt 

Signed-off-by: Francesco Guardiani <francescoguard@gmail.com>
This commit is contained in:
slinkydeveloper 2020-05-18 14:38:12 +02:00 committed by Francesco Guardiani
parent 8c45200807
commit d46f11c318
11 changed files with 70 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
cloudevents-sdk-actix-web/src/server_request.rs
View File

@ -4,8 +4,8 @@ use actix_web::web::{Bytes, BytesMut};
use actix_web::{web, HttpMessage, HttpRequest};
use cloudevents::event::SpecVersion;
use cloudevents::message::{
BinaryDeserializer, BinarySerializer, Encoding, MessageAttributeValue,
MessageDeserializer, StructuredDeserializer, StructuredSerializer, Result
BinaryDeserializer, BinarySerializer, Encoding, MessageAttributeValue, MessageDeserializer,
Result, StructuredDeserializer, StructuredSerializer,
};
use cloudevents::{message, Event};
use futures::StreamExt;
@ -24,10 +24,7 @@ impl HttpRequestDeserializer<'_> {
}
impl<'a> BinaryDeserializer for HttpRequestDeserializer<'a> {
fn deserialize_binary<R: Sized, V: BinarySerializer<R>>(
self,
mut visitor: V,
) -> Result<R> {
fn deserialize_binary<R: Sized, V: BinarySerializer<R>>(self, mut visitor: V) -> Result<R> {
if self.encoding() != Encoding::BINARY {
return Err(message::Error::WrongEncoding {});
}
@ -78,10 +75,7 @@ impl<'a> BinaryDeserializer for HttpRequestDeserializer<'a> {
}
impl<'a> StructuredDeserializer for HttpRequestDeserializer<'a> {
fn deserialize_structured<R: Sized, V: StructuredSerializer<R>>(
self,
visitor: V,
) -> Result<R> {
fn deserialize_structured<R: Sized, V: StructuredSerializer<R>>(self, visitor: V) -> Result<R> {
if self.encoding() != Encoding::STRUCTURED {
return Err(message::Error::WrongEncoding {});
}

3
cloudevents-sdk-actix-web/src/server_response.rs
View File

@ -4,8 +4,7 @@ use actix_web::http::{HeaderName, HeaderValue};
use actix_web::HttpResponse;
use cloudevents::event::SpecVersion;
use cloudevents::message::{
BinaryDeserializer, BinarySerializer, MessageAttributeValue, Result,
StructuredSerializer,
BinaryDeserializer, BinarySerializer, MessageAttributeValue, Result, StructuredSerializer,
};
use cloudevents::Event;
use std::str::FromStr;

21
cloudevents-sdk-reqwest/src/client_request.rs
View File

@ -1,8 +1,7 @@
use super::headers;
use cloudevents::event::SpecVersion;
use cloudevents::message::{
BinaryDeserializer, BinarySerializer, MessageAttributeValue,
Result, StructuredSerializer,
BinaryDeserializer, BinarySerializer, MessageAttributeValue, Result, StructuredSerializer,
};
use cloudevents::Event;
use reqwest::RequestBuilder;
@ -64,10 +63,7 @@ impl StructuredSerializer<RequestBuilder> for RequestSerializer {
}
/// Method to transform an incoming [`HttpRequest`] to [`Event`]
pub fn event_to_request(
event: Event,
request_builder: RequestBuilder,
) -> Result<RequestBuilder> {
pub fn event_to_request(event: Event, request_builder: RequestBuilder) -> Result<RequestBuilder> {
BinaryDeserializer::deserialize_binary(event, RequestSerializer::new(request_builder))
}
@ -76,10 +72,10 @@ mod tests {
use super::*;
use mockito::{mock, Matcher};
use cloudevents::message::StructuredDeserializer;
use cloudevents::EventBuilder;
use serde_json::json;
use url::Url;
use cloudevents::message::StructuredDeserializer;
#[tokio::test]
async fn test_request() {
@ -164,11 +160,12 @@ mod tests {
let client = reqwest::Client::new();
StructuredDeserializer::deserialize_structured(
input,
RequestSerializer::new(client.post(&url))
).unwrap()
.send()
.await
.unwrap();
RequestSerializer::new(client.post(&url)),
)
.unwrap()
.send()
.await
.unwrap();
m.assert();
}

67
cloudevents-sdk-reqwest/src/client_response.rs
View File

@ -1,11 +1,14 @@
use super::headers;
use reqwest::Response;
use cloudevents::event::SpecVersion;
use cloudevents::message::{BinaryDeserializer, BinarySerializer, Encoding, MessageAttributeValue, MessageDeserializer, StructuredDeserializer, StructuredSerializer, Result, Error};
use cloudevents::{message, Event};
use std::convert::TryFrom;
use bytes::Bytes;
use cloudevents::event::SpecVersion;
use cloudevents::message::{
BinaryDeserializer, BinarySerializer, Encoding, Error, MessageAttributeValue,
MessageDeserializer, Result, StructuredDeserializer, StructuredSerializer,
};
use cloudevents::{message, Event};
use reqwest::header::{HeaderMap, HeaderName};
use reqwest::Response;
use std::convert::TryFrom;
/// Wrapper for [`Response`] that implements [`MessageDeserializer`] trait
pub struct ResponseDeserializer {
@ -20,10 +23,7 @@ impl ResponseDeserializer {
}
impl BinaryDeserializer for ResponseDeserializer {
fn deserialize_binary<R: Sized, V: BinarySerializer<R>>(
self,
mut visitor: V,
) -> Result<R> {
fn deserialize_binary<R: Sized, V: BinarySerializer<R>>(self, mut visitor: V) -> Result<R> {
if self.encoding() != Encoding::BINARY {
return Err(message::Error::WrongEncoding {});
}
@ -38,10 +38,10 @@ impl BinaryDeserializer for ResponseDeserializer {
.get(&spec_version)
.unwrap();
for (hn, hv) in
self.headers.iter().filter(|(hn, _)| {
headers::SPEC_VERSION_HEADER.ne(hn) && hn.as_str().starts_with("ce-")
})
for (hn, hv) in self
.headers
.iter()
.filter(|(hn, _)| headers::SPEC_VERSION_HEADER.ne(hn) && hn.as_str().starts_with("ce-"))
{
let name = &hn.as_str()["ce-".len()..];
@ -74,10 +74,7 @@ impl BinaryDeserializer for ResponseDeserializer {
}
impl StructuredDeserializer for ResponseDeserializer {
fn deserialize_structured<R: Sized, V: StructuredSerializer<R>>(
self,
visitor: V,
) -> Result<R> {
fn deserialize_structured<R: Sized, V: StructuredSerializer<R>>(self, visitor: V) -> Result<R> {
if self.encoding() != Encoding::STRUCTURED {
return Err(message::Error::WrongEncoding {});
}
@ -92,21 +89,22 @@ impl MessageDeserializer for ResponseDeserializer {
.map(|r| r.ok())
.flatten()
.map(|e| e.starts_with("application/cloudevents+json")),
self.headers.get::<&'static HeaderName>(&headers::SPEC_VERSION_HEADER)
self.headers
.get::<&'static HeaderName>(&headers::SPEC_VERSION_HEADER),
) {
(Some(true), _) => Encoding::STRUCTURED,
(_, Some(_)) => Encoding::BINARY,
_ => Encoding::UNKNOWN
_ => Encoding::UNKNOWN,
}
}
}
/// Method to transform an incoming [`Response`] to [`Event`]
pub async fn response_to_event(
res: Response,
) -> Result<Event> {
pub async fn response_to_event(res: Response) -> Result<Event> {
let h = res.headers().to_owned();
let b = res.bytes().await.map_err(|e| Error::Other {source: Box::new(e)})?;
let b = res.bytes().await.map_err(|e| Error::Other {
source: Box::new(e),
})?;
MessageDeserializer::into_event(ResponseDeserializer::new(h, b))
}
@ -118,8 +116,8 @@ mod tests {
use cloudevents::EventBuilder;
use serde_json::json;
use url::Url;
use std::str::FromStr;
use url::Url;
#[tokio::test]
async fn test_response() {
@ -141,10 +139,7 @@ mod tests {
.build();
let client = reqwest::Client::new();
let res = client.get(&url)
.send()
.await
.unwrap();
let res = client.get(&url).send().await.unwrap();
let resp = response_to_event(res).await.unwrap();
assert_eq!(expected, resp);
@ -174,12 +169,8 @@ mod tests {
.extension("someint", "10")
.build();
let client = reqwest::Client::new();
let res = client.get(&url)
.send()
.await
.unwrap();
let res = client.get(&url).send().await.unwrap();
let resp = response_to_event(res).await.unwrap();
assert_eq!(expected, resp);
@ -199,15 +190,15 @@ mod tests {
let url = mockito::server_url();
let _m = mock("GET", "/")
.with_status(200)
.with_header("content-type", "application/cloudevents+json; charset=utf-8")
.with_header(
"content-type",
"application/cloudevents+json; charset=utf-8",
)
.with_body(serde_json::to_string(&expected).unwrap())
.create();
let client = reqwest::Client::new();
let res = client.get(&url)
.send()
.await
.unwrap();
let res = client.get(&url).send().await.unwrap();
let resp = response_to_event(res).await.unwrap();
assert_eq!(expected, resp);

2
cloudevents-sdk-reqwest/src/lib.rs
View File

@ -6,4 +6,4 @@ mod client_response;
pub use client_request::event_to_request;
pub use client_request::RequestSerializer;
pub use client_response::response_to_event;
pub use client_response::ResponseDeserializer;
pub use client_response::ResponseDeserializer;

31
src/event/message.rs
View File

@ -3,8 +3,8 @@ use super::Event;
use super::{Attributes, AttributesReader};
use crate::event::SpecVersion;
use crate::message::{
BinaryDeserializer, BinarySerializer, Result, MessageAttributeValue,
StructuredDeserializer, StructuredSerializer,
BinaryDeserializer, BinarySerializer, MessageAttributeValue, Result, StructuredDeserializer,
StructuredSerializer,
};
impl StructuredDeserializer for Event {
@ -15,10 +15,7 @@ impl StructuredDeserializer for Event {
}
impl BinaryDeserializer for Event {
fn deserialize_binary<R: Sized, V: BinarySerializer<R>>(
self,
mut visitor: V,
) -> Result<R> {
fn deserialize_binary<R: Sized, V: BinarySerializer<R>>(self, mut visitor: V) -> Result<R> {
visitor = visitor.set_spec_version(self.get_specversion())?;
visitor = self.attributes.deserialize_attributes(visitor)?;
for (k, v) in self.extensions.into_iter() {
@ -37,25 +34,15 @@ impl BinaryDeserializer for Event {
}
pub(crate) trait AttributesDeserializer {
fn deserialize_attributes<R: Sized, V: BinarySerializer<R>>(
self,
visitor: V,
) -> Result<V>;
fn deserialize_attributes<R: Sized, V: BinarySerializer<R>>(self, visitor: V) -> Result<V>;
}
pub(crate) trait AttributesSerializer {
fn serialize_attribute(
&mut self,
name: &str,
value: MessageAttributeValue,
) -> Result<()>;
fn serialize_attribute(&mut self, name: &str, value: MessageAttributeValue) -> Result<()>;
}
impl AttributesDeserializer for Attributes {
fn deserialize_attributes<R: Sized, V: BinarySerializer<R>>(
self,
visitor: V,
) -> Result<V> {
fn deserialize_attributes<R: Sized, V: BinarySerializer<R>>(self, visitor: V) -> Result<V> {
match self {
Attributes::V03(v03) => v03.deserialize_attributes(visitor),
Attributes::V10(v10) => v10.deserialize_attributes(visitor),
@ -64,11 +51,7 @@ impl AttributesDeserializer for Attributes {
}
impl AttributesSerializer for Attributes {
fn serialize_attribute(
&mut self,
name: &str,
value: MessageAttributeValue,
) -> Result<()> {
fn serialize_attribute(&mut self, name: &str, value: MessageAttributeValue) -> Result<()> {
match self {
Attributes::V03(v03) => v03.serialize_attribute(name, value),
Attributes::V10(v10) => v10.serialize_attribute(name, value),

18
src/event/v03/message.rs
View File

@ -1,13 +1,8 @@
use crate::message::{
BinarySerializer, Result, Error, MessageAttributeValue,
};
use crate::message::{BinarySerializer, Error, MessageAttributeValue, Result};
use std::convert::TryInto;
impl crate::event::message::AttributesDeserializer for super::Attributes {
fn deserialize_attributes<R: Sized, V: BinarySerializer<R>>(
self,
mut visitor: V,
) -> Result<V> {
fn deserialize_attributes<R: Sized, V: BinarySerializer<R>>(self, mut visitor: V) -> Result<V> {
visitor = visitor.set_attribute("id", MessageAttributeValue::String(self.id))?;
visitor = visitor.set_attribute("type", MessageAttributeValue::String(self.ty))?;
visitor = visitor.set_attribute("source", MessageAttributeValue::UriRef(self.source))?;
@ -30,18 +25,15 @@ impl crate::event::message::AttributesDeserializer for super::Attributes {
)?;
}
if self.time.is_some() {
visitor = visitor.set_attribute("time", MessageAttributeValue::DateTime(self.time.unwrap()))?;
visitor = visitor
.set_attribute("time", MessageAttributeValue::DateTime(self.time.unwrap()))?;
}
Ok(visitor)
}
}
impl crate::event::message::AttributesSerializer for super::Attributes {
fn serialize_attribute(
&mut self,
name: &str,
value: MessageAttributeValue,
) -> Result<()> {
fn serialize_attribute(&mut self, name: &str, value: MessageAttributeValue) -> Result<()> {
match name {
"id" => self.id = value.to_string(),
"type" => self.ty = value.to_string(),

18
src/event/v10/message.rs
View File

@ -1,13 +1,8 @@
use crate::message::{
BinarySerializer, Error, MessageAttributeValue, Result,
};
use crate::message::{BinarySerializer, Error, MessageAttributeValue, Result};
use std::convert::TryInto;
impl crate::event::message::AttributesDeserializer for super::Attributes {
fn deserialize_attributes<R: Sized, V: BinarySerializer<R>>(
self,
mut visitor: V,
) -> Result<V> {
fn deserialize_attributes<R: Sized, V: BinarySerializer<R>>(self, mut visitor: V) -> Result<V> {
visitor = visitor.set_attribute("id", MessageAttributeValue::String(self.id))?;
visitor = visitor.set_attribute("type", MessageAttributeValue::String(self.ty))?;
visitor = visitor.set_attribute("source", MessageAttributeValue::UriRef(self.source))?;
@ -30,18 +25,15 @@ impl crate::event::message::AttributesDeserializer for super::Attributes {
)?;
}
if self.time.is_some() {
visitor = visitor.set_attribute("time", MessageAttributeValue::DateTime(self.time.unwrap()))?;
visitor = visitor
.set_attribute("time", MessageAttributeValue::DateTime(self.time.unwrap()))?;
}
Ok(visitor)
}
}
impl crate::event::message::AttributesSerializer for super::Attributes {
fn serialize_attribute(
&mut self,
name: &str,
value: MessageAttributeValue,
) -> Result<()> {
fn serialize_attribute(&mut self, name: &str, value: MessageAttributeValue) -> Result<()> {
match name {
"id" => self.id = value.to_string(),
"type" => self.ty = value.to_string(),

12
src/message/deserializer.rs
View File

@ -1,4 +1,4 @@
use super::{BinarySerializer, Encoding, StructuredSerializer, Result};
use super::{BinarySerializer, Encoding, Result, StructuredSerializer};
use crate::Event;
pub trait StructuredDeserializer
@ -19,10 +19,7 @@ pub trait BinaryDeserializer
where
Self: Sized,
{
fn deserialize_binary<R: Sized, V: BinarySerializer<R>>(
self,
serializer: V,
) -> Result<R>;
fn deserialize_binary<R: Sized, V: BinarySerializer<R>>(self, serializer: V) -> Result<R>;
fn into_event(self) -> Result<Event> {
self.deserialize_binary(Event::default())
@ -39,10 +36,7 @@ where
self.deserialize_to(Event::default())
}
fn deserialize_to_binary<R: Sized, T: BinarySerializer<R>>(
self,
serializer: T,
) -> Result<R> {
fn deserialize_to_binary<R: Sized, T: BinarySerializer<R>>(self, serializer: T) -> Result<R> {
if self.encoding() == Encoding::BINARY {
return self.deserialize_binary(serializer);
}

5
src/message/serializer.rs
View File

@ -5,7 +5,10 @@ pub trait StructuredSerializer<RETURN: Sized> {
fn set_structured_event(self, bytes: Vec<u8>) -> Result<RETURN>;
}
pub trait BinarySerializer<RETURN: Sized> where Self: Sized {
pub trait BinarySerializer<RETURN: Sized>
where
Self: Sized,
{
fn set_spec_version(self, spec_version: SpecVersion) -> Result<Self>;
fn set_attribute(self, name: &str, value: MessageAttributeValue) -> Result<Self>;

4
tests/message.rs
View File

@ -1,7 +1,7 @@
mod test_data;
use cloudevents::message::{
BinaryDeserializer, BinarySerializer, Error, MessageAttributeValue,
StructuredDeserializer, Result,
BinaryDeserializer, BinarySerializer, Error, MessageAttributeValue, Result,
StructuredDeserializer,
};
use test_data::*;