150 lines
3.4 KiB
Rust
150 lines
3.4 KiB
Rust
use std::time::Duration;
|
|
|
|
use actix::Addr;
|
|
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, Weekday};
|
|
use emgauwa_common::utils::printable_relay_states;
|
|
use futures::pin_mut;
|
|
use tokio::time;
|
|
use tokio::time::timeout;
|
|
|
|
use crate::app_state::AppState;
|
|
use crate::app_state;
|
|
|
|
pub async fn run_relays_loop(app_state: Addr<AppState>) {
|
|
log::debug!("Spawned relays loop");
|
|
loop {
|
|
let run_result = run_relays(&app_state).await;
|
|
if let Err(err) = run_result {
|
|
log::error!("Error running relays: {}", err);
|
|
}
|
|
time::sleep(RELAYS_RETRY_TIMEOUT).await;
|
|
}
|
|
}
|
|
|
|
async fn run_relays(app_state: &Addr<AppState>) -> Result<(), EmgauwaError> {
|
|
let notifier = &*app_state
|
|
.send(app_state::GetControllerNotifier {})
|
|
.await?;
|
|
|
|
let mut last_weekday = emgauwa_common::utils::get_weekday();
|
|
let mut this = AppState::get_this(app_state).await?;
|
|
|
|
let mut duration_override = None;
|
|
|
|
loop {
|
|
let now = EmgauwaNow::now();
|
|
|
|
let notifier_future = notifier.notified();
|
|
pin_mut!(notifier_future);
|
|
let mut changed = timeout(
|
|
get_next_duration(&mut this, &mut duration_override, &now),
|
|
&mut notifier_future,
|
|
)
|
|
.await
|
|
.is_ok();
|
|
|
|
let now = EmgauwaNow::now();
|
|
|
|
check_weekday(app_state, &mut last_weekday, &mut changed, &now).await?;
|
|
|
|
if changed {
|
|
log::debug!("Reloading controller in relay loop");
|
|
this = AppState::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()
|
|
.filter_map(|relay| match relay.check_pulsing(&now.instant) {
|
|
None => None,
|
|
Some(pulse) => {
|
|
let dur = pulse - now.instant;
|
|
log::debug!(
|
|
"Pulsing relay {} for {}s until {:?} ",
|
|
relay.r.number,
|
|
dur.as_secs(),
|
|
pulse
|
|
);
|
|
Some(dur)
|
|
}
|
|
})
|
|
.min();
|
|
|
|
calc_relay_states(&mut this, app_state, &now).await?;
|
|
}
|
|
}
|
|
|
|
async fn calc_relay_states(
|
|
this: &mut Controller,
|
|
app_state: &Addr<AppState>,
|
|
now: &EmgauwaNow,
|
|
) -> Result<(), EmgauwaError> {
|
|
this.relays
|
|
.iter_mut()
|
|
.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(),
|
|
);
|
|
});
|
|
|
|
app_state
|
|
.send(app_state::UpdateRelayStates {
|
|
relay_states: this.get_relay_states()
|
|
})
|
|
.await
|
|
.map_err(EmgauwaError::from)
|
|
}
|
|
|
|
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 next_timestamp = this
|
|
.check_next_time(now)
|
|
.map_or(86400, |t| t.num_seconds_from_midnight());
|
|
|
|
let duration_to_next = Duration::from_secs((next_timestamp - now.time_in_s()) as u64);
|
|
|
|
log::debug!(
|
|
"Next timestamp: {}; Waiting for {}s",
|
|
next_timestamp,
|
|
duration_to_next.as_secs()
|
|
);
|
|
|
|
duration_to_next
|
|
}
|
|
|
|
async fn check_weekday(
|
|
app_state: &Addr<AppState>,
|
|
last_weekday: &mut Weekday,
|
|
changed: &mut bool,
|
|
now: &EmgauwaNow,
|
|
) -> Result<(), EmgauwaError> {
|
|
let current_weekday = now.weekday;
|
|
if current_weekday.ne(last_weekday) {
|
|
log::debug!("Weekday changed");
|
|
*last_weekday = current_weekday;
|
|
AppState::trigger_reload(app_state).await?;
|
|
*changed = true;
|
|
}
|
|
|
|
Ok(())
|
|
}
|