rust_webrtc/server/src/signal.rs

79 lines
2.4 KiB
Rust
Raw Normal View History

2025-04-29 22:58:24 +03:00
use std::{collections::VecDeque, sync::LazyLock};
use axum::{Router, http::StatusCode, response::IntoResponse, routing::get};
use fastwebsockets::{
2025-04-29 22:58:24 +03:00
FragmentCollectorRead, OpCode, WebSocketError,
upgrade::{IncomingUpgrade, UpgradeFut},
};
2025-04-29 22:58:24 +03:00
use protocol::{Signal, SignalType};
use tokio::{
net::TcpListener,
sync::{RwLock, broadcast},
};
use tower_http::cors::CorsLayer;
const SERVER_ADDRESS: &str = "192.168.1.3:4546";
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>,
}
pub async fn start_signalling() {
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
{
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);
}
}
}