networking: refactor is_physical from cloudinit.net (#457)

As the first refactor PR, this also includes the initial structure for tests.

LP: #1884619

8 files changed, 181 insertions, 80 deletions

diff --git a/cloudinit/distros/networking.py b/cloudinit/distros/networking.py
index eecdccc6..e421a2ce 100644
--- a/cloudinit/distros/networking.py
+++ b/cloudinit/distros/networking.py
@@ -1,4 +1,5 @@
 import abc
+import os
 
 from cloudinit import net
 
@@ -79,8 +80,15 @@ class Networking(metaclass=abc.ABCMeta):
     def is_bridge(self, devname: DeviceName) -> bool:
         return net.is_bridge(devname)
 
+    @abc.abstractmethod
     def is_physical(self, devname: DeviceName) -> bool:
-        return net.is_physical(devname)
+        """
+        Is ``devname`` a physical network device?
+
+        Examples of non-physical network devices: bonds, bridges, tunnels,
+        loopback devices.
+        """
+        pass
 
     def is_renamed(self, devname: DeviceName) -> bool:
         return net.is_renamed(devname)
@@ -103,7 +111,8 @@ class Networking(metaclass=abc.ABCMeta):
 class BSDNetworking(Networking):
     """Implementation of networking functionality shared across BSDs."""
 
-    pass
+    def is_physical(self, devname: DeviceName) -> bool:
+        raise NotImplementedError()
 
 
 class LinuxNetworking(Networking):
@@ -126,3 +135,6 @@ class LinuxNetworking(Networking):
 
     def is_netfail_standby(self, devname: DeviceName) -> bool:
         return net.is_netfail_standby(devname)
+
+    def is_physical(self, devname: DeviceName) -> bool:
+        return os.path.exists(net.sys_dev_path(devname, "device"))
diff --git a/cloudinit/distros/tests/test_networking.py b/cloudinit/distros/tests/test_networking.py
new file mode 100644
index 00000000..2acb12f4
--- /dev/null
+++ b/cloudinit/distros/tests/test_networking.py
@@ -0,0 +1,42 @@
+from unittest import mock
+
+import pytest
+
+from cloudinit.distros.networking import BSDNetworking, LinuxNetworking
+
+
+@pytest.yield_fixture
+def sys_class_net(tmpdir):
+    sys_class_net_path = tmpdir.join("sys/class/net")
+    sys_class_net_path.ensure_dir()
+    with mock.patch(
+        "cloudinit.net.get_sys_class_path",
+        return_value=sys_class_net_path.strpath + "/",
+    ):
+        yield sys_class_net_path
+
+
+class TestBSDNetworkingIsPhysical:
+    def test_raises_notimplementederror(self):
+        with pytest.raises(NotImplementedError):
+            BSDNetworking().is_physical("eth0")
+
+
+class TestLinuxNetworkingIsPhysical:
+    def test_returns_false_by_default(self, sys_class_net):
+        assert not LinuxNetworking().is_physical("eth0")
+
+    def test_returns_false_if_devname_exists_but_not_physical(
+        self, sys_class_net
+    ):
+        devname = "eth0"
+        sys_class_net.join(devname).mkdir()
+        assert not LinuxNetworking().is_physical(devname)
+
+    def test_returns_true_if_device_is_physical(self, sys_class_net):
+        devname = "eth0"
+        device_dir = sys_class_net.join(devname)
+        device_dir.mkdir()
+        device_dir.join("device").write("")
+
+        assert LinuxNetworking().is_physical(devname)
diff --git a/cloudinit/net/__init__.py b/cloudinit/net/__init__.py
index fd5a1b3e..9d8c7ba9 100644
--- a/cloudinit/net/__init__.py
+++ b/cloudinit/net/__init__.py
@@ -262,10 +262,6 @@ def is_vlan(devname):
     return 'DEVTYPE=vlan' in uevent.splitlines()
 
 
-def is_physical(devname):
-    return os.path.exists(sys_dev_path(devname, "device"))
-
-
 def device_driver(devname):
     """Return the device driver for net device named 'devname'."""
     driver = None
diff --git a/cloudinit/net/tests/test_init.py b/cloudinit/net/tests/test_init.py
index e36d4387..eb458c39 100644
--- a/cloudinit/net/tests/test_init.py
+++ b/cloudinit/net/tests/test_init.py
@@ -198,12 +198,6 @@ class TestReadSysNet(CiTestCase):
         write_file(os.path.join(self.sysdir, 'eth0', 'uevent'), content)
         self.assertTrue(net.is_vlan('eth0'))
 
-    def test_is_physical(self):
-        """is_physical is True when /sys/net/devname/device exists."""
-        self.assertFalse(net.is_physical('eth0'))
-        ensure_file(os.path.join(self.sysdir, 'eth0', 'device'))
-        self.assertTrue(net.is_physical('eth0'))
-
 
 class TestGenerateFallbackConfig(CiTestCase):
 
diff --git a/cloudinit/sources/DataSourceDigitalOcean.py b/cloudinit/sources/DataSourceDigitalOcean.py
index e0ef665e..5040ce5b 100644
--- a/cloudinit/sources/DataSourceDigitalOcean.py
+++ b/cloudinit/sources/DataSourceDigitalOcean.py
@@ -58,7 +58,7 @@ class DataSourceDigitalOcean(sources.DataSource):
 
         ipv4LL_nic = None
         if self.use_ip4LL:
-            ipv4LL_nic = do_helper.assign_ipv4_link_local()
+            ipv4LL_nic = do_helper.assign_ipv4_link_local(self.distro)
 
         md = do_helper.read_metadata(
             self.metadata_address, timeout=self.timeout,
diff --git a/cloudinit/sources/DataSourceOpenNebula.py b/cloudinit/sources/DataSourceOpenNebula.py
index c7fdc2a5..12b1f94f 100644
--- a/cloudinit/sources/DataSourceOpenNebula.py
+++ b/cloudinit/sources/DataSourceOpenNebula.py
@@ -13,6 +13,7 @@
 # This file is part of cloud-init. See LICENSE file for license information.
 
 import collections
+import functools
 import os
 import pwd
 import re
@@ -60,10 +61,19 @@ class DataSourceOpenNebula(sources.DataSource):
         for cdev in candidates:
             try:
                 if os.path.isdir(self.seed_dir):
-                    results = read_context_disk_dir(cdev, asuser=parseuser)
+                    results = read_context_disk_dir(
+                        cdev, self.distro, asuser=parseuser
+                    )
                 elif cdev.startswith("/dev"):
-                    results = util.mount_cb(cdev, read_context_disk_dir,
-                                            data=parseuser)
+                    # util.mount_cb only handles passing a single argument
+                    # through to the wrapped function, so we have to partially
+                    # apply the function to pass in `distro`.  See LP: #1884979
+                    partially_applied_func = functools.partial(
+                        read_context_disk_dir,
+                        asuser=parseuser,
+                        distro=self.distro,
+                    )
+                    results = util.mount_cb(cdev, partially_applied_func)
             except NonContextDiskDir:
                 continue
             except BrokenContextDiskDir as exc:
@@ -129,10 +139,10 @@ class BrokenContextDiskDir(Exception):
 
 
 class OpenNebulaNetwork(object):
-    def __init__(self, context, system_nics_by_mac=None):
+    def __init__(self, context, distro, system_nics_by_mac=None):
         self.context = context
         if system_nics_by_mac is None:
-            system_nics_by_mac = get_physical_nics_by_mac()
+            system_nics_by_mac = get_physical_nics_by_mac(distro)
         self.ifaces = collections.OrderedDict(
             [k for k in sorted(system_nics_by_mac.items(),
                                key=lambda k: net.natural_sort_key(k[1]))])
@@ -367,7 +377,7 @@ def parse_shell_config(content, keylist=None, bash=None, asuser=None,
     return ret
 
 
-def read_context_disk_dir(source_dir, asuser=None):
+def read_context_disk_dir(source_dir, distro, asuser=None):
     """
     read_context_disk_dir(source_dir):
     read source_dir and return a tuple with metadata dict and user-data
@@ -450,15 +460,17 @@ def read_context_disk_dir(source_dir, asuser=None):
     # http://docs.opennebula.org/5.4/operation/references/template.html#context-section
     ipaddr_keys = [k for k in context if re.match(r'^ETH\d+_IP.*$', k)]
     if ipaddr_keys:
-        onet = OpenNebulaNetwork(context)
+        onet = OpenNebulaNetwork(context, distro)
         results['network-interfaces'] = onet.gen_conf()
 
     return results
 
 
-def get_physical_nics_by_mac():
+def get_physical_nics_by_mac(distro):
     devs = net.get_interfaces_by_mac()
-    return dict([(m, n) for m, n in devs.items() if net.is_physical(n)])
+    return dict(
+        [(m, n) for m, n in devs.items() if distro.networking.is_physical(n)]
+    )
 
 
 # Legacy: Must be present in case we load an old pkl object
diff --git a/cloudinit/sources/helpers/digitalocean.py b/cloudinit/sources/helpers/digitalocean.py
index f5bbe46a..b545c4d6 100644
--- a/cloudinit/sources/helpers/digitalocean.py
+++ b/cloudinit/sources/helpers/digitalocean.py
@@ -16,7 +16,7 @@ NIC_MAP = {'public': 'eth0', 'private': 'eth1'}
 LOG = logging.getLogger(__name__)
 
 
-def assign_ipv4_link_local(nic=None):
+def assign_ipv4_link_local(distro, nic=None):
     """Bring up NIC using an address using link-local (ip4LL) IPs. On
        DigitalOcean, the link-local domain is per-droplet routed, so there
        is no risk of collisions. However, to be more safe, the ip4LL
@@ -24,7 +24,7 @@ def assign_ipv4_link_local(nic=None):
     """
 
     if not nic:
-        nic = get_link_local_nic()
+        nic = get_link_local_nic(distro)
         LOG.debug("selected interface '%s' for reading metadata", nic)
 
     if not nic:
@@ -54,8 +54,12 @@ def assign_ipv4_link_local(nic=None):
     return nic
 
 
-def get_link_local_nic():
-    nics = [f for f in cloudnet.get_devicelist() if cloudnet.is_physical(f)]
+def get_link_local_nic(distro):
+    nics = [
+        f
+        for f in cloudnet.get_devicelist()
+        if distro.networking.is_physical(f)
+    ]
     if not nics:
         return None
     return min(nics, key=lambda d: cloudnet.read_sys_net_int(d, 'ifindex'))
diff --git a/tests/unittests/test_datasource/test_opennebula.py b/tests/unittests/test_datasource/test_opennebula.py
index 7c859c8a..80841182 100644
--- a/tests/unittests/test_datasource/test_opennebula.py
+++ b/tests/unittests/test_datasource/test_opennebula.py
@@ -132,18 +132,18 @@ class TestOpenNebulaDataSource(CiTestCase):
 
     def test_seed_dir_non_contextdisk(self):
         self.assertRaises(ds.NonContextDiskDir, ds.read_context_disk_dir,
-                          self.seed_dir)
+                          self.seed_dir, mock.Mock())
 
     def test_seed_dir_empty1_context(self):
         populate_dir(self.seed_dir, {'context.sh': ''})
-        results = ds.read_context_disk_dir(self.seed_dir)
+        results = ds.read_context_disk_dir(self.seed_dir, mock.Mock())
 
         self.assertIsNone(results['userdata'])
         self.assertEqual(results['metadata'], {})
 
     def test_seed_dir_empty2_context(self):
         populate_context_dir(self.seed_dir, {})
-        results = ds.read_context_disk_dir(self.seed_dir)
+        results = ds.read_context_disk_dir(self.seed_dir, mock.Mock())
 
         self.assertIsNone(results['userdata'])
         self.assertEqual(results['metadata'], {})
@@ -153,11 +153,11 @@ class TestOpenNebulaDataSource(CiTestCase):
 
         self.assertRaises(ds.BrokenContextDiskDir,
                           ds.read_context_disk_dir,
-                          self.seed_dir)
+                          self.seed_dir, mock.Mock())
 
     def test_context_parser(self):
         populate_context_dir(self.seed_dir, TEST_VARS)
-        results = ds.read_context_disk_dir(self.seed_dir)
+        results = ds.read_context_disk_dir(self.seed_dir, mock.Mock())
 
         self.assertTrue('metadata' in results)
         self.assertEqual(TEST_VARS, results['metadata'])
@@ -168,7 +168,7 @@ class TestOpenNebulaDataSource(CiTestCase):
             for k in ('SSH_KEY', 'SSH_PUBLIC_KEY'):
                 my_d = os.path.join(self.tmp, "%s-%i" % (k, c))
                 populate_context_dir(my_d, {k: '\n'.join(public_keys)})
-                results = ds.read_context_disk_dir(my_d)
+                results = ds.read_context_disk_dir(my_d, mock.Mock())
 
                 self.assertTrue('metadata' in results)
                 self.assertTrue('public-keys' in results['metadata'])
@@ -182,7 +182,7 @@ class TestOpenNebulaDataSource(CiTestCase):
             my_d = os.path.join(self.tmp, k)
             populate_context_dir(my_d, {k: USER_DATA,
                                         'USERDATA_ENCODING': ''})
-            results = ds.read_context_disk_dir(my_d)
+            results = ds.read_context_disk_dir(my_d, mock.Mock())
 
             self.assertTrue('userdata' in results)
             self.assertEqual(USER_DATA, results['userdata'])
@@ -192,7 +192,7 @@ class TestOpenNebulaDataSource(CiTestCase):
         for k in ('USER_DATA', 'USERDATA'):
             my_d = os.path.join(self.tmp, k)
             populate_context_dir(my_d, {k: b64userdata})
-            results = ds.read_context_disk_dir(my_d)
+            results = ds.read_context_disk_dir(my_d, mock.Mock())
 
             self.assertTrue('userdata' in results)
             self.assertEqual(b64userdata, results['userdata'])
@@ -202,7 +202,7 @@ class TestOpenNebulaDataSource(CiTestCase):
             my_d = os.path.join(self.tmp, k)
             populate_context_dir(my_d, {k: util.b64e(USER_DATA),
                                         'USERDATA_ENCODING': 'base64'})
-            results = ds.read_context_disk_dir(my_d)
+            results = ds.read_context_disk_dir(my_d, mock.Mock())
 
             self.assertTrue('userdata' in results)
             self.assertEqual(USER_DATA, results['userdata'])
@@ -214,7 +214,7 @@ class TestOpenNebulaDataSource(CiTestCase):
             for k in ('HOSTNAME', 'PUBLIC_IP', 'IP_PUBLIC', 'ETH0_IP'):
                 my_d = os.path.join(self.tmp, k)
                 populate_context_dir(my_d, {k: PUBLIC_IP})
-                results = ds.read_context_disk_dir(my_d)
+                results = ds.read_context_disk_dir(my_d, mock.Mock())
 
                 self.assertTrue('metadata' in results)
                 self.assertTrue('local-hostname' in results['metadata'])
@@ -229,7 +229,7 @@ class TestOpenNebulaDataSource(CiTestCase):
             # without ETH0_MAC
             # for Older OpenNebula?
             populate_context_dir(self.seed_dir, {'ETH0_IP': IP_BY_MACADDR})
-            results = ds.read_context_disk_dir(self.seed_dir)
+            results = ds.read_context_disk_dir(self.seed_dir, mock.Mock())
 
             self.assertTrue('network-interfaces' in results)
             self.assertTrue(
@@ -239,7 +239,7 @@ class TestOpenNebulaDataSource(CiTestCase):
             # ETH0_IP and ETH0_MAC
             populate_context_dir(
                 self.seed_dir, {'ETH0_IP': IP_BY_MACADDR, 'ETH0_MAC': MACADDR})
-            results = ds.read_context_disk_dir(self.seed_dir)
+            results = ds.read_context_disk_dir(self.seed_dir, mock.Mock())
 
             self.assertTrue('network-interfaces' in results)
             self.assertTrue(
@@ -251,7 +251,7 @@ class TestOpenNebulaDataSource(CiTestCase):
             # "AR = [ TYPE = ETHER ]"
             populate_context_dir(
                 self.seed_dir, {'ETH0_IP': '', 'ETH0_MAC': MACADDR})
-            results = ds.read_context_disk_dir(self.seed_dir)
+            results = ds.read_context_disk_dir(self.seed_dir, mock.Mock())
 
             self.assertTrue('network-interfaces' in results)
             self.assertTrue(
@@ -265,7 +265,7 @@ class TestOpenNebulaDataSource(CiTestCase):
                     'ETH0_MAC': MACADDR,
                     'ETH0_MASK': '255.255.0.0'
                 })
-            results = ds.read_context_disk_dir(self.seed_dir)
+            results = ds.read_context_disk_dir(self.seed_dir, mock.Mock())
 
             self.assertTrue('network-interfaces' in results)
             self.assertTrue(
@@ -279,7 +279,7 @@ class TestOpenNebulaDataSource(CiTestCase):
                     'ETH0_MAC': MACADDR,
                     'ETH0_MASK': ''
                 })
-            results = ds.read_context_disk_dir(self.seed_dir)
+            results = ds.read_context_disk_dir(self.seed_dir, mock.Mock())
 
             self.assertTrue('network-interfaces' in results)
             self.assertTrue(
@@ -292,7 +292,7 @@ class TestOpenNebulaDataSource(CiTestCase):
                     'ETH0_IP6': IP6_GLOBAL,
                     'ETH0_MAC': MACADDR,
                 })
-            results = ds.read_context_disk_dir(self.seed_dir)
+            results = ds.read_context_disk_dir(self.seed_dir, mock.Mock())
 
             self.assertTrue('network-interfaces' in results)
             self.assertTrue(
@@ -305,7 +305,7 @@ class TestOpenNebulaDataSource(CiTestCase):
                     'ETH0_IP6_ULA': IP6_ULA,
                     'ETH0_MAC': MACADDR,
                 })
-            results = ds.read_context_disk_dir(self.seed_dir)
+            results = ds.read_context_disk_dir(self.seed_dir, mock.Mock())
 
             self.assertTrue('network-interfaces' in results)
             self.assertTrue(
@@ -319,7 +319,7 @@ class TestOpenNebulaDataSource(CiTestCase):
                     'ETH0_IP6_PREFIX_LENGTH': IP6_PREFIX,
                     'ETH0_MAC': MACADDR,
                 })
-            results = ds.read_context_disk_dir(self.seed_dir)
+            results = ds.read_context_disk_dir(self.seed_dir, mock.Mock())
 
             self.assertTrue('network-interfaces' in results)
             self.assertTrue(
@@ -333,7 +333,7 @@ class TestOpenNebulaDataSource(CiTestCase):
                     'ETH0_IP6_PREFIX_LENGTH': '',
                     'ETH0_MAC': MACADDR,
                 })
-            results = ds.read_context_disk_dir(self.seed_dir)
+            results = ds.read_context_disk_dir(self.seed_dir, mock.Mock())
 
             self.assertTrue('network-interfaces' in results)
             self.assertTrue(
@@ -370,7 +370,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
         expected = {
             '02:00:0a:12:01:01': 'ETH0',
             '02:00:0a:12:0f:0f': 'ETH1', }
-        net = ds.OpenNebulaNetwork(context)
+        net = ds.OpenNebulaNetwork(context, mock.Mock())
         self.assertEqual(expected, net.context_devname)
 
     def test_get_nameservers(self):
@@ -385,21 +385,21 @@ class TestOpenNebulaNetwork(unittest.TestCase):
         expected = {
             'addresses': ['1.2.3.6', '1.2.3.7', '1.2.3.8'],
             'search': ['example.com', 'example.org']}
-        net = ds.OpenNebulaNetwork(context)
+        net = ds.OpenNebulaNetwork(context, mock.Mock())
         val = net.get_nameservers('eth0')
         self.assertEqual(expected, val)
 
     def test_get_mtu(self):
         """Verify get_mtu('device') correctly returns MTU size."""
         context = {'ETH0_MTU': '1280'}
-        net = ds.OpenNebulaNetwork(context)
+        net = ds.OpenNebulaNetwork(context, mock.Mock())
         val = net.get_mtu('eth0')
         self.assertEqual('1280', val)
 
     def test_get_ip(self):
         """Verify get_ip('device') correctly returns IPv4 address."""
         context = {'ETH0_IP': PUBLIC_IP}
-        net = ds.OpenNebulaNetwork(context)
+        net = ds.OpenNebulaNetwork(context, mock.Mock())
         val = net.get_ip('eth0', MACADDR)
         self.assertEqual(PUBLIC_IP, val)
 
@@ -410,7 +410,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
         string.
         """
         context = {'ETH0_IP': ''}
-        net = ds.OpenNebulaNetwork(context)
+        net = ds.OpenNebulaNetwork(context, mock.Mock())
         val = net.get_ip('eth0', MACADDR)
         self.assertEqual(IP_BY_MACADDR, val)
 
@@ -423,7 +423,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
             'ETH0_IP6': IP6_GLOBAL,
             'ETH0_IP6_ULA': '', }
         expected = [IP6_GLOBAL]
-        net = ds.OpenNebulaNetwork(context)
+        net = ds.OpenNebulaNetwork(context, mock.Mock())
         val = net.get_ip6('eth0')
         self.assertEqual(expected, val)
 
@@ -436,7 +436,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
             'ETH0_IP6': '',
             'ETH0_IP6_ULA': IP6_ULA, }
         expected = [IP6_ULA]
-        net = ds.OpenNebulaNetwork(context)
+        net = ds.OpenNebulaNetwork(context, mock.Mock())
         val = net.get_ip6('eth0')
         self.assertEqual(expected, val)
 
@@ -449,7 +449,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
             'ETH0_IP6': IP6_GLOBAL,
             'ETH0_IP6_ULA': IP6_ULA, }
         expected = [IP6_GLOBAL, IP6_ULA]
