feat: redirect MAPDL console output to a file

doc/changelog.d/3596.miscellaneous.md

@@ -0,0 +1 @@
+feat: redirect MAPDL console output to a file

src/ansys/mapdl/core/launcher.py

@@ -35,7 +35,7 @@
 import subprocess  # nosec B404
 import threading
 import time
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union
 import warnings
 
 import psutil
@@ -115,6 +115,7 @@
     "license_type",
     "log_apdl",
     "loglevel",
+    "mapdl_output",
     "mode",
     "nproc",
     "override",
@@ -437,6 +438,7 @@
     run_location: str = None,
     env_vars: Optional[Dict[str, str]] = None,
     launch_on_hpc: bool = False,
+    mapdl_output: Optional[str] = None,
 ) -> subprocess.Popen:
     """Start MAPDL locally in gRPC mode.
 
@@ -456,6 +458,9 @@
         If running on an HPC, this needs to be :class:`True` to avoid the
         temporary file creation on Windows.
 
+    mapdl_output : str, optional
+        Whether redirect MAPDL console output (stdout and stderr) to a file.
+
     Returns
     -------
     subprocess.Popen
@@ -487,6 +492,13 @@
         "\n============"
     )
 
+    if mapdl_output:
+        stdout = open(str(mapdl_output), "wb", 0)
+        stderr = subprocess.STDOUT
+    else:
+        stdout = subprocess.PIPE
+        stderr = subprocess.PIPE
+
     if os.name == "nt":
         # getting tmp file name
         if not launch_on_hpc:
@@ -505,8 +517,8 @@
         shell=shell,  # sbatch does not work without shell.
         cwd=run_location,
         stdin=subprocess.DEVNULL,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
+        stdout=stdout,
+        stderr=stderr,
         env_vars=env_vars,
     )
 
@@ -554,7 +566,7 @@
 
         if os.name == "posix" and not ON_WSL:
             LOG.debug("Checking if gRPC server is alive.")
-            _check_server_is_alive(stdout_queue, run_location, timeout)
+            _check_server_is_alive(stdout_queue, timeout)
 
     except MapdlDidNotStart as e:  # pragma: no cover
         msg = (
@@ -596,7 +608,11 @@
         raise MapdlDidNotStart(msg)
 
 
-def _check_server_is_alive(stdout_queue, run_location, timeout):
+def _check_server_is_alive(stdout_queue, timeout):
+    if not stdout_queue:
+        LOG.debug("No STDOUT queue. Not checking MAPDL this way.")
+        return
+
     t0 = time.time()
     empty_attemps = 3
     empty_i = 0
@@ -629,6 +645,9 @@
 
 
 def _get_std_output(std_queue, timeout=1):
+    if not std_queue:
+        return [None]
+
     lines = []
     reach_empty = False
     t0 = time.time()
@@ -642,10 +661,15 @@
     return lines
 
 
-def _create_queue_for_std(std):
+def _create_queue_for_std(
+    std: subprocess.PIPE,
+) -> Tuple[Optional[Queue[str]], Optional[threading.Thread]]:
     """Create a queue and thread objects for a given PIPE std"""
+    if not std:
+        LOG.debug("No STDOUT. Not checking MAPDL this way.")
+        return None, None
 
-    def enqueue_output(out, queue):
+    def enqueue_output(out: subprocess.PIPE, queue: Queue[str]) -> None:
         try:
             for line in iter(out.readline, b""):
                 queue.put(line)
@@ -655,16 +679,16 @@
             # ValueError: PyMemoryView_FromBuffer(): info -> buf must not be NULL
             pass
 
-    q = Queue()
-    t = threading.Thread(target=enqueue_output, args=(std, q))
+    q: Queue[str] = Queue()
+    t: threading.Thread = threading.Thread(target=enqueue_output, args=(std, q))
     t.daemon = True  # thread dies with the program
     t.start()
 
     return q, t
 
 
 def launch_remote_mapdl(
-    version: str = None,
+    version: Optional[str] = None,
     cleanup_on_exit: bool = True,
 ) -> MapdlGrpc:
     """Start MAPDL remotely using the product instance management API.
