Struct Server

pub struct Server<S: Socket, R: RateLimiter, M: PacketModifier> { /* private fields */ }

Implementation of a multi-client low latency socket server.

Basic Usage

use cobalt::{
    BinaryRateLimiter, Server, Config, NoopPacketModifier, MessageKind, UdpSocket
};

// 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.
server.listen("0.0.0.0:1234").expect("Failed to bind to socket.");

// loop {

    // Accept incoming connections and fetch their events
    while let Ok(event) = server.accept_receive() {
        // Handle events (e.g. Connection, Messages, etc.)
    }

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

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

// }

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

Implementations

impl<S: Socket, R: RateLimiter, M: PacketModifier> Server<S, R, M>

pub fn new(config: Config) -> Server<S, R, M>

Creates a new server with the given configuration.

Examples found in repository

examples/server.rs (lines 14-19)

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();

}

pub fn bytes_sent(&self) -> u32

Returns the number of bytes sent over the last second.

pub fn bytes_received(&self) -> u32

Returns the number of bytes received over the last second.

pub fn local_addr(&self) -> Result<SocketAddr, Error>

Returns the local address that the client is sending from.

pub fn connection( &mut self, id: &ConnectionID, ) -> Result<&mut Connection<R, M>, Error>

Returns a mutable reference to the specified client connection.

Examples found in repository

examples/server.rs (line 32)

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();

}

pub fn connections(&mut self) -> &mut HashMap<ConnectionID, Connection<R, M>>

Returns a mutable reference to the servers client connections.

Examples found in repository

examples/server.rs (line 67)

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();

}

pub fn socket(&mut self) -> Result<&mut S, Error>

Returns a mutable reference to the server’s underlying socket.

pub fn config(&self) -> Config

Returns the server’s current configuration.

pub fn set_config(&mut self, config: Config)

Overrides the server’s current configuration.

pub fn listen<A: ToSocketAddrs>(&mut self, addr: A) -> Result<(), Error>

Binds the server to listen the specified address.

Examples found in repository

examples/server.rs (line 23)

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();

}

pub fn accept_receive(&mut self) -> Result<ServerEvent, TryRecvError>

Accepts new incoming client connections from the server’s underlying server and receives and returns messages from them.

Examples found in repository

examples/server.rs (line 28)

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();

}

pub fn send(&mut self, auto_tick: bool) -> Result<(), Error>

Sends all queued messages to the server’s underlying client connections.

If auto_tick is specified as true this method will block the current thread for the amount of time which is required to limit the number of calls per second (when called inside a loop) to the server’s configured send_rate.

Examples found in repository

examples/server.rs (line 74)

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();

}

pub fn shutdown(&mut self) -> Result<(), Error>

Shuts down all of the server’s client connections, clearing any state and freeing the server’s socket.

Examples found in repository

examples/server.rs (line 81)

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();

}

Trait Implementations

impl<S: Debug + Socket, R: Debug + RateLimiter, M: Debug + PacketModifier> Debug for Server<S, R, M>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.