NautSocket

nautilus_sockets::socket

Struct NautSocket 

Source 
pub struct NautSocket<'socket, S>
where
    S: SocketType<'socket>,
{ /* private fields */ }

Implementations§

Source§

impl<'socket> NautSocket<'socket, NautClient>

Source

pub fn new<A>(addr: A) -> Result<Self>
where A: ToSocketAddrs,

Creates a new event listening socket with a client type

Examples found in repository?
examples/chat/chat_client.rs (line 11)
9fn main() {
10    let socket = Arc::new(RwLock::new(
11        NautSocket::<NautClient>::new("127.0.0.1:0").unwrap(),
12    ));
13
14    let mut name: Option<String> = None;
15    {
16        let Ok(mut socket) = socket.write() else {
17            return;
18        };
19
20        socket.connect_to("127.0.0.1:8008").unwrap();
21
22        socket.on("recv_message", |_client, (_addr, bytes)| {
23            let msg = String::from_utf8(bytes.to_vec()).unwrap();
24            println!("{}", msg);
25        });
26    }
27
28    let socket_clone = Arc::clone(&socket);
29    // Separate thread as input blocks
30    std::thread::spawn(move || loop {
31        std::thread::sleep(Duration::from_millis(1));
32
33        let Ok(mut socket) = socket_clone.write() else {
34            continue;
35        };
36
37        // Must be run for every socket
38        socket.poll();
39        socket.run_events();
40    });
41
42    loop {
43        if name.as_ref().is_none() {
44            let mut s = String::new();
45            println!("Enter your name: ");
46            stdin().read_line(&mut s).expect("Invalid string");
47
48            if let Some('\n') = s.chars().next_back() {
49                s.pop();
50            }
51
52            if let Some('\r') = s.chars().next_back() {
53                s.pop();
54            }
55
56            name = Some(s.clone());
57
58            // Get write lock after getting input, shortest time for it in scope
59            let Ok(mut client) = socket.write() else {
60                continue;
61            };
62            let _ = client.send("new_messenger", s.as_bytes(), PacketDelivery::Reliable);
63            continue;
64        }
65
66        let mut s = String::new();
67        stdin().read_line(&mut s).expect("Invalid string");
68
69        if let Some('\n') = s.chars().next_back() {
70            s.pop();
71        }
72
73        if let Some('\r') = s.chars().next_back() {
74            s.pop();
75        }
76
77        // Get write lock after getting input, shortest time for it in scope
78        let Ok(mut client) = socket.write() else {
79            continue;
80        };
81        let _ = client.send("send_message", s.as_bytes(), PacketDelivery::Reliable);
82    }
83}
Source

pub fn get_server_address(&self) -> Option<&SocketAddr>

Gets the address of the (server)crate::server::NautServer we are connected to

Source

pub fn connect_to<A>(&mut self, addr: A) -> Result<()>
where A: ToSocketAddrs + Into<String> + Clone,

Establishes a connection to another nautilus compatible socket

