may_rpc 0.1.7

RPC framework for Rust based on coroutine.
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

// cargo rustc --bin main -- -Z unstable-options --pretty expanded
#[may_rpc::service]
trait RpcSpec {
    /// Say hello
    fn hello(&self, name: String) -> String;
    /// add two number
    fn add(&self, x: u32, y: u32) -> u32;
}

mod count {
    #[may_rpc::service]
    pub trait RpcSpec {
        /// get current count
        fn get_count(&self) -> usize;
    }
}

fn test_count() {
    use may_rpc::TcpServer;
    use std::sync::atomic::{AtomicUsize, Ordering};
    #[derive(may_rpc::Server)]
    #[service(count::RpcSpec)]
    struct CountImpl(AtomicUsize);
    impl count::RpcSpec for CountImpl {
        fn get_count(&self) -> usize {
            self.0.fetch_add(1, Ordering::Relaxed)
        }
    }

    let addr = ("127.0.0.1", 4000);
    let _server = CountImpl(AtomicUsize::new(0)).start(addr).unwrap();

    let tcp_stream = may::net::TcpStream::connect(addr).unwrap();
    let mut client = count::RpcSpecClient::new(tcp_stream).unwrap();
    client.set_timeout(::std::time::Duration::from_millis(100));

    for _ in 0..10 {
        let data = client.get_count();
        println!("recv = {:?}", data);
    }
}

fn test_hello() {
    use may_rpc::TcpServer;

    #[derive(may_rpc::Server)]
    #[service(RpcSpec)]
    struct HelloImpl;

    impl RpcSpec for HelloImpl {
        fn hello(&self, name: String) -> String {
            name
        }

        fn add(&self, x: u32, y: u32) -> u32 {
            x + y
        }
    }

    let addr = ("127.0.0.1", 4000);
    let _server = HelloImpl.start(addr).unwrap();
    let tcp_stream = may::net::TcpStream::connect(addr).unwrap();
    let client = RpcSpecClient::new(tcp_stream).unwrap();

    for i in 0..10 {
        let s = format!("Hello World! id={}", i);
        let data = client.hello(s);
        println!("recv = {:?}", data);
    }

    for i in 0..10 {
        let data = client.add(i, i);
        println!("recv = {:?}", data);
    }
}

fn main() {
    env_logger::init();

    println!("test_hello");
    test_hello();

    println!("\n\ntest_count");
    test_count();
}