Struct MemoryStore

Source

pub struct MemoryStore { /* private fields */ }

Expand description

§in-memory session store

Because there is no external persistance, this session store is ephemeral and will be cleared on server restart.

§DO NOT USE THIS IN A PRODUCTION DEPLOYMENT.

Implementations§

Source §

impl MemoryStore

Source

pub fn new() -> MemoryStore

Create a new instance of MemoryStore

Examples found in repository ?

examples/simple.rs (line 6)

5async fn main() {
6    let session_store = MemoryStore::new();
7
8    let route = warp::get()
9        .and(warp::path!("test"))
10        .and(warp_sessions::request::with_session(session_store, None))
11        .and_then(
12            move |session_with_store: SessionWithStore<MemoryStore>| async move {
13                Ok::<_, Rejection>((
14                    warp::reply::html("<html></html>".to_string()),
15                    session_with_store,
16                ))
17            },
18        )
19        .untuple_one()
20        .and_then(warp_sessions::reply::with_session);
21
22    // Start the server
23    let port = 8080;
24    println!("starting server listening on ::{}", port);
25    warp::serve(route).run(([0, 0, 0, 0], port)).await;
26}

More examples

Hide additional examples

examples/cookie_options.rs (line 6)

5async fn main() {
6    let session_store = MemoryStore::new();
7
8    let route = warp::get()
9        .and(warp::path!("test"))
10        .and(warp_sessions::request::with_session(
11            session_store,
12            Some(CookieOptions {
13                cookie_name: "sid",
14                cookie_value: None,
15                max_age: Some(600),
16                domain: Some("domain.com".to_string()),
17                path: Some("/test".to_string()),
18                secure: true,
19                http_only: true,
20                same_site: Some(SameSiteCookieOption::Strict),
21            }),
22        ))
23        .and_then(
24            move |session_with_store: SessionWithStore<MemoryStore>| async move {
25                Ok::<_, Rejection>((
26                    warp::reply::html("<html></html>".to_string()),
27                    session_with_store,
28                ))
29            },
30        )
31        .untuple_one()
32        .and_then(warp_sessions::reply::with_session);
33
34    // Start the server
35    let port = 8080;
36    println!("starting server listening on ::{}", port);
37    warp::serve(route).run(([0, 0, 0, 0], port)).await;
38}

examples/shared_mutable_session.rs (line 12)

11async fn main() {
12    let session_store = MemoryStore::new();
13
14    let route = warp::get()
15        .and(warp::path!("test"))
16        .and(warp_sessions::request::with_session(session_store, None))
17        .and_then(
18            move |mut session_with_store: SessionWithStore<MemoryStore>| async move {
19                let shared_session = Arc::new(RwLock::new(session_with_store.session));
20                shared_session
21                    .write()
22                    .unwrap()
23                    .insert("key", "value")
24                    .unwrap();
25                session_with_store.session = Arc::try_unwrap(shared_session)
26                    .unwrap()
27                    .into_inner()
28                    .unwrap();
29
30                Ok::<_, Rejection>((
31                    warp::reply::html("<html></html>".to_string()),
32                    session_with_store,
33                ))
34            },
35        )
36        .untuple_one()
37        .and_then(warp_sessions::reply::with_session);
38
39    // Start the server
40    let port = 8080;
41    println!("starting server listening on ::{}", port);
42    warp::serve(route).run(([0, 0, 0, 0], port)).await;
43}

examples/multiple_routes.rs (line 6)

5async fn main() {
6    let session_store = MemoryStore::new();
7
8    let route_get = warp::get()
9        .and(warp::path!("test"))
10        .and(warp_sessions::request::with_session(
11            session_store.clone(),
12            None,
13        ))
14        .and_then(
15            move |session_with_store: SessionWithStore<MemoryStore>| async move {
16                Ok::<_, Rejection>((
17                    warp::reply::html("<html></html>".to_string()),
18                    session_with_store,
19                ))
20            },
21        )
22        .untuple_one()
23        .and_then(warp_sessions::reply::with_session);
24
25    let route_post = warp::post()
26        .and(warp::path!("test"))
27        .and(warp_sessions::request::with_session(
28            session_store.clone(),
29            None,
30        ))
31        .and_then(
32            move |session_with_store: SessionWithStore<MemoryStore>| async move {
33                Ok::<_, Rejection>((
34                    warp::reply::html("<html></html>".to_string()),
35                    session_with_store,
36                ))
37            },
38        )
39        .untuple_one()
40        .and_then(warp_sessions::reply::with_session);
41
42    // Start the server
43    let port = 8080;
44    println!("starting server listening on ::{}", port);
45    warp::serve(route_get.or(route_post))
46        .run(([0, 0, 0, 0], port))
47        .await;
48}

Source

pub async fn cleanup(&self) -> Result<(), Error>

Performs session cleanup. This should be run on an intermittent basis if this store is run for long enough that memory accumulation is a concern

Source

pub async fn count(&self) -> usize

returns the number of elements in the memory store

§Example

let mut store = MemoryStore::new();
assert_eq!(store.count().await, 0);
store.store_session(Session::new()).await?;
assert_eq!(store.count().await, 1);