1use std::{cell::RefCell, convert::Infallible, rc::Rc};
35
36use ntex::http::{Payload, RequestHead};
37use ntex::util::{Extensions, HashMap};
38use ntex::web::{FromRequest, HttpRequest, WebRequest, WebResponse};
39use serde::Serialize;
40use serde::de::DeserializeOwned;
41use serde_json::error::Error as JsonError;
42
43#[cfg(feature = "cookie-session")]
44mod cookie;
45#[cfg(feature = "cookie-session")]
46pub use crate::cookie::{CookieSession, CookieSessionError, CookieSessionMiddleware};
47
48pub struct Session(Rc<RefCell<SessionInner>>);
77
78pub trait UserSession {
80 fn get_session(&self) -> Session;
82}
83
84impl UserSession for HttpRequest {
85 fn get_session(&self) -> Session {
86 Session::get_session(&mut self.extensions_mut())
87 }
88}
89
90impl<St> UserSession for WebRequest<St> {
91 fn get_session(&self) -> Session {
92 Session::get_session(&mut self.extensions_mut())
93 }
94}
95
96impl UserSession for RequestHead {
97 fn get_session(&self) -> Session {
98 Session::get_session(&mut self.extensions_mut())
99 }
100}
101
102#[derive(PartialEq, Clone, Debug, Default)]
107pub enum SessionStatus {
108 Changed,
111 Purged,
113 Renewed,
116 #[default]
118 Unchanged,
119}
120
121#[derive(Default)]
122struct SessionInner {
123 state: HashMap<String, String>,
124 pub status: SessionStatus,
125}
126
127impl Session {
128 pub fn get<T: DeserializeOwned>(&self, key: &str) -> Result<Option<T>, JsonError> {
136 if let Some(s) = self.0.borrow().state.get(key) {
137 Ok(Some(serde_json::from_str(s)?))
138 } else {
139 Ok(None)
140 }
141 }
142
143 pub fn set<T: Serialize>(&self, key: &str, value: T) -> Result<(), JsonError> {
153 let mut inner = self.0.borrow_mut();
154 if inner.status != SessionStatus::Purged {
155 inner.status = SessionStatus::Changed;
156 inner
157 .state
158 .insert(key.to_owned(), serde_json::to_string(&value)?);
159 }
160 Ok(())
161 }
162
163 pub fn remove(&self, key: &str) {
167 let mut inner = self.0.borrow_mut();
168 if inner.status != SessionStatus::Purged {
169 inner.status = SessionStatus::Changed;
170 inner.state.remove(key);
171 }
172 }
173
174 pub fn clear(&self) {
178 let mut inner = self.0.borrow_mut();
179 if inner.status != SessionStatus::Purged {
180 inner.status = SessionStatus::Changed;
181 inner.state.clear()
182 }
183 }
184
185 pub fn purge(&self) {
191 let mut inner = self.0.borrow_mut();
192 inner.status = SessionStatus::Purged;
193 inner.state.clear();
194 }
195
196 pub fn renew(&self) {
202 let mut inner = self.0.borrow_mut();
203 if inner.status != SessionStatus::Purged {
204 inner.status = SessionStatus::Renewed;
205 }
206 }
207
208 pub fn set_session<St>(data: impl Iterator<Item = (String, String)>, req: &WebRequest<St>) {
215 let session = Session::get_session(&mut req.extensions_mut());
216 let mut inner = session.0.borrow_mut();
217 inner.state.extend(data);
218 }
219
220 pub fn get_changes(
227 res: &mut WebResponse,
228 ) -> (
229 SessionStatus,
230 Option<impl Iterator<Item = (String, String)> + use<>>,
231 ) {
232 if let Some(s_impl) = res
233 .request()
234 .extensions()
235 .get::<Rc<RefCell<SessionInner>>>()
236 {
237 let state = std::mem::take(&mut s_impl.borrow_mut().state);
238 (s_impl.borrow().status.clone(), Some(state.into_iter()))
239 } else {
240 (SessionStatus::Unchanged, None)
241 }
242 }
243
244 fn get_session(extensions: &mut Extensions) -> Session {
245 if let Some(s_impl) = extensions.get::<Rc<RefCell<SessionInner>>>() {
246 return Session(Rc::clone(s_impl));
247 }
248 let inner = Rc::new(RefCell::new(SessionInner::default()));
249 extensions.insert(inner.clone());
250 Session(inner)
251 }
252}
253
254impl<St> FromRequest<St> for Session {
273 type Error = Infallible;
274
275 #[inline]
276 async fn from_request(
277 _: &St,
278 req: &HttpRequest,
279 _: &mut Payload,
280 ) -> Result<Session, Infallible> {
281 Ok(Session::get_session(&mut req.extensions_mut()))
282 }
283}
284
285#[cfg(test)]
286mod tests {
287 use ntex::web::{HttpResponse, test};
288
289 use super::*;
290
291 #[test]
292 fn session() {
293 let req = test::TestRequest::default().to_srv_request();
294
295 Session::set_session(
296 vec![("key".to_string(), "\"value\"".to_string())].into_iter(),
297 &req,
298 );
299 let session = Session::get_session(&mut req.extensions_mut());
300 let res = session.get::<String>("key").unwrap();
301 assert_eq!(res, Some("value".to_string()));
302
303 session.set("key2", "value2".to_string()).unwrap();
304 session.remove("key");
305
306 let mut res = req.into_response(HttpResponse::Ok().build());
307 let (_status, state) = Session::get_changes(&mut res);
308 let changes: Vec<_> = state.unwrap().collect();
309 assert_eq!(changes, [("key2".to_string(), "\"value2\"".to_string())]);
310 }
311
312 #[test]
313 fn get_session() {
314 let req = test::TestRequest::default().to_srv_request();
315
316 Session::set_session(
317 vec![("key".to_string(), "\"value\"".to_string())].into_iter(),
318 &req,
319 );
320
321 let session = req.get_session();
322 let res = session.get::<String>("key").unwrap();
323 assert_eq!(res, Some("value".to_string()));
324 }
325
326 #[test]
327 fn get_session_from_request_head() {
328 let mut req = test::TestRequest::default().to_srv_request();
329
330 Session::set_session(
331 vec![("key".to_string(), "\"value\"".to_string())].into_iter(),
332 &req,
333 );
334
335 let session = req.head_mut().get_session();
336 let res = session.get::<String>("key").unwrap();
337 assert_eq!(res, Some("value".to_string()));
338 }
339
340 #[test]
346 fn purge_session() {
347 let req = test::TestRequest::default().to_srv_request();
348 let session = req.get_session();
349 session.set("key", "value").unwrap();
350 session.purge();
351 session.set("key", "replacement").unwrap();
352 session.remove("key");
353 session.clear();
354 session.renew();
355 assert_eq!(session.get::<String>("key").unwrap(), None);
356
357 let mut res = req.into_response(HttpResponse::Ok().build());
358 let (status, state) = Session::get_changes(&mut res);
359 assert_eq!(status, SessionStatus::Purged);
360 assert_eq!(state.unwrap().count(), 0);
361 }
362
363 #[test]
369 fn renew_session() {
370 let req = test::TestRequest::default().to_srv_request();
371 Session::set_session([("key".to_owned(), "42".to_owned())].into_iter(), &req);
372 req.get_session().renew();
373
374 let mut res = req.into_response(HttpResponse::Ok().build());
375 let (status, state) = Session::get_changes(&mut res);
376 assert_eq!(status, SessionStatus::Renewed);
377 assert_eq!(
378 state.unwrap().collect::<Vec<_>>(),
379 [("key".to_owned(), "42".to_owned())]
380 );
381 }
382
383 #[test]
390 fn shared_session_handles_clear_and_drain_state() {
391 let mut untouched =
392 test::TestRequest::default().to_srv_response(HttpResponse::Ok().build());
393 let (status, state) = Session::get_changes(&mut untouched);
394 assert_eq!(status, SessionStatus::Unchanged);
395 assert!(state.is_none());
396
397 let req = test::TestRequest::default().to_http_request();
398 let first = req.get_session();
399 let second = req.clone().get_session();
400 first.set("first", 1).unwrap();
401 second.set("second", 2).unwrap();
402 assert_eq!(second.get::<u32>("first").unwrap(), Some(1));
403 assert_eq!(first.get::<u32>("second").unwrap(), Some(2));
404 second.clear();
405 assert_eq!(first.get::<u32>("first").unwrap(), None);
406 assert_eq!(first.get::<u32>("second").unwrap(), None);
407 first.set("replacement", 3).unwrap();
408
409 let mut res = WebRequest::from_request(req).into_response(HttpResponse::Ok().build());
410 let (status, state) = Session::get_changes(&mut res);
411 assert_eq!(status, SessionStatus::Changed);
412 assert_eq!(
413 state.unwrap().collect::<Vec<_>>(),
414 [("replacement".to_owned(), "3".to_owned())]
415 );
416 assert_eq!(second.get::<u32>("replacement").unwrap(), None);
417 }
418
419 #[test]
426 fn session_json_errors_preserve_existing_values() {
427 struct Unserializable;
428
429 impl Serialize for Unserializable {
430 fn serialize<S: serde::Serializer>(&self, _: S) -> Result<S::Ok, S::Error> {
431 Err(serde::ser::Error::custom("cannot serialize session value"))
432 }
433 }
434
435 let req = test::TestRequest::default().to_srv_request();
436 Session::set_session(
437 [
438 ("bad".to_owned(), "not-json".to_owned()),
439 ("good".to_owned(), "42".to_owned()),
440 ]
441 .into_iter(),
442 &req,
443 );
444 let session = req.get_session();
445 assert!(session.get::<u32>("bad").is_err());
446 assert!(session.get::<String>("good").is_err());
447 assert!(
448 session
449 .set("good", Unserializable)
450 .unwrap_err()
451 .to_string()
452 .contains("cannot serialize")
453 );
454 assert_eq!(session.get::<u32>("good").unwrap(), Some(42));
455
456 let mut res = req.into_response(HttpResponse::Ok().build());
457 let (_, state) = Session::get_changes(&mut res);
458 let state: HashMap<_, _> = state.unwrap().collect();
459 assert_eq!(state.get("good").map(String::as_str), Some("42"));
460 }
461}