Agregate Glide-specific connection params into a struct

Author: ikolomi

redis/examples/async-await.rs

@@ -1,10 +1,12 @@
 #![allow(unknown_lints, dependency_on_unit_never_type_fallback)]
-use redis::AsyncCommands;
+use redis::{AsyncCommands, GlideConnectionOptions};
 
 #[tokio::main]
 async fn main() -> redis::RedisResult<()> {
     let client = redis::Client::open("redis://127.0.0.1/").unwrap();
-    let mut con = client.get_multiplexed_async_connection(None, None).await?;
+    let mut con = client
+        .get_multiplexed_async_connection(GlideConnectionOptions::default())
+        .await?;
 
     con.set("key1", b"foo").await?;
 

redis/examples/async-connection-loss.rs

@@ -13,6 +13,7 @@ use std::time::Duration;
 
 use futures::future;
 use redis::aio::ConnectionLike;
+use redis::GlideConnectionOptions;
 use redis::RedisResult;
 use tokio::time::interval;
 
@@ -81,7 +82,12 @@ async fn main() -> RedisResult<()> {
     let client = redis::Client::open("redis://127.0.0.1/").unwrap();
     match mode {
         Mode::Default => {
-            run_multi(client.get_multiplexed_tokio_connection(None, None).await?).await?
+            run_multi(
+                client
+                    .get_multiplexed_tokio_connection(GlideConnectionOptions::default())
+                    .await?,
+            )
+            .await?
         }
         Mode::Reconnect => run_multi(client.get_connection_manager().await?).await?,
         #[allow(deprecated)]

redis/examples/async-multiplexed.rs

@@ -1,6 +1,6 @@
 #![allow(unknown_lints, dependency_on_unit_never_type_fallback)]
 use futures::prelude::*;
-use redis::{aio::MultiplexedConnection, RedisResult};
+use redis::{aio::MultiplexedConnection, GlideConnectionOptions, RedisResult};
 
 async fn test_cmd(con: &MultiplexedConnection, i: i32) -> RedisResult<()> {
     let mut con = con.clone();
@@ -35,7 +35,7 @@ async fn main() {
     let client = redis::Client::open("redis://127.0.0.1/").unwrap();
 
     let con = client
-        .get_multiplexed_tokio_connection(None, None)
+        .get_multiplexed_tokio_connection(GlideConnectionOptions::default())
         .await
         .unwrap();
 

redis/examples/async-pub-sub.rs

@@ -1,11 +1,13 @@
 #![allow(unknown_lints, dependency_on_unit_never_type_fallback)]
 use futures_util::StreamExt as _;
-use redis::AsyncCommands;
+use redis::{AsyncCommands, GlideConnectionOptions};
 
 #[tokio::main]
 async fn main() -> redis::RedisResult<()> {
     let client = redis::Client::open("redis://127.0.0.1/").unwrap();
-    let mut publish_conn = client.get_multiplexed_async_connection(None, None).await?;
+    let mut publish_conn = client
+        .get_multiplexed_async_connection(GlideConnectionOptions::default())
+        .await?;
     let mut pubsub_conn = client.get_async_pubsub().await?;
 
     pubsub_conn.subscribe("wavephone").await?;

redis/examples/async-scan.rs

@@ -1,11 +1,13 @@
 #![allow(unknown_lints, dependency_on_unit_never_type_fallback)]
 use futures::stream::StreamExt;
-use redis::{AsyncCommands, AsyncIter};
+use redis::{AsyncCommands, AsyncIter, GlideConnectionOptions};
 
 #[tokio::main]
 async fn main() -> redis::RedisResult<()> {
     let client = redis::Client::open("redis://127.0.0.1/").unwrap();
-    let mut con = client.get_multiplexed_async_connection(None, None).await?;
+    let mut con = client
+        .get_multiplexed_async_connection(GlideConnectionOptions::default())
+        .await?;
 
     con.set("async-key1", b"foo").await?;
     con.set("async-key2", b"foo").await?;

redis/src/aio/connection_manager.rs

@@ -1,4 +1,5 @@
 use super::RedisFuture;
+use crate::client::GlideConnectionOptions;
 use crate::cmd::Cmd;
 use crate::push_manager::PushManager;
 use crate::types::{RedisError, RedisResult, Value};
@@ -195,8 +196,7 @@ impl ConnectionManager {
             client.get_multiplexed_async_connection_with_timeouts(
                 response_timeout,
                 connection_timeout,
-                None,
-                None,
+                GlideConnectionOptions::default(),
             )
         })
         .await

redis/src/aio/multiplexed_connection.rs

@@ -1,12 +1,13 @@
 use super::{ConnectionLike, Runtime};
 use crate::aio::setup_connection;
 use crate::aio::DisconnectNotifier;
+use crate::client::GlideConnectionOptions;
 use crate::cmd::Cmd;
 #[cfg(any(feature = "tokio-comp", feature = "async-std-comp"))]
 use crate::parser::ValueCodec;
 use crate::push_manager::PushManager;
 use crate::types::{RedisError, RedisFuture, RedisResult, Value};
-use crate::{cmd, ConnectionInfo, ProtocolVersion, PushInfo, PushKind};
+use crate::{cmd, ConnectionInfo, ProtocolVersion, PushKind};
 use ::tokio::{
     io::{AsyncRead, AsyncWrite},
     sync::{mpsc, oneshot},
@@ -416,8 +417,7 @@ impl MultiplexedConnection {
     pub async fn new<C>(
         connection_info: &ConnectionInfo,
         stream: C,
-        push_sender: Option<mpsc::UnboundedSender<PushInfo>>,
-        disconnect_notifier: Option<Box<dyn DisconnectNotifier>>,
+        glide_connection_options: GlideConnectionOptions,
     ) -> RedisResult<(Self, impl Future<Output = ()>)>
     where
         C: Unpin + AsyncRead + AsyncWrite + Send + 'static,
@@ -426,8 +426,7 @@ impl MultiplexedConnection {
             connection_info,
             stream,
             std::time::Duration::MAX,
-            push_sender,
-            disconnect_notifier,
+            glide_connection_options,
         )
         .await
     }
@@ -438,8 +437,7 @@ impl MultiplexedConnection {
         connection_info: &ConnectionInfo,
         stream: C,
         response_timeout: std::time::Duration,
-        push_sender: Option<mpsc::UnboundedSender<PushInfo>>,
-        disconnect_notifier: Option<Box<dyn DisconnectNotifier>>,
+        glide_connection_options: GlideConnectionOptions,
     ) -> RedisResult<(Self, impl Future<Output = ()>)>
     where
         C: Unpin + AsyncRead + AsyncWrite + Send + 'static,
@@ -457,10 +455,11 @@ impl MultiplexedConnection {
         let codec = ValueCodec::default()
             .framed(stream)
             .and_then(|msg| async move { msg });
-        let (mut pipeline, driver) = Pipeline::new(codec, disconnect_notifier);
+        let (mut pipeline, driver) =
+            Pipeline::new(codec, glide_connection_options.disconnect_notifier);
         let driver = boxed(driver);
         let pm = PushManager::default();
-        if let Some(sender) = push_sender {
+        if let Some(sender) = glide_connection_options.push_sender {
             pm.replace_sender(sender);
         }