Merge pull request #35 from bernhardkaindl/sync-helpers-to-sdbus_block

Thank you

Author: igo95862

examples/async/delete-connection-by-uuid-async.py

@@ -1,29 +1,24 @@
 #!/usr/bin/env python
 # SPDX-License-Identifier: LGPL-2.1-or-later
 #
-# Update a property of a connection profile, looked up by connection id
-#
-# The IPv4 settings of connections profiles are documented here:
-# https://networkmanager.dev/docs/api/latest/settings-ipv4.html
+# Create and delete a connection profile using the unique connection uuid
 #
 import asyncio
 import logging
 import sdbus
 from uuid import uuid4
 from argparse import Namespace
 from sdbus_async.networkmanager import NetworkManagerSettings
-from sdbus_async.networkmanager import NetworkConnectionSettings
+from sdbus_async.networkmanager import NmSettingsInvalidConnectionError
 
 
 async def delete_connection_by_uuid(uuid: str) -> bool:
     """Find and delete the connection identified by the given UUID"""
-    settings_manager = NetworkManagerSettings()
-    connection_path = await settings_manager.get_connection_by_uuid(uuid)
-    if not connection_path:
+    try:
+        await NetworkManagerSettings().delete_connection_by_uuid(uuid)
+    except NmSettingsInvalidConnectionError:
         logging.getLogger().fatal(f"Connection {uuid} for deletion not found")
         return False
-    connection_settings = NetworkConnectionSettings(connection_path)
-    await connection_settings.delete()
     return True
 
 

examples/block/delete-connection-by-uuid.py

@@ -1,32 +1,27 @@
 #!/usr/bin/env python
 # SPDX-License-Identifier: LGPL-2.1-or-later
 #
-# Update a property of a connection profile, looked up by connection id
-#
-# The IPv4 settings of connections profiles are documented here:
-# https://networkmanager.dev/docs/api/latest/settings-ipv4.html
+# Create and delete a connection profile using the unique connection uuid
 #
 import logging
 import sdbus
 from uuid import uuid4
 from argparse import Namespace
 from sdbus_block.networkmanager import NetworkManagerSettings
-from sdbus_block.networkmanager import NetworkConnectionSettings
+from sdbus_block.networkmanager import NmSettingsInvalidConnectionError
 
 
 def delete_connection_by_uuid(uuid: str) -> bool:
     """Find and delete the connection identified by the given UUID"""
-    settings_manager = NetworkManagerSettings()
-    connection_path = settings_manager.get_connection_by_uuid(uuid)
-    if not connection_path:
+    try:
+        NetworkManagerSettings().delete_connection_by_uuid(uuid)
+    except NmSettingsInvalidConnectionError:
         logging.getLogger().fatal(f"Connection {uuid} for deletion not found")
         return False
-    connection_settings = NetworkConnectionSettings(connection_path)
-    connection_settings.delete()
     return True
 
 