Examples found in repository?
examples/chat/chat_client.rs (line 20)
9fn main() {
10    let socket = Arc::new(RwLock::new(
11        NautSocket::<NautClient>::new("127.0.0.1:0").unwrap(),
12    ));
13
14    let mut name: Option<String> = None;
15    {
16        let Ok(mut socket) = socket.write() else {
17            return;
18        };
19
20        socket.connect_to("127.0.0.1:8008").unwrap();
21
22        socket.on("recv_message", |_client, (_addr, bytes)| {
23            let msg = String::from_utf8(bytes.to_vec()).unwrap();
24            println!("{}", msg);
25        });
26    }
27
28    let socket_clone = Arc::clone(&socket);
29    // Separate thread as input blocks
30    std::thread::spawn(move || loop {
31        std::thread::sleep(Duration::from_millis(1));
32
33        let Ok(mut socket) = socket_clone.write() else {
34            continue;
35        };
36
37        // Must be run for every socket
38        socket.poll();
39        socket.run_events();
40    });
41
42    loop {
43        if name.as_ref().is_none() {
44            let mut s = String::new();
45            println!("Enter your name: ");
46            stdin().read_line(&mut s).expect("Invalid string");
47
48            if let Some('\n') = s.chars().next_back() {
49                s.pop();
50            }
51
52            if let Some('\r') = s.chars().next_back() {
53                s.pop();
54            }
55
56            name = Some(s.clone());
57
58            // Get write lock after getting input, shortest time for it in scope
59            let Ok(mut client) = socket.write() else {
60                continue;
61            };
62            let _ = client.send("new_messenger", s.as_bytes(), PacketDelivery::Reliable);
63            continue;
64        }
65
66        let mut s = String::new();
67        stdin().read_line(&mut s).expect("Invalid string");
68
69        if let Some('\n') = s.chars().next_back() {
70            s.pop();
71        }
72
73        if let Some('\r') = s.chars().next_back() {
74            s.pop();
75        }
76
77        // Get write lock after getting input, shortest time for it in scope
78        let Ok(mut client) = socket.write() else {
79            continue;
80        };
81        let _ = client.send("send_message", s.as_bytes(), PacketDelivery::Reliable);
82    }
83}
Source

pub fn send( &mut self, event: &str, buf: &[u8], delivery: PacketDelivery, ) -> Result<()>

Sends an event message to the server we are connected to

Examples found in repository?
examples/chat/chat_client.rs (line 62)
9fn main() {
10    let socket = Arc::new(RwLock::new(
11        NautSocket::<NautClient>::new("127.0.0.1:0").unwrap(),
12    ));
13
14    let mut name: Option<String> = None;
15    {
16        let Ok(mut socket) = socket.write() else {
17            return;
18        };
19
20        socket.connect_to("127.0.0.1:8008").unwrap();
21
22        socket.on("recv_message", |_client, (_addr, bytes)| {
23            let msg = String::from_utf8(bytes.to_vec()).unwrap();
24            println!("{}", msg);
25        });
26    }
27
28    let socket_clone = Arc::clone(&socket);
29    // Separate thread as input blocks
30    std::thread::spawn(move || loop {
31        std::thread::sleep(Duration::from_millis(1));
32
33        let Ok(mut socket) = socket_clone.write() else {
34            continue;
35        };
36
37        // Must be run for every socket
38        socket.poll();
39        socket.run_events();
40    });
41
42    loop {
43        if name.as_ref().is_none() {
44            let mut s = String::new();
45            println!("Enter your name: ");
46            stdin().read_line(&mut s).expect("Invalid string");
47
48            if let Some('\n') = s.chars().next_back() {
49                s.pop();
50            }
51
52            if let Some('\r') = s.chars().next_back() {
53                s.pop();
54            }
55
56            name = Some(s.clone());
57
58            // Get write lock after getting input, shortest time for it in scope
59            let Ok(mut client) = socket.write() else {
60                continue;
61            };
62            let _ = client.send("new_messenger", s.as_bytes(), PacketDelivery::Reliable);
63            continue;
64        }
65
66        let mut s = String::new();
67        stdin().read_line(&mut s).expect("Invalid string");
68
69        if let Some('\n') = s.chars().next_back() {
70            s.pop();
71        }
72
73        if let Some('\r') = s.chars().next_back() {
74            s.pop();
75        }
76
77        // Get write lock after getting input, shortest time for it in scope
78        let Ok(mut client) = socket.write() else {
79            continue;
80        };
81        let _ = client.send("send_message", s.as_bytes(), PacketDelivery::Reliable);
82    }
83}
Source

pub fn run_events(&mut self)

Gets the packets from the packet queue and will handle returning ack packets, resolving sequenced packets and emitting listening events

