Enum CacheDriver 

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

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.

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 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) -> CacheDriver

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<(), Error>

Formats the value using the given formatter.

impl Default for CacheDriver

fn default() -> CacheDriver

Returns the “default value” for a type.

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

fn deserialize<D>( deserializer: D, ) -> Result<CacheDriver, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for CacheDriver

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

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<CacheDriver, <CacheDriver as FromStr>::Err>

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

impl Hash for CacheDriver

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

where __H: Hasher,

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: &CacheDriver) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Serialize for CacheDriver

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::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 [CacheDriver]

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