Update dependencies and refactor random string generation

Signed-off-by: avifenesh <[email protected]>

Author: avifenesh

glide-core/Cargo.toml

@@ -9,7 +9,7 @@ authors = ["Valkey GLIDE Maintainers"]
 
 [dependencies]
 bytes = "1"
-futures = "^0.3"
+futures = "0.3"
 redis = { path = "./redis-rs/redis", features = [
     "aio",
     "tokio-comp",
@@ -21,27 +21,27 @@ redis = { path = "./redis-rs/redis", features = [
 telemetrylib = { path = "./telemetry" }
 tokio = { version = "1", features = ["macros", "time"] }
 logger_core = { path = "../logger_core" }
-dispose = "0.5.0"
-tokio-util = { version = "^0.7", features = ["rt"], optional = true }
-num_cpus = { version = "^1.15", optional = true }
-tokio-retry2 = {version = "0.5", features = ["jitter"]}
+dispose = "0.5"
+tokio-util = { version = "0.7", features = ["rt"], optional = true }
+num_cpus = { version = "1", optional = true }
+tokio-retry2 = { version = "0.5", features = ["jitter"] }
 
 protobuf = { version = "3", features = [
     "bytes",
     "with-bytes",
 ], optional = true }
-integer-encoding = { version = "4.0.0", optional = true }
-thiserror = "1"
-rand = { version = "0.8.5" }
-futures-intrusive = "0.5.0"
-directories = { version = "5.0", optional = true }
-once_cell = "1.18.0"
-sha1_smol = "1.0.0"
-nanoid = "0.4.0"
-async-trait = { version = "0.1.24" }
+integer-encoding = { version = "4", optional = true }
+thiserror = "2"
+rand = "0.9"
+futures-intrusive = "0.5"
+directories = { version = "6", optional = true }
+once_cell = "1"
+sha1_smol = "1"
+nanoid = "0.4"
+async-trait = { version = "0.1" }
 serde_json = "1"
 serde = { version = "1", features = ["derive"] }
-versions = "6.3"
+versions = "6"
 
 [features]
 socket-layer = [
@@ -57,11 +57,11 @@ standalone_heartbeat = []
 rsevents = "0.3.1"
 socket2 = "^0.5"
 tempfile = "3.3.0"
-rstest = "^0.23"
+rstest = "^0.24"
 serial_test = "3"
 criterion = { version = "^0.5", features = ["html_reports", "async_tokio"] }
-which = "6"
-ctor = "0.2.2"
+which = "7"
+ctor = "0.3"
 redis = { path = "./redis-rs/redis", features = ["tls-rustls-insecure"] }
 iai-callgrind = "0.14"
 tokio = { version = "1", features = ["rt-multi-thread"] }

glide-core/benches/rotating_buffer_benchmark.rs

@@ -11,7 +11,7 @@ use glide_core::{
 };
 use integer_encoding::VarInt;
 use protobuf::Message;
-use rand::{distributions::Alphanumeric, Rng};
+use rand::{distr::Alphanumeric, Rng};
 
 fn benchmark(
     c: &mut Criterion,
@@ -102,7 +102,7 @@ fn benchmark_split_data(
 }
 
 fn generate_random_string(length: usize) -> bytes::Bytes {
-    let s: String = rand::thread_rng()
+    let s: String = rand::rng()
         .sample_iter(&Alphanumeric)
         .take(length)
         .map(char::from)

glide-core/src/client/standalone_client.rs

@@ -9,7 +9,6 @@ use crate::retry_strategies::RetryStrategy;
 use futures::{future, stream, StreamExt};
 use logger_core::log_debug;
 use logger_core::log_warn;
-use rand::Rng;
 use redis::aio::ConnectionLike;
 use redis::cluster_routing::{self, is_readonly_cmd, ResponsePolicy, Routable, RoutingInfo};
 use redis::{PushInfo, RedisError, RedisResult, Value};
@@ -125,7 +124,7 @@ impl StandaloneClient {
         let tls_mode = connection_request.tls_mode;
         let node_count = connection_request.addresses.len();
         // randomize pubsub nodes, maybe a batter option is to always use the primary
-        let pubsub_node_index = rand::thread_rng().gen_range(0..node_count);
+        let pubsub_node_index = rand::random_range(0..node_count);
         let pubsub_addr = &connection_request.addresses[pubsub_node_index];
         let discover_az = matches!(
             connection_request.read_from,

glide-core/src/rotating_buffer.rs

@@ -29,18 +29,17 @@ impl RotatingBuffer {
                 let start_pos = prev_position + bytes_read;
                 if (start_pos + request_len as usize) > buffer_len {
                     break;
-                } else {
-                    match T::parse_from_tokio_bytes(
-                        &buffer.slice(start_pos..start_pos + request_len as usize),
-                    ) {
-                        Ok(request) => {
-                            prev_position += request_len as usize + bytes_read;
-                            results.push(request);
-                        }
-                        Err(err) => {
-                            log_error("parse input", format!("Failed to parse request: {err}"));
-                            return Err(err.into());
-                        }
+                }
+                match T::parse_from_tokio_bytes(
+                    &buffer.slice(start_pos..start_pos + request_len as usize),
+                ) {
+                    Ok(request) => {
+                        prev_position += request_len as usize + bytes_read;
+                        results.push(request);
+                    }
+                    Err(err) => {
+                        log_error("parse input", format!("Failed to parse request: {err}"));
+                        return Err(err.into());
                     }
                 }
             } else {
@@ -68,7 +67,7 @@ mod tests {
     use crate::command_request::{command, command_request};
     use crate::command_request::{Command, CommandRequest, RequestType};
     use bytes::BufMut;
-    use rand::{distributions::Alphanumeric, Rng};
+    use rand::{distr::Alphanumeric, Rng};
     use rstest::rstest;
 
     fn write_length(buffer: &mut BytesMut, length: u32) {
@@ -161,7 +160,7 @@ mod tests {
     }
 
     fn generate_random_string(length: usize) -> String {
-        rand::thread_rng()
+        rand::rng()
             .sample_iter(&Alphanumeric)
             .take(length)
             .map(char::from)

glide-core/src/socket_listener.rs

@@ -11,7 +11,6 @@ use crate::errors::{error_message, error_type, RequestErrorType};
 use crate::response;
 use crate::response::Response;
 use bytes::Bytes;
-use directories::BaseDirs;
 use logger_core::{log_debug, log_error, log_info, log_trace, log_warn};
 use once_cell::sync::Lazy;
 use protobuf::{Chars, Message};
@@ -24,8 +23,8 @@ use std::cell::Cell;
 use std::collections::HashSet;
 use std::ptr::from_mut;
 use std::rc::Rc;
+use std::str;
 use std::sync::RwLock;
-use std::{env, str};
 use std::{io, thread};
 use thiserror::Error;
 use tokio::net::{UnixListener, UnixStream};
@@ -39,7 +38,8 @@ use ClosingReason::*;
 use PipeListeningResult::*;
 
 /// The socket file name
-const SOCKET_FILE_NAME: &str = "glide-socket";
+const SOCKET_FILE_NAME: &str = "glide-socket.sock";
+const SOCKET_FOLDER: &str = "valkey-glide";
 
 /// The maximum length of a request's arguments to be passed as a vector of
 /// strings instead of a pointer
@@ -569,7 +569,13 @@ async fn handle_requests(
 
 pub fn close_socket(socket_path: &String) {
     log_info("close_socket", format!("closing socket at {socket_path}"));
-    let _ = std::fs::remove_file(socket_path);
+    // On Unix systems, the files are "unlinked" but not deleted until all references to the file are closed.
+    // Based on the officials docs of `rust std::fs::remove_file: https://doc.rust-lang.org/std/fs/fn.remove_file.html`,
+    // "Note that there is no guarantee that the file is immediately deleted (e.g., depending on platform, other open file descriptors may prevent immediate removal)."
+    // So, we rename the file to a new name and then remove it, to avoid any issues with the file being unlinked but not deleted, and the system is closed before the file is deleted.
+    // As we saw with dockers being closed on immediate shutdown of the program.
+    let _ = std::fs::rename(socket_path, format!("{socket_path}.closed"));
+    let _ = std::fs::remove_file(format!("{socket_path}.closed"));
 }
 
 async fn create_client(
@@ -582,6 +588,8 @@ async fn create_client(
         Err(err) => return Err(ClientCreationError::ConnectionError(err)),
     };
     write_result(Ok(Value::Okay), 0, writer).await?;
+
+    log_info("create_client", "Client created successfully");
     Ok(client)
 }
 
@@ -780,32 +788,22 @@ struct ClosingError {
     err_message: String,
 }
 
-/// Get the socket full path.
-/// The socket file name will contain the process ID and will try to be saved into the user's runtime directory
-/// (e.g. /run/user/1000) in Unix systems. If the runtime dir isn't found, the socket file will be saved to the temp dir.
-/// For Windows, the socket file will be saved to %AppData%\Local.
-pub fn get_socket_path_from_name(socket_name: String) -> String {
-    let base_dirs = BaseDirs::new().expect("Failed to create BaseDirs");
-    let tmp_dir;
-    let folder = if cfg!(windows) {
-        base_dirs.data_local_dir()
-    } else {
-        base_dirs.runtime_dir().unwrap_or({
-            tmp_dir = env::temp_dir();
-            tmp_dir.as_path()
-        })
-    };
-    folder
-        .join(socket_name)
-        .into_os_string()
-        .into_string()
-        .expect("Couldn't create socket path")
-}
-
 /// Get the socket path as a string
 pub fn get_socket_path() -> String {
-    let socket_name = format!("{}-{}", SOCKET_FILE_NAME, std::process::id());
-    get_socket_path_from_name(socket_name)
+    // Remove the socket folder if it exists, to ensure there are no conflicts with the socket file
+    // that will be created.
+    let tmp_dir = std::env::temp_dir();
+    let socket_folder = tmp_dir
+        .join(SOCKET_FOLDER)
+        .join(std::process::id().to_string());
+
+    let _ = std::fs::remove_dir_all(&socket_folder);
+
+    let _ = std::fs::create_dir_all(&socket_folder);
+    socket_folder
+        .join(SOCKET_FILE_NAME)
+        .to_string_lossy()
+        .into_owned()
 }
 
 /// This function is exposed only for the sake of testing with a nonstandard `socket_path`.

glide-core/tests/test_socket_listener.rs

@@ -515,11 +515,9 @@ mod socket_listener {
 
     #[rstest]
     #[timeout(SHORT_STANDALONE_TEST_TIMEOUT)]
+    #[cfg(test)]
     fn test_working_after_socket_listener_was_dropped() {
-        let socket_path = get_socket_path_from_name(format!(
-            "{}_test_working_after_socket_listener_was_dropped",
-            std::process::id()
-        ));
+        let socket_path = get_socket_path();
         close_socket(&socket_path);
         // create a socket listener and drop it, to simulate a panic in a previous iteration.
         Builder::new_current_thread()
@@ -556,10 +554,7 @@ mod socket_listener {
     #[rstest]
     #[timeout(SHORT_STANDALONE_TEST_TIMEOUT)]
     fn test_multiple_listeners_competing_for_the_socket() {
-        let socket_path = get_socket_path_from_name(format!(
-            "{}_test_multiple_listeners_competing_for_the_socket",
-            std::process::id()
-        ));
+        let socket_path = get_socket_path();
         close_socket(&socket_path);
         let server = Arc::new(RedisServer::new(ServerType::Tcp { tls: false }));
 

glide-core/tests/utilities/mod.rs

@@ -7,7 +7,7 @@ use glide_core::{
     connection_request::{self, AuthenticationInfo, NodeAddress, ProtocolVersion},
 };
 use once_cell::sync::Lazy;
-use rand::{distributions::Alphanumeric, Rng};
+use rand::{distr::Alphanumeric, Rng};
 use redis::{
     cluster_routing::{MultipleNodeRoutingInfo, RoutingInfo},
     ConnectionAddr, GlideConnectionOptions, PushInfo, RedisConnectionInfo, RedisResult, Value,
@@ -517,7 +517,7 @@ pub fn get_address_info(address: &ConnectionAddr) -> NodeAddress {
 }
 
 pub fn generate_random_string(length: usize) -> String {
-    rand::thread_rng()
+    rand::rng()
         .sample_iter(&Alphanumeric)
         .take(length)
         .map(char::from)