tactix 0.0.6

A simple Actor Model based on Tokio.
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

use std::sync::Arc;

use crate::{addr::Addr, context::Context, envelope::Envelope};
use async_trait::async_trait;
use tokio::sync::{mpsc, oneshot, Mutex};

/// Defines an Actor. An Actor is an independent unit that processes messages, makes decisions, and communicates with other Actors without shared state.
#[async_trait]
pub trait Actor: Sized + Send + Sync + 'static {
    type Context: Send + Sync + 'static;

    /// Start the actor and return an address
    fn start(self) -> Addr<Self>
    where
        Self: Actor<Context = Context<Self>>,
    {
        Context::new().run(self)
    }

    /// Async handler that is run after the actor is started
    async fn started(&self) {}

    /// Async handler that is run after the actor has been stopped
    async fn stopped(&self) {}
}

/// Defines a message type for actor communication, specifying an associated response type.
pub trait Message: Send + 'static {
    type Response: Send;
}

/// Defines an asynchronous message handler for processing actor messages and returning responses.
///
/// Handlers can be added to actors like so:
///
/// ```
/// use tactix::*;
/// use async_trait::async_trait;
///
/// struct MyActor;
///
/// impl Actor for MyActor {
///   type Context = tactix::Context<Self>;
/// }
///
/// struct SomeMessage;
/// impl Message for SomeMessage {
///   type Response = u8;
/// }
///
/// #[async_trait]
/// impl Handler<SomeMessage> for MyActor {
///   async fn handle(&mut self, msg:SomeMessage, _:Self::Context) -> u8 {
///      // Implement your handler
///      1u8
///   }
/// }
/// ```
///
/// Note this trait requires the use of the `#[async_trait]` macro.
#[async_trait]
pub trait Handler<M>
where
    Self: Actor,
    M: Message,
{
    async fn handle(&mut self, msg: M, ctx: Self::Context) -> M::Response;
}

/// This enables the host to pack messages to an envelope
pub trait ToEnvelope<A, M>
where
    A: Actor,
    M: Message,
{
    fn pack(&self, msg: Option<M>, tx: Option<oneshot::Sender<M::Response>>) -> Envelope<A>;
}

/// This allows us to run our handler via our actor bound Envelope
#[async_trait]
pub trait EnvelopeApi<A: Actor> {
    async fn handle(&mut self, act: Arc<Mutex<A>>, ctx: A::Context);
}

/// Encapsulates the idea of a channel transmitter. Represents the ability to send messages
#[async_trait]
pub trait Sender<M: Message>: Sync {
    fn do_send(&self, msg: M);
    async fn send(&self, msg: M) -> Result<M::Response, String>;
}

/// Represent the ability to send messages wrapped in actor envelopes
pub trait EnvelopeSender<A: Actor> {
    fn get_tx(&self) -> mpsc::Sender<Envelope<A>>;

    /// Send a given Envelope on the structs given envelope sender
    fn send_env(&self, env: Envelope<A>) {
        let tx = self.get_tx();
        tokio::spawn(async move {
            let _ = tx.send(env).await;
        });
    }
}