From 01de229f71e8d114863bf08aa4d25d32e91aad73 Mon Sep 17 00:00:00 2001
From: Florian Wickert <FlorianWickert@gmail.com>
Date: Mon, 12 Feb 2024 10:43:43 +0100
Subject: [PATCH] implement 'alarm_last_duration' and 'alarm_last_duration_iso'
 generic placeholders

---
 doc/check.md               |  6 +++++
 src/alarm/state_machine.rs | 46 ++++++++++++++++++++++++++++++++++----
 2 files changed, 48 insertions(+), 4 deletions(-)

diff --git a/doc/check.md b/doc/check.md
index 874d864..70f57ba 100644
--- a/doc/check.md
+++ b/doc/check.md
@@ -149,6 +149,12 @@ Name of the alarm that triggered the action.
 ### alarm_timestamp
 ISO8601 timestamp of the alarm's state change event.
 
+### alarm_last_duration
+Duration the last state lasted in seconds.
+
+### alarm_last_duration_iso
+Duration the last state lasted as ISO8601.
+
 ### alarm_state
 Current state of the alarm.
 
diff --git a/src/alarm/state_machine.rs b/src/alarm/state_machine.rs
index a654787..7fb4908 100644
--- a/src/alarm/state_machine.rs
+++ b/src/alarm/state_machine.rs
@@ -1,5 +1,4 @@
-use crate::PlaceholderMap;
-use crate::{Error, Result};
+use crate::{duration_iso8601, Error, PlaceholderMap, Result};
 
 #[cfg_attr(test, mockall::automock)]
 pub trait StateHandler: Send + Sync + Sized {
@@ -45,6 +44,8 @@ impl State {
 #[derive(Clone)]
 struct GoodState {
     timestamp: std::time::SystemTime,
+    instant: std::time::Instant,
+    last_state_duration: Option<std::time::Duration>,
     bad_cycles: u32,
 }
 
@@ -52,6 +53,8 @@ impl Default for GoodState {
     fn default() -> Self {
         Self {
             timestamp: std::time::SystemTime::now(),
+            instant: std::time::Instant::now(),
+            last_state_duration: None,
             bad_cycles: 0,
         }
     }
@@ -60,6 +63,8 @@ impl Default for GoodState {
 #[derive(Clone)]
 struct BadState {
     timestamp: std::time::SystemTime,
+    instant: std::time::Instant,
+    last_state_duration: std::time::Duration,
     cycles: u32,
     good_cycles: u32,
 }
@@ -67,6 +72,7 @@ struct BadState {
 #[derive(Clone)]
 struct ErrorState {
     timestamp: std::time::SystemTime,
+    last_state_duration: std::time::Duration,
     shadowed_state: Box<State>,
     cycles: u32,
 }
@@ -105,6 +111,14 @@ impl StateHandler for StateMachine {
                     String::from("alarm_timestamp"),
                     crate::datetime_iso8601(bad.timestamp),
                 );
+                placeholders.insert(
+                    String::from("alarm_last_duration"),
+                    bad.last_state_duration.as_secs().to_string(),
+                );
+                placeholders.insert(
+                    String::from("alarm_last_duration_iso"),
+                    duration_iso8601(bad.last_state_duration),
+                );
             }
 
             State::Good(good) => {
@@ -113,6 +127,16 @@ impl StateHandler for StateMachine {
                     String::from("alarm_timestamp"),
                     crate::datetime_iso8601(good.timestamp),
                 );
+                if let Some(last_state_duration) = good.last_state_duration {
+                    placeholders.insert(
+                        String::from("alarm_last_duration"),
+                        last_state_duration.as_secs().to_string(),
+                    );
+                    placeholders.insert(
+                        String::from("alarm_last_duration_iso"),
+                        duration_iso8601(last_state_duration),
+                    );
+                }
             }
 
             State::Error(error) => {
@@ -121,6 +145,14 @@ impl StateHandler for StateMachine {
                     String::from("alarm_timestamp"),
                     crate::datetime_iso8601(error.timestamp),
                 );
+                placeholders.insert(
+                    String::from("alarm_last_duration"),
+                    error.last_state_duration.as_secs().to_string(),
+                );
+                placeholders.insert(
+                    String::from("alarm_last_duration_iso"),
+                    duration_iso8601(error.last_state_duration),
+                );
             }
         }
     }
@@ -128,21 +160,23 @@ impl StateHandler for StateMachine {
     fn error(&mut self) -> bool {
         let mut trigger = false;
         self.state = match &self.state {
-            State::Good(_) => {
+            State::Good(good) => {
                 trigger = true;
                 log::warn!("{} changing from good to error state.", self.log_id);
                 State::Error(ErrorState {
                     timestamp: std::time::SystemTime::now(),
+                    last_state_duration: good.instant.elapsed(),
                     shadowed_state: Box::new(self.state.clone()),
                     cycles: 1,
                 })
             }
 
-            State::Bad(_) => {
+            State::Bad(bad) => {
                 trigger = true;
                 log::warn!("{} changing from bad to error state.", self.log_id);
                 State::Error(ErrorState {
                     timestamp: std::time::SystemTime::now(),
+                    last_state_duration: bad.instant.elapsed(),
                     shadowed_state: Box::new(self.state.clone()),
                     cycles: 1,
                 })
@@ -174,6 +208,8 @@ impl StateHandler for StateMachine {
                     log::warn!("{} changing from good to bad state.", self.log_id);
                     State::Bad(BadState {
                         timestamp: std::time::SystemTime::now(),
+                        instant: std::time::Instant::now(),
+                        last_state_duration: good.instant.elapsed(),
                         cycles: 1,
                         good_cycles: 0,
                     })
@@ -227,6 +263,8 @@ impl StateHandler for StateMachine {
                     log::info!("{} changing from bad to good state.", self.log_id);
                     State::Good(GoodState {
                         timestamp: std::time::SystemTime::now(),
+                        instant: std::time::Instant::now(),
+                        last_state_duration: Some(bad.instant.elapsed()),
                         bad_cycles: 0,
                     })
                 } else {