Examples found in repository?
examples/chat/chat_client.rs (line 39)
9fn main() {
10    let socket = Arc::new(RwLock::new(
11        NautSocket::<NautClient>::new("127.0.0.1:0").unwrap(),
12    ));
13
14    let mut name: Option<String> = None;
15    {
16        let Ok(mut socket) = socket.write() else {
17            return;
18        };
19
20        socket.connect_to("127.0.0.1:8008").unwrap();
21
22        socket.on("recv_message", |_client, (_addr, bytes)| {
23            let msg = String::from_utf8(bytes.to_vec()).unwrap();
24            println!("{}", msg);
25        });
26    }
27
28    let socket_clone = Arc::clone(&socket);
29    // Separate thread as input blocks
30    std::thread::spawn(move || loop {
31        std::thread::sleep(Duration::from_millis(1));
32
33        let Ok(mut socket) = socket_clone.write() else {
34            continue;
35        };
36
37        // Must be run for every socket
38        socket.poll();
39        socket.run_events();
40    });
41
42    loop {
43        if name.as_ref().is_none() {
44            let mut s = String::new();
45            println!("Enter your name: ");
46            stdin().read_line(&mut s).expect("Invalid string");
47
48            if let Some('\n') = s.chars().next_back() {
49                s.pop();
50            }
51
52            if let Some('\r') = s.chars().next_back() {
53                s.pop();
54            }
55
56            name = Some(s.clone());
57
58            // Get write lock after getting input, shortest time for it in scope
59            let Ok(mut client) = socket.write() else {
60                continue;
61            };
62            let _ = client.send("new_messenger", s.as_bytes(), PacketDelivery::Reliable);
63            continue;
64        }
65
66        let mut s = String::new();
67        stdin().read_line(&mut s).expect("Invalid string");
68
69        if let Some('\n') = s.chars().next_back() {
70            s.pop();
71        }
72
73        if let Some('\r') = s.chars().next_back() {
74            s.pop();
75        }
76
77        // Get write lock after getting input, shortest time for it in scope
78        let Ok(mut client) = socket.write() else {
79            continue;
80        };
81        let _ = client.send("send_message", s.as_bytes(), PacketDelivery::Reliable);
82    }
83}
Source§

impl<'socket> NautSocket<'socket, NautServer>

Source

pub fn new<A>(addr: A, config: ServerConfig) -> Result<Self>
where A: ToSocketAddrs,

Creates a new event listening socket with a server type

Examples found in repository?
examples/chat/chat_server.rs (line 7)
5fn main() {
6    let mut socket =
7        NautSocket::<NautServer>::new("127.0.0.1:8008", ServerConfig::default()).unwrap();
8
9    socket.register_plugin(LoggingPlugin);
10    socket.register_plugin(ChattersPlugin);
11
12
13    loop {
14        // Must be run for every socket
15        socket.poll();
16        socket.run_events();
17    }
18}
More examples
Hide additional examples
examples/godot/godot_server.rs (line 7)
5fn main() {
6    let mut socket =
7        NautSocket::<NautServer>::new("127.0.0.1:8008", ServerConfig::default()).unwrap();
8    socket.register_plugin(LoggingPlugin);
9
10    socket.on("join", move |socket, (addr, _packet)| {
11        let client = socket.server().get_client_id(&addr);
12        let _ = socket.send("hello", &[], PacketDelivery::Reliable, *client.unwrap());
13    });
14
15    loop {
16        sleep(Duration::from_millis(1));
17        socket.poll();
18        socket.run_events();
19    }
20}
Source

pub fn server(&self) -> &NautServer

Gets a reference to the server

