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.insert("counter", count + 1)?;
    } else {
        session.insert("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 entries(&self) -> Ref<'_, HashMap<String, String>>

Get all raw key-value data from the session.

Note that values are JSON encoded.

pub fn insert(
    &self,
    key: impl Into<String>,
    value: impl Serialize
) -> Result<(), Error>

Inserts a key-value pair into the session.

Any serializable value can be used and will be encoded as JSON in session data, hence why only a reference to the value is taken.

pub fn remove(&self, key: &str) -> Option<String>

Remove value from the session.

If present, the JSON encoded value is returned.

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

Remove value from the session and deserialize.

Returns None if key was not present in session. Returns T if deserialization succeeds, otherwise returns un-deserialized JSON string.

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

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(
    &mut req,
    vec![("counter".to_string(), serde_json::to_string(&0).unwrap())],
);

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

Returns session status and iterator of key-value pairs of changes.

Trait Implementations

impl FromRequest for Session

Extractor implementation for Session type.

Examples

use actix_session::Session;

#[get("/")]
async fn index(session: Session) -> Result<impl Responder> {
    // access session data
    if let Some(count) = session.get::<i32>("counter")? {
        session.insert("counter", count + 1)?;
    } else {
        session.insert("counter", 1)?;
    }

    let count = session.get::<i32>("counter")?.unwrap();
    Ok(format!("Counter: {}", count))
}

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.