From c524d089adc0698a8d823e10c1e8adf17039a7b8 Mon Sep 17 00:00:00 2001
From: Tobias Reisinger <tobias@msrg.cc>
Date: Tue, 14 May 2024 01:23:34 +0200
Subject: [PATCH 01/10] Move websocket handlers
---
src/settings.rs | 2 +-
src/ws/handlers.rs | 166 ++++++++++++++++++++++++++++++++++++++++++++
src/ws/mod.rs | 169 ++-------------------------------------------
3 files changed, 174 insertions(+), 163 deletions(-)
create mode 100644 src/ws/handlers.rs
diff --git a/src/settings.rs b/src/settings.rs
index a5fd5bf..15d91bd 100644
--- a/src/settings.rs
+++ b/src/settings.rs
@@ -71,7 +71,7 @@ impl Settings {
initial_states: Vec<bool>,
) -> Result<Vec<Box<dyn drivers::RelayDriver>>, EmgauwaError> {
let mut drivers = Vec::new();
- let result: Result<(), EmgauwaError> = self.relays.iter().zip(initial_states.into_iter()).try_for_each(|(relay, state)| {
+ let result: Result<(), EmgauwaError> = self.relays.iter().zip(initial_states).try_for_each(|(relay, state)| {
let driver = relay.make_driver(pfd, state)?;
drivers.push(driver);
Ok(())
diff --git a/src/ws/handlers.rs b/src/ws/handlers.rs
new file mode 100644
index 0000000..7af953a
--- /dev/null
+++ b/src/ws/handlers.rs
@@ -0,0 +1,166 @@
+use actix::Addr;
+use sqlx::{Pool, Sqlite};
+use sqlx::pool::PoolConnection;
+use tokio_tungstenite::tungstenite;
+use tokio_tungstenite::tungstenite::Message;
+use emgauwa_common::db::{DbController, DbJunctionRelaySchedule, DbRelay, DbSchedule};
+use emgauwa_common::errors::{DatabaseError, EmgauwaError};
+use emgauwa_common::models::{Controller, Relay};
+use emgauwa_common::types::{ControllerWsAction, ScheduleUid};
+use crate::app_state::AppState;
+use crate::utils;
+use crate::utils::app_state_get_this;
+
+pub async fn handle_message(
+ pool: Pool<Sqlite>,
+ app_state: &Addr<AppState>,
+ message_result: Result<Message, tungstenite::Error>,
+) {
+ let msg = match message_result {
+ Ok(msg) => msg,
+ Err(err) => {
+ log::error!("Error reading message: {}", err);
+ return;
+ }
+ };
+ if let Message::Text(text) = msg {
+ match serde_json::from_str(&text) {
+ Ok(action) => {
+ log::debug!("Received action: {:?}", action);
+ let mut pool_conn = match pool.acquire().await {
+ Ok(conn) => conn,
+ Err(err) => {
+ log::error!("Failed to acquire database connection: {:?}", err);
+ return;
+ }
+ };
+ let action_res = handle_action(&mut pool_conn, app_state, action).await;
+ if let Err(e) = action_res {
+ log::error!("Error handling action: {:?}", e);
+ }
+ }
+ Err(e) => {
+ log::error!("Error deserializing action: {:?}", e);
+ }
+ }
+ }
+}
+
+pub async fn handle_action(
+ conn: &mut PoolConnection<Sqlite>,
+ app_state: &Addr<AppState>,
+ action: ControllerWsAction,
+) -> Result<(), EmgauwaError> {
+ let this = app_state_get_this(app_state).await?;
+
+ match action {
+ ControllerWsAction::Controller(controller) => {
+ handle_controller(conn, &this, controller).await?
+ }
+ ControllerWsAction::Relays(relays) => handle_relays(conn, &this, relays).await?,
+ ControllerWsAction::Schedules(schedules) => handle_schedules(conn, schedules).await?,
+ ControllerWsAction::RelayPulse((relay_num, duration)) => {
+ handle_relay_pulse(app_state, relay_num, duration).await?
+ }
+ _ => return Ok(()),
+ };
+
+ utils::app_state_reload(app_state).await
+}
+
+async fn handle_controller(
+ conn: &mut PoolConnection<Sqlite>,
+ this: &Controller,
+ controller: Controller,
+) -> Result<(), EmgauwaError> {
+ if controller.c.uid != this.c.uid {
+ return Err(EmgauwaError::Other(String::from(
+ "Controller UID mismatch during update",
+ )));
+ }
+ DbController::get_by_uid(conn, &controller.c.uid)
+ .await?
+ .ok_or(DatabaseError::NotFound)?
+ .update(conn, controller.c.name.as_str(), this.c.relay_count)
+ .await?;
+
+ Ok(())
+}
+
+async fn handle_schedules(
+ conn: &mut PoolConnection<Sqlite>,
+ schedules: Vec<DbSchedule>,
+) -> Result<(), EmgauwaError> {
+ let mut handled_uids = vec![
+ // on and off schedules are always present and should not be updated
+ ScheduleUid::On,
+ ScheduleUid::Off,
+ ];
+ for schedule in schedules {
+ if handled_uids.contains(&schedule.uid) {
+ continue;
+ }
+ handled_uids.push(schedule.uid.clone());
+
+ log::debug!("Handling schedule: {:?}", schedule);
+ let schedule_db = DbSchedule::get_by_uid(conn, &schedule.uid).await?;
+
+ if let Some(schedule_db) = schedule_db {
+ schedule_db
+ .update(conn, schedule.name.as_str(), &schedule.periods)
+ .await?;
+ } else {
+ DbSchedule::create(
+ conn,
+ schedule.uid.clone(),
+ schedule.name.as_str(),
+ &schedule.periods,
+ )
+ .await?;
+ }
+ }
+
+ Ok(())
+}
+
+async fn handle_relays(
+ conn: &mut PoolConnection<Sqlite>,
+ this: &Controller,
+ relays: Vec<Relay>,
+) -> Result<(), EmgauwaError> {
+ for relay in relays {
+ if relay.controller.uid != this.c.uid {
+ return Err(EmgauwaError::Other(String::from(
+ "Controller UID mismatch during relay update",
+ )));
+ }
+ let db_relay = DbRelay::get_by_controller_and_num(conn, &this.c, relay.r.number)
+ .await?
+ .ok_or(DatabaseError::NotFound)?;
+
+ db_relay.update(conn, relay.r.name.as_str()).await?;
+
+ handle_schedules(conn, relay.schedules.clone()).await?;
+
+ let mut schedules = Vec::new(); // We need to get the schedules from the database to have the right IDs
+ for schedule in relay.schedules {
+ schedules.push(
+ DbSchedule::get_by_uid(conn, &schedule.uid)
+ .await?
+ .ok_or(DatabaseError::NotFound)?,
+ );
+ }
+
+ DbJunctionRelaySchedule::set_schedules(conn, &db_relay, schedules.iter().collect()).await?;
+ }
+
+ Ok(())
+}
+
+async fn handle_relay_pulse(
+ app_state: &Addr<AppState>,
+ relay_num: i64,
+ duration: Option<u32>,
+) -> Result<(), EmgauwaError> {
+ utils::app_state_relay_pulse(app_state, relay_num, duration).await
+}
diff --git a/src/ws/mod.rs b/src/ws/mod.rs
index 994cec6..a79b13c 100644
--- a/src/ws/mod.rs
+++ b/src/ws/mod.rs
@@ -1,19 +1,18 @@
+mod handlers;
+
use actix::Addr;
use emgauwa_common::constants::WEBSOCKET_RETRY_TIMEOUT;
-use emgauwa_common::db::{DbController, DbJunctionRelaySchedule, DbRelay, DbSchedule};
-use emgauwa_common::errors::{DatabaseError, EmgauwaError};
-use emgauwa_common::models::{Controller, Relay};
-use emgauwa_common::types::{ControllerWsAction, ScheduleUid};
+use emgauwa_common::errors::EmgauwaError;
+use emgauwa_common::types::ControllerWsAction;
use futures::{future, pin_mut, SinkExt, StreamExt};
-use sqlx::pool::PoolConnection;
use sqlx::{Pool, Sqlite};
use tokio::time;
use tokio_tungstenite::tungstenite::Message;
-use tokio_tungstenite::{connect_async, tungstenite};
+use tokio_tungstenite::connect_async;
use crate::app_state::AppState;
-use crate::utils;
use crate::utils::{app_state_get_relay_notifier, app_state_get_this};
+use crate::ws::handlers::handle_message;
pub async fn run_ws_loop(pool: Pool<Sqlite>, app_state: Addr<AppState>, url: String) {
log::debug!("Spawned ws loop");
@@ -90,158 +89,4 @@ async fn read_app_state(
))
})?;
}
-}
-
-async fn handle_message(
- pool: Pool<Sqlite>,
- app_state: &Addr<AppState>,
- message_result: Result<Message, tungstenite::Error>,
-) {
- let msg = match message_result {
- Ok(msg) => msg,
- Err(err) => {
- log::error!("Error reading message: {}", err);
- return;
- }
- };
- if let Message::Text(text) = msg {
- match serde_json::from_str(&text) {
- Ok(action) => {
- log::debug!("Received action: {:?}", action);
- let mut pool_conn = match pool.acquire().await {
- Ok(conn) => conn,
- Err(err) => {
- log::error!("Failed to acquire database connection: {:?}", err);
- return;
- }
- };
- let action_res = handle_action(&mut pool_conn, app_state, action).await;
- if let Err(e) = action_res {
- log::error!("Error handling action: {:?}", e);
- }
- }
- Err(e) => {
- log::error!("Error deserializing action: {:?}", e);
- }
- }
- }
-}
-
-pub async fn handle_action(
- conn: &mut PoolConnection<Sqlite>,
- app_state: &Addr<AppState>,
- action: ControllerWsAction,
-) -> Result<(), EmgauwaError> {
- let this = app_state_get_this(app_state).await?;
-
- match action {
- ControllerWsAction::Controller(controller) => {
- handle_controller(conn, &this, controller).await?
- }
- ControllerWsAction::Relays(relays) => handle_relays(conn, &this, relays).await?,
- ControllerWsAction::Schedules(schedules) => handle_schedules(conn, schedules).await?,
- ControllerWsAction::RelayPulse((relay_num, duration)) => {
- handle_relay_pulse(app_state, relay_num, duration).await?
- }
- _ => return Ok(()),
- };
-
- utils::app_state_reload(app_state).await
-}
-
-async fn handle_controller(
- conn: &mut PoolConnection<Sqlite>,
- this: &Controller,
- controller: Controller,
-) -> Result<(), EmgauwaError> {
- if controller.c.uid != this.c.uid {
- return Err(EmgauwaError::Other(String::from(
- "Controller UID mismatch during update",
- )));
- }
- DbController::get_by_uid(conn, &controller.c.uid)
- .await?
- .ok_or(DatabaseError::NotFound)?
- .update(conn, controller.c.name.as_str(), this.c.relay_count)
- .await?;
-
- Ok(())
-}
-
-async fn handle_schedules(
- conn: &mut PoolConnection<Sqlite>,
- schedules: Vec<DbSchedule>,
-) -> Result<(), EmgauwaError> {
- let mut handled_uids = vec![
- // on and off schedules are always present and should not be updated
- ScheduleUid::On,
- ScheduleUid::Off,
- ];
- for schedule in schedules {
- if handled_uids.contains(&schedule.uid) {
- continue;
- }
- handled_uids.push(schedule.uid.clone());
-
- log::debug!("Handling schedule: {:?}", schedule);
- let schedule_db = DbSchedule::get_by_uid(conn, &schedule.uid).await?;
-
- if let Some(schedule_db) = schedule_db {
- schedule_db
- .update(conn, schedule.name.as_str(), &schedule.periods)
- .await?;
- } else {
- DbSchedule::create(
- conn,
- schedule.uid.clone(),
- schedule.name.as_str(),
- &schedule.periods,
- )
- .await?;
- }
- }
-
- Ok(())
-}
-
-async fn handle_relays(
- conn: &mut PoolConnection<Sqlite>,
- this: &Controller,
- relays: Vec<Relay>,
-) -> Result<(), EmgauwaError> {
- for relay in relays {
- if relay.controller.uid != this.c.uid {
- return Err(EmgauwaError::Other(String::from(
- "Controller UID mismatch during relay update",
- )));
- }
- let db_relay = DbRelay::get_by_controller_and_num(conn, &this.c, relay.r.number)
- .await?
- .ok_or(DatabaseError::NotFound)?;
-
- db_relay.update(conn, relay.r.name.as_str()).await?;
-
- handle_schedules(conn, relay.schedules.clone()).await?;
-
- let mut schedules = Vec::new(); // We need to get the schedules from the database to have the right IDs
- for schedule in relay.schedules {
- schedules.push(
- DbSchedule::get_by_uid(conn, &schedule.uid)
- .await?
- .ok_or(DatabaseError::NotFound)?,
- );
- }
-
- DbJunctionRelaySchedule::set_schedules(conn, &db_relay, schedules.iter().collect()).await?;
- }
-
- Ok(())
-}
-
-async fn handle_relay_pulse(
- app_state: &Addr<AppState>,
- relay_num: i64,
- duration: Option<u32>,
-) -> Result<(), EmgauwaError> {
- utils::app_state_relay_pulse(app_state, relay_num, duration).await
-}
+}
\ No newline at end of file
From bf3192ec65023fef1ca372b7a1c339d2f5839808 Mon Sep 17 00:00:00 2001
From: Tobias Reisinger <tobias@msrg.cc>
Date: Thu, 23 May 2024 20:16:44 +0200
Subject: [PATCH 02/10] Format code a bit
---
Cargo.lock | 117 +++++++++++++++++++++++++++++++++++++++---
src/drivers/mod.rs | 1 +
src/drivers/piface.rs | 8 +--
src/errors.rs | 4 +-
src/main.rs | 20 ++++----
src/settings.rs | 17 +++---
src/ws/mod.rs | 4 +-
7 files changed, 141 insertions(+), 30 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
index 637c455..6b6c5dc 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -55,7 +55,7 @@ dependencies = [
"actix-service",
"actix-utils",
"ahash",
- "base64",
+ "base64 0.21.7",
"bitflags 2.5.0",
"brotli",
"bytes",
@@ -355,6 +355,12 @@ version = "0.21.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
[[package]]
name = "base64ct"
version = "1.6.0"
@@ -626,6 +632,41 @@ dependencies = [
"typenum",
]
+[[package]]
+name = "darling"
+version = "0.20.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83b2eb4d90d12bdda5ed17de686c2acb4c57914f8f921b8da7e112b5a36f3fe1"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.20.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "622687fe0bac72a04e5599029151f5796111b90f1baaa9b544d807a5e31cd120"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 2.0.61",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.20.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "733cabb43482b1a1b53eee8583c2b9e8684d592215ea83efd305dd31bc2f0178"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn 2.0.61",
+]
+
[[package]]
name = "data-encoding"
version = "2.6.0"
@@ -650,6 +691,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
dependencies = [
"powerfmt",
+ "serde",
]
[[package]]
@@ -717,6 +759,7 @@ dependencies = [
"serde",
"serde_derive",
"serde_json",
+ "serde_with",
"simple_logger",
"sqlx",
"uuid",
@@ -973,13 +1016,19 @@ dependencies = [
"futures-sink",
"futures-util",
"http 0.2.12",
- "indexmap",
+ "indexmap 2.2.6",
"slab",
"tokio",
"tokio-util",
"tracing",
]
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
[[package]]
name = "hashbrown"
version = "0.13.2"
@@ -1110,6 +1159,12 @@ dependencies = [
"cc",
]
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
[[package]]
name = "idna"
version = "0.5.0"
@@ -1120,6 +1175,17 @@ dependencies = [
"unicode-normalization",
]
+[[package]]
+name = "indexmap"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
+dependencies = [
+ "autocfg",
+ "hashbrown 0.12.3",
+ "serde",
+]
+
[[package]]
name = "indexmap"
version = "2.2.6"
@@ -1128,6 +1194,7 @@ checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
dependencies = [
"equivalent",
"hashbrown 0.14.5",
+ "serde",
]
[[package]]
@@ -1660,7 +1727,7 @@ version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b91f7eff05f748767f183df4320a63d6936e9c6107d97c9e6bdd9784f4289c94"
dependencies = [
- "base64",
+ "base64 0.21.7",
"bitflags 2.5.0",
"serde",
"serde_derive",
@@ -1836,6 +1903,36 @@ dependencies = [
"serde",
]
+[[package]]
+name = "serde_with"
+version = "3.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ad483d2ab0149d5a5ebcd9972a3852711e0153d863bf5a5d0391d28883c4a20"
+dependencies = [
+ "base64 0.22.1",
+ "chrono",
+ "hex",
+ "indexmap 1.9.3",
+ "indexmap 2.2.6",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "serde_with_macros",
+ "time",
+]
+
+[[package]]
+name = "serde_with_macros"
+version = "3.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65569b702f41443e8bc8bbb1c5779bd0450bbe723b56198980e80ec45780bce2"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.61",
+]
+
[[package]]
name = "sha1"
version = "0.10.6"
@@ -1984,7 +2081,7 @@ dependencies = [
"futures-util",
"hashlink",
"hex",
- "indexmap",
+ "indexmap 2.2.6",
"log",
"memchr",
"once_cell",
@@ -2047,7 +2144,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ed31390216d20e538e447a7a9b959e06ed9fc51c37b514b46eb758016ecd418"
dependencies = [
"atoi",
- "base64",
+ "base64 0.21.7",
"bitflags 2.5.0",
"byteorder",
"bytes",
@@ -2089,7 +2186,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7c824eb80b894f926f89a0b9da0c7f435d27cdd35b8c655b114e58223918577e"
dependencies = [
"atoi",
- "base64",
+ "base64 0.21.7",
"bitflags 2.5.0",
"byteorder",
"crc",
@@ -2154,6 +2251,12 @@ dependencies = [
"unicode-normalization",
]
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
[[package]]
name = "subtle"
version = "2.5.0"
@@ -2364,7 +2467,7 @@ version = "0.22.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d3328d4f68a705b2a4498da1d580585d39a6510f98318a2cec3018a7ec61ddef"
dependencies = [
- "indexmap",
+ "indexmap 2.2.6",
"serde",
"serde_spanned",
"toml_datetime",
diff --git a/src/drivers/mod.rs b/src/drivers/mod.rs
index 9c0c971..35d9754 100644
--- a/src/drivers/mod.rs
+++ b/src/drivers/mod.rs
@@ -2,6 +2,7 @@ pub use gpio::GpioDriver;
pub use null::NullDriver;
pub use piface::PiFaceDriver;
use serde::{Deserialize, Deserializer};
+
use crate::errors::EmgauwaControllerError;
mod gpio;
diff --git a/src/drivers/piface.rs b/src/drivers/piface.rs
index 4a0baf0..0af161a 100644
--- a/src/drivers/piface.rs
+++ b/src/drivers/piface.rs
@@ -11,9 +11,11 @@ pub struct PiFaceDriver {
impl PiFaceDriver {
pub fn new(pin: u8, pfd: &Option<PiFaceDigital>) -> Result<Self, EmgauwaControllerError> {
- let pfd = pfd.as_ref().ok_or(EmgauwaControllerError::Hardware(String::from(
- "PiFaceDigital not initialized",
- )))?;
+ let pfd = pfd
+ .as_ref()
+ .ok_or(EmgauwaControllerError::Hardware(String::from(
+ "PiFaceDigital not initialized",
+ )))?;
let pfd_pin = pfd.get_output_pin(pin)?;
Ok(Self { pfd_pin })
}
diff --git a/src/errors.rs b/src/errors.rs
index 3916180..a13f4b1 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -1,10 +1,10 @@
use std::fmt::{Display, Formatter};
+
+use emgauwa_common::errors::EmgauwaError;
use rppal::gpio;
use rppal_mcp23s17::Mcp23s17Error;
use rppal_pfd::PiFaceDigitalError;
-use emgauwa_common::errors::EmgauwaError;
-
#[derive(Debug)]
pub enum EmgauwaControllerError {
Hardware(String),
diff --git a/src/main.rs b/src/main.rs
index bbb1a79..f9d70eb 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -15,11 +15,11 @@ use crate::ws::run_ws_loop;
mod app_state;
mod drivers;
+mod errors;
mod relay_loop;
mod settings;
mod utils;
mod ws;
-mod errors;
async fn create_this_controller(
conn: &mut PoolConnection<Sqlite>,
@@ -80,14 +80,10 @@ async fn main() -> Result<(), std::io::Error> {
};
for relay in &settings.relays {
- if DbRelay::get_by_controller_and_num(
- &mut conn,
- &db_controller,
- relay.number,
- )
- .await
- .map_err(EmgauwaError::from)?
- .is_none()
+ if DbRelay::get_by_controller_and_num(&mut conn, &db_controller, relay.number)
+ .await
+ .map_err(EmgauwaError::from)?
+ .is_none()
{
create_this_relay(&mut conn, &db_controller, relay)
.await
@@ -103,7 +99,11 @@ async fn main() -> Result<(), std::io::Error> {
let this = Controller::from_db_model(&mut conn, db_controller).map_err(EmgauwaError::from)?;
let now = chrono::Local::now().time();
- let initial_states: Vec<bool> = this.relays.iter().map(|r| r.active_schedule.is_on(&now)).collect();
+ let initial_states: Vec<bool> = this
+ .relays
+ .iter()
+ .map(|r| r.active_schedule.is_on(&now))
+ .collect();
let mut pfd: Option<PiFaceDigital> = None;
let drivers = settings.relays_make_drivers(&mut pfd, initial_states)?;
diff --git a/src/settings.rs b/src/settings.rs
index 15d91bd..f4f83fd 100644
--- a/src/settings.rs
+++ b/src/settings.rs
@@ -2,6 +2,7 @@ use emgauwa_common::errors::EmgauwaError;
use emgauwa_common::settings;
use rppal_pfd::PiFaceDigital;
use serde_derive::Deserialize;
+
use crate::drivers;
#[derive(Clone, Debug, Deserialize)]
@@ -69,13 +70,17 @@ impl Settings {
&self,
pfd: &mut Option<PiFaceDigital>,
initial_states: Vec<bool>,
- ) -> Result<Vec<Box<dyn drivers::RelayDriver>>, EmgauwaError> {
+ ) -> Result<Vec<Box<dyn drivers::RelayDriver>>, EmgauwaError> {
let mut drivers = Vec::new();
- let result: Result<(), EmgauwaError> = self.relays.iter().zip(initial_states).try_for_each(|(relay, state)| {
- let driver = relay.make_driver(pfd, state)?;
- drivers.push(driver);
- Ok(())
- });
+ let result: Result<(), EmgauwaError> =
+ self.relays
+ .iter()
+ .zip(initial_states)
+ .try_for_each(|(relay, state)| {
+ let driver = relay.make_driver(pfd, state)?;
+ drivers.push(driver);
+ Ok(())
+ });
result?;
Ok(drivers)
}
diff --git a/src/ws/mod.rs b/src/ws/mod.rs
index a79b13c..bdb7e07 100644
--- a/src/ws/mod.rs
+++ b/src/ws/mod.rs
@@ -7,8 +7,8 @@ use emgauwa_common::types::ControllerWsAction;
use futures::{future, pin_mut, SinkExt, StreamExt};
use sqlx::{Pool, Sqlite};
use tokio::time;
-use tokio_tungstenite::tungstenite::Message;
use tokio_tungstenite::connect_async;
+use tokio_tungstenite::tungstenite::Message;
use crate::app_state::AppState;
use crate::utils::{app_state_get_relay_notifier, app_state_get_this};
@@ -89,4 +89,4 @@ async fn read_app_state(
))
})?;
}
-}
\ No newline at end of file
+}
From 8244a1d8374d46462b7396afd3a81c99cebdd89a Mon Sep 17 00:00:00 2001
From: Tobias Reisinger <tobias@msrg.cc>
Date: Sun, 26 May 2024 22:47:56 +0200
Subject: [PATCH 03/10] Rename active_schedule to override_schedule and add
EmgauwaNow
---
src/app_state.rs | 42 +++++++-
src/relay_loop.rs | 60 ++++++-----
src/utils.rs | 19 +++-
src/ws/handlers.rs | 258 ++++++++++++++++++++++++---------------------
4 files changed, 228 insertions(+), 151 deletions(-)
diff --git a/src/app_state.rs b/src/app_state.rs
index c47cd9b..624621e 100644
--- a/src/app_state.rs
+++ b/src/app_state.rs
@@ -3,9 +3,10 @@ use std::time::{Duration, Instant};
use actix::{Actor, Context, Handler, Message};
use emgauwa_common::constants;
+use emgauwa_common::db::DbSchedule;
use emgauwa_common::errors::EmgauwaError;
use emgauwa_common::models::Controller;
-use emgauwa_common::types::RelayStates;
+use emgauwa_common::types::{RelayStates, Weekday};
use futures::executor::block_on;
use sqlx::{Pool, Sqlite};
use tokio::sync::Notify;
@@ -30,6 +31,14 @@ pub struct RelayPulse {
pub duration: Option<u32>,
}
+#[derive(Message)]
+#[rtype(result = "Result<(), EmgauwaError>")]
+pub struct RelayOverrideSchedule {
+ pub relay_number: i64,
+ pub schedule: Option<DbSchedule>,
+ pub weekday: Weekday,
+}
+
#[derive(Message)]
#[rtype(result = "Controller")]
pub struct GetThis {}
@@ -105,7 +114,7 @@ impl Handler<UpdateRelayStates> for AppState {
.iter_mut()
.zip(msg.relay_states.iter())
.for_each(|(driver, state)| {
- if let Err(e) = driver.set(state.unwrap_or(false)) {
+ if let Err(e) = driver.set(state.is_on.unwrap_or(false)) {
log::error!("Error setting relay: {}", e);
}
});
@@ -148,6 +157,35 @@ impl Handler<RelayPulse> for AppState {
}
}
+impl Handler<RelayOverrideSchedule> for AppState {
+ type Result = Result<(), EmgauwaError>;
+
+ fn handle(&mut self, msg: RelayOverrideSchedule, _ctx: &mut Self::Context) -> Self::Result {
+ let relay_num = msg.relay_number;
+ let schedule = msg.schedule;
+ let weekday = msg.weekday;
+
+ let relay = self
+ .this
+ .relays
+ .iter_mut()
+ .find(|r| r.r.number == relay_num)
+ .ok_or(EmgauwaError::Other(String::from("Relay not found")))?;
+
+ log::debug!(
+ "Overriding schedule for relay {} to '{}' on day {}",
+ relay_num,
+ schedule.as_ref().map_or("NONE", |s| &s.name),
+ weekday
+ );
+
+ relay.override_schedule = Some(schedule);
+ relay.override_schedule_weekday = weekday;
+
+ Ok(())
+ }
+}
+
impl Handler<GetThis> for AppState {
type Result = Controller;
diff --git a/src/relay_loop.rs b/src/relay_loop.rs
index 3247f7f..972824b 100644
--- a/src/relay_loop.rs
+++ b/src/relay_loop.rs
@@ -1,11 +1,11 @@
-use std::time::{Duration, Instant};
+use std::time::Duration;
use actix::Addr;
-use chrono::{Local, Timelike};
+use chrono::Timelike;
use emgauwa_common::constants::RELAYS_RETRY_TIMEOUT;
use emgauwa_common::errors::EmgauwaError;
use emgauwa_common::models::Controller;
-use emgauwa_common::types::{RelayStates, Weekday};
+use emgauwa_common::types::{EmgauwaNow, RelayState, RelayStates, Weekday};
use emgauwa_common::utils::printable_relay_states;
use futures::pin_mut;
use tokio::time;
@@ -32,42 +32,44 @@ async fn run_relays(app_state: &Addr<AppState>) -> Result<(), EmgauwaError> {
let mut last_weekday = emgauwa_common::utils::get_weekday();
let mut this = utils::app_state_get_this(app_state).await?;
let mut relay_states: RelayStates = Vec::new();
+ let now = EmgauwaNow::now();
+
init_relay_states(&mut relay_states, &this);
- calc_relay_states(&mut relay_states, &mut this, app_state).await?;
+ calc_relay_states(&mut relay_states, &mut this, app_state, &now).await?;
let mut duration_override = None;
loop {
+ let now = EmgauwaNow::now();
log::debug!(
"Relay loop at {}: {}",
- Local::now().naive_local().time(),
+ now.time,
printable_relay_states(&this.get_relay_states())
);
let notifier_future = notifier.notified();
pin_mut!(notifier_future);
let mut changed = timeout(
- get_next_duration(&this, &mut duration_override),
+ get_next_duration(&mut this, &mut duration_override, &now),
&mut notifier_future,
)
.await
.is_ok();
- check_weekday(app_state, &mut last_weekday, &mut changed).await?;
+ check_weekday(app_state, &mut last_weekday, &mut changed, &now).await?;
if changed {
log::debug!("Reloading controller in relay loop");
this = utils::app_state_get_this(app_state).await?;
}
- let now_pulse = Instant::now();
duration_override = this
.relays
.iter_mut()
- .filter_map(|relay| match relay.check_pulsing(&now_pulse) {
+ .filter_map(|relay| match relay.check_pulsing(&now.instant) {
None => None,
Some(pulse) => {
- let dur = pulse - now_pulse;
+ let dur = pulse - now.instant;
log::debug!(
"Pulsing relay {} for {}s until {:?} ",
relay.r.number,
@@ -79,50 +81,57 @@ async fn run_relays(app_state: &Addr<AppState>) -> Result<(), EmgauwaError> {
})
.min();
- calc_relay_states(&mut relay_states, &mut this, app_state).await?;
+ calc_relay_states(&mut relay_states, &mut this, app_state, &now).await?;
}
}
fn init_relay_states(relay_states: &mut RelayStates, this: &Controller) {
relay_states.clear();
- for _ in 0..this.c.relay_count {
- relay_states.push(None);
- }
+ this.relays.iter().for_each(|r| {
+ relay_states.push(RelayState {
+ active_schedule: r.active_schedule.clone(),
+ is_on: None
+ });
+ });
}
async fn calc_relay_states(
relay_states: &mut RelayStates,
this: &mut Controller,
app_state: &Addr<AppState>,
+ now: &EmgauwaNow,
) -> Result<(), EmgauwaError> {
- let now = Local::now().time();
- let now_pulse = Instant::now();
-
this.relays
.iter_mut()
.zip(relay_states.iter_mut())
.for_each(|(relay, state)| {
+ relay.reload_active_schedule(now.weekday);
relay.is_on = Some(
- relay.active_schedule.is_on(&now) || relay.check_pulsing(&now_pulse).is_some(),
+ relay.active_schedule.is_on(&now.time)
+ || relay.check_pulsing(&now.instant).is_some(),
);
- *state = relay.is_on;
+
+ state.is_on = relay.is_on;
+ state.active_schedule = relay.active_schedule.clone();
});
utils::app_state_update_relays_on(app_state, relay_states.clone()).await
}
-fn get_next_duration(this: &Controller, duration_override: &mut Option<Duration>) -> Duration {
+fn get_next_duration(
+ this: &mut Controller,
+ duration_override: &mut Option<Duration>,
+ now: &EmgauwaNow,
+) -> Duration {
if let Some(duration) = duration_override {
log::debug!("Duration override. Waiting for {}s", duration.as_secs());
return *duration;
}
- let now = Local::now().time();
- let now_in_s = now.num_seconds_from_midnight();
let next_timestamp = this
- .get_next_time(&now)
+ .check_next_time(now)
.map_or(86400, |t| t.num_seconds_from_midnight());
- let duration_to_next = Duration::from_secs((next_timestamp - now_in_s) as u64);
+ let duration_to_next = Duration::from_secs((next_timestamp - now.time_in_s()) as u64);
log::debug!(
"Next timestamp: {}; Waiting for {}s",
@@ -137,8 +146,9 @@ async fn check_weekday(
app_state: &Addr<AppState>,
last_weekday: &mut Weekday,
changed: &mut bool,
+ now: &EmgauwaNow,
) -> Result<(), EmgauwaError> {
- let current_weekday = emgauwa_common::utils::get_weekday();
+ let current_weekday = now.weekday;
if current_weekday.ne(last_weekday) {
log::debug!("Weekday changed");
*last_weekday = current_weekday;
diff --git a/src/utils.rs b/src/utils.rs
index c6d2830..2080c50 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -1,9 +1,10 @@
use std::sync::Arc;
use actix::Addr;
+use emgauwa_common::db::DbSchedule;
use emgauwa_common::errors::EmgauwaError;
use emgauwa_common::models::Controller;
-use emgauwa_common::types::RelayStates;
+use emgauwa_common::types::{RelayStates, Weekday};
use tokio::sync::Notify;
use crate::app_state;
@@ -64,3 +65,19 @@ pub async fn app_state_relay_pulse(
.await
.map_err(EmgauwaError::from)?
}
+
+pub async fn app_state_relay_override_schedule(
+ app_state: &Addr<AppState>,
+ relay_number: i64,
+ schedule: Option<DbSchedule>,
+ weekday: Weekday,
+) -> Result<(), EmgauwaError> {
+ app_state
+ .send(app_state::RelayOverrideSchedule {
+ relay_number,
+ weekday,
+ schedule,
+ })
+ .await
+ .map_err(EmgauwaError::from)?
+}
diff --git a/src/ws/handlers.rs b/src/ws/handlers.rs
index 7af953a..20ada8c 100644
--- a/src/ws/handlers.rs
+++ b/src/ws/handlers.rs
@@ -1,166 +1,178 @@
use actix::Addr;
-use sqlx::{Pool, Sqlite};
-use sqlx::pool::PoolConnection;
-use tokio_tungstenite::tungstenite;
-use tokio_tungstenite::tungstenite::Message;
use emgauwa_common::db::{DbController, DbJunctionRelaySchedule, DbRelay, DbSchedule};
use emgauwa_common::errors::{DatabaseError, EmgauwaError};
use emgauwa_common::models::{Controller, Relay};
use emgauwa_common::types::{ControllerWsAction, ScheduleUid};
+use sqlx::pool::PoolConnection;
+use sqlx::{Pool, Sqlite};
+use tokio_tungstenite::tungstenite;
+use tokio_tungstenite::tungstenite::Message;
+
use crate::app_state::AppState;
use crate::utils;
use crate::utils::app_state_get_this;
pub async fn handle_message(
- pool: Pool<Sqlite>,
- app_state: &Addr<AppState>,
- message_result: Result<Message, tungstenite::Error>,
+ pool: Pool<Sqlite>,
+ app_state: &Addr<AppState>,
+ message_result: Result<Message, tungstenite::Error>,
) {
- let msg = match message_result {
- Ok(msg) => msg,
- Err(err) => {
- log::error!("Error reading message: {}", err);
- return;
- }
- };
- if let Message::Text(text) = msg {
- match serde_json::from_str(&text) {
- Ok(action) => {
- log::debug!("Received action: {:?}", action);
- let mut pool_conn = match pool.acquire().await {
- Ok(conn) => conn,
- Err(err) => {
- log::error!("Failed to acquire database connection: {:?}", err);
- return;
- }
- };
- let action_res = handle_action(&mut pool_conn, app_state, action).await;
- if let Err(e) = action_res {
- log::error!("Error handling action: {:?}", e);
- }
- }
- Err(e) => {
- log::error!("Error deserializing action: {:?}", e);
- }
- }
- }
+ let msg = match message_result {
+ Ok(msg) => msg,
+ Err(err) => {
+ log::error!("Error reading message: {}", err);
+ return;
+ }
+ };
+ if let Message::Text(text) = msg {
+ match serde_json::from_str(&text) {
+ Ok(action) => {
+ log::debug!("Received action: {:?}", action);
+ let mut pool_conn = match pool.acquire().await {
+ Ok(conn) => conn,
+ Err(err) => {
+ log::error!("Failed to acquire database connection: {:?}", err);
+ return;
+ }
+ };
+ let action_res = handle_action(&mut pool_conn, app_state, action).await;
+ if let Err(e) = action_res {
+ log::error!("Error handling action: {:?}", e);
+ }
+ }
+ Err(e) => {
+ log::error!("Error deserializing action: {:?}", e);
+ }
+ }
+ }
}
pub async fn handle_action(
- conn: &mut PoolConnection<Sqlite>,
- app_state: &Addr<AppState>,
- action: ControllerWsAction,
+ conn: &mut PoolConnection<Sqlite>,
+ app_state: &Addr<AppState>,
+ action: ControllerWsAction,
) -> Result<(), EmgauwaError> {
- let this = app_state_get_this(app_state).await?;
+ let this = app_state_get_this(app_state).await?;
- match action {
- ControllerWsAction::Controller(controller) => {
- handle_controller(conn, &this, controller).await?
- }
- ControllerWsAction::Relays(relays) => handle_relays(conn, &this, relays).await?,
- ControllerWsAction::Schedules(schedules) => handle_schedules(conn, schedules).await?,
- ControllerWsAction::RelayPulse((relay_num, duration)) => {
- handle_relay_pulse(app_state, relay_num, duration).await?
- }
- _ => return Ok(()),
- };
+ match action {
+ ControllerWsAction::Controller(controller) => {
+ handle_controller(conn, &this, controller).await?
+ }
+ ControllerWsAction::Relays(relays) => handle_relays(conn, app_state, &this, relays).await?,
+ ControllerWsAction::Schedules(schedules) => handle_schedules(conn, schedules).await?,
+ ControllerWsAction::RelayPulse((relay_num, duration)) => {
+ handle_relay_pulse(app_state, relay_num, duration).await?
+ }
+ _ => return Ok(()),
+ };
- utils::app_state_reload(app_state).await
+ utils::app_state_reload(app_state).await
}
async fn handle_controller(
- conn: &mut PoolConnection<Sqlite>,
- this: &Controller,
- controller: Controller,
+ conn: &mut PoolConnection<Sqlite>,
+ this: &Controller,
+ controller: Controller,
) -> Result<(), EmgauwaError> {
- if controller.c.uid != this.c.uid {
- return Err(EmgauwaError::Other(String::from(
- "Controller UID mismatch during update",
- )));
- }
- DbController::get_by_uid(conn, &controller.c.uid)
- .await?
- .ok_or(DatabaseError::NotFound)?
- .update(conn, controller.c.name.as_str(), this.c.relay_count)
- .await?;
+ if controller.c.uid != this.c.uid {
+ return Err(EmgauwaError::Other(String::from(
+ "Controller UID mismatch during update",
+ )));
+ }
+ DbController::get_by_uid(conn, &controller.c.uid)
+ .await?
+ .ok_or(DatabaseError::NotFound)?
+ .update(conn, controller.c.name.as_str(), this.c.relay_count)
+ .await?;
- Ok(())
+ Ok(())
}
async fn handle_schedules(
- conn: &mut PoolConnection<Sqlite>,
- schedules: Vec<DbSchedule>,
+ conn: &mut PoolConnection<Sqlite>,
+ schedules: Vec<DbSchedule>,
) -> Result<(), EmgauwaError> {
- let mut handled_uids = vec![
- // on and off schedules are always present and should not be updated
- ScheduleUid::On,
- ScheduleUid::Off,
- ];
- for schedule in schedules {
- if handled_uids.contains(&schedule.uid) {
- continue;
- }
- handled_uids.push(schedule.uid.clone());
+ let mut handled_uids = vec![
+ // on and off schedules are always present and should not be updated
+ ScheduleUid::On,
+ ScheduleUid::Off,
+ ];
+ for schedule in schedules {
+ if handled_uids.contains(&schedule.uid) {
+ continue;
+ }
+ handled_uids.push(schedule.uid.clone());
- log::debug!("Handling schedule: {:?}", schedule);
- let schedule_db = DbSchedule::get_by_uid(conn, &schedule.uid).await?;
+ log::debug!("Handling schedule: {:?}", schedule);
+ let schedule_db = DbSchedule::get_by_uid(conn, &schedule.uid).await?;
- if let Some(schedule_db) = schedule_db {
- schedule_db
- .update(conn, schedule.name.as_str(), &schedule.periods)
- .await?;
- } else {
- DbSchedule::create(
- conn,
- schedule.uid.clone(),
- schedule.name.as_str(),
- &schedule.periods,
- )
- .await?;
- }
- }
+ if let Some(schedule_db) = schedule_db {
+ schedule_db
+ .update(conn, schedule.name.as_str(), &schedule.periods)
+ .await?;
+ } else {
+ DbSchedule::create(
+ conn,
+ schedule.uid.clone(),
+ schedule.name.as_str(),
+ &schedule.periods,
+ )
+ .await?;
+ }
+ }
- Ok(())
+ Ok(())
}
async fn handle_relays(
- conn: &mut PoolConnection<Sqlite>,
- this: &Controller,
- relays: Vec<Relay>,
+ conn: &mut PoolConnection<Sqlite>,
+ app_state: &Addr<AppState>,
+ this: &Controller,
+ relays: Vec<Relay>,
) -> Result<(), EmgauwaError> {
- for relay in relays {
- if relay.controller.uid != this.c.uid {
- return Err(EmgauwaError::Other(String::from(
- "Controller UID mismatch during relay update",
- )));
- }
- let db_relay = DbRelay::get_by_controller_and_num(conn, &this.c, relay.r.number)
- .await?
- .ok_or(DatabaseError::NotFound)?;
+ for relay in relays {
+ if relay.controller.uid != this.c.uid {
+ return Err(EmgauwaError::Other(String::from(
+ "Controller UID mismatch during relay update",
+ )));
+ }
+ let db_relay = DbRelay::get_by_controller_and_num(conn, &this.c, relay.r.number)
+ .await?
+ .ok_or(DatabaseError::NotFound)?;
- db_relay.update(conn, relay.r.name.as_str()).await?;
+ db_relay.update(conn, relay.r.name.as_str()).await?;
- handle_schedules(conn, relay.schedules.clone()).await?;
+ handle_schedules(conn, relay.schedules.clone()).await?;
- let mut schedules = Vec::new(); // We need to get the schedules from the database to have the right IDs
- for schedule in relay.schedules {
- schedules.push(
- DbSchedule::get_by_uid(conn, &schedule.uid)
- .await?
- .ok_or(DatabaseError::NotFound)?,
- );
- }
+ let mut schedules = Vec::new(); // We need to get the schedules from the database to have the right IDs
+ for schedule in &relay.schedules {
+ schedules.push(
+ DbSchedule::get_by_uid(conn, &schedule.uid)
+ .await?
+ .ok_or(DatabaseError::NotFound)?,
+ );
+ }
- DbJunctionRelaySchedule::set_schedules(conn, &db_relay, schedules.iter().collect()).await?;
- }
+ if let Some((override_schedule, weekday)) = relay.unwrap_override_schedule() {
+ utils::app_state_relay_override_schedule(
+ app_state,
+ relay.r.number,
+ override_schedule.clone(),
+ weekday,
+ )
+ .await?;
+ }
- Ok(())
+ DbJunctionRelaySchedule::set_schedules(conn, &db_relay, schedules.iter().collect()).await?;
+ }
+
+ Ok(())
}
async fn handle_relay_pulse(
- app_state: &Addr<AppState>,
- relay_num: i64,
- duration: Option<u32>,
+ app_state: &Addr<AppState>,
+ relay_num: i64,
+ duration: Option<u32>,
) -> Result<(), EmgauwaError> {
- utils::app_state_relay_pulse(app_state, relay_num, duration).await
+ utils::app_state_relay_pulse(app_state, relay_num, duration).await
}
From 2eb38ec11e591c7bed6069ba6b8f0c02e7766fe0 Mon Sep 17 00:00:00 2001
From: Tobias Reisinger <tobias@msrg.cc>
Date: Tue, 28 May 2024 21:17:25 +0200
Subject: [PATCH 04/10] Improve handling of override_schedule
---
src/app_state.rs | 2 +-
src/relay_loop.rs | 29 +++++------------------------
src/utils.rs | 2 +-
src/ws/handlers.rs | 25 ++++++++++++-------------
4 files changed, 19 insertions(+), 39 deletions(-)
diff --git a/src/app_state.rs b/src/app_state.rs
index 624621e..94f05eb 100644
--- a/src/app_state.rs
+++ b/src/app_state.rs
@@ -179,7 +179,7 @@ impl Handler<RelayOverrideSchedule> for AppState {
weekday
);
- relay.override_schedule = Some(schedule);
+ relay.override_schedule = schedule;
relay.override_schedule_weekday = weekday;
Ok(())
diff --git a/src/relay_loop.rs b/src/relay_loop.rs
index 972824b..9f1846a 100644
--- a/src/relay_loop.rs
+++ b/src/relay_loop.rs
@@ -5,7 +5,7 @@ use chrono::Timelike;
use emgauwa_common::constants::RELAYS_RETRY_TIMEOUT;
use emgauwa_common::errors::EmgauwaError;
use emgauwa_common::models::Controller;
-use emgauwa_common::types::{EmgauwaNow, RelayState, RelayStates, Weekday};
+use emgauwa_common::types::{EmgauwaNow, Weekday};
use emgauwa_common::utils::printable_relay_states;
use futures::pin_mut;
use tokio::time;
@@ -31,11 +31,6 @@ async fn run_relays(app_state: &Addr<AppState>) -> Result<(), EmgauwaError> {
let mut last_weekday = emgauwa_common::utils::get_weekday();
let mut this = utils::app_state_get_this(app_state).await?;
- let mut relay_states: RelayStates = Vec::new();
- let now = EmgauwaNow::now();
-
- init_relay_states(&mut relay_states, &this);
- calc_relay_states(&mut relay_states, &mut this, app_state, &now).await?;
let mut duration_override = None;
@@ -81,40 +76,26 @@ async fn run_relays(app_state: &Addr<AppState>) -> Result<(), EmgauwaError> {
})
.min();
- calc_relay_states(&mut relay_states, &mut this, app_state, &now).await?;
+ calc_relay_states(&mut this, app_state, &now).await?;
}
}
-fn init_relay_states(relay_states: &mut RelayStates, this: &Controller) {
- relay_states.clear();
- this.relays.iter().for_each(|r| {
- relay_states.push(RelayState {
- active_schedule: r.active_schedule.clone(),
- is_on: None
- });
- });
-}
-
async fn calc_relay_states(
- relay_states: &mut RelayStates,
this: &mut Controller,
app_state: &Addr<AppState>,
now: &EmgauwaNow,
) -> Result<(), EmgauwaError> {
this.relays
.iter_mut()
- .zip(relay_states.iter_mut())
- .for_each(|(relay, state)| {
+ .for_each(|relay| {
relay.reload_active_schedule(now.weekday);
relay.is_on = Some(
relay.active_schedule.is_on(&now.time)
|| relay.check_pulsing(&now.instant).is_some(),
);
-
- state.is_on = relay.is_on;
- state.active_schedule = relay.active_schedule.clone();
});
- utils::app_state_update_relays_on(app_state, relay_states.clone()).await
+ let relay_states = this.get_relay_states();
+ utils::app_state_update_relay_states(app_state, relay_states.clone()).await
}
fn get_next_duration(
diff --git a/src/utils.rs b/src/utils.rs
index 2080c50..3ea7854 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -42,7 +42,7 @@ pub async fn app_state_reload(app_state: &Addr<AppState>) -> Result<(), EmgauwaE
.map_err(EmgauwaError::from)?
}
-pub async fn app_state_update_relays_on(
+pub async fn app_state_update_relay_states(
app_state: &Addr<AppState>,
relay_states: RelayStates,
) -> Result<(), EmgauwaError> {
diff --git a/src/ws/handlers.rs b/src/ws/handlers.rs
index 20ada8c..1ad709a 100644
--- a/src/ws/handlers.rs
+++ b/src/ws/handlers.rs
@@ -1,12 +1,13 @@
use actix::Addr;
+use sqlx::{Pool, Sqlite};
+use sqlx::pool::PoolConnection;
+use tokio_tungstenite::tungstenite;
+use tokio_tungstenite::tungstenite::Message;
+
use emgauwa_common::db::{DbController, DbJunctionRelaySchedule, DbRelay, DbSchedule};
use emgauwa_common::errors::{DatabaseError, EmgauwaError};
use emgauwa_common::models::{Controller, Relay};
use emgauwa_common::types::{ControllerWsAction, ScheduleUid};
-use sqlx::pool::PoolConnection;
-use sqlx::{Pool, Sqlite};
-use tokio_tungstenite::tungstenite;
-use tokio_tungstenite::tungstenite::Message;
use crate::app_state::AppState;
use crate::utils;
@@ -153,15 +154,13 @@ async fn handle_relays(
);
}
- if let Some((override_schedule, weekday)) = relay.unwrap_override_schedule() {
- utils::app_state_relay_override_schedule(
- app_state,
- relay.r.number,
- override_schedule.clone(),
- weekday,
- )
- .await?;
- }
+ utils::app_state_relay_override_schedule(
+ app_state,
+ relay.r.number,
+ relay.override_schedule.clone(),
+ relay.override_schedule_weekday,
+ )
+ .await?;
DbJunctionRelaySchedule::set_schedules(conn, &db_relay, schedules.iter().collect()).await?;
}
From bb982c4444d0701e7592b922daf674997dc9c6c4 Mon Sep 17 00:00:00 2001
From: Tobias Reisinger <tobias@msrg.cc>
Date: Tue, 28 May 2024 22:50:57 +0200
Subject: [PATCH 05/10] Fix calculation of EmgauwaNow in relay loop
---
src/relay_loop.rs | 13 ++++++++-----
1 file changed, 8 insertions(+), 5 deletions(-)
diff --git a/src/relay_loop.rs b/src/relay_loop.rs
index 9f1846a..753dfba 100644
--- a/src/relay_loop.rs
+++ b/src/relay_loop.rs
@@ -36,11 +36,6 @@ async fn run_relays(app_state: &Addr<AppState>) -> Result<(), EmgauwaError> {
loop {
let now = EmgauwaNow::now();
- log::debug!(
- "Relay loop at {}: {}",
- now.time,
- printable_relay_states(&this.get_relay_states())
- );
let notifier_future = notifier.notified();
pin_mut!(notifier_future);
@@ -51,6 +46,8 @@ async fn run_relays(app_state: &Addr<AppState>) -> Result<(), EmgauwaError> {
.await
.is_ok();
+ let now = EmgauwaNow::now();
+
check_weekday(app_state, &mut last_weekday, &mut changed, &now).await?;
if changed {
@@ -58,6 +55,12 @@ async fn run_relays(app_state: &Addr<AppState>) -> Result<(), EmgauwaError> {
this = utils::app_state_get_this(app_state).await?;
}
+ log::debug!(
+ "Relay loop at {}: {}",
+ now.time,
+ printable_relay_states(&this.get_relay_states())
+ );
+
duration_override = this
.relays
.iter_mut()
From b065c8dd972df43516d49a57db228f1ad2ba6648 Mon Sep 17 00:00:00 2001
From: Tobias Reisinger <tobias@msrg.cc>
Date: Wed, 29 May 2024 00:59:08 +0200
Subject: [PATCH 06/10] Refactor the utils (remove them)
---
src/app_state.rs | 16 ++++++++-
src/main.rs | 1 -
src/relay_loop.rs | 22 +++++++-----
src/utils.rs | 83 ----------------------------------------------
src/ws/handlers.rs | 30 +++++++++--------
src/ws/mod.rs | 11 +++---
6 files changed, 53 insertions(+), 110 deletions(-)
delete mode 100644 src/utils.rs
diff --git a/src/app_state.rs b/src/app_state.rs
index 94f05eb..d53de02 100644
--- a/src/app_state.rs
+++ b/src/app_state.rs
@@ -1,7 +1,7 @@
use std::sync::Arc;
use std::time::{Duration, Instant};
-use actix::{Actor, Context, Handler, Message};
+use actix::{Actor, Addr, Context, Handler, Message};
use emgauwa_common::constants;
use emgauwa_common::db::DbSchedule;
use emgauwa_common::errors::EmgauwaError;
@@ -84,6 +84,20 @@ impl AppState {
pub fn notify_relay_change(&self) {
self.relay_notifier.notify_one();
}
+
+ pub async fn trigger_reload(app_state: &Addr<AppState>) -> Result<(), EmgauwaError> {
+ app_state
+ .send(Reload {})
+ .await
+ .map_err(EmgauwaError::from)?
+ }
+
+ pub async fn get_this(app_state: &Addr<AppState>) -> Result<Controller, EmgauwaError> {
+ app_state
+ .send(GetThis {})
+ .await
+ .map_err(EmgauwaError::from)
+ }
}
impl Actor for AppState {
diff --git a/src/main.rs b/src/main.rs
index f9d70eb..0c7eee0 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -18,7 +18,6 @@ mod drivers;
mod errors;
mod relay_loop;
mod settings;
-mod utils;
mod ws;
async fn create_this_controller(
diff --git a/src/relay_loop.rs b/src/relay_loop.rs
index 753dfba..d5f1676 100644
--- a/src/relay_loop.rs
+++ b/src/relay_loop.rs
@@ -10,10 +10,9 @@ use emgauwa_common::utils::printable_relay_states;
use futures::pin_mut;
use tokio::time;
use tokio::time::timeout;
-use utils::app_state_get_controller_notifier;
use crate::app_state::AppState;
-use crate::utils;
+use crate::app_state;
pub async fn run_relays_loop(app_state: Addr<AppState>) {
log::debug!("Spawned relays loop");
@@ -27,10 +26,12 @@ pub async fn run_relays_loop(app_state: Addr<AppState>) {
}
async fn run_relays(app_state: &Addr<AppState>) -> Result<(), EmgauwaError> {
- let notifier = &*app_state_get_controller_notifier(app_state).await?;
+ let notifier = &*app_state
+ .send(app_state::GetControllerNotifier {})
+ .await?;
let mut last_weekday = emgauwa_common::utils::get_weekday();
- let mut this = utils::app_state_get_this(app_state).await?;
+ let mut this = AppState::get_this(app_state).await?;
let mut duration_override = None;
@@ -52,7 +53,7 @@ async fn run_relays(app_state: &Addr<AppState>) -> Result<(), EmgauwaError> {
if changed {
log::debug!("Reloading controller in relay loop");
- this = utils::app_state_get_this(app_state).await?;
+ this = AppState::get_this(app_state).await?;
}
log::debug!(
@@ -97,8 +98,13 @@ async fn calc_relay_states(
|| relay.check_pulsing(&now.instant).is_some(),
);
});
- let relay_states = this.get_relay_states();
- utils::app_state_update_relay_states(app_state, relay_states.clone()).await
+
+ app_state
+ .send(app_state::UpdateRelayStates {
+ relay_states: this.get_relay_states()
+ })
+ .await
+ .map_err(EmgauwaError::from)
}
fn get_next_duration(
@@ -136,7 +142,7 @@ async fn check_weekday(
if current_weekday.ne(last_weekday) {
log::debug!("Weekday changed");
*last_weekday = current_weekday;
- utils::app_state_reload(app_state).await?;
+ AppState::trigger_reload(app_state).await?;
*changed = true;
}
diff --git a/src/utils.rs b/src/utils.rs
deleted file mode 100644
index 3ea7854..0000000
--- a/src/utils.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-use std::sync::Arc;
-
-use actix::Addr;
-use emgauwa_common::db::DbSchedule;
-use emgauwa_common::errors::EmgauwaError;
-use emgauwa_common::models::Controller;
-use emgauwa_common::types::{RelayStates, Weekday};
-use tokio::sync::Notify;
-
-use crate::app_state;
-use crate::app_state::AppState;
-
-pub async fn app_state_get_this(app_state: &Addr<AppState>) -> Result<Controller, EmgauwaError> {
- app_state
- .send(app_state::GetThis {})
- .await
- .map_err(EmgauwaError::from)
-}
-
-pub async fn app_state_get_relay_notifier(
- app_state: &Addr<AppState>,
-) -> Result<Arc<Notify>, EmgauwaError> {
- app_state
- .send(app_state::GetRelayNotifier {})
- .await
- .map_err(EmgauwaError::from)
-}
-
-pub async fn app_state_get_controller_notifier(
- app_state: &Addr<AppState>,
-) -> Result<Arc<Notify>, EmgauwaError> {
- app_state
- .send(app_state::GetControllerNotifier {})
- .await
- .map_err(EmgauwaError::from)
-}
-
-pub async fn app_state_reload(app_state: &Addr<AppState>) -> Result<(), EmgauwaError> {
- app_state
- .send(app_state::Reload {})
- .await
- .map_err(EmgauwaError::from)?
-}
-
-pub async fn app_state_update_relay_states(
- app_state: &Addr<AppState>,
- relay_states: RelayStates,
-) -> Result<(), EmgauwaError> {
- app_state
- .send(app_state::UpdateRelayStates { relay_states })
- .await
- .map_err(EmgauwaError::from)
-}
-
-pub async fn app_state_relay_pulse(
- app_state: &Addr<AppState>,
- relay_number: i64,
- duration: Option<u32>,
-) -> Result<(), EmgauwaError> {
- app_state
- .send(app_state::RelayPulse {
- relay_number,
- duration,
- })
- .await
- .map_err(EmgauwaError::from)?
-}
-
-pub async fn app_state_relay_override_schedule(
- app_state: &Addr<AppState>,
- relay_number: i64,
- schedule: Option<DbSchedule>,
- weekday: Weekday,
-) -> Result<(), EmgauwaError> {
- app_state
- .send(app_state::RelayOverrideSchedule {
- relay_number,
- weekday,
- schedule,
- })
- .await
- .map_err(EmgauwaError::from)?
-}
diff --git a/src/ws/handlers.rs b/src/ws/handlers.rs
index 1ad709a..97caded 100644
--- a/src/ws/handlers.rs
+++ b/src/ws/handlers.rs
@@ -10,8 +10,7 @@ use emgauwa_common::models::{Controller, Relay};
use emgauwa_common::types::{ControllerWsAction, ScheduleUid};
use crate::app_state::AppState;
-use crate::utils;
-use crate::utils::app_state_get_this;
+use crate::app_state;
pub async fn handle_message(
pool: Pool<Sqlite>,
@@ -53,7 +52,7 @@ pub async fn handle_action(
app_state: &Addr<AppState>,
action: ControllerWsAction,
) -> Result<(), EmgauwaError> {
- let this = app_state_get_this(app_state).await?;
+ let this = AppState::get_this(app_state).await?;
match action {
ControllerWsAction::Controller(controller) => {
@@ -67,7 +66,7 @@ pub async fn handle_action(
_ => return Ok(()),
};
- utils::app_state_reload(app_state).await
+ AppState::trigger_reload(app_state).await
}
async fn handle_controller(
@@ -154,13 +153,13 @@ async fn handle_relays(
);
}
- utils::app_state_relay_override_schedule(
- app_state,
- relay.r.number,
- relay.override_schedule.clone(),
- relay.override_schedule_weekday,
- )
- .await?;
+ app_state
+ .send(app_state::RelayOverrideSchedule {
+ relay_number: relay.r.number,
+ schedule: relay.override_schedule.clone(),
+ weekday: relay.override_schedule_weekday,
+ })
+ .await??;
DbJunctionRelaySchedule::set_schedules(conn, &db_relay, schedules.iter().collect()).await?;
}
@@ -170,8 +169,13 @@ async fn handle_relays(
async fn handle_relay_pulse(
app_state: &Addr<AppState>,
- relay_num: i64,
+ relay_number: i64,
duration: Option<u32>,
) -> Result<(), EmgauwaError> {
- utils::app_state_relay_pulse(app_state, relay_num, duration).await
+ app_state
+ .send(app_state::RelayPulse {
+ relay_number,
+ duration,
+ })
+ .await?
}
diff --git a/src/ws/mod.rs b/src/ws/mod.rs
index bdb7e07..5ee6229 100644
--- a/src/ws/mod.rs
+++ b/src/ws/mod.rs
@@ -9,9 +9,9 @@ use sqlx::{Pool, Sqlite};
use tokio::time;
use tokio_tungstenite::connect_async;
use tokio_tungstenite::tungstenite::Message;
+use crate::app_state;
use crate::app_state::AppState;
-use crate::utils::{app_state_get_relay_notifier, app_state_get_this};
use crate::ws::handlers::handle_message;
pub async fn run_ws_loop(pool: Pool<Sqlite>, app_state: Addr<AppState>, url: String) {
@@ -43,7 +43,7 @@ async fn run_websocket(
let (mut write, read) = ws_stream.split();
- let ws_action = ControllerWsAction::Register(app_state_get_this(app_state).await?);
+ let ws_action = ControllerWsAction::Register(AppState::get_this(app_state).await?);
let ws_action_json = serde_json::to_string(&ws_action)?;
if let Err(err) = write.send(Message::text(ws_action_json)).await {
@@ -73,11 +73,14 @@ async fn read_app_state(
app_state: Addr<AppState>,
tx: futures_channel::mpsc::UnboundedSender<Message>,
) -> Result<(), EmgauwaError> {
- let notifier = &*app_state_get_relay_notifier(&app_state).await?;
+ let notifier = &*app_state
+ .send(app_state::GetRelayNotifier {})
+ .await?;
+
loop {
notifier.notified().await;
log::debug!("Relay change detected");
- let this = app_state_get_this(&app_state).await?;
+ let this = AppState::get_this(&app_state).await?;
let relay_states = this.get_relay_states();
let ws_action = ControllerWsAction::RelayStates((this.c.uid, relay_states));
From 1e2afe481c1272111c8d99cfbaf320298078fc64 Mon Sep 17 00:00:00 2001
From: Tobias Reisinger <tobias@msrg.cc>
Date: Wed, 29 May 2024 15:51:59 +0200
Subject: [PATCH 07/10] Remove guessing of active_schedule
---
src/main.rs | 13 ++++++++-----
src/relay_loop.rs | 2 +-
2 files changed, 9 insertions(+), 6 deletions(-)
diff --git a/src/main.rs b/src/main.rs
index 0c7eee0..0da73b5 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,7 +3,7 @@ use emgauwa_common::db;
use emgauwa_common::db::{DbController, DbJunctionRelaySchedule, DbRelay, DbSchedule};
use emgauwa_common::errors::EmgauwaError;
use emgauwa_common::models::{Controller, FromDbModel};
-use emgauwa_common::types::EmgauwaUid;
+use emgauwa_common::types::{EmgauwaNow, EmgauwaUid};
use emgauwa_common::utils::{drop_privileges, init_logging};
use rppal_pfd::PiFaceDigital;
use sqlx::pool::PoolConnection;
@@ -95,13 +95,16 @@ async fn main() -> Result<(), std::io::Error> {
.await
.map_err(EmgauwaError::from)?;
- let this = Controller::from_db_model(&mut conn, db_controller).map_err(EmgauwaError::from)?;
+ let mut this = Controller::from_db_model(&mut conn, db_controller).map_err(EmgauwaError::from)?;
- let now = chrono::Local::now().time();
+ let now = EmgauwaNow::now();
let initial_states: Vec<bool> = this
.relays
- .iter()
- .map(|r| r.active_schedule.is_on(&now))
+ .iter_mut()
+ .map(|r| {
+ r.reload_active_schedule(now.weekday);
+ r.is_on(&now.time)
+ })
.collect();
let mut pfd: Option<PiFaceDigital> = None;
diff --git a/src/relay_loop.rs b/src/relay_loop.rs
index d5f1676..366a3de 100644
--- a/src/relay_loop.rs
+++ b/src/relay_loop.rs
@@ -94,7 +94,7 @@ async fn calc_relay_states(
.for_each(|relay| {
relay.reload_active_schedule(now.weekday);
relay.is_on = Some(
- relay.active_schedule.is_on(&now.time)
+ relay.is_on(&now.time)
|| relay.check_pulsing(&now.instant).is_some(),
);
});
From 4f48b04acc0b341eeafa0ceed5397497056ba198 Mon Sep 17 00:00:00 2001
From: Tobias Reisinger <tobias@msrg.cc>
Date: Thu, 30 May 2024 02:37:40 +0200
Subject: [PATCH 08/10] Add setting to change "midnight" of day
---
controller.pkl | 2 +-
src/app_state.rs | 5 ++---
src/main.rs | 6 +++---
src/relay_loop.rs | 41 +++++++++++++++++++++++++++--------------
src/settings.rs | 3 +++
src/ws/handlers.rs | 3 +--
6 files changed, 37 insertions(+), 23 deletions(-)
diff --git a/controller.pkl b/controller.pkl
index 98dfdb2..3685ba0 100644
--- a/controller.pkl
+++ b/controller.pkl
@@ -1,4 +1,4 @@
-amends "package://emgauwa.app/pkl/emgauwa@0.1.1#/controller.pkl"
+amends "package://emgauwa.app/pkl/emgauwa@0.2.0#/controller.pkl"
logging {
level = "DEBUG"
diff --git a/src/app_state.rs b/src/app_state.rs
index d53de02..cfe8d62 100644
--- a/src/app_state.rs
+++ b/src/app_state.rs
@@ -6,7 +6,7 @@ use emgauwa_common::constants;
use emgauwa_common::db::DbSchedule;
use emgauwa_common::errors::EmgauwaError;
use emgauwa_common::models::Controller;
-use emgauwa_common::types::{RelayStates, Weekday};
+use emgauwa_common::types::{EmgauwaNow, RelayStates};
use futures::executor::block_on;
use sqlx::{Pool, Sqlite};
use tokio::sync::Notify;
@@ -36,7 +36,6 @@ pub struct RelayPulse {
pub struct RelayOverrideSchedule {
pub relay_number: i64,
pub schedule: Option<DbSchedule>,
- pub weekday: Weekday,
}
#[derive(Message)]
@@ -177,7 +176,7 @@ impl Handler<RelayOverrideSchedule> for AppState {
fn handle(&mut self, msg: RelayOverrideSchedule, _ctx: &mut Self::Context) -> Self::Result {
let relay_num = msg.relay_number;
let schedule = msg.schedule;
- let weekday = msg.weekday;
+ let weekday = EmgauwaNow::now(&self.settings.midnight).weekday;
let relay = self
.this
diff --git a/src/main.rs b/src/main.rs
index 0da73b5..c3be8a6 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -97,7 +97,7 @@ async fn main() -> Result<(), std::io::Error> {
let mut this = Controller::from_db_model(&mut conn, db_controller).map_err(EmgauwaError::from)?;
- let now = EmgauwaNow::now();
+ let now = EmgauwaNow::now(&settings.midnight);
let initial_states: Vec<bool> = this
.relays
.iter_mut()
@@ -115,12 +115,12 @@ async fn main() -> Result<(), std::io::Error> {
settings.server.host, settings.server.port
);
- let app_state = app_state::AppState::new(pool.clone(), this, settings, drivers).start();
+ let app_state = app_state::AppState::new(pool.clone(), this, settings.clone(), drivers).start();
log::info!("Starting main loops");
let _ = tokio::join!(
- tokio::spawn(run_relays_loop(app_state.clone())),
+ tokio::spawn(run_relays_loop(app_state.clone(), settings.clone())),
tokio::spawn(run_ws_loop(pool.clone(), app_state.clone(), url)),
);
diff --git a/src/relay_loop.rs b/src/relay_loop.rs
index 366a3de..6196501 100644
--- a/src/relay_loop.rs
+++ b/src/relay_loop.rs
@@ -1,11 +1,11 @@
use std::time::Duration;
use actix::Addr;
-use chrono::Timelike;
+use chrono::{Timelike, Weekday};
use emgauwa_common::constants::RELAYS_RETRY_TIMEOUT;
use emgauwa_common::errors::EmgauwaError;
use emgauwa_common::models::Controller;
-use emgauwa_common::types::{EmgauwaNow, Weekday};
+use emgauwa_common::types::EmgauwaNow;
use emgauwa_common::utils::printable_relay_states;
use futures::pin_mut;
use tokio::time;
@@ -13,11 +13,12 @@ use tokio::time::timeout;
use crate::app_state::AppState;
use crate::app_state;
+use crate::settings::Settings;
-pub async fn run_relays_loop(app_state: Addr<AppState>) {
+pub async fn run_relays_loop(app_state: Addr<AppState>, settings: Settings) {
log::debug!("Spawned relays loop");
loop {
- let run_result = run_relays(&app_state).await;
+ let run_result = run_relays(&app_state, &settings).await;
if let Err(err) = run_result {
log::error!("Error running relays: {}", err);
}
@@ -25,18 +26,21 @@ pub async fn run_relays_loop(app_state: Addr<AppState>) {
}
}
-async fn run_relays(app_state: &Addr<AppState>) -> Result<(), EmgauwaError> {
+async fn run_relays(app_state: &Addr<AppState>, settings: &Settings) -> Result<(), EmgauwaError> {
let notifier = &*app_state
.send(app_state::GetControllerNotifier {})
.await?;
- let mut last_weekday = emgauwa_common::utils::get_weekday();
+ let mut last_weekday = EmgauwaNow::now(&settings.midnight).weekday;
let mut this = AppState::get_this(app_state).await?;
let mut duration_override = None;
+ let now = EmgauwaNow::now(&settings.midnight);
+ calc_relay_states(&mut this, app_state, &now).await?;
+
loop {
- let now = EmgauwaNow::now();
+ let now = EmgauwaNow::now(&settings.midnight);
let notifier_future = notifier.notified();
pin_mut!(notifier_future);
@@ -47,7 +51,7 @@ async fn run_relays(app_state: &Addr<AppState>) -> Result<(), EmgauwaError> {
.await
.is_ok();
- let now = EmgauwaNow::now();
+ let now = EmgauwaNow::now(&settings.midnight);
check_weekday(app_state, &mut last_weekday, &mut changed, &now).await?;
@@ -57,8 +61,9 @@ async fn run_relays(app_state: &Addr<AppState>) -> Result<(), EmgauwaError> {
}
log::debug!(
- "Relay loop at {}: {}",
+ "Relay loop at {} on {}: {}",
now.time,
+ now.weekday.to_string(),
printable_relay_states(&this.get_relay_states())
);
@@ -117,15 +122,23 @@ fn get_next_duration(
return *duration;
}
- let next_timestamp = this
+ let next_time = this
.check_next_time(now)
- .map_or(86400, |t| t.num_seconds_from_midnight());
+ .unwrap_or(now.midnight);
- let duration_to_next = Duration::from_secs((next_timestamp - now.time_in_s()) as u64);
+ // 86400 is the number of seconds in a day
+ // If the next timestamp is before the current time, we need to wait until the next day
+ let mut seconds_to_next = (86400 + next_time.num_seconds_from_midnight() - now.num_seconds_from_midnight()) % 86400;
+ if seconds_to_next == 0 {
+ seconds_to_next = 86400;
+ }
+
+
+ let duration_to_next = Duration::from_secs(seconds_to_next as u64);
log::debug!(
- "Next timestamp: {}; Waiting for {}s",
- next_timestamp,
+ "Next time: {}; Waiting for {}s",
+ next_time,
duration_to_next.as_secs()
);
diff --git a/src/settings.rs b/src/settings.rs
index f4f83fd..b812ab0 100644
--- a/src/settings.rs
+++ b/src/settings.rs
@@ -1,3 +1,4 @@
+use chrono::NaiveTime;
use emgauwa_common::errors::EmgauwaError;
use emgauwa_common::settings;
use rppal_pfd::PiFaceDigital;
@@ -27,6 +28,7 @@ pub struct Settings {
pub logging: settings::Logging,
pub name: String,
+ pub midnight: NaiveTime,
pub relays: Vec<Relay>,
}
@@ -39,6 +41,7 @@ impl Default for Settings {
logging: settings::Logging::default(),
name: String::from("Emgauwa Controller"),
+ midnight: NaiveTime::default(),
relays: Vec::new(),
}
}
diff --git a/src/ws/handlers.rs b/src/ws/handlers.rs
index 97caded..bc38744 100644
--- a/src/ws/handlers.rs
+++ b/src/ws/handlers.rs
@@ -156,8 +156,7 @@ async fn handle_relays(
app_state
.send(app_state::RelayOverrideSchedule {
relay_number: relay.r.number,
- schedule: relay.override_schedule.clone(),
- weekday: relay.override_schedule_weekday,
+ schedule: relay.override_schedule.clone()
})
.await??;
From 8a04278da574afef90be0d719291cb07df270ba4 Mon Sep 17 00:00:00 2001
From: Tobias Reisinger <tobias@msrg.cc>
Date: Tue, 11 Jun 2024 14:10:51 +0200
Subject: [PATCH 09/10] Adapt to new relay model
---
src/ws/handlers.rs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/ws/handlers.rs b/src/ws/handlers.rs
index bc38744..b4d0b16 100644
--- a/src/ws/handlers.rs
+++ b/src/ws/handlers.rs
@@ -131,7 +131,7 @@ async fn handle_relays(
relays: Vec<Relay>,
) -> Result<(), EmgauwaError> {
for relay in relays {
- if relay.controller.uid != this.c.uid {
+ if relay.r.controller_uid != this.c.uid {
return Err(EmgauwaError::Other(String::from(
"Controller UID mismatch during relay update",
)));
From 5ee542b44b3c7f1d1d59a4dfe7cb0679d44e0f3f Mon Sep 17 00:00:00 2001
From: Tobias Reisinger <tobias@msrg.cc>
Date: Tue, 11 Jun 2024 17:47:10 +0200
Subject: [PATCH 10/10] Improve config a bit
---
controller.pkl | 2 +-
src/main.rs | 2 +-
2 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/controller.pkl b/controller.pkl
index 3685ba0..107103b 100644
--- a/controller.pkl
+++ b/controller.pkl
@@ -1,4 +1,4 @@
-amends "package://emgauwa.app/pkl/emgauwa@0.2.0#/controller.pkl"
+amends "package://emgauwa.app/pkl/emgauwa@0.2.1#/controller.pkl"
logging {
level = "DEBUG"
diff --git a/src/main.rs b/src/main.rs
index c3be8a6..1e30cab 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -61,7 +61,7 @@ async fn main() -> Result<(), std::io::Error> {
drop_privileges(&settings.permissions)?;
- init_logging(&settings.logging.level)?;
+ init_logging(&settings.logging)?;
let pool = db::init(&settings.database, 5)
.await