Allow pool to connect to remote MAPDL instances

src/ansys/mapdl/core/errors.py

@@ -316,7 +316,9 @@ def wrapper(*args, **kwargs):
 
             # Must close unfinished processes
             mapdl._close_process()
-            raise MapdlExitedError("MAPDL server connection terminated") from None
+            raise MapdlExitedError(
+                f"MAPDL server connection terminated with the following error\n{error}"
+            ) from None
 
         if threading.current_thread().__class__.__name__ == "_MainThread":
             received_interrupt = bool(SIGINT_TRACKER)

src/ansys/mapdl/core/launcher.py

@@ -820,6 +820,11 @@ def get_start_instance(start_instance: bool = True):
         )
         return start_instance
 
+    elif start_instance is None:
+        LOG.debug(
+            f"'PYMAPDL_START_INSTANCE' is unset, and there is no supplied value, hence using default value 'True'"
+        )
+        return True  # Default is true
     else:
         raise ValueError("Only booleans are allowed as arguments.")
 

src/ansys/mapdl/core/mapdl_grpc.py

@@ -880,7 +880,9 @@ def _run(self, cmd: str, verbose: bool = False, mute: Optional[bool] = None) ->
             mute = self._mute
 
         if self._exited:
-            raise MapdlExitedError
+            raise MapdlExitedError(
+                f"The MAPDL instance has been exited before running the command: {cmd}"
+            )
 
         # don't allow empty commands
         if not cmd.strip():
