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

@@ -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;
@@ -300,10 +299,13 @@ mod inner {
 
     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 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 {
@@ -337,16 +339,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())
             };
         });
 

src/twin/system_info.rs

@@ -5,19 +5,25 @@ use crate::{
 use actix_server::ServerHandle;
 use actix_web::{App, HttpResponse, HttpServer, http::StatusCode, web};
 use anyhow::{Context, Result};
-use lazy_static::lazy_static;
 use log::{debug, error, info};
 use reqwest::{Client, header};
 use reqwest_middleware::{ClientBuilder, ClientWithMiddleware};
 use reqwest_retry::{RetryTransientMiddleware, policies::ExponentialBackoff};
 use serde::{Deserialize, Serialize};
 use serde_json::json;
-use std::{collections::HashMap, env, path::Path, str::FromStr, sync::LazyLock};
+use std::{
+    collections::HashMap,
+    env,
+    path::Path,
+    str::FromStr,
+    sync::{LazyLock, OnceLock},
+};
 use tokio::{
     sync::{Mutex, mpsc, oneshot},
     time::Duration,
 };
 
+static IS_WEBSERVICE_DISABLED: OnceLock<bool> = OnceLock::new();
 static PUBLISH_CHANNEL_MAP: LazyLock<Mutex<serde_json::Map<String, serde_json::Value>>> =
     LazyLock::new(|| Mutex::new(serde_json::Map::default()));
 static PUBLISH_STATUS_MAP: LazyLock<Mutex<serde_json::Map<String, serde_json::Value>>> =
@@ -28,13 +34,12 @@ static PUBLISH_CLIENT: LazyLock<Mutex<ClientWithMiddleware>> = LazyLock::new(||
     Mutex::new(
         ClientBuilder::new(
             Client::builder()
-                .timeout(Duration::from_secs(3))
                 .danger_accept_invalid_certs(true)
                 .build()
                 .expect("building ClientWithMiddleware failed"),
         )
         .with(RetryTransientMiddleware::new_with_policy(
-            ExponentialBackoff::builder().build_with_total_retry_duration(Duration::from_secs(15)),
+            ExponentialBackoff::builder().build_with_total_retry_duration(Duration::from_secs(3)),
         ))
         .build(),
     )
@@ -88,23 +93,19 @@ struct PublishEndpointRequest {
     endpoint: PublishEndpoint,
 }
 
-lazy_static! {
-    static ref IS_WEBSERVICE_ENABLED: bool = {
-        env::var("DISABLE_WEBSERVICE")
-            .unwrap_or("false".to_string())
-            .to_lowercase()
-            != "true"
-    };
-}
-
 pub struct WebService {
     srv_handle: ServerHandle,
 }
 
 impl WebService {
     pub async fn run(tx_request: mpsc::Sender<CommandRequest>) -> Result<Option<Self>> {
         // we only start web service feature if not explicitly disabled by 'DISABLE_WEBSERVICE="true"' env var
-        if !(*IS_WEBSERVICE_ENABLED) {
+        if *IS_WEBSERVICE_DISABLED.get_or_init(|| {
+            env::var("DISABLE_WEBSERVICE")
+                .unwrap_or("false".to_string())
+                .to_lowercase()
+                == "true"
+        }) {
             info!("WebService is disabled");
             return Ok(None);
         };
@@ -397,7 +398,7 @@ impl WebService {
 }
 
 pub async fn publish(channel: PublishChannel, value: serde_json::Value) {
-    if !(*IS_WEBSERVICE_ENABLED) {
+    if *IS_WEBSERVICE_DISABLED.wait() {
         debug!("publish: skip since feature not enabled");
         return;
     }