Enum CacheDriver 

pub enum CacheDriver {
    Memory,
    Redis,
    RedisCluster,
    Memcached,
    DynamoDb,
    Kv,
}

Where cached values live.

The enum names every store this crate knows how to build, whether or not the cargo feature behind it is on. That is deliberate: CACHE_DRIVER=redis in a build without the redis-driver feature is a build mistake, and it deserves a message saying so — not the same “unknown driver” message a typo gets.

use rainier_cache::CacheDriver;
use rainier_support::Setting;

assert_eq!(CacheDriver::parse("redis-cluster").unwrap(), CacheDriver::RedisCluster);
assert!(CacheDriver::parse("redys").is_err());

Variants

Memory

This process only. Fast, and shares nothing between instances.

The default because it needs no server, and the right choice for tests and single-process development. Anything cached for correctness rather than for speed is wrong in it — a rate-limit counter becomes N × its limit across N instances, and a lock is not a lock.

Redis

One Redis server, or a Sentinel-fronted primary.

RedisCluster

A sharded Redis Cluster. Keys distribute across the seed nodes.

Memcached

Memcached over its text protocol.

DynamoDb

DynamoDB, with TTL doing the expiry. No server to run.

Kv

Cloudflare Workers KV — the edge key-value store.

Read-heavy and eventually consistent. A write reaches other edges in roughly a minute, and there is no compare-and-set at all, so it cannot hold a lock or count anything that has to be exact. Right for a configuration blob or a feature-flag set; wrong for a session, a rate limit or on_one_server.

See KvCache, which says the same thing at more length and is worth reading before choosing this.

Implementations

impl CacheDriver

pub fn as_str(&self) -> &'static str

The wire spelling — what appears in .env and in the config tree.

Inherent as well as on the trait, so callers do not have to import Setting to print one.

impl CacheDriver

pub fn is_shared(&self) -> bool

Whether this driver is shared between instances of the application.

The question a production checklist is really asking. A rate limiter, a lock, or a cached authorisation decision needs true here; a memoised computation does not.

pub fn can_hold_a_lock(&self) -> bool

Whether this driver can hold a lock.

Shared and lock-capable are different questions, and Workers KV is the reason: it is visible to every replica on earth and has no compare-and-set, so two callers both win the add a lock is built from and both believe they hold it.

The check that matters is LockManager::is_shared, which asks the built store rather than the configured name; this answers the same question about a driver nobody has built yet, for a boot-time configuration check.

pub fn feature(&self) -> Option<&'static str>

The cargo feature that has to be on for this driver to be built.

None for the ones that are always available.

Trait Implementations

impl AsRef<str> for CacheDriver

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for CacheDriver

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for CacheDriver

impl Debug for CacheDriver

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

Formats the value using the given formatter.

impl Default for CacheDriver

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CacheDriver

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for CacheDriver

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

Formats the value using the given formatter.

impl Eq for CacheDriver

impl FromStr for CacheDriver

type Err = Error

The associated error which can be returned from parsing.

fn from_str(raw: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for CacheDriver

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CacheDriver

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for CacheDriver

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Setting for CacheDriver

const SETTING: &'static str = "cache driver"

What this setting is called in an error message — "cache driver".

const ALL: &'static [Self]

Every variant, in the order they should be listed to a human.

fn as_str(&self) -> &'static str

The wire spelling — what appears in .env, in the config tree, and in serialised output.

fn parse(raw: &str) -> Result<Self, Error>

Parse a wire spelling.

fn options() -> String

The valid spellings, backtick-quoted and comma-separated.

impl StructuralPartialEq for CacheDriver