non async code

i found out that async code would be better, so saved this code i might see this in future maybe :)
This commit is contained in:
RafayAhmad7548 2025-04-09 22:11:17 +05:00
parent 59cff14584
commit 5b4fd10214
3 changed files with 341 additions and 28 deletions

View file

@ -1,46 +1,105 @@
use std::{net::TcpListener, thread::spawn};
use tungstenite::{accept, protocol::{frame::coding::CloseCode, CloseFrame}, Message};
use std::{collections::HashMap, net::TcpListener, sync::{mpsc::{channel, Receiver, Sender}, Arc, Mutex}, thread::spawn};
use tungstenite::{accept, Message};
fn main() {
let mut connection_count: usize = 0;
let senders = Arc::new(Mutex::new(HashMap::<usize, Sender<Arc<Message>>>::new()));
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);
spawn(move || {
let mut websocket = accept(stream.unwrap()).unwrap();
println!("Connection Received");
let id = connection_count;
println!("Connection Received: {}", id);
loop {
let res = websocket.read();
let res = {
let mut wssocket_lock = r_websocket.lock().unwrap();
(*wssocket_lock).read()
};
match res {
Ok(Message::Text(txtmsg)) => {
println!("received: {}", txtmsg);
let strmsg = format!("i shall send this back to you {}", txtmsg.to_string());
websocket.send(Message::text(strmsg)).unwrap();
}
Ok(Message::Close(_)) => {
match websocket.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(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)
}
}
}
}
}
Err(e) => {
let mut t_sender_lock = t_senders.lock().unwrap();
(*t_sender_lock).remove(&id);
println!("MyError Occured: {}", e);
println!("Connection Closed");
break;
}
_ => {
println!("not handled");
},
}
}
}
});
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;
}
}
}
});
}
}