test(tracker-core): wait for mysql readiness in persistence benchmark

The persistence benchmark used to fail intermittently when running the
MySQL driver because sqlx does not retry the first connection. The
official mysql container emits 'ready for connections' twice (first on
the unix socket during init, then on TCP), so we now wait for the
second occurrence on stderr and additionally ping with SELECT 1 in a
short retry loop before initializing the schema.

Add the new technical terms (finalises, mysqld, syscall, testcontainer)
to the project dictionary so cspell stays happy across follow-up
benchmark documentation.

Author: josecelano

packages/tracker-core/src/bin/persistence_benchmark/driver_bench/database/mysql.rs

@@ -1,15 +1,34 @@
+use std::str::FromStr;
+use std::time::Duration;
+
 use anyhow::{Context, Result};
 use bittorrent_tracker_core::databases::setup::initialize_database;
-use testcontainers::core::IntoContainerPort;
+use sqlx::mysql::{MySqlConnectOptions, MySqlPoolOptions};
+use testcontainers::core::wait::LogWaitStrategy;
+use testcontainers::core::{IntoContainerPort, WaitFor};
 use testcontainers::runners::AsyncRunner;
 use testcontainers::{GenericImage, ImageExt};
 use torrust_tracker_configuration as configuration;
 
 use super::{ActiveDatabase, BenchmarkResource};
 
+/// Maximum number of connect-and-ping attempts after the container is reported
+/// ready. Belt-and-braces against a brief race between the second
+/// `ready for connections` log line and TCP acceptance on port 3306.
+const READINESS_PING_RETRIES: usize = 30;
+/// Delay between readiness-ping attempts.
+const READINESS_PING_INTERVAL: Duration = Duration::from_millis(500);
+
 pub(super) async fn initialize(db_version: &str) -> Result<ActiveDatabase> {
+    // The official `mysql` image emits `ready for connections` twice on stderr:
+    // first transiently during init on the unix socket, then again once mysqld
+    // is actually accepting TCP clients on port 3306. We wait for the second
+    // occurrence so the first query (DDL via `initialize_database`) does not
+    // race the TCP listener and panic with `UnexpectedEof`. This is the same
+    // idiom the Java testcontainers MySQL module uses internally.
     let mysql_container = GenericImage::new("mysql", db_version)
         .with_exposed_port(3306.tcp())
+        .with_wait_for(WaitFor::Log(LogWaitStrategy::stderr("ready for connections").with_times(2)))
         .with_env_var("MYSQL_ROOT_PASSWORD", "test")
         .with_env_var("MYSQL_DATABASE", "torrust_tracker_bench")
         .with_env_var("MYSQL_ROOT_HOST", "%")
@@ -27,6 +46,17 @@ pub(super) async fn initialize(db_version: &str) -> Result<ActiveDatabase> {
         .context("failed to resolve mysql container host port")?;
 
     let mysql_database_url = format!("mysql://root:test@{host}:{port}/torrust_tracker_bench");
+
+    // Belt-and-braces: even after the readiness log message, the very first TCP
+    // connect can still hit `UnexpectedEof` while mysqld finalises bind/accept.
+    // Probe with a short connect-and-ping loop so the production
+    // `initialize_database` call below sees a steady server. This mirrors what
+    // the previous r2d2-based driver did implicitly through pool checkout
+    // retries.
+    wait_until_mysql_accepts_connections(&mysql_database_url)
+        .await
+        .context("mysql container did not accept connections in time")?;
+
     let mut config = configuration::Core::default();
     config.database.driver = configuration::Driver::MySQL;
     config.database.path = mysql_database_url;
@@ -37,3 +67,32 @@ pub(super) async fn initialize(db_version: &str) -> Result<ActiveDatabase> {
         resource: Some(BenchmarkResource::Mysql(Box::new(mysql_container))),
     })
 }
+
+async fn wait_until_mysql_accepts_connections(database_url: &str) -> Result<()> {
+    let options = MySqlConnectOptions::from_str(database_url).context("invalid mysql benchmark URL")?;
+
+    let mut last_error: Option<sqlx::Error> = None;
+
+    for _ in 0..READINESS_PING_RETRIES {
+        match MySqlPoolOptions::new().max_connections(1).connect_with(options.clone()).await {
+            Ok(pool) => {
+                if let Err(error) = sqlx::query("SELECT 1").execute(&pool).await {
+                    last_error = Some(error);
+                } else {
+                    pool.close().await;
+                    return Ok(());
+                }
+            }
+            Err(error) => {
+                last_error = Some(error);
+            }
+        }
+
+        tokio::time::sleep(READINESS_PING_INTERVAL).await;
+    }
+
+    Err(anyhow::anyhow!(
+        "mysql still not accepting connections after {READINESS_PING_RETRIES} attempts; last error: {error}",
+        error = last_error.map_or_else(|| "<none>".to_string(), |e| e.to_string())
+    ))
+}

project-words.txt

@@ -81,6 +81,7 @@ fastrand
 fdbased
 fdget
 filesd
+finalises
 flamegraph
 formatjson
 fput
@@ -152,6 +153,7 @@ MSRV
 multimap
 myacicontext
 mysqladmin
+mysqld
 ñaca
 Naim
 nanos
@@ -242,6 +244,7 @@ subsec
 supertrait
 Swatinem
 Swiftbit
+syscall
 sysmalloc
 sysret
 taiki
@@ -250,6 +253,7 @@ tdyne
 Tebibytes
 tempfile
 Tera
+testcontainer
 testcontainers
 thiserror
 timespec