cobalt 0.22.0

Low level, UDP based networking library.
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

// Crates ---------------------------------------------------------------------
extern crate cobalt;


// Dependencies ---------------------------------------------------------------
use cobalt::{
    BinaryRateLimiter, Config, NoopPacketModifier, MessageKind, UdpSocket,
    Server, ServerEvent
};

fn main() {

    // Create a new server that communicates over a udp socket
    let mut server = Server::<
        UdpSocket,
        BinaryRateLimiter,
        NoopPacketModifier

    >::new(Config::default());

    // Make the server listen on port `1234` on all interfaces.
    println!("[Server] Listening...");
    server.listen("0.0.0.0:1234").expect("Failed to bind to socket.");

    'main: loop {

        // Accept incoming connections and fetch their events
        while let Ok(event) = server.accept_receive() {
            // Handle events (e.g. Connection, Messages, etc.)
            match event {
                ServerEvent::Connection(id) => {
                    let conn = server.connection(&id).unwrap();
                    println!(
                        "[Server] Client {} ({}, {}ms rtt) connected.",
                        id.0,
                        conn.peer_addr(),
                        conn.rtt()
                    );

                },
                ServerEvent::Message(id, message) => {
                    let conn = server.connection(&id).unwrap();
                    println!(
                        "[Server] Message from client {} ({}, {}ms rtt): {:?}",
                        id.0,
                        conn.peer_addr(),
                        conn.rtt(),
                        message
                    );

                },
                ServerEvent::ConnectionClosed(id, _) | ServerEvent::ConnectionLost(id, _) => {
                    let conn = server.connection(&id).unwrap();
                    println!(
                        "[Server] Client {} ({}, {}ms rtt) disconnected.",
                        id.0,
                        conn.peer_addr(),
                        conn.rtt()
                    );
                    break 'main;
                },
                _ => {}
            }
        }

        // Send a message to all connected clients
        for (_, conn) in server.connections() {
            conn.send(MessageKind::Instant, b"Hello from Server".to_vec());
        }

        // Send all outgoing messages.
        //
        // Also auto delay the current thread to achieve the configured tick rate.
        server.send(true).is_ok();

    }

    println!("[Server] Shutting down...");

    // Shutdown the server (freeing its socket and closing all its connections)
    server.shutdown().ok();

}