Crate cachet_tier 

Core cache tier abstractions for building cache backends.

This crate defines the CacheTier trait that all cache implementations must satisfy, along with CacheEntry for storing values with metadata and Error types for fallible operations.

Overview

The cache tier abstraction separates storage concerns from caching features. Implement CacheTier for your storage backend, then use cachet to add telemetry, TTL, multi-tier fallback, and other features on top.

Implementing a Cache Tier

Implement all required methods of CacheTier:

use std::collections::HashMap;
use std::sync::RwLock;

use cachet_tier::{CacheEntry, CacheTier, Error};

struct SimpleCache<K, V>(RwLock<HashMap<K, CacheEntry<V>>>);

impl<K, V> CacheTier<K, V> for SimpleCache<K, V>
where
    K: Clone + Eq + std::hash::Hash + Send + Sync,
    V: Clone + Send + Sync,
{
    async fn get(&self, key: &K) -> Result<Option<CacheEntry<V>>, Error> {
        Ok(self.0.read().unwrap().get(key).cloned())
    }

    async fn insert(&self, key: K, entry: CacheEntry<V>) -> Result<(), Error> {
        self.0.write().unwrap().insert(key.clone(), entry);
        Ok(())
    }

    async fn invalidate(&self, key: &K) -> Result<(), Error> {
        self.0.write().unwrap().remove(key);
        Ok(())
    }

    async fn clear(&self) -> Result<(), Error> {
        self.0.write().unwrap().clear();
        Ok(())
    }
}

Dynamic Dispatch

DynamicCache wraps any CacheTier in a type-erased container. This is useful for multi-tier caches with heterogeneous storage backends.

Structs

CacheEntry

A cached value with associated metadata.

DynamicCache

A cloneable dynamic cache tier with type erasure.

Error

An error from a cache operation.

MockCachetest-util

A configurable mock cache for testing.

SizeError

An error from a CacheTier::len operation.

Enums

CacheOptest-util

Recorded cache operation with full context.

SizeErrorKind

The kind of error returned by CacheTier::len.

Traits

CacheTier

Trait for cache tier implementations.

Type Aliases

Result

A specialized Result type for cache operations.