orsomafo 0.3.6

Event dispatcher crate
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

use crate::{
    dispatched_event::DispatchedEvent,
    event_dispatcher::event_dispatcher,
    event_listener::{merge_subscribers, SubscriberList, LOG_TITLE},
};
use async_trait::async_trait;

/// Types that are dispatchable must implement this trait
#[async_trait]
pub trait Dispatchable:
    serde::Serialize + serde::de::DeserializeOwned + Clone + Send + Sync
{
    /// By default the name of the type is used as the event name
    /// It is recommended to leave this as it is if you don't
    /// have any good reason to change it.
    fn event() -> String
    where
        Self: Sized,
    {
        std::any::type_name::<Self>().to_string()
    }

    /// Call this method when you are ready to dispatch the event
    /// ```
    /// # use async_trait::async_trait;
    /// # use orsomafo::{Dispatchable, DispatchedEvent, EventDispatcherBuilder, EventHandler};
    /// # use tokio::time::{sleep, Duration};
    ///
    /// # #[tokio::main]
    /// # async fn main() {
    /// #  _ =  EventDispatcherBuilder::new().build().await;
    ///
    ///    #[derive(Clone, serde::Serialize, serde::Deserialize)]
    ///    struct MyEvent;
    ///    impl Dispatchable for MyEvent {}
    ///
    ///    let e = MyEvent;
    ///    e.dispatch_event();
    /// }
    /// ```
    ///
    fn dispatch_event(self)
    where
        Self: Sized + 'static,
    {
        event_dispatcher().dispatch(self);
    }

    fn supports_cluster(&self) -> bool {
        true
    }

    fn serialize_event(&self) -> String {
        let event = DispatchedEvent::new(serde_json::to_string(self).unwrap(), Self::event());

        serde_json::to_string(&event).unwrap()
    }

    async fn subscribe<H: EventHandler + Default>()
    where
        Self: Sized,
    {
        crate::setup().await;

        let event = Self::event();
        let the_handler = H::default().to_handler();

        let mut subscriber = SubscriberList::new();

        log::trace!(
            target: LOG_TITLE,
            "registered handler: {:?}, for event: {:?}",
            &event,
            &the_handler.handler_id()
        );

        subscriber.insert(event, vec![the_handler]);
        merge_subscribers(subscriber).await;
    }
}

/// Event handler must implement this trait
#[async_trait]
pub trait EventHandler: Send + Sync + 'static {
    /// The "handle" method will be called when an event is ready
    /// ```
    /// # use async_trait::async_trait;
    /// # use orsomafo::{Dispatchable, DispatchedEvent, EventDispatcherBuilder, EventHandler};
    /// # use tokio::time::{sleep, Duration};
    ///
    /// # #[tokio::main]
    /// # async fn main() {
    /// #  _ =  EventDispatcherBuilder::new().build().await;
    ///
    ///    struct MyEventHandler;
    ///    
    ///    #[orsomafo::async_trait]
    ///    impl EventHandler for MyEventHandler {
    ///        async fn handle(&self, event: &DispatchedEvent)  {
    ///           //...
    ///        }
    ///    }
    ///
    /// }
    /// ```
    async fn handle(&self, event: &DispatchedEvent);

    fn to_handler(self) -> Box<Self>
    where
        Self: Sized,
    {
        Box::new(self)
    }

    /// The identification of this handler
    /// It is recommended to leave this as it is
    fn handler_id(&self) -> String {
        std::any::type_name::<Self>().to_string()
    }

    /// Executes this handler once and dequeue it if `true` is returned
    fn execute_once(&self) -> bool {
        false
    }

    /// Stops propagating the event to other handlers when `false` is returned
    fn propagate(&self) -> bool {
        true
    }
}

mod test {
    use super::*;

    #[derive(Clone, serde::Serialize, serde::Deserialize)]
    struct UserCreated {
        id: u32,
    }

    impl Dispatchable for UserCreated {}

    #[tokio::test]
    async fn test_event_dispatching() {
        UserCreated::subscribe::<HandleUserCreated>().await;
        event_dispatcher()
            .dispatch_sync(UserCreated { id: 200 })
            .await;
    }

    #[derive(Default)]
    struct HandleUserCreated;

    #[async_trait]
    impl EventHandler for HandleUserCreated {
        async fn handle(&self, dispatched: &DispatchedEvent) {
            let the_event = dispatched.the_event();

            assert_eq!(the_event.is_none(), false);

            let event: UserCreated = the_event.unwrap();
            assert_eq!(event.id, 200);
        }
    }
}