simple/

simple.rs

use spunet::{
    Protocol,
    client::{
        Client,
        ClientError,
    },
    server::{
        Server,
        ServerError,
    },
};
use std::net::{
    SocketAddr,
    IpAddr,
    Ipv4Addr,
};
use std::time::Duration;
use std::io::{ self, Write };

// Server address stuff.
const SERVER_IP: IpAddr = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
const SERVER_PORT: u16 = 6969;
const SERVER_ADDRESS: SocketAddr = SocketAddr::new(SERVER_IP, SERVER_PORT);

// Buffer size for received messages.
const BUFFER_SIZE: usize = 1024;

// Timeout for reading messages on the receiving thread
// (this library runs parallel threads for reading which is a blocking operation).
// This should be set to something small if you want to receive
// messages quickly, but it shouldn't be zero since that
// doesn't even give the receiver a chance to receive.
const READ_TIMEOUT: Duration = Duration::from_nanos(1);

// Optional timeout for when a client is connecting to a server.
const CONNECTION_TIMEOUT: Option<Duration> = None;

fn main() {
    let args: Vec<String> = std::env::args().collect();

    if args.len() == 2 {
        let protocol = match input("Protocol [tcp/udp]: ").to_lowercase().as_str() {
            "tcp" => Protocol::TCP,
            "udp" => Protocol::UDP,
            _ => {
                eprintln!("Invalid protocol! Please choose either TCP or UDP!");

                std::process::exit(1);
            },
        };

        match args[1].as_str() {
            "server" => spawn_server(protocol).unwrap(),
            "client" => spawn_client(protocol).unwrap(),
            _ => {
                eprintln!("Invalid option: {}", args[1]);

                std::process::exit(1);
            },
        };
    }

    else {
        eprintln!("Usage: {} <COMMAND>", args[0]);
        eprintln!("");
        eprintln!("Commands:");
        eprintln!("  server ... Spawn the server.");
        eprintln!("  client ... Spawn a client and connect to the server.");

        std::process::exit(1);
    }
}

fn input(prefix: &str) -> String {
    print!("{}", prefix);

    io::stdout().flush().unwrap();

    let mut user_input = String::new();

    io::stdin().read_line(&mut user_input).unwrap();

    return user_input.trim().to_string();
}

// This function is what spawns the server for this example.
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(())
}

// This function is what spawns a client for this example.
fn spawn_client(protocol: Protocol) -> Result<(), ClientError> {
    println!("Creating a client...");

    // Pretty self-explanatory, just creating a client. :)
    let mut client: Client<BUFFER_SIZE> = Client::new(READ_TIMEOUT);

    println!("Connecting to server... ({})", SERVER_ADDRESS);
    client.connect(SERVER_ADDRESS, CONNECTION_TIMEOUT)?;
    client.send(protocol, "Hello, server!".as_bytes())?;
    client.flush()?; // Send the message immediately by flushing the client.

    loop {
        // Check whether or not the client is still connected.
        if client.is_connected() == false {
            break;
        }

        // Flush the client.
        client.flush()?;

        // Pretty much the same as the server example.
        if let Some((message_raw, message_size)) = client.recv(protocol)? {
            let message = String::from_utf8_lossy(&message_raw[..message_size]).to_string();

            println!("<Server> {}", message);
        }

        let user_message = input("[ Message To Server ]: ");

        client.send(protocol, user_message.as_bytes())?;

        match user_message.as_str() {
            "quit" => {
                client.disconnect()?; // This needs to be handled client-side too,
                                      // since TCP and UDP (vanilla implementations)
                                      // do not let the clients know that they have
                                      // been disconnected. Clients also don't let
                                      // the server know that they have disconnected.
            },
            "stop" => {
                println!("Sent stop request to server...");
                client.disconnect()?; // Same reason as the above comment. ^
            },
            "protocol" => {
                println!("Protocol: {:?}", protocol);
            },
            _ => {
                if let Ok(times) = user_message.parse::<usize>() {
                    for _ in 0..times {
                        client.send(protocol, "Ping!".as_bytes())?;
                    }
                }
            },
        };
    }

    Ok(())
}