Use LazyLock instead of lazy_static.

Author: astonbitecode

Cargo.toml

@@ -54,12 +54,8 @@ async-trait = "0.1"
 zeroize = {version = "1.8", features = ["zeroize_derive"] }
 serde = { version = "1.0", features = ["derive"] }
 bytes = "1.10"
-lazy_static = "1.5"
 
 [dependencies.toml]
 version = "0.8"
 default-features = false
-features = ["preserve_order", "display", "parse"]
-
-[dev-dependencies]
-lazy_static = "1.5"
+features = ["preserve_order", "display", "parse"]

src/asynch/dropbox.rs

@@ -16,7 +16,7 @@
 
 use std::io::Read;
 use std::net::{IpAddr, Ipv4Addr, SocketAddr};
-use std::sync::mpsc;
+use std::sync::{LazyLock, mpsc};
 use std::sync::{Arc, Mutex};
 use std::time::{self, Duration};
 
@@ -31,7 +31,6 @@ use hyper::server::conn::http1;
 use hyper::service::service_fn;
 use hyper::{Request, Response};
 use hyper_util::rt::{TokioIo, TokioTimer};
-use lazy_static::lazy_static;
 use log::*;
 use percent_encoding::{utf8_percent_encode, AsciiSet, CONTROLS};
 use serde::{Deserialize, Serialize};
@@ -74,9 +73,7 @@ const HTTP_GET_RESPONSE_BODY: &str = r#"
 </html>
 "#;
 
-lazy_static! {
-    static ref STOP_SYNCHRONIZATION: Mutex<bool> = Mutex::new(false);
-}
+static STOP_SYNCHRONIZATION: LazyLock<Mutex<bool>> = LazyLock::new(|| { Mutex::new(false) });
 
 /// A Dropbox synchronizer
 #[derive(Clone)]

src/asynch/nextcloud.rs

@@ -16,12 +16,11 @@
 
 use async_trait::async_trait;
 use reqwest::{Body, Client, Request, Response};
-use lazy_static::lazy_static;
 use tokio::time::sleep;
 use std::io::prelude::*;
 use std::time::Duration;
 use url::Url;
-use std::sync::Mutex;
+use std::sync::{LazyLock, Mutex};
 
 use http::{Method, StatusCode};
 use log::*;
@@ -36,9 +35,7 @@ use crate::errors::RustKeylockError;
 use crate::SystemConfiguration;
 use crate::{errors, file_handler};
 
-lazy_static! {
-    static ref STOP_SYNCHRONIZATION: Mutex<bool> = Mutex::new(false);
-}
+static STOP_SYNCHRONIZATION: LazyLock<Mutex<bool>> = LazyLock::new(|| { Mutex::new(false) });
 
 /// A (Next/Own)cloud synchronizer
 #[derive(Clone)]
@@ -781,15 +778,14 @@ mod nextcloud_tests {
     use std::io::prelude::*;
     use std::net::{IpAddr, Ipv4Addr, SocketAddr};
     use std::sync::mpsc::{self, Receiver, SyncSender};
-    use std::sync::Mutex;
+    use std::sync::{LazyLock, Mutex};
     use std::thread;
     use std::time;
 
     use http::StatusCode;
     use hyper::service::service_fn;
     use hyper::{Request, Response};
     use hyper_util::rt::{TokioIo, TokioTimer};
-    use lazy_static::lazy_static;
     use std::convert::Infallible;
     use tokio;
     use toml;
@@ -800,9 +796,7 @@ mod nextcloud_tests {
     use super::super::super::{errors, file_handler, SystemConfiguration};
     use super::super::AsyncTask;
 
-    lazy_static! {
-        static ref TXMAP: Mutex<HashMap<String, SyncSender<bool>>> = Mutex::new(HashMap::new());
-    }
+    static TXMAP: LazyLock<Mutex<HashMap<String, SyncSender<bool>>>> = LazyLock::new(|| { Mutex::new(HashMap::new()) });
 
     fn get_tx_for(command: &str) -> SyncSender<bool> {
         let map = TXMAP.lock().unwrap();

src/lib.rs

@@ -27,8 +27,6 @@ extern crate futures;
 extern crate http;
 extern crate hyper;
 extern crate hyper_tls;
-#[cfg(test)]
-extern crate lazy_static;
 extern crate log;
 extern crate native_tls;
 extern crate openssl_probe;

src/rest_server.rs

@@ -25,15 +25,14 @@ use hyper::server::conn::http1;
 use hyper::service::Service;
 use hyper::{body::Incoming as IncomingBody, Request, Response};
 use hyper_util::rt::TokioIo;
-use lazy_static::lazy_static;
 use log::{debug, info, warn};
 use rand::{thread_rng, Rng};
 use spake2::{Ed25519Group, Identity, Password, Spake2};
 use tokio::net::TcpListener;
 use tokio::task::JoinHandle;
 use url::form_urlencoded;
 
-use std::future::Future;
+use std::{future::Future, sync::LazyLock};
 use std::net::SocketAddr;
 use std::pin::Pin;
 use std::sync::{Arc, Mutex};
@@ -47,11 +46,9 @@ use crate::{
     Entry, Safe,
 };
 
-lazy_static! {
-    static ref SESSION_KEY: Mutex<Option<Vec<u8>>> = Mutex::new(None);
-    static ref COUNTER: Mutex<Counter> = Mutex::new(0);
-    static ref LOST_COUNTS: Mutex<Vec<Counter>> = Mutex::new(Vec::new());
-}
+static SESSION_KEY: LazyLock<Mutex<Option<Vec<u8>>>> = LazyLock::new(|| { Mutex::new(None) });
+static COUNTER: LazyLock<Mutex<Counter>> = LazyLock::new(|| { Mutex::new(0) });
+static LOST_COUNTS: LazyLock<Mutex<Vec<Counter>>> = LazyLock::new(|| { Mutex::new(Vec::new()) });
 
 fn get_session_key_opt() -> Option<Vec<u8>> {
     SESSION_KEY.lock().expect("Session Key is poisoned").clone()
@@ -356,9 +353,7 @@ fn decrypt_base_64(key: &[u8], product: &str) -> errors::Result<Vec<u8>> {
 mod rest_server_tests {
     use super::*;
 
-    lazy_static! {
-        static ref SYNC_GUARD: Mutex<()> = Mutex::new(());
-    }
+    static SYNC_GUARD: LazyLock<Mutex<()>> = LazyLock::new(|| { Mutex::new(()) });
 
     fn init_tests() {
         let _guard = SYNC_GUARD.lock().unwrap();

tests/execution_cases.rs

@@ -415,6 +415,8 @@ async fn execute_update_configuration() {
         // Update the configuration
         UserSelection::GoTo(Menu::ShowConfiguration),
         UserSelection::UpdateConfiguration(new_conf),
+        // Ack sync error message
+        UserSelection::UserOption(UserOption::ok()),
         // Save
         UserSelection::GoTo(Menu::Save(false)),
         // Ack saved message