fixing timeout for container launch

Author: raph-luc

src/ansys/fluent/core/launcher/container_launcher.py

@@ -216,13 +216,17 @@ def __call__(self):
 
         if is_compose():
             port, config_dict, container = start_fluent_container(
-                self._args, self.argvals["container_dict"]
+                self._args,
+                self.argvals["container_dict"],
+                self.argvals["start_timeout"],
             )
 
             _, _, password = _get_server_info_from_container(config_dict=config_dict)
         else:
             port, password, container = start_fluent_container(
-                self._args, self.argvals["container_dict"]
+                self._args,
+                self.argvals["container_dict"],
+                self.argvals["start_timeout"],
             )
 
         fluent_connection = FluentConnection(

src/ansys/fluent/core/launcher/error_handler.py

@@ -70,7 +70,7 @@ class LaunchFluentError(Exception):
 
     def __init__(self, launch_string):
         """__init__ method of LaunchFluentError class."""
-        details = "\n" + "Fluent Launch string: " + launch_string
+        details = "\n" + "Fluent Launch command: " + launch_string
         super().__init__(details)
 
 

src/ansys/fluent/core/launcher/fluent_container.py

@@ -80,6 +80,9 @@
 
 import ansys.fluent.core as pyfluent
 from ansys.fluent.core.docker.docker_compose import ComposeBasedLauncher
+from ansys.fluent.core.launcher.error_handler import (
+    LaunchFluentError,
+)
 from ansys.fluent.core.launcher.launcher_utils import is_compose
 from ansys.fluent.core.session import _parse_server_info_file
 from ansys.fluent.core.utils.deprecate import all_deprecators
@@ -155,7 +158,6 @@ def configure_container_dict(
     args: List[str],
     mount_source: str | Path | None = None,
     mount_target: str | Path | None = None,
-    timeout: int | None = None,
     port: int | None = None,
     license_server: str | None = None,
     container_server_info_file: str | Path | None = None,
@@ -179,8 +181,6 @@ def configure_container_dict(
     mount_target : str | Path, optional
         Path inside the container where ``mount_source`` will be mounted. This will be the working directory path
         visible to the Fluent process running inside the container.
-    timeout : int, optional
-        Time limit  for the Fluent container to start, in seconds. By default, 60 seconds.
     port : int, optional
         Port for Fluent container to use.
     license_server : str, optional
@@ -206,7 +206,6 @@ def configure_container_dict(
     -------
     fluent_image : str
     container_dict : dict
-    timeout : int
     port : int
     host_server_info_file : Path
     remove_server_info_file: bool
@@ -230,8 +229,6 @@ def configure_container_dict(
 
     See also :func:`start_fluent_container`.
     """
-    if timeout is None:
-        timeout = int(os.getenv("PYFLUENT_FLUENT_LAUNCH_TIMEOUT", "60"))
 
     logger.debug(f"container_dict before processing:\n{dict_to_str(container_dict)}")
 
@@ -446,23 +443,22 @@ def configure_container_dict(
         container_dict["mount_target"] = mount_target
 
     logger.debug(
-        f"Fluent container timeout: {timeout}, container_grpc_port: {container_grpc_port}, "
+        f"Fluent container container_grpc_port: {container_grpc_port}, "
         f"host_server_info_file: '{host_server_info_file}', "
         f"remove_server_info_file: {remove_server_info_file}"
     )
     logger.debug(f"container_dict after processing:\n{dict_to_str(container_dict)}")
 
     return (
         container_dict,
-        timeout,
         container_grpc_port,
         host_server_info_file,
         remove_server_info_file,
     )
 
 
 def start_fluent_container(
-    args: List[str], container_dict: dict | None = None
+    args: List[str], container_dict: dict | None = None, start_timeout: int = 60
 ) -> tuple[int, str, Any]:
     """Start a Fluent container.
 
@@ -472,6 +468,9 @@ def start_fluent_container(
         List of Fluent launch arguments.
     container_dict : dict, optional
         Dictionary with Docker container configuration.
+    start_timeout : int, optional
+        Timeout in seconds for the container to start. If not specified, it defaults to 60
+        seconds.
 
     Returns
     -------
@@ -500,11 +499,11 @@ def start_fluent_container(
 
     (
         config_dict,
-        timeout,
         port,
         host_server_info_file,
         remove_server_info_file,
     ) = container_vars
+    launch_string = " ".join(config_dict["command"])
 
     try:
         if is_compose():
@@ -538,20 +537,26 @@ def start_fluent_container(
                 config_dict.pop("fluent_image"), **config_dict
             )
 
-            logger.debug(f"Waiting for container for up to {timeout} seconds...")
+            logger.debug(
+                f"Waiting for Fluent container for up to {start_timeout} seconds..."
+            )
 
             success = timeout_loop(
-                lambda: host_server_info_file.stat().st_mtime > last_mtime, timeout
+                lambda: host_server_info_file.stat().st_mtime > last_mtime,
+                start_timeout,
             )
 
             if not success:
                 raise TimeoutError(
-                    f"Fluent container launch has timed out after {timeout} seconds. Container will need to be stopped manually."
+                    f"Fluent container launch has timed out after {start_timeout} seconds. Container will need to be stopped manually."
                 )
             else:
                 _, _, password = _parse_server_info_file(str(host_server_info_file))
 
                 return port, password, container
+    except Exception as ex:
+        logger.error(f"Exception caught - {type(ex).__name__}: {ex}")
+        raise LaunchFluentError(launch_string) from ex
     finally:
         if remove_server_info_file and host_server_info_file.exists():
             host_server_info_file.unlink()

src/ansys/fluent/core/launcher/launcher.py

@@ -207,9 +207,8 @@ def launch_fluent(
         The string path to a Fluent journal file, or a list of such paths. Fluent will execute the
         journal(s). The default is ``None``.
     start_timeout : int, optional
-        Maximum allowable time in seconds for connecting to the Fluent
-        server. The default is ``60`` if Fluent is launched outside a Slurm environment,
-        no timeout if Fluent is launched within a Slurm environment.
+        Maximum allowable time, in seconds, to connect to the Fluent server after launching it,
+        before raising a timeout error. The default is ``60`` seconds.
     additional_arguments : str, optional
         Additional arguments to send to Fluent as a string in the same
         format they are normally passed to Fluent on the command line.
@@ -323,6 +322,9 @@ def launch_fluent(
     if env is None:
         env = {}
 
+    if start_timeout is None:
+        start_timeout = int(os.getenv("PYFLUENT_FLUENT_LAUNCH_TIMEOUT", "60"))
+
     def _mode_to_launcher_type(fluent_launch_mode: LaunchMode):
         launcher_mode_type = {
             LaunchMode.CONTAINER: DockerLauncher,

tests/test_launcher.py

@@ -87,11 +87,10 @@ def test_mode():
         )
 
 
-@pytest.mark.standalone
 def test_unsuccessful_fluent_connection():
-    # start-timeout is intentionally provided to be 2s for the connection to fail
+    # start-timeout is intentionally provided to be 1s for the connection to fail
     with pytest.raises(LaunchFluentError) as ex:
-        pyfluent.launch_fluent(mode="solver", start_timeout=2)
+        pyfluent.launch_fluent(mode="solver", start_timeout=1)
     # TimeoutError -> LaunchFluentError
     assert isinstance(ex.value.__context__, TimeoutError)