Add a decorator for our long running operations

This way we can relatively cheaply avoid printing the timeout error
message and return a zero exit code on the timeout.

Signed-off-by: mulhern <amulhern@redhat.com>

Author: mulkieran

src/stratis_cli/_actions/__init__.py

@@ -35,3 +35,4 @@
 from ._stratis import StratisActions
 from ._stratisd_version import check_stratisd_version
 from ._top import TopActions
+from ._utils import get_errors

src/stratis_cli/_actions/_crypt.py

@@ -29,6 +29,7 @@
 from .._stratisd_constants import StratisdErrors
 from ._connection import get_object
 from ._constants import TOP_OBJECT
+from ._utils import long_running_operation
 
 
 class CryptActions:
@@ -37,6 +38,7 @@ class CryptActions:
     """
 
     @staticmethod
+    @long_running_operation(method_names=["EncryptPool"])
     def encrypt(namespace: Namespace):
         """
         Encrypt a previously unencrypted pool.
@@ -97,6 +99,7 @@ def encrypt(namespace: Namespace):
             )
 
     @staticmethod
+    @long_running_operation(method_names=["DecryptPool"])
     def unencrypt(namespace: Namespace):
         """
         Unencrypt a previously encrypted pool.
@@ -138,6 +141,7 @@ def unencrypt(namespace: Namespace):
             )
 
     @staticmethod
+    @long_running_operation(method_names=["ReencryptPool"])
     def reencrypt(namespace: Namespace):
         """
         Reencrypt an already encrypted pool with a new key.

src/stratis_cli/_actions/_utils.py

@@ -22,15 +22,21 @@
 import os
 import sys
 import termios
+from argparse import Namespace
 from enum import Enum
-from typing import Any, Optional, Tuple
+from functools import wraps
+from typing import Any, Callable, Generator, Optional, Sequence, Tuple
 from uuid import UUID
 
 # isort: THIRDPARTY
 from dbus import Dictionary, Struct
+from dbus.exceptions import DBusException
 from dbus.proxies import ProxyObject
 from justbytes import Range
 
+# isort: FIRSTPARTY
+from dbus_python_client_gen import DPClientInvocationError, DPClientMethodCallContext
+
 from .._errors import (
     StratisCliKeyfileNotFoundError,
     StratisCliPassphraseEmptyError,
@@ -300,3 +306,58 @@ def free(self) -> Optional[Range]:
         Total - used.
         """
         return None if self._used is None else self._total - self._used
+
+
+def get_errors(exc: BaseException) -> Generator[BaseException, None, None]:
+    """
+    Generates a sequence of exceptions starting with exc and following the chain
+    of causes.
+    """
+    yield exc
+    while exc.__cause__ is not None:
+        yield exc.__cause__
+        exc = exc.__cause__
+
+
+def long_running_operation(
+    *, method_names: Sequence[str]
+) -> Callable[[Callable], Callable]:
+    """
+    Mark a function as a long running operation and catch and ignore NoReply
+    D-Bus exception so long as the method raising the exception is one
+    of the methods specified in method_names.
+    """
+
+    def decorator(func: Callable[[Namespace], None]) -> Callable[[Namespace], None]:
+        """
+        Decorator
+        """
+
+        @wraps(func)
+        def wrapper(namespace: Namespace):
+            """
+            Wrapper
+            """
+            try:
+                func(namespace)
+            except DPClientInvocationError as err:
+                if not any(
+                    isinstance(e, DBusException)
+                    and e.get_dbus_name() == "org.freedesktop.DBus.Error.NoReply"
+                    for e in get_errors(err)
+                ):
+                    raise err
+
+                context = err.context
+                if (
+                    isinstance(context, DPClientMethodCallContext)
+                    and context.method_name in method_names
+                ):
+                    print("Operation initiated", file=sys.stderr)
+
+                else:
+                    raise err
+
+        return wrapper
+
+    return decorator

src/stratis_cli/_error_reporting.py

@@ -17,7 +17,6 @@
 # isort: STDLIB
 import os
 import sys
-from collections.abc import Iterator
 from typing import List, Optional
 
 # isort: THIRDPARTY
@@ -41,6 +40,7 @@
     FILESYSTEM_INTERFACE,
     MANAGER_0_INTERFACE,
     POOL_INTERFACE,
+    get_errors,
 )
 from ._errors import (
     StratisCliActionError,
@@ -87,17 +87,6 @@ def _interface_name_to_common_name(interface_name: str) -> str:
     raise StratisCliUnknownInterfaceError(interface_name)  # pragma: no cover
 
 
-def get_errors(exc: BaseException) -> Iterator[BaseException]:
-    """
-    Generates a sequence of exceptions starting with exc and following the chain
-    of causes.
-    """
-    yield exc
-    while exc.__cause__ is not None:
-        yield exc.__cause__
-        exc = exc.__cause__
-
-
 def _interpret_errors_0(
     error: dbus.exceptions.DBusException,
 ) -> Optional[str]:

tests/unit/test_running.py

@@ -0,0 +1,79 @@
+# Copyright 2025 Red Hat, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Test 'long_running_operation'.
+"""
+
+# isort: STDLIB
+import unittest
+
+# isort: THIRDPARTY
+import dbus
+
+# isort: FIRSTPARTY
+from dbus_python_client_gen import DPClientInvocationError, DPClientMethodCallContext
+
+# isort: LOCAL
+from stratis_cli._actions._utils import long_running_operation
+
+
+class LongRunningOperationTestCase(unittest.TestCase):
+    """
+    Test long_running_operation error paths that don't show up in the sim
+    engine.
+    """
+
+    def test_catch_dbus_exception(self):
+        """
+        Should succeed because it catches the distinguishing NoReply D-Bus
+        error from the identified method.
+        """
+
+        def raises_error(_):
+            raise DPClientInvocationError(
+                "fake", "intf", DPClientMethodCallContext("MethodName", [])
+            ) from dbus.exceptions.DBusException(
+                name="org.freedesktop.DBus.Error.NoReply"
+            )
+
+        self.assertIsNone(
+            long_running_operation(method_names=["MethodName"])(raises_error)(None)
+        )
+
+    def test_raise_dbus_exception_no_name_match(self):
+        """
+        Should raise an exception because the method to be matched is not
+        MethodName.
+        """
+
+        def raises_error(_):
+            raise DPClientInvocationError(
+                "fake", "intf", DPClientMethodCallContext("MethodName", [])
+            ) from dbus.exceptions.DBusException(
+                name="org.freedesktop.DBus.Error.NoReply"
+            )
+
+        with self.assertRaises(DPClientInvocationError):
+            long_running_operation(method_names=["OtherMethodName"])(raises_error)(None)
+
+    def test_no_dbus_exception(self):
+        """
+        Should raise an exception that was previously raised.
+        """
+
+        def raises_error(_):
+            raise DPClientInvocationError("fake", "intf", None)
+
+        with self.assertRaises(DPClientInvocationError):
+            long_running_operation(method_names=["OtherMethodName"])(raises_error)(None)