WIP connection manager

README.md

@@ -105,7 +105,7 @@ use laminar::{Socket, Packet};
 
 // create the socket
 let mut socket = Socket::bind("127.0.0.1:12345")?;
-let packet_sender = socket.get_packet_sender();
+let packet_sender = socket.get_event_sender();
 // this will start the socket, which will start a poll mechanism to receive and send messages.
 let _thread = thread::spawn(move || socket.start_polling());
 

examples/server_client.rs

@@ -5,41 +5,48 @@ use std::io::stdin;
 use std::thread;
 use std::time::Instant;
 
-use laminar::{ErrorKind, Packet, Socket, SocketEvent};
+use laminar::{
+    managers::SimpleConnectionManagerFactory, ConnectionEvent, ErrorKind, Packet, ReceiveEvent,
+    SendEvent, Socket,
+};
 
 const SERVER: &str = "127.0.0.1:12351";
 
 fn server() -> Result<(), ErrorKind> {
-    let mut socket = Socket::bind(SERVER)?;
-    let (sender, receiver) = (socket.get_packet_sender(), socket.get_event_receiver());
+    // create socket manager, that will use SimpleConnectionManager, that actually initiates connection by exchanging methods
+    let mut socket = Socket::bind(SERVER, Box::new(SimpleConnectionManagerFactory(false)))?;
+    let (sender, receiver) = (socket.get_event_sender(), socket.get_event_receiver());
     let _thread = thread::spawn(move || socket.start_polling());
 
     loop {
-        if let Ok(event) = receiver.recv() {
+        if let Ok(ConnectionEvent(addr, event)) = receiver.recv() {
             match event {
-                SocketEvent::Packet(packet) => {
+                ReceiveEvent::Connected(data) => {
+                    println!(
+                        "{:?} -> Connected msg:{}",
+                        addr,
+                        String::from_utf8_lossy(data.as_ref())
+                    );
+                }
+                ReceiveEvent::Packet(packet) => {
                     let msg = packet.payload();
-
                     if msg == b"Bye!" {
                         break;
                     }
-
                     let msg = String::from_utf8_lossy(msg);
-                    let ip = packet.addr().ip();
-
-                    println!("Received {:?} from {:?}", msg, ip);
+                    println!("{:?} -> Packet msg:{}", addr, msg);
 
                     sender
-                        .send(Packet::reliable_unordered(
+                        .send(ConnectionEvent(
                             packet.addr(),
-                            "Copy that!".as_bytes().to_vec(),
+                            SendEvent::Packet(Packet::reliable_unordered(
+                                packet.addr(),
+                                [b"Echo: ", msg.as_bytes()].concat(),
+                            )),
                         ))
                         .expect("This should send");
                 }
-                SocketEvent::Timeout(address) => {
-                    println!("Client timed out: {}", address);
-                }
-                _ => {}
+                _ => println!("{:?} -> {:?}", addr, event),
             }
         }
     }
@@ -49,43 +56,66 @@ fn server() -> Result<(), ErrorKind> {
 
 fn client() -> Result<(), ErrorKind> {
     let addr = "127.0.0.1:12352";
-    let mut socket = Socket::bind(addr)?;
+    let mut socket = Socket::bind(addr, Box::new(SimpleConnectionManagerFactory(false)))?;
     println!("Connected on {}", addr);
 
-    let server = SERVER.parse().unwrap();
+    let sender = socket.get_event_sender();
+    let _thread = thread::spawn(move || loop {
+        socket.manual_poll(Instant::now());
 
-    println!("Type a message and press Enter to send. Send `Bye!` to quit.");
+        if let Some(ConnectionEvent(addr, event)) = socket.recv() {
+            match event {
+                ReceiveEvent::Connected(data) => {
+                    println!(
+                        "{:?} -> Connected msg:{}",
+                        addr,
+                        String::from_utf8_lossy(data.as_ref())
+                    );
+                }
+                ReceiveEvent::Packet(packet) => {
+                    let msg = String::from_utf8_lossy(packet.payload());
+                    println!("{:?} -> Packet msg:{}", addr, msg);
+                }
+                _ => println!("{:?} -> {:?}", addr, event),
+            }
+        }
+    });
 
     let stdin = stdin();
     let mut s_buffer = String::new();
+    s_buffer.clear();
+
+    let server = SERVER.parse().unwrap();
+    println!("Type a `:c<message>` to connect");
+    println!("Type a `<message>` to send a packet");
+    println!("Type a `:d` to disconnect");
+    println!("Type a `:q` to quit.");
 
     loop {
-        s_buffer.clear();
         stdin.read_line(&mut s_buffer)?;
         let line = s_buffer.replace(|x| x == '\n' || x == '\r', "");
-
-        socket.send(Packet::reliable_unordered(
-            server,
-            line.clone().into_bytes(),
-        ))?;
-
-        socket.manual_poll(Instant::now());
-
-        if line == "Bye!" {
+        if line == ":q" {
             break;
+        } else if line.starts_with(":c") {
+            sender
+                .send(ConnectionEvent(
+                    server,
+                    SendEvent::Connect(Box::from(line.split_at(2).1.as_bytes())),
+                ))
+                .expect("sending should not fail");
+        } else if line == ":d" {
+            sender
+                .send(ConnectionEvent(server, SendEvent::Disconnect))
+                .expect("sending should not fail");
+        } else {
+            sender
+                .send(ConnectionEvent(
+                    server,
+                    SendEvent::Packet(Packet::reliable_unordered(server, line.into_bytes())),
+                ))
+                .expect("sending should not fail");
         }
-
-        match socket.recv() {
-            Some(SocketEvent::Packet(packet)) => {
-                if packet.addr() == server {
-                    println!("Server sent: {}", String::from_utf8_lossy(packet.payload()));
-                } else {
-                    println!("Unknown sender.");
-                }
-            }
-            Some(SocketEvent::Timeout(_)) => {}
-            _ => println!("Silence.."),
-        }
+        s_buffer.clear();
     }
 
     Ok(())
@@ -99,7 +129,7 @@ fn main() -> Result<(), ErrorKind> {
     let mut s = String::new();
     stdin.read_line(&mut s)?;
 
-    if s.starts_with("s") {
+    if s.starts_with('s') {
         println!("Starting server..");
         server()
     } else {

examples/simple_udp.rs

@@ -3,15 +3,18 @@
 //! 2. setting up client to send data.
 //! 3. serialize data to send and deserialize when received.
 use bincode::{deserialize, serialize};
-use laminar::{Packet, Socket, SocketEvent};
+use laminar::{
+    managers::SimpleConnectionManagerFactory, ConnectionEvent, Packet, ReceiveEvent, SendEvent,
+    Socket,
+};
 use serde_derive::{Deserialize, Serialize};
 use std::net::SocketAddr;
 use std::time::Instant;
 
 /// The socket address of where the server is located.
-const SERVER_ADDR: &'static str = "127.0.0.1:12345";
+const SERVER_ADDR: &str = "127.0.0.1:12345";
 // The client address from where the data is sent.
-const CLIENT_ADDR: &'static str = "127.0.0.1:12346";
+const CLIENT_ADDR: &str = "127.0.0.1:12346";
 
 fn client_address() -> SocketAddr {
     CLIENT_ADDR.parse().unwrap()
@@ -21,40 +24,55 @@ fn server_address() -> SocketAddr {
     SERVER_ADDR.parse().unwrap()
 }
 
+// helper function to reduce boiler plate
+fn create_packet<T>(addr: SocketAddr, data: &T) -> ConnectionEvent<SendEvent>
+where
+    T: serde::Serialize,
+{
+    ConnectionEvent(
+        addr,
+        SendEvent::Packet(Packet::unreliable(addr, serialize(data).unwrap())),
+    )
+}
+
 /// This will run an simple example with client and server communicating.
 #[allow(unused_must_use)]
 pub fn main() {
-    let mut server = Socket::bind(server_address()).unwrap();
+    let mut server = Socket::bind(
+        server_address(),
+        Box::new(SimpleConnectionManagerFactory(true)),
+    )
+    .unwrap();
 
     /*  setup or `Client` and send some test data. */
-    let mut client = Socket::bind(client_address()).unwrap();
-
-    client.send(Packet::unreliable(
+    let mut client = Socket::bind(
+        client_address(),
+        Box::new(SimpleConnectionManagerFactory(true)),
+    )
+    .unwrap();
+    client.send(create_packet(
         server_address(),
-        serialize(&DataType::Coords {
+        &DataType::Coords {
             latitude: 10.55454,
             longitude: 10.555,
             altitude: 1.3,
-        })
-        .unwrap(),
+        },
     ));
 
-    client.send(Packet::unreliable(
+    client.send(create_packet(
         server_address(),
-        serialize(&DataType::Coords {
+        &DataType::Coords {
             latitude: 3.344,
             longitude: 5.4545,
             altitude: 1.33,
-        })
-        .unwrap(),
+        },
     ));
 
-    client.send(Packet::unreliable(
+    client.send(create_packet(
         server_address(),
-        serialize(&DataType::Text {
+        &DataType::Text {
             string: String::from("Some information"),
-        })
-        .unwrap(),
+        },
     ));
 
     // Send the queued send operations
@@ -68,11 +86,8 @@ pub fn main() {
     // Coords { longitude: 5.4545, latitude: 3.344, altitude: 1.33 }
     // Text { string: "Some information" }
     while let Some(pkt) = server.recv() {
-        match pkt {
-            SocketEvent::Packet(pkt) => {
-                println!["{:?}", deserialize::<DataType>(pkt.payload()).unwrap()]
-            }
-            _ => {}
+        if let ConnectionEvent(_addr, ReceiveEvent::Packet(pkt)) = pkt {
+            println!["{:?}", deserialize::<DataType>(pkt.payload()).unwrap()]
         }
     }
 }