fix(cloudstack): get domain name and vr information from network manager leases

cloudinit/net/dhcp.py

@@ -29,6 +29,7 @@
 DHCLIENT_FALLBACK_LEASE_DIR = "/var/lib/dhclient"
 # Match something.lease or something.leases
 DHCLIENT_FALLBACK_LEASE_REGEX = r".+\.leases?$"
+NMCLI = "nmcli"
 UDHCPC_SCRIPT = """#!/bin/sh
 log() {
     echo "udhcpc[$PPID]" "$interface: $2"
@@ -147,6 +148,81 @@ def networkd_get_option_from_leases(keyname, leases_d=None):
     return None
 
 
+def run_nmcli(nmcli_opts: List[str]) -> str:
+    nmcli_path = subp.which(NMCLI)
+    if not nmcli_path:
+        raise NoDHCPLeaseMissingDhclientError()
+
+    command = [nmcli_path] + nmcli_opts
+    try:
+        out, _ = subp.subp(
+            command,
+        )
+    except subp.ProcessExecutionError as error:
+        LOG.debug(
+            "nmcli command exited with code: %s stderr: %r stdout: %r",
+            error.exit_code,
+            error.stderr,
+            error.stdout,
+        )
+        raise NoDHCPLeaseError from error
+    return out
+
+
+def network_manager_load_leases(device: str) -> Dict[str, str]:
+    """Return a dictionary of lease options obtained from NM cli"""
+
+    opts = ["--fields", "DHCP4", "device", "show", device]
+    nmcli_out = run_nmcli(opts)
+
+    content = []
+    for line in nmcli_out.splitlines():
+        line = line.partition(":")[2].strip()
+        content.append(line)
+
+    return dict(configobj.ConfigObj(content, list_values=False))
+
+
+def find_correct_device_nmcli(device: Optional[str]) -> Optional[str]:
+    """If device is specified, return the value of the lease parameter
+    specified by 'keyname' for that device. Else return the lease value for
+    the first connected device as returned by 'nmcli'"""
+
+    device_list_opts = ["--terse", "device"]
+    nmcli_out = run_nmcli(device_list_opts)
+
+    for line in nmcli_out.splitlines():
+        if line == "":
+            continue
+        dev_name, _, state, _ = line.split(":", 3)
+
+        # skip devices that are not connected
+        if state != "connected":
+            continue
+        # skip loopback
+        if dev_name == "lo":
+            continue
+        # if no device name is passed, use the first one found.
+        if device is None:
+            return dev_name
+        # else use the name of the device passed.
+        elif device and device.lower() == dev_name.lower():
+            return dev_name
+    return None
+
+
+def network_manager_get_option_from_leases(
+    keyname: str, device: Optional[str] = None
+) -> Optional[str]:
+
+    leases = None
+    dev = find_correct_device_nmcli(device)
+    if dev:
+        leases = network_manager_load_leases(dev)
+
+    return leases.get(keyname) if leases else None
+
+
 class DhcpClient(abc.ABC):
     client_name = ""
     timeout = 10

cloudinit/sources/DataSourceCloudStack.py

@@ -90,6 +90,7 @@ def _get_domainname(self):
         """Try obtaining a "domain-name" DHCP lease parameter:
         - From systemd-networkd lease (case-insensitive)
         - From ISC dhclient
