152 lines
4.3 KiB
Rust
152 lines
4.3 KiB
Rust
use crate::page;
|
|
use common::{ClientMessage, ServerMessage};
|
|
use seed::app::orders::OrdersContainer;
|
|
use seed::prelude::*;
|
|
use seed::{log, window};
|
|
use seed_router::Router;
|
|
use std::collections::VecDeque;
|
|
|
|
pub type AppOrders = OrdersContainer<Msg, Model, Vec<Node<Msg>>>;
|
|
|
|
/// Delays between successive attempts to reconnect in case the socket breaks. In seconds.
|
|
const TIMEOUT_CONNECT_DELAYS: &[u32] = &[2, 5, 10, 10, 10, 20, 30, 60, 120, 300];
|
|
|
|
pub struct Model {
|
|
page: Pages,
|
|
send_queue: VecDeque<ClientMessage>,
|
|
socket: WebSocket,
|
|
ws_url: String,
|
|
timeout_count: usize,
|
|
}
|
|
|
|
#[derive(Router)]
|
|
pub enum Pages {
|
|
#[page("404", NotFound)]
|
|
NotFound(page::not_found::Model),
|
|
|
|
#[page("info", Info)]
|
|
Info(page::info::Model),
|
|
|
|
#[page("lights", Lights)]
|
|
Lights(page::lights::Model),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum PageMsg {
|
|
NotFound(page::not_found::Msg),
|
|
Info(page::info::Msg),
|
|
Lights(page::lights::Msg),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum Msg {
|
|
Page(PageMsg),
|
|
|
|
SendMessage(ClientMessage),
|
|
FlushMessageQueue,
|
|
|
|
// Global
|
|
Connect,
|
|
SocketOpened(),
|
|
SocketClosed(CloseEvent),
|
|
SocketError(),
|
|
SocketMessage(WebSocketMessage),
|
|
}
|
|
|
|
pub fn init(url: Url, orders: &mut impl Orders<Msg>) -> Model {
|
|
orders.subscribe(Msg::SendMessage);
|
|
|
|
let location = window().location();
|
|
let host = location.host().expect("Failed to get hostname");
|
|
let ws_protocol = match location.protocol().ok().as_deref() {
|
|
Some("http:") => "ws",
|
|
_ => "wss",
|
|
};
|
|
|
|
let ws_url = format!("{ws_protocol}://{host}/api/ws");
|
|
|
|
Model {
|
|
page: Pages::from_url(url, &mut orders.proxy(Msg::Page))
|
|
.unwrap_or(Pages::NotFound(Default::default())),
|
|
send_queue: Default::default(),
|
|
socket: open_socket(&ws_url, orders),
|
|
ws_url,
|
|
timeout_count: 0,
|
|
}
|
|
}
|
|
|
|
fn open_socket(url: &str, orders: &mut impl Orders<Msg>) -> WebSocket {
|
|
WebSocket::builder(url, orders)
|
|
.on_open(Msg::SocketOpened)
|
|
.on_close(Msg::SocketClosed)
|
|
.on_error(Msg::SocketError)
|
|
.on_message(Msg::SocketMessage)
|
|
.build_and_open()
|
|
.expect("failed to open websocket")
|
|
}
|
|
|
|
pub fn update(msg: Msg, model: &mut Model, orders: &mut AppOrders) {
|
|
#[cfg(debug_assertions)]
|
|
log!(format!("{msg:?}"));
|
|
|
|
match msg {
|
|
Msg::Page(msg) => model.page.update(msg, &mut orders.proxy(Msg::Page)),
|
|
Msg::FlushMessageQueue => {
|
|
while let Some(message) = model.send_queue.pop_front() {
|
|
let serialized = ron::to_string(&message).unwrap();
|
|
|
|
if let Err(e) = model.socket.send_text(serialized) {
|
|
model.send_queue.push_front(message);
|
|
log!(e);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Msg::Connect => {
|
|
model.socket = open_socket(&model.ws_url, orders);
|
|
}
|
|
Msg::SendMessage(message) => {
|
|
model.send_queue.push_back(message);
|
|
orders.send_msg(Msg::FlushMessageQueue);
|
|
}
|
|
Msg::SocketOpened() => {
|
|
model.timeout_count = 0;
|
|
orders.send_msg(Msg::FlushMessageQueue);
|
|
}
|
|
Msg::SocketClosed(_event) => {
|
|
let timeout_sec = TIMEOUT_CONNECT_DELAYS[model.timeout_count];
|
|
let timeout_ms = timeout_sec * 1000;
|
|
orders.perform_cmd(cmds::timeout(timeout_ms, || Msg::Connect));
|
|
|
|
log!(format!(
|
|
"Socket closed, trying to reconnect in {timeout_sec} seconds"
|
|
));
|
|
|
|
model.timeout_count = TIMEOUT_CONNECT_DELAYS.len().min(model.timeout_count + 1);
|
|
}
|
|
Msg::SocketError() => {}
|
|
Msg::SocketMessage(message) => {
|
|
if let Err(e) = handle_ws_msg(message, orders) {
|
|
log!(e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn handle_ws_msg(message: WebSocketMessage, orders: &mut impl Orders<Msg>) -> anyhow::Result<()> {
|
|
let message = message.text().map_err(|e| anyhow::format_err!("{e:?}"))?;
|
|
let message: ServerMessage = ron::from_str(&message)?;
|
|
orders.notify(message);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn view(model: &Model) -> Vec<Node<Msg>> {
|
|
vec![model.page.view().map_msg(Msg::Page)]
|
|
//match &model.page {
|
|
// Pages::NotFound => vec![h1!["Not Found"]],
|
|
// Pages::InfoScreen => vec![div![C![C.info_box], raw![&model.info_page]]],
|
|
// Pages::Lights(page) => vec![],
|
|
//}
|
|
}
|