@@ -1020,6 +1044,7 @@
     version: Optional[Union[int, str]] = None,
     running_on_hpc: bool = True,
     launch_on_hpc: bool = False,
+    mapdl_output: Optional[str] = None,
     **kwargs: Dict[str, Any],
 ) -> Union[MapdlGrpc, "MapdlConsole"]:
     """Start MAPDL locally.
@@ -1205,6 +1230,9 @@
         to specify the scheduler arguments as a string or as a dictionary.
         For more information, see :ref:`ref_hpc_slurm`.
 
+    mapdl_output : str, optional
+        Redirect the MAPDL console output to a given file.
+
     kwargs : dict, Optional
         These keyword arguments are interface-specific or for
         development purposes. For more information, see Notes.
@@ -1575,6 +1603,7 @@
                 run_location=args["run_location"],
                 env_vars=env_vars,
                 launch_on_hpc=args.get("launch_on_hpc"),
+                mapdl_output=args.get("mapdl_output"),
             )
 
             if args["launch_on_hpc"]:

src/ansys/mapdl/core/mapdl_grpc.py

@@ -650,7 +650,7 @@ def _read_stds(self):
             _get_std_output,  # Avoid circular import error
         )
 
-        if self._mapdl_process is None:
+        if self._mapdl_process is None or not self._mapdl_process.stdout:
             return
 
         self._log.debug("Reading stdout")
@@ -2701,7 +2701,7 @@ def _download_as_raw(self, target_name: str) -> str:
     @property
     def is_alive(self) -> bool:
         """True when there is an active connect to the gRPC server"""
-        if self.channel_state not in ["IDLE", "READY"]:
+        if self.channel_state not in ["IDLE", "READY", None]:
             self._log.debug(
                 "MAPDL instance is not alive because the channel is not 'IDLE' o 'READY'."
             )

tests/test_launcher.py

@@ -1947,3 +1947,60 @@ def raising():
 @patch("ansys.mapdl.core.launcher.check_valid_ansys", raising)
 def test_check_has_mapdl_failed():
     assert check_has_mapdl() is False
+
+
+@requires("local")
+@patch("ansys.mapdl.core.launcher._is_ubuntu", lambda *args, **kwargs: True)
+@patch("ansys.mapdl.core.launcher.check_mapdl_launch", lambda *args, **kwargs: None)
+def test_mapdl_output_pass_arg(tmpdir):
+    def submitter(*args, **kwargs):
+        from _io import FileIO
+
+        # Checking we are passing the arguments
+        assert isinstance(kwargs["stdout"], FileIO)
+        assert kwargs["stderr"] is subprocess.STDOUT
+
+        return
+
+    with patch("ansys.mapdl.core.launcher.submitter", submitter) as mck_sub:
+        mapdl_output = os.path.join(tmpdir, "apdl.txt")
+        args = launch_mapdl(just_launch=True, mapdl_output=mapdl_output)
+
+    assert isinstance(args, list)
+
+
+@requires("local")
+@requires("nostudent")
+def test_mapdl_output(tmpdir):
+    mapdl_output = os.path.join(tmpdir, "apdl.txt")
+    mapdl = launch_mapdl(mapdl_output=mapdl_output, port=50058)
+
+    assert os.path.exists(mapdl_output)
+
+    mapdl.prep7()
+    mapdl.exit(force=True)
+
+    with open(mapdl_output, "r") as fid:
+        content = fid.read()
+
+    assert "Beta activation of the GRPC server." in content
+    assert "### START GRPC SERVER      ###" in content
+    assert "Server listening on" in content
+
+
+def test_check_server_is_alive_no_queue():
+    from ansys.mapdl.core.launcher import _check_server_is_alive
+
+    assert _check_server_is_alive(None, 30) is None
+
+
+def test_get_std_output_no_queue():
+    from ansys.mapdl.core.launcher import _get_std_output
+
+    assert _get_std_output(None, 30) == [None]
+
+
+def test_create_queue_for_std_no_queue():
+    from ansys.mapdl.core.launcher import _create_queue_for_std
+
+    assert _create_queue_for_std(None) == (None, None)