grpc 0.6.2

Rust implementation of gRPC
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

#[macro_use]
extern crate log;
extern crate env_logger;

extern crate futures;
extern crate grpc;

mod test_misc;

use grpc::rt::*;
use grpc::*;

use test_misc::*;

fn echo_fn(_: RequestOptions, req: String) -> SingleResponse<String> {
    SingleResponse::completed(req)
}

fn reverse_fn(_: RequestOptions, req: String) -> SingleResponse<String> {
    SingleResponse::completed(req.chars().rev().collect())
}

#[test]
fn multiple_services() {
    drop(env_logger::try_init());

    let mut server = ServerBuilder::new_plain();
    server.http.set_port(0);

    let echo = string_string_method("/foo/echo", GrpcStreaming::Unary);
    let reverse = string_string_method("/bar/reverse", GrpcStreaming::Unary);

    server.add_service(ServerServiceDefinition::new(
        "/foo",
        vec![ServerMethod::new(
            echo.clone(),
            MethodHandlerUnary::new(echo_fn),
        )],
    ));

    server.add_service(ServerServiceDefinition::new(
        "/bar",
        vec![ServerMethod::new(
            reverse.clone(),
            MethodHandlerUnary::new(reverse_fn),
        )],
    ));

    let server = server.build().expect("server");

    let port = server.local_addr().port().expect("port");

    let client = Client::new_plain(BIND_HOST, port, ClientConf::new()).expect("client");

    assert_eq!(
        "abc".to_owned(),
        client
            .call_unary(RequestOptions::new(), "abc".to_owned(), echo)
            .wait_drop_metadata()
            .unwrap()
    );

    assert_eq!(
        "zyx".to_owned(),
        client
            .call_unary(RequestOptions::new(), "xyz".to_owned(), reverse)
            .wait_drop_metadata()
            .unwrap()
    );
}

#[cfg(unix)]
#[test]
fn single_service_unix() {
    let test_socket_address = "/tmp/grpc_rust_single_service_unix";
    let mut server = ServerBuilder::new_plain();
    server
        .http
        .set_unix_addr(test_socket_address.to_owned())
        .unwrap();

    let echo = string_string_method("/foo/echo", GrpcStreaming::Unary);
    let reverse = string_string_method("/bar/reverse", GrpcStreaming::Unary);

    server.add_service(ServerServiceDefinition::new(
        "/foo",
        vec![ServerMethod::new(
            echo.clone(),
            MethodHandlerUnary::new(echo_fn),
        )],
    ));

    server.add_service(ServerServiceDefinition::new(
        "/bar",
        vec![ServerMethod::new(
            reverse.clone(),
            MethodHandlerUnary::new(reverse_fn),
        )],
    ));

    let _server = server.build().expect("server");

    let client = Client::new_plain_unix(test_socket_address, ClientConf::new()).expect("client");

    assert_eq!(
        "abc".to_owned(),
        client
            .call_unary(RequestOptions::new(), "abc".to_owned(), echo)
            .wait_drop_metadata()
            .unwrap()
    );

    assert_eq!(
        "zyx".to_owned(),
        client
            .call_unary(RequestOptions::new(), "xyz".to_owned(), reverse)
            .wait_drop_metadata()
            .unwrap()
    );
}