Do not allow not found exceptions to propagate in list context

zbus crate omits property values from the GetManagedObjects result if it
can not get them.

Instead of a stack trace, return a TABLE_UNKNOWN_STRING for printing.

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

Author: mulkieran

src/stratis_cli/_actions/_formatting.py

@@ -17,13 +17,17 @@
 
 # isort: STDLIB
 import sys
+from functools import wraps
 from typing import Any, Callable, List, Optional
 from uuid import UUID
 
 # isort: THIRDPARTY
 from dbus import Struct
 from wcwidth import wcswidth
 
+# isort: FIRSTPARTY
+from dbus_client_gen import DbusClientMissingPropertyError
+
 # placeholder for tables where a desired value was not obtained from stratisd
 # when the value should be supported.
 TABLE_FAILURE_STRING = "FAILURE"
@@ -160,3 +164,23 @@ def get_uuid_formatter(unhyphenated: bool) -> Callable:
     return (
         (lambda u: UUID(str(u)).hex) if unhyphenated else (lambda u: str(UUID(str(u))))
     )
+
+
+def catch_missing_property(
+    prop_to_str: Callable[[Any], Any], default: Any
+) -> Callable[[Any], Any]:
+    """
+    Return a function to just return a default if a property is missing.
+    """
+
+    @wraps(prop_to_str)
+    def inner(mo: Any) -> str:
+        """
+        Catch the exception and return a default
+        """
+        try:
+            return prop_to_str(mo)
+        except DbusClientMissingPropertyError:  # pragma: no cover
+            return default
+
+    return inner

src/stratis_cli/_actions/_list_filesystem.py

@@ -28,7 +28,9 @@
 from ._constants import TOP_OBJECT
 from ._formatting import (
     TABLE_FAILURE_STRING,
+    TABLE_UNKNOWN_STRING,
     TOTAL_USED_FREE,
+    catch_missing_property,
     get_property,
     print_table,
 )
@@ -152,17 +154,37 @@ def filesystem_size_quartet(
             )
             return f"{triple_str} / {limit}"
 
+        pool_name_func = catch_missing_property(
+            lambda mo: self.pool_object_path_to_pool_name.get(
+                mo.Pool(), TABLE_UNKNOWN_STRING
+            ),
+            TABLE_UNKNOWN_STRING,
+        )
+        name_func = catch_missing_property(
+            lambda mofs: mofs.Name(), TABLE_UNKNOWN_STRING
+        )
+        size_func = catch_missing_property(
+            lambda mofs: filesystem_size_quartet(
+                Range(mofs.Size()),
+                get_property(mofs.Used(), Range, None),
+                get_property(mofs.SizeLimit(), Range, None),
+            ),
+            TABLE_UNKNOWN_STRING,
+        )
+        devnode_func = catch_missing_property(
+            lambda mofs: mofs.Devnode(), TABLE_UNKNOWN_STRING
+        )
+        uuid_func = catch_missing_property(
+            lambda mofs: self.uuid_formatter(mofs.Uuid()), TABLE_UNKNOWN_STRING
+        )
+
         tables = [
             (
-                self.pool_object_path_to_pool_name[mofilesystem.Pool()],
-                mofilesystem.Name(),
-                filesystem_size_quartet(
-                    Range(mofilesystem.Size()),
-                    get_property(mofilesystem.Used(), Range, None),
-                    get_property(mofilesystem.SizeLimit(), Range, None),
-                ),
-                mofilesystem.Devnode(),
-                self.uuid_formatter(mofilesystem.Uuid()),
+                pool_name_func(mofilesystem),
+                name_func(mofilesystem),
+                size_func(mofilesystem),
+                devnode_func(mofilesystem),
+                uuid_func(mofilesystem),
             )
             for mofilesystem in self.filesystems_with_props
         ]

src/stratis_cli/_actions/_list_pool.py

