Struct actori_redis::RedisSession

pub struct RedisSession(_);

Use redis as session storage.

You need to pass an address of the redis server and random value to the constructor of RedisSessionBackend. This is private key for cookie session, When this value is changed, all session data is lost.

Constructor panics if key length is less than 32 bytes.

Methods

impl RedisSession

pub fn new<S: Into<String>>(addr: S, key: &[u8]) -> RedisSession

Create new redis session backend

• addr - address of the redis server

pub fn ttl(self, ttl: u16) -> Self

Set time to live in seconds for session value

pub fn cookie_name(self, name: &str) -> Self

Set custom cookie name for session id

pub fn cookie_path(self, path: &str) -> Self

Set custom cookie path

pub fn cookie_domain(self, domain: &str) -> Self

Set custom cookie domain

pub fn cookie_secure(self, secure: bool) -> Self

Set custom cookie secure If the secure field is set, a cookie will only be transmitted when the connection is secure - i.e. https

pub fn cookie_max_age(self, max_age: Duration) -> Self

Set custom cookie max-age

pub fn cookie_same_site(self, same_site: SameSite) -> Self

Set custom cookie SameSite

pub fn cache_keygen(self, keygen: Box<dyn Fn(&str) -> String>) -> Self

Set a custom cache key generation strategy, expecting session key as input

Trait Implementations

impl<S, B> Transform<S> for RedisSession where
    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static,
    S::Future: 'static,
    B: 'static, 

type Request = ServiceRequest

Requests handled by the service.

type Response = ServiceResponse<B>

Responses given by the service.

type Error = S::Error

Errors produced by the service.

type InitError = ()

Errors produced while building a transform service.

type Transform = RedisSessionMiddleware<S>

The TransformService value created by this factory

type Future = Ready<Result<Self::Transform, Self::InitError>>

The future response value.

fn new_transform(&self, service: S) -> Self::Future

Creates and returns a new Transform component, asynchronously

fn map_init_err<F, E>(self, f: F) -> TransformMapInitErr<Self, S, F, E> where
    F: Fn(Self::InitError) -> E + Clone, 

Map this transforms's factory error to a different error, returning a new transform service factory.