Struct Server 

pub struct Server<const BUFFER_SIZE: usize> { /* private fields */ }

Implementations

impl<const BUFFER_SIZE: usize> Server<BUFFER_SIZE>

pub fn bind( address: SocketAddr, read_timeout: Duration, ) -> Result<Self, ServerError>

Examples found in repository

examples/simple.rs (line 91)

fn spawn_server(protocol: Protocol) -> Result<(), ServerError> {
    println!("Starting server...");

    // Creating the server and binding it to a local address to listen on.
    let mut server: Server<BUFFER_SIZE> = Server::bind(SERVER_ADDRESS, READ_TIMEOUT)?;

    // Server loop.
    loop {
        // Check to see if the server is still running.
        if server.is_running() == false {
            break;
        }

        // Flush the server.
        //
        // I just now, as I was writing this comment, realized
        // that you are flushing using a handle to the underlying
        // TCP stream! Ha! Flushing... using a handle! :D
        server.flush()?;

        // There is a separate thread that accepts incoming client
        // connections, and this function simply gets a list of
        // any client IDs for clients that joined since the last call
        // of this function. If this function was never called, it
        // will return all clients, which means this function is guarenteed
        // to return all client IDs through out the runtime of the program.
        let new_clients = server.new_clients()?;

        // Just iterating through all the new clients and welcoming them.
        for client_id in new_clients {
            // This should always return Some(...) since the client ID
            // is guarenteed to be a valid client's ID.
            let client_info = server.get_client_info(client_id).unwrap();

            println!("New client {}: {}", client_id.id, client_info.client_address);
            server.send(
                client_id,
                protocol,
                format!(
                    "Hello client #{}! Your address is: {}",
                    client_id.id,
                    client_info.client_address,
                ).as_bytes(),
            )?;
        }

        // Iterate through every client connected to the server.
        for client_id in server.clients() {
            // If this returns false, this is most likely because the
            // server kicked this client in a previous iteration.
            if server.is_valid_client(client_id) == false {
                println!("Invalid client, skipping... (#{})", client_id.id);

                continue;
            }

            // Unlike the vanilla implementations of TCP and UDP in the standard libraries
            // of programming languages, this library's recv() function is non-blocking,
            // so it returns either data or nothing.
            // The read timeout (discussed earlier) is for the blocking recv() call in the
            // reading thread so the reading thread doesn't get stuck.
            if let Some((message_raw, message_size)) = server.recv(client_id, protocol)? {
                // The reason that a slice of the raw bytes as opposed to the whole
                // thing is being used is because the string will actually have a lot
                // of termination characters at the end since the raw bytes message
                // is the same size as the BUFFER_SIZE constant. So by passing a slice,
                // this string will only be made with bytes that were received as opposed
                // to the entire buffer.
                let message = String::from_utf8_lossy(&message_raw[..message_size]).to_string();

                println!("<Client #{}> {}", client_id.id, message);

                match message.as_str() {
                    "quit" => {
                        println!("Kicking client #{}...", client_id.id);
                        server.kick(client_id)?;
                    },
                    "stop" => {
                        println!("Stopping server...");
                        server.stop()?;
                    },
                    "protocol" => {
                        println!("Protocol: {:?}", protocol);
                    },
                    _ => (),
                };
            }
        }
    }

    Ok(())
}

pub fn address(&self) -> SocketAddr

Returns the address that the server is listening on this is the address that the server is bound to

pub fn get_client_info(&self, client_id: ClientID) -> Option<ServerClientInfo>

Return client information

Examples found in repository

examples/simple.rs (line 119)

