Make event messaging better; implement klippy_state

suchmememanyskill · suchmememanyskill · commit a6e9360dd331 · 2025-09-22T18:35:24.000+02:00
diff --git a/moonraker-rs/src/connector/read_deserialize.rs b/moonraker-rs/src/connector/read_deserialize.rs
@@ -51,22 +51,23 @@ impl<'de> Deserialize<'de> for JsonRpcNotification {
         struct NotificationHelper {
             jsonrpc: String,
             method: String,
-            params: Vec<serde_json::Value>,
+            params: Option<Vec<serde_json::Value>>,
         }
 
-        let mut helper = NotificationHelper::deserialize(deserializer)?;
+        let helper = NotificationHelper::deserialize(deserializer)?;
 
         let params = match helper.method.as_str() {
             "notify_status_update" => {
-                let parsed_params = serde_json::from_value(helper.params[0].take())
+                let parsed_params = serde_json::from_value(helper.params.unwrap()[0].take())
                     .map_err(serde::de::Error::custom)?;
                 MoonrakerEventParameters::NotifyStatusUpdate(parsed_params)
             }
             "notify_proc_stat_update" => {
-                let parsed_params = serde_json::from_value(helper.params[0].take())
+                let parsed_params = serde_json::from_value(helper.params.unwrap()[0].take())
                     .map_err(serde::de::Error::custom)?;
                 MoonrakerEventParameters::NotifyProcessStatisticsUpdate(parsed_params)
             }
+            "notify_klippy_disconnected" => MoonrakerEventParameters::NotifyKlippyDisconnect,
             _ => return Err(serde::de::Error::custom("Unknown method")),
         };
 
@@ -82,6 +83,7 @@ impl<'de> Deserialize<'de> for JsonRpcNotification {
 pub enum MoonrakerEventParameters {
     NotifyStatusUpdate(MoonrakerEventNotifyStatusUpdate),
     NotifyProcessStatisticsUpdate(MoonrakerNotifyProcStatUpdate),
+    NotifyKlippyDisconnect,
 }
 
 #[derive(Debug)]
diff --git a/moonraker-rs/src/connector/websocket_read.rs b/moonraker-rs/src/connector/websocket_read.rs
@@ -94,6 +94,12 @@ impl MoonrakerConnectionReadLoop {
             } {
                 // TODO: Erorr handling
                 eprintln!("Failed to process websocket event: {:?}", e);
+
+                if let Error::BreakError = e {
+                    #[cfg(debug_assertions)]
+                    println!("Breaking out of read loop");
+                    break;
+                }
             }
         }
     }
@@ -152,6 +158,11 @@ impl MoonrakerConnectionReadLoop {
                     }
                     MoonrakerEventParameters::NotifyProcessStatisticsUpdate(proc_stat_update) => {
                         self.inbound_sender.send(Arc::new(WebsocketEvent::MoonrakerEvent(MoonrakerEvent::NotifyProcessStatisticsUpdate(proc_stat_update)))).expect("Failed to internally send a moonraker process statistics update event");
+                    },
+                    MoonrakerEventParameters::NotifyKlippyDisconnect => {
+                        self.inbound_sender.send(Arc::new(WebsocketEvent::Disconnected)).expect("Failed to internally send a disconnect event");
+                        self.outbound_sender.send(Arc::new(OutboundMessage::EndLoop)).expect("Failed to internally send an endloop event");
+                        return Err(Error::BreakError);
                     }
                 }
             }
