chore: release v1.7.84-alpha

core/archipelago/src/server.rs

@@ -15,6 +15,7 @@ use hyper::server::conn::Http;
 use hyper::service::service_fn;
 use std::collections::HashMap;
 use std::net::SocketAddr;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
@@ -28,6 +29,25 @@ pub struct Server {
     _state_manager: Arc<StateManager>,
 }
 
+struct ContainerScanGuard<'a> {
+    scanning: &'a AtomicBool,
+}
+
+impl<'a> ContainerScanGuard<'a> {
+    fn try_acquire(scanning: &'a AtomicBool) -> Option<Self> {
+        scanning
+            .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed)
+            .ok()
+            .map(|_| Self { scanning })
+    }
+}
+
+impl Drop for ContainerScanGuard<'_> {
+    fn drop(&mut self) {
+        self.scanning.store(false, Ordering::Release);
+    }
+}
+
 impl Server {
     pub async fn new(
         config: Config,
@@ -362,7 +382,7 @@ impl Server {
                 // Skip missed ticks instead of catching up — prevents burst of scans
                 // after a slow podman response (which causes DB lock storms)
                 interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
-                let scanning = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
+                let scanning = std::sync::Arc::new(AtomicBool::new(false));
                 loop {
                     tokio::select! {
                         _ = interval.tick() => {}
@@ -377,13 +397,12 @@ impl Server {
                             continue;
                         }
                     }
-                    if scanning.load(std::sync::atomic::Ordering::Relaxed) {
+                    let Some(_scan_guard) = ContainerScanGuard::try_acquire(&scanning) else {
                         debug!("Skipping container scan — previous scan still in progress");
                         scan_tick.send_modify(|n| *n = n.wrapping_add(1));
                         continue;
-                    }
-                    scanning.store(true, std::sync::atomic::Ordering::Relaxed);
-                    if let Err(e) = scan_and_update_packages(
+                    };
+                    let scan_result = scan_and_update_packages(
                         &scanner,
                         &state,
                         identity_clone.as_ref(),
@@ -391,8 +410,8 @@ impl Server {
                         &mut absence_tracker,
                         &mut transitional_since,
                     )
-                    .await
-                    {
+                    .await;
+                    if let Err(e) = scan_result {
                         error!("Failed to update containers: {}", e);
                         if is_podman_scan_timeout(&e) {
                             scan_backoff_until = Some(Instant::now() + Duration::from_secs(30));
@@ -402,7 +421,6 @@ impl Server {
                         scan_backoff_until = None;
                     }
                     scan_tick.send_modify(|n| *n = n.wrapping_add(1));
-                    scanning.store(false, std::sync::atomic::Ordering::Relaxed);
                 }
             });
         }