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

Changed again interface now to work similar to a builder (receives self -> return self) 

Signed-off-by: Francesco Guardiani <francescoguard@gmail.com>
This commit is contained in:
slinkydeveloper 2020-05-18 12:18:28 +02:00 committed by Francesco Guardiani
parent 2dfdd78923
commit 534cf01fd2
9 changed files with 143 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
src/event/message.rs
View File

@ -3,12 +3,12 @@ use super::Event;
use super::{Attributes, AttributesReader};
use crate::event::SpecVersion;
use crate::message::{
BinaryDeserializer, BinarySerializer, DeserializationResult, Error, MessageAttributeValue,
SerializationResult, StructuredDeserializer, StructuredSerializer,
BinaryDeserializer, BinarySerializer, Result, MessageAttributeValue,
StructuredDeserializer, StructuredSerializer,
};
impl StructuredDeserializer for Event {
fn deserialize_structured<R, V: StructuredSerializer<R>>(self, visitor: V) -> Result<R, Error> {
fn deserialize_structured<R, V: StructuredSerializer<R>>(self, visitor: V) -> Result<R> {
let vec: Vec<u8> = serde_json::to_vec(&self)?;
visitor.set_structured_event(vec)
}
@ -18,11 +18,11 @@ impl BinaryDeserializer for Event {
fn deserialize_binary<R: Sized, V: BinarySerializer<R>>(
self,
mut visitor: V,
) -> Result<R, Error> {
visitor.set_spec_version(self.get_specversion())?;
self.attributes.deserialize_attributes(&mut visitor)?;
) -> Result<R> {
visitor = visitor.set_spec_version(self.get_specversion())?;
visitor = self.attributes.deserialize_attributes(visitor)?;
for (k, v) in self.extensions.into_iter() {
visitor.set_extension(&k, v.into())?;
visitor = visitor.set_extension(&k, v.into())?;
}
match self.data {
Some(Data::String(s)) => visitor.end_with_data(s.into_bytes()),
@ -39,8 +39,8 @@ impl BinaryDeserializer for Event {
pub(crate) trait AttributesDeserializer {
fn deserialize_attributes<R: Sized, V: BinarySerializer<R>>(
self,
visitor: &mut V,
) -> DeserializationResult;
visitor: V,
) -> Result<V>;
}
pub(crate) trait AttributesSerializer {
@ -48,14 +48,14 @@ pub(crate) trait AttributesSerializer {
&mut self,
name: &str,
value: MessageAttributeValue,
) -> SerializationResult;
) -> Result<()>;
}
impl AttributesDeserializer for Attributes {
fn deserialize_attributes<R: Sized, V: BinarySerializer<R>>(
self,
visitor: &mut V,
) -> DeserializationResult {
visitor: V,
) -> Result<V> {
match self {
Attributes::V03(v03) => v03.deserialize_attributes(visitor),
Attributes::V10(v10) => v10.deserialize_attributes(visitor),
@ -68,7 +68,7 @@ impl AttributesSerializer for Attributes {
&mut self,
name: &str,
value: MessageAttributeValue,
) -> SerializationResult {
) -> Result<()> {
match self {
Attributes::V03(v03) => v03.serialize_attribute(name, value),
Attributes::V10(v10) => v10.serialize_attribute(name, value),
@ -77,7 +77,7 @@ impl AttributesSerializer for Attributes {
}
impl StructuredSerializer<Event> for Event {
fn set_structured_event(mut self, bytes: Vec<u8>) -> Result<Event, Error> {
fn set_structured_event(mut self, bytes: Vec<u8>) -> Result<Event> {
let new_event: Event = serde_json::from_slice(&bytes)?;
self.attributes = new_event.attributes;
self.data = new_event.data;
@ -87,29 +87,30 @@ impl StructuredSerializer<Event> for Event {
}
impl BinarySerializer<Event> for Event {
fn set_spec_version(&mut self, spec_version: SpecVersion) -> SerializationResult {
fn set_spec_version(mut self, spec_version: SpecVersion) -> Result<Self> {
match spec_version {
SpecVersion::V03 => self.attributes = self.attributes.clone().into_v03(),
SpecVersion::V10 => self.attributes = self.attributes.clone().into_v10(),
}
Ok(())
Ok(self)
}
fn set_attribute(&mut self, name: &str, value: MessageAttributeValue) -> SerializationResult {
self.attributes.serialize_attribute(name, value)
fn set_attribute(mut self, name: &str, value: MessageAttributeValue) -> Result<Self> {
self.attributes.serialize_attribute(name, value)?;
Ok(self)
}
fn set_extension(&mut self, name: &str, value: MessageAttributeValue) -> SerializationResult {
fn set_extension(mut self, name: &str, value: MessageAttributeValue) -> Result<Self> {
self.extensions.insert(name.to_string(), value.into());
Ok(())
Ok(self)
}
fn end_with_data(mut self, bytes: Vec<u8>) -> Result<Event, Error> {
fn end_with_data(mut self, bytes: Vec<u8>) -> Result<Event> {
self.data = Some(Data::from_binary(self.get_datacontenttype(), bytes)?);
Ok(self)
}
fn end(self) -> Result<Event, Error> {
fn end(self) -> Result<Event> {
Ok(self)
}
}

66
src/event/v03/attributes.rs
View File

@ -1,7 +1,7 @@
use crate::event::attributes::{AttributeValue, AttributesConverter, DataAttributesWriter};
use crate::event::AttributesV10;
use crate::event::{AttributesReader, AttributesWriter, SpecVersion};
use chrono::{DateTime, NaiveDateTime, Utc};
use chrono::{DateTime, Utc};
use hostname::get_hostname;
use url::Url;
use uuid::Uuid;
@ -187,34 +187,40 @@ impl AttributesConverter for Attributes {
}
}
#[test]
fn iterator_test_V03() {
let a = Attributes {
id: String::from("1"),
ty: String::from("someType"),
source: Url::parse("https://example.net").unwrap(),
datacontenttype: None,
schemaurl: None,
subject: None,
time: Some(DateTime::<Utc>::from_utc(
NaiveDateTime::from_timestamp(61, 0),
Utc,
)),
};
let b = &mut a.into_iter();
let time = DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(61, 0), Utc);
#[cfg(test)]
mod tests {
use super::*;
use chrono::NaiveDateTime;
assert_eq!(("id", AttributeValue::String("1")), b.next().unwrap());
assert_eq!(
("type", AttributeValue::String("someType")),
b.next().unwrap()
);
assert_eq!(
(
"source",
AttributeValue::URIRef(&Url::parse("https://example.net").unwrap())
),
b.next().unwrap()
);
assert_eq!(("time", AttributeValue::Time(&time)), b.next().unwrap());
#[test]
fn iterator_test_V03() {
let a = Attributes {
id: String::from("1"),
ty: String::from("someType"),
source: Url::parse("https://example.net").unwrap(),
datacontenttype: None,
schemaurl: None,
subject: None,
time: Some(DateTime::<Utc>::from_utc(
NaiveDateTime::from_timestamp(61, 0),
Utc,
)),
};
let b = &mut a.into_iter();
let time = DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(61, 0), Utc);
assert_eq!(("id", AttributeValue::String("1")), b.next().unwrap());
assert_eq!(
("type", AttributeValue::String("someType")),
b.next().unwrap()
);
assert_eq!(
(
"source",
AttributeValue::URIRef(&Url::parse("https://example.net").unwrap())
),
b.next().unwrap()
);
assert_eq!(("time", AttributeValue::Time(&time)), b.next().unwrap());
}
}

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

@ -1,38 +1,38 @@
use crate::message::{
BinarySerializer, DeserializationResult, Error, MessageAttributeValue, SerializationResult,
BinarySerializer, Result, Error, MessageAttributeValue,
};
use std::convert::TryInto;
impl crate::event::message::AttributesDeserializer for super::Attributes {
fn deserialize_attributes<R: Sized, V: BinarySerializer<R>>(
self,
visitor: &mut V,
) -> DeserializationResult {
visitor.set_attribute("id", MessageAttributeValue::String(self.id))?;
visitor.set_attribute("type", MessageAttributeValue::String(self.ty))?;
visitor.set_attribute("source", MessageAttributeValue::UriRef(self.source))?;
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))?;
if self.datacontenttype.is_some() {
visitor.set_attribute(
visitor = visitor.set_attribute(
"datacontenttype",
MessageAttributeValue::String(self.datacontenttype.unwrap()),
)?;
}
if self.schemaurl.is_some() {
visitor.set_attribute(
visitor = visitor.set_attribute(
"schemaurl",
MessageAttributeValue::Uri(self.schemaurl.unwrap()),
)?;
}
if self.subject.is_some() {
visitor.set_attribute(
visitor = visitor.set_attribute(
"subject",
MessageAttributeValue::String(self.subject.unwrap()),
)?;
}
if self.time.is_some() {
visitor.set_attribute("time", MessageAttributeValue::DateTime(self.time.unwrap()))?;
visitor = visitor.set_attribute("time", MessageAttributeValue::DateTime(self.time.unwrap()))?;
}
Ok(())
Ok(visitor)
}
}
@ -41,7 +41,7 @@ impl crate::event::message::AttributesSerializer for super::Attributes {
&mut self,
name: &str,
value: MessageAttributeValue,
) -> SerializationResult {
) -> Result<()> {
match name {
"id" => self.id = value.to_string(),
"type" => self.ty = value.to_string(),

66
src/event/v10/attributes.rs
View File

@ -1,6 +1,6 @@
use crate::event::attributes::{AttributeValue, AttributesConverter, DataAttributesWriter};
use crate::event::{AttributesReader, AttributesV03, AttributesWriter, SpecVersion};
use chrono::{DateTime, NaiveDateTime, Utc};
use chrono::{DateTime, Utc};
use hostname::get_hostname;
use url::Url;
use uuid::Uuid;
@ -186,34 +186,40 @@ impl AttributesConverter for Attributes {
}
}
#[test]
fn iterator_test_V10() {
let a = Attributes {
id: String::from("1"),
ty: String::from("someType"),
source: Url::parse("https://example.net").unwrap(),
datacontenttype: None,
dataschema: None,
subject: None,
time: Some(DateTime::<Utc>::from_utc(
NaiveDateTime::from_timestamp(61, 0),
Utc,
)),
};
let b = &mut a.into_iter();
let time = DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(61, 0), Utc);
#[cfg(test)]
mod tests {
use super::*;
use chrono::NaiveDateTime;
assert_eq!(("id", AttributeValue::String("1")), b.next().unwrap());
assert_eq!(
("type", AttributeValue::String("someType")),
b.next().unwrap()
);
assert_eq!(
(
"source",
AttributeValue::URIRef(&Url::parse("https://example.net").unwrap())
),
b.next().unwrap()
);
assert_eq!(("time", AttributeValue::Time(&time)), b.next().unwrap());
#[test]
fn iterator_test_V10() {
let a = Attributes {
id: String::from("1"),
ty: String::from("someType"),
source: Url::parse("https://example.net").unwrap(),
datacontenttype: None,
dataschema: None,
subject: None,
time: Some(DateTime::<Utc>::from_utc(
NaiveDateTime::from_timestamp(61, 0),
Utc,
)),
};
let b = &mut a.into_iter();
let time = DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(61, 0), Utc);
assert_eq!(("id", AttributeValue::String("1")), b.next().unwrap());
assert_eq!(
("type", AttributeValue::String("someType")),
b.next().unwrap()
);
assert_eq!(
(
"source",
AttributeValue::URIRef(&Url::parse("https://example.net").unwrap())
),
b.next().unwrap()
);
assert_eq!(("time", AttributeValue::Time(&time)), b.next().unwrap());
}
}

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

@ -1,38 +1,38 @@
use crate::message::{
BinarySerializer, DeserializationResult, Error, MessageAttributeValue, SerializationResult,
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,
visitor: &mut V,
) -> DeserializationResult {
visitor.set_attribute("id", MessageAttributeValue::String(self.id))?;
visitor.set_attribute("type", MessageAttributeValue::String(self.ty))?;
visitor.set_attribute("source", MessageAttributeValue::UriRef(self.source))?;
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))?;
if self.datacontenttype.is_some() {
visitor.set_attribute(
visitor = visitor.set_attribute(
"datacontenttype",
MessageAttributeValue::String(self.datacontenttype.unwrap()),
)?;
}
if self.dataschema.is_some() {
visitor.set_attribute(
visitor = visitor.set_attribute(
"dataschema",
MessageAttributeValue::Uri(self.dataschema.unwrap()),
)?;
}
if self.subject.is_some() {
visitor.set_attribute(
visitor = visitor.set_attribute(
"subject",
MessageAttributeValue::String(self.subject.unwrap()),
)?;
}
if self.time.is_some() {
visitor.set_attribute("time", MessageAttributeValue::DateTime(self.time.unwrap()))?;
visitor = visitor.set_attribute("time", MessageAttributeValue::DateTime(self.time.unwrap()))?;
}
Ok(())
Ok(visitor)
}
}
@ -41,7 +41,7 @@ impl crate::event::message::AttributesSerializer for super::Attributes {
&mut self,
name: &str,
value: MessageAttributeValue,
) -> SerializationResult {
) -> Result<()> {
match name {
"id" => self.id = value.to_string(),
"type" => self.ty = value.to_string(),

18
src/message/deserializer.rs
View File

@ -1,4 +1,4 @@
use super::{BinarySerializer, Encoding, Error, StructuredSerializer};
use super::{BinarySerializer, Encoding, Error, StructuredSerializer, Result};
use crate::Event;
pub trait StructuredDeserializer
@ -8,9 +8,9 @@ where
fn deserialize_structured<R: Sized, V: StructuredSerializer<R>>(
self,
serializer: V,
) -> Result<R, Error>;
) -> Result<R>;
fn into_event(self) -> Result<Event, Error> {
fn into_event(self) -> Result<Event> {
self.deserialize_structured(Event::default())
}
}
@ -22,9 +22,9 @@ where
fn deserialize_binary<R: Sized, V: BinarySerializer<R>>(
self,
serializer: V,
) -> Result<R, Error>;
) -> Result<R>;
fn into_event(self) -> Result<Event, Error> {
fn into_event(self) -> Result<Event> {
self.deserialize_binary(Event::default())
}
}
@ -35,14 +35,14 @@ where
{
fn encoding(&self) -> Encoding;
fn into_event(self) -> Result<Event, Error> {
fn into_event(self) -> Result<Event> {
self.deserialize_to(Event::default())
}
fn deserialize_to_binary<R: Sized, T: BinarySerializer<R>>(
self,
serializer: T,
) -> Result<R, Error> {
) -> Result<R> {
if self.encoding() == Encoding::BINARY {
return self.deserialize_binary(serializer);
}
@ -53,7 +53,7 @@ where
fn deserialize_to_structured<R: Sized, T: StructuredSerializer<R>>(
self,
serializer: T,
) -> Result<R, Error> {
) -> Result<R> {
if self.encoding() == Encoding::STRUCTURED {
return self.deserialize_structured(serializer);
}
@ -64,7 +64,7 @@ where
fn deserialize_to<R: Sized, T: BinarySerializer<R> + StructuredSerializer<R>>(
self,
serializer: T,
) -> Result<R, Error> {
) -> Result<R> {
if self.encoding() == Encoding::STRUCTURED {
self.deserialize_structured(serializer)
} else {

3
src/message/error.rs
View File

@ -30,5 +30,4 @@ pub enum Error {
Other { source: Box<dyn std::error::Error> },
}
pub type SerializationResult = Result<(), Error>;
pub type DeserializationResult = Result<(), Error>;
pub type Result<T> = std::result::Result<T, Error>;

16
src/message/serializer.rs
View File

@ -1,18 +1,18 @@
use super::{Error, MessageAttributeValue, SerializationResult};
use super::{MessageAttributeValue, Result};
use crate::event::SpecVersion;
pub trait StructuredSerializer<RETURN: Sized> {
fn set_structured_event(self, bytes: Vec<u8>) -> Result<RETURN, Error>;
fn set_structured_event(self, bytes: Vec<u8>) -> Result<RETURN>;
}
pub trait BinarySerializer<RETURN: Sized> {
fn set_spec_version(&mut self, spec_version: SpecVersion) -> SerializationResult;
pub trait BinarySerializer<RETURN: Sized> where Self: Sized {
fn set_spec_version(self, spec_version: SpecVersion) -> Result<Self>;
fn set_attribute(&mut self, name: &str, value: MessageAttributeValue) -> SerializationResult;
fn set_attribute(self, name: &str, value: MessageAttributeValue) -> Result<Self>;
fn set_extension(&mut self, name: &str, value: MessageAttributeValue) -> SerializationResult;
fn set_extension(self, name: &str, value: MessageAttributeValue) -> Result<Self>;
fn end_with_data(self, bytes: Vec<u8>) -> Result<RETURN, Error>;
fn end_with_data(self, bytes: Vec<u8>) -> Result<RETURN>;
fn end(self) -> Result<RETURN, Error>;
fn end(self) -> Result<RETURN>;
}

12
tests/message.rs
View File

@ -1,13 +1,13 @@
mod test_data;
use cloudevents::message::{
BinaryDeserializer, BinarySerializer, DeserializationResult, Error, MessageAttributeValue,
StructuredDeserializer,
BinaryDeserializer, BinarySerializer, Error, MessageAttributeValue,
StructuredDeserializer, Result,
};
use test_data::*;
#[test]
fn message_v03_roundtrip_structured() -> DeserializationResult {
fn message_v03_roundtrip_structured() -> Result<()> {
assert_eq!(
v03::full_json_data(),
StructuredDeserializer::into_event(v03::full_json_data())?
@ -16,7 +16,7 @@ fn message_v03_roundtrip_structured() -> DeserializationResult {
}
#[test]
fn message_v03_roundtrip_binary() -> DeserializationResult {
fn message_v03_roundtrip_binary() -> Result<()> {
assert_eq!(
v03::full_json_data(),
BinaryDeserializer::into_event(v03::full_json_data())?
@ -25,7 +25,7 @@ fn message_v03_roundtrip_binary() -> DeserializationResult {
}
#[test]
fn message_v10_roundtrip_structured() -> DeserializationResult {
fn message_v10_roundtrip_structured() -> Result<()> {
assert_eq!(
v10::full_json_data(),
StructuredDeserializer::into_event(v10::full_json_data())?
@ -34,7 +34,7 @@ fn message_v10_roundtrip_structured() -> DeserializationResult {
}
#[test]
fn message_v10_roundtrip_binary() -> DeserializationResult {
fn message_v10_roundtrip_binary() -> Result<()> {
assert_eq!(
v10::full_json_data(),
BinaryDeserializer::into_event(v10::full_json_data())?