+        - From network manager dhcp client
         - From dhcpcd (ephemeral)
         - Return empty string if not found (non-fatal)
         """
@@ -113,7 +114,19 @@ def _get_domainname(self):
 
         LOG.debug(
             "Could not obtain FQDN from ISC dhclient leases. Falling back to "
-            "%s",
+            "Network Manager leases"
+        )
+        with suppress(
+            dhcp.NoDHCPLeaseMissingDhclientError, dhcp.NoDHCPLeaseError
+        ):
+            domain_name = dhcp.network_manager_get_option_from_leases(
+                "domain_name"
+            )
+            if domain_name:
+                return domain_name.strip()
+
+        LOG.debug(
+            "Could not obtain FQDN from NM leases. Falling back to %s",
             self.distro.dhcp_client.client_name,
         )
         try:
@@ -338,6 +351,15 @@ def get_vr_address(distro):
             LOG.debug("Found SERVER_ADDRESS '%s' via dhclient", latest_address)
             return latest_address
 
+    # try network manager DHCP lease information
+    with suppress(dhcp.NoDHCPLeaseMissingDhclientError, dhcp.NoDHCPLeaseError):
+        latest_address = dhcp.network_manager_get_option_from_leases(
+            "dhcp_server_identifier"
+        )
+        if latest_address:
+            LOG.debug("Found SERVER_ADDRESS '%s' via nmcli", latest_address)
+            return latest_address
+
     with suppress(FileNotFoundError):
         latest_lease = distro.dhcp_client.get_newest_lease(
             distro.fallback_interface

tests/unittests/net/test_dhcp.py

@@ -20,8 +20,11 @@
     NoDHCPLeaseInterfaceError,
     NoDHCPLeaseMissingDhclientError,
     Udhcpc,
+    find_correct_device_nmcli,
     maybe_perform_dhcp_discovery,
+    network_manager_load_leases,
     networkd_load_leases,
+    run_nmcli,
 )
 from cloudinit.net.ephemeral import EphemeralDHCPv4
 from cloudinit.subp import SubpResult
@@ -1392,3 +1395,112 @@ def test_none_and_missing_fallback(self):
         with pytest.raises(NoDHCPLeaseInterfaceError):
             distro = mock.Mock(fallback_interface=None)
             maybe_perform_dhcp_discovery(distro, None)
+
+
+class TestNMDhcpLeases:
+    def test_find_correct_connected_device_first_match(self):
+        with mock.patch(
+            "cloudinit.net.dhcp.run_nmcli",
+            return_value=dedent(
+                """
+                   ens150:ethernet:unavailable:
+                   p2p-dev-wlp:wifi-p2p:disconnected:
+                   ens160:ethernet:connected:Wired connection 2
+                   ens256:ethernet:connected:Wired connection 3
+                   lo:loopback:connected (externally):lo
+                """
+            ),
+        ):
+            ret = find_correct_device_nmcli(None)
+        assert ret == "ens160"
+
+    def test_find_correct_connected_device_no_match(self):
+        with mock.patch(
+            "cloudinit.net.dhcp.run_nmcli",
+            return_value=dedent(
+                """
+                   ens160:ethernet:connected:Wired connection 1
+                   ens256:ethernet:connected:Wired connection 2
+                   lo:loopback:connected (externally):lo
+                """
+            ),
+        ):
+            ret = find_correct_device_nmcli("ens250")
+        assert ret is None
+
+    def test_find_correct_connected_device_second_match(self):
+        with mock.patch(
+            "cloudinit.net.dhcp.run_nmcli",
+            return_value=dedent(
+                """
+                   ens160:ethernet:connected:Wired connection 1
+                   ens256:ethernet:connected:Wired connection 2
+                   lo:loopback:connected (externally):lo
+                """
+            ),
+        ):
+            ret = find_correct_device_nmcli("ens256")
+        assert ret == "ens256"
+
+    def test_network_manager_load_leases(self):
+        expected_return = {
+            "broadcast_address": "172.16.127.255",
+            "dhcp_client_identifier": "01:00:0c:29:bf:c5:56",
+            "dhcp_lease_time": "1800",
+            "dhcp_server_identifier": "172.16.127.254",
+        }
+        with mock.patch(
+            "cloudinit.net.dhcp.run_nmcli",
+            return_value=dedent(
+                """
+                DHCP4.OPTION[1]: broadcast_address = 172.16.127.255
+                DHCP4.OPTION[2]: dhcp_client_identifier = 01:00:0c:29:bf:c5:56
+                DHCP4.OPTION[3]: dhcp_lease_time = 1800
+                DHCP4.OPTION[4]: dhcp_server_identifier = 172.16.127.254
+                """
+            ),
+        ):
+            ret = network_manager_load_leases("ens10")
+            assert ret == expected_return
+
+    @mock.patch("cloudinit.net.dhcp.subp.which", return_value="/usr/bin/nmcli")
+    @mock.patch("cloudinit.net.dhcp.subp.subp")
+    def test_run_nmcli(self, m_subp, m_which):
+        expected_return = dedent(
+            """
+                DHCP4.OPTION[1]: broadcast_address = 172.16.127.255
+                DHCP4.OPTION[2]: dhcp_client_identifier = 01:00:0c:29:bf:c5:56
+                DHCP4.OPTION[3]: dhcp_lease_time = 1800
+                DHCP4.OPTION[4]: dhcp_server_identifier = 172.16.127.254
+                """
+        )
+        m_subp.return_value = (expected_return, "")
+        ret = run_nmcli(["show"])
+        assert ret == expected_return
+
+    @mock.patch("cloudinit.net.dhcp.subp.which", return_value=None)
+    def test_run_nmcli_missing_nmcli(self, m_which):
+        """verify that absence of nmcli binary can result in
+        raising NoDHCPLeaseMissingDhclientError"""
+
+        with pytest.raises(NoDHCPLeaseMissingDhclientError):
+            run_nmcli(["show"])
+
+    @mock.patch("cloudinit.net.dhcp.subp.which", return_value="/usr/bin/nmcli")
+    @mock.patch("cloudinit.net.dhcp.subp.subp")
+    def test_run_nmcli_subp_err(self, m_subp, m_which):
+        """verify that when subp.ProcessExecutionError is raised while
+        running nmcli, it results in run_nmcli raising NoDHCPLeaseError"""
+
+        m_subp.side_effect = subp.ProcessExecutionError(exit_code=-5)
+
+        with pytest.raises(NoDHCPLeaseError):
+            run_nmcli(["--fields", "all", "device", "show"])
+
+        m_subp.assert_has_calls(
+            [
+                mock.call(
+                    ["/usr/bin/nmcli", "--fields", "all", "device", "show"],
+                ),
+            ]
+        )