core/src/frontend.rs
2021-02-18 09:44:22 +00:00

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 }
}
}