0.34.6_repo_cleanup

src/cache/collapse.rs

@@ -36,10 +36,7 @@ impl Drop for CollapseWaiterGuard {
 impl Drop for FillLeaderGuard {
     fn drop(&mut self) {
         if let Some(cache) = self.cache.upgrade() {
-            let mut flights = cache
-                .fill_flights
-                .lock()
-                .unwrap_or_else(|e| e.into_inner());
+            let mut flights = cache.fill_flights.lock().unwrap_or_else(|e| e.into_inner());
             let current = flights
                 .get(&self.key)
                 .is_some_and(|flight| flight.id == self.id);
@@ -47,25 +44,17 @@ impl Drop for FillLeaderGuard {
                 flights.remove(&self.key);
             }
         }
-        // Publish completion even when a purge already removed this flight from the map.
         self.done.send_replace(true);
     }
 }
 
 impl Cache {
-    pub async fn claim_fill(
-        self: &Arc<Self>,
-        ticket: &Ticket,
-        settings: &Settings,
-    ) -> FillClaim {
+    pub async fn claim_fill(self: &Arc<Self>, ticket: &Ticket, settings: &Settings) -> FillClaim {
         if !settings.collapse_enabled {
             return FillClaim::Disabled;
         }
         let existing = {
-            let mut flights = self
-                .fill_flights
-                .lock()
-                .unwrap_or_else(|e| e.into_inner());
+            let mut flights = self.fill_flights.lock().unwrap_or_else(|e| e.into_inner());
             if let Some(flight) = flights.get(&ticket.key) {
                 Some(flight.clone())
             } else {
@@ -96,8 +85,6 @@ impl Cache {
         let Some(flight) = existing else {
             unreachable!("existing fill resolved above")
         };
-        // A watch channel retains the completed state, so a leader finishing between
-        // map lookup and follower polling cannot lose the wakeup.
         let mut done = flight.done.subscribe();
         self.collapse_waiters.fetch_add(1, Ordering::Relaxed);
         let _waiter = CollapseWaiterGuard {
@@ -131,11 +118,11 @@ impl Cache {
 
     fn cancel_all_fill_flights(&self) {
         let flights = {
-            let mut flights = self
-                .fill_flights
-                .lock()
-                .unwrap_or_else(|e| e.into_inner());
-            flights.drain().map(|(_, flight)| flight).collect::<Vec<_>>()
+            let mut flights = self.fill_flights.lock().unwrap_or_else(|e| e.into_inner());
+            flights
+                .drain()
+                .map(|(_, flight)| flight)
+                .collect::<Vec<_>>()
         };
         for flight in flights {
             flight.done.send_replace(true);
@@ -144,10 +131,7 @@ impl Cache {
 
     fn cancel_scope_fill_flights(&self, scope: &str) {
         let removed = {
-            let mut flights = self
-                .fill_flights
-                .lock()
-                .unwrap_or_else(|e| e.into_inner());
+            let mut flights = self.fill_flights.lock().unwrap_or_else(|e| e.into_inner());
             let keys = flights
                 .iter()
                 .filter(|(_, flight)| flight.scope == scope)
@@ -210,9 +194,6 @@ impl Cache {
             .proactive_scheduled_keys
             .lock()
             .unwrap_or_else(|e| e.into_inner());
-        // Each scheduled key owns a sleeping Tokio task plus refresh context.
-        // Bound the pending set independently from the cache entry count so a
-        // large cache with long TTLs cannot turn into thousands of resident tasks.
         let pending_limit = settings
             .proactive_refresh_max_inflight
             .saturating_mul(64)
@@ -250,12 +231,7 @@ impl Cache {
             }
             if self
                 .proactive_inflight
-                .compare_exchange_weak(
-                    current,
-                    current + 1,
-                    Ordering::AcqRel,
-                    Ordering::Relaxed,
-                )
+                .compare_exchange_weak(current, current + 1, Ordering::AcqRel, Ordering::Relaxed)
                 .is_ok()
             {
                 self.counters