@@ -1141,6 +1143,7 @@ def _close_process(self, timeout=2):  # pragma: no cover
         processes making this method ineffective for a local instance of MAPDL.
 
         """
+        self._log.debug(f"Closing processes")
         if self._local:
             # killing server process
             self._kill_server()

src/ansys/mapdl/core/pool.py

@@ -25,12 +25,16 @@
 import shutil
 import tempfile
 import time
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 import warnings
 
 from ansys.mapdl.core import LOG, launch_mapdl
 from ansys.mapdl.core.errors import MapdlRuntimeError, VersionError
-from ansys.mapdl.core.launcher import MAPDL_DEFAULT_PORT, port_in_use
+from ansys.mapdl.core.launcher import (
+    MAPDL_DEFAULT_PORT,
+    get_start_instance,
+    port_in_use,
+)
 from ansys.mapdl.core.mapdl_grpc import _HAS_TQDM
 from ansys.mapdl.core.misc import create_temp_dir, threaded, threaded_daemon
 
@@ -114,6 +118,11 @@ class LocalMapdlPool:
         the index of each instance in the pool.
         By default, the instances directories are named as "Instances_{i}".
 
+    start_instance : bool
+        Set it to ``False`` to make PyMAPDL to connect to remote instances instead
+        of launching them. In that case, you need to supply the MAPDL instances
+        ports as a list of ``int``s.
+
     **kwargs : dict, optional
         Additional keyword arguments. For a complete listing, see the description for the
         :func:`ansys.mapdl.core.launcher.launch_mapdl` method.
@@ -154,12 +163,14 @@ def __init__(
         n_instances: int,
         wait: bool = True,
         run_location: Optional[str] = None,
-        port: int = MAPDL_DEFAULT_PORT,
+        port: Union[int, List[int]] = MAPDL_DEFAULT_PORT,
         progress_bar: bool = DEFAULT_PROGRESS_BAR,
         restart_failed: bool = True,
         remove_temp_files: bool = True,
         names: Optional[str] = None,
         override=True,
+        start_instance: bool = None,
+        exec_file: Optional[str] = None,
         **kwargs,
     ) -> None:
         """Initialize several instances of mapdl"""
@@ -176,6 +187,11 @@ def __init__(
         self._exiting_i: int = 0
         self._override = override
 
+        # Getting start_instance
+        start_instance = get_start_instance(start_instance)
+        self._start_instance = start_instance
+        LOG.debug(f"'start_instance' equals to '{start_instance}'")
+
         if not names:
             names = "Instance"
 
@@ -189,34 +205,55 @@ def __init__(
             )
 
         # verify that mapdl is 2021R1 or newer
-        if "exec_file" in kwargs:
-            exec_file = kwargs["exec_file"]
-        else:  # get default executable
+        if start_instance:
+            if "exec_file" in kwargs:
+                exec_file = kwargs["exec_file"]
+            else:  # get default executable
+                if _HAS_ATP:
+                    exec_file = get_ansys_path()
+                else:
+                    raise ValueError(
+                        "Please use 'exec_file' argument to specify the location of the ansys installation.\n"
+                        "Alternatively, PyMAPDL can detect your ansys installation if you install 'ansys-tools-path' library."
+                    )
+
+                if exec_file is None:
+                    raise FileNotFoundError(
+                        "Invalid exec_file path or cannot load cached "
+                        "ansys path.  Enter one manually using "
+                        "exec_file=<path to executable>"
+                    )
+
             if _HAS_ATP:
-                exec_file = get_ansys_path()
-            else:
-                raise ValueError(
-                    "Please use 'exec_file' argument to specify the location of the ansys installation.\n"
-                    "Alternatively, PyMAPDL can detect your ansys installation if you install 'ansys-tools-path' library."
-                )
+                if version_from_path("mapdl", exec_file) < 211:
+                    raise VersionError("LocalMapdlPool requires MAPDL 2021R1 or later.")
 
-            if exec_file is None:
-                raise FileNotFoundError(
-                    "Invalid exec_file path or cannot load cached "
-                    "ansys path.  Enter one manually using "
-                    "exec_file=<path to executable>"
-                )
+        else:
+            exec_file = None
 
-        if _HAS_ATP:
-            if version_from_path("mapdl", exec_file) < 211:
-                raise VersionError("LocalMapdlPool requires MAPDL 2021R1 or later.")
+        self._exec_file = exec_file
 
         # grab available ports
-        ports = available_ports(n_instances, port)
+        if start_instance:
+            if isinstance(port, int) or len(port) == 1:
+                ports = available_ports(n_instances, port)
+            else:
+                ports = port
 
-        if self._root_dir is not None:
-            if not os.path.isdir(self._root_dir):
-                os.makedirs(self._root_dir)
+            if self._root_dir is not None:
+                if not os.path.isdir(self._root_dir):
+                    os.makedirs(self._root_dir)
+        else:
+            if isinstance(port, int) or len(port) == 1:
+                ports = [port + i for i in range(n_instances)]
+            else:
+                ports = port
+
+        if len(ports) != n_instances:
+            raise ValueError(
+                "The number of instances should be the same as the number of ports."
+            )
+        LOG.debug(f"Using ports: {ports}")
 
         self._instances = []
         self._active = True  # used by pool monitor
@@ -241,7 +278,13 @@ def __init__(
         # threaded spawn
         threads = [
             self._spawn_mapdl(
-                i, ports[i], pbar, name=self._names(i), thread_name=self._names(i)
+                i,
+                ports[i],
+                pbar,
+                name=self._names(i),
+                thread_name=self._names(i),
+                start_instance=start_instance,
+                exec_file=exec_file,
             )
             for i in range(n_instances)
         ]
@@ -612,8 +655,6 @@ def next_available(self, return_index=False):
                             return instance, i
                         else:
                             return instance
-                    else:
-                        instance._exited = True
 
     def __del__(self):
         self.exit()
@@ -688,7 +729,13 @@ def __iter__(self):
 
     @threaded_daemon
     def _spawn_mapdl(
-        self, index: int, port: int = None, pbar: Optional[bool] = None, name: str = ""
+        self,
+        index: int,
+        port: int = None,
+        pbar: Optional[bool] = None,
+        name: str = "",
+        start_instance=True,
+        exec_file=None,
     ):
         """Spawn a mapdl instance at an index"""
         # create a new temporary directory for each instance
@@ -697,9 +744,11 @@ def _spawn_mapdl(
         run_location = create_temp_dir(self._root_dir, name=name)
 
         self._instances[index] = launch_mapdl(
+            exec_file=exec_file,
             run_location=run_location,
             port=port,
             override=True,
+            start_instance=start_instance,
             **self._spawn_kwargs,
         )
 
@@ -726,20 +775,26 @@ def _monitor_pool(self, refresh=1.0):
         """
         while self._active:
             for index, instance in enumerate(self._instances):
-                name = self._names[index]
+                name = self._names(index)
                 if not instance:  # encountered placeholder
                     continue
 
                 if instance._exited:
                     try:
                         # use the next port after the current available port
                         self._spawning_i += 1
-                        port = max(self._ports) + 1
+                        if self._start_instance:
+                            port = max(self._ports) + 1
+                        else:
+                            port = instance.port
+
                         self._spawn_mapdl(
                             index,
                             port=port,
                             name=name,
                             thread_name=name,
+                            exec_file=self._exec_file,
+                            start_instance=self._start_instance,
                         ).join()
 
                     except Exception as e:

tests/test_pool.py

@@ -27,7 +27,7 @@
 import numpy as np
 import pytest
 