-        net = ds.OpenNebulaNetwork(context)
+        net = ds.OpenNebulaNetwork(context, mock.Mock())
         val = net.get_ip6('eth0')
         self.assertEqual(expected, val)
 
@@ -458,7 +458,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
         Verify get_ip6_prefix('device') correctly returns IPv6 prefix.
         """
         context = {'ETH0_IP6_PREFIX_LENGTH': IP6_PREFIX}
-        net = ds.OpenNebulaNetwork(context)
+        net = ds.OpenNebulaNetwork(context, mock.Mock())
         val = net.get_ip6_prefix('eth0')
         self.assertEqual(IP6_PREFIX, val)
 
@@ -469,7 +469,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
         string.
         """
         context = {'ETH0_IP6_PREFIX_LENGTH': ''}
-        net = ds.OpenNebulaNetwork(context)
+        net = ds.OpenNebulaNetwork(context, mock.Mock())
         val = net.get_ip6_prefix('eth0')
         self.assertEqual('64', val)
 
@@ -479,7 +479,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
         address.
         """
         context = {'ETH0_GATEWAY': '1.2.3.5'}
-        net = ds.OpenNebulaNetwork(context)
+        net = ds.OpenNebulaNetwork(context, mock.Mock())
         val = net.get_gateway('eth0')
         self.assertEqual('1.2.3.5', val)
 
@@ -489,7 +489,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
         address.
         """
         context = {'ETH0_GATEWAY6': IP6_GW}