fn spawn_server(protocol: Protocol) -> Result<(), ServerError> {
    println!("Starting server...");

    // Creating the server and binding it to a local address to listen on.
    let mut server: Server<BUFFER_SIZE> = Server::bind(SERVER_ADDRESS, READ_TIMEOUT)?;

    // Server loop.
    loop {
        // Check to see if the server is still running.
        if server.is_running() == false {
            break;
        }

        // Flush the server.
        //
        // I just now, as I was writing this comment, realized
        // that you are flushing using a handle to the underlying
        // TCP stream! Ha! Flushing... using a handle! :D
        server.flush()?;

        // There is a separate thread that accepts incoming client
        // connections, and this function simply gets a list of
        // any client IDs for clients that joined since the last call
        // of this function. If this function was never called, it
        // will return all clients, which means this function is guarenteed
        // to return all client IDs through out the runtime of the program.
        let new_clients = server.new_clients()?;

        // Just iterating through all the new clients and welcoming them.
        for client_id in new_clients {
            // This should always return Some(...) since the client ID
            // is guarenteed to be a valid client's ID.
            let client_info = server.get_client_info(client_id).unwrap();

            println!("New client {}: {}", client_id.id, client_info.client_address);
            server.send(
                client_id,
                protocol,
                format!(
                    "Hello client #{}! Your address is: {}",
                    client_id.id,
                    client_info.client_address,
                ).as_bytes(),
            )?;
        }

        // Iterate through every client connected to the server.
        for client_id in server.clients() {
            // If this returns false, this is most likely because the
            // server kicked this client in a previous iteration.
            if server.is_valid_client(client_id) == false {
                println!("Invalid client, skipping... (#{})", client_id.id);

                continue;
            }

            // Unlike the vanilla implementations of TCP and UDP in the standard libraries
            // of programming languages, this library's recv() function is non-blocking,
            // so it returns either data or nothing.
            // The read timeout (discussed earlier) is for the blocking recv() call in the
            // reading thread so the reading thread doesn't get stuck.
            if let Some((message_raw, message_size)) = server.recv(client_id, protocol)? {
                // The reason that a slice of the raw bytes as opposed to the whole
                // thing is being used is because the string will actually have a lot
                // of termination characters at the end since the raw bytes message
                // is the same size as the BUFFER_SIZE constant. So by passing a slice,
                // this string will only be made with bytes that were received as opposed
                // to the entire buffer.
                let message = String::from_utf8_lossy(&message_raw[..message_size]).to_string();

                println!("<Client #{}> {}", client_id.id, message);

                match message.as_str() {
                    "quit" => {
                        println!("Kicking client #{}...", client_id.id);
                        server.kick(client_id)?;
                    },
                    "stop" => {
                        println!("Stopping server...");
                        server.stop()?;
                    },
                    "protocol" => {
                        println!("Protocol: {:?}", protocol);
                    },
                    _ => (),
                };
            }
        }
    }

    Ok(())
}

pub fn is_valid_client(&self, client_id: ClientID) -> bool

Check whether or not a client id matches a valid connected client

Examples found in repository

examples/simple.rs (line 137)

fn spawn_server(protocol: Protocol) -> Result<(), ServerError> {
    println!("Starting server...");

    // Creating the server and binding it to a local address to listen on.
    let mut server: Server<BUFFER_SIZE> = Server::bind(SERVER_ADDRESS, READ_TIMEOUT)?;

    // Server loop.
    loop {
        // Check to see if the server is still running.
        if server.is_running() == false {
            break;
        }

        // Flush the server.
        //
        // I just now, as I was writing this comment, realized
        // that you are flushing using a handle to the underlying
        // TCP stream! Ha! Flushing... using a handle! :D
        server.flush()?;

        // There is a separate thread that accepts incoming client
        // connections, and this function simply gets a list of
        // any client IDs for clients that joined since the last call
        // of this function. If this function was never called, it
        // will return all clients, which means this function is guarenteed
        // to return all client IDs through out the runtime of the program.
        let new_clients = server.new_clients()?;

        // Just iterating through all the new clients and welcoming them.
        for client_id in new_clients {
            // This should always return Some(...) since the client ID
            // is guarenteed to be a valid client's ID.
            let client_info = server.get_client_info(client_id).unwrap();

            println!("New client {}: {}", client_id.id, client_info.client_address);
            server.send(
                client_id,
                protocol,
                format!(
                    "Hello client #{}! Your address is: {}",
                    client_id.id,
                    client_info.client_address,
                ).as_bytes(),
            )?;
        }

        // Iterate through every client connected to the server.
        for client_id in server.clients() {
            // If this returns false, this is most likely because the
            // server kicked this client in a previous iteration.
            if server.is_valid_client(client_id) == false {
                println!("Invalid client, skipping... (#{})", client_id.id);

                continue;
            }

            // Unlike the vanilla implementations of TCP and UDP in the standard libraries
            // of programming languages, this library's recv() function is non-blocking,
            // so it returns either data or nothing.
            // The read timeout (discussed earlier) is for the blocking recv() call in the
            // reading thread so the reading thread doesn't get stuck.
            if let Some((message_raw, message_size)) = server.recv(client_id, protocol)? {
                // The reason that a slice of the raw bytes as opposed to the whole
                // thing is being used is because the string will actually have a lot
                // of termination characters at the end since the raw bytes message
                // is the same size as the BUFFER_SIZE constant. So by passing a slice,
                // this string will only be made with bytes that were received as opposed
                // to the entire buffer.
                let message = String::from_utf8_lossy(&message_raw[..message_size]).to_string();

                println!("<Client #{}> {}", client_id.id, message);

                match message.as_str() {
                    "quit" => {
                        println!("Kicking client #{}...", client_id.id);
                        server.kick(client_id)?;
                    },
                    "stop" => {
                        println!("Stopping server...");
                        server.stop()?;
                    },
                    "protocol" => {
                        println!("Protocol: {:?}", protocol);
                    },
                    _ => (),
                };
            }
        }
    }

    Ok(())
}