Examples found in repository?
examples/godot/godot_server.rs (line 11)
5fn main() {
6    let mut socket =
7        NautSocket::<NautServer>::new("127.0.0.1:8008", ServerConfig::default()).unwrap();
8    socket.register_plugin(LoggingPlugin);
9
10    socket.on("join", move |socket, (addr, _packet)| {
11        let client = socket.server().get_client_id(&addr);
12        let _ = socket.send("hello", &[], PacketDelivery::Reliable, *client.unwrap());
13    });
14
15    loop {
16        sleep(Duration::from_millis(1));
17        socket.poll();
18        socket.run_events();
19    }
20}
More examples
Hide additional examples
examples/chat/chat_server.rs (line 41)
40fn remove_chatters_on_disconnect(socket: &mut NautSocket<'_, NautServer>) {
41    for event in socket.server().iter_server_events() {
42        match event {
43            ServerEvent::OnClientTimeout(id) | ServerEvent::OnClientDisconnected(id) => {
44                let Some(chatters) = socket.get_persistent::<Chatters>() else {
45                    return;
46                };
47
48                let Ok(mut chatters) = chatters.write() else {
49                    return;
50                };
51
52                chatters.names.remove(id);
53            }
54            _ => {}
55        }
56    }
57}
58
59fn on_send_message(socket: &mut NautSocket<'_, NautServer>, (addr, packet): (SocketAddr, &[u8])) {
60    let Some(id) = socket.server().get_client_id(&addr) else {
61        return;
62    };
63
64    let name = {
65        let Some(chatters) = socket.get_persistent::<Chatters>() else {
66            return;
67        };
68        let Ok(chatters) = chatters.read() else {
69            return;
70        };
71
72        chatters.names.get(id).cloned()
73    };
74
75    let Some(name) = name else {
76        return;
77    };
78
79    let msg = String::from_utf8(packet.to_vec()).unwrap();
80    let string = format!("{}: {}", name, msg);
81    let _ = socket.broadcast("recv_message", string.as_bytes(), PacketDelivery::Reliable);
82}
83
84fn create_new_chatter(
85    socket: &mut NautSocket<'_, NautServer>,
86    (addr, packet): (SocketAddr, &[u8]),
87) {
88    let Some(id) = socket.server().get_client_id(&addr) else {
89        return;
90    };
91
92    let Some(chatters) = socket.get_persistent::<Chatters>() else {
93        return;
94    };
95
96    let name = String::from_utf8(packet.to_vec()).unwrap();
97    {
98        let Ok(mut chatters) = chatters.write() else {
99            return;
100        };
101
102        chatters.names.insert(*id, name.clone());
103    }
104
105    let join_msg = format!("Welcome {name}");
106
107    let _ = socket.broadcast(
108        "recv_message",
109        join_msg.as_bytes(),
110        PacketDelivery::Reliable,
111    );
112}
Source

pub fn server_mut(&mut self) -> &mut NautServer

Gets a mutable reference to the server

Source

pub fn run_events(&mut self)

Gets the packets from the packet queue and will handle returning ack packets, resolving sequenced packets, emitting listening events, establishing new connections and disconnecting idling clients

Examples found in repository?
examples/chat/chat_server.rs (line 16)
5fn main() {
6    let mut socket =
7        NautSocket::<NautServer>::new("127.0.0.1:8008", ServerConfig::default()).unwrap();
8
9    socket.register_plugin(LoggingPlugin);
10    socket.register_plugin(ChattersPlugin);
11
12
13    loop {
14        // Must be run for every socket
15        socket.poll();
16        socket.run_events();
17    }
18}
More examples
Hide additional examples
examples/godot/godot_server.rs (line 18)
5fn main() {
6    let mut socket =
7        NautSocket::<NautServer>::new("127.0.0.1:8008", ServerConfig::default()).unwrap();
8    socket.register_plugin(LoggingPlugin);
9
10    socket.on("join", move |socket, (addr, _packet)| {
11        let client = socket.server().get_client_id(&addr);
12        let _ = socket.send("hello", &[], PacketDelivery::Reliable, *client.unwrap());
13    });
14
15    loop {
16        sleep(Duration::from_millis(1));
17        socket.poll();
18        socket.run_events();
19    }
20}
Source

pub fn broadcast( &mut self, event: &str, buf: &[u8], delivery: PacketDelivery, ) -> Result<()>

Sends an event message to all established connections