@@ -32,6 +32,7 @@
 from justbytes import Range
 
 from .._alerts import (
+    PoolAlertType,
     PoolAllocSpaceAlert,
     PoolDeviceSizeChangeAlert,
     PoolEncryptionAlert,
@@ -44,7 +45,9 @@
 from ._constants import TOP_OBJECT
 from ._formatting import (
     TABLE_FAILURE_STRING,
+    TABLE_UNKNOWN_STRING,
     TOTAL_USED_FREE,
+    catch_missing_property,
     get_property,
     print_table,
 )
@@ -452,7 +455,7 @@ def __init__(self, uuid_formatter: Callable[[str | UUID], str]):
         """
         self.uuid_formatter = uuid_formatter
 
-    def display(self):
+    def display(self):  # pylint: disable=too-many-locals
         """
         List pools in table view.
         """
@@ -526,20 +529,31 @@ def gen_string(has_property: bool, code: str) -> str:
             (objpath, MOPool(info)) for objpath, info in pools().search(managed_objects)
         ]
 
+        name_func = catch_missing_property(lambda mo: mo.Name(), TABLE_UNKNOWN_STRING)
+        size_func = catch_missing_property(physical_size_triple, TABLE_UNKNOWN_STRING)
+        properties_func = catch_missing_property(
+            properties_string, TABLE_UNKNOWN_STRING
+        )
+        uuid_func = catch_missing_property(
+            lambda mo: self.uuid_formatter(mo.Uuid()), TABLE_UNKNOWN_STRING
+        )
+
+        def alert_func(pool_object_path: str, mopool: Any) -> List[PoolAlertType]:
+            """
+            Combined alert codes.
+            """
+            return catch_missing_property(
+                Default.alert_codes, default=[TABLE_UNKNOWN_STRING]
+            )(mopool) + alerts.alert_codes(pool_object_path)
+
         tables = [
             (
-                mopool.Name(),
-                physical_size_triple(mopool),
-                properties_string(mopool),
-                self.uuid_formatter(mopool.Uuid()),
+                name_func(mopool),
+                size_func(mopool),
+                properties_func(mopool),
+                uuid_func(mopool),
                 ", ".join(
-                    sorted(
-                        str(code)
-                        for code in (
-                            Default.alert_codes(mopool)
-                            + alerts.alert_codes(pool_object_path)
-                        )
-                    )
+                    sorted(str(code) for code in alert_func(pool_object_path, mopool))
                 ),
             )
             for (pool_object_path, mopool) in pools_with_props

src/stratis_cli/_actions/_physical.py

@@ -17,6 +17,7 @@
 
 # isort: STDLIB
 from argparse import Namespace
+from typing import Any
 
 # isort: THIRDPARTY
 from justbytes import Range
@@ -26,6 +27,7 @@
 from ._constants import TOP_OBJECT
 from ._formatting import (
     TABLE_UNKNOWN_STRING,
+    catch_missing_property,
     get_property,
     get_uuid_formatter,
     print_table,
@@ -79,7 +81,7 @@ def list_devices(namespace: Namespace):  # pylint: disable=too-many-locals
             ).search(managed_objects)
         )
 
-        def paths(modev):
+        def paths(modev: Any) -> str:
             """
             Return <physical_path> (<metadata_path>) if they are different,
             otherwise, just <metadata_path>.
@@ -100,7 +102,7 @@ def paths(modev):
                 else f"{physical_path} ({metadata_path})"
             )
 
-        def size(modev):
+        def size_str(modev: Any) -> str:
             """
             Return in-use size (observed size) if they are different, otherwise
             just in-use size.
@@ -113,24 +115,35 @@ def size(modev):
                 else f"{in_use_size} ({observed_size})"
             )
 
-        def tier_str(value):
+        def tier_str(modev: Any) -> str:
             """
             String representation of a tier.
             """
             try:
-                return str(BlockDevTiers(value))
+                return str(BlockDevTiers(modev.Tier()))
             except ValueError:  # pragma: no cover
                 return TABLE_UNKNOWN_STRING
 
         format_uuid = get_uuid_formatter(namespace.unhyphenated_uuids)
 
+        pool_name_func = catch_missing_property(
+            lambda mo: path_to_name.get(mo.Pool(), TABLE_UNKNOWN_STRING),
+            TABLE_UNKNOWN_STRING,
+        )
+        paths_func = catch_missing_property(paths, TABLE_UNKNOWN_STRING)
+        size_func = catch_missing_property(size_str, TABLE_UNKNOWN_STRING)
+        tier_func = catch_missing_property(tier_str, TABLE_UNKNOWN_STRING)
+        uuid_func = catch_missing_property(
+            lambda modev: format_uuid(modev.Uuid()), TABLE_UNKNOWN_STRING
+        )
+
         tables = [
             [
-                path_to_name.get(modev.Pool(), TABLE_UNKNOWN_STRING),
-                paths(modev),
-                size(modev),
-                tier_str(modev.Tier()),
-                format_uuid(modev.Uuid()),
+                pool_name_func(modev),
+                paths_func(modev),
+                size_func(modev),
+                tier_func(modev),
+                uuid_func(modev),
             ]
             for modev in modevs
         ]