remove unessecrry az return type

Adar Ovadia · Adar Ovadia · commit 938a1eea29b8 · 2024-11-17T12:27:10.000Z
Signed-off-by: Adar Ovadia &lt;adarov@amazon.com&gt;
diff --git a/glide-core/redis-rs/redis/src/aio/connection.rs b/glide-core/redis-rs/redis/src/aio/connection.rs
@@ -411,14 +411,13 @@ where
 pub(crate) async fn connect_simple<T: RedisRuntime>(
     connection_info: &ConnectionInfo,
     _socket_addr: Option<SocketAddr>,
-) -> RedisResult<(T, Option<IpAddr>, Option<String>)> {
+) -> RedisResult<(T, Option<IpAddr>)> {
     Ok(match connection_info.addr {
         ConnectionAddr::Tcp(ref host, port) => {
             if let Some(socket_addr) = _socket_addr {
                 return Ok::<_, RedisError>((
                     <T>::connect_tcp(socket_addr).await?,
                     Some(socket_addr.ip()),
-                    None,
                 ));
             }
             let socket_addrs = get_socket_addrs(host, port).await?;
@@ -428,7 +427,6 @@ pub(crate) async fn connect_simple<T: RedisRuntime>(
                     Ok::<_, RedisError>((
                         <T>::connect_tcp(socket_addr).await?,
                         Some(socket_addr.ip()),
-                        None,
                     ))
                 })
             }))
@@ -447,7 +445,6 @@ pub(crate) async fn connect_simple<T: RedisRuntime>(
                 return Ok::<_, RedisError>((
                     <T>::connect_tcp_tls(host, socket_addr, insecure, tls_params).await?,
                     Some(socket_addr.ip()),
-                    None,
                 ));
             }
             let socket_addrs = get_socket_addrs(host, port).await?;
@@ -461,7 +458,6 @@ pub(crate) async fn connect_simple<T: RedisRuntime>(
                     Ok::<_, RedisError>((
                         <T>::connect_tcp_tls(host, socket_addr, insecure, tls_params).await?,
                         Some(socket_addr.ip()),
-                        None,
                     ))
                 })
             }))