pub fn clients(&self) -> Vec<ClientID>

Return all the connected client IDs

Examples found in repository

examples/simple.rs (line 134)

fn spawn_server(protocol: Protocol) -> Result<(), ServerError> {
    println!("Starting server...");

    // Creating the server and binding it to a local address to listen on.
    let mut server: Server<BUFFER_SIZE> = Server::bind(SERVER_ADDRESS, READ_TIMEOUT)?;

    // Server loop.
    loop {
        // Check to see if the server is still running.
        if server.is_running() == false {
            break;
        }

        // Flush the server.
        //
        // I just now, as I was writing this comment, realized
        // that you are flushing using a handle to the underlying
        // TCP stream! Ha! Flushing... using a handle! :D
        server.flush()?;

        // There is a separate thread that accepts incoming client
        // connections, and this function simply gets a list of
        // any client IDs for clients that joined since the last call
        // of this function. If this function was never called, it
        // will return all clients, which means this function is guarenteed
        // to return all client IDs through out the runtime of the program.
        let new_clients = server.new_clients()?;

        // Just iterating through all the new clients and welcoming them.
        for client_id in new_clients {
            // This should always return Some(...) since the client ID
            // is guarenteed to be a valid client's ID.
            let client_info = server.get_client_info(client_id).unwrap();

            println!("New client {}: {}", client_id.id, client_info.client_address);
            server.send(
                client_id,
                protocol,
                format!(
                    "Hello client #{}! Your address is: {}",
                    client_id.id,
                    client_info.client_address,
                ).as_bytes(),
            )?;
        }

        // Iterate through every client connected to the server.
        for client_id in server.clients() {
            // If this returns false, this is most likely because the
            // server kicked this client in a previous iteration.
            if server.is_valid_client(client_id) == false {
                println!("Invalid client, skipping... (#{})", client_id.id);

                continue;
            }

            // Unlike the vanilla implementations of TCP and UDP in the standard libraries
            // of programming languages, this library's recv() function is non-blocking,
            // so it returns either data or nothing.
            // The read timeout (discussed earlier) is for the blocking recv() call in the
            // reading thread so the reading thread doesn't get stuck.
            if let Some((message_raw, message_size)) = server.recv(client_id, protocol)? {
                // The reason that a slice of the raw bytes as opposed to the whole
                // thing is being used is because the string will actually have a lot
                // of termination characters at the end since the raw bytes message
                // is the same size as the BUFFER_SIZE constant. So by passing a slice,
                // this string will only be made with bytes that were received as opposed
                // to the entire buffer.
                let message = String::from_utf8_lossy(&message_raw[..message_size]).to_string();

                println!("<Client #{}> {}", client_id.id, message);

                match message.as_str() {
                    "quit" => {
                        println!("Kicking client #{}...", client_id.id);
                        server.kick(client_id)?;
                    },
                    "stop" => {
                        println!("Stopping server...");
                        server.stop()?;
                    },
                    "protocol" => {
                        println!("Protocol: {:?}", protocol);
                    },
                    _ => (),
                };
            }
        }
    }

    Ok(())
}

pub fn is_running(&self) -> bool

Returns true if the server is still running (not stopped)

Examples found in repository

examples/simple.rs (line 96)

