ci: fix flaky ttc test (#17665)

Author: forsaken628

tests/sqllogictests/src/error.rs

@@ -22,6 +22,7 @@ use serde::Deserialize;
 use serde::Serialize;
 use serde_json::Error as SerdeJsonError;
 use sqllogictest::TestError;
+use testcontainers::core::error::ClientError;
 use thiserror::Error;
 use walkdir::Error as WalkDirError;
 
@@ -80,3 +81,9 @@ impl From<String> for DSqlLogicTestError {
         DSqlLogicTestError::SelfError(value)
     }
 }
+
+impl From<ClientError> for DSqlLogicTestError {
+    fn from(value: ClientError) -> Self {
+        DSqlLogicTestError::SelfError(value.to_string())
+    }
+}

tests/sqllogictests/src/main.rs

@@ -17,7 +17,6 @@ use std::future::Future;
 use std::path::Path;
 use std::time::Instant;
 
-use bollard::Docker;
 use clap::Parser;
 use client::TTCClient;
 use futures_util::stream;
@@ -161,12 +160,11 @@ async fn run_hybrid_client(
 ) -> Result<()> {
     println!("Hybird client starts to run with: {:?}", args);
 
-    let docker = Docker::connect_with_local_defaults().unwrap();
     for (c, _) in HYBRID_CONFIGS.iter() {
         match c.as_ref() {
             ClientType::MySQL | ClientType::Http => {}
             ClientType::Ttc(image, port) => {
-                run_ttc_container(&docker, image, *port, args.port, cs).await?;
+                run_ttc_container(image, *port, args.port, cs).await?;
             }
             ClientType::Hybird => panic!("Can't run hybrid client in hybrid client"),
         }

tests/sqllogictests/src/util.rs

@@ -26,6 +26,7 @@ use redis::Commands;
 use serde::Deserialize;
 use serde::Serialize;
 use serde_json::Value;
+use testcontainers::core::client::docker_client_instance;
 use testcontainers::core::error::WaitContainerError;
 use testcontainers::core::IntoContainerPort;
 use testcontainers::core::WaitFor;
@@ -242,12 +243,12 @@ fn run_script(name: &str, args: &[&str]) -> Result<()> {
 }
 
 pub async fn run_ttc_container(
-    docker: &Docker,
     image: &str,
     port: u16,
     http_server_port: u16,
     cs: &mut Vec<ContainerAsync<GenericImage>>,
 ) -> Result<()> {
+    let docker = &docker_client_instance().await?;
     let mut images = image.split(":");
     let image = images.next().unwrap();
     let tag = images.next().unwrap_or("latest");
@@ -264,8 +265,6 @@ pub async fn run_ttc_container(
     let start = Instant::now();
     println!("Start container {container_name}");
 
-    stop_container(docker, &container_name).await;
-
     let mut i = 1;
     loop {
         let container_res = GenericImage::new(image, tag)
@@ -287,28 +286,24 @@ pub async fn run_ttc_container(
         match container_res {
             Ok(container) => {
                 println!(
-                    "Start container {} using {} secs success",
+                    "Start container {container_name} {} using {duration} secs success",
                     container.id(),
-                    duration
                 );
                 cs.push(container);
                 return Ok(());
             }
             Err(err) => {
-                println!(
-                    "Start container {} using {} secs failed: {}",
-                    container_name, duration, err
-                );
+                println!("Start container {container_name} using {duration} secs failed: {err}");
                 if err.to_string().to_ascii_lowercase().contains("timeout")
                     || err.to_string().to_ascii_lowercase().contains("conflict")
                 {
-                    println!("start to stop container {container_name}");
+                    println!("Start to stop container {container_name}");
                     stop_container(docker, &container_name).await;
                 }
                 if i == CONTAINER_RETRY_TIMES || duration >= CONTAINER_TIMEOUT_SECONDS {
                     break;
                 } else {
-                    println!("retry start container {container_name} after {duration}");
+                    println!("retry start container {container_name} after {duration} secs");
                     i += 1;
                 }
             }
@@ -330,7 +325,7 @@ pub async fn lazy_run_dictionary_containers(
         return Ok(None);
     }
     println!("Start run dictionary source server container");
-    let docker = Docker::connect_with_local_defaults().unwrap();
+    let docker = docker_client_instance().await?;
     let redis = run_redis_server(&docker).await?;
     let mysql = run_mysql_server(&docker).await?;
     let dict_container = DictionaryContainer { redis, mysql };
@@ -469,11 +464,15 @@ async fn run_mysql_server(docker: &Docker) -> Result<ContainerAsync<Mysql>> {
 
 // Stop the running container to avoid conflict
 async fn stop_container(docker: &Docker, container_name: &str) {
-    let _ = docker.stop_container(container_name, None).await;
+    if let Err(err) = docker.stop_container(container_name, None).await {
+        println!("stop container {container_name} err: {err}");
+    }
     let options = Some(RemoveContainerOptions {
         force: true,
         ..Default::default()
     });
-    let _ = docker.remove_container(container_name, options).await;
-    println!("Stop container {container_name}");
+    if let Err(err) = docker.remove_container(container_name, options).await {
+        println!("remove container {container_name} err: {err}");
+    }
+    println!("Stopped container {container_name}");
 }