turbulence 0.4.0

Tools to provide serialization, multiplexing, optional reliability, and optional compression to a game's networking.
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

use futures::{
    executor::LocalPool,
    future::{self, Either},
    task::SpawnExt,
    SinkExt, StreamExt,
};

use turbulence::{
    buffer::BufferPacketPool,
    packet::{Packet, PacketPool},
    packet_multiplexer::{MuxPacketPool, PacketMultiplexer},
};

mod util;

use self::util::SimpleBufferPool;

#[test]
fn test_multiplexer() {
    let mut pool = LocalPool::new();
    let spawner = pool.spawner();
    let packet_pool = MuxPacketPool::new(BufferPacketPool::new(SimpleBufferPool(32)));

    let mut multiplexer_a = PacketMultiplexer::new();
    let (mut sender4a, mut receiver4a, _) = multiplexer_a.open_channel(4, 8).unwrap();
    let (mut sender32a, mut receiver32a, _) = multiplexer_a.open_channel(32, 8).unwrap();

    let mut multiplexer_b = PacketMultiplexer::new();
    let (mut sender4b, mut receiver4b, _) = multiplexer_b.open_channel(4, 8).unwrap();
    let (mut sender32b, mut receiver32b, _) = multiplexer_b.open_channel(32, 8).unwrap();

    spawner
        .spawn(async move {
            let (mut a_incoming, mut a_outgoing) = multiplexer_a.start();
            let (mut b_incoming, mut b_outgoing) = multiplexer_b.start();
            loop {
                match future::select(a_outgoing.next(), b_outgoing.next()).await {
                    Either::Left((Some(packet), _)) => {
                        b_incoming.send(packet).await.unwrap();
                    }
                    Either::Right((Some(packet), _)) => {
                        a_incoming.send(packet).await.unwrap();
                    }
                    Either::Left((None, _)) | Either::Right((None, _)) => break,
                }
            }
        })
        .unwrap();

    spawner
        .spawn(async move {
            let mut packet = packet_pool.acquire();
            packet.resize(1, 17);
            sender4a.send(packet).await.unwrap();

            let mut packet = packet_pool.acquire();
            packet.resize(1, 18);
            sender4b.send(packet).await.unwrap();

            let mut packet = packet_pool.acquire();
            packet.resize(1, 19);
            sender32a.send(packet).await.unwrap();

            let mut packet = packet_pool.acquire();
            packet.resize(1, 20);
            sender32b.send(packet).await.unwrap();

            let packet = receiver4a.next().await.unwrap();
            assert_eq!(packet[0], 18);

            let packet = receiver4b.next().await.unwrap();
            assert_eq!(packet[0], 17);

            let packet = receiver32a.next().await.unwrap();
            assert_eq!(packet[0], 20);

            let packet = receiver32b.next().await.unwrap();
            assert_eq!(packet[0], 19);
        })
        .unwrap();

    pool.run();
}