Skip to main content

next_rust_server/
session.rs

1//! Server-side sessions.
2//!
3//! Sessions are opt-in. The cookie holds only a random 256-bit identifier;
4//! data lives in a [`SessionStore`], so nothing needs to be signed and no
5//! data is exposed to the client.
6//!
7//! ```ignore
8//! App::new(routes()).middleware(sessions(MemorySessionStore::default()))
9//! // in a page:  pub fn Page(Extension(session): Extension<Session>) -> impl View
10//! ```
11
12use std::collections::{BTreeMap, HashMap};
13use std::sync::{Arc, Mutex};
14use std::time::{Duration, Instant};
15
16use serde::Serialize;
17use serde::de::DeserializeOwned;
18use serde_json::Value;
19
20use crate::Cookie;
21use crate::middleware::{BoxFuture, Middleware, Next};
22use crate::request::Request;
23
24pub const SESSION_COOKIE: &str = "next_rust_session";
25
26/// Session storage backend.
27pub trait SessionStore: Send + Sync + 'static {
28    fn load(&self, id: &str) -> BoxFuture<Option<BTreeMap<String, Value>>>;
29    fn save(&self, id: &str, data: BTreeMap<String, Value>, ttl: Duration) -> BoxFuture<()>;
30    fn destroy(&self, id: &str) -> BoxFuture<()>;
31}
32
33type StoredSession = (BTreeMap<String, Value>, Instant);
34
35/// In-memory store for development and single-instance deployments.
36#[derive(Default, Clone)]
37pub struct MemorySessionStore {
38    inner: Arc<Mutex<HashMap<String, StoredSession>>>,
39}
40
41impl SessionStore for MemorySessionStore {
42    fn load(&self, id: &str) -> BoxFuture<Option<BTreeMap<String, Value>>> {
43        let now = Instant::now();
44        let mut map = self.inner.lock().unwrap_or_else(|e| e.into_inner());
45        let data = match map.get(id) {
46            Some((d, exp)) if *exp > now => Some(d.clone()),
47            Some(_) => {
48                map.remove(id);
49                None
50            }
51            None => None,
52        };
53        Box::pin(async move { data })
54    }
55
56    fn save(&self, id: &str, data: BTreeMap<String, Value>, ttl: Duration) -> BoxFuture<()> {
57        self.inner.lock().unwrap_or_else(|e| e.into_inner()).insert(id.to_owned(), (data, Instant::now() + ttl));
58        Box::pin(async {})
59    }
60
61    fn destroy(&self, id: &str) -> BoxFuture<()> {
62        self.inner.lock().unwrap_or_else(|e| e.into_inner()).remove(id);
63        Box::pin(async {})
64    }
65}
66
67#[derive(Debug, Default)]
68struct SessionState {
69    data: BTreeMap<String, Value>,
70    dirty: bool,
71    destroyed: bool,
72    regenerate: bool,
73}
74
75/// Request-scoped session handle (cheap to clone).
76#[derive(Debug, Clone, Default)]
77pub struct Session {
78    state: Arc<Mutex<SessionState>>,
79}
80
81impl Session {
82    fn lock(&self) -> std::sync::MutexGuard<'_, SessionState> {
83        self.state.lock().unwrap_or_else(|e| e.into_inner())
84    }
85
86    pub fn get<T: DeserializeOwned>(&self, key: &str) -> Option<T> {
87        self.lock().data.get(key).and_then(|v| serde_json::from_value(v.clone()).ok())
88    }
89
90    pub fn insert<T: Serialize>(&self, key: &str, value: T) {
91        if let Ok(v) = serde_json::to_value(value) {
92            let mut s = self.lock();
93            s.data.insert(key.to_owned(), v);
94            s.dirty = true;
95        }
96    }
97
98    pub fn remove(&self, key: &str) {
99        let mut s = self.lock();
100        s.dirty |= s.data.remove(key).is_some();
101    }
102
103    /// Issue a new session id (call after login to prevent fixation).
104    pub fn regenerate(&self) {
105        let mut s = self.lock();
106        s.regenerate = true;
107        s.dirty = true;
108    }
109
110    /// Delete the session and its cookie (logout).
111    pub fn destroy(&self) {
112        self.lock().destroyed = true;
113    }
114}
115
116/// Session middleware.
117pub fn sessions(store: impl SessionStore) -> impl Middleware {
118    sessions_with_ttl(store, Duration::from_secs(60 * 60 * 24 * 7))
119}
120
121pub fn sessions_with_ttl(store: impl SessionStore, ttl: Duration) -> impl Middleware {
122    let store = Arc::new(store);
123    move |mut req: Request, next: Next| {
124        let store = store.clone();
125        async move {
126            let incoming = req
127                .cookies()
128                .get(SESSION_COOKIE)
129                .filter(|id| id.len() == 64 && id.bytes().all(|b| b.is_ascii_hexdigit()));
130            let data = match &incoming {
131                Some(id) => store.load(id).await,
132                None => None,
133            };
134            let exists = data.is_some();
135            let session = Session {
136                state: Arc::new(Mutex::new(SessionState { data: data.unwrap_or_default(), ..Default::default() })),
137            };
138            req.insert_extension(session.clone());
139            let cookies = req.cookies().clone();
140            let res = next.run(req).await;
141            let (data, dirty, destroyed, regenerate) = {
142                let s = session.lock();
143                (s.data.clone(), s.dirty, s.destroyed, s.regenerate)
144            };
145            if destroyed {
146                if let Some(id) = &incoming {
147                    store.destroy(id).await;
148                }
149                cookies.delete(SESSION_COOKIE);
150            } else if dirty || (exists && incoming.is_some()) {
151                let id = match (&incoming, regenerate, exists) {
152                    (Some(id), false, true) => id.clone(),
153                    (old, _, _) => {
154                        if let Some(old) = old {
155                            store.destroy(old).await;
156                        }
157                        crate::random_hex(32)
158                    }
159                };
160                store.save(&id, data, ttl).await;
161                if incoming.as_deref() != Some(id.as_str()) || dirty {
162                    cookies.set(Cookie::new(SESSION_COOKIE, id).max_age(ttl));
163                }
164            }
165            res
166        }
167    }
168}