Struct actix_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 RedisSession. 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.

Implementations

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: u32) -> 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.

Default is false.

pub fn cookie_max_age(self, max_age: impl Into<Option<Duration>>) -> Self

Set custom cookie max-age.

Use None for session-only cookies.

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

Set custom cookie SameSite attribute.

By default, the attribute is omitted.

pub fn cookie_http_only(self, http_only: bool) -> Self

Set custom cookie HttpOnly policy.

Default is true.

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, ServiceRequest> for RedisSession where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static,
    S::Future: 'static,
    B: 'static, 

type Response = ServiceResponse<B>

Responses produced by the service.

type Error = S::Error

Errors produced by the service.

type Transform = RedisSessionMiddleware<S>

The TransformService value created by this factory

type InitError = ()

Errors produced while building a transform service.

type Future = LocalBoxFuture<'static, 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