fn spawn_server(protocol: Protocol) -> Result<(), ServerError> {
    println!("Starting server...");

    // Creating the server and binding it to a local address to listen on.
    let mut server: Server<BUFFER_SIZE> = Server::bind(SERVER_ADDRESS, READ_TIMEOUT)?;

    // Server loop.
    loop {
        // Check to see if the server is still running.
        if server.is_running() == false {
            break;
        }

        // Flush the server.
        //
        // I just now, as I was writing this comment, realized
        // that you are flushing using a handle to the underlying
        // TCP stream! Ha! Flushing... using a handle! :D
        server.flush()?;

        // There is a separate thread that accepts incoming client
        // connections, and this function simply gets a list of
        // any client IDs for clients that joined since the last call
        // of this function. If this function was never called, it
        // will return all clients, which means this function is guarenteed
        // to return all client IDs through out the runtime of the program.
        let new_clients = server.new_clients()?;

        // Just iterating through all the new clients and welcoming them.
        for client_id in new_clients {
            // This should always return Some(...) since the client ID
            // is guarenteed to be a valid client's ID.
            let client_info = server.get_client_info(client_id).unwrap();

            println!("New client {}: {}", client_id.id, client_info.client_address);
            server.send(
                client_id,
                protocol,
                format!(
                    "Hello client #{}! Your address is: {}",
                    client_id.id,
                    client_info.client_address,
                ).as_bytes(),
            )?;
        }

        // Iterate through every client connected to the server.
        for client_id in server.clients() {
            // If this returns false, this is most likely because the
            // server kicked this client in a previous iteration.
            if server.is_valid_client(client_id) == false {
                println!("Invalid client, skipping... (#{})", client_id.id);

                continue;
            }

            // Unlike the vanilla implementations of TCP and UDP in the standard libraries
            // of programming languages, this library's recv() function is non-blocking,
            // so it returns either data or nothing.
            // The read timeout (discussed earlier) is for the blocking recv() call in the
            // reading thread so the reading thread doesn't get stuck.
            if let Some((message_raw, message_size)) = server.recv(client_id, protocol)? {
                // The reason that a slice of the raw bytes as opposed to the whole
                // thing is being used is because the string will actually have a lot
                // of termination characters at the end since the raw bytes message
                // is the same size as the BUFFER_SIZE constant. So by passing a slice,
                // this string will only be made with bytes that were received as opposed
                // to the entire buffer.
                let message = String::from_utf8_lossy(&message_raw[..message_size]).to_string();

                println!("<Client #{}> {}", client_id.id, message);

                match message.as_str() {
                    "quit" => {
                        println!("Kicking client #{}...", client_id.id);
                        server.kick(client_id)?;
                    },
                    "stop" => {
                        println!("Stopping server...");
                        server.stop()?;
                    },
                    "protocol" => {
                        println!("Protocol: {:?}", protocol);
                    },
                    _ => (),
                };
            }
        }
    }

    Ok(())
}

pub fn stop(&mut self) -> Result<(), ServerError>

Stops the server

Examples found in repository

examples/simple.rs (line 166)

