91 lines
2.3 KiB
Rust
91 lines
2.3 KiB
Rust
use log::info;
|
|
use tokio::sync::mpsc::{channel, Receiver, Sender};
|
|
|
|
use crate::events::{ActorMessage};
|
|
use crate::BoxError;
|
|
use futures_util::stream::TryStreamExt;
|
|
use futures_util::StreamExt;
|
|
|
|
use std::net::SocketAddr;
|
|
|
|
use tokio::net::{TcpListener, TcpStream};
|
|
use tokio_tungstenite::accept_async;
|
|
|
|
#[derive(Debug)]
|
|
pub struct FrontendManager {
|
|
receiver: Receiver<ActorMessage>,
|
|
}
|
|
|
|
impl FrontendManager {
|
|
pub fn new(receiver: Receiver<ActorMessage>) -> Self {
|
|
Self { receiver }
|
|
}
|
|
|
|
async fn handle_ws_connection(stream: TcpStream, addr: SocketAddr) -> Result<(), BoxError> {
|
|
let websocket = accept_async(stream).await?;
|
|
info!("Received WebSocket connection <{:?}>", addr);
|
|
|
|
let (_, ws_in) = websocket.split();
|
|
|
|
let on_received = ws_in.try_for_each(move |msg| {
|
|
info!(
|
|
"Received a message from {:?}: {}",
|
|
addr,
|
|
msg.to_text().unwrap()
|
|
);
|
|
|
|
futures_util::future::ok(())
|
|
});
|
|
|
|
tokio::spawn(on_received);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn websocket() -> Result<(), BoxError> {
|
|
let server = TcpListener::bind("127.0.0.1:3012").await?;
|
|
|
|
while let Ok((stream, addr)) = server.accept().await {
|
|
tokio::spawn(FrontendManager::handle_ws_connection(stream, addr));
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn handle_message(&mut self, message: ActorMessage) -> Result<(), BoxError> {
|
|
match message.message {
|
|
_ => {}
|
|
}
|
|
|
|
Ok(message
|
|
.respond_to
|
|
.send((None, None))
|
|
.map_err(|_| BoxError::from("Could not send message."))?)
|
|
}
|
|
}
|
|
|
|
pub struct FrontendManagerHandle {
|
|
sender: Sender<ActorMessage>,
|
|
}
|
|
|
|
impl FrontendManagerHandle {
|
|
// async fn run_frontend_manager(mut manager: FrontendManager) {
|
|
// info!("Frontend handler ready");
|
|
//
|
|
// while let Some(msg) = manager.receiver.recv().await {
|
|
// manager.handle_message(msg).await.unwrap();
|
|
// }
|
|
// }
|
|
|
|
pub fn new() -> Self {
|
|
let (sender, receiver) = channel(1);
|
|
|
|
let _frontend = FrontendManager::new(receiver);
|
|
|
|
tokio::spawn(FrontendManager::websocket());
|
|
// tokio::spawn(FrontendManagerHandle::run_frontend_manager(frontend));
|
|
|
|
Self { sender }
|
|
}
|
|
}
|