General purpose actix redis error
+Redis(Error)Receiving message during reconnecting
+Cancel all waters when connection get dropped
+impl Debug for Error[src]impl Display for Error[src]impl From<Error> for Error[src]impl ResponseError for Error[src]fn status_code(&self) -> StatusCodefn error_response(&self) -> Response<Body>impl !RefUnwindSafe for Errorimpl Send for Errorimpl Sync for Errorimpl Unpin for Errorimpl !UnwindSafe for Errorimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> Sealed<T> for T where
T: ?Sized, impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]type Error = <U as TryFrom<T>>::ErrorThe type returned in the event of a conversion error.
+fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]impl<V, T> VZip<V> for T where
V: MultiLane<T>, fn vzip(self) -> VInternal(String)A non-specific internal error that prevented an operation from completing
+IO(Error)An IO error occurred
+A RESP parsing/serialising error occurred
+Remote(String)A remote error
+Error creating a connection, or an error with a connection being closed unexpectedly
+Unexpected(String)An unexpected error. In this context "unexpected" means +"unexpected because we check ahead of time", it used to maintain the type signature of +chains of futures; but it occurring at runtime should be considered a catastrophic +failure.
+If any error is propagated this way that needs to be handled, then it should be made into +a proper option.
+impl Debug for Errorimpl Display for Errorimpl Error for Errorfn source(&self) -> Option<&(dyn Error + 'static)>fn backtrace(&self) -> Option<&Backtrace>[src]fn description(&self) -> &str1.0.0[src]fn cause(&self) -> Option<&dyn Error>1.0.0[src]impl From<Error> for Errorimpl From<Error> for Error[src]impl<T> From<TrySendError<T>> for Error where
T: 'static + Send, fn from(err: TrySendError<T>) -> Errorimpl !RefUnwindSafe for Errorimpl Send for Errorimpl Sync for Errorimpl Unpin for Errorimpl !UnwindSafe for Errorimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> Sealed<T> for T where
T: ?Sized, impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]type Error = <U as TryFrom<T>>::ErrorThe type returned in the event of a conversion error.
+fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]impl<V, T> VZip<V> for T where
V: MultiLane<T>, fn vzip(self) -> VA single RESP value, this owns the data that is read/to-be written to Redis.
+It is cloneable to allow multiple copies to be delivered in certain circumstances, e.g. multiple +subscribers to the same topic.
+Zero, one or more other RespValues.
A bulk string. In Redis terminology a string is a byte-array, so this is stored as a
+vector of u8s to allow clients to interpret the bytes as appropriate.
Error(String)An error from the Redis server
+Integer(i64)Redis documentation defines an integer as being a signed 64-bit integer: +https://redis.io/topics/protocol#resp-integers
+SimpleString(String)impl RespValuepub fn append<T>(self, other: impl IntoIterator<Item = T>) -> RespValue where
T: Into<RespValue>, Convenience function for building dynamic Redis commands with variable numbers of +arguments, e.g. RPUSH
+This will panic if called for anything other than arrays
+impl Clone for RespValuefn clone(&self) -> RespValuefn clone_from(&mut self, source: &Self)1.0.0[src]impl Debug for RespValueimpl Eq for RespValueimpl<'a> From<&'a [u8]> for RespValueimpl<'a> From<&'a String> for RespValueimpl<'a> From<&'a str> for RespValueimpl<'a> From<String> for RespValueimpl<'a> From<Vec<u8>> for RespValueimpl<'a> From<usize> for RespValueimpl FromResp for RespValuefn from_resp_int(resp: RespValue) -> Result<RespValue, Error>fn from_resp(resp: RespValue) -> Result<Self, Error>impl PartialEq<RespValue> for RespValueimpl StructuralEq for RespValueimpl StructuralPartialEq for RespValueimpl RefUnwindSafe for RespValueimpl Send for RespValueimpl Sync for RespValueimpl Unpin for RespValueimpl UnwindSafe for RespValueimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> Sealed<T> for T where
T: ?Sized, impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]type Error = <U as TryFrom<T>>::ErrorThe type returned in the event of a conversion error.
+fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]impl<V, T> VZip<V> for T where
V: MultiLane<T>, fn vzip(self) -> VThe SameSite cookie attribute.
A cookie with a SameSite attribute is imposed restrictions on when it is
+sent to the origin server in a cross-site request. If the SameSite
+attribute is "Strict", then the cookie is never sent in cross-site requests.
+If the SameSite attribute is "Lax", the cookie is only sent in cross-site
+requests with "safe" HTTP methods, i.e, GET, HEAD, OPTIONS, TRACE.
+If the SameSite attribute is "None", the cookie is sent in all cross-site
+requests if the "Secure" flag is also set, otherwise the cookie is ignored.
+This library automatically sets the "Secure" flag on cookies when
+same_site is set to SameSite::None as long as secure is not explicitly
+set to false.
If the SameSite attribute is not present (by not setting SameSite
+initally or passing None to Cookie::set_same_site()), then the cookie
+will be sent as normal.
Note: This cookie attribute is an HTTP draft! Its meaning and +definition are subject to change.
+The "Strict" SameSite attribute.
The "Lax" SameSite attribute.
The "None" SameSite attribute.
impl SameSite[src]pub fn is_strict(&self) -> bool[src]Returns true if self is SameSite::Strict and false otherwise.
+use cookie::SameSite; + +let strict = SameSite::Strict; +assert!(strict.is_strict()); +assert!(!strict.is_lax()); +assert!(!strict.is_none());
pub fn is_lax(&self) -> bool[src]Returns true if self is SameSite::Lax and false otherwise.
+use cookie::SameSite; + +let lax = SameSite::Lax; +assert!(lax.is_lax()); +assert!(!lax.is_strict()); +assert!(!lax.is_none());
pub fn is_none(&self) -> bool[src]Returns true if self is SameSite::None and false otherwise.
+use cookie::SameSite; + +let none = SameSite::None; +assert!(none.is_none()); +assert!(!none.is_lax()); +assert!(!none.is_strict());
impl Clone for SameSite[src]impl Copy for SameSite[src]impl Debug for SameSite[src]impl Display for SameSite[src]impl Eq for SameSite[src]impl Hash for SameSite[src]fn hash<__H>(&self, state: &mut __H) where
__H: Hasher, [src]fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]impl PartialEq<SameSite> for SameSite[src]impl StructuralEq for SameSite[src]impl StructuralPartialEq for SameSite[src]impl RefUnwindSafe for SameSiteimpl Send for SameSiteimpl Sync for SameSiteimpl Unpin for SameSiteimpl UnwindSafe for SameSiteimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized, [src]fn equivalent(&self, key: &K) -> bool[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> Sealed<T> for T where
T: ?Sized, impl<T> ToOwned for T where
T: Clone, [src]type Owned = TThe resulting type after obtaining ownership.
+fn to_owned(&self) -> T[src]fn clone_into(&self, target: &mut T)[src]impl<T> ToString for T where
T: Display + ?Sized, [src]impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]type Error = <U as TryFrom<T>>::ErrorThe type returned in the event of a conversion error.
+fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]impl<V, T> VZip<V> for T where
V: MultiLane<T>, fn vzip(self) -> VRedis integration for Actix framework.
+| Command | Command for send data to Redis + |
| RedisActor | Redis comminucation actor + |
| RedisSession | Use redis as session storage. + |
| Error | General purpose actix redis error + |
| RespError | |
| RespValue | A single RESP value, this owns the data that is read/to-be written to Redis. + |
| SameSite | The |
Redirecting to ../../actix_redis/struct.Command.html...
+ + + \ No newline at end of file diff --git a/actix_redis/redis/struct.RedisActor.html b/actix_redis/redis/struct.RedisActor.html new file mode 100644 index 000000000..ee86750c4 --- /dev/null +++ b/actix_redis/redis/struct.RedisActor.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../actix_redis/struct.RedisActor.html...
+ + + \ No newline at end of file diff --git a/actix_redis/session/struct.RedisSession.html b/actix_redis/session/struct.RedisSession.html new file mode 100644 index 000000000..069093cae --- /dev/null +++ b/actix_redis/session/struct.RedisSession.html @@ -0,0 +1,10 @@ + + + + + + +Redirecting to ../../actix_redis/struct.RedisSession.html...
+ + + \ No newline at end of file diff --git a/actix_redis/sidebar-items.js b/actix_redis/sidebar-items.js new file mode 100644 index 000000000..da2928aa2 --- /dev/null +++ b/actix_redis/sidebar-items.js @@ -0,0 +1 @@ +initSidebarItems({"enum":[["Error","General purpose actix redis error"],["RespError",""],["RespValue","A single RESP value, this owns the data that is read/to-be written to Redis."],["SameSite","The `SameSite` cookie attribute."]],"struct":[["Command","Command for send data to Redis"],["RedisActor","Redis comminucation actor"],["RedisSession","Use redis as session storage."]]}); \ No newline at end of file diff --git a/actix_redis/struct.Command.html b/actix_redis/struct.Command.html new file mode 100644 index 000000000..85dbe1960 --- /dev/null +++ b/actix_redis/struct.Command.html @@ -0,0 +1,16 @@ +Command for send data to Redis
+impl Debug for Command[src]impl Handler<Command> for RedisActor[src]type Result = ResponseFuture<Result<RespValue, Error>>The type of value that this handler will return. Read more
+fn handle(&mut self, msg: Command, _: &mut Self::Context) -> Self::Result[src]impl Message for Command[src]impl RefUnwindSafe for Commandimpl Send for Commandimpl Sync for Commandimpl Unpin for Commandimpl UnwindSafe for Commandimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> Sealed<T> for T where
T: ?Sized, impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]type Error = <U as TryFrom<T>>::ErrorThe type returned in the event of a conversion error.
+fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]impl<V, T> VZip<V> for T where
V: MultiLane<T>, fn vzip(self) -> VRedis comminucation actor
+impl RedisActor[src]pub fn start<S: Into<String>>(addr: S) -> Addr<RedisActor>[src]Start new Supervisor with RedisActor.
impl Actor for RedisActor[src]type Context = Context<Self>Actor execution context type
+fn started(&mut self, ctx: &mut Context<Self>)[src]fn stopping(&mut self, ctx: &mut Self::Context) -> Runningfn stopped(&mut self, ctx: &mut Self::Context)fn start(self) -> Addr<Self> where
Self: Actor<Context = Context<Self>>, fn start_default() -> Addr<Self> where
Self: Actor<Context = Context<Self>> + Default, fn start_in_arbiter<F>(arb: &Arbiter, f: F) -> Addr<Self> where
F: FnOnce(&mut Context<Self>) -> Self + Send + 'static,
Self: Actor<Context = Context<Self>>, fn create<F>(f: F) -> Addr<Self> where
F: FnOnce(&mut Context<Self>) -> Self,
Self: Actor<Context = Context<Self>>, impl Handler<Command> for RedisActor[src]type Result = ResponseFuture<Result<RespValue, Error>>The type of value that this handler will return. Read more
+fn handle(&mut self, msg: Command, _: &mut Self::Context) -> Self::Result[src]impl StreamHandler<Result<RespValue, Error>> for RedisActor[src]fn handle(&mut self, msg: Result<RespValue, RespError>, ctx: &mut Self::Context)[src]fn started(&mut self, ctx: &mut Self::Context)fn finished(&mut self, ctx: &mut Self::Context)fn add_stream<S>(fut: S, ctx: &mut Self::Context) -> SpawnHandle where
I: 'static,
S: Stream<Item = I> + 'static,
Self::Context: AsyncContext<Self>, impl Supervised for RedisActor[src]fn restarting(&mut self, _: &mut Self::Context)[src]impl WriteHandler<Error> for RedisActor[src]impl !RefUnwindSafe for RedisActorimpl !Send for RedisActorimpl !Sync for RedisActorimpl Unpin for RedisActorimpl !UnwindSafe for RedisActorimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> Sealed<T> for T where
T: ?Sized, impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]type Error = <U as TryFrom<T>>::ErrorThe type returned in the event of a conversion error.
+fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]impl<V, T> VZip<V> for T where
V: MultiLane<T>, fn vzip(self) -> VUse redis as session storage.
+You need to pass an address of the redis server and random value to the
+constructor of RedisSession. This is private key for cookie
+session, When this value is changed, all session data is lost.
Constructor panics if key length is less than 32 bytes.
+impl RedisSession[src]pub fn new<S: Into<String>>(addr: S, key: &[u8]) -> RedisSession[src]Create new redis session backend
+addr - address of the redis serverpub fn ttl(self, ttl: u32) -> Self[src]Set time to live in seconds for session value
+pub fn cookie_name(self, name: &str) -> Self[src]Set custom cookie name for session id
+pub fn cookie_path(self, path: &str) -> Self[src]Set custom cookie path
+pub fn cookie_domain(self, domain: &str) -> Self[src]Set custom cookie domain
+pub fn cookie_secure(self, secure: bool) -> Self[src]Set custom cookie secure
+If the secure field is set, a cookie will only be transmitted when the
+connection is secure - i.e. https
pub fn cookie_max_age(self, max_age: Duration) -> Self[src]Set custom cookie max-age
+pub fn cookie_same_site(self, same_site: SameSite) -> Self[src]Set custom cookie SameSite
+pub fn cookie_http_only(self, http_only: bool) -> Self[src]Set custom cookie HttpOnly policy
+pub fn cache_keygen(self, keygen: Box<dyn Fn(&str) -> String>) -> Self[src]Set a custom cache key generation strategy, expecting session key as input
+impl<S, B> Transform<S> for RedisSession where
S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static,
S::Future: 'static,
B: 'static, [src]type Request = ServiceRequestRequests handled by the service.
+type Response = ServiceResponse<B>Responses given by the service.
+type Error = S::ErrorErrors produced by the service.
+type InitError = ()Errors produced while building a transform service.
+type Transform = RedisSessionMiddleware<S>The TransformService value created by this factory
type Future = Ready<Result<Self::Transform, Self::InitError>>The future response value.
+fn new_transform(&self, service: S) -> Self::Future[src]fn map_init_err<F, E>(self, f: F) -> TransformMapInitErr<Self, S, F, E> where
F: Fn(Self::InitError) -> E + Clone, impl !RefUnwindSafe for RedisSessionimpl !Send for RedisSessionimpl !Sync for RedisSessionimpl Unpin for RedisSessionimpl !UnwindSafe for RedisSessionimpl<T> Any for T where
T: 'static + ?Sized, [src]impl<T> Borrow<T> for T where
T: ?Sized, [src]impl<T> BorrowMut<T> for T where
T: ?Sized, [src]fn borrow_mut(&mut self) -> &mut T[src]impl<T> From<T> for T[src]impl<T, U> Into<U> for T where
U: From<T>, [src]impl<T> Same<T> for Ttype Output = TShould always be Self
impl<T> Sealed<T> for T where
T: ?Sized, impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]type Error = InfallibleThe type returned in the event of a conversion error.
+fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]type Error = <U as TryFrom<T>>::ErrorThe type returned in the event of a conversion error.
+fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]impl<V, T> VZip<V> for T where
V: MultiLane<T>, fn vzip(self) -> V| "+""+(item.is_alias===true?(""+item.alias+" - see "):"")+item.displayPath+""+name+" | "+""+""+escape(item.desc)+" |
"+code.outerHTML+" |
fn:) to \
+ restrict the search to a given type.","Accepted types are: fn, mod, struct, \
+ enum, trait, type, macro, \
+ and const.","Search functions by type signature (e.g., vec -> usize or \
+ * -> vec)","Search multiple things at once by splitting your query with comma (e.g., \
+ str,u8 or String,struct:Vec,test)","You can look for items with an exact name by putting double quotes around \
+ your request: \"string\"","Look for items inside another one by searching for a path: vec::Vec",].map(x=>""+x+"
").join("");var div_infos=document.createElement("div");addClass(div_infos,"infos");div_infos.innerHTML="1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +
+//! Redis integration for Actix framework. +//! +//! ## Documentation +//! * [API Documentation (Development)](http://actix.github.io/actix-redis/actix_redis/) +//! * [API Documentation (Releases)](https://docs.rs/actix-redis/) +//! * [Chat on gitter](https://gitter.im/actix/actix) +//! * Cargo package: [actix-redis](https://crates.io/crates/actix-redis) +//! * Minimum supported Rust version: 1.40.0 or later +mod redis; +pub use redis::{Command, RedisActor}; + +use derive_more::{Display, From}; + +#[cfg(feature = "web")] +mod session; +#[cfg(feature = "web")] +pub use actix_web::cookie::SameSite; +#[cfg(feature = "web")] +pub use session::RedisSession; + +/// General purpose actix redis error +#[derive(Debug, Display, From)] +pub enum Error { + #[display(fmt = "Redis error {}", _0)] + Redis(redis_async::error::Error), + /// Receiving message during reconnecting + #[display(fmt = "Redis: Not connected")] + NotConnected, + /// Cancel all waters when connection get dropped + #[display(fmt = "Redis: Disconnected")] + Disconnected, +} + +#[cfg(feature = "web")] +impl actix_web::ResponseError for Error {} + +// re-export +pub use redis_async::error::Error as RespError; +pub use redis_async::resp::RespValue; +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +
+use std::collections::VecDeque; +use std::io; + +use actix::actors::resolver::{Connect, Resolver}; +use actix::prelude::*; +use actix_utils::oneshot; +use backoff::backoff::Backoff; +use backoff::ExponentialBackoff; +use futures_util::FutureExt; +use log::{error, info, warn}; +use redis_async::error::Error as RespError; +use redis_async::resp::{RespCodec, RespValue}; +use tokio::io::{split, WriteHalf}; +use tokio::net::TcpStream; +use tokio_util::codec::FramedRead; + +use crate::Error; + +/// Command for send data to Redis +#[derive(Debug)] +pub struct Command(pub RespValue); + +impl Message for Command { + type Result = Result<RespValue, Error>; +} + +/// Redis comminucation actor +pub struct RedisActor { + addr: String, + backoff: ExponentialBackoff, + cell: Option<actix::io::FramedWrite<RespValue, WriteHalf<TcpStream>, RespCodec>>, + queue: VecDeque<oneshot::Sender<Result<RespValue, Error>>>, +} + +impl RedisActor { + /// Start new `Supervisor` with `RedisActor`. + pub fn start<S: Into<String>>(addr: S) -> Addr<RedisActor> { + let addr = addr.into(); + + let mut backoff = ExponentialBackoff::default(); + backoff.max_elapsed_time = None; + + Supervisor::start(|_| RedisActor { + addr, + cell: None, + backoff, + queue: VecDeque::new(), + }) + } +} + +impl Actor for RedisActor { + type Context = Context<Self>; + + fn started(&mut self, ctx: &mut Context<Self>) { + Resolver::from_registry() + .send(Connect::host(self.addr.as_str())) + .into_actor(self) + .map(|res, act, ctx| match res { + Ok(res) => match res { + Ok(stream) => { + info!("Connected to redis server: {}", act.addr); + + let (r, w) = split(stream); + + // configure write side of the connection + let framed = actix::io::FramedWrite::new(w, RespCodec, ctx); + act.cell = Some(framed); + + // read side of the connection + ctx.add_stream(FramedRead::new(r, RespCodec)); + + act.backoff.reset(); + } + Err(err) => { + error!("Can not connect to redis server: {}", err); + // re-connect with backoff time. + // we stop current context, supervisor will restart it. + if let Some(timeout) = act.backoff.next_backoff() { + ctx.run_later(timeout, |_, ctx| ctx.stop()); + } + } + }, + Err(err) => { + error!("Can not connect to redis server: {}", err); + // re-connect with backoff time. + // we stop current context, supervisor will restart it. + if let Some(timeout) = act.backoff.next_backoff() { + ctx.run_later(timeout, |_, ctx| ctx.stop()); + } + } + }) + .wait(ctx); + } +} + +impl Supervised for RedisActor { + fn restarting(&mut self, _: &mut Self::Context) { + self.cell.take(); + for tx in self.queue.drain(..) { + let _ = tx.send(Err(Error::Disconnected)); + } + } +} + +impl actix::io::WriteHandler<io::Error> for RedisActor { + fn error(&mut self, err: io::Error, _: &mut Self::Context) -> Running { + warn!("Redis connection dropped: {} error: {}", self.addr, err); + Running::Stop + } +} + +impl StreamHandler<Result<RespValue, RespError>> for RedisActor { + fn handle(&mut self, msg: Result<RespValue, RespError>, ctx: &mut Self::Context) { + match msg { + Err(e) => { + if let Some(tx) = self.queue.pop_front() { + let _ = tx.send(Err(e.into())); + } + ctx.stop(); + } + Ok(val) => { + if let Some(tx) = self.queue.pop_front() { + let _ = tx.send(Ok(val)); + } + } + } + } +} + +impl Handler<Command> for RedisActor { + type Result = ResponseFuture<Result<RespValue, Error>>; + + fn handle(&mut self, msg: Command, _: &mut Self::Context) -> Self::Result { + let (tx, rx) = oneshot::channel(); + if let Some(ref mut cell) = self.cell { + self.queue.push_back(tx); + cell.write(msg.0); + } else { + let _ = tx.send(Err(Error::NotConnected)); + } + + Box::pin(rx.map(|res| match res { + Ok(res) => res, + Err(_) => Err(Error::Disconnected), + })) + } +} +
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 + 28 + 29 + 30 + 31 + 32 + 33 + 34 + 35 + 36 + 37 + 38 + 39 + 40 + 41 + 42 + 43 + 44 + 45 + 46 + 47 + 48 + 49 + 50 + 51 + 52 + 53 + 54 + 55 + 56 + 57 + 58 + 59 + 60 + 61 + 62 + 63 + 64 + 65 + 66 + 67 + 68 + 69 + 70 + 71 + 72 + 73 + 74 + 75 + 76 + 77 + 78 + 79 + 80 + 81 + 82 + 83 + 84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +491 +492 +493 +494 +495 +496 +497 +498 +499 +500 +501 +502 +503 +504 +505 +506 +507 +508 +509 +510 +511 +512 +513 +514 +515 +516 +517 +518 +519 +520 +521 +522 +523 +524 +525 +526 +527 +528 +529 +530 +531 +532 +533 +534 +535 +536 +537 +538 +539 +540 +541 +542 +543 +544 +545 +546 +547 +548 +549 +550 +551 +552 +553 +554 +555 +556 +557 +558 +559 +560 +561 +562 +563 +564 +565 +566 +567 +568 +569 +570 +571 +572 +573 +574 +575 +576 +577 +578 +579 +580 +581 +582 +583 +584 +585 +586 +587 +588 +589 +590 +591 +592 +593 +594 +595 +596 +597 +598 +599 +600 +601 +602 +603 +604 +605 +606 +607 +608 +609 +610 +611 +612 +613 +614 +615 +616 +617 +618 +619 +620 +621 +622 +623 +624 +625 +626 +627 +628 +629 +630 +631 +632 +633 +634 +635 +636 +637 +638 +639 +640 +641 +642 +643 +644 +645 +646 +647 +648 +649 +650 +651 +652 +653 +654 +655 +656 +657 +658 +659 +660 +661 +662 +663 +664 +665 +666 +667 +668 +669 +
+use std::cell::RefCell; +use std::pin::Pin; +use std::task::{Context, Poll}; +use std::{collections::HashMap, iter, rc::Rc}; + +use actix::prelude::*; +use actix_service::{Service, Transform}; +use actix_session::{Session, SessionStatus}; +use actix_web::cookie::{Cookie, CookieJar, Key, SameSite}; +use actix_web::dev::{ServiceRequest, ServiceResponse}; +use actix_web::http::header::{self, HeaderValue}; +use actix_web::{error, Error, HttpMessage}; +use futures_util::future::{ok, Future, Ready}; +use rand::{distributions::Alphanumeric, rngs::OsRng, Rng}; +use redis_async::resp::RespValue; +use redis_async::resp_array; +use time::{self, Duration, OffsetDateTime}; + +use crate::redis::{Command, RedisActor}; + +/// Use redis as session storage. +/// +/// You need to pass an address of the redis server and random value to the +/// constructor of `RedisSession`. This is private key for cookie +/// session, When this value is changed, all session data is lost. +/// +/// Constructor panics if key length is less than 32 bytes. +pub struct RedisSession(Rc<Inner>); + +impl RedisSession { + /// Create new redis session backend + /// + /// * `addr` - address of the redis server + pub fn new<S: Into<String>>(addr: S, key: &[u8]) -> RedisSession { + RedisSession(Rc::new(Inner { + key: Key::derive_from(key), + cache_keygen: Box::new(|key: &str| format!("session:{}", &key)), + ttl: "7200".to_owned(), + addr: RedisActor::start(addr), + name: "actix-session".to_owned(), + path: "/".to_owned(), + domain: None, + secure: false, + max_age: Some(Duration::days(7)), + same_site: None, + http_only: Some(true), + })) + } + + /// Set time to live in seconds for session value + pub fn ttl(mut self, ttl: u32) -> Self { + Rc::get_mut(&mut self.0).unwrap().ttl = format!("{}", ttl); + self + } + + /// Set custom cookie name for session id + pub fn cookie_name(mut self, name: &str) -> Self { + Rc::get_mut(&mut self.0).unwrap().name = name.to_owned(); + self + } + + /// Set custom cookie path + pub fn cookie_path(mut self, path: &str) -> Self { + Rc::get_mut(&mut self.0).unwrap().path = path.to_owned(); + self + } + + /// Set custom cookie domain + pub fn cookie_domain(mut self, domain: &str) -> Self { + Rc::get_mut(&mut self.0).unwrap().domain = Some(domain.to_owned()); + self + } + + /// Set custom cookie secure + /// If the `secure` field is set, a cookie will only be transmitted when the + /// connection is secure - i.e. `https` + pub fn cookie_secure(mut self, secure: bool) -> Self { + Rc::get_mut(&mut self.0).unwrap().secure = secure; + self + } + + /// Set custom cookie max-age + pub fn cookie_max_age(mut self, max_age: Duration) -> Self { + Rc::get_mut(&mut self.0).unwrap().max_age = Some(max_age); + self + } + + /// Set custom cookie SameSite + pub fn cookie_same_site(mut self, same_site: SameSite) -> Self { + Rc::get_mut(&mut self.0).unwrap().same_site = Some(same_site); + self + } + + /// Set custom cookie HttpOnly policy + pub fn cookie_http_only(mut self, http_only: bool) -> Self { + Rc::get_mut(&mut self.0).unwrap().http_only = Some(http_only); + self + } + + /// Set a custom cache key generation strategy, expecting session key as input + pub fn cache_keygen(mut self, keygen: Box<dyn Fn(&str) -> String>) -> Self { + Rc::get_mut(&mut self.0).unwrap().cache_keygen = keygen; + self + } +} + +impl<S, B> Transform<S> for RedisSession +where + S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error> + + 'static, + S::Future: 'static, + B: 'static, +{ + type Request = ServiceRequest; + type Response = ServiceResponse<B>; + type Error = S::Error; + type InitError = (); + type Transform = RedisSessionMiddleware<S>; + type Future = Ready<Result<Self::Transform, Self::InitError>>; + + fn new_transform(&self, service: S) -> Self::Future { + ok(RedisSessionMiddleware { + service: Rc::new(RefCell::new(service)), + inner: self.0.clone(), + }) + } +} + +/// Cookie session middleware +pub struct RedisSessionMiddleware<S: 'static> { + service: Rc<RefCell<S>>, + inner: Rc<Inner>, +} + +impl<S, B> Service for RedisSessionMiddleware<S> +where + S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error> + + 'static, + S::Future: 'static, + B: 'static, +{ + type Request = ServiceRequest; + type Response = ServiceResponse<B>; + type Error = Error; + #[allow(clippy::type_complexity)] + type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>; + + fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { + self.service.borrow_mut().poll_ready(cx) + } + + fn call(&mut self, mut req: ServiceRequest) -> Self::Future { + let mut srv = self.service.clone(); + let inner = self.inner.clone(); + + Box::pin(async move { + let state = inner.load(&req).await?; + let value = if let Some((state, value)) = state { + Session::set_session(state.into_iter(), &mut req); + Some(value) + } else { + None + }; + + let mut res = srv.call(req).await?; + + match Session::get_changes(&mut res) { + (SessionStatus::Unchanged, None) => Ok(res), + (SessionStatus::Unchanged, Some(state)) => { + if value.is_none() { + // implies the session is new + inner.update(res, state, value).await + } else { + Ok(res) + } + } + (SessionStatus::Changed, Some(state)) => { + inner.update(res, state, value).await + } + (SessionStatus::Purged, Some(_)) => { + if let Some(val) = value { + inner.clear_cache(val).await?; + match inner.remove_cookie(&mut res) { + Ok(_) => Ok(res), + Err(_err) => Err(error::ErrorInternalServerError(_err)), + } + } else { + Err(error::ErrorInternalServerError("unexpected")) + } + } + (SessionStatus::Renewed, Some(state)) => { + if let Some(val) = value { + inner.clear_cache(val).await?; + inner.update(res, state, None).await + } else { + inner.update(res, state, None).await + } + } + (_, None) => unreachable!(), + } + }) + } +} + +struct Inner { + key: Key, + cache_keygen: Box<dyn Fn(&str) -> String>, + ttl: String, + addr: Addr<RedisActor>, + name: String, + path: String, + domain: Option<String>, + secure: bool, + max_age: Option<Duration>, + same_site: Option<SameSite>, + http_only: Option<bool>, +} + +impl Inner { + async fn load( + &self, + req: &ServiceRequest, + ) -> Result<Option<(HashMap<String, String>, String)>, Error> { + if let Ok(cookies) = req.cookies() { + for cookie in cookies.iter() { + if cookie.name() == self.name { + let mut jar = CookieJar::new(); + jar.add_original(cookie.clone()); + if let Some(cookie) = jar.signed(&self.key).get(&self.name) { + let value = cookie.value().to_owned(); + let cachekey = (self.cache_keygen)(&cookie.value()); + return match self + .addr + .send(Command(resp_array!["GET", cachekey])) + .await + { + Err(e) => Err(Error::from(e)), + Ok(res) => match res { + Ok(val) => { + match val { + RespValue::Error(err) => { + return Err( + error::ErrorInternalServerError(err), + ); + } + RespValue::SimpleString(s) => { + if let Ok(val) = serde_json::from_str(&s) { + return Ok(Some((val, value))); + } + } + RespValue::BulkString(s) => { + if let Ok(val) = serde_json::from_slice(&s) { + return Ok(Some((val, value))); + } + } + _ => (), + } + Ok(None) + } + Err(err) => Err(error::ErrorInternalServerError(err)), + }, + }; + } else { + return Ok(None); + } + } + } + } + Ok(None) + } + + async fn update<B>( + &self, + mut res: ServiceResponse<B>, + state: impl Iterator<Item = (String, String)>, + value: Option<String>, + ) -> Result<ServiceResponse<B>, Error> { + let (value, jar) = if let Some(value) = value { + (value, None) + } else { + let value: String = iter::repeat(()) + .map(|()| OsRng.sample(Alphanumeric)) + .take(32) + .collect(); + + // prepare session id cookie + let mut cookie = Cookie::new(self.name.clone(), value.clone()); + cookie.set_path(self.path.clone()); + cookie.set_secure(self.secure); + cookie.set_http_only(self.http_only.unwrap_or(true)); + + if let Some(ref domain) = self.domain { + cookie.set_domain(domain.clone()); + } + + if let Some(max_age) = self.max_age { + cookie.set_max_age(max_age); + } + + if let Some(same_site) = self.same_site { + cookie.set_same_site(same_site); + } + + // set cookie + let mut jar = CookieJar::new(); + jar.signed(&self.key).add(cookie); + + (value, Some(jar)) + }; + + let cachekey = (self.cache_keygen)(&value); + + let state: HashMap<_, _> = state.collect(); + match serde_json::to_string(&state) { + Err(e) => Err(e.into()), + Ok(body) => { + match self + .addr + .send(Command(resp_array!["SET", cachekey, body, "EX", &self.ttl])) + .await + { + Err(e) => Err(Error::from(e)), + Ok(redis_result) => match redis_result { + Ok(_) => { + if let Some(jar) = jar { + for cookie in jar.delta() { + let val = + HeaderValue::from_str(&cookie.to_string())?; + res.headers_mut().append(header::SET_COOKIE, val); + } + } + Ok(res) + } + Err(err) => Err(error::ErrorInternalServerError(err)), + }, + } + } + } + } + + /// removes cache entry + async fn clear_cache(&self, key: String) -> Result<(), Error> { + let cachekey = (self.cache_keygen)(&key); + + match self.addr.send(Command(resp_array!["DEL", cachekey])).await { + Err(e) => Err(Error::from(e)), + Ok(res) => { + match res { + // redis responds with number of deleted records + Ok(RespValue::Integer(x)) if x > 0 => Ok(()), + _ => Err(error::ErrorInternalServerError( + "failed to remove session from cache", + )), + } + } + } + } + + /// invalidates session cookie + fn remove_cookie<B>(&self, res: &mut ServiceResponse<B>) -> Result<(), Error> { + let mut cookie = Cookie::named(self.name.clone()); + cookie.set_value(""); + cookie.set_max_age(Duration::zero()); + cookie.set_expires(OffsetDateTime::now_utc() - Duration::days(365)); + + let val = HeaderValue::from_str(&cookie.to_string()) + .map_err(error::ErrorInternalServerError)?; + res.headers_mut().append(header::SET_COOKIE, val); + + Ok(()) + } +} + +#[cfg(test)] +mod test { + use super::*; + use actix_session::Session; + use actix_web::{ + middleware, test, web, + web::{get, post, resource}, + App, HttpResponse, Result, + }; + use serde::{Deserialize, Serialize}; + use serde_json::json; + + #[derive(Serialize, Deserialize, Debug, PartialEq)] + pub struct IndexResponse { + user_id: Option<String>, + counter: i32, + } + + async fn index(session: Session) -> Result<HttpResponse> { + let user_id: Option<String> = session.get::<String>("user_id").unwrap(); + let counter: i32 = session + .get::<i32>("counter") + .unwrap_or(Some(0)) + .unwrap_or(0); + + Ok(HttpResponse::Ok().json(IndexResponse { user_id, counter })) + } + + async fn do_something(session: Session) -> Result<HttpResponse> { + let user_id: Option<String> = session.get::<String>("user_id").unwrap(); + let counter: i32 = session + .get::<i32>("counter") + .unwrap_or(Some(0)) + .map_or(1, |inner| inner + 1); + session.set("counter", counter)?; + + Ok(HttpResponse::Ok().json(IndexResponse { user_id, counter })) + } + + #[derive(Deserialize)] + struct Identity { + user_id: String, + } + + async fn login( + user_id: web::Json<Identity>, + session: Session, + ) -> Result<HttpResponse> { + let id = user_id.into_inner().user_id; + session.set("user_id", &id)?; + session.renew(); + + let counter: i32 = session + .get::<i32>("counter") + .unwrap_or(Some(0)) + .unwrap_or(0); + + Ok(HttpResponse::Ok().json(IndexResponse { + user_id: Some(id), + counter, + })) + } + + async fn logout(session: Session) -> Result<HttpResponse> { + let id: Option<String> = session.get("user_id")?; + if let Some(x) = id { + session.purge(); + Ok(format!("Logged out: {}", x).into()) + } else { + Ok("Could not log out anonymous user".into()) + } + } + + #[actix_rt::test] + async fn test_workflow() { + // Step 1: GET index + // - set-cookie actix-session will be in response (session cookie #1) + // - response should be: {"counter": 0, "user_id": None} + // Step 2: GET index, including session cookie #1 in request + // - set-cookie will *not* be in response + // - response should be: {"counter": 0, "user_id": None} + // Step 3: POST to do_something, including session cookie #1 in request + // - adds new session state in redis: {"counter": 1} + // - response should be: {"counter": 1, "user_id": None} + // Step 4: POST again to do_something, including session cookie #1 in request + // - updates session state in redis: {"counter": 2} + // - response should be: {"counter": 2, "user_id": None} + // Step 5: POST to login, including session cookie #1 in request + // - set-cookie actix-session will be in response (session cookie #2) + // - updates session state in redis: {"counter": 2, "user_id": "ferris"} + // Step 6: GET index, including session cookie #2 in request + // - response should be: {"counter": 2, "user_id": "ferris"} + // Step 7: POST again to do_something, including session cookie #2 in request + // - updates session state in redis: {"counter": 3, "user_id": "ferris"} + // - response should be: {"counter": 2, "user_id": None} + // Step 8: GET index, including session cookie #1 in request + // - set-cookie actix-session will be in response (session cookie #3) + // - response should be: {"counter": 0, "user_id": None} + // Step 9: POST to logout, including session cookie #2 + // - set-cookie actix-session will be in response with session cookie #2 + // invalidation logic + // Step 10: GET index, including session cookie #2 in request + // - set-cookie actix-session will be in response (session cookie #3) + // - response should be: {"counter": 0, "user_id": None} + + let srv = test::start(|| { + App::new() + .wrap( + RedisSession::new("127.0.0.1:6379", &[0; 32]) + .cookie_name("test-session"), + ) + .wrap(middleware::Logger::default()) + .service(resource("/").route(get().to(index))) + .service(resource("/do_something").route(post().to(do_something))) + .service(resource("/login").route(post().to(login))) + .service(resource("/logout").route(post().to(logout))) + }); + + // Step 1: GET index + // - set-cookie actix-session will be in response (session cookie #1) + // - response should be: {"counter": 0, "user_id": None} + let req_1a = srv.get("/").send(); + let mut resp_1 = req_1a.await.unwrap(); + let cookie_1 = resp_1 + .cookies() + .unwrap() + .clone() + .into_iter() + .find(|c| c.name() == "test-session") + .unwrap(); + let result_1 = resp_1.json::<IndexResponse>().await.unwrap(); + assert_eq!( + result_1, + IndexResponse { + user_id: None, + counter: 0 + } + ); + + // Step 2: GET index, including session cookie #1 in request + // - set-cookie will *not* be in response + // - response should be: {"counter": 0, "user_id": None} + let req_2 = srv.get("/").cookie(cookie_1.clone()).send(); + let resp_2 = req_2.await.unwrap(); + let cookie_2 = resp_2 + .cookies() + .unwrap() + .clone() + .into_iter() + .find(|c| c.name() == "test-session"); + assert_eq!(cookie_2, None); + + // Step 3: POST to do_something, including session cookie #1 in request + // - adds new session state in redis: {"counter": 1} + // - response should be: {"counter": 1, "user_id": None} + let req_3 = srv.post("/do_something").cookie(cookie_1.clone()).send(); + let mut resp_3 = req_3.await.unwrap(); + let result_3 = resp_3.json::<IndexResponse>().await.unwrap(); + assert_eq!( + result_3, + IndexResponse { + user_id: None, + counter: 1 + } + ); + + // Step 4: POST again to do_something, including session cookie #1 in request + // - updates session state in redis: {"counter": 2} + // - response should be: {"counter": 2, "user_id": None} + let req_4 = srv.post("/do_something").cookie(cookie_1.clone()).send(); + let mut resp_4 = req_4.await.unwrap(); + let result_4 = resp_4.json::<IndexResponse>().await.unwrap(); + assert_eq!( + result_4, + IndexResponse { + user_id: None, + counter: 2 + } + ); + + // Step 5: POST to login, including session cookie #1 in request + // - set-cookie actix-session will be in response (session cookie #2) + // - updates session state in redis: {"counter": 2, "user_id": "ferris"} + let req_5 = srv + .post("/login") + .cookie(cookie_1.clone()) + .send_json(&json!({"user_id": "ferris"})); + let mut resp_5 = req_5.await.unwrap(); + let cookie_2 = resp_5 + .cookies() + .unwrap() + .clone() + .into_iter() + .find(|c| c.name() == "test-session") + .unwrap(); + assert_ne!(cookie_1.value(), cookie_2.value()); + + let result_5 = resp_5.json::<IndexResponse>().await.unwrap(); + assert_eq!( + result_5, + IndexResponse { + user_id: Some("ferris".into()), + counter: 2 + } + ); + + // Step 6: GET index, including session cookie #2 in request + // - response should be: {"counter": 2, "user_id": "ferris"} + let req_6 = srv.get("/").cookie(cookie_2.clone()).send(); + let mut resp_6 = req_6.await.unwrap(); + let result_6 = resp_6.json::<IndexResponse>().await.unwrap(); + assert_eq!( + result_6, + IndexResponse { + user_id: Some("ferris".into()), + counter: 2 + } + ); + + // Step 7: POST again to do_something, including session cookie #2 in request + // - updates session state in redis: {"counter": 3, "user_id": "ferris"} + // - response should be: {"counter": 2, "user_id": None} + let req_7 = srv.post("/do_something").cookie(cookie_2.clone()).send(); + let mut resp_7 = req_7.await.unwrap(); + let result_7 = resp_7.json::<IndexResponse>().await.unwrap(); + assert_eq!( + result_7, + IndexResponse { + user_id: Some("ferris".into()), + counter: 3 + } + ); + + // Step 8: GET index, including session cookie #1 in request + // - set-cookie actix-session will be in response (session cookie #3) + // - response should be: {"counter": 0, "user_id": None} + let req_8 = srv.get("/").cookie(cookie_1.clone()).send(); + let mut resp_8 = req_8.await.unwrap(); + let cookie_3 = resp_8 + .cookies() + .unwrap() + .clone() + .into_iter() + .find(|c| c.name() == "test-session") + .unwrap(); + let result_8 = resp_8.json::<IndexResponse>().await.unwrap(); + assert_eq!( + result_8, + IndexResponse { + user_id: None, + counter: 0 + } + ); + assert_ne!(cookie_3.value(), cookie_2.value()); + + // Step 9: POST to logout, including session cookie #2 + // - set-cookie actix-session will be in response with session cookie #2 + // invalidation logic + let req_9 = srv.post("/logout").cookie(cookie_2.clone()).send(); + let resp_9 = req_9.await.unwrap(); + let cookie_4 = resp_9 + .cookies() + .unwrap() + .clone() + .into_iter() + .find(|c| c.name() == "test-session") + .unwrap(); + assert_ne!( + OffsetDateTime::now_utc().year(), + cookie_4.expires().map(|t| t.year()).unwrap() + ); + + // Step 10: GET index, including session cookie #2 in request + // - set-cookie actix-session will be in response (session cookie #3) + // - response should be: {"counter": 0, "user_id": None} + let req_10 = srv.get("/").cookie(cookie_2.clone()).send(); + let mut resp_10 = req_10.await.unwrap(); + let result_10 = resp_10.json::<IndexResponse>().await.unwrap(); + assert_eq!( + result_10, + IndexResponse { + user_id: None, + counter: 0 + } + ); + + let cookie_5 = resp_10 + .cookies() + .unwrap() + .clone() + .into_iter() + .find(|c| c.name() == "test-session") + .unwrap(); + assert_ne!(cookie_5.value(), cookie_2.value()); + } +} +