actr-cli 0.3.1

Command line tool for Actor-RTC framework projects
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

//! {{PROJECT_NAME}} — package-backed Actor-RTC EchoService workload
//!
//! Run `actr gen -l rust` to create `src/generated/` from `protos/local/echo.proto`.

#[cfg(actr_has_generated)]
pub mod generated;

#[cfg(not(actr_has_generated))]
pub mod generated_stub {
    pub mod echo {
        #[derive(Clone, PartialEq, prost::Message)]
        pub struct EchoRequest {
            #[prost(string, tag = "1")]
            pub message: String,
        }

        #[derive(Clone, PartialEq, prost::Message)]
        pub struct EchoResponse {
            #[prost(string, tag = "1")]
            pub reply: String,
            #[prost(uint64, tag = "2")]
            pub timestamp: u64,
        }
    }

    pub mod echo_actor {
        use actr_framework::{Context, MessageDispatcher, Workload};
        use actr_protocol::{ActorResult, PayloadType, RpcEnvelope, RpcRequest};
        use async_trait::async_trait;
        use bytes::Bytes;
        use prost::Message as ProstMessage;

        use super::echo::{EchoRequest, EchoResponse};

        impl RpcRequest for EchoRequest {
            type Response = EchoResponse;

            fn route_key() -> &'static str {
                "echo.EchoService.Echo"
            }

            fn payload_type() -> PayloadType {
                PayloadType::RpcReliable
            }
        }

        #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
        #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
        pub trait EchoServiceHandler: Send + Sync + 'static {
            async fn echo<C: Context>(&self, req: EchoRequest, ctx: &C) -> ActorResult<EchoResponse>;
        }

        pub struct EchoServiceWorkload<T: EchoServiceHandler>(pub T);

        impl<T: EchoServiceHandler> EchoServiceWorkload<T> {
            pub fn new(handler: T) -> Self {
                Self(handler)
            }
        }

        pub struct EchoServiceDispatcher<T: EchoServiceHandler>(std::marker::PhantomData<T>);

        #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
        #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
        impl<T: EchoServiceHandler> MessageDispatcher for EchoServiceDispatcher<T> {
            type Workload = EchoServiceWorkload<T>;

            async fn dispatch<C: Context>(
                workload: &Self::Workload,
                envelope: RpcEnvelope,
                ctx: &C,
            ) -> ActorResult<Bytes> {
                match envelope.route_key.as_str() {
                    "echo.EchoService.Echo" => {
                        let payload = envelope.payload.as_ref().ok_or_else(|| {
                            actr_protocol::ActrError::DecodeFailure(
                                "Missing payload in RpcEnvelope".to_string(),
                            )
                        })?;
                        let req = EchoRequest::decode(&**payload).map_err(|error| {
                            actr_protocol::ActrError::DecodeFailure(format!(
                                "Failed to decode EchoRequest: {error}"
                            ))
                        })?;
                        let response = workload.0.echo(req, ctx).await?;
                        Ok(Bytes::from(response.encode_to_vec()))
                    }
                    _ => Err(actr_protocol::ActrError::UnknownRoute(
                        envelope.route_key.to_string(),
                    )),
                }
            }
        }

        impl<T: EchoServiceHandler> Workload for EchoServiceWorkload<T> {
            type Dispatcher = EchoServiceDispatcher<T>;
        }
    }
}

#[cfg(not(actr_has_generated))]
pub use generated_stub as generated;

pub mod echo_service;

use actr_framework::entry;
use generated::echo_actor::EchoServiceWorkload;

pub use crate::echo_service::EchoServiceImpl;

entry!(
    EchoServiceWorkload<EchoServiceImpl>,
    EchoServiceWorkload::new(EchoServiceImpl::new())
);