Examples found in repository?
examples/chat/chat_server.rs (line 81)
59fn on_send_message(socket: &mut NautSocket<'_, NautServer>, (addr, packet): (SocketAddr, &[u8])) {
60    let Some(id) = socket.server().get_client_id(&addr) else {
61        return;
62    };
63
64    let name = {
65        let Some(chatters) = socket.get_persistent::<Chatters>() else {
66            return;
67        };
68        let Ok(chatters) = chatters.read() else {
69            return;
70        };
71
72        chatters.names.get(id).cloned()
73    };
74
75    let Some(name) = name else {
76        return;
77    };
78
79    let msg = String::from_utf8(packet.to_vec()).unwrap();
80    let string = format!("{}: {}", name, msg);
81    let _ = socket.broadcast("recv_message", string.as_bytes(), PacketDelivery::Reliable);
82}
83
84fn create_new_chatter(
85    socket: &mut NautSocket<'_, NautServer>,
86    (addr, packet): (SocketAddr, &[u8]),
87) {
88    let Some(id) = socket.server().get_client_id(&addr) else {
89        return;
90    };
91
92    let Some(chatters) = socket.get_persistent::<Chatters>() else {
93        return;
94    };
95
96    let name = String::from_utf8(packet.to_vec()).unwrap();
97    {
98        let Ok(mut chatters) = chatters.write() else {
99            return;
100        };
101
102        chatters.names.insert(*id, name.clone());
103    }
104
105    let join_msg = format!("Welcome {name}");
106
107    let _ = socket.broadcast(
108        "recv_message",
109        join_msg.as_bytes(),
110        PacketDelivery::Reliable,
111    );
112}
Source

pub fn send( &mut self, event: &str, buf: &[u8], delivery: PacketDelivery, client: ConnectionId, ) -> Result<()>

Sends an event message to the server we are connected to

Examples found in repository?
examples/godot/godot_server.rs (line 12)
5fn main() {
6    let mut socket =
7        NautSocket::<NautServer>::new("127.0.0.1:8008", ServerConfig::default()).unwrap();
8    socket.register_plugin(LoggingPlugin);
9
10    socket.on("join", move |socket, (addr, _packet)| {
11        let client = socket.server().get_client_id(&addr);
12        let _ = socket.send("hello", &[], PacketDelivery::Reliable, *client.unwrap());
13    });
14
15    loop {
16        sleep(Duration::from_millis(1));
17        socket.poll();
18        socket.run_events();
19    }
20}
Source§

impl<'socket, S> NautSocket<'socket, S>
where S: SocketType<'socket>,

Source

pub const DELIVERY_TYPE_OFFSET: usize = 0usize

The offset in the packet of the delivery type

Source

pub const DELIVERY_TYPE_BUF: usize = 2usize

The amount of space in each packet for the delivery type

Source

pub const SEQ_NUM_OFFSET: usize = 2usize

The offset in the packet of the sequence number if its got a sequenced delivery type

Source

pub const SEQ_NUM_BUF: usize = 4usize

The amount of space in each packet for the sequence order if its a sequenced packet

Source

pub const ACK_NUM_OFFSET: usize = 6usize

The offset in the packet of the acknowldegement number

Source

pub const ACK_NUM_BUF: usize = 4usize

The amount of space in each packet for the ack number

Source

pub const EVENT_LEN_OFFSET: usize = 10usize

The offset in the packet for the length of the event title

Source

pub const EVENT_LEN_BUF: usize = 4usize

The amount of space in each packet for the length of the event title

Source

pub const PACKET_PADDING: usize = 14usize

Source

pub fn socket(&self) -> &UdpSocket

Reference to the raw socket

Source

pub fn socket_mut(&mut self) -> &mut UdpSocket

Mutable reference to the raw socket

Source

pub fn poll(&mut self)

Polls the received packets and pushes them to the packet queue