fn spawn_server(protocol: Protocol) -> Result<(), ServerError> {
    println!("Starting server...");

    // Creating the server and binding it to a local address to listen on.
    let mut server: Server<BUFFER_SIZE> = Server::bind(SERVER_ADDRESS, READ_TIMEOUT)?;

    // Server loop.
    loop {
        // Check to see if the server is still running.
        if server.is_running() == false {
            break;
        }

        // Flush the server.
        //
        // I just now, as I was writing this comment, realized
        // that you are flushing using a handle to the underlying
        // TCP stream! Ha! Flushing... using a handle! :D
        server.flush()?;

        // There is a separate thread that accepts incoming client
        // connections, and this function simply gets a list of
        // any client IDs for clients that joined since the last call
        // of this function. If this function was never called, it
        // will return all clients, which means this function is guarenteed
        // to return all client IDs through out the runtime of the program.
        let new_clients = server.new_clients()?;

        // Just iterating through all the new clients and welcoming them.
        for client_id in new_clients {
            // This should always return Some(...) since the client ID
            // is guarenteed to be a valid client's ID.
            let client_info = server.get_client_info(client_id).unwrap();

            println!("New client {}: {}", client_id.id, client_info.client_address);
            server.send(
                client_id,
                protocol,
                format!(
                    "Hello client #{}! Your address is: {}",
                    client_id.id,
                    client_info.client_address,
                ).as_bytes(),
            )?;
        }

        // Iterate through every client connected to the server.
        for client_id in server.clients() {
            // If this returns false, this is most likely because the
            // server kicked this client in a previous iteration.
            if server.is_valid_client(client_id) == false {
                println!("Invalid client, skipping... (#{})", client_id.id);

                continue;
            }

            // Unlike the vanilla implementations of TCP and UDP in the standard libraries
            // of programming languages, this library's recv() function is non-blocking,
            // so it returns either data or nothing.
            // The read timeout (discussed earlier) is for the blocking recv() call in the
            // reading thread so the reading thread doesn't get stuck.
            if let Some((message_raw, message_size)) = server.recv(client_id, protocol)? {
                // The reason that a slice of the raw bytes as opposed to the whole
                // thing is being used is because the string will actually have a lot
                // of termination characters at the end since the raw bytes message
                // is the same size as the BUFFER_SIZE constant. So by passing a slice,
                // this string will only be made with bytes that were received as opposed
                // to the entire buffer.
                let message = String::from_utf8_lossy(&message_raw[..message_size]).to_string();

                println!("<Client #{}> {}", client_id.id, message);

                match message.as_str() {
                    "quit" => {
                        println!("Kicking client #{}...", client_id.id);
                        server.kick(client_id)?;
                    },
                    "stop" => {
                        println!("Stopping server...");
                        server.stop()?;
                    },
                    "protocol" => {
                        println!("Protocol: {:?}", protocol);
                    },
                    _ => (),
                };
            }
        }
    }

    Ok(())
}

pub fn send( &self, client_id: ClientID, protocol: Protocol, data: &[u8], ) -> Result<(), ServerError>

Send data to a client

Examples found in repository

examples/simple.rs (lines 122-130)

fn spawn_server(protocol: Protocol) -> Result<(), ServerError> {
    println!("Starting server...");

    // Creating the server and binding it to a local address to listen on.
    let mut server: Server<BUFFER_SIZE> = Server::bind(SERVER_ADDRESS, READ_TIMEOUT)?;

    // Server loop.
    loop {
        // Check to see if the server is still running.
        if server.is_running() == false {
            break;
        }

        // Flush the server.
        //
        // I just now, as I was writing this comment, realized
        // that you are flushing using a handle to the underlying
        // TCP stream! Ha! Flushing... using a handle! :D
        server.flush()?;

        // There is a separate thread that accepts incoming client
        // connections, and this function simply gets a list of
        // any client IDs for clients that joined since the last call
        // of this function. If this function was never called, it
        // will return all clients, which means this function is guarenteed
        // to return all client IDs through out the runtime of the program.
        let new_clients = server.new_clients()?;

        // Just iterating through all the new clients and welcoming them.
        for client_id in new_clients {
            // This should always return Some(...) since the client ID
            // is guarenteed to be a valid client's ID.
            let client_info = server.get_client_info(client_id).unwrap();

            println!("New client {}: {}", client_id.id, client_info.client_address);
            server.send(
                client_id,
                protocol,
                format!(
                    "Hello client #{}! Your address is: {}",
                    client_id.id,
                    client_info.client_address,
                ).as_bytes(),
            )?;
        }

        // Iterate through every client connected to the server.
        for client_id in server.clients() {
            // If this returns false, this is most likely because the
            // server kicked this client in a previous iteration.
            if server.is_valid_client(client_id) == false {
                println!("Invalid client, skipping... (#{})", client_id.id);

                continue;
            }

            // Unlike the vanilla implementations of TCP and UDP in the standard libraries
            // of programming languages, this library's recv() function is non-blocking,
            // so it returns either data or nothing.
            // The read timeout (discussed earlier) is for the blocking recv() call in the
            // reading thread so the reading thread doesn't get stuck.
            if let Some((message_raw, message_size)) = server.recv(client_id, protocol)? {
                // The reason that a slice of the raw bytes as opposed to the whole
                // thing is being used is because the string will actually have a lot
                // of termination characters at the end since the raw bytes message
                // is the same size as the BUFFER_SIZE constant. So by passing a slice,
                // this string will only be made with bytes that were received as opposed
                // to the entire buffer.
                let message = String::from_utf8_lossy(&message_raw[..message_size]).to_string();

                println!("<Client #{}> {}", client_id.id, message);

                match message.as_str() {
                    "quit" => {
                        println!("Kicking client #{}...", client_id.id);
                        server.kick(client_id)?;
                    },
                    "stop" => {
                        println!("Stopping server...");
                        server.stop()?;
                    },
                    "protocol" => {
                        println!("Protocol: {:?}", protocol);
                    },
                    _ => (),
                };
            }
        }
    }

    Ok(())
}

