refactor: replace lazy-static

Signed-off-by: Jan Zachmann <50990105+JanZachmann@users.noreply.github.com>

Author: JanZachmann

Cargo.lock

@@ -26,7 +26,6 @@ futures = { version = "0.3", default-features = false }
 futures-util = { version = "0.3", default-features = false }
 glob = { version = "0.3", default-features = false }
 inotify = { version = "0.11", default-features = false, features = ["stream"] }
-lazy_static = { version = "1.5", default-features = false }
 log = { version = "0.4", default-features = false }
 log-panics = { version = "2", default-features = false }
 modemmanager = { git = "https://github.com/omnect/modemmanager.git", tag = "0.3.4", default-features = false, optional = true }

Cargo.toml

@@ -283,6 +283,10 @@ pub fn add_watch<T>(path: &Path, mask: WatchMask) -> Result<WatchDescriptor>
 where
     T: 'static,
 {
+    let feature_id = TypeId::of::<T>();
+
+    debug!("add_watch: {feature_id:?} {path:?} {mask:?}");
+
     let mut watcher = FILE_WATCHER
         .get()
         .context("add_watch: FileWatcher missing")?
@@ -291,14 +295,20 @@ where
 
     let desc = watcher.watches.add(path, mask)?;
 
-    let None = watcher.feature_map.insert(desc.clone(), TypeId::of::<T>()) else {
+    if watcher
+        .feature_map
+        .insert(desc.clone(), feature_id)
+        .is_some()
+    {
         bail!("add_watch: currently only one feature per watch supported")
-    };
+    }
 
     Ok(desc)
 }
 
 pub fn remove_watch(wd: WatchDescriptor) -> Result<()> {
+    debug!("add_watch: {wd:?}");
+
     let mut watcher = FILE_WATCHER
         .get()
         .context("remove_watch: FileWatcher missing")?
@@ -318,6 +328,10 @@ pub fn notify_interval<T>(interval: Duration) -> Result<()>
 where
     T: 'static,
 {
+    let feature_id = TypeId::of::<T>();
+
+    debug!("notify_interval: {feature_id:?} {interval:?}");
+
     let tx_command_request = TX_COMMAND_REQUEST
         .get()
         .context("notify_interval: failed to get TX_COMMAND_REQUEST")?
@@ -332,9 +346,7 @@ where
                 interval.tick().await;
                 if let Err(e) = tx_command_request
                     .send(CommandRequest {
-                        command: Command::Interval(IntervalCommand {
-                            feature_id: TypeId::of::<T>(),
-                        }),
+                        command: Command::Interval(IntervalCommand { feature_id }),
                         reply: None,
                     })
                     .await

src/twin/feature/mod.rs

@@ -68,6 +68,8 @@ impl Twin {
         tx_outgoing_message: mpsc::Sender<IotMessage>,
     ) -> Result<Self> {
         feature::init(tx_command_request.clone())?;
+        let web_service = web_service::WebService::run(tx_command_request.clone()).await?;
+        
         /*
             - init features first
             - start with SystemInfo in order to log useful infos asap
@@ -117,7 +119,7 @@ impl Twin {
 
         let twin = Twin {
             client: None,
-            web_service: web_service::WebService::run(tx_command_request.clone()).await?,
+            web_service,
             tx_command_request,
             tx_reported_properties,
             tx_outgoing_message,

src/twin/mod.rs

@@ -1,7 +1,6 @@
 use crate::twin::feature::{self, *};
 use anyhow::{Context, Result, bail};
 use azure_iot_sdk::client::IotMessage;
-use lazy_static::lazy_static;
 use serde_json::json;
 use std::{env, time::Duration};
 use tokio::sync::mpsc::Sender;
@@ -294,21 +293,26 @@ mod inner {
     use super::*;
     use log::warn;
 
+    #[derive(Default)]
     pub struct ModemInfo {
         pub(super) tx_reported_properties: Option<Sender<serde_json::Value>>,
     }
 
     impl ModemInfo {
         pub fn new() -> Result<Self> {
-            if 0 < *REFRESH_MODEM_INFO_INTERVAL_SECS {
-                feature::notify_interval::<Self>(Duration::from_secs(
-                    *REFRESH_MODEM_INFO_INTERVAL_SECS,
-                ))?;
+            let modem_info = ModemInfo::default();
+            if modem_info.is_enabled() {
+                let refresh_interval = env::var("REFRESH_MODEM_INFO_INTERVAL_SECS")
+                    .unwrap_or("600".to_string())
+                    .parse::<u64>()
+                    .context("cannot parse REFRESH_MODEM_INFO_INTERVAL_SECS env var")?;
+
+                if 0 < refresh_interval {
+                    feature::notify_interval::<Self>(Duration::from_secs(refresh_interval))?;
+                }
             }
 
-            Ok(ModemInfo {
-                tx_reported_properties: None,
-            })
+            Ok(modem_info)
         }
 
         pub async fn report(&self, force: bool) -> Result<()> {
@@ -337,16 +341,6 @@ pub use inner::ModemInfo;
 const MODEM_INFO_VERSION: u8 = 1;
 const ID: &str = "modem_info";
 
-lazy_static! {
-    static ref REFRESH_MODEM_INFO_INTERVAL_SECS: u64 = {
-        const REFRESH_MODEM_INFO_INTERVAL_SECS_DEFAULT: &str = "600";
-        env::var("REFRESH_MODEM_INFO_INTERVAL_SECS")
-            .unwrap_or(REFRESH_MODEM_INFO_INTERVAL_SECS_DEFAULT.to_string())
-            .parse::<u64>()
-            .expect("cannot parse REFRESH_MODEM_INFO_INTERVAL_SECS env var")
-    };
-}
-
 impl Feature for ModemInfo {
     fn name(&self) -> String {
         ID.to_string()

src/twin/modem_info.rs

@@ -5,23 +5,12 @@ use crate::{
 };
 use anyhow::{Context, Result, bail};
 use azure_iot_sdk::client::IotMessage;
-use lazy_static::lazy_static;
 use log::{debug, error, info, warn};
 use serde::Serialize;
 use serde_json::json;
 use std::{env, time::Duration};
 use tokio::sync::mpsc::Sender;
 
-lazy_static! {
-    static ref REFRESH_NETWORK_STATUS_INTERVAL_SECS: u64 = {
-        const REFRESH_NETWORK_STATUS_INTERVAL_SECS_DEFAULT: &str = "60";
-        env::var("REFRESH_NETWORK_STATUS_INTERVAL_SECS")
-            .unwrap_or(REFRESH_NETWORK_STATUS_INTERVAL_SECS_DEFAULT.to_string())
-            .parse::<u64>()
-            .expect("cannot parse REFRESH_NETWORK_STATUS_INTERVAL_SECS env var")
-    };
-}
-
 static NETWORK_SERVICE: &str = "systemd-networkd.service";
 
 #[derive(PartialEq, Serialize)]
@@ -100,10 +89,13 @@ impl Network {
     const ID: &'static str = "network_status";
 
     pub fn new() -> Result<Self> {
-        if 0 < *REFRESH_NETWORK_STATUS_INTERVAL_SECS {
-            feature::notify_interval::<Self>(Duration::from_secs(
-                *REFRESH_NETWORK_STATUS_INTERVAL_SECS,
-            ))?;
+        let refresh_interval = env::var("REFRESH_NETWORK_STATUS_INTERVAL_SECS")
+            .unwrap_or("60".to_string())
+            .parse::<u64>()
+            .context("cannot parse REFRESH_NETWORK_STATUS_INTERVAL_SECS env var")?;
+
+        if 0 < refresh_interval {
+            feature::notify_interval::<Self>(Duration::from_secs(refresh_interval))?;
         }
 
         Ok(Network {

src/twin/network.rs

@@ -1,24 +1,13 @@
 use crate::twin::feature::{self, *};
 use anyhow::{Context, Result, bail, ensure};
 use azure_iot_sdk::client::IotMessage;
-use lazy_static::lazy_static;
 use log::{debug, info, warn};
 use serde::Serialize;
 use serde_json::json;
 use std::{env, path::Path, time::Duration};
 use time::format_description::well_known::Rfc3339;
 use tokio::sync::mpsc::Sender;
 
-lazy_static! {
-    static ref REFRESH_EST_EXPIRY_INTERVAL_SECS: u64 = {
-        const REFRESH_EST_EXPIRY_INTERVAL_SECS_DEFAULT: &str = "180";
-        env::var("REFRESH_EST_EXPIRY_INTERVAL_SECS")
-            .unwrap_or(REFRESH_EST_EXPIRY_INTERVAL_SECS_DEFAULT.to_string())
-            .parse::<u64>()
-            .expect("cannot parse REFRESH_EST_EXPIRY_INTERVAL_SECS env var")
-    };
-}
-
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "snake_case")]
 enum Source {
@@ -219,7 +208,12 @@ impl ProvisioningConfig {
             _ => bail!("provisioning_config: invalid provisioning configuration found"),
         };
 
-        if 0 < *REFRESH_EST_EXPIRY_INTERVAL_SECS
+        let refresh_interval = env::var("REFRESH_EST_EXPIRY_INTERVAL_SECS")
+            .unwrap_or("180".to_string())
+            .parse::<u64>()
+            .context("cannot parse REFRESH_EST_EXPIRY_INTERVAL_SECS env var")?;
+
+        if 0 < refresh_interval
             && matches!(
                 method,
                 Method::X509(X509 {
@@ -228,9 +222,7 @@ impl ProvisioningConfig {
                 })
             )
         {
-            feature::notify_interval::<Self>(Duration::from_secs(
-                *REFRESH_EST_EXPIRY_INTERVAL_SECS,
-            ))?;
+            feature::notify_interval::<Self>(Duration::from_secs(refresh_interval))?;
         }
 
         let this = ProvisioningConfig {

src/twin/provisioning_config.rs

@@ -7,7 +7,6 @@ use crate::{
 use anyhow::{Context, Result, bail};
 use azure_iot_sdk::client::{IotHubClient, IotMessage};
 use inotify::WatchMask;
-use lazy_static::lazy_static;
 use log::{info, warn};
 use serde::{Deserialize, Serialize, Serializer, ser::Error};
 use serde_json::json;
@@ -22,17 +21,10 @@ use time::format_description::well_known::Rfc3339;
 use tokio::sync::mpsc;
 
 static BOOTLOADER_UPDATED_FILE: &str = "/run/omnect-device-service/omnect_bootloader_updated";
-
-// ToDo
-lazy_static! {
-    static ref REFRESH_SYSTEM_INFO_INTERVAL_SECS: u64 = {
-        const REFRESH_SYSTEM_INFO_INTERVAL_SECS_DEFAULT: &str = "60";
-        env::var("REFRESH_SYSTEM_INFO_INTERVAL_SECS")
-            .unwrap_or(REFRESH_SYSTEM_INFO_INTERVAL_SECS_DEFAULT.to_string())
-            .parse::<u64>()
-            .expect("cannot parse REFRESH_SYSTEM_INFO_INTERVAL_SECS env var")
-    };
-}
+#[cfg(not(feature = "mock"))]
+static TIMESYNC_FILE: &str = "/run/systemd/timesync/synchronized";
+#[cfg(feature = "mock")]
+static TIMESYNC_FILE: &str = "/tmp/synchronized";
 
 #[derive(Default, Serialize)]
 struct Label {
@@ -73,7 +65,7 @@ enum MetricValue {
 }
 
 impl MetricValue {
-    fn to_metric(self) -> Metric {
+    fn metric(self) -> Metric {
         let (name, value, labels) = match self {
             MetricValue::CpuUsage(value) => ("cpu_usage".to_owned(), value, Label::default()),
             MetricValue::MemoryUsed(value) => ("memory_used".to_owned(), value, Label::default()),
@@ -130,15 +122,6 @@ where
     s.serialize_str(&time_stamp)
 }
 
-// ToDo rm lazy_staticw
-lazy_static! {
-    static ref TIMESYNC_FILE: &'static Path = if cfg!(feature = "mock") {
-        Path::new("/tmp/synchronized")
-    } else {
-        Path::new("/run/systemd/timesync/synchronized")
-    };
-}
-
 #[derive(Clone, Debug, Deserialize, PartialEq)]
 pub struct FleetIdCommand {
     pub fleet_id: String,
@@ -253,12 +236,18 @@ impl SystemInfo {
             RootPartition::current()?.as_str()
         );
 
-        feature::add_watch::<Self>(&TIMESYNC_FILE, WatchMask::CREATE | WatchMask::ONESHOT)?;
+        feature::add_watch::<Self>(
+            Path::new(TIMESYNC_FILE),
+            WatchMask::CREATE | WatchMask::ONESHOT,
+        )?;
 
-        if 0 < *REFRESH_SYSTEM_INFO_INTERVAL_SECS {
-            feature::notify_interval::<Self>(Duration::from_secs(
-                *REFRESH_SYSTEM_INFO_INTERVAL_SECS,
-            ))?;
+        let refresh_interval = env::var("REFRESH_SYSTEM_INFO_INTERVAL_SECS")
+            .unwrap_or("60".to_string())
+            .parse::<u64>()
+            .context("cannot parse REFRESH_SYSTEM_INFO_INTERVAL_SECS env var")?;
+
+        if 0 < refresh_interval {
+            feature::notify_interval::<Self>(Duration::from_secs(refresh_interval))?;
         }
 
         Ok(SystemInfo {
@@ -332,12 +321,14 @@ impl SystemInfo {
             return Ok(());
         };
 
-        let Ok(mut time_stamp) = TIME_STAMP.write() else {
-            bail!("metrics: failed to lock TIME_STAMP")
-        };
-        *time_stamp = time::OffsetDateTime::now_utc()
-            .format(&Rfc3339)
-            .context("metrics: failed to get and format timestamp")?;
+        {
+            let Ok(mut time_stamp) = TIME_STAMP.write() else {
+                bail!("metrics: failed to lock TIME_STAMP")
+            };
+            *time_stamp = time::OffsetDateTime::now_utc()
+                .format(&Rfc3339)
+                .context("metrics: failed to get and format timestamp")?;
+        }
 
         self.hardware_info.components.refresh(true);
         self.hardware_info.system.refresh_cpu_usage();
@@ -356,16 +347,16 @@ impl SystemInfo {
             .unwrap_or((0, 0));
 
         let mut metrics = vec![
-            MetricValue::CpuUsage(self.hardware_info.system.global_cpu_usage() as f64).to_metric(),
-            MetricValue::MemoryUsed(self.hardware_info.system.used_memory() as f64).to_metric(),
-            MetricValue::MemoryTotal(self.hardware_info.system.total_memory() as f64).to_metric(),
-            MetricValue::DiskUsed(disk_used as f64).to_metric(),
-            MetricValue::DiskTotal(disk_total as f64).to_metric(),
+            MetricValue::CpuUsage(self.hardware_info.system.global_cpu_usage() as f64).metric(),
+            MetricValue::MemoryUsed(self.hardware_info.system.used_memory() as f64).metric(),
+            MetricValue::MemoryTotal(self.hardware_info.system.total_memory() as f64).metric(),
+            MetricValue::DiskUsed(disk_used as f64).metric(),
+            MetricValue::DiskTotal(disk_total as f64).metric(),
         ];
 
         self.hardware_info.components.iter().for_each(|c| {
             if let Some(t) = c.temperature() {
-                metrics.push(MetricValue::Temp(t.into(), c.label().to_string()).to_metric())
+                metrics.push(MetricValue::Temp(t.into(), c.label().to_string()).metric())
             };
         });