gasket 0.9.0

Staged Event-Driven Architecture (SEDA) framework
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

#[macro_export]
macro_rules! impl_mapper {
    (| $worker_param:ident : $worker_type:ty, $stage_param:ident : $stage_type:ty, $unit_param:ident : $unit_type:ty |  => $map:expr) => {
        #[async_trait::async_trait(?Send)]
        impl $crate::framework::Worker<$stage_type> for $worker_type {
            async fn bootstrap(
                stage: &$stage_type,
            ) -> Result<Self, $crate::framework::WorkerError> {
                Ok(Self::from(stage))
            }

            async fn schedule(
                &mut self,
                stage: &mut $stage_type,
            ) -> Result<$crate::framework::WorkSchedule<$unit_type>, $crate::framework::WorkerError>
            {
                use $crate::framework::*;
                let msg = stage.input.recv().await.or_panic()?;

                Ok($crate::framework::WorkSchedule::Unit(msg.payload))
            }

            async fn execute(
                &mut self,
                __unit: &$unit_type,
                __stage: &mut $stage_type,
            ) -> Result<(), $crate::framework::WorkerError> {
                use $crate::framework::*;
                let $worker_param = self;
                let $unit_param = __unit;
                let $stage_param = __stage;

                let out = { $map };

                $stage_param.output.send(out.into()).await.or_panic()?;

                Ok(())
            }
        }
    };
}

#[macro_export]
macro_rules! impl_splitter {
    (| $worker_param:ident : $worker_type:ty, $stage_param:ident : $stage_type:ty, $unit_param:ident : $unit_type:ty |  => $map:expr) => {
        #[async_trait::async_trait(?Send)]
        impl $crate::framework::Worker<$stage_type> for $worker_type {
            async fn bootstrap(
                stage: &$stage_type,
            ) -> Result<Self, $crate::framework::WorkerError> {
                Ok(Self::from(stage))
            }

            async fn schedule(
                &mut self,
                stage: &mut $stage_type,
            ) -> Result<$crate::framework::WorkSchedule<$unit_type>, $crate::framework::WorkerError>
            {
                use $crate::framework::*;
                let msg = stage.input.recv().await.or_panic()?;

                Ok($crate::framework::WorkSchedule::Unit(msg.payload))
            }

            async fn execute(
                &mut self,
                __unit: &$unit_type,
                __stage: &mut $stage_type,
            ) -> Result<(), $crate::framework::WorkerError> {
                use $crate::framework::*;
                let $worker_param = self;
                let $unit_param = __unit;
                let $stage_param = __stage;

                let out = { $map };

                for i in out.into_iter() {
                    $stage_param.output.send(i.into()).await.or_panic()?;
                }

                Ok(())
            }
        }
    };
}