-from conftest import ON_STUDENT, has_dependency
+from conftest import ON_LOCAL, START_INSTANCE, has_dependency
 
 if has_dependency("ansys-tools-path"):
     from ansys.tools.path import find_ansys
@@ -37,7 +37,7 @@
 else:
     EXEC_FILE = os.environ.get("PYMAPDL_MAPDL_EXEC")
 
-if not EXEC_FILE or ON_STUDENT:
+if not ON_LOCAL:
     pytest.skip(allow_module_level=True)
 
 from ansys.mapdl.core import LocalMapdlPool, examples
@@ -67,11 +67,13 @@
 def pool(tmpdir_factory):
     run_path = str(tmpdir_factory.mktemp("ansys_pool"))
 
+    port = os.environ.get("PYMAPDL_PORT", 50056)
+
     mapdl_pool = LocalMapdlPool(
-        4,
+        2,
         license_server_check=False,
         run_location=run_path,
-        port=50056,
+        port=port,
         start_timeout=30,
         exec_file=EXEC_FILE,
         additional_switches=QUICK_LAUNCH_SWITCHES,
@@ -111,7 +113,6 @@ def test_invalid_exec():
 
 
 # @pytest.mark.xfail(strict=False, reason="Flaky test. See #2435")
-@requires("local")
 def test_heal(pool):
     pool_sz = len(pool)
     pool_names = pool._names  # copy pool names
@@ -131,15 +132,13 @@ def test_heal(pool):
     pool._verify_unique_ports()
 
 
-@requires("local")
 @skip_if_ignore_pool
 def test_simple_map(pool):
     pool_sz = len(pool)
     _ = pool.map(lambda mapdl: mapdl.prep7())
     assert len(pool) == pool_sz
 
 
-@requires("local")
 @skip_if_ignore_pool
 def test_map_timeout(pool):
     pool_sz = len(pool)
@@ -168,7 +167,6 @@ def func(mapdl, tsleep):
     assert len(pool) == pool_sz
 
 
-@requires("local")
 @skip_if_ignore_pool
 def test_simple(pool):
     pool_sz = len(pool)
@@ -182,16 +180,14 @@ def func(mapdl):
 
 
 # fails intermittently
-@requires("local")
 @skip_if_ignore_pool
 def test_batch(pool):
-    input_files = [examples.vmfiles["vm%d" % i] for i in range(1, 11)]
+    input_files = [examples.vmfiles["vm%d" % i] for i in range(1, len(pool) + 3)]
     outputs = pool.run_batch(input_files)
     assert len(outputs) == len(input_files)
 
 
 # fails intermittently
-@requires("local")
 @skip_if_ignore_pool
 def test_map(pool):
     completed_indices = []
@@ -204,14 +200,16 @@ def func(mapdl, input_file, index):
         completed_indices.append(index)
         return mapdl.parameters.routine
 
-    inputs = [(examples.vmfiles["vm%d" % i], i) for i in range(1, 11)]
+    inputs = [(examples.vmfiles["vm%d" % i], i) for i in range(1, len(pool) + 3)]
     outputs = pool.map(func, inputs, wait=True)
 
     assert len(outputs) == len(inputs)
 
 
-@requires("local")
 @skip_if_ignore_pool
+@pytest.mark.skipif(
+    not START_INSTANCE, reason="This test requires the pool to be local"
+)
 def test_abort(pool, tmpdir):
     pool_sz = len(pool)  # initial pool size
 
@@ -245,17 +243,14 @@ def test_abort(pool, tmpdir):
     assert path_deleted
 
 
-@requires("local")
 @skip_if_ignore_pool
 def test_directory_names_default(pool):
     dirs_path_pool = os.listdir(pool._root_dir)
-    assert "Instance_0" in dirs_path_pool
-    assert "Instance_1" in dirs_path_pool
-    assert "Instance_2" in dirs_path_pool
-    assert "Instance_3" in dirs_path_pool
+    for i, _ in enumerate(pool._instances):
+        assert pool._names(i) in dirs_path_pool
+        assert f"Instance_{i}" in dirs_path_pool
 
 
-@requires("local")
 @skip_if_ignore_pool
 def test_directory_names_custom_string(tmpdir):
     pool = LocalMapdlPool(
@@ -275,7 +270,6 @@ def test_directory_names_custom_string(tmpdir):
     pool.exit(block=True)
 
 
-@requires("local")
 @skip_if_ignore_pool
 def test_directory_names_function(tmpdir):
     def myfun(i):
@@ -313,7 +307,6 @@ def test_num_instances():
         )
 
 
-@requires("local")
 @skip_if_ignore_pool
 def test_only_one_instance():
     pool = LocalMapdlPool(