@@ -480,7 +476,7 @@ pub(crate) async fn connect_simple<T: RedisRuntime>(
         #[cfg(unix)]
         ConnectionAddr::Unix(ref path) => {
             log_conn_creation("UDS", path, None);
-            (<T>::connect_unix(path).await?, None, None)
+            (<T>::connect_unix(path).await?, None)
         }
 
         #[cfg(not(unix))]
diff --git a/glide-core/redis-rs/redis/src/client.rs b/glide-core/redis-rs/redis/src/client.rs
@@ -105,7 +105,7 @@ impl Client {
         &self,
         _push_sender: Option<mpsc::UnboundedSender<PushInfo>>,
     ) -> RedisResult<crate::aio::Connection> {
-        let (con, _ip, _az) = match Runtime::locate() {
+        let (con, _ip) = match Runtime::locate() {
             #[cfg(feature = "tokio-comp")]
             Runtime::Tokio => {
                 self.get_simple_async_connection::<crate::aio::tokio::Tokio>(None)
@@ -160,21 +160,17 @@ impl Client {
             Ok(Err(e)) => Err(e),
             Err(elapsed) => Err(elapsed.into()),
         }
-        .map(|(conn, _ip, _az)| conn)
+        .map(|(conn, _ip)| conn)
     }
 
-    /// For TCP connections: returns (async connection, Some(the direct IP address, Some(az)))
-    /// For Unix connections, returns (async connection, None, None)
+    /// For TCP connections: returns (async connection, Some(the direct IP address))
+    /// For Unix connections, returns (async connection, None)
     #[cfg(feature = "tokio-comp")]
     #[cfg_attr(docsrs, doc(cfg(feature = "tokio-comp")))]
-    pub async fn get_multiplexed_async_connection_ip_and_az(
+    pub async fn get_multiplexed_async_connection_ip(
         &self,
         glide_connection_options: GlideConnectionOptions,
-    ) -> RedisResult<(
-        crate::aio::MultiplexedConnection,
-        Option<IpAddr>,
-        Option<String>,
-    )> {
+    ) -> RedisResult<(crate::aio::MultiplexedConnection, Option<IpAddr>)> {
         match Runtime::locate() {
             #[cfg(feature = "tokio-comp")]
             Runtime::Tokio => {
@@ -212,7 +208,7 @@ impl Client {
             .await;
 
         match result {
-            Ok(Ok((connection, _ip, _az))) => Ok(connection),
+            Ok(Ok((connection, _ip))) => Ok(connection),
             Ok(Err(e)) => Err(e),
             Err(elapsed) => Err(elapsed.into()),
         }
@@ -396,23 +392,19 @@ impl Client {
         response_timeout: std::time::Duration,
         socket_addr: Option<SocketAddr>,
         glide_connection_options: GlideConnectionOptions,
-    ) -> RedisResult<(
-        crate::aio::MultiplexedConnection,
-        Option<IpAddr>,
-        Option<String>,
-    )>
+    ) -> RedisResult<(crate::aio::MultiplexedConnection, Option<IpAddr>)>
     where
         T: crate::aio::RedisRuntime,
     {
-        let (connection, driver, ip, az) = self
+        let (connection, driver, ip) = self
             .create_multiplexed_async_connection_inner::<T>(
                 response_timeout,
                 socket_addr,
                 glide_connection_options,
             )
             .await?;
         T::spawn(driver);
-        Ok((connection, ip, az))
+        Ok((connection, ip))
     }
 
     async fn create_multiplexed_async_connection_inner<T>(
@@ -424,20 +416,19 @@ impl Client {
         crate::aio::MultiplexedConnection,
         impl std::future::Future<Output = ()>,
         Option<IpAddr>,
-        Option<String>,
     )>
     where
         T: crate::aio::RedisRuntime,
     {
-        let (con, ip, az) = self.get_simple_async_connection::<T>(socket_addr).await?;
+        let (con, ip) = self.get_simple_async_connection::<T>(socket_addr).await?;
         crate::aio::MultiplexedConnection::new_with_response_timeout(
             &self.connection_info,
             con,
             response_timeout,
             glide_connection_options,
         )
         .await
-        .map(|res| (res.0, res.1, ip, az))
+        .map(|res| (res.0, res.1, ip))
     }
 
     async fn get_simple_async_connection<T>(
@@ -446,14 +437,13 @@ impl Client {
     ) -> RedisResult<(
         Pin<Box<dyn crate::aio::AsyncStream + Send + Sync>>,
         Option<IpAddr>,
-        Option<String>,
     )>
     where
         T: crate::aio::RedisRuntime,
     {
-        let (conn, ip, az) =
+        let (conn, ip) =
             crate::aio::connect_simple::<T>(&self.connection_info, socket_addr).await?;
-        Ok((conn.boxed(), ip, az))
+        Ok((conn.boxed(), ip))
     }
 
     #[cfg(feature = "connection-manager")]
diff --git a/glide-core/redis-rs/redis/src/cluster_async/mod.rs b/glide-core/redis-rs/redis/src/cluster_async/mod.rs
@@ -2843,7 +2843,7 @@ pub trait Connect: Sized {
         connection_timeout: Duration,
         socket_addr: Option<SocketAddr>,
         glide_connection_options: GlideConnectionOptions,
-    ) -> RedisFuture<'a, (Self, Option<IpAddr>, Option<String>)>
+    ) -> RedisFuture<'a, (Self, Option<IpAddr>)>
     where
         T: IntoConnectionInfo + Send + 'a;
 }
@@ -2855,7 +2855,7 @@ impl Connect for MultiplexedConnection {
         connection_timeout: Duration,
         socket_addr: Option<SocketAddr>,
         glide_connection_options: GlideConnectionOptions,
-    ) -> RedisFuture<'a, (MultiplexedConnection, Option<IpAddr>, Option<String>)>
+    ) -> RedisFuture<'a, (MultiplexedConnection, Option<IpAddr>)>
     where
         T: IntoConnectionInfo + Send + 'a,
     {
diff --git a/glide-core/redis-rs/redis/tests/support/mock_cluster.rs b/glide-core/redis-rs/redis/tests/support/mock_cluster.rs
@@ -133,7 +133,7 @@ impl cluster_async::Connect for MockConnection {
         _connection_timeout: Duration,
         _socket_addr: Option<SocketAddr>,
         _glide_connection_options: GlideConnectionOptions,
-    ) -> RedisFuture<'a, (Self, Option<IpAddr>, Option<String>)>
+    ) -> RedisFuture<'a, (Self, Option<IpAddr>)>
     where
         T: IntoConnectionInfo + Send + 'a,
     {
@@ -180,7 +180,6 @@ impl cluster_async::Connect for MockConnection {
                 port,
             },
             ip,
-            None,
         )))
     }
 }
diff --git a/glide-core/redis-rs/redis/tests/test_cluster_async.rs b/glide-core/redis-rs/redis/tests/test_cluster_async.rs
@@ -724,20 +724,20 @@ mod cluster_async {
             connection_timeout: std::time::Duration,
             socket_addr: Option<SocketAddr>,
             glide_connection_options: GlideConnectionOptions,
-        ) -> RedisFuture<'a, (Self, Option<IpAddr>, Option<String>)>
+        ) -> RedisFuture<'a, (Self, Option<IpAddr>)>
         where
             T: IntoConnectionInfo + Send + 'a,
         {
             Box::pin(async move {
-                let (inner, _ip, _az) = MultiplexedConnection::connect(
+                let (inner, _ip) = MultiplexedConnection::connect(
                     info,
                     response_timeout,
                     connection_timeout,
                     socket_addr,
                     glide_connection_options,
                 )
                 .await?;
-                Ok((ErrorConnection { inner }, None, None))
+                Ok((ErrorConnection { inner }, None))
             })
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -133,7 +133,7 @@ impl cluster_async::Connect for MockConnection {`
`133`	`133`	`_connection_timeout: Duration,`
`134`	`134`	`_socket_addr: Option<SocketAddr>,`
`135`	`135`	`_glide_connection_options: GlideConnectionOptions,`
`136`		`- ) -> RedisFuture<'a, (Self, Option<IpAddr>, Option<String>)>`
	`136`	`+ ) -> RedisFuture<'a, (Self, Option<IpAddr>)>`
`137`	`137`	`where`
`138`	`138`	`T: IntoConnectionInfo + Send + 'a,`
`139`	`139`	`{`
`@@ -180,7 +180,6 @@ impl cluster_async::Connect for MockConnection {`
`180`	`180`	`port,`
`181`	`181`	`},`
`182`	`182`	`ip,`
`183`		`- None,`
`184`	`183`	`)))`
`185`	`184`	`}`
`186`	`185`	`}`
Original file line number	Diff line number	Diff line change
`@@ -724,20 +724,20 @@ mod cluster_async {`
`724`	`724`	`connection_timeout: std::time::Duration,`
`725`	`725`	`socket_addr: Option<SocketAddr>,`
`726`	`726`	`glide_connection_options: GlideConnectionOptions,`
`727`		`- ) -> RedisFuture<'a, (Self, Option<IpAddr>, Option<String>)>`
	`727`	`+ ) -> RedisFuture<'a, (Self, Option<IpAddr>)>`
`728`	`728`	`where`
`729`	`729`	`T: IntoConnectionInfo + Send + 'a,`
`730`	`730`	`{`
`731`	`731`	`Box::pin(async move {`
`732`		`- let (inner, _ip, _az) = MultiplexedConnection::connect(`
	`732`	`+ let (inner, _ip) = MultiplexedConnection::connect(`
`733`	`733`	`info,`
`734`	`734`	`response_timeout,`
`735`	`735`	`connection_timeout,`
`736`	`736`	`socket_addr,`
`737`	`737`	`glide_connection_options,`
`738`	`738`	`)`
`739`	`739`	`.await?;`
`740`		`- Ok((ErrorConnection { inner }, None, None))`
	`740`	`+ Ok((ErrorConnection { inner }, None))`
`741`	`741`	`})`
`742`	`742`	`}`
`743`	`743`	`}`