From ce0dbf6b249956700c6a1705bf4ad85a09d53e8c Mon Sep 17 00:00:00 2001
From: Dawid Rycerz <dawid@rycerz.xyz>
Date: Sun, 15 Feb 2026 21:27:00 +0100
Subject: feat: witryna 0.2.0
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Switch, cleanup, and status CLI commands. Persistent build state via
state.json. Post-deploy hooks on success and failure with
WITRYNA_BUILD_STATUS. Dependency diet (axum→tiny_http, clap→argh,
tracing→log). Drop built-in rate limiting. Nix flake with NixOS module.
Arch Linux PKGBUILD. Centralized version management.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 src/build_guard.rs | 43 ++++++++++++++++++++++++++++---------------
 1 file changed, 28 insertions(+), 15 deletions(-)

(limited to 'src/build_guard.rs')

diff --git a/src/build_guard.rs b/src/build_guard.rs
index 0c7fed3..dd67bea 100644
--- a/src/build_guard.rs
+++ b/src/build_guard.rs
@@ -1,33 +1,35 @@
-use dashmap::DashSet;
-use std::sync::Arc;
+use std::collections::HashSet;
+use std::sync::{Arc, Mutex};
 
 /// Manages per-site build scheduling: immediate execution and a depth-1 queue.
 ///
 /// When a build is already in progress, a single rebuild can be queued.
 /// Subsequent requests while a rebuild is already queued are collapsed (no-op).
 pub struct BuildScheduler {
-    pub in_progress: DashSet<String>,
-    pub queued: DashSet<String>,
+    pub in_progress: Mutex<HashSet<String>>,
+    pub queued: Mutex<HashSet<String>>,
 }
 
 impl BuildScheduler {
     #[must_use]
     pub fn new() -> Self {
         Self {
-            in_progress: DashSet::new(),
-            queued: DashSet::new(),
+            in_progress: Mutex::new(HashSet::new()),
+            queued: Mutex::new(HashSet::new()),
         }
     }
 
     /// Queue a rebuild for a site that is currently building.
     /// Returns `true` if newly queued, `false` if already queued (collapse).
     pub(crate) fn try_queue(&self, site_name: &str) -> bool {
-        self.queued.insert(site_name.to_owned())
+        #[allow(clippy::unwrap_used)]
+        self.queued.lock().unwrap().insert(site_name.to_owned())
     }
 
     /// Check and clear queued rebuild. Returns `true` if there was one.
     pub(crate) fn take_queued(&self, site_name: &str) -> bool {
-        self.queued.remove(site_name).is_some()
+        #[allow(clippy::unwrap_used)]
+        self.queued.lock().unwrap().remove(site_name)
     }
 }
 
@@ -47,7 +49,13 @@ pub(crate) struct BuildGuard {
 
 impl BuildGuard {
     pub(crate) fn try_acquire(site_name: String, scheduler: &Arc<BuildScheduler>) -> Option<Self> {
-        if scheduler.in_progress.insert(site_name.clone()) {
+        #[allow(clippy::unwrap_used)]
+        let inserted = scheduler
+            .in_progress
+            .lock()
+            .unwrap()
+            .insert(site_name.clone());
+        if inserted {
             Some(Self {
                 site_name,
                 scheduler: Arc::clone(scheduler),
@@ -60,7 +68,12 @@ impl BuildGuard {
 
 impl Drop for BuildGuard {
     fn drop(&mut self) {
-        self.scheduler.in_progress.remove(&self.site_name);
+        #[allow(clippy::unwrap_used)]
+        self.scheduler
+            .in_progress
+            .lock()
+            .unwrap()
+            .remove(&self.site_name);
     }
 }
 
@@ -74,7 +87,7 @@ mod tests {
         let scheduler = Arc::new(BuildScheduler::new());
         let guard = BuildGuard::try_acquire("my-site".to_owned(), &scheduler);
         assert!(guard.is_some());
-        assert!(scheduler.in_progress.contains("my-site"));
+        assert!(scheduler.in_progress.lock().unwrap().contains("my-site"));
     }
 
     #[test]
@@ -90,10 +103,10 @@ mod tests {
         let scheduler = Arc::new(BuildScheduler::new());
         {
             let _guard = BuildGuard::try_acquire("my-site".to_owned(), &scheduler);
-            assert!(scheduler.in_progress.contains("my-site"));
+            assert!(scheduler.in_progress.lock().unwrap().contains("my-site"));
         }
         // Guard dropped — lock released
-        assert!(!scheduler.in_progress.contains("my-site"));
+        assert!(!scheduler.in_progress.lock().unwrap().contains("my-site"));
         let again = BuildGuard::try_acquire("my-site".to_owned(), &scheduler);
         assert!(again.is_some());
     }
@@ -102,7 +115,7 @@ mod tests {
     fn scheduler_try_queue_succeeds() {
         let scheduler = BuildScheduler::new();
         assert!(scheduler.try_queue("my-site"));
-        assert!(scheduler.queued.contains("my-site"));
+        assert!(scheduler.queued.lock().unwrap().contains("my-site"));
     }
 
     #[test]
@@ -117,7 +130,7 @@ mod tests {
         let scheduler = BuildScheduler::new();
         scheduler.try_queue("my-site");
         assert!(scheduler.take_queued("my-site"));
-        assert!(!scheduler.queued.contains("my-site"));
+        assert!(!scheduler.queued.lock().unwrap().contains("my-site"));
     }
 
     #[test]
-- 
cgit v1.2.3