-        net = ds.OpenNebulaNetwork(context)
+        net = ds.OpenNebulaNetwork(context, mock.Mock())
         val = net.get_gateway6('eth0')
         self.assertEqual(IP6_GW, val)
 
@@ -498,7 +498,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
         Verify get_mask('device') correctly returns IPv4 subnet mask.
         """
         context = {'ETH0_MASK': '255.255.0.0'}
-        net = ds.OpenNebulaNetwork(context)
+        net = ds.OpenNebulaNetwork(context, mock.Mock())
         val = net.get_mask('eth0')
         self.assertEqual('255.255.0.0', val)
 
@@ -508,7 +508,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
         It returns default value '255.255.255.0' if ETH0_MASK has empty string.
         """
         context = {'ETH0_MASK': ''}
-        net = ds.OpenNebulaNetwork(context)
+        net = ds.OpenNebulaNetwork(context, mock.Mock())
         val = net.get_mask('eth0')
         self.assertEqual('255.255.255.0', val)
 
@@ -517,7 +517,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
         Verify get_network('device') correctly returns IPv4 network address.
         """
         context = {'ETH0_NETWORK': '1.2.3.0'}
-        net = ds.OpenNebulaNetwork(context)
+        net = ds.OpenNebulaNetwork(context, mock.Mock())
         val = net.get_network('eth0', MACADDR)
         self.assertEqual('1.2.3.0', val)
 
@@ -528,7 +528,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
         empty string.
         """
         context = {'ETH0_NETWORK': ''}
