add hash checker, remove time locker, remove checker from refresh

Author: TOwInOK

Cargo.toml

@@ -36,13 +36,25 @@ base64_light = "0.1.5"
 [profile.dev]
 opt-level = 0
 debug = true
+strip = "none"
+debug-assertions = true
+overflow-checks = true
+lto = false
+panic = 'unwind'
+incremental = true
+codegen-units = 256
+rpath = false
 
 [profile.release]
-opt-level = 3
+opt-level = 'z'
 debug = false
 lto = true
-codegen-units = 1
-panic = 'abort'
+codegen-units = 24
+panic = 'unwind'
+strip = true
+incremental = true
+debug-assertions = false
+overflow-checks = false
 
 [profile.test]
 opt-level = 0

sss-cli/Cargo.toml

@@ -36,3 +36,8 @@ utoipa = {workspace = true}
 utoipa-scalar = { version = "0.3.0", features = ["axum"] }
 ## base64
 base64_light.workspace = true
+sha2 = "0.10.8"
+
+[dependencies.xxhash-rust]
+version = "0.8.12"
+features = ["xxh3"]

sss-cli/src/tools.rs

@@ -31,25 +31,21 @@ pub async fn refresh_settings(
     path: &str,
     themes: Option<&Themes>,
     layouts: Option<&Layouts>,
-) -> Result<SettingsUpdateType> {
+) -> Result<()> {
+    info!("Settings is't actual!");
+
     let mut settings = SSSCliSettings::load(path).await?;
-    {
-        let current_settings = SETTINGS.read().await;
-        if settings == *current_settings {
-            info!("Nothing to update, settings is actual");
-            return Ok(SettingsUpdateType::AlreadyActual);
-        }
-    }
-    info!("Settigns is't actual, updating...");
     if let Some(themes) = themes {
         settings.themes = themes.to_owned()
     }
     if let Some(layouts) = layouts {
         settings.layouts = layouts.to_owned()
     }
-    *SETTINGS.deref().write().await = settings;
+    {
+        *SETTINGS.deref().write().await = settings;
+    }
     info!("Settings is actual now!");
-    Ok(SettingsUpdateType::NotActual)
+    Ok(())
 }
 /// Status of actual data
 pub enum SettingsUpdateType {
@@ -70,36 +66,33 @@ pub async fn refresh(
 ) -> Result {
     debug!("Themes in cli: {:#?}", &themes);
     debug!("Layouts in cli: {:#?}", &layouts);
-    match refresh_settings(path, themes, layouts).await? {
-        SettingsUpdateType::AlreadyActual => Ok(()),
-        SettingsUpdateType::NotActual => {
-            refresh_html().await?;
-            tokio::spawn(async move {
-                if let Err(e) = refresh_png().await {
-                    error!("Got refresh error: {}", e);
-                }
-            });
-            tokio::spawn(async move {
-                if let Err(e) = refresh_pdf().await {
-                    error!("Got refresh error: {}", e);
-                }
-            });
-            Ok(())
+    refresh_settings(path, themes, layouts).await?;
+    refresh_html().await?;
+    tokio::spawn(async move {
+        if let Err(e) = refresh_png().await {
+            error!("Got refresh error: {}", e);
         }
-    }
+    });
+    tokio::spawn(async move {
+        if let Err(e) = refresh_pdf().await {
+            error!("Got refresh error: {}", e);
+        }
+    });
+    Ok(())
 }
 
 #[instrument]
 #[inline]
 /// Generate final component
 pub async fn refresh_html() -> Result {
     info!("Render HTML");
-    let settings = SETTINGS.read().await;
-    let layout = settings
-        .layouts
-        .to_layout(&settings.sss_user_settings, (&settings.themes).into());
-
-    *HTML.write().await = layout.finalize()?;
+    {
+        let settings = SETTINGS.read().await;
+        let layout = settings
+            .layouts
+            .to_layout(&settings.sss_user_settings, (&settings.themes).into());
+        *HTML.write().await = layout.finalize()?;
+    }
     info!("Done HTML");
     Ok(())
 }
@@ -109,9 +102,11 @@ pub async fn refresh_html() -> Result {
 /// Generate final component
 pub async fn refresh_png() -> Result {
     info!("Render PNG");
-    let html = HTML.read().await;
-    let image = html_to_image(&html, None, 12).await?;
-    *PNG.deref().write().await = image;
+    {
+        let html = HTML.read().await;
+        let image = html_to_image(&html, None, 12).await?;
+        *PNG.deref().write().await = image;
+    }
     info!("Done PNG");
     Ok(())
 }
@@ -121,9 +116,11 @@ pub async fn refresh_png() -> Result {
 /// Generate final component
 pub async fn refresh_pdf() -> Result {
     info!("Render PDF");
-    let html = HTML.read().await;
-    let image = html_to_pdf(&html, None).await?;
-    *PDF.deref().write().await = image;
+    {
+        let html = HTML.read().await;
+        let image = html_to_pdf(&html, None).await?;
+        *PDF.deref().write().await = image;
+    }
     info!("Done PDF");
     Ok(())
 }

sss-cli/src/web/file_watcher.rs

@@ -1,53 +1,69 @@
-use std::{path::Path, time::Duration};
-
 use notify::{recommended_watcher, Event, RecursiveMode, Watcher};
 use sss_std::{prelude::Layouts, themes::Themes};
+use std::path::Path;
 use tokio::sync::mpsc;
-use tracing::{error, info, trace};
+use tracing::{debug, error, info, trace};
+use xxhash_rust::xxh3::xxh3_64;
 
 use crate::tools::refresh;
 
+// Function to watch a file and refresh settings upon modification
 pub async fn check_file_loop(
     path: String,
     themes: Option<&Themes>,
     layouts: Option<&Layouts>,
     mut shutdown_rx: tokio::sync::broadcast::Receiver<()>,
 ) -> anyhow::Result<()> {
-    let (tx, mut rx) = mpsc::channel(1);
+    // Create a channel to receive file events
+    let (tx, mut rx) = mpsc::channel(100);
 
-    let p = move |res: Result<Event, notify::Error>| {
+    // Define a watcher callback
+    let watcher = move |res: Result<Event, notify::Error>| {
         if let Ok(event) = res {
             let _ = tx.try_send(event);
         }
     };
 
-    let mut watcher = recommended_watcher(p)?;
+    // Initialize the file watcher
+    let mut watcher = recommended_watcher(watcher)?;
     watcher.watch(Path::new(&path), RecursiveMode::NonRecursive)?;
 
-    info!("Start watching changes for file: {}", &path);
+    // Read the file content and calculate the initial hash
+    let file_content = tokio::fs::read(&path).await?;
+    let mut prevision_processed_hash = calculate_xxhash(&file_content);
+    drop(file_content);
 
-    let mut last_event_time = tokio::time::Instant::now() - Duration::from_millis(1);
+    info!("Start watching changes for file: {}", &path);
 
     loop {
         tokio::select! {
+            // Receive file events
             Some(event) = rx.recv() => {
-                let now = tokio::time::Instant::now();
-                if now.duration_since(last_event_time) >= Duration::from_millis(300) {
-                    last_event_time = now;
-
                     match event {
                         Event { kind, .. } if kind.is_modify() => {
-                            trace!("Received modify event");
-                            if let Err(e) = refresh(&path, themes, layouts).await {
-                                error!("Load failed: {}", e);
+                            trace!("Received modify event for {}", path);
+                            // Read the file content
+                            let file_content = tokio::fs::read(&path).await?;
+                            // Calculate the current hash
+                            let current_hash = calculate_xxhash(&file_content);
+                            // Check if the hash has changed
+                            if current_hash != prevision_processed_hash {
+                                debug!("Hash is different:\nprevision: {}\ncurrent: {}", prevision_processed_hash, current_hash);
+                                // Update the hash to the current one
+                                prevision_processed_hash = current_hash;
+                                    // Refresh settings
+                                    if let Err(e) = refresh(&path, themes, layouts).await {
+                                        error!("Failed to refresh settings: {}", e);
+                                    }
+                            } else {
+                                info!("Nothing to change");
+                                trace!("Skipped identical update for {}", path);
                             }
                         }
                         _ => (),
                     }
-                } else {
-                    trace!("Ignored event due to cooldown");
-                }
             }
+            // Handle shutdown signal
             _ = shutdown_rx.recv() => {
                 info!("Shutting down file watcher");
                 break;
@@ -57,3 +73,8 @@ pub async fn check_file_loop(
 
     Ok(())
 }
+
+// Function to calculate the xxHash of data
+fn calculate_xxhash(data: &[u8]) -> u64 {
+    xxh3_64(data)
+}