Struct CacheSessionStore 

pub struct CacheSessionStore { /* private fields */ }

Sessions in a cache.

The usual production choice, because it gets the two things a session needs from infrastructure you already have: shared between instances, so a load balancer can send a user anywhere, and expiring by itself, so nothing has to sweep old rows.

Works over any Cache — including a sharded Redis Cluster (rainier_cache::RedisCache), where each session lands on the node that owns its slot. Every operation here touches exactly one key, which is what makes that safe.

use rainier_cache::MemoryCache;
use rainier_session::CacheSessionStore;
use std::sync::Arc;

let store = CacheSessionStore::new(Arc::new(MemoryCache::new()));

A cache can evict

This is the trade against a database store. A cache under memory pressure evicts whatever it likes, and an evicted session logs somebody out mid-checkout.

For Redis, maxmemory-policy volatile-lru at least confines eviction to keys with a TTL; allkeys-lru will take sessions ahead of things you would rather lose. If being logged out is genuinely unacceptable, the database store is the one that does not evict.

Implementations

impl CacheSessionStore

pub fn new(cache: Arc<dyn Cache>) -> Self

A store over cache, with two-hour sessions.

pub fn with_lifetime(self, lifetime: ChronoDuration) -> Self

Sessions expiring after lifetime.

pub fn cache(&self) -> &Arc<dyn Cache>

The cache underneath, for sharing it.

pub fn lifetime(&self) -> Duration

How long a session lives without being touched.

Trait Implementations

impl Debug for CacheSessionStore

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

Formats the value using the given formatter.

impl SessionStore for CacheSessionStore

fn gc(&self) -> BoxFuture<'_, Result<u64>>

Nothing to do: the cache expires its own keys.

Returns zero rather than pretending, and deliberately does not delegate to Cache::flush — that would empty the whole cache, which is not what “collect expired sessions” means.

fn name(&self) -> &str

A label for diagnostics — "memory", "database", "cache", "cookie".

fn read<'a>(&'a self, id: &'a str) -> BoxFuture<'a, Result<Option<SessionData>>>

The data for this id, or None if it is unknown or expired.

fn write<'a>( &'a self, id: &'a str, data: &'a SessionData, ) -> BoxFuture<'a, Result<()>>

Write the data back, refreshing its expiry.

fn destroy<'a>(&'a self, id: &'a str) -> BoxFuture<'a, Result<()>>

Remove a session.

fn is_client_side(&self) -> bool

Whether the session travels in the cookie rather than being stored here.

fn encode(&self, id: &str, data: &SessionData) -> Result<String>

The cookie value carrying this session.

fn decode(&self, value: &str) -> Result<(String, Option<SessionData>)>

Recover a session id — and, for a client-side store, its data — from a cookie value.