Examples found in repository?
examples/chat/chat_server.rs (line 15)
5fn main() {
6    let mut socket =
7        NautSocket::<NautServer>::new("127.0.0.1:8008", ServerConfig::default()).unwrap();
8
9    socket.register_plugin(LoggingPlugin);
10    socket.register_plugin(ChattersPlugin);
11
12
13    loop {
14        // Must be run for every socket
15        socket.poll();
16        socket.run_events();
17    }
18}
More examples
Hide additional examples
examples/godot/godot_server.rs (line 17)
5fn main() {
6    let mut socket =
7        NautSocket::<NautServer>::new("127.0.0.1:8008", ServerConfig::default()).unwrap();
8    socket.register_plugin(LoggingPlugin);
9
10    socket.on("join", move |socket, (addr, _packet)| {
11        let client = socket.server().get_client_id(&addr);
12        let _ = socket.send("hello", &[], PacketDelivery::Reliable, *client.unwrap());
13    });
14
15    loop {
16        sleep(Duration::from_millis(1));
17        socket.poll();
18        socket.run_events();
19    }
20}
examples/chat/chat_client.rs (line 38)
9fn main() {
10    let socket = Arc::new(RwLock::new(
11        NautSocket::<NautClient>::new("127.0.0.1:0").unwrap(),
12    ));
13
14    let mut name: Option<String> = None;
15    {
16        let Ok(mut socket) = socket.write() else {
17            return;
18        };
19
20        socket.connect_to("127.0.0.1:8008").unwrap();
21
22        socket.on("recv_message", |_client, (_addr, bytes)| {
23            let msg = String::from_utf8(bytes.to_vec()).unwrap();
24            println!("{}", msg);
25        });
26    }
27
28    let socket_clone = Arc::clone(&socket);
29    // Separate thread as input blocks
30    std::thread::spawn(move || loop {
31        std::thread::sleep(Duration::from_millis(1));
32
33        let Ok(mut socket) = socket_clone.write() else {
34            continue;
35        };
36
37        // Must be run for every socket
38        socket.poll();
39        socket.run_events();
40    });
41
42    loop {
43        if name.as_ref().is_none() {
44            let mut s = String::new();
45            println!("Enter your name: ");
46            stdin().read_line(&mut s).expect("Invalid string");
47
48            if let Some('\n') = s.chars().next_back() {
49                s.pop();
50            }
51
52            if let Some('\r') = s.chars().next_back() {
53                s.pop();
54            }
55
56            name = Some(s.clone());
57
58            // Get write lock after getting input, shortest time for it in scope
59            let Ok(mut client) = socket.write() else {
60                continue;
61            };
62            let _ = client.send("new_messenger", s.as_bytes(), PacketDelivery::Reliable);
63            continue;
64        }
65
66        let mut s = String::new();
67        stdin().read_line(&mut s).expect("Invalid string");
68
69        if let Some('\n') = s.chars().next_back() {
70            s.pop();
71        }
72
73        if let Some('\r') = s.chars().next_back() {
74            s.pop();
75        }
76
77        // Get write lock after getting input, shortest time for it in scope
78        let Ok(mut client) = socket.write() else {
79            continue;
80        };
81        let _ = client.send("send_message", s.as_bytes(), PacketDelivery::Reliable);
82    }
83}
Source

pub fn on<F>(&mut self, event: &str, cb: F)
where F: Fn(&mut NautSocket<'_, S>, (SocketAddr, &'_ [u8])) + Send + Sync + 'static,

Run a function as a callback when a certain event is sent

