hbkr-rs 0.3.2

Hashblock Key Rotation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! HBKR Event Message

use serde::{Deserialize, Serialize, Serializer};

use crate::{
    errors::KrError,
    said::SelfAddressingPrefix,
    serialization_info::{SerializationFormats, SerializationInfo},
    Digestible, EventTypeTag, Typeable,
};

#[derive(Default, Deserialize, Debug, Clone, PartialEq)]
pub struct EventMessage<D> {
    /// Serialization Information
    ///
    /// Encodes the version, size and serialization format of the event
    #[serde(rename = "v")]
    pub serialization_info: SerializationInfo,

    #[serde(flatten)]
    pub event: D,
}

impl<D: Digestible> EventMessage<D> {
    pub fn get_digest(&self) -> SelfAddressingPrefix {
        self.event.get_digest()
    }
}

impl<T: Clone + Serialize + Digestible + Typeable> EventMessage<T> {
    pub fn serialization(&self) -> SerializationFormats {
        self.serialization_info.kind
    }

    /// Serialize
    ///
    /// returns the serialized event message
    /// NOTE: this method, for deserialized events, will be UNABLE to preserve ordering
    pub fn serialize(&self) -> Result<Vec<u8>, KrError> {
        self.serialization().encode(self)
    }
}

impl<D: Digestible + Typeable + Serialize + Clone> Serialize for EventMessage<D> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        // Helper struct for adding `t` field to EventMessage serialization
        #[derive(Serialize)]
        struct TypedEventMessage<D> {
            v: SerializationInfo,
            #[serde(rename = "t")]
            event_type: EventTypeTag,

            #[serde(rename = "d")]
            digest: SelfAddressingPrefix,

            #[serde(flatten)]
            event: D,
        }
        impl<D: Digestible + Typeable + Clone> From<&EventMessage<D>> for TypedEventMessage<D> {
            fn from(em: &EventMessage<D>) -> Self {
                TypedEventMessage {
                    v: em.serialization_info,
                    event_type: em.event.get_type(),
                    digest: em.event.get_digest(),
                    event: em.event.clone(),
                }
            }
        }

        let tem: TypedEventMessage<_> = self.into();
        tem.serialize(serializer)
    }
}

// #[derive(Serialize, Deserialize, PartialEq)]
// pub struct TimestampedEventMessage {
//     pub timestamp: DateTime<Local>,
//     pub event_message: EventMessage<KeyEvent>,
// }

// impl TimestampedEventMessage {
//     pub fn new(event: EventMessage<KeyEvent>) -> Self {
//         Self {
//             timestamp: Local::now(),
//             event_message: event,
//         }
//     }
// }

// impl PartialOrd for TimestampedEventMessage {
//     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
//         Some(
//             match self.event_message.event.get_sn() == other.event_message.event.get_sn() {
//                 true => Ordering::Equal,
//                 false => {
//                     match self.event_message.event.get_sn() > other.event_message.event.get_sn() {
//                         true => Ordering::Greater,
//                         false => Ordering::Less,
//                     }
//                 }
//             },
//         )
//     }
// }

// impl Ord for TimestampedEventMessage {
//     fn cmp(&self, other: &Self) -> Ordering {
//         match self.event_message.event.get_sn() == other.event_message.event.get_sn() {
//             true => Ordering::Equal,
//             false => match self.event_message.event.get_sn() > other.event_message.event.get_sn() {
//                 true => Ordering::Greater,
//                 false => Ordering::Less,
//             },
//         }
//     }
// }

// impl Eq for TimestampedEventMessage {}

// impl From<TimestampedEventMessage> for EventMessage<KeyEvent> {
//     fn from(event: TimestampedEventMessage) -> EventMessage<KeyEvent> {
//         event.event_message
//     }
// }

// /// WARNING: timestamp will change on conversion to current time
// impl From<EventMessage<KeyEvent>> for TimestampedEventMessage {
//     fn from(event: EventMessage<KeyEvent>) -> TimestampedEventMessage {
//         TimestampedEventMessage::new(event)
//     }
// }