@lovrozagar/honey 0.1.0

package/src/client-rust/invalidation_sync.rs

@@ -0,0 +1,306 @@
+/* Code generated by honey. DO NOT EDIT. */
+
+#![allow(dead_code)]
+
+/* Sync counterpart of StaleTracker. Uses std::sync::Mutex instead of
+   tokio::sync::Mutex so it can be called from blocking SyncClient paths
+   without requiring an async runtime. Reuses the shared StaleEntry /
+   RequestMeta types + pattern/interpolation helpers from invalidation.rs. */
+
+use crate::invalidation::{
+    path_matches_pattern, resolve_invalidation_targets_for_mutation, RequestMeta, StaleEntry,
+};
+use crate::runtime::InvalidationConfig;
+use std::collections::HashMap;
+use std::sync::Mutex;
+use std::time::{Duration, Instant};
+
+struct TrackerStateSync {
+    entries: HashMap<String, StaleEntry>,
+    order: Vec<String>,
+    seq: u64,
+}
+
+/// StaleTrackerSync is the blocking counterpart of StaleTracker.
+/// All public methods are safe for concurrent blocking use (interior std Mutex).
+pub struct StaleTrackerSync {
+    state: Mutex<TrackerStateSync>,
+    enabled: bool,
+    stale_time: Duration,
+    max_entries: usize,
+    max_sources: usize,
+}
+
+impl StaleTrackerSync {
+    /// new constructs a tracker from an InvalidationConfig.
+    /// Tracker is disabled (cheap no-op) when cfg is None or stale_time ≤ 0.
+    pub fn new(cfg: Option<&InvalidationConfig>) -> Self {
+        let mut enabled = false;
+        let mut stale_time = Duration::from_millis(0);
+        let mut max_entries = 1000usize;
+        let mut max_sources = 16usize;
+        if let Some(c) = cfg {
+            if c.stale_time > 0 {
+                enabled = true;
+                stale_time = Duration::from_millis(c.stale_time as u64);
+                if c.stale_max_entries > 0 {
+                    max_entries = c.stale_max_entries;
+                }
+                if c.max_sources_per_target > 0 {
+                    max_sources = c.max_sources_per_target;
+                }
+            }
+        }
+        StaleTrackerSync {
+            state: Mutex::new(TrackerStateSync {
+                entries: HashMap::new(),
+                order: Vec::new(),
+                seq: 0,
+            }),
+            enabled,
+            stale_time,
+            max_entries,
+            max_sources,
+        }
+    }
+
+    /// enabled reports whether the tracker will record / report stale entries.
+    pub fn enabled(&self) -> bool {
+        self.enabled
+    }
+
+    /// mark_stale bumps seq, expands templated invalidation entries with
+    /// `params`, and records each resolved target as freshly stale.
+    pub fn mark_stale(
+        &self,
+        invalidate: &[String],
+        params: &HashMap<String, String>,
+        mutation_selector: &str,
+    ) {
+        if !self.enabled || invalidate.is_empty() {
+            return;
+        }
+        let mut s = self.state.lock().unwrap();
+        s.seq += 1;
+        let seq = s.seq;
+        let until = Instant::now() + self.stale_time;
+        let resolved = resolve_invalidation_targets_for_mutation(invalidate, params);
+        for target in resolved {
+            upsert_locked(&mut s, &target, until, seq, mutation_selector, self.max_sources);
+        }
+        enforce_capacity_locked(&mut s, self.max_entries);
+    }
+
+    /// lookup_stale returns (invalidated_by, is_stale): exact + pattern lookup
+    /// with expired-key sweep. Disabled tracker → (vec![], false).
+    pub fn lookup_stale(
+        &self,
+        concrete_selector: &str,
+        concrete_path: &str,
+        method: &str,
+        now: Instant,
+    ) -> (Vec<String>, bool) {
+        if !self.enabled {
+            return (Vec::new(), false);
+        }
+        let mut s = self.state.lock().unwrap();
+        lookup_locked(&mut s, concrete_selector, concrete_path, method, now)
+    }
+
+    /// clear_stale drops stale entries whose seq ≤ seq_snapshot and which match
+    /// the given concrete_path under method (exact key + pattern keys).
+    pub fn clear_stale(
+        &self,
+        concrete_selector: &str,
+        concrete_path: &str,
+        method: &str,
+        seq_snapshot: u64,
+    ) {
+        if !self.enabled {
+            return;
+        }
+        let mut s = self.state.lock().unwrap();
+        if let Some(entry) = s.entries.get(concrete_selector) {
+            if entry.seq <= seq_snapshot {
+                delete_locked(&mut s, concrete_selector);
+            }
+        }
+        let mut to_delete: Vec<String> = Vec::new();
+        for (key, entry) in s.entries.iter() {
+            if entry.seq > seq_snapshot {
+                continue;
+            }
+            if !key.contains('{') && !key.contains(':') {
+                continue;
+            }
+            let space_idx = match key.find(' ') {
+                Some(i) => i,
+                None => continue,
+            };
+            if &key[..space_idx] != method {
+                continue;
+            }
+            if path_matches_pattern(concrete_path, &key[space_idx + 1..]) {
+                to_delete.push(key.clone());
+            }
+        }
+        for key in to_delete {
+            delete_locked(&mut s, &key);
+        }
+    }
+
+    /// is_stale reports whether (method, path) currently sits inside an active
+    /// stale window. Walks pattern entries too. Disabled tracker → false.
+    pub fn is_stale(&self, method: &str, path: &str) -> bool {
+        if !self.enabled {
+            return false;
+        }
+        let mut s = self.state.lock().unwrap();
+        let selector = format!("{} {}", method, path);
+        let (_, is_stale) = lookup_locked(&mut s, &selector, path, method, Instant::now());
+        is_stale
+    }
+
+    /// build_request_meta returns a RequestMeta snapshot for the request about
+    /// to fire, or None when tracker is disabled.
+    pub fn build_request_meta(
+        &self,
+        concrete_selector: &str,
+        concrete_path: &str,
+        method: &str,
+    ) -> Option<RequestMeta> {
+        if !self.enabled {
+            return None;
+        }
+        let mut s = self.state.lock().unwrap();
+        let (by, is_stale) =
+            lookup_locked(&mut s, concrete_selector, concrete_path, method, Instant::now());
+        Some(RequestMeta {
+            selector: concrete_selector.to_string(),
+            is_stale,
+            invalidated_by: by,
+            seq_snapshot: s.seq,
+        })
+    }
+}
+
+fn upsert_locked(
+    s: &mut TrackerStateSync,
+    key: &str,
+    until: Instant,
+    seq: u64,
+    mutation_selector: &str,
+    max_sources: usize,
+) {
+    if let Some(existing) = s.entries.get_mut(key) {
+        existing.until = until;
+        existing.seq = seq;
+        if !mutation_selector.is_empty() && existing.by.len() < max_sources {
+            let already = existing.by.iter().any(|b| b == mutation_selector);
+            if !already {
+                existing.by.push(mutation_selector.to_string());
+            }
+        }
+        touch_order_locked(s, key);
+        return;
+    }
+    let by = if mutation_selector.is_empty() {
+        Vec::new()
+    } else {
+        vec![mutation_selector.to_string()]
+    };
+    s.entries.insert(key.to_string(), StaleEntry { by, seq, until });
+    s.order.push(key.to_string());
+}
+
+fn touch_order_locked(s: &mut TrackerStateSync, key: &str) {
+    if let Some(idx) = s.order.iter().position(|k| k == key) {
+        s.order.remove(idx);
+    }
+    s.order.push(key.to_string());
+}
+
+fn delete_locked(s: &mut TrackerStateSync, key: &str) {
+    if s.entries.remove(key).is_none() {
+        return;
+    }
+    if let Some(idx) = s.order.iter().position(|k| k == key) {
+        s.order.remove(idx);
+    }
+}
+
+fn lookup_locked(
+    s: &mut TrackerStateSync,
+    concrete_selector: &str,
+    concrete_path: &str,
+    method: &str,
+    now: Instant,
+) -> (Vec<String>, bool) {
+    let mut all_by: Vec<String> = Vec::new();
+    let mut exact_expired = false;
+    if let Some(exact) = s.entries.get(concrete_selector) {
+        if exact.until > now {
+            all_by.extend(exact.by.iter().cloned());
+        } else {
+            exact_expired = true;
+        }
+    }
+    if exact_expired {
+        delete_locked(s, concrete_selector);
+    }
+    let mut expired: Vec<String> = Vec::new();
+    for (key, entry) in s.entries.iter() {
+        if entry.until <= now {
+            expired.push(key.clone());
+            continue;
+        }
+        if key == concrete_selector {
+            continue;
+        }
+        if !key.contains('{') && !key.contains(':') {
+            continue;
+        }
+        let space_idx = match key.find(' ') {
+            Some(i) => i,
+            None => continue,
+        };
+        if &key[..space_idx] != method {
+            continue;
+        }
+        if path_matches_pattern(concrete_path, &key[space_idx + 1..]) {
+            all_by.extend(entry.by.iter().cloned());
+        }
+    }
+    for key in expired {
+        delete_locked(s, &key);
+    }
+    let mut deduped: Vec<String> = Vec::with_capacity(all_by.len());
+    for src in all_by {
+        if !deduped.iter().any(|d| d == &src) {
+            deduped.push(src);
+        }
+    }
+    let any = !deduped.is_empty();
+    (deduped, any)
+}
+
+fn enforce_capacity_locked(s: &mut TrackerStateSync, max_entries: usize) {
+    if s.entries.len() <= max_entries {
+        return;
+    }
+    let now = Instant::now();
+    let expired: Vec<String> = s
+        .entries
+        .iter()
+        .filter(|(_, e)| e.until <= now)
+        .map(|(k, _)| k.clone())
+        .collect();
+    for key in expired {
+        delete_locked(s, &key);
+    }
+    let target = if max_entries / 2 < 1 { 1 } else { max_entries / 2 };
+    while s.entries.len() > target && !s.order.is_empty() {
+        let oldest = s.order[0].clone();
+        delete_locked(s, &oldest);
+    }
+}