feat: Adds option to stop containers with a timeout

Previously containers were stopped with no timeout (SIGKILL) which was interfering with
clean shutdown of processes being tested. This commit adds a new API of
stop_with_timeout(timeout_secconds) in addition to the original stop(). The original
stop() interface calls stop_with_timeout using the default '0'.

Author: o087D

testcontainers/src/core/client.rs

@@ -162,9 +162,12 @@ 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: i64) -> Result<(), ClientError> {
         self.bollard
-            .stop_container(id, None)
+            .stop_container(
+                id,
+                Some(bollard::container::StopContainerOptions { t: timeout_seconds }),
+            )
             .await
             .map_err(ClientError::StopContainer)
     }

testcontainers/src/core/containers/async_container.rs

@@ -282,9 +282,22 @@ where
 
     /// Stops the container (not the same with `pause`).
     pub async fn stop(&self) -> Result<()> {
-        log::debug!("Stopping docker container {}", self.id);
+        self.stop_with_timeout(0).await?;
+        Ok(())
+    }
+
+    /// Stops the container with timeout before issuing SIGKILL (not the same with `pause`).
+    ///
+    /// Set -1 for immediate SIGKILL, otherwise the runtime will issue SIGINT and then wait
+    /// the specified number of seconds for process to stop before issunging SIGKILL.
+    pub async fn stop_with_timeout(&self, timeout_seconds: i64) -> Result<()> {
+        log::debug!(
+            "Stopping docker container {} with {} second timeout",
+            self.id,
+            timeout_seconds
+        );
 
-        self.docker_client.stop(&self.id).await?;
+        self.docker_client.stop(&self.id, timeout_seconds).await?;
         Ok(())
     }
 

testcontainers/src/core/containers/sync_container.rs

@@ -132,6 +132,14 @@ where
         self.rt().block_on(self.async_impl().stop())
     }
 
+    /// Stops the container with timeout before issuing SIGKILL (not the same with `pause`).
+    ///
+    /// Set -1 for immediate SIGKILL, otherwise the runtime will issue SIGINT and then wait
+    /// the specified number of seconds for process to stop before issunging SIGKILL.
+    pub fn stop_with_timeout(&self, timeout_seconds: 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/watchdog.rs

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