Update to service-0.4

Author: fafhrd91

CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [0.4.0-alpha.0] - 2022-xx-xx
+
+* Upgrade to ntex-service-0.4
+
 ## [0.3.3] - 2022-07-07
 
 * pubsub support #5

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-redis"
-version = "0.3.3"
+version = "0.4.0-alpha.0"
 authors = ["ntex contributors <[email protected]>"]
 description = "Redis client"
 documentation = "https://docs.rs/ntex-redis"
@@ -12,13 +12,23 @@ exclude = [".gitignore", ".travis.yml", ".cargo/config"]
 edition = "2018"
 
 [dependencies]
-ntex = "0.5.15"
+ntex = "0.6.0-alpha.0"
 itoa = "1.0.0"
 btoi = "0.4.2"
 log = "0.4"
 derive_more = "0.99"
 
 [dev-dependencies]
 rand = "0.8"
-env_logger = "0.9"
-ntex = { version = "0.5", features = ["tokio"] }
+env_logger = "0.10"
+ntex = { version = "0.6.0-alpha.0", features = ["tokio"] }
+
+[patch.crates-io]
+ntex = { git = "https://github.com/ntex-rs/ntex.git", branch = "service-0-4" }
+ntex-connect = { git = "https://github.com/ntex-rs/ntex.git", branch = "service-0-4" }
+ntex-io = { git = "https://github.com/ntex-rs/ntex.git", branch = "service-0-4" }
+ntex-service = { git = "https://github.com/ntex-rs/ntex.git", branch = "service-0-4" }
+ntex-util = { git = "https://github.com/ntex-rs/ntex.git", branch = "service-0-4" }
+ntex-tls = { git = "https://github.com/ntex-rs/ntex.git", branch = "service-0-4" }
+ntex-tokio = { git = "https://github.com/ntex-rs/ntex.git", branch = "service-0-4" }
+ntex-h2 = { git = "https://github.com/ntex-rs/ntex-h2.git", branch = "service-0-4" }

src/client.rs

@@ -110,7 +110,7 @@ impl Client {
 impl Service<Request> for Client {
     type Response = Response;
     type Error = Error;
-    type Future = Either<CommandResult, Ready<Response, Error>>;
+    type Future<'f> = Either<CommandResult, Ready<Response, Error>>;
 
     fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         if self.disconnect.poll_ready(cx).is_ready() {
@@ -120,7 +120,7 @@ impl Service<Request> for Client {
         }
     }
 
-    fn call(&self, req: Request) -> Self::Future {
+    fn call(&self, req: Request) -> Self::Future<'_> {
         if let Err(e) = self.io.encode(req, &Codec) {
             Either::Right(Ready::Err(e))
         } else {

src/connector.rs

@@ -1,5 +1,3 @@
-use std::future::Future;
-
 use ntex::connect::{self, Address, Connect, Connector};
 use ntex::io::IoBoxed;
 use ntex::{service::Service, time::Seconds, util::ByteString, util::PoolId, util::PoolRef};
@@ -75,40 +73,33 @@ where
     T: Service<Connect<A>, Error = connect::ConnectError>,
     IoBoxed: From<T::Response>,
 {
-    fn _connect(&self) -> impl Future<Output = Result<IoBoxed, ConnectError>> {
-        let pool = self.pool;
-        let passwords = self.passwords.clone();
+    async fn _connect(&self) -> Result<IoBoxed, ConnectError> {
         let fut = self.connector.call(Connect::new(self.address.clone()));
+        let io = IoBoxed::from(fut.await?);
+        io.set_memory_pool(self.pool);
+        io.set_disconnect_timeout(Seconds::ZERO.into());
 
-        async move {
-            let io = IoBoxed::from(fut.await?);
-            io.set_memory_pool(pool);
-            io.set_disconnect_timeout(Seconds::ZERO.into());
-
-            if passwords.is_empty() {
-                Ok(io)
-            } else {
-                let client = SimpleClient::new(io);
+        if self.passwords.is_empty() {
+            Ok(io)
+        } else {
+            let client = SimpleClient::new(io);
 
-                for password in passwords {
-                    if client.exec(cmd::Auth(password)).await? {
-                        return Ok(client.into_inner());
-                    }
+            for password in &self.passwords {
+                if client.exec(cmd::Auth(password)).await? {
+                    return Ok(client.into_inner());
                 }
-                Err(ConnectError::Unauthorized)
             }
+            Err(ConnectError::Unauthorized)
         }
     }
 
     /// Connect to redis server and create shared client
-    pub fn connect(&self) -> impl Future<Output = Result<Client, ConnectError>> {
-        let fut = self._connect();
-        async move { fut.await.map(Client::new) }
+    pub async fn connect(&self) -> Result<Client, ConnectError> {
+        self._connect().await.map(Client::new)
     }
 
     /// Connect to redis server and create simple client
-    pub fn connect_simple(&self) -> impl Future<Output = Result<SimpleClient, ConnectError>> {
-        let fut = self._connect();
-        async move { fut.await.map(SimpleClient::new) }
+    pub async fn connect_simple(&self) -> Result<SimpleClient, ConnectError> {
+        self._connect().await.map(SimpleClient::new)
     }
 }