-        net = ds.OpenNebulaNetwork(context)
+        net = ds.OpenNebulaNetwork(context, mock.Mock())
         val = net.get_network('eth0', MACADDR)
         self.assertEqual('10.18.1.0', val)
 
@@ -537,7 +537,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
         Verify get_field('device', 'name') returns *context* value.
         """
         context = {'ETH9_DUMMY': 'DUMMY_VALUE'}
-        net = ds.OpenNebulaNetwork(context)
+        net = ds.OpenNebulaNetwork(context, mock.Mock())
         val = net.get_field('eth9', 'dummy')
         self.assertEqual('DUMMY_VALUE', val)
 
@@ -547,7 +547,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
         value.
         """
         context = {'ETH9_DUMMY': 'DUMMY_VALUE'}
-        net = ds.OpenNebulaNetwork(context)
+        net = ds.OpenNebulaNetwork(context, mock.Mock())
         val = net.get_field('eth9', 'dummy', 'DEFAULT_VALUE')
         self.assertEqual('DUMMY_VALUE', val)
 
@@ -557,7 +557,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
         value if context value is empty string.
         """
         context = {'ETH9_DUMMY': ''}
-        net = ds.OpenNebulaNetwork(context)
+        net = ds.OpenNebulaNetwork(context, mock.Mock())
         val = net.get_field('eth9', 'dummy', 'DEFAULT_VALUE')
         self.assertEqual('DEFAULT_VALUE', val)
 
@@ -567,7 +567,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
         empty string.
         """
         context = {'ETH9_DUMMY': ''}
