feat: avoiding reconnecting if MAPDL exited already (#3708)

* test: refactor check_stds and post_mortem_checks

* test: backing off algorithm

* chore: adding changelog file 3703.added.md [dependabot-skip]

* fix: codacity warnings

* feat: using get_value to obtain the n elements

* revert: revert "feat: using get_value to obtain the n elements"
Performance is not as go

This reverts commit 877f803.

* feat: using get_value to obtain the n elements

* revert: revert "feat: using get_value to obtain the n elements"
Performance is not as go

This reverts commit 877f803.

* feat: using mapdl.exit when raising final error.

* test: fix test by avoiding killing mapdl.

* fix: test

* fix: test

* feat: adding warnings when restarting MAPDL during testing

* fix: test

* feat: caching requires_package

* test: adding more tests

* chore: adding changelog file 3705.added.md [dependabot-skip]

* chore: adding changelog file 3705.added.md [dependabot-skip]

* fix: warnings import

* feat: not reconnecting if MAPDL already exited

* test: adding tests

* chore: adding changelog file 3708.miscellaneous.md [dependabot-skip]

* fix: tests

---------

Co-authored-by: pyansys-ci-bot <[email protected]>

Author: germa89

doc/changelog.d/3708.miscellaneous.md

@@ -0,0 +1 @@
+feat: avoiding reconnecting if MAPDL exited already

src/ansys/mapdl/core/errors.py

@@ -323,25 +323,29 @@ def wrapper(*args, **kwargs):
             except grpc.RpcError as error:
 
                 mapdl = retrieve_mapdl_from_args(args)
+
                 mapdl._log.debug("A gRPC error has been detected.")
 
-                i_attemps += 1
-                if i_attemps <= n_attempts:
+                if not mapdl.exited:
+                    i_attemps += 1
+                    if i_attemps <= n_attempts:
 
-                    wait = (
-                        initial_backoff * multiplier_backoff**i_attemps
-                    )  # Exponential backoff
-                    sleep(wait)
+                        wait = (
+                            initial_backoff * multiplier_backoff**i_attemps
+                        )  # Exponential backoff
 
-                    # reconnect
-                    mapdl._log.debug(
-                        f"Re-connection attempt {i_attemps} after waiting {wait:0.3f} seconds"
-                    )
+                        # reconnect
+                        mapdl._log.debug(
+                            f"Re-connection attempt {i_attemps} after waiting {wait:0.3f} seconds"
+                        )
 
-                    connected = mapdl._connect(timeout=wait)
+                        if not mapdl.is_alive:
+                            connected = mapdl._connect(timeout=wait)
+                        else:
+                            sleep(wait)
 
-                    # Retry again
-                    continue
+                        # Retry again
+                        continue
 
                 # Custom errors
                 reason = ""

tests/test_cli.py

@@ -76,8 +76,79 @@ def test_launch_mapdl_cli(monkeypatch, run_cli, start_instance):
     # grab ips and port
     pid = int(re.search(r"\(PID=(\d+)\)", output).groups()[0])
 
-    output = run_cli(f"stop --port {PORT1}")
-    assert "success" in output.lower()
+
+@requires("click")
+@pytest.mark.parametrize(
+    "mapping",
+    ((False, True), (False, True, False), (False, False, False), (True, True, False)),
+)
+def test_pymapdl_stop_instances(run_cli, mapping):
+
+    fake_process_ = [
+        {
+            "pid": np.random.randint(10000, 100000),
+            "name": f"ansys251_{ind}" if each else "process",
+            "port": str(50052 + ind),
+            "ansys_process": each,
+        }
+        for ind, each in enumerate(mapping)
+    ]
+
+    fake_processes = [make_fake_process(**each) for each in fake_process_]
+
+    with (
+        patch("ansys.mapdl.core.cli.stop._kill_process") as mock_kill,
+        patch("psutil.pid_exists") as mock_pid,
+        patch("psutil.process_iter", return_value=iter(fake_processes)),
+    ):
+
+        mock_pid.return_value = lambda *args, **kwargs: True  # All process exists
+        mock_kill.side_effect = lambda *args, **kwargs: None  # avoid kill nothing
+
+        if sum(mapping) == 0:
+            output = run_cli(f"stop --port {PORT1}")
+            assert (
+                f"error: no ansys instances running on port {PORT1}" in output.lower()
+            )
+            mock_kill.assert_not_called()
+
+            output = run_cli(f"stop --all")
+            assert f"error: no ansys instances have been found." in output.lower()
+            mock_kill.assert_not_called()
+
+        elif sum(mapping) == 1:
+            # Port
+            process, process_mock = [
+                (each, each_mock)
+                for each, each_mock in zip(fake_process_, fake_processes)
+                if "ansys251" in each["name"]
+            ][0]
+            port = process["port"]
+
+            output = run_cli(f"stop --port {port}")
+            assert (
+                f"success: ansys instances running on port {port} have been stopped"
+                in output.lower()
+            )
+
+            # PID
+            pid = process["pid"]
+            with patch("psutil.Process") as mock_process:
+                mock_process.return_value = process_mock
+
+                output = run_cli(f"stop --pid {pid}")
+                assert (
+                    f"the process with pid {pid} and its children have been stopped."
+                    in output.lower()
+                )
+
+            mock_kill.assert_called()
+            assert mock_kill.call_count == 2
+
+        else:
+            output = run_cli(f"stop --all")
+            assert "success: ansys instances have been stopped." in output.lower()
+            assert mock_kill.call_count == sum(mapping)
 
 
 @requires("click")

tests/test_mapdl.py

@@ -2599,3 +2599,119 @@ def test_comment_on_debug_mode(mapdl, cleared):
     mockcom.assert_called_once_with("Entering in non_interactive mode")
 
     mapdl.logger.logger.level = loglevel
+
+
+@patch("ansys.mapdl.core.errors.N_ATTEMPTS", 2)
+@patch("ansys.mapdl.core.errors.MULTIPLIER_BACKOFF", 1)
+@pytest.mark.parametrize("is_exited", [True, False])
+def test_timeout_when_exiting(mapdl, is_exited):
+    from ansys.mapdl.core import errors
+
+    def raise_exception(*args, **kwargs):
+        from grpc import RpcError
+
+        e = RpcError("My patched error")
+        e.code = lambda: grpc.StatusCode.ABORTED
+        e.details = lambda: "My gRPC error details"
+
+        # Simulating MAPDL exiting by force
+        mapdl._exited = is_exited
+
+        raise e
+
+    handle_generic_grpc_error = errors.handle_generic_grpc_error
+
+    with (
+        patch("ansys.mapdl.core.mapdl_grpc.pb_types.CmdRequest") as mock_cmdrequest,
+        patch(
+            "ansys.mapdl.core.mapdl_grpc.MapdlGrpc.is_alive", new_callable=PropertyMock
+        ) as mock_is_alive,
+        patch.object(mapdl, "_connect") as mock_connect,
+        patch(
+            "ansys.mapdl.core.errors.handle_generic_grpc_error", autospec=True
+        ) as mock_handle,
+        patch.object(mapdl, "_exit_mapdl") as mock_exit_mapdl,
+    ):
+
+        mock_exit_mapdl.return_value = None  # Avoid exiting
+        mock_is_alive.return_value = False
+        mock_connect.return_value = None  # patched to avoid timeout
+        mock_cmdrequest.side_effect = raise_exception
+        mock_handle.side_effect = handle_generic_grpc_error
+
+        with pytest.raises(MapdlExitedError):
+            mapdl.prep7()
+
+        # After
+        assert mapdl._exited
+
+        assert mock_handle.call_count == 1
+
+        if is_exited:
+            # Checking no trying to reconnect
+            assert mock_connect.call_count == 0
+            assert mock_cmdrequest.call_count == 1
+            assert mock_is_alive.call_count == 1
+
+        else:
+            assert mock_connect.call_count == errors.N_ATTEMPTS
+            assert mock_cmdrequest.call_count == errors.N_ATTEMPTS + 1
+            assert mock_is_alive.call_count == errors.N_ATTEMPTS + 1
+
+        mapdl._exited = False
+
+
+@pytest.mark.parametrize(
+    "cmd,arg",
+    (
+        ("block", None),
+        ("nsel", None),
+        ("esel", None),
+        ("ksel", None),
+        ("modopt", None),
+    ),
+)
+def test_none_as_argument(mapdl, make_block, cmd, arg):
+    if "sel" in cmd:
+        kwargs = {"wraps": mapdl._run}
+    else:
+        kwargs = {}
+
+    with patch.object(mapdl, "_run", **kwargs) as mock_run:
+
+        mock_run.assert_not_called()
+
+        func = getattr(mapdl, cmd)
+        out = func(arg)
+
+        mock_run.assert_called()
+
+        if "sel" in cmd:
+            assert isinstance(out, np.ndarray)
+            assert len(out) == 0
+
+        cmd = mock_run.call_args_list[0].args[0]
+        assert isinstance(cmd, str)
+        assert "NONE" in cmd.upper()
+
+
+@pytest.mark.parametrize("func", ["ksel", "lsel", "asel", "vsel"])
+def test_none_on_selecting(mapdl, cleared, func):
+    mapdl.block(0, 1, 0, 1, 0, 1)
+
+    selfunc = getattr(mapdl, func)
+
+    assert len(selfunc("all")) > 0
+    assert len(selfunc(None)) == 0
+
+
+@requires("pyvista")
+def test_requires_package_speed():
+    from ansys.mapdl.core.misc import requires_package
+
+    @requires_package("pyvista")
+    def my_func(i):
+        return i + 1
+
+    for i in range(1_000_000):
+        my_func(i)