Struct actix_session::Session

pub struct Session(_);

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

Session object is obtained with UserSession::get_session. The UserSession trait is implemented for HttpRequest, ServiceRequest, and RequestHead.

use actix_session::Session;
use actix_web::Result;

async 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!")
}

Implementations

impl Session

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

Get a value from the session.

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

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 IntoIterator<Item = (String, String)>,
    req: &mut ServiceRequest
)

Adds the given key-value pairs to the session on the request.

Values that match keys already existing on the session will be overwritten. Values should already be JSON serialized.

Examples

let mut req = test::TestRequest::default().to_srv_request();

Session::set_session(
    vec![("counter".to_string(), serde_json::to_string(&0).unwrap())],
    &mut req,
);

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 = Ready<Result<Session, Error>>

Future that resolves to a Self.

type Config = ()

Configuration for this extractor.

fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future

Create a Self from request parts asynchronously.

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

Create a Self from request head asynchronously.

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

Create and configure config instance.