-        net = ds.OpenNebulaNetwork(context)
+        net = ds.OpenNebulaNetwork(context, mock.Mock())
         val = net.get_field('eth9', 'dummy')
         self.assertEqual(None, val)
 
@@ -577,7 +577,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
         None.
         """
         context = {'ETH9_DUMMY': None}
-        net = ds.OpenNebulaNetwork(context)
+        net = ds.OpenNebulaNetwork(context, mock.Mock())
         val = net.get_field('eth9', 'dummy')
         self.assertEqual(None, val)
 
@@ -597,7 +597,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
                         'match': {'macaddress': MACADDR},
                         'addresses': [IP_BY_MACADDR + '/' + IP4_PREFIX]}}}
             m_get_phys_by_mac.return_value = {MACADDR: nic}
-            net = ds.OpenNebulaNetwork(context)
+            net = ds.OpenNebulaNetwork(context, mock.Mock())
             self.assertEqual(net.gen_conf(), expected)
 
         # set ETH0_GATEWAY
@@ -613,7 +613,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
                         'match': {'macaddress': MACADDR},
                         'addresses': [IP_BY_MACADDR + '/' + IP4_PREFIX]}}}
             m_get_phys_by_mac.return_value = {MACADDR: nic}
-            net = ds.OpenNebulaNetwork(context)
+            net = ds.OpenNebulaNetwork(context, mock.Mock())
             self.assertEqual(net.gen_conf(), expected)
 
     @mock.patch(DS_PATH + ".get_physical_nics_by_mac")
@@ -632,7 +632,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
                         'match': {'macaddress': MACADDR},
                         'addresses': [IP_BY_MACADDR + '/' + IP4_PREFIX]}}}
             m_get_phys_by_mac.return_value = {MACADDR: nic}
-            net = ds.OpenNebulaNetwork(context)
+            net = ds.OpenNebulaNetwork(context, mock.Mock())
             self.assertEqual(net.gen_conf(), expected)
 
         # set ETH0_GATEWAY6
@@ -648,7 +648,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
                         'match': {'macaddress': MACADDR},
                         'addresses': [IP_BY_MACADDR + '/' + IP4_PREFIX]}}}
             m_get_phys_by_mac.return_value = {MACADDR: nic}
-            net = ds.OpenNebulaNetwork(context)
+            net = ds.OpenNebulaNetwork(context, mock.Mock())
             self.assertEqual(net.gen_conf(), expected)
 
     @mock.patch(DS_PATH + ".get_physical_nics_by_mac")
@@ -669,7 +669,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
                         'match': {'macaddress': MACADDR},
                         'addresses': [IP_BY_MACADDR + '/' + IP4_PREFIX]}}}
             m_get_phys_by_mac.return_value = {MACADDR: nic}
-            net = ds.OpenNebulaNetwork(context)
+            net = ds.OpenNebulaNetwork(context, mock.Mock())
             self.assertEqual(net.gen_conf(), expected)
 
         # set ETH0_IP6, ETH0_IP6_ULA, ETH0_IP6_PREFIX_LENGTH
@@ -689,7 +689,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
                             IP6_GLOBAL + '/' + IP6_PREFIX,
                             IP6_ULA + '/' + IP6_PREFIX]}}}
             m_get_phys_by_mac.return_value = {MACADDR: nic}
-            net = ds.OpenNebulaNetwork(context)
+            net = ds.OpenNebulaNetwork(context, mock.Mock())
             self.assertEqual(net.gen_conf(), expected)
 
     @mock.patch(DS_PATH + ".get_physical_nics_by_mac")
@@ -710,7 +710,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
                         'match': {'macaddress': MACADDR},
                         'addresses': [IP_BY_MACADDR + '/' + IP4_PREFIX]}}}
             m_get_phys_by_mac.return_value = {MACADDR: nic}
-            net = ds.OpenNebulaNetwork(context)
+            net = ds.OpenNebulaNetwork(context, mock.Mock())
             self.assertEqual(net.gen_conf(), expected)
 
         # set DNS, ETH0_DNS, ETH0_SEARCH_DOMAIN
@@ -730,7 +730,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
                         'match': {'macaddress': MACADDR},
                         'addresses': [IP_BY_MACADDR + '/' + IP4_PREFIX]}}}
             m_get_phys_by_mac.return_value = {MACADDR: nic}
-            net = ds.OpenNebulaNetwork(context)
+            net = ds.OpenNebulaNetwork(context, mock.Mock())
             self.assertEqual(net.gen_conf(), expected)
 
     @mock.patch(DS_PATH + ".get_physical_nics_by_mac")
@@ -749,7 +749,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
                         'match': {'macaddress': MACADDR},
                         'addresses': [IP_BY_MACADDR + '/' + IP4_PREFIX]}}}
             m_get_phys_by_mac.return_value = {MACADDR: nic}
-            net = ds.OpenNebulaNetwork(context)
+            net = ds.OpenNebulaNetwork(context, mock.Mock())
             self.assertEqual(net.gen_conf(), expected)
 
         # set ETH0_MTU
@@ -765,14 +765,14 @@ class TestOpenNebulaNetwork(unittest.TestCase):
                         'match': {'macaddress': MACADDR},
                         'addresses': [IP_BY_MACADDR + '/' + IP4_PREFIX]}}}
             m_get_phys_by_mac.return_value = {MACADDR: nic}
-            net = ds.OpenNebulaNetwork(context)
+            net = ds.OpenNebulaNetwork(context, mock.Mock())
             self.assertEqual(net.gen_conf(), expected)
 
     @mock.patch(DS_PATH + ".get_physical_nics_by_mac")
     def test_eth0(self, m_get_phys_by_mac):
         for nic in self.system_nics:
             m_get_phys_by_mac.return_value = {MACADDR: nic}
-            net = ds.OpenNebulaNetwork({})
+            net = ds.OpenNebulaNetwork({}, mock.Mock())
             expected = {
                 'version': 2,
                 'ethernets': {
@@ -782,6 +782,14 @@ class TestOpenNebulaNetwork(unittest.TestCase):
 
             self.assertEqual(net.gen_conf(), expected)
 
+    @mock.patch(DS_PATH + ".get_physical_nics_by_mac")
+    def test_distro_passed_through(self, m_get_physical_nics_by_mac):
+        ds.OpenNebulaNetwork({}, mock.sentinel.distro)
+        self.assertEqual(
+            [mock.call(mock.sentinel.distro)],
+            m_get_physical_nics_by_mac.call_args_list,
+        )
+
     def test_eth0_override(self):
         self.maxDiff = None
         context = {
@@ -800,7 +808,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
             'ETH0_SEARCH_DOMAIN': '',
         }
         for nic in self.system_nics:
-            net = ds.OpenNebulaNetwork(context,
+            net = ds.OpenNebulaNetwork(context, mock.Mock(),
                                        system_nics_by_mac={MACADDR: nic})
             expected = {
                 'version': 2,
@@ -832,7 +840,7 @@ class TestOpenNebulaNetwork(unittest.TestCase):
             'ETH0_SEARCH_DOMAIN': 'example.com example.org',
         }
         for nic in self.system_nics:
-            net = ds.OpenNebulaNetwork(context,
+            net = ds.OpenNebulaNetwork(context, mock.Mock(),
                                        system_nics_by_mac={MACADDR: nic})
 
             expected = {
@@ -886,7 +894,10 @@ class TestOpenNebulaNetwork(unittest.TestCase):
             'ETH3_SEARCH_DOMAIN': 'third.example.com third.example.org',
         }
         net = ds.OpenNebulaNetwork(
-            context, system_nics_by_mac={MAC_1: 'enp0s25', MAC_2: 'enp1s2'})
+            context,
+            mock.Mock(),
+            system_nics_by_mac={MAC_1: 'enp0s25', MAC_2: 'enp1s2'}
+        )
 
         expected = {
             'version': 2,
@@ -926,6 +937,36 @@ class TestParseShellConfig:
         assert ret == {"foo": "bar", "xx": "foo"}
 
 
+class TestGetPhysicalNicsByMac:
+    @pytest.mark.parametrize(
+        "interfaces_by_mac,physical_devs,expected_return",
+        [
+            # No interfaces => empty return
+            ({}, [], {}),
+            # Only virtual interface => empty return
+            ({"mac1": "virtual0"}, [], {}),
+            # Only physical interface => it is returned
+            ({"mac2": "physical0"}, ["physical0"], {"mac2": "physical0"}),
+            # Combination of physical and virtual => only physical returned
+            (
+                {"mac3": "physical1", "mac4": "virtual1"},
+                ["physical1"],
+                {"mac3": "physical1"},
+            ),
+        ],
+    )
+    def test(self, interfaces_by_mac, physical_devs, expected_return):
+        distro = mock.Mock()
+        distro.networking.is_physical.side_effect = (
+            lambda devname: devname in physical_devs
+        )
+        with mock.patch(
+            DS_PATH + ".net.get_interfaces_by_mac",
+            return_value=interfaces_by_mac,
+        ):
+            assert expected_return == ds.get_physical_nics_by_mac(distro)
+
+
 def populate_context_dir(path, variables):
     data = "# Context variables generated by OpenNebula\n"
     for k, v in variables.items():