clipsync-server/src/main.rs

106 lines
4.5 KiB
Rust
Raw Normal View History

use std::{collections::HashMap, net::TcpListener, sync::{mpsc::{channel, Receiver, Sender}, Arc, Mutex}, thread::spawn};
use tungstenite::{accept, Message};
2025-04-08 17:48:38 +05:00
2025-04-07 17:31:16 +05:00
fn main() {
let mut connection_count: usize = 0;
let senders = Arc::new(Mutex::new(HashMap::<usize, Sender<Arc<Message>>>::new()));
2025-04-08 17:48:38 +05:00
let server = TcpListener::bind("0.0.0.0:9001").unwrap();
for stream in server.incoming() {
let t_senders = Arc::clone(&senders);
let (sender, receiver): (Sender<Arc<Message>>, Receiver<Arc<Message>>) = channel();
{
let mut sender_lock = t_senders.lock().unwrap();
connection_count += 1;
(*sender_lock).insert(connection_count, sender);
}
let websocket = Arc::new(Mutex::new(accept(stream.unwrap()).unwrap()));
let r_websocket = Arc::clone(&websocket);
2025-04-08 17:48:38 +05:00
spawn(move || {
let id = connection_count;
println!("Connection Received: {}", id);
2025-04-08 17:48:38 +05:00
loop {
let res = {
let mut wssocket_lock = r_websocket.lock().unwrap();
(*wssocket_lock).read()
};
2025-04-08 17:48:38 +05:00
match res {
// Ok(Message::Close(_)) => {
// let mut t_sender_lock = t_senders.lock().unwrap();
// (*t_sender_lock).remove(&id);
// match (*wssocket_lock).send(Message::Close(Some(CloseFrame{
// code: CloseCode::Normal,
// reason: "Connection Closed :)".into()
// }))) {
// Ok(_) => println!("Close frame sent succesfully"),
// Err(e) => println!("Failed to send close frame (connection may already be closed): {}", e)
// };
// println!("closing connection");
// break;
// }
Ok(msg) => {
let arc_msg = Arc::new(msg);
if arc_msg.is_close() {
let t_sender_lock = t_senders.lock().unwrap();
let arc_msg_clone = Arc::clone(&arc_msg);
match (*t_sender_lock).get(&id).unwrap().send(arc_msg_clone) {
Ok(_) => println!("close message sent to thread no {}", id),
Err(e) => println!("My Error: {}", e)
}
break;
}
else if arc_msg.is_text() || arc_msg.is_binary() {
let t_sender_lock = t_senders.lock().unwrap();
for (iter_id, sender) in (*t_sender_lock).iter() {
let arc_msg_clone = Arc::clone(&arc_msg);
if *iter_id != id {
match (*sender).send(arc_msg_clone) {
Ok(_) => println!("message sent to thread no {}", *iter_id),
Err(e) => println!("My Error: {}", e)
}
}
}
}
2025-04-08 17:48:38 +05:00
}
Err(e) => {
let mut t_sender_lock = t_senders.lock().unwrap();
(*t_sender_lock).remove(&id);
2025-04-08 17:48:38 +05:00
println!("MyError Occured: {}", e);
println!("Connection Closed");
2025-04-08 17:48:38 +05:00
break;
}
}
2025-04-08 17:48:38 +05:00
}
});
let s_websocket = Arc::clone(&websocket);
spawn(move || {
let id = connection_count;
loop {
match receiver.recv() {
Ok(arc_msg) => {
println!("Message received by thread {}", id);
println!("The message is {}", arc_msg);
let mut wssocket_lock = s_websocket.lock().unwrap();
println!("Lock acquired");
let msg = (*arc_msg).clone();
//TODO add match for this
let _ = (*wssocket_lock).send(msg);
println!("message sent to client {}", id);
}
Err(e) => {
println!("Error in receiving from other threads: {}", e);
break;
}
}
}
});
2025-04-08 17:48:38 +05:00
}
2025-04-07 17:31:16 +05:00
}