Enum SessionDriver 

pub enum SessionDriver {
    Memory,
    Database,
    Cache,
    Cookie,
}

Which SessionStore to build.

use rainier_session::SessionDriver;
use rainier_support::Setting;

assert_eq!(SessionDriver::parse("cookie").unwrap(), SessionDriver::Cookie);
assert!(SessionDriver::parse("redis").is_err(), "sessions go in the cache, not a driver of their own");

Note what is not here: redis. Sessions in Redis are the cache driver pointed at Redis, which is one store to configure rather than two, and one connection pool rather than two.

Variants

Memory

This process only. Sessions vanish on restart and are not shared between instances, so a second instance logs everyone out.

The default because it needs nothing, and wrong for anything with more than one process.

Database

A table in the application’s own database.

Shared, durable, and revocable. Needs the migration — DatabaseSessionStore::migrations() — and something to call prune() periodically.

Cache

Whatever the cache is pointed at: Redis, a Redis Cluster, or Memcached, all behind one port.

The cache expires them itself, so nothing has to sweep.

Cookie

The whole session, encrypted, in the cookie.

No server state at all — and therefore no way to revoke a session short of rotating the key, and a hard size limit. Read the docs before choosing it.

Implementations

impl SessionDriver

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 SessionDriver

pub fn is_durable(&self) -> bool

Whether sessions survive a restart of the process that made them.

pub fn is_revocable(&self) -> bool

Whether the server can end a session it has already issued.

false for Cookie, and that is the property that decides whether it is usable: a logout, a password change and a stolen cookie all need this.

pub fn is_shared(&self) -> bool

Whether every instance of the application sees the same sessions.

Trait Implementations

impl AsRef<str> for SessionDriver

fn as_ref(&self) -> &str

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

impl Clone for SessionDriver

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 SessionDriver

impl Debug for SessionDriver

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

Formats the value using the given formatter.

impl Default for SessionDriver

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SessionDriver

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for SessionDriver

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

Formats the value using the given formatter.

impl Eq for SessionDriver

impl FromStr for SessionDriver

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 SessionDriver

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 SessionDriver

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for SessionDriver

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 SessionDriver

const SETTING: &'static str = "session 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 SessionDriver