distant-net 0.20.0

Network library for distant, providing implementations to support client/server architecture
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

use async_trait::async_trait;
use distant_auth::{DummyAuthHandler, Verifier};
use distant_net::client::Client;
use distant_net::common::{InmemoryTransport, OneshotListener, Request};
use distant_net::server::{RequestCtx, Server, ServerHandler};
use log::*;
use test_log::test;

struct TestServerHandler;

#[async_trait]
impl ServerHandler for TestServerHandler {
    type Request = (u8, String);
    type Response = String;

    async fn on_request(&self, ctx: RequestCtx<Self::Request, Self::Response>) {
        let (cnt, msg) = ctx.request.payload;

        for i in 0..cnt {
            ctx.reply
                .send(format!("echo {i} {msg}"))
                .expect("Failed to send response");
        }
    }
}

#[test(tokio::test)]
async fn should_be_able_to_send_and_receive_untyped_payloads_between_client_and_server() {
    let (t1, t2) = InmemoryTransport::pair(100);

    let _server = Server::new()
        .handler(TestServerHandler)
        .verifier(Verifier::none())
        .start(OneshotListener::from_value(t2))
        .expect("Failed to start server");

    let mut client = Client::build()
        .auth_handler(DummyAuthHandler)
        .connector(t1)
        .connect_untyped()
        .await
        .expect("Failed to connect to server");

    info!("Mailing a message from the client, and waiting for 3 responses");
    let mut mailbox = client
        .mail(
            Request::new((3, "hello".to_string()))
                .to_untyped_request()
                .unwrap(),
        )
        .await
        .expect("Failed to mail message");

    assert_eq!(
        mailbox
            .next()
            .await
            .unwrap()
            .to_typed_response::<String>()
            .unwrap()
            .payload,
        "echo 0 hello"
    );
    assert_eq!(
        mailbox
            .next()
            .await
            .unwrap()
            .to_typed_response::<String>()
            .unwrap()
            .payload,
        "echo 1 hello"
    );
    assert_eq!(
        mailbox
            .next()
            .await
            .unwrap()
            .to_typed_response::<String>()
            .unwrap()
            .payload,
        "echo 2 hello"
    );

    info!("Sending a message from the client, and waiting for a response");
    let response = client
        .send(
            Request::new((1, "hello".to_string()))
                .to_untyped_request()
                .unwrap(),
        )
        .await
        .expect("Failed to send message");

    assert_eq!(
        response.to_typed_response::<String>().unwrap().payload,
        "echo 0 hello"
    );

    info!("Firing off a message from the client");
    client
        .fire(
            Request::new((1, "hello".to_string()))
                .to_untyped_request()
                .unwrap(),
        )
        .await
        .expect("Failed to fire message");
}