next_rust_server/
session.rs1use 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
26pub 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#[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#[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 pub fn regenerate(&self) {
105 let mut s = self.lock();
106 s.regenerate = true;
107 s.dirty = true;
108 }
109
110 pub fn destroy(&self) {
112 self.lock().destroyed = true;
113 }
114}
115
116pub 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}