tokio_ipc 0.1.0

Multi-protocol RPC framework built on top of 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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

// tokio_socket/examples/example_protocol/mod.rs
use lockshed::SharedCounter;

tokio_socket::rpc::protocol! {
    pub mod server_rpc {
        #[derive(Debug)] server_action1 {
            server_arg1: u32,
            server_arg2: String,
        } -> #[derive(Debug)] {
            server_result1: u32,
            server_result2: String,
        };

        #[derive(Debug)] server_action2 -> #[derive(Debug)] {
            server_result1: u32,
            server_result2: String,
        };

        #[derive(Debug)] server_action3 {
            server_arg1: u32,
            server_arg2: String,
        };
    }
}

tokio_socket::rpc::protocol! {
    pub mod client_rpc {
        #[derive(Debug)] client_action1 {
            client_arg1: u32,
            client_arg2: String,
        } -> #[derive(Debug)] {
            client_result1: u32,
            client_result2: String,
        };

        #[derive(Debug)] client_action2 -> #[derive(Debug)] {
            client_result1: u32,
            client_result2: String,
        };

        #[derive(Debug)] client_action3 {
            client_arg1: u32,
            client_arg2: String,
        };
    }
}

#[derive(Clone)]
pub struct ServerHandler {
    #[allow(unused)]
    pub client: client_rpc::Sender,
}

impl server_rpc::Receive for ServerHandler {
    async fn server_action1(
        &self,
        server_arg1: u32,
        server_arg2: String,
    ) -> anyhow::Result<server_rpc::server_action1::Response> {
        tracing::info!("server action 1");
        Ok(server_rpc::server_action1::Response {
            server_result1: server_arg1 + 1,
            server_result2: format!("hi from server {server_arg2}"),
        })
    }

    async fn server_action2(
        &self,
    ) -> tokio_socket::rpc::anyhow::Result<server_rpc::server_action2::Response> {
        tracing::info!("server action 2");
        Ok(server_rpc::server_action2::Response {
            server_result1: 42,
            server_result2: "hi from server".to_string(),
        })
    }

    async fn server_action3(
        &self,
        server_arg1: u32,
        server_arg2: String,
    ) -> tokio_socket::rpc::anyhow::Result<()> {
        tracing::info!("server action 3: {} {}", server_arg1, server_arg2);
        Ok(())
    }
}

#[derive(Clone)]
pub struct ClientHandler {
    #[allow(unused)]
    pub state: SharedCounter,
}

impl client_rpc::Receive for ClientHandler {
    async fn client_action1(
        &self,
        client_arg1: u32,
        client_arg2: String,
    ) -> tokio_socket::rpc::anyhow::Result<client_rpc::client_action1::Response> {
        tracing::info!("client action 1");
        Ok(client_rpc::client_action1::Response {
            client_result1: client_arg1 + 1,
            client_result2: format!("hi from client {client_arg2}"),
        })
    }

    async fn client_action2(
        &self,
    ) -> tokio_socket::rpc::anyhow::Result<client_rpc::client_action2::Response> {
        tracing::info!("client action 2");
        Ok(client_rpc::client_action2::Response {
            client_result1: 42,
            client_result2: "hi from client".to_string(),
        })
    }

    async fn client_action3(
        &self,
        client_arg1: u32,
        client_arg2: String,
    ) -> tokio_socket::rpc::anyhow::Result<()> {
        tracing::info!("client action 3: {} {}", client_arg1, client_arg2);
        Ok(())
    }
}