networker_rs/
lib.rs

1use std::collections::HashMap;
2use std::io::{self, BufRead, Read, Write};
3use std::net::{TcpListener, TcpStream, UdpSocket};
4use std::sync::{Arc, Mutex};
5use tungstenite::{accept, Message};
6use hyper::{body::Body, Request, Response, Server, service::{make_service_fn, service_fn}};
7use std::collections::hash_map::DefaultHasher;
8use std::hash::{Hash, Hasher};
9
10pub mod net {
11    use super::*;
12
13    pub struct EasySocketServer {
14        handlers: Arc<Mutex<HashMap<String, Arc<dyn Fn(Socket) + Send + Sync + 'static>>>>,
15    }
16
17    #[derive(Clone)]
18    pub struct Socket {
19        id: i32,
20        stream: Option<Arc<Mutex<TcpStream>>>,
21        udp_socket: Option<Arc<UdpSocket>>,
22        handlers: Arc<Mutex<HashMap<String, Box<dyn Fn(&str) + Send>>>>,
23    }
24
25    impl EasySocketServer {
26        pub fn new() -> Self {
27            Self {
28                handlers: Arc::new(Mutex::new(HashMap::new())),
29            }
30        }
31
32        pub fn on<F>(&self, event: &str, callback: F)
33        where
34            F: Fn(Socket) + Send + Sync + 'static,
35        {
36            self.handlers.lock().unwrap().insert(event.to_string(), Arc::new(callback));
37        }
38
39        pub fn listen_tcp(&self, address: &str) -> io::Result<()> {
40            let listener = TcpListener::bind(address)?;
41            for stream in listener.incoming() {
42                let stream = stream?;
43                let socket = Socket::new_tcp(stream);
44                let handlers = Arc::clone(&self.handlers);
45                let callback = handlers.lock().unwrap().get("connection").cloned();
46                if let Some(callback) = callback {
47                    callback(socket);
48                }
49            }
50            Ok(())
51        }
52
53        pub fn listen_udp(&self, address: &str) -> io::Result<()> {
54            let socket = UdpSocket::bind(address)?;
55            let udp_socket = Arc::new(socket);
56            let mut buffer = [0; 1024];
57            loop {
58                if let Ok((size, src)) = udp_socket.recv_from(&mut buffer) {
59                    let message = String::from_utf8_lossy(&buffer[..size]).to_string();
60                    let handlers = Arc::clone(&self.handlers);
61                    if let Some(callback) = handlers.lock().unwrap().get("connection") {
62                        callback(Socket::new_udp(udp_socket.clone()));
63                    }
64                    println!("Received from {}: {}", src, message);
65                }
66            }
67        }
68
69        pub async fn listen_http(&self, address: &str) -> Result<(), Box<dyn std::error::Error>> {
70            let make_svc = make_service_fn(|_conn| async {
71                Ok::<_, hyper::Error>(service_fn(|_req: Request<Body>| async {
72                    Ok::<_, hyper::Error>(Response::new(Body::from("Hello, HTTP!")))
73                }))
74            });
75        
76            let addr = address.parse()?; // Parse the address
77            let server = Server::bind(&addr).serve(make_svc); // Use `try_bind` to bind to the address        
78            println!("Listening on http://{}", address);
79            server.await?;
80            Ok(())
81        }
82        
83        pub fn listen_ws(&self, address: &str) -> io::Result<()> {
84            let listener = TcpListener::bind(address)?;
85            for stream in listener.incoming() {
86                let stream = stream?;
87                let mut websocket = accept(stream).expect("Error during WebSocket handshake");
88                if let Ok(Message::Text(msg)) = websocket.read_message() {
89                    println!("WebSocket received: {}", msg);
90                    websocket.write_message(Message::Text("Hello, WebSocket!".into())).unwrap();
91                }
92            }
93            Ok(())
94        }
95    }
96
97    impl Socket {
98        fn generate_stable_id(addr: &str) -> i32 {
99            let mut hasher = DefaultHasher::new();
100            addr.hash(&mut hasher);
101            (hasher.finish() & 0x7FFFFFFF) as i32 // Ensure positive i32
102        }
103
104        pub fn new_tcp(stream: TcpStream) -> Self {
105            let addr = format!("{:?}", stream.peer_addr().unwrap_or_else(|_| panic!("Could not get peer address")));
106            let id = Self::generate_stable_id(&addr);
107            Self {
108                id,
109                stream: Some(Arc::new(Mutex::new(stream))),
110                udp_socket: None,
111                handlers: Arc::new(Mutex::new(HashMap::new())),
112            }
113        }
114
115        pub fn new_udp(socket: Arc<UdpSocket>) -> Self {
116            let addr = format!("{:?}", socket.local_addr().unwrap_or_else(|_| panic!("Could not get local address")));
117            let id = Self::generate_stable_id(&addr);
118            Self {
119                id,
120                stream: None,
121                udp_socket: Some(socket),
122                handlers: Arc::new(Mutex::new(HashMap::new())),
123            }
124        }
125
126        pub fn id(&self) -> i32 {
127            self.id
128        }
129
130        pub fn on<F>(&self, event: &str, callback: F)
131        where
132            F: Fn(&str) + Send + 'static,
133        {
134            self.handlers.lock().unwrap().insert(event.to_string(), Box::new(callback));
135        }
136
137        pub fn emit(&self, event: &str) {
138            if let Some(stream) = &self.stream {
139                let mut stream = stream.lock().unwrap();
140                let message = format!("{}:\n", event); // Append newline
141                let _ = stream.write_all(message.as_bytes());
142            }
143        }
144        
145
146        pub fn listen_tcp(&self) {
147            let mut buffer = [0; 1024];
148            if let Some(stream) = &self.stream {
149                let mut stream = stream.lock().unwrap();
150                if let Ok(size) = stream.read(&mut buffer) {
151                    let data = String::from_utf8_lossy(&buffer[..size]).to_string();
152                    for line in data.lines() { // Split by newline
153                        if let Some((event, _)) = line.split_once(':') {
154                            if let Some(callback) = self.handlers.lock().unwrap().get(event) {
155                                callback(""); // Call handler (pass empty string as data)
156                            }
157                        }
158                    }
159                }
160            }
161        }
162        
163    }
164
165    #[cfg(test)]
166    mod tests {
167        use super::*;
168
169        #[test]
170        fn test_stable_socket_ids() {
171            let addr = "127.0.0.1:8080";
172            let id1 = Socket::generate_stable_id(addr);
173            let id2 = Socket::generate_stable_id(addr);
174            assert_eq!(id1, id2, "Same address should generate same ID");
175        }
176    }
177}
178
179#[cfg(test)]
180mod tests {
181    use super::net::{self, EasySocketServer};
182    use std::thread;
183
184    #[test]
185    fn test_tcp_server_client() {
186        thread::spawn(|| {
187            let server = EasySocketServer::new();
188            server.on("connection", |socket| {
189                socket.on("hello, server", |msg| {
190                    println!("Server received: {}", msg);
191                });
192                socket.emit("hello, client!");
193                socket.listen_tcp();
194            });
195            server.listen_tcp("127.0.0.1:4000").unwrap();
196        });
197
198        thread::sleep(std::time::Duration::from_secs(1)); // Allow server to start
199
200        let client = std::net::TcpStream::connect("127.0.0.1:4000").unwrap();
201        let socket = net::Socket::new_tcp(client);
202        socket.on("hello, client!", |msg| {
203            println!("Client received: {}", msg);
204        });
205        socket.emit("hello, server");
206        socket.listen_tcp();
207    }
208}
networker_rs/lib.rs

networker_rs/
lib.rs
