v0.34.0_2

src/cache/invalidation/invalidate.rs

@@ -1,17 +1,24 @@
 impl Cache {
     fn active_bans(&self) -> Vec<BanRule> {
+        if self.ban_rule_count.load(Ordering::Acquire) == 0 {
+            return Vec::new();
+        }
         let now = SystemTime::now();
         let mut bans = self.bans.lock().unwrap_or_else(|e| e.into_inner());
         bans.retain(|rule| !rule.expired(now));
+        self.ban_rule_count.store(bans.len() as u64, Ordering::Release);
         bans.clone()
     }
 
     fn hot_entry_banned(&self, key: &Key, entry: &Entry) -> bool {
+        if self.ban_rule_count.load(Ordering::Acquire) == 0 {
+            return false;
+        }
         let now = SystemTime::now();
-        let banned = self
-            .active_bans()
-            .iter()
-            .any(|rule| rule.matches_hot(key, entry, now));
+        let mut bans = self.bans.lock().unwrap_or_else(|e| e.into_inner());
+        bans.retain(|rule| !rule.expired(now));
+        self.ban_rule_count.store(bans.len() as u64, Ordering::Release);
+        let banned = bans.iter().any(|rule| rule.matches_hot(key, entry, now));
         if banned {
             self.counters.ban_matches.fetch_add(1, Ordering::Relaxed);
         }
@@ -19,11 +26,14 @@ impl Cache {
     }
 
     fn cold_entry_banned(&self, key: &Key, entry: &ColdEntry) -> bool {
+        if self.ban_rule_count.load(Ordering::Acquire) == 0 {
+            return false;
+        }
         let now = SystemTime::now();
-        let banned = self
-            .active_bans()
-            .iter()
-            .any(|rule| rule.matches_cold(key, entry, now));
+        let mut bans = self.bans.lock().unwrap_or_else(|e| e.into_inner());
+        bans.retain(|rule| !rule.expired(now));
+        self.ban_rule_count.store(bans.len() as u64, Ordering::Release);
+        let banned = bans.iter().any(|rule| rule.matches_cold(key, entry, now));
         if banned {
             self.counters.ban_matches.fetch_add(1, Ordering::Relaxed);
         }
@@ -31,10 +41,14 @@ impl Cache {
     }
 
     fn entry_banned_before_insert(&self, key: &Key, entry: &Entry) -> bool {
+        if self.ban_rule_count.load(Ordering::Acquire) == 0 {
+            return false;
+        }
         let now = SystemTime::now();
-        self.active_bans()
-            .iter()
-            .any(|rule| rule.matches_hot(key, entry, now))
+        let mut bans = self.bans.lock().unwrap_or_else(|e| e.into_inner());
+        bans.retain(|rule| !rule.expired(now));
+        self.ban_rule_count.store(bans.len() as u64, Ordering::Release);
+        bans.iter().any(|rule| rule.matches_hot(key, entry, now))
     }
 
     pub fn bans(&self) -> Vec<BanView> {
@@ -46,6 +60,7 @@ impl Cache {
         let before = bans.len();
         bans.retain(|rule| rule.id != id);
         let removed = bans.len() != before;
+        self.ban_rule_count.store(bans.len() as u64, Ordering::Release);
         if removed {
             self.counters.bans_removed.fetch_add(1, Ordering::Relaxed);
         }
@@ -82,6 +97,7 @@ impl Cache {
                     created_at: now,
                     expires_at: now.checked_add(Duration::from_secs(ttl)).unwrap_or(now),
                 });
+                self.ban_rule_count.store(bans.len() as u64, Ordering::Release);
                 self.counters.bans_created.fetch_add(1, Ordering::Relaxed);
                 Ok(InvalidationResult {
                     operation: request.operation,