valkey-glide-sync 2.2.3__tar.gz → 2.2.5__tar.gz

{valkey_glide_sync-2.2.3 → valkey_glide_sync-2.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: valkey-glide-sync
-Version: 2.2.3
+Version: 2.2.5
 Summary: Valkey GLIDE Sync client. Supports Valkey and Redis OSS.
 License: Apache-2.0
 Classifier: Topic :: Database

{valkey_glide_sync-2.2.3 → valkey_glide_sync-2.2.5}/glide-core/redis-rs/redis/src/aio/connection.rs

@@ -419,12 +419,13 @@ where
 pub(crate) async fn connect_simple<T: RedisRuntime>(
     connection_info: &ConnectionInfo,
     _socket_addr: Option<SocketAddr>,
+    tcp_nodelay: bool,
 ) -> 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?,
+                    <T>::connect_tcp(socket_addr, tcp_nodelay).await?,
                     Some(socket_addr.ip()),
                 ));
             }
@@ -433,7 +434,7 @@ pub(crate) async fn connect_simple<T: RedisRuntime>(
                 log_conn_creation("TCP", format!("{host}:{port}"), Some(socket_addr.ip()));
                 Box::pin(async move {
                     Ok::<_, RedisError>((
-                        <T>::connect_tcp(socket_addr).await?,
+                        <T>::connect_tcp(socket_addr, tcp_nodelay).await?,
                         Some(socket_addr.ip()),
                     ))
                 })
@@ -450,7 +451,8 @@ pub(crate) async fn connect_simple<T: RedisRuntime>(
         } => {
             if let Some(socket_addr) = _socket_addr {
                 return Ok::<_, RedisError>((
-                    <T>::connect_tcp_tls(host, socket_addr, insecure, tls_params).await?,
+                    <T>::connect_tcp_tls(host, socket_addr, insecure, tls_params, tcp_nodelay)
+                        .await?,
                     Some(socket_addr.ip()),
                 ));
             }
@@ -463,7 +465,8 @@ pub(crate) async fn connect_simple<T: RedisRuntime>(
                 );
                 Box::pin(async move {
                     Ok::<_, RedisError>((
-                        <T>::connect_tcp_tls(host, socket_addr, insecure, tls_params).await?,
+                        <T>::connect_tcp_tls(host, socket_addr, insecure, tls_params, tcp_nodelay)
+                            .await?,
                         Some(socket_addr.ip()),
                     ))
                 })

{valkey_glide_sync-2.2.3 → valkey_glide_sync-2.2.5}/glide-core/redis-rs/redis/src/aio/mod.rs

@@ -29,7 +29,7 @@ pub mod tokio;
 #[async_trait]
 pub(crate) trait RedisRuntime: AsyncStream + Send + Sync + Sized + 'static {
     /// Performs a TCP connection
-    async fn connect_tcp(socket_addr: SocketAddr) -> RedisResult<Self>;
+    async fn connect_tcp(socket_addr: SocketAddr, tcp_nodelay: bool) -> RedisResult<Self>;
 
     // Performs a TCP TLS connection
     async fn connect_tcp_tls(
@@ -37,6 +37,7 @@ pub(crate) trait RedisRuntime: AsyncStream + Send + Sync + Sized + 'static {
         socket_addr: SocketAddr,
         insecure: bool,
         tls_params: &Option<TlsConnParams>,
+        tcp_nodelay: bool,
     ) -> RedisResult<Self>;
 
     /// Performs a UNIX connection

{valkey_glide_sync-2.2.3 → valkey_glide_sync-2.2.5}/glide-core/redis-rs/redis/src/aio/tokio.rs

@@ -25,8 +25,9 @@ use crate::tls::TlsConnParams;
 use super::Path;
 
 #[inline(always)]
-async fn connect_tcp(addr: &SocketAddr) -> io::Result<TcpStreamTokio> {
+async fn connect_tcp(addr: &SocketAddr, tcp_nodelay: bool) -> io::Result<TcpStreamTokio> {
     let socket = TcpStreamTokio::connect(addr).await?;
+    socket.set_nodelay(tcp_nodelay)?;
     #[cfg(feature = "keep-alive")]
     {
         //For now rely on system defaults
@@ -111,8 +112,10 @@ impl AsyncRead for Tokio {
 
 #[async_trait]
 impl RedisRuntime for Tokio {
-    async fn connect_tcp(socket_addr: SocketAddr) -> RedisResult<Self> {
-        Ok(connect_tcp(&socket_addr).await.map(Tokio::Tcp)?)
+    async fn connect_tcp(socket_addr: SocketAddr, tcp_nodelay: bool) -> RedisResult<Self> {
+        Ok(connect_tcp(&socket_addr, tcp_nodelay)
+            .await
+            .map(Tokio::Tcp)?)
     }
 
     async fn connect_tcp_tls(
@@ -120,6 +123,7 @@ impl RedisRuntime for Tokio {
         socket_addr: SocketAddr,
         insecure: bool,
         tls_params: &Option<TlsConnParams>,
+        tcp_nodelay: bool,
     ) -> RedisResult<Self> {
         let config = create_rustls_config(insecure, tls_params.clone())?;
         let tls_connector = TlsConnector::from(Arc::new(config));
@@ -127,7 +131,7 @@ impl RedisRuntime for Tokio {
         Ok(tls_connector
             .connect(
                 rustls_pki_types::ServerName::try_from(hostname)?.to_owned(),
-                connect_tcp(&socket_addr).await?,
+                connect_tcp(&socket_addr, tcp_nodelay).await?,
             )
             .await
             .map(|con| Tokio::TcpTls(Box::new(con)))?)

{valkey_glide_sync-2.2.3 → valkey_glide_sync-2.2.5}/glide-core/redis-rs/redis/src/client.rs

@@ -96,6 +96,9 @@ pub struct GlideConnectionOptions {
     pub connection_timeout: Option<Duration>,
     /// Retry strategy configuration for reconnect attempts.
     pub connection_retry_strategy: Option<RetryStrategy>,
+    /// TCP_NODELAY socket option. When true, disables Nagle's algorithm for lower latency.
+    /// When false, enables Nagle's algorithm to reduce network overhead.
+    pub tcp_nodelay: bool,
 }
 
 /// To enable async support you need to enable the feature: `tokio-comp`
@@ -115,7 +118,10 @@ impl Client {
         let (con, _ip) = match Runtime::locate() {
             #[cfg(feature = "tokio-comp")]
             Runtime::Tokio => {
-                self.get_simple_async_connection::<crate::aio::tokio::Tokio>(None)
+                // Note: tcp_nodelay is hardcoded to true (default) since this deprecated API
+                // doesn't accept GlideConnectionOptions. Modern code should use
+                // get_multiplexed_async_connection which allows configuring tcp_nodelay.
+                self.get_simple_async_connection::<crate::aio::tokio::Tokio>(None, true)
                     .await?
             }
         };
@@ -427,7 +433,9 @@ impl Client {
     where
         T: crate::aio::RedisRuntime,
     {
-        let (con, ip) = self.get_simple_async_connection::<T>(socket_addr).await?;
+        let (con, ip) = self
+            .get_simple_async_connection::<T>(socket_addr, glide_connection_options.tcp_nodelay)
+            .await?;
         crate::aio::MultiplexedConnection::new_with_response_timeout(
             &self.connection_info,
             con,
@@ -441,6 +449,7 @@ impl Client {
     async fn get_simple_async_connection<T>(
         &self,
         socket_addr: Option<SocketAddr>,
+        tcp_nodelay: bool,
     ) -> RedisResult<(
         Pin<Box<dyn crate::aio::AsyncStream + Send + Sync>>,
         Option<IpAddr>,
@@ -449,7 +458,8 @@ impl Client {
         T: crate::aio::RedisRuntime,
     {
         let (conn, ip) =
-            crate::aio::connect_simple::<T>(&self.connection_info, socket_addr).await?;
+            crate::aio::connect_simple::<T>(&self.connection_info, socket_addr, tcp_nodelay)
+                .await?;
         Ok((conn.boxed(), ip))
     }
 
@@ -519,11 +529,11 @@ impl Client {
     ///
     ///     let mut con = client.get_async_connection(None).await?;
     ///
-    ///     con.set("key1", b"foo").await?;
+    ///     con.set::<_, _, ()>("key1", b"foo").await?;
     ///
     ///     redis::cmd("SET")
     ///         .arg(&["key2", "bar"])
-    ///         .query_async(&mut con)
+    ///         .query_async::<_, ()>(&mut con)
     ///         .await?;
     ///
     ///     let result = redis::cmd("MGET")

{valkey_glide_sync-2.2.3 → valkey_glide_sync-2.2.5}/glide-core/redis-rs/redis/src/cluster_async/connections_logic.rs

@@ -193,6 +193,7 @@ where
             discover_az,
             connection_timeout: Some(params.connection_timeout),
             connection_retry_strategy: None,
+            tcp_nodelay: params.tcp_nodelay,
         },
     )
     .await

{valkey_glide_sync-2.2.3 → valkey_glide_sync-2.2.5}/glide-core/redis-rs/redis/src/cluster_async/mod.rs

@@ -1132,6 +1132,7 @@ where
             discover_az,
             connection_timeout: Some(cluster_params.connection_timeout),
             connection_retry_strategy: Some(connection_retry_strategy),
+            tcp_nodelay: cluster_params.tcp_nodelay,
         };
 
         let connections = Self::create_initial_connections(

{valkey_glide_sync-2.2.3 → valkey_glide_sync-2.2.5}/glide-core/redis-rs/redis/src/cluster_client.rs

@@ -47,6 +47,7 @@ struct BuilderParams {
     reconnect_retry_strategy: Option<RetryStrategy>,
     refresh_topology_from_initial_nodes: bool,
     database_id: i64,
+    tcp_nodelay: bool,
 }
 
 #[derive(Clone)]
@@ -150,6 +151,7 @@ pub struct ClusterParams {
     pub(crate) reconnect_retry_strategy: Option<RetryStrategy>,
     pub(crate) refresh_topology_from_initial_nodes: bool,
     pub(crate) database_id: i64,
+    pub(crate) tcp_nodelay: bool,
 }
 
 impl ClusterParams {
@@ -182,6 +184,7 @@ impl ClusterParams {
             reconnect_retry_strategy: value.reconnect_retry_strategy,
             refresh_topology_from_initial_nodes: value.refresh_topology_from_initial_nodes,
             database_id: value.database_id,
+            tcp_nodelay: value.tcp_nodelay,
         })
     }
 }
@@ -495,6 +498,16 @@ impl ClusterClientBuilder {
         self
     }
 
+    /// Sets the TCP_NODELAY socket option.
+    ///
+    /// When true, disables Nagle's algorithm for lower latency.
+    /// When false, enables Nagle's algorithm to reduce network overhead.
+    /// Defaults to true if not set.
+    pub fn tcp_nodelay(mut self, tcp_nodelay: bool) -> ClusterClientBuilder {
+        self.builder_params.tcp_nodelay = tcp_nodelay;
+        self
+    }
+
     /// Enables timing out on slow connection time.
     ///
     /// If enabled, the cluster will only wait the given time on each connection attempt to each node.

{valkey_glide_sync-2.2.3 → valkey_glide_sync-2.2.5}/glide-core/redis-rs/redis/src/cmd.rs

@@ -131,8 +131,8 @@ impl<'a, T: FromRedisValue + 'a + Unpin + Send> AsyncIter<'a, T> {
     /// # async fn scan_set() -> redis::RedisResult<()> {
     /// # let client = redis::Client::open("redis://127.0.0.1/")?;
     /// # let mut con = client.get_async_connection(None).await?;
-    /// con.sadd("my_set", 42i32).await?;
-    /// con.sadd("my_set", 43i32).await?;
+    /// con.sadd::<_, _, ()>("my_set", 42i32).await?;
+    /// con.sadd::<_, _, ()>("my_set", 43i32).await?;
     /// let mut iter: redis::AsyncIter<i32> = con.sscan("my_set").await?;
     /// while let Some(element) = iter.next_item().await {
     ///     assert!(element == 42 || element == 43);

{valkey_glide_sync-2.2.3 → valkey_glide_sync-2.2.5}/glide-core/redis-rs/redis/src/commands/macros.rs

@@ -32,7 +32,7 @@ macro_rules! implement_commands {
         /// use redis::Commands;
         /// let client = redis::Client::open("redis://127.0.0.1/")?;
         /// let mut con = client.get_connection(None)?;
-        /// con.set("my_key", 42)?;
+        /// con.set::<_, _, ()>("my_key", 42)?;
         /// assert_eq!(con.get("my_key"), Ok(42));
         /// # Ok(()) }
         /// ```
@@ -136,7 +136,7 @@ macro_rules! implement_commands {
         /// # async fn do_something() -> redis::RedisResult<()> {
         /// let client = redis::Client::open("redis://127.0.0.1/")?;
         /// let mut con = client.get_async_connection(None).await?;
-        /// redis::cmd("SET").arg("my_key").arg(42i32).query_async(&mut con).await?;
+        /// redis::cmd("SET").arg("my_key").arg(42i32).query_async::<_, ()>(&mut con).await?;
         /// assert_eq!(redis::cmd("GET").arg("my_key").query_async(&mut con).await, Ok(42i32));
         /// # Ok(()) }
         /// ```
@@ -149,7 +149,7 @@ macro_rules! implement_commands {
         /// use redis::Commands;
         /// let client = redis::Client::open("redis://127.0.0.1/")?;
         /// let mut con = client.get_async_connection(None).await?;
-        /// con.set("my_key", 42i32).await?;
+        /// con.set::<_, _, ()>("my_key", 42i32).await?;
         /// assert_eq!(con.get("my_key").await, Ok(42i32));
         /// # Ok(()) }
         /// ```

{valkey_glide_sync-2.2.3 → valkey_glide_sync-2.2.5}/glide-core/redis-rs/redis/src/lib.rs

@@ -107,7 +107,7 @@
 //! fn do_something(con: &mut redis::Connection) -> redis::RedisResult<usize> {
 //!     // This will result in a server error: "unknown command `MEMORY USAGE`"
 //!     // because "USAGE" is technically a sub-command of "MEMORY".
-//!     redis::cmd("MEMORY USAGE").arg("my_key").query(con)?;
+//!     redis::cmd("MEMORY USAGE").arg("my_key").query::<()>(con)?;
 //!
 //!     // However, this will work as you'd expect
 //!     redis::cmd("MEMORY").arg("USAGE").arg("my_key").query(con)
@@ -312,9 +312,9 @@ use redis::AsyncCommands;
 let client = redis::Client::open("redis://127.0.0.1/").unwrap();
 let mut con = client.get_async_connection(None).await?;
 
-con.set("key1", b"foo").await?;
+con.set::<_, _, ()>("key1", b"foo").await?;
 
-redis::cmd("SET").arg(&["key2", "bar"]).query_async(&mut con).await?;
+redis::cmd("SET").arg(&["key2", "bar"]).query_async::<_, ()>(&mut con).await?;
 
 let result = redis::cmd("MGET")
  .arg(&["key1", "key2"])

{valkey_glide_sync-2.2.3 → valkey_glide_sync-2.2.5}/glide-core/src/client/mod.rs

@@ -1260,6 +1260,8 @@ async fn create_cluster_client(
     builder =
         builder.refresh_topology_from_initial_nodes(request.refresh_topology_from_initial_nodes);
 
+    builder = builder.tcp_nodelay(request.tcp_nodelay);
+
     // Always use with Glide
     builder = builder.periodic_connections_checks(Some(CONNECTION_CHECKS_INTERVAL));
 

{valkey_glide_sync-2.2.3 → valkey_glide_sync-2.2.5}/glide-core/src/client/reconnecting_connection.rs

@@ -123,6 +123,7 @@ async fn create_connection(
     push_sender: Option<mpsc::UnboundedSender<PushInfo>>,
     discover_az: bool,
     connection_timeout: Duration,
+    tcp_nodelay: bool,
 ) -> Result<ReconnectingConnection, (ReconnectingConnection, RedisError)> {
     let client = {
         let guard = connection_backend
@@ -140,6 +141,7 @@ async fn create_connection(
         discover_az,
         connection_timeout: Some(connection_timeout),
         connection_retry_strategy: Some(retry_strategy),
+        tcp_nodelay,
     };
 
     let action = || async {
@@ -224,6 +226,7 @@ impl ReconnectingConnection {
         discover_az: bool,
         connection_timeout: Duration,
         tls_params: Option<redis::TlsConnParams>,
+        tcp_nodelay: bool,
     ) -> Result<ReconnectingConnection, (ReconnectingConnection, RedisError)> {
         log_debug(
             "connection creation",
@@ -242,6 +245,7 @@ impl ReconnectingConnection {
             push_sender,
             discover_az,
             connection_timeout,
+            tcp_nodelay,
         )
         .await
     }

{valkey_glide_sync-2.2.3 → valkey_glide_sync-2.2.5}/glide-core/src/client/standalone_client.rs

@@ -152,6 +152,8 @@ impl StandaloneClient {
             DEFAULT_CONNECTION_TIMEOUT,
         );
 
+        let tcp_nodelay = connection_request.tcp_nodelay;
+
         let tls_params = if !connection_request.root_certs.is_empty() {
             if tls_mode.unwrap_or(TlsMode::NoTls) == TlsMode::NoTls {
                 return Err(StandaloneClientConnectionError::FailedConnection(vec![(
@@ -192,9 +194,10 @@ impl StandaloneClient {
                 let discover = discover_az;
                 let timeout = connection_timeout;
                 let params = tls_params.clone();
+                let nodelay = tcp_nodelay;
                 async move {
                     get_connection_and_replication_info(
-                        &address, &retry, &info, tls, &sender, discover, timeout, params,
+                        &address, &retry, &info, tls, &sender, discover, timeout, params, nodelay,
                     )
                     .await
                     .map_err(|err| (format!("{}:{}", address.host, address.port), err))
@@ -692,6 +695,7 @@ async fn get_connection_and_replication_info(
     discover_az: bool,
     connection_timeout: Duration,
     tls_params: Option<redis::TlsConnParams>,
+    tcp_nodelay: bool,
 ) -> Result<(ReconnectingConnection, Value), (ReconnectingConnection, RedisError)> {
     let reconnecting_connection = ReconnectingConnection::new(
         address,
@@ -702,6 +706,7 @@ async fn get_connection_and_replication_info(
         discover_az,
         connection_timeout,
         tls_params,
+        tcp_nodelay,
     )
     .await?;
 

{valkey_glide_sync-2.2.3 → valkey_glide_sync-2.2.5}/glide-core/src/client/types.rs

@@ -30,6 +30,7 @@ pub struct ConnectionRequest {
     pub lazy_connect: bool,
     pub refresh_topology_from_initial_nodes: bool,
     pub root_certs: Vec<Vec<u8>>,
+    pub tcp_nodelay: bool,
 }
 
 /// Authentication information for connecting to Redis/Valkey servers
@@ -283,6 +284,8 @@ impl From<protobuf::ConnectionRequest> for ConnectionRequest {
             .map(|cert| cert.to_vec())
             .collect();
 
+        let tcp_nodelay = value.tcp_nodelay.unwrap_or(true);
+
         ConnectionRequest {
             read_from,
             client_name,
@@ -302,6 +305,7 @@ impl From<protobuf::ConnectionRequest> for ConnectionRequest {
             lazy_connect,
             refresh_topology_from_initial_nodes,
             root_certs,
+            tcp_nodelay,
         }
     }
 }

{valkey_glide_sync-2.2.3 → valkey_glide_sync-2.2.5}/glide-core/src/protobuf/connection_request.proto

@@ -90,6 +90,8 @@ message ConnectionRequest {
     bool refresh_topology_from_initial_nodes = 18;
     string lib_name = 19;
     repeated bytes root_certs = 20;
+    // for future backport: the number skip is due to not porting PR 4759 and 5093
+    optional bool tcp_nodelay = 24;
 }
 
 message ConnectionRetryStrategy {

{valkey_glide_sync-2.2.3 → valkey_glide_sync-2.2.5}/glide_shared/config.py

@@ -289,15 +289,21 @@ class AdvancedBaseClientConfiguration:
         tls_config (Optional[TlsAdvancedConfiguration]): The advanced TLS configuration settings.
             This allows for more granular control of TLS behavior, such as enabling an insecure mode
             that bypasses certificate validation.
+        tcp_nodelay (Optional[bool]): Controls TCP_NODELAY socket option (Nagle's algorithm).
+            When True, disables Nagle's algorithm for lower latency by sending packets immediately without buffering.
+            When False, enables Nagle's algorithm to reduce network overhead by buffering small packets.
+            If not explicitly set, defaults to True.
     """
 
     def __init__(
         self,
         connection_timeout: Optional[int] = None,
         tls_config: Optional[TlsAdvancedConfiguration] = None,
+        tcp_nodelay: Optional[bool] = None,
     ):
         self.connection_timeout = connection_timeout
         self.tls_config = tls_config
+        self.tcp_nodelay = tcp_nodelay
 
     def _create_a_protobuf_conn_request(
         self, request: ConnectionRequest
@@ -305,6 +311,9 @@ class AdvancedBaseClientConfiguration:
         if self.connection_timeout:
             request.connection_timeout = self.connection_timeout
 
+        if self.tcp_nodelay is not None:
+            request.tcp_nodelay = self.tcp_nodelay
+
         if self.tls_config:
             if self.tls_config.use_insecure_tls:
                 # Validate that TLS is enabled before allowing insecure mode
@@ -564,9 +573,10 @@ class AdvancedGlideClientConfiguration(AdvancedBaseClientConfiguration):
         self,
         connection_timeout: Optional[int] = None,
         tls_config: Optional[TlsAdvancedConfiguration] = None,
+        tcp_nodelay: Optional[bool] = None,
     ):
 
-        super().__init__(connection_timeout, tls_config)
+        super().__init__(connection_timeout, tls_config, tcp_nodelay)
 
 
 class GlideClientConfiguration(BaseClientConfiguration):
@@ -744,8 +754,9 @@ class AdvancedGlideClusterClientConfiguration(AdvancedBaseClientConfiguration):
         connection_timeout: Optional[int] = None,
         tls_config: Optional[TlsAdvancedConfiguration] = None,
         refresh_topology_from_initial_nodes: bool = False,
+        tcp_nodelay: Optional[bool] = None,
     ):
-        super().__init__(connection_timeout, tls_config)
+        super().__init__(connection_timeout, tls_config, tcp_nodelay)
         self.refresh_topology_from_initial_nodes = refresh_topology_from_initial_nodes
 
     def _create_a_protobuf_conn_request(

{valkey_glide_sync-2.2.3 → valkey_glide_sync-2.2.5}/pyproject.toml

@@ -1,5 +1,5 @@
 [project]
-version = "2.2.3"
+version = "2.2.5"
 name = "valkey-glide-sync"
 description = "Valkey GLIDE Sync client. Supports Valkey and Redis OSS."
 readme = "README.md"

{valkey_glide_sync-2.2.3 → valkey_glide_sync-2.2.5}/valkey_glide_sync.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: valkey-glide-sync
-Version: 2.2.3
+Version: 2.2.5
 Summary: Valkey GLIDE Sync client. Supports Valkey and Redis OSS.
 License: Apache-2.0
 Classifier: Topic :: Database