-def create_and_delete_wifi_psk_connection_(args: Namespace) -> bool:
+def create_and_delete_wifi_psk_connection_async(args: Namespace) -> bool:
     """Add a temporary (not yet saved) network connection profile
     :param Namespace args: autoconnect, conn_id, psk, save, ssid, uuid
     :return: dbus connection path of the created connection profile
@@ -41,5 +36,5 @@ def create_and_delete_wifi_psk_connection_(args: Namespace) -> bool:
     logging.basicConfig(format="%(message)s", level=logging.WARNING)
     sdbus.set_default_bus(sdbus.sd_bus_open_system())
     args = Namespace(conn_id="Example", uuid=uuid4(), ssid="S", psk="Password")
-    if create_and_delete_wifi_psk_connection_(args):
+    if create_and_delete_wifi_psk_connection_async(args):
         print(f"Succeeded in creating and deleting connection {args.uuid}")

examples/block/list-connections.py

@@ -17,39 +17,41 @@
 # | ipv6: method: disabled
 import sdbus
 from sdbus_block.networkmanager import (
+    ConnectionType,
     NetworkManagerSettings,
     NetworkConnectionSettings,
 )
 
 
 def list_connection_profiles_blocking() -> None:
-    for connection_path in NetworkManagerSettings().connections:
-        connection_settings = NetworkConnectionSettings(connection_path)
-        settings = connection_settings.get_settings()
-        connection = settings["connection"]
-
-        # Skip connection profiles for bridges and wireless networks
-        if connection["type"][1] in ("bridge", "802-11-wireless"):
-            continue
-
-        print("-------------------------------------------------------------")
-        print("name:", connection["id"][1])
-        print("uuid:", connection["uuid"][1])
-        print("type:", connection["type"][1])
-        if "interface-name" in connection:
-            print("      interface-name:", connection["interface-name"][1])
-
-        if "ipv4" in settings:
-            ipv4 = settings["ipv4"]
-            print("ipv4: method:", ipv4["method"][1])
-            if "address-data" in ipv4:
-                for a in ipv4["address-data"][1]:
-                    print(f'      ipaddr: {a["address"][1]}/{a["prefix"][1]}')
-            if "route-metric" in ipv4:
-                print(f'      route-metric: {ipv4["route-metric"][1]}')
-
-        if "ipv6" in settings:
-            print("ipv6: method:", settings["ipv6"]["method"][1])
+    """Call print_connection_profile_blocking() for all connection profiles"""
+    networkmanager_settings = NetworkManagerSettings()
+    for dbus_connection_path in networkmanager_settings.connections:
+        print_connection_profile_blocking(dbus_connection_path)
+
+
+def print_connection_profile_blocking(connection_path: str) -> None:
+    """Show the use of NetworkConnectionSettings(path).connection_profile()"""
+    profile = NetworkConnectionSettings(connection_path).connection_profile()
+    print("-------------------------------------------------------------")
+    print("name:", profile.connection.connection_id)
+    print("uuid:", profile.connection.uuid)
+    print("type:", profile.connection.connection_type)
+    if profile.connection.interface_name:
+        print("      interface-name:", profile.connection.interface_name)
+    if profile.ipv4:
+        print("ipv4: method:", profile.ipv4.method)
+        if profile.ipv4.address_data:
+            for address in profile.ipv4.address_data:
+                print(f'      ipaddr: {address.address}/{address.prefix}')
+        if profile.ipv4.route_metric:
+            print(f'      route-metric: {profile.ipv4.route_metric}')
+    if profile.ipv6:
+        print("ipv6: method:", profile.ipv6.method)
+    if profile.connection.connection_type == ConnectionType.WIFI:
+        assert profile.wireless
+        assert profile.wireless.ssid
+        print("ssid:", profile.wireless.ssid.decode())
 
 
 if __name__ == "__main__":

sdbus_block/networkmanager/objects.py

@@ -67,6 +67,8 @@
     NetworkManagerVPNConnectionInterface,
     NetworkManagerWifiP2PPeerInterface,
 )
+from .settings.profile import ConnectionProfile
+from .types import NetworkManagerConnectionProperties
 
 NETWORK_MANAGER_SERVICE_NAME = 'org.freedesktop.NetworkManager'
 
@@ -158,7 +160,7 @@ def get_connections_by_id(self, connection_id: str) -> List[str]:
         which use the given connection identifier.
 
         :param str connection_id: The connection identifier of the connections,
-        e.g. "Ethernet connection 1"
+                                  e.g. "Wired connection 1"
         :return: List of connection profile paths using the given identifier.
         """
         connection_paths_with_matching_id = []
@@ -169,6 +171,25 @@ def get_connections_by_id(self, connection_id: str) -> List[str]:
                 connection_paths_with_matching_id.append(connection_path)
         return connection_paths_with_matching_id
 
+    def get_settings_by_uuid(
+        self, connection_uuid: str
+    ) -> NetworkManagerConnectionProperties:
+        """Helper to get a nested settings dict of a connection profile by uuid.
+
+        :param str connection_uuid: The connection uuid of the connection profile
+        :return: Nested dictionary of all settings of the given connection profile
+        """
+        connection = self.get_connection_by_uuid(connection_uuid)
+        return NetworkConnectionSettings(connection).get_settings()
+
+    def delete_connection_by_uuid(self, connection_uuid: str) -> None:
+        """Helper to delete a connection profile identified by the connection uuid.
+
+        :param str connection_uuid: The connection uuid of the connection profile
+        """
+        conn_dbus_path = self.get_connection_by_uuid(connection_uuid)
+        NetworkConnectionSettings(conn_dbus_path).delete()
+
 
 class NetworkConnectionSettings(
         NetworkManagerSettingsConnectionInterface):
@@ -192,6 +213,13 @@ def __init__(self, settings_path: str,
             settings_path,
             bus)
 
+    def connection_profile(self) -> ConnectionProfile:
+        """Return a ConnectionProfile object containing all profile settings
+
+        :return: Nested dataclass containing all settings of the profile
+        """
+        return ConnectionProfile.from_dbus(self.get_settings())
+
 
 class NetworkDeviceGeneric(
         NetworkManagerDeviceInterface,