update version

CHANGES.md

@@ -12,6 +12,8 @@
 
 * Extend `Responder` trait, allow to override status code and headers.
 
+* Store visit and login timestamp in the identity cookie #502
+
 ### Changed
 
 * `.to_async()` handler can return `Responder` type #792

actix-session/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [0.1.0-beta.2] - 2019-04-28
+
+* Add helper trait `UserSession` which allows to get session for ServiceRequest and HttpRequest
+
 ## [0.1.0-beta.1] - 2019-04-20
 
 * Update actix-web to beta.1

actix-session/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-session"
-version = "0.1.0-beta.1"
+version = "0.1.0-beta.2"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Session for actix web framework."
 readme = "README.md"
@@ -24,7 +24,7 @@ default = ["cookie-session"]
 cookie-session = ["actix-web/secure-cookies"]
 
 [dependencies]
-actix-web = "1.0.0-beta.1"
+actix-web = "1.0.0-beta.2"
 actix-service = "0.3.4"
 bytes = "0.4"
 derive_more = "0.14"

actix-session/src/lib.rs

@@ -79,6 +79,23 @@ pub use crate::cookie::CookieSession;
 /// ```
 pub struct Session(Rc<RefCell<SessionInner>>);
 
+/// Helper trait that allows to get session
+pub trait UserSession {
+    fn get_session(&mut self) -> Session;
+}
+
+impl UserSession for HttpRequest {
+    fn get_session(&mut self) -> Session {
+        Session::get_session(&mut *self.extensions_mut())
+    }
+}
+
+impl UserSession for ServiceRequest {
+    fn get_session(&mut self) -> Session {
+        Session::get_session(&mut *self.extensions_mut())
+    }
+}
+
 #[derive(Default)]
 struct SessionInner {
     state: HashMap<String, String>,
@@ -208,4 +225,18 @@ mod tests {
         let changes: Vec<_> = Session::get_changes(&mut res).unwrap().collect();
         assert_eq!(changes, [("key2".to_string(), "\"value2\"".to_string())]);
     }
+
+    #[test]
+    fn get_session() {
+        let mut req = test::TestRequest::default().to_srv_request();
+
+        Session::set_session(
+            vec![("key".to_string(), "\"value\"".to_string())].into_iter(),
+            &mut req,
+        );
+
+        let session = req.get_session();
+        let res = session.get::<String>("key").unwrap();
+        assert_eq!(res, Some("value".to_string()));
+    }
 }

src/middleware/compress.rs

@@ -6,7 +6,7 @@ use std::str::FromStr;
 use actix_http::body::MessageBody;
 use actix_http::encoding::Encoder;
 use actix_http::http::header::{ContentEncoding, ACCEPT_ENCODING};
-use actix_http::{Response, ResponseBuilder};
+use actix_http::{Error, Response, ResponseBuilder};
 use actix_service::{Service, Transform};
 use futures::future::{ok, FutureResult};
 use futures::{Async, Future, Poll};
