CORE: Track HELLO and AUTH state for reconnection (#5145)

- Add update_username() and update_protocol() methods to Client for persisting authentication state
- Add update_connection_username() and update_connection_protocol() methods to ClusterConnection for cluster-wide state updates
- Add UpdateConnectionUsername and UpdateConnectionProtocol operations to cluster routing
- Reclassify AUTH command as write operation in cluster routing to ensure state is tracked across all nodes
- Update CHANGELOG.md to document HELLO and AUTH state tracking feature
- Ensure reconnections preserve protocol version and username from previous successful connections

Signed-off-by: affonsov <67347924+affonsov@users.noreply.github.com>
Co-authored-by: Pratheep Kumar <pratheepkumar0403@gmail.com>

Author: pratheep-kumar

CHANGELOG.md

@@ -20,6 +20,7 @@
 * Python: Move OpenTelemetry config classes to glide_shared for code reuse between async and sync clients
 * JAVA: Add dynamic PubSub methods (subscribe, psubscribe, unsubscribe, punsubscribe, ssubscribe, sunsubscribe), getSubscriptions() for subscription state tracking, pubsubReconciliationIntervalMs configuration option, and subscription_out_of_sync_count and subscription_last_sync_timestamp metrics ([#5267](https://github.com/valkey-io/valkey-glide/issues/5267))
 * Go: Add ALLOW_NON_COVERED_SLOTS flag support for cluster scan ([#4895](https://github.com/valkey-io/valkey-glide/issues/4895))
+* CORE: Track HELLO and AUTH state for reconnection ([#5145](https://github.com/valkey-io/valkey-glide/issues/5145))
 
 #### Fixes
 * Node: Fix to handle non-string types in toBuffersArray ([#4842](https://github.com/valkey-io/valkey-glide/issues/4842))

glide-core/redis-rs/redis/src/client.rs

@@ -7,7 +7,7 @@ use crate::{
     connection::{connect, Connection, ConnectionInfo, ConnectionLike, IntoConnectionInfo},
     push_manager::PushInfo,
     retry_strategies::RetryStrategy,
-    types::{RedisResult, Value},
+    types::{ProtocolVersion, RedisResult, Value},
 };
 #[cfg(feature = "aio")]
 use std::net::IpAddr;
@@ -602,6 +602,34 @@ impl Client {
     pub fn update_client_name(&mut self, client_name: Option<String>) {
         self.connection_info.redis.client_name = client_name;
     }
+
+    /// Updates the username in connection_info.
+    ///
+    /// This method updates the username field in the connection information,
+    /// which will be used for subsequent connections and reconnections.
+    /// Typically updated when AUTH command is used with a username.
+    ///
+    /// # Arguments
+    ///
+    /// * `username` - The username to use for authentication (None to clear)
+    ///
+    pub fn update_username(&mut self, username: Option<String>) {
+        self.connection_info.redis.username = username;
+    }
+
+    /// Updates the protocol version in connection_info.
+    ///
+    /// This method updates the protocol field in the connection information,
+    /// which will be used for subsequent connections and reconnections.
+    /// Typically updated when HELLO command is used to change protocol version.
+    ///
+    /// # Arguments
+    ///
+    /// * `protocol` - The protocol version to use (RESP2 or RESP3)
+    ///
+    pub fn update_protocol(&mut self, protocol: ProtocolVersion) {
+        self.connection_info.redis.protocol = protocol;
+    }
 }
 
 #[cfg(feature = "aio")]

glide-core/redis-rs/redis/src/cluster_async/mod.rs

@@ -85,6 +85,7 @@ use crate::{
         self, MultipleNodeRoutingInfo, Redirect, ResponsePolicy, Route, SingleNodeRoutingInfo,
     },
     push_manager::PushInfo,
+    types::ProtocolVersion,
     Cmd, ConnectionInfo, ErrorKind, IntoConnectionInfo, RedisError, RedisFuture, RedisResult,
     Value,
 };
@@ -356,6 +357,40 @@ where
             .await
     }
 
+    /// Update the username used to authenticate with all cluster servers
+    ///
+    /// This method updates the username for all cluster connections and stores it for future reconnections.
+    /// Typically called after a successful AUTH command with a username parameter.
+    ///
+    /// # Arguments
+    ///
+    /// * `username` - The username to use for authentication (None to clear)
+    ///
+    pub async fn update_connection_username(
+        &mut self,
+        username: Option<String>,
+    ) -> RedisResult<Value> {
+        self.route_operation_request(Operation::UpdateConnectionUsername(username))
+            .await
+    }
+
+    /// Update the protocol version used for all cluster connections
+    ///
+    /// This method updates the protocol version for all cluster connections and stores it for future reconnections.
+    /// Typically called after a successful HELLO command that changes the protocol version.
+    ///
+    /// # Arguments
+    ///
+    /// * `protocol` - The protocol version to use (RESP2 or RESP3)
+    ///
+    pub async fn update_connection_protocol(
+        &mut self,
+        protocol: ProtocolVersion,
+    ) -> RedisResult<Value> {
+        self.route_operation_request(Operation::UpdateConnectionProtocol(protocol))
+            .await
+    }
+
     /// Get the username used to authenticate with all cluster servers
     pub async fn get_username(&mut self) -> RedisResult<Value> {
         self.route_operation_request(Operation::GetUsername).await
@@ -683,6 +718,8 @@ enum Operation {
     UpdateConnectionPassword(Option<String>),
     UpdateConnectionDatabase(i64),
     UpdateConnectionClientName(Option<String>),
+    UpdateConnectionUsername(Option<String>),
+    UpdateConnectionProtocol(ProtocolVersion),
     GetUsername,
 }
 
@@ -2621,6 +2658,16 @@ where
                         .expect(MUTEX_WRITE_ERR);
                     Ok(Response::Single(Value::Okay))
                 }
+                Operation::UpdateConnectionUsername(username) => {
+                    core.set_cluster_param(|params| params.username = username)
+                        .expect(MUTEX_WRITE_ERR);
+                    Ok(Response::Single(Value::Okay))
+                }
+                Operation::UpdateConnectionProtocol(protocol) => {
+                    core.set_cluster_param(|params| params.protocol = protocol)
+                        .expect(MUTEX_WRITE_ERR);
+                    Ok(Response::Single(Value::Okay))
+                }
                 Operation::GetUsername => {
                     let username = match core
                         .get_cluster_param(|params| params.username.clone())

glide-core/redis-rs/redis/src/cluster_routing.rs

@@ -595,7 +595,7 @@ impl ResponsePolicy {
 
             b"WAITAOF" => Some(ResponsePolicy::AggregateArray(ArrayAggregateOp::Min)),
 
-            b"ACL SETUSER" | b"ACL DELUSER" | b"ACL SAVE" | b"CLIENT SETNAME"
+            b"ACL SETUSER" | b"ACL DELUSER" | b"ACL SAVE" | b"AUTH" | b"CLIENT SETNAME"
             | b"CLIENT SETINFO" | b"CONFIG SET" | b"CONFIG RESETSTAT" | b"CONFIG REWRITE"
             | b"FLUSHALL" | b"FLUSHDB" | b"FUNCTION DELETE" | b"FUNCTION FLUSH"
             | b"FUNCTION LOAD" | b"FUNCTION RESTORE" | b"MEMORY PURGE" | b"MSET" | b"JSON.MSET"
@@ -654,6 +654,7 @@ fn base_routing(cmd: &[u8]) -> RouteBy {
         b"ACL SETUSER"
         | b"ACL DELUSER"
         | b"ACL SAVE"
+        | b"AUTH"
         | b"CLIENT SETNAME"
         | b"CLIENT SETINFO"
         | b"SELECT"
@@ -750,7 +751,6 @@ fn base_routing(cmd: &[u8]) -> RouteBy {
         | b"ACL LOG"
         | b"ACL USERS"
         | b"ACL WHOAMI"
-        | b"AUTH"
         | b"BGSAVE"
         | b"CLIENT GETNAME"
         | b"CLIENT GETREDIR"