RafayAhmad/clipsync-server
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

first try babbyyyy

Browse source
This commit is contained in:
RafayAhmad7548 2025-04-10 11:28:15 +05:00
parent 5b4fd10214
commit d8e30fcf55
3 changed files with 177 additions and 49 deletions
Download patch file Download diff file Expand all files Collapse all files

86
src/main.rs
View file

@ -1,62 +1,54 @@
use std::{collections::HashMap, net::TcpListener, sync::{mpsc::{channel, Receiver, Sender}, Arc, Mutex}, thread::spawn};
use tungstenite::{accept, Message};
use std::{collections::HashMap, sync::Arc};
fn main() {
use futures::{SinkExt, StreamExt};
use tokio::{net::TcpListener, spawn, sync::{mpsc::{channel, Receiver, Sender}, Mutex}};
use tokio_tungstenite::{accept_async, tungstenite::Message};
#[tokio::main]
async 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 server = TcpListener::bind("0.0.0.0:9001").await.unwrap();
while let Ok((stream, socket)) = server.accept().await {
println!("Connection Received from ip: {}, port: {}", socket.ip(), socket.port());
let t_senders = Arc::clone(&senders);
let (sender, receiver): (Sender<Arc<Message>>, Receiver<Arc<Message>>) = channel();
let (sender, mut receiver): (Sender<Arc<Message>>, Receiver<Arc<Message>>) = channel(100);
{
let mut sender_lock = t_senders.lock().unwrap();
let mut sender_lock = t_senders.lock().await;
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 websocket = accept_async(stream).await.unwrap();
let (mut websocket_send, mut websocket_read) = websocket.split();
spawn(async move {
let id = connection_count;
println!("Connection Received: {}", id);
loop {
let res = {
let mut wssocket_lock = r_websocket.lock().unwrap();
(*wssocket_lock).read()
};
while let Some(res) = websocket_read.next().await {
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 sender_lock = t_senders.lock().await;
let arc_msg_clone = Arc::clone(&arc_msg);
match (*t_sender_lock).get(&id).unwrap().send(arc_msg_clone) {
match (*sender_lock).get(&id).unwrap().send(arc_msg_clone).await {
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 sender_lock = t_senders.lock().await;
for (iter_id, sender) in (*sender_lock).iter() {
let arc_msg_clone = Arc::clone(&arc_msg);
if *iter_id != id {
match (*sender).send(arc_msg_clone) {
match (*sender).send(arc_msg_clone).await {
Ok(_) => println!("message sent to thread no {}", *iter_id),
Err(e) => println!("My Error: {}", e)
}
@ -65,36 +57,36 @@ fn main() {
}
}
Err(e) => {
let mut t_sender_lock = t_senders.lock().unwrap();
(*t_sender_lock).remove(&id);
let mut sender_lock = t_senders.lock().await;
(*sender_lock).remove(&id);
println!("MyError Occured: {}", e);
println!("Connection Closed");
break;
}
}
}
});
let s_websocket = Arc::clone(&websocket);
spawn(move || {
spawn(async move {
let id = connection_count;
loop {
match receiver.recv() {
Ok(arc_msg) => {
match receiver.recv().await {
Some(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);
match websocket_send.send(msg).await {
Ok(_) => println!("message sent to client {}", id),
Err(e) => {
println!("error in sending to client {}: {}", id, e);
break;
}
}
}
Err(e) => {
println!("Error in receiving from other threads: {}", e);
None => {
println!("Error in receiving from other threads");
break;
}
}