Struct actix_sled_session::Session

pub struct Session(_);

The high-level interface you use to modify session data.

Session object could be obtained with RequestSession::session method. RequestSession trait is implemented for HttpRequest.

use actix_session::Session;
use actix_web::*;

fn index(session: Session) -> Result<&'static str> {
    // access session data
    if let Some(count) = session.get::<i32>("counter")? {
        session.set("counter", count + 1)?;
    } else {
        session.set("counter", 1)?;
    }

    Ok("Welcome!")
}

Methods

impl Session

pub fn get<T>(&self, key: &str) -> Result<Option<T>, Error> where
    T: DeserializeOwned, 

Get a value from the session.

pub fn set<T>(&self, key: &str, value: T) -> Result<(), Error> where
    T: Serialize, 

Set a value from the session.

pub fn remove(&self, key: &str)

Remove value from the session.

pub fn clear(&self)

Clear the session.

pub fn purge(&self)

Removes session, both client and server side.

pub fn renew(&self)

Renews the session key, assigning existing session state to new key.

pub fn set_session(
    data: impl Iterator<Item = (String, String)>,
    req: &mut ServiceRequest
)

pub fn get_changes<B>(
    res: &mut ServiceResponse<B>
) -> (SessionStatus, Option<impl Iterator<Item = (String, String)>>)

Trait Implementations

impl FromRequest for Session

Extractor implementation for Session type.

use actix_session::Session;

fn index(session: Session) -> Result<&'static str> {
    // access session data
    if let Some(count) = session.get::<i32>("counter")? {
        session.set("counter", count + 1)?;
    } else {
        session.set("counter", 1)?;
    }

    Ok("Welcome!")
}

type Error = Error

The associated error which can be returned.

type Future = Result<Session, Error>

Future that resolves to a Self

type Config = ()

Configuration for this extractor

fn from_request(
    req: &HttpRequest,
    &mut Payload<Box<dyn Stream<Item = Bytes, Error = PayloadError> + 'static>>
) -> <Session as FromRequest>::Future

Convert request to a Self

fn extract(req: &HttpRequest) -> Self::Future

Convert request to a Self

fn configure<F>(f: F) -> Self::Config where
    F: FnOnce(Self::Config) -> Self::Config, 

Create and configure config instance.