diff --git a/moonraker-rs/src/error.rs b/moonraker-rs/src/error.rs
@@ -9,4 +9,6 @@ pub enum Error {
     WebsocketWriteError(#[from] WebSocketError),
     #[error("Unknown error")]
     Unknown(String),
+    #[error("Internally used")]
+    BreakError,
 }
diff --git a/moonraker-rs/src/moonraker_connection.rs b/moonraker-rs/src/moonraker_connection.rs
@@ -13,6 +13,7 @@ use serde_json::Value;
 use std::error::Error;
 use std::fmt::Debug;
 use std::sync::Arc;
+use std::time::Duration;
 use tokio::io::{ReadHalf, WriteHalf};
 use tokio::net::TcpStream;
 use tokio::sync::broadcast::{Receiver, Sender};
@@ -75,7 +76,6 @@ pub struct MoonrakerConnection {
 impl MoonrakerConnection {
     pub fn new(host: &str, port: u16) -> Self {
         let host = format!("{}:{}", host, port);
-        let url = format!("ws://{}/websocket", host);
 
         let req = Request::builder()
             .method("GET")
@@ -173,6 +173,8 @@ impl MoonrakerConnection {
                 }
             };
 
+            // TODO: Wait until Klippy is ready
+
             // TOOD: Don't subscribe to objects we don't have a use for.
             let initial_objects = self
                 .subscribe_to_printer_objects(object_list.objects.clone())
@@ -193,6 +195,7 @@ impl MoonrakerConnection {
 
             reader_handle.await.unwrap();
             writer_handle.await.unwrap();
+            sleep(Duration::from_secs(2)).await;
         }
     }
 
diff --git a/moonraker-rs/src/printer_objects/webhooks.rs b/moonraker-rs/src/printer_objects/webhooks.rs
@@ -1,3 +1,5 @@
+use std::fmt::Display;
+
 use optional_struct::*;
 use serde::Deserialize;
 
@@ -16,6 +18,18 @@ impl Default for KlippyState {
     }
 }
 
+impl Display for KlippyState {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let state_str = match self {
+            KlippyState::Ready => "Ready",
+            KlippyState::Startup => "Startup",
+            KlippyState::Error => "Error",
+            KlippyState::Shutdown => "Shutdown",
+        };
+        write!(f, "{}", state_str)
+    }
+}
+
 #[optional_struct]
 #[derive(Debug, Deserialize, Clone)]
 pub struct Webhooks {
diff --git a/src/application_error.rs b/src/application_error.rs
@@ -6,6 +6,8 @@ pub enum ApplicationError {
     IoError(#[from] std::io::Error),
     #[error("Slint platform error")]
     SlintFailure(#[from] slint::PlatformError),
+    #[error("Event loop error")]
+    EventLoopError(#[from] slint::EventLoopError),
     #[error("Unknown application error")]
     Unknown(String),
 }
diff --git a/src/event_loop/event_loop.rs b/src/event_loop/event_loop.rs
@@ -0,0 +1,86 @@
+use std::sync::Arc;
+
+use moonraker_rs::{connector::websocket_read::{MoonrakerEvent, PrinterEvent}, moonraker_connection::{MoonrakerConnection, WebsocketEvent}};
+use slint::{ComponentHandle, Weak};
+
+use crate::{application_error::ApplicationError, event_loop::{KlipperStateHandler, TemperatureDevicesHandler}, AppState, AppWindow};
+
+pub struct EventLoop
+{
+    pub ui_weak : Weak<AppWindow>,
+    pub moonraker_connection : Arc<MoonrakerConnection>   
+}
+
+impl EventLoop
+{
+    pub fn new(ui_weak : Weak<AppWindow>, moonraker_connection : Arc<MoonrakerConnection>) -> EventLoop
+    {
+        EventLoop { ui_weak: ui_weak, moonraker_connection: moonraker_connection }
+    }
+
+    pub async fn event_loop(&mut self)
+    {
+        let mut receiver = self.moonraker_connection.get_listener();
+        loop 
+        {
+            match receiver.recv().await
+            {
+                Ok(message) => 
+                {
+                    if let Err(e) = match &*message 
+                    {
+                        WebsocketEvent::Connected => self.on_connected().await,
+                        WebsocketEvent::Disconnected => self.on_disconnected().await,
+                        WebsocketEvent::MoonrakerEvent(event) => self.on_event(event).await,
+                        _ => Ok(()),
+                    }
+                    {
+                        eprintln!("Error handling Moonraker message: {}", e);
+                    }
+                },
+                Err(e) => 
+                {
+                    eprintln!("Error receiving message from Moonraker: {}", e);
+                    break;
+                }
+            }
+        }
+    }
+
+    async fn on_connected(&mut self) -> Result<(), ApplicationError>
+    {
+        self.ui_weak
+            .upgrade_in_event_loop(move |ui| ui.global::<AppState>().set_moonraker_connected(true))?;
+
+        Ok(())
+    }
+
+    async fn on_disconnected(&mut self) -> Result<(), ApplicationError>
+    {
+        self.ui_weak
+            .upgrade_in_event_loop(move |ui| {
+                ui.global::<AppState>().set_moonraker_connected(false);
+                ui.global::<AppState>().set_klipper_state("Disconnected".into());
+                ui.global::<AppState>().set_klipper_state_message("Disconnected".into());
+            })?;
+
+        Ok(())
+    }
+
+    async fn on_event(&mut self, moonraker_event : &MoonrakerEvent) -> Result<(), ApplicationError>
+    {
+        match moonraker_event
+        {
+            MoonrakerEvent::NotifyStatusUpdate(printer_event) => self.on_status_update(printer_event).await,
+            _ => Ok(()),
+        }
+    }
+
+    async fn on_status_update(&mut self, printer_event : &PrinterEvent) -> Result<(), ApplicationError>
+    {
+        self.handle_temperature_devices_update(printer_event)?;
+        self.handle_klipper_state_updates(printer_event)?;
+
+        Ok(())
+    }
+}
diff --git a/src/event_loop/klipper_state.rs b/src/event_loop/klipper_state.rs
@@ -0,0 +1,30 @@
+use moonraker_rs::connector::websocket_read::PrinterEvent;
+use slint::{ComponentHandle, SharedString};
+
+use crate::{application_error::ApplicationError, event_loop::EventLoop};
+
+pub trait KlipperStateHandler {
+    fn handle_klipper_state_updates(
+        &mut self,
+        printer_event: &PrinterEvent,
+    ) -> Result<(), ApplicationError>;
+}
+
+impl KlipperStateHandler for EventLoop {
+    fn handle_klipper_state_updates(
+        &mut self,
+        printer_event: &PrinterEvent,
+    ) -> Result<(), ApplicationError> {
+        if let PrinterEvent::Webhooks(webhooks) = printer_event {
+            let state = SharedString::from(webhooks.state.to_string());
+            let state_message = SharedString::from(&webhooks.state_message);
+
+            self.ui_weak.upgrade_in_event_loop(move |ui| {
+                ui.global::<crate::AppState>().set_klipper_state(state);
+                ui.global::<crate::AppState>().set_klipper_state_message(state_message);
+            })?;
+        }
+
+        Ok(())
+    }
+}
diff --git a/src/event_loop/mod.rs b/src/event_loop/mod.rs
@@ -0,0 +1,7 @@
+pub mod event_loop;
+pub mod temperature_devices;
+pub mod klipper_state;
+
+pub use event_loop::*;
+pub use temperature_devices::*;
+pub use klipper_state::*;
diff --git a/src/event_loop/temperature_devices.rs b/src/event_loop/temperature_devices.rs
@@ -0,0 +1,123 @@
+use std::rc::Rc;
+
+use moonraker_rs::connector::websocket_read::PrinterEvent;
+use slint::{ComponentHandle, Model, ModelRc, SharedString, VecModel};
+
+use crate::{
+    application_error::ApplicationError, event_loop::EventLoop, AppWindow, Heater, HeaterFan, TemperatureSensor, TemperatureSensors
+};
+
+pub trait TemperatureDevicesHandler {
+    fn handle_temperature_devices_update(
+        &mut self,
+        printer_event: &PrinterEvent,
+    ) -> Result<(), ApplicationError>;
+}
+
+impl TemperatureDevicesHandler for EventLoop {
+    fn handle_temperature_devices_update(
+        &mut self,
+        printer_event: &PrinterEvent,
+    ) -> Result<(), ApplicationError> {
+        if let PrinterEvent::Extruder(extruder_event) = printer_event {
+            let extruder = Heater {
+                name: SharedString::from("extruder"),
+                target: extruder_event.target as i32,
+                temperature: extruder_event.temperature as i32,
+            };
+
+            self.ui_weak
+                .upgrade_in_event_loop(Box::new(move |ui: AppWindow| {
+                    ui.global::<TemperatureSensors>().set_extruder(extruder)
+                }))?;
+        }
+
+        if let PrinterEvent::HeaterBed(heater_bed_event) = printer_event {
+            let bed = Heater {
+                name: SharedString::from("heated_bed"),
+                target: heater_bed_event.target as i32,
+                temperature: heater_bed_event.temperature as i32,
+            };
+
+            self.ui_weak.upgrade_in_event_loop(move |ui: AppWindow| {
+                ui.global::<TemperatureSensors>().set_heated_bed(bed)
+            })?;
+        }
+
+        if let PrinterEvent::TemperatureSensor(temperature_sensor_event) = printer_event {
+            let sensor_event = TemperatureSensor {
+                name: SharedString::from(&temperature_sensor_event.name),
+                temperature: temperature_sensor_event.sensor.temperature as i32,
+            };
+
+            self.ui_weak
+                .upgrade_in_event_loop(move |ui| {
+                    let temperature_sensors =
+                        ui.global::<TemperatureSensors>().get_temperature_sensors();
+                    let current_sensors = temperature_sensors
+                        .as_any()
+                        .downcast_ref::<VecModel<TemperatureSensor>>();
+
+                    let mut entries = match &current_sensors {
+                        Some(model) => model.iter().collect::<Vec<TemperatureSensor>>(),
+                        None => vec![],
+                    };
+
+                    let index = entries
+                        .iter()
+                        .position(|sensor| sensor.name == sensor_event.name);
+
+                    match index {
+                        Some(index) => entries[index].temperature = sensor_event.temperature as i32,
+                        None => entries.push(sensor_event),
+                    }
+
+                    ui.global::<TemperatureSensors>()
+                        .set_temperature_sensors(ModelRc::new(Rc::new(VecModel::from(entries))));
+                })?;
+        }
+
+        if let PrinterEvent::TemperatureFan(temperature_fan_event) = printer_event {
+            let sensor_event = HeaterFan {
+                heater: Heater {
+                    name: SharedString::from(&temperature_fan_event.name),
+                    temperature: temperature_fan_event.fan.temperature as i32,
+                    target: temperature_fan_event.fan.target as i32,
+                },
+                speed: temperature_fan_event.fan.speed,
+            };
+
+            self.ui_weak
+                .upgrade_in_event_loop(move |ui| {
+                    let heater_fans =
+                        ui.global::<TemperatureSensors>().get_heater_fans();
+                    let current_sensors = heater_fans
+                        .as_any()
+                        .downcast_ref::<VecModel<HeaterFan>>();
+
+                    let mut entries = match &current_sensors {
+                        Some(model) => model.iter().collect::<Vec<HeaterFan>>(),
+                        None => vec![],
+                    };
+
+                    let index = entries
+                        .iter()
+                        .position(|sensor| sensor.heater.name == sensor_event.heater.name);
+
+                    match index {
+                        Some(index) => {
+                            entries[index].heater.temperature = sensor_event.heater.temperature;
+                            entries[index].heater.target = sensor_event.heater.target;
+                            entries[index].speed = sensor_event.speed;
+                        },
+                        None => entries.push(sensor_event),
+                    }
+
+                    ui.global::<TemperatureSensors>()
+                        .set_heater_fans(ModelRc::new(Rc::new(VecModel::from(entries))));
+                })?;
+        }
+
+        Ok(())
+    }
+}
diff --git a/src/main.rs b/src/main.rs
diff --git a/ui/main.slint b/ui/main.slint
diff --git a/ui/state.slint b/ui/state.slint

Original file line number	Diff line number	Diff line change
`@@ -94,6 +94,12 @@ impl MoonrakerConnectionReadLoop {`
`94`	`94`	`} {`
`95`	`95`	`// TODO: Erorr handling`
`96`	`96`	`eprintln!("Failed to process websocket event: {:?}", e);`
	`97`	`+`
	`98`	`+ if let Error::BreakError = e {`
	`99`	`+ #[cfg(debug_assertions)]`
	`100`	`+ println!("Breaking out of read loop");`
	`101`	`+ break;`
	`102`	`+ }`
`97`	`103`	`}`
`98`	`104`	`}`
`99`	`105`	`}`
`@@ -152,6 +158,11 @@ impl MoonrakerConnectionReadLoop {`
`152`	`158`	`}`
`153`	`159`	`MoonrakerEventParameters::NotifyProcessStatisticsUpdate(proc_stat_update) => {`
`154`	`160`	`self.inbound_sender.send(Arc::new(WebsocketEvent::MoonrakerEvent(MoonrakerEvent::NotifyProcessStatisticsUpdate(proc_stat_update)))).expect("Failed to internally send a moonraker process statistics update event");`
	`161`	`+ },`
	`162`	`+ MoonrakerEventParameters::NotifyKlippyDisconnect => {`
	`163`	`+ self.inbound_sender.send(Arc::new(WebsocketEvent::Disconnected)).expect("Failed to internally send a disconnect event");`
	`164`	`+ self.outbound_sender.send(Arc::new(OutboundMessage::EndLoop)).expect("Failed to internally send an endloop event");`
	`165`	`+ return Err(Error::BreakError);`
`155`	`166`	`}`
`156`	`167`	`}`
`157`	`168`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,4 +9,6 @@ pub enum Error {`
`9`	`9`	`WebsocketWriteError(#[from] WebSocketError),`
`10`	`10`	`#[error("Unknown error")]`
`11`	`11`	`Unknown(String),`
	`12`	`+ #[error("Internally used")]`
	`13`	`+ BreakError,`
`12`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,8 @@ pub enum ApplicationError {`
`6`	`6`	`IoError(#[from] std::io::Error),`
`7`	`7`	`#[error("Slint platform error")]`
`8`	`8`	`SlintFailure(#[from] slint::PlatformError),`
	`9`	`+ #[error("Event loop error")]`
	`10`	`+ EventLoopError(#[from] slint::EventLoopError),`
`9`	`11`	`#[error("Unknown application error")]`
`10`	`12`	`Unknown(String),`
`11`	`13`	`}`