pub fn recv( &self, client_id: ClientID, protocol: Protocol, ) -> Result<Option<([u8; BUFFER_SIZE], usize)>, ServerError>

Receive data from a client and also return the size

Examples found in repository

examples/simple.rs (line 148)

fn spawn_server(protocol: Protocol) -> Result<(), ServerError> {
    println!("Starting server...");

    // Creating the server and binding it to a local address to listen on.
    let mut server: Server<BUFFER_SIZE> = Server::bind(SERVER_ADDRESS, READ_TIMEOUT)?;

    // Server loop.
    loop {
        // Check to see if the server is still running.
        if server.is_running() == false {
            break;
        }

        // Flush the server.
        //
        // I just now, as I was writing this comment, realized
        // that you are flushing using a handle to the underlying
        // TCP stream! Ha! Flushing... using a handle! :D
        server.flush()?;

        // There is a separate thread that accepts incoming client
        // connections, and this function simply gets a list of
        // any client IDs for clients that joined since the last call
        // of this function. If this function was never called, it
        // will return all clients, which means this function is guarenteed
        // to return all client IDs through out the runtime of the program.
        let new_clients = server.new_clients()?;

        // Just iterating through all the new clients and welcoming them.
        for client_id in new_clients {
            // This should always return Some(...) since the client ID
            // is guarenteed to be a valid client's ID.
            let client_info = server.get_client_info(client_id).unwrap();

            println!("New client {}: {}", client_id.id, client_info.client_address);
            server.send(
                client_id,
                protocol,
                format!(
                    "Hello client #{}! Your address is: {}",
                    client_id.id,
                    client_info.client_address,
                ).as_bytes(),
            )?;
        }

        // Iterate through every client connected to the server.
        for client_id in server.clients() {
            // If this returns false, this is most likely because the
            // server kicked this client in a previous iteration.
            if server.is_valid_client(client_id) == false {
                println!("Invalid client, skipping... (#{})", client_id.id);

                continue;
            }

            // Unlike the vanilla implementations of TCP and UDP in the standard libraries
            // of programming languages, this library's recv() function is non-blocking,
            // so it returns either data or nothing.
            // The read timeout (discussed earlier) is for the blocking recv() call in the
            // reading thread so the reading thread doesn't get stuck.
            if let Some((message_raw, message_size)) = server.recv(client_id, protocol)? {
                // The reason that a slice of the raw bytes as opposed to the whole
                // thing is being used is because the string will actually have a lot
                // of termination characters at the end since the raw bytes message
                // is the same size as the BUFFER_SIZE constant. So by passing a slice,
                // this string will only be made with bytes that were received as opposed
                // to the entire buffer.
                let message = String::from_utf8_lossy(&message_raw[..message_size]).to_string();

                println!("<Client #{}> {}", client_id.id, message);

                match message.as_str() {
                    "quit" => {
                        println!("Kicking client #{}...", client_id.id);
                        server.kick(client_id)?;
                    },
                    "stop" => {
                        println!("Stopping server...");
                        server.stop()?;
                    },
                    "protocol" => {
                        println!("Protocol: {:?}", protocol);
                    },
                    _ => (),
                };
            }
        }
    }

    Ok(())
}

pub fn flush(&self) -> Result<(), ServerError>

Flush all queued tasks

Examples found in repository

examples/simple.rs (line 105)