§Examples
// When the client recieves a "hello" event it will print the bytes received
client.on("hello", |_client, (_addr, packet)| {
    println!("hello bytes {:?}", packet);
});
Examples found in repository?
examples/chat/chat_server.rs (line 33)
30    fn register(&self, socket: &mut NautSocket<'_, NautServer>) {
31        socket.init_persistent::<Chatters>();
32
33        socket.on("new_messenger", create_new_chatter);
34        socket.on("send_message", on_send_message);
35
36        socket.on_poll(remove_chatters_on_disconnect);
37    }
More examples
Hide additional examples
examples/godot/godot_server.rs (lines 10-13)
5fn main() {
6    let mut socket =
7        NautSocket::<NautServer>::new("127.0.0.1:8008", ServerConfig::default()).unwrap();
8    socket.register_plugin(LoggingPlugin);
9
10    socket.on("join", move |socket, (addr, _packet)| {
11        let client = socket.server().get_client_id(&addr);
12        let _ = socket.send("hello", &[], PacketDelivery::Reliable, *client.unwrap());
13    });
14
15    loop {
16        sleep(Duration::from_millis(1));
17        socket.poll();
18        socket.run_events();
19    }
20}
examples/chat/chat_client.rs (lines 22-25)
9fn main() {
10    let socket = Arc::new(RwLock::new(
11        NautSocket::<NautClient>::new("127.0.0.1:0").unwrap(),
12    ));
13
14    let mut name: Option<String> = None;
15    {
16        let Ok(mut socket) = socket.write() else {
17            return;
18        };
19
20        socket.connect_to("127.0.0.1:8008").unwrap();
21
22        socket.on("recv_message", |_client, (_addr, bytes)| {
23            let msg = String::from_utf8(bytes.to_vec()).unwrap();
24            println!("{}", msg);
25        });
26    }
27
28    let socket_clone = Arc::clone(&socket);
29    // Separate thread as input blocks
30    std::thread::spawn(move || loop {
31        std::thread::sleep(Duration::from_millis(1));
32
33        let Ok(mut socket) = socket_clone.write() else {
34            continue;
35        };
36
37        // Must be run for every socket
38        socket.poll();
39        socket.run_events();
40    });
41
42    loop {
43        if name.as_ref().is_none() {
44            let mut s = String::new();
45            println!("Enter your name: ");
46            stdin().read_line(&mut s).expect("Invalid string");
47
48            if let Some('\n') = s.chars().next_back() {
49                s.pop();
50            }
51
52            if let Some('\r') = s.chars().next_back() {
53                s.pop();
54            }
55
56            name = Some(s.clone());
57
58            // Get write lock after getting input, shortest time for it in scope
59            let Ok(mut client) = socket.write() else {
60                continue;
61            };
62            let _ = client.send("new_messenger", s.as_bytes(), PacketDelivery::Reliable);
63            continue;
64        }
65
66        let mut s = String::new();
67        stdin().read_line(&mut s).expect("Invalid string");
68
69        if let Some('\n') = s.chars().next_back() {
70            s.pop();
71        }
72
73        if let Some('\r') = s.chars().next_back() {
74            s.pop();
75        }
76
77        // Get write lock after getting input, shortest time for it in scope
78        let Ok(mut client) = socket.write() else {
79            continue;
80        };
81        let _ = client.send("send_message", s.as_bytes(), PacketDelivery::Reliable);
82    }
83}
Source

