2025-04-29 22:58:24 +03:00
|
|
|
use std::{collections::VecDeque, sync::LazyLock};
|
|
|
|
|
2025-04-27 05:52:58 +03:00
|
|
|
use axum::{Router, http::StatusCode, response::IntoResponse, routing::get};
|
|
|
|
use fastwebsockets::{
|
2025-04-29 22:58:24 +03:00
|
|
|
FragmentCollectorRead, OpCode, WebSocketError,
|
2025-04-27 05:52:58 +03:00
|
|
|
upgrade::{IncomingUpgrade, UpgradeFut},
|
|
|
|
};
|
2025-04-29 22:58:24 +03:00
|
|
|
use protocol::{Signal, SignalType};
|
|
|
|
use tokio::{
|
|
|
|
net::TcpListener,
|
|
|
|
sync::{RwLock, broadcast},
|
|
|
|
};
|
2025-04-27 05:52:58 +03:00
|
|
|
use tower_http::cors::CorsLayer;
|
2025-04-16 06:27:08 +03:00
|
|
|
|
2025-04-26 03:34:07 +03:00
|
|
|
const SERVER_ADDRESS: &str = "192.168.1.3:4546";
|
2025-04-11 04:58:16 +03:00
|
|
|
|
2025-04-29 22:58:24 +03:00
|
|
|
static USER_MESSAGES: LazyLock<RwLock<VecDeque<UserMessages>>> =
|
|
|
|
LazyLock::new(|| VecDeque::new().into());
|
|
|
|
|
|
|
|
struct UserMessages {
|
|
|
|
user: String,
|
|
|
|
message_receiver: broadcast::Receiver<Signal>,
|
|
|
|
}
|
|
|
|
|
2025-04-11 04:58:16 +03:00
|
|
|
pub async fn start_signalling() {
|
2025-04-27 05:52:58 +03:00
|
|
|
let router = Router::new()
|
|
|
|
.route("/", get(alive))
|
|
|
|
.route("/signal", get(signal))
|
|
|
|
.layer(CorsLayer::permissive());
|
|
|
|
|
|
|
|
let listener = TcpListener::bind(SERVER_ADDRESS).await.unwrap();
|
|
|
|
|
|
|
|
println!("{}", SERVER_ADDRESS);
|
|
|
|
axum::serve(listener, router).await.unwrap();
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn alive() -> impl IntoResponse {
|
|
|
|
StatusCode::OK
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn signal(websocket: IncomingUpgrade) -> impl IntoResponse {
|
|
|
|
let (response, websocket) = websocket.upgrade().unwrap();
|
|
|
|
tokio::spawn(websocket_handler(websocket));
|
|
|
|
response
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn websocket_handler(websocket: UpgradeFut) {
|
|
|
|
let mut websocket = websocket.await.unwrap();
|
|
|
|
websocket.set_auto_pong(true);
|
|
|
|
websocket.set_writev(false);
|
|
|
|
websocket.set_auto_close(true);
|
|
|
|
|
2025-04-29 22:58:24 +03:00
|
|
|
let (mut websocket_receiver, websocker_sender) = websocket.split(tokio::io::split);
|
|
|
|
let mut user = String::default();
|
|
|
|
let (message_sender, message_receiver) = broadcast::channel(100);
|
|
|
|
|
|
|
|
if let Ok(received_frame) = websocket_receiver
|
|
|
|
.read_frame::<_, WebSocketError>(&mut move |_| async { unreachable!() })
|
|
|
|
.await
|
|
|
|
{
|
2025-04-27 05:52:58 +03:00
|
|
|
if let OpCode::Text = received_frame.opcode {
|
2025-04-29 22:58:24 +03:00
|
|
|
let signal =
|
|
|
|
serde_json::from_slice::<Signal>(&received_frame.payload.to_vec()).unwrap();
|
|
|
|
|
|
|
|
if signal.get_signal_type() == SignalType::Auth && user == String::default() {
|
|
|
|
let new_user = UserMessages {
|
|
|
|
user: signal.get_data(),
|
|
|
|
message_receiver,
|
|
|
|
};
|
|
|
|
user = new_user.user.to_owned();
|
|
|
|
USER_MESSAGES.write().await.push_back(new_user);
|
|
|
|
} else {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
println!("{:#?}", signal);
|
2025-04-16 06:27:08 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|