fn spawn_server(protocol: Protocol) -> Result<(), ServerError> {
    println!("Starting server...");

    // Creating the server and binding it to a local address to listen on.
    let mut server: Server<BUFFER_SIZE> = Server::bind(SERVER_ADDRESS, READ_TIMEOUT)?;

    // Server loop.
    loop {
        // Check to see if the server is still running.
        if server.is_running() == false {
            break;
        }

        // Flush the server.
        //
        // I just now, as I was writing this comment, realized
        // that you are flushing using a handle to the underlying
        // TCP stream! Ha! Flushing... using a handle! :D
        server.flush()?;

        // There is a separate thread that accepts incoming client
        // connections, and this function simply gets a list of
        // any client IDs for clients that joined since the last call
        // of this function. If this function was never called, it
        // will return all clients, which means this function is guarenteed
        // to return all client IDs through out the runtime of the program.
        let new_clients = server.new_clients()?;

        // Just iterating through all the new clients and welcoming them.
        for client_id in new_clients {
            // This should always return Some(...) since the client ID
            // is guarenteed to be a valid client's ID.
            let client_info = server.get_client_info(client_id).unwrap();

            println!("New client {}: {}", client_id.id, client_info.client_address);
            server.send(
                client_id,
                protocol,
                format!(
                    "Hello client #{}! Your address is: {}",
                    client_id.id,
                    client_info.client_address,
                ).as_bytes(),
            )?;
        }

        // Iterate through every client connected to the server.
        for client_id in server.clients() {
            // If this returns false, this is most likely because the
            // server kicked this client in a previous iteration.
            if server.is_valid_client(client_id) == false {
                println!("Invalid client, skipping... (#{})", client_id.id);

                continue;
            }

            // Unlike the vanilla implementations of TCP and UDP in the standard libraries
            // of programming languages, this library's recv() function is non-blocking,
            // so it returns either data or nothing.
            // The read timeout (discussed earlier) is for the blocking recv() call in the
            // reading thread so the reading thread doesn't get stuck.
            if let Some((message_raw, message_size)) = server.recv(client_id, protocol)? {
                // The reason that a slice of the raw bytes as opposed to the whole
                // thing is being used is because the string will actually have a lot
                // of termination characters at the end since the raw bytes message
                // is the same size as the BUFFER_SIZE constant. So by passing a slice,
                // this string will only be made with bytes that were received as opposed
                // to the entire buffer.
                let message = String::from_utf8_lossy(&message_raw[..message_size]).to_string();

                println!("<Client #{}> {}", client_id.id, message);

                match message.as_str() {
                    "quit" => {
                        println!("Kicking client #{}...", client_id.id);
                        server.kick(client_id)?;
                    },
                    "stop" => {
                        println!("Stopping server...");
                        server.stop()?;
                    },
                    "protocol" => {
                        println!("Protocol: {:?}", protocol);
                    },
                    _ => (),
                };
            }
        }
    }

    Ok(())
}

pub fn kick(&mut self, client_id: ClientID) -> Result<(), ServerError>

Kick a client

Examples found in repository

examples/simple.rs (line 162)

fn spawn_server(protocol: Protocol) -> Result<(), ServerError> {
    println!("Starting server...");

    // Creating the server and binding it to a local address to listen on.
    let mut server: Server<BUFFER_SIZE> = Server::bind(SERVER_ADDRESS, READ_TIMEOUT)?;

    // Server loop.
    loop {
        // Check to see if the server is still running.
        if server.is_running() == false {
            break;
        }

        // Flush the server.
        //
        // I just now, as I was writing this comment, realized
        // that you are flushing using a handle to the underlying
        // TCP stream! Ha! Flushing... using a handle! :D
        server.flush()?;

        // There is a separate thread that accepts incoming client
        // connections, and this function simply gets a list of
        // any client IDs for clients that joined since the last call
        // of this function. If this function was never called, it
        // will return all clients, which means this function is guarenteed
        // to return all client IDs through out the runtime of the program.
        let new_clients = server.new_clients()?;

        // Just iterating through all the new clients and welcoming them.
        for client_id in new_clients {
            // This should always return Some(...) since the client ID
            // is guarenteed to be a valid client's ID.
            let client_info = server.get_client_info(client_id).unwrap();

            println!("New client {}: {}", client_id.id, client_info.client_address);
            server.send(
                client_id,
                protocol,
                format!(
                    "Hello client #{}! Your address is: {}",
                    client_id.id,
                    client_info.client_address,
                ).as_bytes(),
            )?;
        }

        // Iterate through every client connected to the server.
        for client_id in server.clients() {
            // If this returns false, this is most likely because the
            // server kicked this client in a previous iteration.
            if server.is_valid_client(client_id) == false {
                println!("Invalid client, skipping... (#{})", client_id.id);

                continue;
            }

            // Unlike the vanilla implementations of TCP and UDP in the standard libraries
            // of programming languages, this library's recv() function is non-blocking,
            // so it returns either data or nothing.
            // The read timeout (discussed earlier) is for the blocking recv() call in the
            // reading thread so the reading thread doesn't get stuck.
            if let Some((message_raw, message_size)) = server.recv(client_id, protocol)? {
                // The reason that a slice of the raw bytes as opposed to the whole
                // thing is being used is because the string will actually have a lot
                // of termination characters at the end since the raw bytes message
                // is the same size as the BUFFER_SIZE constant. So by passing a slice,
                // this string will only be made with bytes that were received as opposed
                // to the entire buffer.
                let message = String::from_utf8_lossy(&message_raw[..message_size]).to_string();

                println!("<Client #{}> {}", client_id.id, message);

                match message.as_str() {
                    "quit" => {
                        println!("Kicking client #{}...", client_id.id);
                        server.kick(client_id)?;
                    },
                    "stop" => {
                        println!("Stopping server...");
                        server.stop()?;
                    },
                    "protocol" => {
                        println!("Protocol: {:?}", protocol);
                    },
                    _ => (),
                };
            }
        }
    }

    Ok(())
}