pub fn on_poll<F>(&mut self, cb: F)
where F: Fn(&mut NautSocket<'_, S>) + Send + Sync + 'static,

Run a function as a callback everytime the socket is polled

§Examples
// When the server is polled it will print "Do some stuff"]
// Can be used to read server events, etc.
server.on_poll(|_server| {
    println!("Do some stufff");
});
Examples found in repository?
examples/chat/chat_server.rs (line 36)
30    fn register(&self, socket: &mut NautSocket<'_, NautServer>) {
31        socket.init_persistent::<Chatters>();
32
33        socket.on("new_messenger", create_new_chatter);
34        socket.on("send_message", on_send_message);
35
36        socket.on_poll(remove_chatters_on_disconnect);
37    }
Source

pub fn register_plugin<'plugin>( &'plugin mut self, plugin: impl SocketPlugin<'socket, S>, )

Registers a plugin

Examples found in repository?
examples/chat/chat_server.rs (line 9)
5fn main() {
6    let mut socket =
7        NautSocket::<NautServer>::new("127.0.0.1:8008", ServerConfig::default()).unwrap();
8
9    socket.register_plugin(LoggingPlugin);
10    socket.register_plugin(ChattersPlugin);
11
12
13    loop {
14        // Must be run for every socket
15        socket.poll();
16        socket.run_events();
17    }
18}
More examples
Hide additional examples
examples/godot/godot_server.rs (line 8)
5fn main() {
6    let mut socket =
7        NautSocket::<NautServer>::new("127.0.0.1:8008", ServerConfig::default()).unwrap();
8    socket.register_plugin(LoggingPlugin);
9
10    socket.on("join", move |socket, (addr, _packet)| {
11        let client = socket.server().get_client_id(&addr);
12        let _ = socket.send("hello", &[], PacketDelivery::Reliable, *client.unwrap());
13    });
14
15    loop {
16        sleep(Duration::from_millis(1));
17        socket.poll();
18        socket.run_events();
19    }
20}
Source

pub fn get_persistent<P>(&self) -> Option<Arc<RwLock<P>>>
where P: Persistent,

Examples found in repository?
examples/chat/chat_server.rs (line 44)
40fn remove_chatters_on_disconnect(socket: &mut NautSocket<'_, NautServer>) {
41    for event in socket.server().iter_server_events() {
42        match event {
43            ServerEvent::OnClientTimeout(id) | ServerEvent::OnClientDisconnected(id) => {
44                let Some(chatters) = socket.get_persistent::<Chatters>() else {
45                    return;
46                };
47
48                let Ok(mut chatters) = chatters.write() else {
49                    return;
50                };
51
52                chatters.names.remove(id);
53            }
54            _ => {}
55        }
56    }
57}
58
59fn on_send_message(socket: &mut NautSocket<'_, NautServer>, (addr, packet): (SocketAddr, &[u8])) {
60    let Some(id) = socket.server().get_client_id(&addr) else {
61        return;
62    };
63
64    let name = {
65        let Some(chatters) = socket.get_persistent::<Chatters>() else {
66            return;
67        };
68        let Ok(chatters) = chatters.read() else {
69            return;
70        };
71
72        chatters.names.get(id).cloned()
73    };
74
75    let Some(name) = name else {
76        return;
77    };
78
79    let msg = String::from_utf8(packet.to_vec()).unwrap();
80    let string = format!("{}: {}", name, msg);
81    let _ = socket.broadcast("recv_message", string.as_bytes(), PacketDelivery::Reliable);
82}
83
84fn create_new_chatter(
85    socket: &mut NautSocket<'_, NautServer>,
86    (addr, packet): (SocketAddr, &[u8]),
87) {
88    let Some(id) = socket.server().get_client_id(&addr) else {
89        return;
90    };
91
92    let Some(chatters) = socket.get_persistent::<Chatters>() else {
93        return;
94    };
95
96    let name = String::from_utf8(packet.to_vec()).unwrap();
97    {
98        let Ok(mut chatters) = chatters.write() else {
99            return;
100        };
101
102        chatters.names.insert(*id, name.clone());
103    }
104
105    let join_msg = format!("Welcome {name}");
106
107    let _ = socket.broadcast(
108        "recv_message",
109        join_msg.as_bytes(),
110        PacketDelivery::Reliable,
111    );
112}
Source

pub fn insert_persistent<P>(&mut self, persistent: P)
where P: Persistent,

Source

pub fn init_persistent<P>(&mut self)
where P: Persistent + Default,

Examples found in repository?
examples/chat/chat_server.rs (line 31)
30    fn register(&self, socket: &mut NautSocket<'_, NautServer>) {
31        socket.init_persistent::<Chatters>();
32
33        socket.on("new_messenger", create_new_chatter);
34        socket.on("send_message", on_send_message);
35
36        socket.on_poll(remove_chatters_on_disconnect);
37    }

Auto Trait Implementations§

§

impl<'socket, S> Freeze for NautSocket<'socket, S>
where S: Freeze,

§

impl<'socket, S> !RefUnwindSafe for NautSocket<'socket, S>

§

impl<'socket, S> Send for NautSocket<'socket, S>
where S: Send + Sync,

§

impl<'socket, S> Sync for NautSocket<'socket, S>
where S: Sync,

§

impl<'socket, S> Unpin for NautSocket<'socket, S>
where S: Unpin,

§

impl<'socket, S> !UnwindSafe for NautSocket<'socket, S>

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.