quickie 0.7.0

A simple, low-level, and customizable implementation of a QUIC P2P node.
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

//! These tests verify whether a node containing a client config can initiate outbound
//! connections, and one containing a server config can accept inbound ones.

mod common;

use std::{
    sync::{
        atomic::{AtomicBool, Ordering},
        Arc,
    },
    time::Duration,
};

use deadline::deadline;
use quickie::*;
use tokio::time::timeout;

#[tokio::test]
#[should_panic]
async fn conns_double_none_config() {
    // a node with neither client nor server config
    let _node = common::TestNode(Node::new(Config::new(None, None)));
}

#[tokio::test]
async fn conns_server_only() {
    // prepare the configs
    let (client_cfg, server_cfg) = common::client_and_server_config();

    // a node in server-only mode
    let node = common::TestNode(Node::new(Config::new(None, Some(server_cfg.clone()))));
    let node_addr = node.start("127.0.0.1:0".parse().unwrap()).await.unwrap();

    // a raw endpoint
    let raw_endpoint = common::raw_endpoint(client_cfg, server_cfg);
    let raw_endpoint_addr = raw_endpoint.local_addr().unwrap();

    // a server-only node can't initiate a connection
    assert!(node
        .connect(raw_endpoint_addr, common::SERVER_NAME)
        .await
        .is_err());

    // a server-only node can accept a connection
    assert!(raw_endpoint
        .connect(node_addr, common::SERVER_NAME)
        .unwrap()
        .await
        .is_ok());

    // find the inbound connection
    let node_clone = node.clone();
    deadline!(Duration::from_secs(1), move || node_clone.num_connections()
        == 1);
    let conn_id = node.get_connections().pop().unwrap().stable_id();

    // check a node-side disconnect
    assert!(node.disconnect(conn_id, Default::default(), &[0]).await);
    assert!(node.get_connection(conn_id).is_none());
}

#[tokio::test]
async fn conns_client_only() {
    // prepare the configs
    let (client_cfg, server_cfg) = common::client_and_server_config();

    // a node in client-only mode
    let node = common::TestNode(Node::new(Config::new(Some(client_cfg.clone()), None)));
    let node_addr = node.start("127.0.0.1:0".parse().unwrap()).await.unwrap();

    // a raw endpoint
    let raw_endpoint = common::raw_endpoint(client_cfg, server_cfg);
    let raw_endpoint_addr = raw_endpoint.local_addr().unwrap();

    // a client-only node can't accept a connection
    // impose a timeout, as it takes 3s otherwise
    assert!(timeout(
        Duration::from_millis(50),
        raw_endpoint
            .connect(node_addr, common::SERVER_NAME)
            .unwrap()
    )
    .await
    .is_err());

    // a flag to indicate that the client connection was accepted
    let conn_success_flag: Arc<AtomicBool> = Default::default();

    // prepare to accept a connection at the raw endpoint
    let flag = conn_success_flag.clone();
    tokio::spawn(async move {
        if let Some(conn) = raw_endpoint.accept().await {
            conn.await.unwrap();
            flag.store(true, Ordering::Relaxed);
        }
    });

    // a client-only node can initiate a connection
    let conn_id = node
        .connect(raw_endpoint_addr, common::SERVER_NAME)
        .await
        .unwrap();

    // make sure that the connection was accepted by the endpoint
    assert!(conn_success_flag.load(Ordering::Relaxed));

    // check a node-side disconnect
    assert!(node.disconnect(conn_id, Default::default(), &[0]).await);
    assert!(node.get_connection(conn_id).is_none());
}

#[tokio::test]
async fn conns_client_plus_server() {
    // prepare the configs
    let (client_cfg, server_cfg) = common::client_and_server_config();

    // a node in client+server mode
    let node = common::TestNode(Node::new(Config::new(
        Some(client_cfg.clone()),
        Some(server_cfg.clone()),
    )));
    let node_addr = node.start("127.0.0.1:0".parse().unwrap()).await.unwrap();

    // a raw endpoint
    let raw_endpoint = common::raw_endpoint(client_cfg, server_cfg);
    let raw_endpoint_addr = raw_endpoint.local_addr().unwrap();

    // a client+server node can accept a connection
    assert!(raw_endpoint
        .connect(node_addr, common::SERVER_NAME)
        .unwrap()
        .await
        .is_ok());

    // a flag to indicate that the client connection was accepted
    let conn_success_flag: Arc<AtomicBool> = Default::default();

    // prepare to accept a connection at the raw endpoint
    let flag = conn_success_flag.clone();
    tokio::spawn(async move {
        if let Some(conn) = raw_endpoint.accept().await {
            conn.await.unwrap();
            flag.store(true, Ordering::Relaxed);
        }
    });

    // a client+server node can initiate a connection
    let conn_id = node
        .connect(raw_endpoint_addr, common::SERVER_NAME)
        .await
        .unwrap();

    // make sure that the connection was accepted by the endpoint
    assert!(conn_success_flag.load(Ordering::Relaxed));

    // check a node-side disconnect
    assert!(node.disconnect(conn_id, Default::default(), &[0]).await);
    assert!(node.get_connection(conn_id).is_none());

    // find the inbound connection
    let node_clone = node.clone();
    deadline!(Duration::from_secs(1), move || node_clone.num_connections()
        == 1);
    let conn_id = node.get_connections().pop().unwrap().stable_id();

    // check a node-side disconnect
    assert!(node.disconnect(conn_id, Default::default(), &[0]).await);
    assert!(node.get_connection(conn_id).is_none());
}