mirrors/ntex-extras
1
0
Fork 0
mirror of https://github.com/ntex-rs/ntex-extras.git synced 2025-04-05 05:47:44 +03:00
Code Issues Projects Releases Packages Wiki Activity

migrate session

Browse source
This commit is contained in:
Nikolay Kim 2020-04-11 01:01:11 +06:00
parent 2a7d26b349
commit 8d2e70094e
3 changed files with 101 additions and 87 deletions
Download patch file Download diff file Expand all files Collapse all files

3
ntex-session/Cargo.toml
View file

@ -19,11 +19,12 @@ path = "src/lib.rs"
default = ["cookie-session"] default = ["cookie-session"]
# sessions feature, session require "ring" crate and c compiler # sessions feature, session require "ring" crate and c compiler
cookie-session = [] # "actix-web/secure-cookies"] cookie-session = ["cookie/secure", "ntex/cookie"]
[dependencies] [dependencies]
ntex = "0.1.7" ntex = "0.1.7"
bytes = "0.5.4" bytes = "0.5.4"
cookie = "0.13.3"
derive_more = "0.99.5" derive_more = "0.99.5"
futures = "0.3.4" futures = "0.3.4"
serde = "1.0" serde = "1.0"

139
ntex-session/src/cookie.rs
View file

