Merge pull request #45 from silicon-heaven/state-alarm

j4r0u53k · web-flow · commit eddba3d4d517 · 2025-11-18T18:19:47.000+01:00
State alarm
diff --git a/src/alarm.rs b/src/alarm.rs
@@ -124,7 +124,33 @@ impl From<Alarm> for RpcValue {
     }
 }
 
-pub fn collect_alarms(type_info: &TypeInfo, shv_path: impl AsRef<str>, value: &RpcValue) -> Vec<Alarm> {
+trait AlarmGetter {
+    fn alarm_getter(f: &impl FieldDescriptionMethods) -> Option<&str>;
+}
+
+struct CommonAlarm;
+impl AlarmGetter for CommonAlarm {
+    fn alarm_getter(f: &impl FieldDescriptionMethods) -> Option<&str> {
+        f.alarm()
+    }
+}
+
+struct StateAlarm;
+impl AlarmGetter for StateAlarm {
+    fn alarm_getter(f: &impl FieldDescriptionMethods) -> Option<&str> {
+        f.state_alarm()
+    }
+}
+
+pub fn collect_alarms(type_info: &TypeInfo, shv_path: &str, value: &RpcValue) -> Vec<Alarm> {
+    impl_collect_alarms::<CommonAlarm>(type_info, shv_path, value)
+}
+
+pub fn collect_state_alarms(type_info: &TypeInfo, shv_path: &str, value: &RpcValue) -> Vec<Alarm> {
+    impl_collect_alarms::<StateAlarm>(type_info, shv_path, value)
+}
+
+fn impl_collect_alarms<Getter: AlarmGetter>(type_info: &TypeInfo, shv_path: impl AsRef<str>, value: &RpcValue) -> Vec<Alarm> {
     if value.is_null() {
         // value not available, keep previous alarms active
         return vec![];
@@ -136,7 +162,7 @@ pub fn collect_alarms(type_info: &TypeInfo, shv_path: impl AsRef<str>, value: &R
         return vec![];
     }
 
-    if let Some(alarm) = property_description.alarm() && !alarm.is_empty() {
+    if let Some(alarm) = Getter::alarm_getter(&property_description) && !alarm.is_empty() {
         vec![
             Alarm {
                 path: shv_path.into(),
@@ -148,11 +174,11 @@ pub fn collect_alarms(type_info: &TypeInfo, shv_path: impl AsRef<str>, value: &R
             }
         ]
     } else {
-        collect_alarms_for_type(type_info, shv_path, property_description.type_name().unwrap_or_default(), value)
+        collect_alarms_for_type::<Getter>(type_info, shv_path, property_description.type_name().unwrap_or_default(), value)
     }
 }
 
-fn collect_alarms_for_type(type_info: &TypeInfo, shv_path: impl AsRef<str>, type_name: impl AsRef<str>, value: &RpcValue) -> Vec<Alarm> {
+fn collect_alarms_for_type<Getter: AlarmGetter>(type_info: &TypeInfo, shv_path: impl AsRef<str>, type_name: impl AsRef<str>, value: &RpcValue) -> Vec<Alarm> {
     let Some(type_descr) = type_info.find_type_description(type_name).filter(|descr| descr.is_valid()) else {
         return vec![]
     };
@@ -164,7 +190,7 @@ fn collect_alarms_for_type(type_info: &TypeInfo, shv_path: impl AsRef<str>, type
                 .flat_map(|fld_descr| {
                     let sub_path = format!("{shv_path}/{fld_descr_name}", fld_descr_name = fld_descr.name());
                     let bitfield_value = fld_descr.bitfield_value(value.as_u64());
-                    if let Some(alarm) = fld_descr.alarm().filter(|alarm| !alarm.is_empty()) {
+                    if let Some(alarm) = Getter::alarm_getter(fld_descr).filter(|alarm| !alarm.is_empty()) {
                         vec![
                             Alarm {
                                 path: sub_path,
@@ -176,7 +202,7 @@ fn collect_alarms_for_type(type_info: &TypeInfo, shv_path: impl AsRef<str>, type
                             }
                         ]
                     } else {
-                        collect_alarms_for_type(
+                        collect_alarms_for_type::<Getter>(
                             type_info,
                             sub_path,
                             fld_descr.type_name().unwrap_or_default(),
@@ -191,17 +217,16 @@ fn collect_alarms_for_type(type_info: &TypeInfo, shv_path: impl AsRef<str>, type
 
             let has_alarm_definition = fields
                 .iter()
-                .any(|field| field
-                    .alarm()
+                .any(|field| Getter::alarm_getter(field)
                     .is_some_and(|f| !f.is_empty())
                 );
             if !has_alarm_definition {
                 return vec![];
             }
 
             let active_alarm_field = fields
-                .iter()
-                .find(|field| field.alarm().is_some_and(|alarm| !alarm.is_empty())
+                .into_iter()
+                .find(|field| Getter::alarm_getter(field).is_some_and(|alarm| !alarm.is_empty())
                     && field.bit_range().is_some_and(|bit_range| bit_range.as_u64() == value.as_u64()));
             match active_alarm_field {
                 Some(field) => vec![
@@ -211,7 +236,7 @@ fn collect_alarms_for_type(type_info: &TypeInfo, shv_path: impl AsRef<str>, type
                         description: field.description().unwrap_or_default().into(),
                         label: field.label().unwrap_or_default().into(),
                         level: field.alarm_level().unwrap_or_default(),
-                        severity: field.alarm().unwrap_or_default().into(),
+                        severity: Getter::alarm_getter(&field).unwrap_or_default().into(),
                     }
                 ],
                 None => vec![
diff --git a/src/alarmlog.rs b/src/alarmlog.rs
@@ -8,6 +8,7 @@ use shvclient::AppState;
 use shvproto::{FromRpcValue, ToRpcValue};
 use tokio::sync::Semaphore;
 
+use crate::alarm::collect_alarms;
 use crate::getlog::getlog_handler;
 use crate::journalrw::{GetLog2Params, GetLog2Since};
 use crate::sites::update_alarms;
@@ -84,14 +85,14 @@ pub(crate) async fn alarmlog_impl(
         .map(|(site_path, log, type_info)| {
             let mut tmp_alarms = Vec::<AlarmWithTimestamp>::new();
             for entry in log.snapshot_entries {
-                update_alarms(&mut tmp_alarms, type_info, &entry.path, &entry.value, shvproto::DateTime::from_epoch_msec(entry.epoch_msec));
+                update_alarms(collect_alarms, &mut tmp_alarms, type_info, &entry.path, &entry.value, shvproto::DateTime::from_epoch_msec(entry.epoch_msec));
             }
 
             let snapshot = tmp_alarms.clone();
 
             let events = log.event_entries
                 .into_iter()
-                .flat_map(|entry| update_alarms(&mut tmp_alarms, type_info, &entry.path, &entry.value, shvproto::DateTime::from_epoch_msec(entry.epoch_msec)))
+                .flat_map(|entry| update_alarms(collect_alarms, &mut tmp_alarms, type_info, &entry.path, &entry.value, shvproto::DateTime::from_epoch_msec(entry.epoch_msec)))
                 .collect::<Vec<_>>();
 
             (site_path.to_string(), AlarmLog {
diff --git a/src/lib.rs b/src/lib.rs
@@ -72,6 +72,7 @@ struct State {
     sites_data: RwLock<sites::SitesData>,
     sync_info: sync::SyncInfo,
     alarms: RwLock<BTreeMap<String, Vec<AlarmWithTimestamp>>>,
+    state_alarms: RwLock<BTreeMap<String, Vec<AlarmWithTimestamp>>>,
     online_states: RwLock<BTreeMap<String, SiteOnlineStatus>>,
     config: HpConfig,
     sync_cmd_tx: DedupSender<sync::SyncCommand>,
@@ -94,6 +95,7 @@ pub async fn run(hp_config: &HpConfig, client_config: &ClientConfig) -> shvrpc::
         sites_data: RwLock::default(),
         sync_info: Default::default(),
         alarms: Default::default(),
+        state_alarms: Default::default(),
         online_states: Default::default(),
         config: hp_config.clone(),
         sync_cmd_tx,
diff --git a/src/sites.rs b/src/sites.rs
@@ -14,7 +14,7 @@ use shvrpc::rpcmessage::{RpcError, RpcErrorCode};
 use shvrpc::{join_path, RpcMessageMetaTags};
 use tokio::time::timeout;
 
-use crate::alarm::{collect_alarms, Alarm};
+use crate::alarm::{collect_alarms, collect_state_alarms, Alarm};
 use crate::getlog::getlog_handler;
 use crate::typeinfo::TypeInfo;
 use crate::util::{subscribe, subscription_prefix_path};
@@ -163,8 +163,9 @@ fn collect_sub_hps(
         .collect()
 }
 
-pub(crate) fn update_alarms(alarms_for_site: &mut Vec<AlarmWithTimestamp>, type_info: &TypeInfo, property_path: &str, value: &RpcValue, timestamp: shvproto::DateTime) -> Vec<AlarmWithTimestamp> {
-    let new_alarms = collect_alarms(type_info, property_path, value)
+type AlarmCollector = fn(type_info: &TypeInfo, shv_path: &str, value: &RpcValue) -> Vec<Alarm>;
+pub(crate) fn update_alarms(alarms_colector: AlarmCollector, alarms_for_site: &mut Vec<AlarmWithTimestamp>, type_info: &TypeInfo, property_path: &str, value: &RpcValue, timestamp: shvproto::DateTime) -> Vec<AlarmWithTimestamp> {
+    let new_alarms = alarms_colector(type_info, property_path, value)
         .into_iter()
         .map(|alarm| AlarmWithTimestamp {
             alarm,
@@ -524,6 +525,7 @@ pub(crate) async fn sites_task(
                         ..Default::default()
                     };
                     let mut alarms = BTreeMap::<String, Vec<AlarmWithTimestamp>>::new();
+                    let mut state_alarms = BTreeMap::<String, Vec<AlarmWithTimestamp>>::new();
                     for site_path in sites_info.keys() {
                         let Some(Ok(type_info)) = typeinfos.get(site_path) else {
                             // No typeinfo for this site - skip
@@ -538,15 +540,21 @@ pub(crate) async fn sites_task(
                             }
                         };
 
-                        let alarms_for_site = alarms.entry(site_path.to_string()).or_default();
-
                         let chained_entries = log.snapshot_entries.iter().map(Arc::as_ref).chain(log.event_entries.iter().map(Arc::as_ref));
-                        for entry in chained_entries  {
-                            update_alarms(alarms_for_site, type_info, &entry.path, &entry.value, shvproto::DateTime::from_epoch_msec(entry.epoch_msec));
-                        }
+                        let impl_update_alarms = |alarm_table: &mut BTreeMap<String, Vec<AlarmWithTimestamp>>, alarm_collector| {
+                            let alarms_for_site = alarm_table.entry(site_path.to_string()).or_default();
+
+                            for entry in chained_entries.clone()  {
+                                update_alarms(alarm_collector, alarms_for_site, type_info, &entry.path, &entry.value, shvproto::DateTime::from_epoch_msec(entry.epoch_msec));
+                            }
+                        };
+
+                        impl_update_alarms(&mut alarms, collect_alarms);
+                        impl_update_alarms(&mut state_alarms, collect_state_alarms);
                     }
 
                     *app_state.alarms.write().await = alarms;
+                    *app_state.state_alarms.write().await = state_alarms;
 
                     let mut online_status_workers = Vec::new();
                     for (site, info) in sites_info.iter() {
@@ -634,14 +642,18 @@ pub(crate) async fn sites_task(
                     continue;
                 };
 
-                let alarms = &mut *app_state.alarms.write().await;
-                let alarms_for_site = alarms.entry(parsed_notification.site_path.clone()).or_default();
+                let impl_update_alarms = |alarm_table: &mut BTreeMap<String, Vec<AlarmWithTimestamp>>, alarm_collector, signal_name| {
+                    let alarms_for_site = alarm_table.entry(parsed_notification.site_path.clone()).or_default();
 
-                let updated = update_alarms(alarms_for_site, type_info, &parsed_notification.property_path, &parsed_notification.param, shvproto::DateTime::now());
-                if !updated.is_empty() {
-                    client_cmd_tx.send_message(shvrpc::RpcMessage::new_signal(&parsed_notification.site_path, "alarmmod", None))
-                        .unwrap_or_else(|err| log::error!("alarms: Cannot send signal ({err})"));
-                }
+                    let updated = update_alarms(alarm_collector, alarms_for_site, type_info, &parsed_notification.property_path, &parsed_notification.param, shvproto::DateTime::now());
+                    if !updated.is_empty() {
+                        client_cmd_tx.send_message(shvrpc::RpcMessage::new_signal(&parsed_notification.site_path, signal_name, None))
+                            .unwrap_or_else(|err| log::error!("alarms: Cannot send signal ({err})"));
+                    }
+                };
+
+                impl_update_alarms(&mut *app_state.alarms.write().await, collect_alarms, "alarmmod");
+                impl_update_alarms(&mut *app_state.state_alarms.write().await, collect_state_alarms, "statealarmmod");
             }
             complete => break,
         }
diff --git a/src/tree.rs b/src/tree.rs
@@ -1,3 +1,4 @@
+use std::collections::BTreeMap;
 use std::sync::Arc;
 
 use async_compression::tokio::write::GzipEncoder;
@@ -11,6 +12,7 @@ use shvrpc::metamethod::MetaMethod;
 use shvrpc::rpcmessage::{RpcError, RpcErrorCode};
 use shvrpc::{RpcMessage, RpcMessageMetaTags};
 use tokio::io::{AsyncBufRead, AsyncReadExt, AsyncSeekExt, AsyncWriteExt};
+use tokio::sync::RwLockReadGuard;
 use tokio_stream::wrappers::ReadDirStream;
 use tokio_util::io::ReaderStream;
 
@@ -20,11 +22,12 @@ use crate::getlog::getlog_handler;
 use crate::journalrw::{journal_entries_to_rpcvalue, GetLog2Params, Log2Header, Log2Reader};
 use crate::pushlog::pushlog_impl;
 use crate::sites::SubHpInfo;
-use crate::{ClientCommandSender, HpConfig, State, MAX_JOURNAL_DIR_SIZE_DEFAULT};
+use crate::{AlarmWithTimestamp, ClientCommandSender, HpConfig, State, MAX_JOURNAL_DIR_SIZE_DEFAULT};
 
 // History site node methods
 const METH_GET_LOG: &str = "getLog";
 const METH_ALARM_TABLE: &str = "alarmTable";
+const METH_STATE_ALARM_TABLE: &str = "stateAlarmTable";
 const METH_ALARM_LOG: &str = "alarmLog";
 const METH_PUSH_LOG: &str = "pushLog";
 
@@ -48,6 +51,16 @@ const META_METHOD_ALARM_TABLE: MetaMethod = MetaMethod {
     description: "",
 };
 
+const META_METHOD_STATE_ALARM_TABLE: MetaMethod = MetaMethod {
+    name: METH_STATE_ALARM_TABLE,
+    flags: 0,
+    access: shvrpc::metamethod::AccessLevel::Read,
+    param: "RpcValue",
+    result: "RpcValue",
+    signals: &[("statealarmmod", Some("Null"))],
+    description: "",
+};
+
 const META_METHOD_ALARM_LOG: MetaMethod = MetaMethod {
     name: METH_ALARM_LOG,
     flags: 0,
@@ -688,14 +701,33 @@ async fn getlog_handler_rq(
     Ok(result)
 }
 
-async fn alarmtable_handler(
+trait AlarmGetter {
+    async fn alarm_getter(f: &State) -> RwLockReadGuard<'_, BTreeMap<String, Vec<AlarmWithTimestamp>>>;
+}
+
+struct CommonAlarm;
+impl AlarmGetter for CommonAlarm {
+    async fn alarm_getter(f: &State) -> RwLockReadGuard<'_, BTreeMap<String, Vec<AlarmWithTimestamp>>> {
+        f.alarms.read().await
+    }
+}
+
+struct StateAlarm;
+impl AlarmGetter for StateAlarm {
+    async fn alarm_getter(f: &State) -> RwLockReadGuard<'_, BTreeMap<String, Vec<AlarmWithTimestamp>>> {
+        f.state_alarms.read().await
+    }
+}
+
+async fn alarmtable_handler<Getter: AlarmGetter>(
     site_path: &str,
     app_state: AppState<State>,
 ) -> RpcRequestResult {
     if !app_state.sites_data.read().await.sites_info.contains_key(site_path) {
         return Err(RpcError::new(RpcErrorCode::InvalidParam, format!("Wrong alarmTable path: {site_path}")));
     }
-    match app_state.alarms.read().await.get(site_path) {
+
+    match Getter::alarm_getter(&app_state).await.get(site_path) {
         Some(alarms_for_site) => Ok(alarms_for_site.clone().into()),
         None => Ok(Vec::<RpcValue>::new().into()),
     }
@@ -725,7 +757,8 @@ async fn history_request_handler(
     match method {
         METH_LS => Ok(children.into()),
         METH_GET_LOG => getlog_handler_rq(path, &param, app_state).await,
-        METH_ALARM_TABLE => alarmtable_handler(path, app_state).await,
+        METH_ALARM_TABLE => alarmtable_handler::<CommonAlarm>(path, app_state).await,
+        METH_STATE_ALARM_TABLE => alarmtable_handler::<StateAlarm>(path, app_state).await,
         METH_ALARM_LOG => alarmlog_handler(path, &param, app_state).await,
         METH_PUSH_LOG => pushlog_handler(path, param, app_state).await,
         _ => Err(rpc_error_unknown_method(method)),
@@ -815,7 +848,7 @@ pub(crate) async fn methods_getter(
                 }
 
                 if sites_data.typeinfos.get(&path).is_some_and(Result::is_ok) {
-                    Some(MetaMethods::from(&[&META_METHOD_GET_LOG, &META_METHOD_ALARM_TABLE, &META_METHOD_ALARM_LOG]))
+                    Some(MetaMethods::from(&[&META_METHOD_GET_LOG, &META_METHOD_ALARM_TABLE, &META_METHOD_STATE_ALARM_TABLE, &META_METHOD_ALARM_LOG]))
                 } else {
                     Some(MetaMethods::from(&[&META_METHOD_GET_LOG, &META_METHOD_ALARM_LOG]))
                 }
diff --git a/src/typeinfo.rs b/src/typeinfo.rs
@@ -30,6 +30,7 @@ pub const KEY_BLACKLIST: &str = "blacklist";
 pub const KEY_DEC_PLACES: &str = "decPlaces";
 pub const KEY_VISUAL_STYLE: &str = "visualStyle";
 pub const KEY_ALARM: &str = "alarm";
+pub const KEY_STATE_ALARM: &str = "stateAlarm";
 pub const KEY_ALARM_LEVEL: &str = "alarmLevel";
 
 fn merge_tags(mut map: RpcMap) -> RpcMap {
@@ -290,6 +291,12 @@ pub trait FieldDescriptionMethods: TypeDescriptionMethods {
     fn set_alarm(&mut self, alarm: impl AsRef<str>) {
         set_data_value(self, KEY_ALARM, alarm.as_ref());
     }
+    fn state_alarm(&self) -> Option<&str> {
+        self.data_value(KEY_STATE_ALARM).map(RpcValue::as_str)
+    }
+    fn set_state_alarm(&mut self, alarm: impl AsRef<str>) {
+        set_data_value(self, KEY_STATE_ALARM, alarm.as_ref());
+    }
     fn alarm_level(&self) -> Option<i32> {
         self.data_value(KEY_ALARM_LEVEL).map(RpcValue::as_i32)
     }
@@ -565,6 +572,7 @@ impl PropertyDescription {
             "monitorOptions",
             KEY_SAMPLE_TYPE,
             KEY_ALARM,
+            KEY_STATE_ALARM,
             KEY_ALARM_LEVEL,
         ];
 
@@ -1278,6 +1286,7 @@ mod tests {
                 {"alarm":"warning", "description":"Alarm 1", "label":"Alarm 1 label", "name":"field1", "value": [0,7] },
                 {"alarm":"error", "description":"Alarm 2", "label":"Alarm 2 label", "name":"field2", "value": 24 },
                 {"name":"field3", "value": [25, 26] },
+                {"stateAlarm":"error", "description":"State alarm 1", "label":"State alarm 1 label", "name":"field4", "value": 27 },
             ],
             "typeName":"BitField"
         },
@@ -1303,6 +1312,7 @@ mod tests {
                 },
                 {
                     "alarm":"error",
+                    "stateAlarm":"error",
                     "alarmLevel":100,
                     "description":"",
                     "label":"",
@@ -1416,6 +1426,8 @@ mod tests {
         assert_eq!(bitfield_type_descr.field_value(0x7effffff, "field2").unwrap().as_u32(), 0);
         assert_eq!(bitfield_type_descr.field_value(0x1cffffff, "field3").unwrap().as_u32(), 2);
 
+        assert_eq!(bitfield_type_descr.field("field4").as_ref().and_then(FieldDescriptionMethods::state_alarm), Some("error"));
+
         let map_type_descr = type_info.find_type_description("Map").unwrap();
         assert!(matches!(map_type_descr.type_id(), Some(Type::Map)));
         assert!(map_type_descr.sample_type().is_some_and(|st| matches!(st, SampleType::Discrete)));
@@ -1436,6 +1448,8 @@ mod tests {
         for fld in &enum_type_descr.fields() {
             assert!(field_alarms.get(fld.name()).is_some_and(|(alarm, level)| alarm == &fld.alarm() && level == &fld.alarm_level()));
         }
+
+        assert_eq!(enum_type_descr.field("Error").as_ref().and_then(FieldDescriptionMethods::state_alarm), Some("error"));
     }
 
     #[test]
diff --git a/src/util.rs b/src/util.rs
@@ -423,6 +423,7 @@ pub mod testing {
             }),
             sync_info: Default::default(),
             alarms: Default::default(),
+            state_alarms: Default::default(),
             online_states: Default::default(),
         });
 
