Struct NautServer 

pub struct NautServer { /* private fields */ }

Implementations

impl NautServer

pub fn new(config: ServerConfig) -> Self

pub fn get_client_addr(&self, id: &ConnectionId) -> Option<&SocketAddr>

Gets the client’s id from an address

pub fn get_client_id(&self, addr: &SocketAddr) -> Option<&ConnectionId>

Gets the client’s address from an id

Examples found in repository

examples/godot/godot_server.rs (line 11)

fn main() {
    let mut socket =
        NautSocket::<NautServer>::new("127.0.0.1:8008", ServerConfig::default()).unwrap();
    socket.register_plugin(LoggingPlugin);

    socket.on("join", move |socket, (addr, _packet)| {
        let client = socket.server().get_client_id(&addr);
        let _ = socket.send("hello", &[], PacketDelivery::Reliable, *client.unwrap());
    });

    loop {
        sleep(Duration::from_millis(1));
        socket.poll();
        socket.run_events();
    }
}

examples/chat/chat_server.rs (line 60)

fn on_send_message(socket: &mut NautSocket<'_, NautServer>, (addr, packet): (SocketAddr, &[u8])) {
    let Some(id) = socket.server().get_client_id(&addr) else {
        return;
    };

    let name = {
        let Some(chatters) = socket.get_persistent::<Chatters>() else {
            return;
        };
        let Ok(chatters) = chatters.read() else {
            return;
        };

        chatters.names.get(id).cloned()
    };

    let Some(name) = name else {
        return;
    };

    let msg = String::from_utf8(packet.to_vec()).unwrap();
    let string = format!("{}: {}", name, msg);
    let _ = socket.broadcast("recv_message", string.as_bytes(), PacketDelivery::Reliable);
}

fn create_new_chatter(
    socket: &mut NautSocket<'_, NautServer>,
    (addr, packet): (SocketAddr, &[u8]),
) {
    let Some(id) = socket.server().get_client_id(&addr) else {
        return;
    };

    let Some(chatters) = socket.get_persistent::<Chatters>() else {
        return;
    };

    let name = String::from_utf8(packet.to_vec()).unwrap();
    {
        let Ok(mut chatters) = chatters.write() else {
            return;
        };

        chatters.names.insert(*id, name.clone());
    }

    let join_msg = format!("Welcome {name}");

    let _ = socket.broadcast(
        "recv_message",
        join_msg.as_bytes(),
        PacketDelivery::Reliable,
    );
}

pub fn iter_server_events(&self) -> Iter<'_, ServerEvent>

Gets an iterator to all server events in the queue, this will not remove any from queue

Examples found in repository

examples/chat/chat_server.rs (line 41)

fn remove_chatters_on_disconnect(socket: &mut NautSocket<'_, NautServer>) {
    for event in socket.server().iter_server_events() {
        match event {
            ServerEvent::OnClientTimeout(id) | ServerEvent::OnClientDisconnected(id) => {
                let Some(chatters) = socket.get_persistent::<Chatters>() else {
                    return;
                };

                let Ok(mut chatters) = chatters.write() else {
                    return;
                };

                chatters.names.remove(id);
            }
            _ => {}
        }
    }
}

pub fn get_max_connections(&self) -> u8

Gets the max amount of connections the server can handle

pub fn get_current_connections(&self) -> u8

Gets the current amount of established connections

pub fn close_connection_with_client(&mut self, id: ConnectionId)

Closes a connection with a client and pushes a client disconnected event to the server events queue

Trait Implementations

impl Default for NautServer

fn default() -> Self

Returns the “default value” for a type.

impl SocketPlugin<'_, NautServer> for LoggingPlugin

fn register(&self, socket: &mut NautSocket<'_, NautServer>)

impl<'socket> SocketType<'socket> for NautServer

fn last_recv_seq_num_for_event( &'socket mut self, addr: &SocketAddr, event: &str, ) -> Option<&'socket mut SequenceNumber>

Returns a mutable reference to the last received sequence number, it should be changed to the newest sequence number if the last received sequence number is lower

fn update_current_send_seq_num_for_event( &mut self, addr: &SocketAddr, event: &str, ) -> Option<SequenceNumber>

Updates the current sequence number for that specific event and should be handled on a per client basis