serviceless 0.4.1

An simple actor model in rust, like actix
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

use service_channel::{mpsc::UnboundedSender, oneshot};

use crate::{envelop::EnvelopWithMessage, Error, Message, Result};

/// Address for specific message type
///
/// This address is typed with a specific message type M.
pub struct Address<M>
where
    M: Message,
{
    pub(crate) sender: UnboundedSender<Box<EnvelopWithMessage<M>>>,
}

impl<M> Clone for Address<M>
where
    M: Message,
{
    fn clone(&self) -> Self {
        Self {
            sender: self.sender.clone(),
        }
    }
}

impl<M> Address<M>
where
    M: Message + Send + 'static,
    M::Result: Send,
{
    /// Return true when service stopped.
    pub fn is_stop(&self) -> bool {
        self.sender.is_closed()
    }

    /// Call service's handler and get result
    pub async fn call(&self, message: M) -> Result<M::Result> {
        let (sender, receiver) = oneshot::channel::<M::Result>();

        let env = Box::new(EnvelopWithMessage::new(message, Some(sender)));

        self.sender
            .unbounded_send(env)
            .map_err(|_| Error::ServiceStoped)?;

        receiver.await.map_err(|_| Error::ServiceStoped)
    }

    /// Call service's handler without result
    ///
    /// Because this function don't need result, so it can call without async.
    pub fn send(&self, message: M) -> Result<()> {
        let env = Box::new(EnvelopWithMessage::new(message, None));

        self.sender
            .unbounded_send(env)
            .map_err(|_| Error::ServiceStoped)?;

        Ok(())
    }
}