Enum UnifiedCache 

pub enum UnifiedCache {
    Availability(AvailabilityIndex),
    Memory(ArticleCache),
    Hybrid(HybridArticleCache),
}

Unified cache that can be availability-only, memory-only (moka), or hybrid (foyer)

This enum provides a common interface for all cache implementations, allowing the proxy to switch between availability-only, memory, and disk-backed caching based on configuration.

Variants

Availability(AvailabilityIndex)

Availability-only negative index with exact key matches.

Memory(ArticleCache)

Memory-only cache using moka

Hybrid(HybridArticleCache)

Hybrid memory+disk cache using foyer

Implementations

impl UnifiedCache

pub fn availability(ttl: Duration) -> Self

Create an availability-only negative index.

pub fn memory(capacity: u64, ttl: Duration) -> Self

Create a memory-only cache

pub async fn hybrid(config: HybridCacheConfig) -> Result<Self>

Create a hybrid cache (async because foyer needs async initialization)

pub const fn records_backend_has_status(&self) -> bool

Returns true when successful backend responses update positive availability metadata.

pub const fn stores_payload_responses(&self) -> bool

Returns true when this cache stores response payloads.

pub async fn get(&self, message_id: &MessageId<'_>) -> Option<CachedArticle>

Get an article from the cache

pub async fn get_request_message_id( &self, message_id: &str, ) -> Option<CachedArticle>

Get an article from a validated request message-id string (<...>).

Memory and hybrid cache hits avoid rebuilding a MessageId by looking up the stripped cache key directly.

pub async fn upsert_ingest( &self, message_id: MessageId<'_>, buffer: impl Into<CacheIngestResponse>, backend: BackendId, tier: CacheTier, )

Store a successful article response for an eligible backend.

pub async fn record_backend_missing( &self, message_id: MessageId<'_>, backend_id: BackendId, )

Record that a backend returned 430 for this article

pub async fn record_backend_has_status( &self, message_id: MessageId<'_>, status_code: StatusCode, backend: BackendId, tier: CacheTier, )

Record that a backend has an article with a known status, without storing payload bytes.

pub fn load_from_disk(&self, path: &Path) -> Result<bool>

Load persisted availability state if this is an availability-only cache.

pub fn save_to_disk(&self, path: &Path) -> Result<bool>

Save persisted availability state if this is an availability-only cache.

pub fn capacity(&self) -> u64

Get cache capacity

pub fn entry_count(&self) -> u64

Get number of cached entries

pub fn weighted_size(&self) -> u64

Get weighted size in bytes

pub fn hit_rate(&self) -> f64

Get cache hit rate

pub const fn is_hybrid(&self) -> bool

Check if this is a hybrid cache (has disk tier)

pub const fn is_availability_only(&self) -> bool

Check if this cache is the dedicated availability-only index.

pub async fn sync(&self)

Run pending background tasks (for testing)

Ensures all async maintenance tasks complete for deterministic testing.

pub async fn close(&self) -> Result<()>

Close the cache and flush all pending writes

For hybrid cache, this ensures all enqueued disk writes complete before returning. For memory cache, this is a no-op (no persistent state).

Trait Implementations

impl CacheStatsProvider for UnifiedCache

fn display_stats(&self) -> CacheDisplayStats

Get statistics for TUI display

impl Debug for UnifiedCache

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.