@@ -71,11 +71,11 @@ impl Default for Compress {
 impl<S, B> Transform<S> for Compress
 where
     B: MessageBody,
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
 {
     type Request = ServiceRequest;
     type Response = ServiceResponse<Encoder<B>>;
-    type Error = S::Error;
+    type Error = Error;
     type InitError = ();
     type Transform = CompressMiddleware<S>;
     type Future = FutureResult<Self::Transform, Self::InitError>;
@@ -96,11 +96,11 @@ pub struct CompressMiddleware<S> {
 impl<S, B> Service for CompressMiddleware<S>
 where
     B: MessageBody,
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
 {
     type Request = ServiceRequest;
     type Response = ServiceResponse<Encoder<B>>;
-    type Error = S::Error;
+    type Error = Error;
     type Future = CompressResponse<S, B>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
@@ -141,10 +141,10 @@ where
 impl<S, B> Future for CompressResponse<S, B>
 where
     B: MessageBody,
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
 {
     type Item = ServiceResponse<Encoder<B>>;
-    type Error = S::Error;
+    type Error = Error;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
         let resp = futures::try_ready!(self.fut.poll());

src/middleware/cors.rs

@@ -47,7 +47,7 @@ use futures::future::{ok, Either, Future, FutureResult};
 use futures::Poll;
 
 use crate::dev::RequestHead;
-use crate::error::{ResponseError, Result};
+use crate::error::{Error, ResponseError, Result};
 use crate::http::header::{self, HeaderName, HeaderValue};
 use crate::http::{self, HttpTryFrom, Method, StatusCode, Uri};
 use crate::service::{ServiceRequest, ServiceResponse};
@@ -477,9 +477,8 @@ fn cors<'a>(
 
 impl<S, B> IntoTransform<CorsFactory, S> for Cors
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     S::Future: 'static,
-    S::Error: 'static,
     B: 'static,
 {
     fn into_transform(self) -> CorsFactory {
@@ -539,14 +538,13 @@ pub struct CorsFactory {
 
 impl<S, B> Transform<S> for CorsFactory
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     S::Future: 'static,
-    S::Error: 'static,
     B: 'static,
 {
     type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
-    type Error = S::Error;
+    type Error = Error;
     type InitError = ();
     type Transform = CorsMiddleware<S>;
     type Future = FutureResult<Self::Transform, Self::InitError>;
@@ -680,17 +678,16 @@ impl Inner {
 
 impl<S, B> Service for CorsMiddleware<S>
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     S::Future: 'static,
-    S::Error: 'static,
     B: 'static,
 {
     type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
-    type Error = S::Error;
+    type Error = Error;
     type Future = Either<
-        FutureResult<Self::Response, Self::Error>,
+        FutureResult<Self::Response, Error>,
-        Either<S::Future, Box<Future<Item = Self::Response, Error = Self::Error>>>,
+        Either<S::Future, Box<Future<Item = Self::Response, Error = Error>>>,
     >;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
@@ -820,10 +817,12 @@ mod tests {
     impl Cors {
         fn finish<S, B>(self, srv: S) -> CorsMiddleware<S>
         where
-            S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>
+            S: Service<
-                + 'static,
+                    Request = ServiceRequest,
+                    Response = ServiceResponse<B>,
+                    Error = Error,
+                > + 'static,
             S::Future: 'static,
-            S::Error: 'static,
             B: 'static,
         {
             block_on(

src/middleware/defaultheaders.rs

@@ -8,6 +8,7 @@ use futures::{Future, Poll};
 use crate::http::header::{HeaderName, HeaderValue, CONTENT_TYPE};
 use crate::http::{HeaderMap, HttpTryFrom};
 use crate::service::{ServiceRequest, ServiceResponse};
+use crate::Error;
 
 /// `Middleware` for setting default response headers.
 ///
@@ -87,12 +88,12 @@ impl DefaultHeaders {
 
 impl<S, B> Transform<S> for DefaultHeaders
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     S::Future: 'static,
 {
     type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
-    type Error = S::Error;
+    type Error = Error;
     type InitError = ();
     type Transform = DefaultHeadersMiddleware<S>;
     type Future = FutureResult<Self::Transform, Self::InitError>;
@@ -112,12 +113,12 @@ pub struct DefaultHeadersMiddleware<S> {
 
 impl<S, B> Service for DefaultHeadersMiddleware<S>
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     S::Future: 'static,
 {
     type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
-    type Error = S::Error;
+    type Error = Error;
     type Future = Box<Future<Item = Self::Response, Error = Self::Error>>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {

src/middleware/errhandlers.rs

@@ -85,7 +85,6 @@ impl<S, B> Transform<S> for ErrorHandlers<B>
 where
     S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     S::Future: 'static,
-    S::Error: 'static,
     B: 'static,
 {
     type Request = ServiceRequest;
@@ -113,7 +112,6 @@ impl<S, B> Service for ErrorHandlersMiddleware<S, B>
 where
     S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     S::Future: 'static,
-    S::Error: 'static,
     B: 'static,
 {
     type Request = ServiceRequest;

src/middleware/identity.rs

@@ -203,15 +203,15 @@ impl<T> IdentityService<T> {
 
 impl<S, T, B> Transform<S> for IdentityService<T>
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>> + 'static,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>
+        + 'static,
     S::Future: 'static,
-    S::Error: 'static,
     T: IdentityPolicy,
     B: 'static,
 {
     type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
-    type Error = S::Error;
+    type Error = Error;
     type InitError = ();
     type Transform = IdentityServiceMiddleware<S, T>;
     type Future = FutureResult<Self::Transform, Self::InitError>;
@@ -233,14 +233,14 @@ pub struct IdentityServiceMiddleware<S, T> {
 impl<S, T, B> Service for IdentityServiceMiddleware<S, T>
 where
     B: 'static,
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>> + 'static,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>
+        + 'static,
     S::Future: 'static,
-    S::Error: 'static,
     T: IdentityPolicy,
 {
     type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
-    type Error = S::Error;
+    type Error = Error;
     type Future = Box<Future<Item = Self::Response, Error = Self::Error>>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
@@ -512,12 +512,16 @@ impl CookieIdentityPolicy {
     }
 
     /// Accepts only users whose cookie has been seen before the given deadline
+    ///
+    /// By default visit deadline is disabled.
     pub fn visit_deadline(mut self, value: Duration) -> CookieIdentityPolicy {
         Rc::get_mut(&mut self.0).unwrap().visit_deadline = Some(value);
         self
     }
 
     /// Accepts only users which has been authenticated before the given deadline
+    ///
+    /// By default login deadline is disabled.
     pub fn login_deadline(mut self, value: Duration) -> CookieIdentityPolicy {
         Rc::get_mut(&mut self.0).unwrap().login_deadline = Some(value);
         self

src/middleware/logger.rs

@@ -116,12 +116,12 @@ impl Default for Logger {
 
 impl<S, B> Transform<S> for Logger
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     B: MessageBody,
 {
     type Request = ServiceRequest;
     type Response = ServiceResponse<StreamLog<B>>;
-    type Error = S::Error;
+    type Error = Error;
     type InitError = ();
     type Transform = LoggerMiddleware<S>;
     type Future = FutureResult<Self::Transform, Self::InitError>;
@@ -142,12 +142,12 @@ pub struct LoggerMiddleware<S> {
 
 impl<S, B> Service for LoggerMiddleware<S>
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     B: MessageBody,
 {
     type Request = ServiceRequest;
     type Response = ServiceResponse<StreamLog<B>>;
-    type Error = S::Error;
+    type Error = Error;
     type Future = LoggerResponse<S, B>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
@@ -194,10 +194,10 @@ where
 impl<S, B> Future for LoggerResponse<S, B>
 where
     B: MessageBody,
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
 {
     type Item = ServiceResponse<StreamLog<B>>;
-    type Error = S::Error;
+    type Error = Error;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
         let res = futures::try_ready!(self.fut.poll());

src/middleware/normalize.rs

@@ -5,6 +5,7 @@ use futures::future::{self, FutureResult};
 use regex::Regex;
 
 use crate::service::{ServiceRequest, ServiceResponse};
+use crate::Error;
 
 #[derive(Default, Clone, Copy)]
 /// `Middleware` to normalize request's URI in place
@@ -16,11 +17,11 @@ pub struct NormalizePath;
 
 impl<S> Transform<S> for NormalizePath
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse, Error = Error>,
 {
     type Request = ServiceRequest;
     type Response = ServiceResponse;
-    type Error = S::Error;
+    type Error = Error;
     type InitError = ();
     type Transform = NormalizePathNormalization<S>;
     type Future = FutureResult<Self::Transform, Self::InitError>;
@@ -40,11 +41,11 @@ pub struct NormalizePathNormalization<S> {
 
 impl<S> Service for NormalizePathNormalization<S>
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse, Error = Error>,
 {
     type Request = ServiceRequest;
     type Response = ServiceResponse;
-    type Error = S::Error;
+    type Error = Error;
     type Future = S::Future;
 
     fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {

src/scope.rs

@@ -247,7 +247,7 @@ where
 
     /// Registers middleware, in the form of a closure, that runs during inbound
     /// processing in the request lifecycle (request -> response), modifying
-    /// request as necessary, across all requests managed by the *Scope*.  
+    /// request as necessary, across all requests managed by the *Scope*.
     /// Scope-level middleware is more limited in what it can modify, relative
     /// to Route or Application level middleware, in that Scope-level middleware
     /// can not modify ServiceResponse.