temp

Author: nihohit

redis/tests/support/cluster.rs

@@ -3,7 +3,6 @@
 
 use std::convert::identity;
 use std::env;
-use std::io::Read;
 use std::process;
 use std::thread::sleep;
 use std::time::Duration;
@@ -200,44 +199,30 @@ impl RedisCluster {
                     folders.push(tempdir);
                     addrs.push(addr.clone());
 
-                    let mut cur_attempts = 0;
-                    loop {
-                        let mut process = cmd.spawn().unwrap();
-                        sleep(Duration::from_millis(50));
+                    cmd.spawn().unwrap()    
+                },
+            ));
+        }
 
+        for server in servers.iter_mut() {
+            let process = &mut server.process;
+            sleep(Duration::from_millis(50));
                         match process.try_wait() {
-                            Ok(Some(status)) => {
-                                let stdout = process.stdout.map_or(String::new(), |mut out|{
-                                    let mut str = String::new();
-                                    out.read_to_string(&mut str).unwrap();
-                                    str
-                                });
-                                let stderr = process.stderr.map_or(String::new(), |mut out|{
-                                    let mut str = String::new();
-                                    out.read_to_string(&mut str).unwrap();
-                                    str
-                                });
-                                let err =
-                                    format!("redis server creation failed with status {status:?}.\nstdout: `{stdout}`.\nstderr: `{stderr}`");
-                                if cur_attempts == max_attempts {
-                                    let log_file_index = cmd.get_args().position(|os_str| os_str == "--logfile").unwrap() + 1;
-                                    let log_file_path = cmd.get_args().nth(log_file_index).unwrap();
-                                    let contents = std::fs::read_to_string(log_file_path).unwrap();
-                                    panic!("{err} - logfile: {contents}");
-                                }
-                                eprintln!("Retrying: {err}");
-                                cur_attempts += 1;
+                            Ok(Some(status)) => {                                
+                                    let contents = std::fs::read_to_string(server.log_file.clone()).unwrap();
+                                    panic!("redis server creation failed with status {status:?}.\nlogfile: {contents}");
                             }
                             Ok(None) => {
                                 // wait for 10 seconds for the server to be available.
                                 let max_attempts = 200;
                                 let mut cur_attempts = 0;
+                                let addr = &server.addr;
                                 loop {
                                     if cur_attempts == max_attempts {
-                                        panic!("redis server creation failed: Port {port} closed")
+                                        panic!("redis server creation failed: Port {} closed", &addr)
                                     }
-                                    if port_in_use(&addr) {
-                                        return process;
+                                    if port_in_use(&addr.to_string()) {
+                                        continue;
                                     }
                                     eprintln!("Waiting for redis process to initialize");
                                     sleep(Duration::from_millis(50));
@@ -248,9 +233,6 @@ impl RedisCluster {
                                 panic!("Unexpected error in redis server creation {e}");
                             }
                         }
-                    }
-                },
-            ));
         }
 
         let mut cmd = process::Command::new("redis-cli");

redis/tests/support/mod.rs

@@ -142,6 +142,7 @@ pub enum Module {
 pub struct RedisServer {
     pub process: process::Child,
     tempdir: tempfile::TempDir,
+    log_file: PathBuf,
     addr: redis::ConnectionAddr,
     pub(crate) tls_paths: Option<TlsFilePaths>,
 }
@@ -270,7 +271,8 @@ impl RedisServer {
             .prefix("redis")
             .tempdir()
             .expect("failed to create tempdir");
-        redis_cmd.arg("--logfile").arg(Self::log_file(&tempdir));
+        let log_file = Self::log_file(&tempdir);
+        redis_cmd.arg("--logfile").arg(log_file.clone());
         match addr {
             redis::ConnectionAddr::Tcp(ref bind, server_port) => {
                 redis_cmd
@@ -281,6 +283,7 @@ impl RedisServer {
 
                 RedisServer {
                     process: spawner(&mut redis_cmd),
+                    log_file,
                     tempdir,
                     addr,
                     tls_paths: None,
@@ -320,6 +323,7 @@ impl RedisServer {
 
                 RedisServer {
                     process: spawner(&mut redis_cmd),
+                    log_file,
                     tempdir,
                     addr,
                     tls_paths: Some(tls_paths),
@@ -333,6 +337,7 @@ impl RedisServer {
                     .arg(path);
                 RedisServer {
                     process: spawner(&mut redis_cmd),
+                    log_file,
                     tempdir,
                     addr,
                     tls_paths: None,