pub fn new_clients(&mut self) -> Result<Vec<ClientID>, ServerError>

Returns new clients’ IDs

Examples found in repository

examples/simple.rs (line 113)

fn spawn_server(protocol: Protocol) -> Result<(), ServerError> {
    println!("Starting server...");

    // Creating the server and binding it to a local address to listen on.
    let mut server: Server<BUFFER_SIZE> = Server::bind(SERVER_ADDRESS, READ_TIMEOUT)?;

    // Server loop.
    loop {
        // Check to see if the server is still running.
        if server.is_running() == false {
            break;
        }

        // Flush the server.
        //
        // I just now, as I was writing this comment, realized
        // that you are flushing using a handle to the underlying
        // TCP stream! Ha! Flushing... using a handle! :D
        server.flush()?;

        // There is a separate thread that accepts incoming client
        // connections, and this function simply gets a list of
        // any client IDs for clients that joined since the last call
        // of this function. If this function was never called, it
        // will return all clients, which means this function is guarenteed
        // to return all client IDs through out the runtime of the program.
        let new_clients = server.new_clients()?;

        // Just iterating through all the new clients and welcoming them.
        for client_id in new_clients {
            // This should always return Some(...) since the client ID
            // is guarenteed to be a valid client's ID.
            let client_info = server.get_client_info(client_id).unwrap();

            println!("New client {}: {}", client_id.id, client_info.client_address);
            server.send(
                client_id,
                protocol,
                format!(
                    "Hello client #{}! Your address is: {}",
                    client_id.id,
                    client_info.client_address,
                ).as_bytes(),
            )?;
        }

        // Iterate through every client connected to the server.
        for client_id in server.clients() {
            // If this returns false, this is most likely because the
            // server kicked this client in a previous iteration.
            if server.is_valid_client(client_id) == false {
                println!("Invalid client, skipping... (#{})", client_id.id);

                continue;
            }

            // Unlike the vanilla implementations of TCP and UDP in the standard libraries
            // of programming languages, this library's recv() function is non-blocking,
            // so it returns either data or nothing.
            // The read timeout (discussed earlier) is for the blocking recv() call in the
            // reading thread so the reading thread doesn't get stuck.
            if let Some((message_raw, message_size)) = server.recv(client_id, protocol)? {
                // The reason that a slice of the raw bytes as opposed to the whole
                // thing is being used is because the string will actually have a lot
                // of termination characters at the end since the raw bytes message
                // is the same size as the BUFFER_SIZE constant. So by passing a slice,
                // this string will only be made with bytes that were received as opposed
                // to the entire buffer.
                let message = String::from_utf8_lossy(&message_raw[..message_size]).to_string();

                println!("<Client #{}> {}", client_id.id, message);

                match message.as_str() {
                    "quit" => {
                        println!("Kicking client #{}...", client_id.id);
                        server.kick(client_id)?;
                    },
                    "stop" => {
                        println!("Stopping server...");
                        server.stop()?;
                    },
                    "protocol" => {
                        println!("Protocol: {:?}", protocol);
                    },
                    _ => (),
                };
            }
        }
    }

    Ok(())
}

Trait Implementations

impl<const BUFFER_SIZE: usize> Debug for Server<BUFFER_SIZE>

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

Formats the value using the given formatter.