feat: Adds option to stop containers with a timeout

Previously containers were stopped with the system default timeout before
issuing SIGKILL which was interfering with clean shutdown of processes being
tested. This commit adds a new API of stop_with_timeout(Option<timeout_seconds>)
in addition to the original stop() which retains its original functionality.

A value of Some(-1) will issue a SIGTERM then wait indefinitely, a value of
Some(t) will issue a SIGTERM then wait t seconds before issuing a SIGKILL. A
value of None will follow the system default - often waiting 10 seconds, but
this is configurable within the docker engine.

Author: o087D

testcontainers/src/core/client.rs

@@ -162,9 +162,16 @@ impl Client {
             .map_err(ClientError::RemoveContainer)
     }
 
-    pub(crate) async fn stop(&self, id: &str) -> Result<(), ClientError> {
+    pub(crate) async fn stop(
+        &self,
+        id: &str,
+        timeout_seconds: Option<i64>,
+    ) -> Result<(), ClientError> {
         self.bollard
-            .stop_container(id, None)
+            .stop_container(
+                id,
+                timeout_seconds.map(|t| bollard::container::StopContainerOptions { t }),
+            )
             .await
             .map_err(ClientError::StopContainer)
     }

testcontainers/src/core/containers/async_container.rs

@@ -280,11 +280,27 @@ where
         Ok(())
     }
 
-    /// Stops the container (not the same with `pause`).
+    /// Stops the container (not the same with `pause`) using the default 10 second timeout
     pub async fn stop(&self) -> Result<()> {
-        log::debug!("Stopping docker container {}", self.id);
+        self.stop_with_timeout(None).await?;
+        Ok(())
+    }
+
+    /// Stops the container with timeout before issuing SIGKILL (not the same with `pause`).
+    ///
+    /// Set Some(-1) to wait indefinitely, None to use system configured default and Some(0)
+    /// to forcibly stop the container immediately - otherwise the runtime will issue SIGINT
+    /// and then wait timeout_seconds seconds for the process to stop before issuing SIGKILL.
+    pub async fn stop_with_timeout(&self, timeout_seconds: Option<i64>) -> Result<()> {
+        log::debug!(
+            "Stopping docker container {} with {} second timeout",
+            self.id,
+            timeout_seconds
+                .map(|t| t.to_string())
+                .unwrap_or("'system default'".into())
+        );
 
-        self.docker_client.stop(&self.id).await?;
+        self.docker_client.stop(&self.id, timeout_seconds).await?;
         Ok(())
     }
 

testcontainers/src/core/containers/sync_container.rs

@@ -127,11 +127,21 @@ where
         })
     }
 
-    /// Stops the container (not the same with `pause`).
+    /// Stops the container (not the same with `pause`) using the default 10 second timeout.
     pub fn stop(&self) -> Result<()> {
         self.rt().block_on(self.async_impl().stop())
     }
 
+    /// Stops the container with timeout before issuing SIGKILL (not the same with `pause`).
+    ///
+    /// Set Some(-1) to wait indefinitely, None to use system configured default and Some(0)
+    /// to forcibly stop the container immediately - otherwise the runtime will issue SIGINT
+    /// and then wait timeout_seconds seconds for the process to stop before issuing SIGKILL.
+    pub fn stop_with_timeout(&self, timeout_seconds: Option<i64>) -> Result<()> {
+        self.rt()
+            .block_on(self.async_impl().stop_with_timeout(timeout_seconds))
+    }
+
     /// Starts the container.
     pub fn start(&self) -> Result<()> {
         self.rt().block_on(self.async_impl().start())

testcontainers/src/runners/async_runner.rs

@@ -289,8 +289,7 @@ where
             res => res,
         }?;
 
-        let copy_to_sources: Vec<&CopyToContainer> =
-            container_req.copy_to_sources().map(Into::into).collect();
+        let copy_to_sources: Vec<&CopyToContainer> = container_req.copy_to_sources().collect();
 
         for copy_to_source in copy_to_sources {
             client

testcontainers/src/watchdog.rs

@@ -34,7 +34,7 @@ static WATCHDOG: Lazy<Mutex<Watchdog>> = Lazy::new(|| {
                     .unwrap_or_default()
                 {
                     signal_docker
-                        .stop(&container_id)
+                        .stop(&container_id, None)
                         .await
                         .expect("failed to stop container");
                     signal_docker