@ -16,16 +16,19 @@
//! for cookie session - when this value is changed, all session data is lost. //! for cookie session - when this value is changed, all session data is lost.
use std::collections::HashMap; use std::collections::HashMap;
use std::convert::Infallible;
use std::marker::PhantomData;
use std::rc::Rc; use std::rc::Rc;
use std::task::{Context, Poll}; use std::task::{Context, Poll};
use actix_service::{Service, Transform}; use cookie::{Cookie, CookieJar, Key, SameSite};
use actix_web::cookie::{Cookie, CookieJar, Key, SameSite};
use actix_web::dev::{ServiceRequest, ServiceResponse};
use actix_web::http::{header::SET_COOKIE, HeaderValue};
use actix_web::{Error, HttpMessage, ResponseError};
use derive_more::{Display, From}; use derive_more::{Display, From};
use futures::future::{ok, FutureExt, LocalBoxFuture, Ready}; use futures::future::{ok, FutureExt, LocalBoxFuture, Ready};
use ntex::http::header::{HeaderValue, SET_COOKIE};
use ntex::http::HttpMessage;
use ntex::service::{Service, Transform};
use ntex::web::dev::{WebRequest, WebResponse};
use ntex::web::{DefaultError, ErrorRenderer, WebResponseError};
use serde_json::error::Error as JsonError; use serde_json::error::Error as JsonError;
use time::{Duration, OffsetDateTime}; use time::{Duration, OffsetDateTime};
@ -42,14 +45,14 @@ pub enum CookieSessionError {
Serialize(JsonError), Serialize(JsonError),
} }
impl ResponseError for CookieSessionError {} impl WebResponseError<DefaultError> for CookieSessionError {}
enum CookieSecurity { enum CookieSecurity {
Signed, Signed,
Private, Private,
} }
struct CookieSessionInner { struct CookieSessionInner<Err> {
key: Key, key: Key,
security: CookieSecurity, security: CookieSecurity,
name: String, name: String,
@ -60,10 +63,11 @@ struct CookieSessionInner {
max_age: Option<Duration>, max_age: Option<Duration>,
expires_in: Option<Duration>, expires_in: Option<Duration>,
same_site: Option<SameSite>, same_site: Option<SameSite>,
_t: PhantomData<Err>,
} }
impl CookieSessionInner { impl<Err> CookieSessionInner<Err> {
fn new(key: &[u8], security: CookieSecurity) -> CookieSessionInner { fn new(key: &[u8], security: CookieSecurity) -> Self {
CookieSessionInner { CookieSessionInner {
security, security,
key: Key::from_master(key), key: Key::from_master(key),
@ -75,14 +79,15 @@ impl CookieSessionInner {
max_age: None, max_age: None,
expires_in: None, expires_in: None,
same_site: None, same_site: None,
_t: PhantomData,
} }
} }
fn set_cookie<B>( fn set_cookie<B>(
&self, &self,
res: &mut ServiceResponse<B>, res: &mut WebResponse<B>,
state: impl Iterator<Item = (String, String)>, state: impl Iterator<Item = (String, String)>,
) -> Result<(), Error> { ) -> Result<(), CookieSessionError> {
let state: HashMap<String, String> = state.collect(); let state: HashMap<String, String> = state.collect();
let value = let value =
serde_json::to_string(&state).map_err(CookieSessionError::Serialize)?; serde_json::to_string(&state).map_err(CookieSessionError::Serialize)?;
@ -119,7 +124,7 @@ impl CookieSessionInner {
} }
for cookie in jar.delta() { for cookie in jar.delta() {
let val = HeaderValue::from_str(&cookie.encoded().to_string())?; let val = HeaderValue::from_str(&cookie.encoded().to_string()).unwrap();
res.headers_mut().append(SET_COOKIE, val); res.headers_mut().append(SET_COOKIE, val);
} }
@ -127,19 +132,19 @@ impl CookieSessionInner {
} }
/// invalidates session cookie /// invalidates session cookie
fn remove_cookie<B>(&self, res: &mut ServiceResponse<B>) -> Result<(), Error> { fn remove_cookie<B>(&self, res: &mut WebResponse<B>) -> Result<(), Infallible> {
let mut cookie = Cookie::named(self.name.clone()); let mut cookie = Cookie::named(self.name.clone());
cookie.set_value(""); cookie.set_value("");
cookie.set_max_age(Duration::zero()); cookie.set_max_age(Duration::zero());
cookie.set_expires(OffsetDateTime::now() - Duration::days(365)); cookie.set_expires(OffsetDateTime::now() - Duration::days(365));
let val = HeaderValue::from_str(&cookie.to_string())?; let val = HeaderValue::from_str(&cookie.to_string()).unwrap();
res.headers_mut().append(SET_COOKIE, val); res.headers_mut().append(SET_COOKIE, val);
Ok(()) Ok(())
} }
fn load(&self, req: &ServiceRequest) -> (bool, HashMap<String, String>) { fn load(&self, req: &WebRequest<Err>) -> (bool, HashMap<String, String>) {
if let Ok(cookies) = req.cookies() { if let Ok(cookies) = req.cookies() {
for cookie in cookies.iter() { for cookie in cookies.iter() {
if cookie.name() == self.name { if cookie.name() == self.name {
@ -193,26 +198,26 @@ impl CookieSessionInner {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// use actix_session::CookieSession; /// use ntex_session::CookieSession;
/// use actix_web::{web, App, HttpResponse, HttpServer}; /// use ntex::web::{self, App, HttpResponse, HttpServer};
/// ///
/// fn main() { /// fn main() {
/// let app = App::new().wrap( /// let app = App::new().wrap(
/// CookieSession::signed(&[0; 32]) /// CookieSession::signed(&[0; 32])
/// .domain("www.rust-lang.org") /// .domain("www.rust-lang.org")
/// .name("actix_session") /// .name("ntex-session")
/// .path("/") /// .path("/")
/// .secure(true)) /// .secure(true))
/// .service(web::resource("/").to(|| HttpResponse::Ok())); /// .service(web::resource("/").to(|| async { HttpResponse::Ok() }));
/// } /// }
/// ``` /// ```
pub struct CookieSession(Rc<CookieSessionInner>); pub struct CookieSession<Err>(Rc<CookieSessionInner<Err>>);
impl CookieSession { impl<Err> CookieSession<Err> {
/// Construct new *signed* `CookieSessionBackend` instance. /// Construct new *signed* `CookieSessionBackend` instance.
/// ///
/// Panics if key length is less than 32 bytes. /// Panics if key length is less than 32 bytes.
pub fn signed(key: &[u8]) -> CookieSession { pub fn signed(key: &[u8]) -> Self {
CookieSession(Rc::new(CookieSessionInner::new( CookieSession(Rc::new(CookieSessionInner::new(
key, key,
CookieSecurity::Signed, CookieSecurity::Signed,
@ -222,7 +227,7 @@ impl CookieSession {
/// Construct new *private* `CookieSessionBackend` instance. /// Construct new *private* `CookieSessionBackend` instance.
/// ///
/// Panics if key length is less than 32 bytes. /// Panics if key length is less than 32 bytes.
pub fn private(key: &[u8]) -> CookieSession { pub fn private(key: &[u8]) -> Self {
CookieSession(Rc::new(CookieSessionInner::new( CookieSession(Rc::new(CookieSessionInner::new(
key, key,
CookieSecurity::Private, CookieSecurity::Private,
@ -230,19 +235,19 @@ impl CookieSession {
} }
/// Sets the `path` field in the session cookie being built. /// Sets the `path` field in the session cookie being built.
pub fn path<S: Into<String>>(mut self, value: S) -> CookieSession { pub fn path<S: Into<String>>(mut self, value: S) -> Self {
Rc::get_mut(&mut self.0).unwrap().path = value.into(); Rc::get_mut(&mut self.0).unwrap().path = value.into();
self self
} }
/// Sets the `name` field in the session cookie being built. /// Sets the `name` field in the session cookie being built.
pub fn name<S: Into<String>>(mut self, value: S) -> CookieSession { pub fn name<S: Into<String>>(mut self, value: S) -> Self {
Rc::get_mut(&mut self.0).unwrap().name = value.into(); Rc::get_mut(&mut self.0).unwrap().name = value.into();
self self
} }
/// Sets the `domain` field in the session cookie being built. /// Sets the `domain` field in the session cookie being built.
pub fn domain<S: Into<String>>(mut self, value: S) -> CookieSession { pub fn domain<S: Into<String>>(mut self, value: S) -> Self {
Rc::get_mut(&mut self.0).unwrap().domain = Some(value.into()); Rc::get_mut(&mut self.0).unwrap().domain = Some(value.into());
self self
} }
@ -251,57 +256,60 @@ impl CookieSession {
/// ///
/// If the `secure` field is set, a cookie will only be transmitted when the /// If the `secure` field is set, a cookie will only be transmitted when the
/// connection is secure - i.e. `https` /// connection is secure - i.e. `https`
pub fn secure(mut self, value: bool) -> CookieSession { pub fn secure(mut self, value: bool) -> Self {
Rc::get_mut(&mut self.0).unwrap().secure = value; Rc::get_mut(&mut self.0).unwrap().secure = value;
self self
} }
/// Sets the `http_only` field in the session cookie being built. /// Sets the `http_only` field in the session cookie being built.
pub fn http_only(mut self, value: bool) -> CookieSession { pub fn http_only(mut self, value: bool) -> Self {
Rc::get_mut(&mut self.0).unwrap().http_only = value; Rc::get_mut(&mut self.0).unwrap().http_only = value;
self self
} }
/// Sets the `same_site` field in the session cookie being built. /// Sets the `same_site` field in the session cookie being built.
pub fn same_site(mut self, value: SameSite) -> CookieSession { pub fn same_site(mut self, value: SameSite) -> Self {
Rc::get_mut(&mut self.0).unwrap().same_site = Some(value); Rc::get_mut(&mut self.0).unwrap().same_site = Some(value);
self self
} }
/// Sets the `max-age` field in the session cookie being built. /// Sets the `max-age` field in the session cookie being built.
pub fn max_age(self, seconds: i64) -> CookieSession { pub fn max_age(self, seconds: i64) -> Self {
self.max_age_time(Duration::seconds(seconds)) self.max_age_time(Duration::seconds(seconds))
} }
/// Sets the `max-age` field in the session cookie being built. /// Sets the `max-age` field in the session cookie being built.
pub fn max_age_time(mut self, value: time::Duration) -> CookieSession { pub fn max_age_time(mut self, value: time::Duration) -> Self {
Rc::get_mut(&mut self.0).unwrap().max_age = Some(value); Rc::get_mut(&mut self.0).unwrap().max_age = Some(value);
self self
} }
/// Sets the `expires` field in the session cookie being built. /// Sets the `expires` field in the session cookie being built.
pub fn expires_in(self, seconds: i64) -> CookieSession { pub fn expires_in(self, seconds: i64) -> Self {
self.expires_in_time(Duration::seconds(seconds)) self.expires_in_time(Duration::seconds(seconds))
} }
/// Sets the `expires` field in the session cookie being built. /// Sets the `expires` field in the session cookie being built.
pub fn expires_in_time(mut self, value: Duration) -> CookieSession { pub fn expires_in_time(mut self, value: Duration) -> Self {
Rc::get_mut(&mut self.0).unwrap().expires_in = Some(value); Rc::get_mut(&mut self.0).unwrap().expires_in = Some(value);
self self
} }
} }
impl<S, B: 'static> Transform<S> for CookieSession impl<S, B, Err> Transform<S> for CookieSession<Err>
where where
S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>, S: Service<Request = WebRequest<Err>, Response = WebResponse<B>>,
S::Future: 'static, S::Future: 'static,
S::Error: 'static, S::Error: 'static,
B: 'static,
Err: ErrorRenderer,
Err::Container: From<CookieSessionError>,
{ {
type Request = ServiceRequest; type Request = WebRequest<Err>;
type Response = ServiceResponse<B>; type Response = WebResponse<B>;
type Error = S::Error; type Error = S::Error;
type InitError = (); type InitError = ();
type Transform = CookieSessionMiddleware<S>; type Transform = CookieSessionMiddleware<S, Err>;
type Future = Ready<Result<Self::Transform, Self::InitError>>; type Future = Ready<Result<Self::Transform, Self::InitError>>;
fn new_transform(&self, service: S) -> Self::Future { fn new_transform(&self, service: S) -> Self::Future {
@ -313,32 +321,39 @@ where
} }
/// Cookie session middleware /// Cookie session middleware
pub struct CookieSessionMiddleware<S> { pub struct CookieSessionMiddleware<S, Err> {
service: S, service: S,
inner: Rc<CookieSessionInner>, inner: Rc<CookieSessionInner<Err>>,
} }
impl<S, B: 'static> Service for CookieSessionMiddleware<S> impl<S, B, Err> Service for CookieSessionMiddleware<S, Err>
where where
S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>, S: Service<Request = WebRequest<Err>, Response = WebResponse<B>>,
S::Future: 'static, S::Future: 'static,
S::Error: 'static, S::Error: 'static,
B: 'static,
Err: ErrorRenderer,
Err::Container: From<CookieSessionError>,
{ {
type Request = ServiceRequest; type Request = WebRequest<Err>;
type Response = ServiceResponse<B>; type Response = WebResponse<B>;
type Error = S::Error; type Error = S::Error;
type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>; type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
fn poll_ready(&mut self, cx: &mut Context) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
self.service.poll_ready(cx) self.service.poll_ready(cx)
} }
fn poll_shutdown(&self, cx: &mut Context, is_error: bool) -> Poll<()> {
self.service.poll_shutdown(cx, is_error)
}
/// On first request, a new session cookie is returned in response, regardless /// On first request, a new session cookie is returned in response, regardless
/// of whether any session state is set. With subsequent requests, if the /// of whether any session state is set. With subsequent requests, if the
/// session state changes, then set-cookie is returned in response. As /// session state changes, then set-cookie is returned in response. As
/// a user logs out, call session.purge() to set SessionStatus accordingly /// a user logs out, call session.purge() to set SessionStatus accordingly
/// and this will trigger removal of the session cookie in the response. /// and this will trigger removal of the session cookie in the response.
fn call(&mut self, mut req: ServiceRequest) -> Self::Future { fn call(&self, mut req: WebRequest<Err>) -> Self::Future {
let inner = self.inner.clone(); let inner = self.inner.clone();
let (is_new, state) = self.inner.load(&req); let (is_new, state) = self.inner.load(&req);
let prolong_expiration = self.inner.expires_in.is_some(); let prolong_expiration = self.inner.expires_in.is_some();
@ -351,17 +366,17 @@ where
match Session::get_changes(&mut res) { match Session::get_changes(&mut res) {
(SessionStatus::Changed, Some(state)) (SessionStatus::Changed, Some(state))
| (SessionStatus::Renewed, Some(state)) => { | (SessionStatus::Renewed, Some(state)) => {
res.checked_expr(|res| inner.set_cookie(res, state)) res.checked_expr::<_, _, Err>(|res| inner.set_cookie(res, state))
} }
(SessionStatus::Unchanged, Some(state)) if prolong_expiration => { (SessionStatus::Unchanged, Some(state)) if prolong_expiration => {
res.checked_expr(|res| inner.set_cookie(res, state)) res.checked_expr::<_, _, Err>(|res| inner.set_cookie(res, state))
} }
(SessionStatus::Unchanged, _) => (SessionStatus::Unchanged, _) =>
// set a new session cookie upon first request (new client) // set a new session cookie upon first request (new client)
{ {
if is_new { if is_new {
let state: HashMap<String, String> = HashMap::new(); let state: HashMap<String, String> = HashMap::new();
res.checked_expr(|res| { res.checked_expr::<_, _, Err>(|res| {
inner.set_cookie(res, state.into_iter()) inner.set_cookie(res, state.into_iter())
}) })
} else { } else {
@ -383,12 +398,12 @@ where
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use actix_web::{test, web, App};
use bytes::Bytes; use bytes::Bytes;
use ntex::web::{self, test, App};
#[actix_rt::test] #[ntex::test]
async fn cookie_session() { async fn cookie_session() {
let mut app = test::init_service( let app = test::init_service(
App::new() App::new()
.wrap(CookieSession::signed(&[0; 32]).secure(false)) .wrap(CookieSession::signed(&[0; 32]).secure(false))
.service(web::resource("/").to(|ses: Session| async move { .service(web::resource("/").to(|ses: Session| async move {
@ -407,9 +422,9 @@ mod tests {
.is_some()); .is_some());
} }
#[actix_rt::test] #[ntex::test]
async fn private_cookie() { async fn private_cookie() {
let mut app = test::init_service( let app = test::init_service(
App::new() App::new()
.wrap(CookieSession::private(&[0; 32]).secure(false)) .wrap(CookieSession::private(&[0; 32]).secure(false))
.service(web::resource("/").to(|ses: Session| async move { .service(web::resource("/").to(|ses: Session| async move {
@ -428,9 +443,9 @@ mod tests {
.is_some()); .is_some());
} }
#[actix_rt::test] #[ntex::test]
async fn cookie_session_extractor() { async fn cookie_session_extractor() {
let mut app = test::init_service( let app = test::init_service(
App::new() App::new()
.wrap(CookieSession::signed(&[0; 32]).secure(false)) .wrap(CookieSession::signed(&[0; 32]).secure(false))
.service(web::resource("/").to(|ses: Session| async move { .service(web::resource("/").to(|ses: Session| async move {
@ -449,9 +464,9 @@ mod tests {
.is_some()); .is_some());
} }
#[actix_rt::test] #[ntex::test]
async fn basics() { async fn basics() {
let mut app = test::init_service( let app = test::init_service(
App::new() App::new()
.wrap( .wrap(
CookieSession::signed(&[0; 32]) CookieSession::signed(&[0; 32])
@ -486,13 +501,13 @@ mod tests {
let request = test::TestRequest::with_uri("/test/") let request = test::TestRequest::with_uri("/test/")
.cookie(cookie) .cookie(cookie)
.to_request(); .to_request();
let body = test::read_response(&mut app, request).await; let body = test::read_response(&app, request).await;
assert_eq!(body, Bytes::from_static(b"counter: 100")); assert_eq!(body, Bytes::from_static(b"counter: 100"));
} }
#[actix_rt::test] #[ntex::test]
async fn prolong_expiration() { async fn prolong_expiration() {
let mut app = test::init_service( let app = test::init_service(
App::new() App::new()
.wrap(CookieSession::signed(&[0; 32]).secure(false).expires_in(60)) .wrap(CookieSession::signed(&[0; 32]).secure(false).expires_in(60))
.service(web::resource("/").to(|ses: Session| async move { .service(web::resource("/").to(|ses: Session| async move {
@ -516,7 +531,7 @@ mod tests {
.expires() .expires()
.expect("Expiration is set"); .expect("Expiration is set");
actix_rt::time::delay_for(std::time::Duration::from_secs(1)).await; ntex::rt::time::delay_for(std::time::Duration::from_secs(1)).await;
let request = test::TestRequest::with_uri("/test/").to_request(); let request = test::TestRequest::with_uri("/test/").to_request();
let response = app.call(request).await.unwrap(); let response = app.call(request).await.unwrap();

46
ntex-session/src/lib.rs
View file

@ -13,8 +13,8 @@
//! extractor allows us to get or set session data. //! extractor allows us to get or set session data.
//! //!
//! ```rust,no_run //! ```rust,no_run
//! use actix_web::{web, App, HttpServer, HttpResponse, Error}; //! use ntex::web::{self, App, HttpResponse, Error};
//! use actix_session::{Session, CookieSession}; //! use ntex_session::{Session, CookieSession};
//! //!
//! fn index(session: Session) -> Result<&'static str, Error> { //! fn index(session: Session) -> Result<&'static str, Error> {
//! // access session data //! // access session data
@ -28,14 +28,14 @@
//! Ok("Welcome!") //! Ok("Welcome!")
//! } //! }
//! //!
//! #[actix_rt::main] //! #[ntex::main]
//! async fn main() -> std::io::Result<()> { //! async fn main() -> std::io::Result<()> {
//! HttpServer::new( //! web::server(
//! || App::new().wrap( //! || App::new().wrap(
//! CookieSession::signed(&[0; 32]) // <- create cookie based session middleware //! CookieSession::signed(&[0; 32]) // <- create cookie based session middleware
//! .secure(false) //! .secure(false)
//! ) //! )
//! .service(web::resource("/").to(|| HttpResponse::Ok()))) //! .service(web::resource("/").to(|| async { HttpResponse::Ok() })))
//! .bind("127.0.0.1:59880")? //! .bind("127.0.0.1:59880")?
//! .run() //! .run()
//! .await //! .await
@ -43,13 +43,13 @@
//! ``` //! ```
use std::cell::RefCell; use std::cell::RefCell;
use std::collections::HashMap; use std::collections::HashMap;
use std::convert::Infallible;
use std::rc::Rc; use std::rc::Rc;
use actix_web::dev::{
Extensions, Payload, RequestHead, ServiceRequest, ServiceResponse,
};
use actix_web::{Error, FromRequest, HttpMessage, HttpRequest};
use futures::future::{ok, Ready}; use futures::future::{ok, Ready};
use ntex::http::{Extensions, Payload, RequestHead};
use ntex::web::dev::{WebRequest, WebResponse};
use ntex::web::{Error, FromRequest, HttpRequest};
use serde::de::DeserializeOwned; use serde::de::DeserializeOwned;
use serde::Serialize; use serde::Serialize;
use serde_json; use serde_json;
@ -66,10 +66,10 @@ pub use crate::cookie::CookieSession;
/// method. `RequestSession` trait is implemented for `HttpRequest`. /// method. `RequestSession` trait is implemented for `HttpRequest`.
/// ///
/// ```rust /// ```rust
/// use actix_session::Session; /// use ntex_session::Session;
/// use actix_web::*; /// use ntex::web::*;
/// ///
/// fn index(session: Session) -> Result<&'static str> { /// fn index(session: Session) -> Result<&'static str, Error> {
/// // access session data /// // access session data
/// if let Some(count) = session.get::<i32>("counter")? { /// if let Some(count) = session.get::<i32>("counter")? {
/// session.set("counter", count + 1)?; /// session.set("counter", count + 1)?;
@ -94,7 +94,7 @@ impl UserSession for HttpRequest {
} }
} }
impl UserSession for ServiceRequest { impl<Err> UserSession for WebRequest<Err> {
fn get_session(&self) -> Session { fn get_session(&self) -> Session {
Session::get_session(&mut *self.extensions_mut()) Session::get_session(&mut *self.extensions_mut())
} }
@ -180,9 +180,9 @@ impl Session {
} }
} }
pub fn set_session( pub fn set_session<Err>(
data: impl Iterator<Item = (String, String)>, data: impl Iterator<Item = (String, String)>,
req: &mut ServiceRequest, req: &WebRequest<Err>,
) { ) {
let session = Session::get_session(&mut *req.extensions_mut()); let session = Session::get_session(&mut *req.extensions_mut());
let mut inner = session.0.borrow_mut(); let mut inner = session.0.borrow_mut();
@ -190,7 +190,7 @@ impl Session {
} }
pub fn get_changes<B>( pub fn get_changes<B>(
res: &mut ServiceResponse<B>, res: &mut WebResponse<B>,
) -> ( ) -> (
SessionStatus, SessionStatus,
Option<impl Iterator<Item = (String, String)>>, Option<impl Iterator<Item = (String, String)>>,
@ -221,10 +221,9 @@ impl Session {
/// Extractor implementation for Session type. /// Extractor implementation for Session type.
/// ///
/// ```rust /// ```rust
/// # use actix_web::*; /// use ntex_session::Session;
/// use actix_session::Session;
/// ///
/// fn index(session: Session) -> Result<&'static str> { /// fn index(session: Session) -> Result<&'static str, ntex::web::Error> {
/// // access session data /// // access session data
/// if let Some(count) = session.get::<i32>("counter")? { /// if let Some(count) = session.get::<i32>("counter")? {
/// session.set("counter", count + 1)?; /// session.set("counter", count + 1)?;
@ -236,10 +235,9 @@ impl Session {
/// } /// }
/// # fn main() {} /// # fn main() {}
/// ``` /// ```
impl FromRequest for Session { impl<Err> FromRequest<Err> for Session {
type Error = Error; type Error = Infallible;
type Future = Ready<Result<Session, Error>>; type Future = Ready<Result<Session, Infallible>>;
type Config = ();
#[inline] #[inline]
fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future { fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
@ -249,7 +247,7 @@ impl FromRequest for Session {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use actix_web::{test, HttpResponse}; use ntex::web::{test, HttpResponse};
use super::*; use super::*;