Add few bond tests

- add some tests for Bond
- add new abstractions (Network and Bond) with fixtures

Signed-off-by: Sebastien Marie <semarie@kapouay.eu.org>

Author: semarie

jobs.py

@@ -468,6 +468,8 @@
 BROKEN_TESTS = [
     # not really broken but has complex prerequisites (3 NICs on 3 different networks)
     "tests/migration/test_host_evacuate.py::TestHostEvacuateWithNetwork",
+    # not really broken but has complex prerequisites (3 NICs)
+    "tests/network/test_bond.py::TestBond",
     # running quicktest on zfsvol generates dangling TAP devices that are hard to
     # cleanup. Bug needs to be fixed before enabling quicktest on zfsvol.
     "tests/storage/zfsvol/test_zfsvol_sr.py::TestZfsvolVm::test_quicktest",

lib/bond.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import logging
+
+from lib.common import _param_add, _param_clear, _param_get, _param_remove, _param_set, safe_split
+from lib.host import Host
+from lib.network import Network
+from lib.pif import PIF
+
+from typing import Dict, List, Optional
+
+class Bond:
+    xe_prefix = "bond"
+
+    def __init__(self, host: Host, uuid: str):
+        self.host = host
+        self.uuid = uuid
+
+    def param_get(self, param_name, key=None, accept_unknown_key=False):
+        return _param_get(self.host, Bond.xe_prefix, self.uuid, param_name, key, accept_unknown_key)
+
+    def param_set(self, param_name, value, key=None):
+        _param_set(self.host, Bond.xe_prefix, self.uuid, param_name, value, key)
+
+    def param_add(self, param_name, value, key=None):
+        _param_add(self.host, Bond.xe_prefix, self.uuid, param_name, value, key)
+
+    def param_clear(self, param_name):
+        _param_clear(self.host, Bond.xe_prefix, self.uuid, param_name)
+
+    def param_remove(self, param_name, key, accept_unknown_key=False):
+        _param_remove(self.host, Bond.xe_prefix, self.uuid, param_name, key, accept_unknown_key)
+
+    @staticmethod
+    def create(host: Host, network: Network, pifs: List[PIF], mode: Optional[str] = None) -> Bond:
+        args: Dict[str, str | bool] = {
+            'network-uuid': network.uuid,
+            'pif-uuids': ','.join([pif.uuid for pif in pifs]),
+        }
+
+        if mode is not None:
+            args['mode'] = mode
+
+        uuid = host.xe("bond-create", args, minimal=True)
+        logging.info(f"New Bond: {uuid}")
+
+        return Bond(host, uuid)
+
+    def destroy(self):
+        logging.info(f"Destroying bond: {self.uuid}")
+        self.host.xe('bond-destroy', {'uuid': self.uuid})
+
+    def master(self) -> PIF:
+        uuid = self.param_get('master')
+        assert uuid is not None, "no master on Bond"
+        return PIF(uuid, self.host)
+
+    def slaves(self) -> List[str]:
+        return safe_split(self.param_get('slaves'))
+
+    def mode(self) -> Optional[str]:
+        return self.param_get("mode")

lib/host.py

@@ -767,3 +767,13 @@ def lvs(self, vgName: Optional[str] = None, ignore_MGT: bool = True) -> List[str
                 continue
             ret.append(line.strip())
         return ret
+
+    def PIFs(self, device: Optional[str] = None) -> List[pif.PIF]:
+        args: Dict[str, str | bool] = {
+            "host-uuid": self.uuid,
+        }
+
+        if device is not None:
+            args["device"] = device
+
+        return [pif.PIF(uuid, self) for uuid in safe_split(self.xe("pif-list", args, minimal=True))]

lib/network.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import logging
+
+from lib.common import _param_add, _param_clear, _param_get, _param_remove, _param_set, safe_split
+from lib.host import Host
+
+from typing import Dict, List, Optional
+
+class Network:
+    xe_prefix = "network"
+
+    def __init__(self, host: Host, uuid: str):
+        self.host = host
+        self.uuid = uuid
+
+    def param_get(self, param_name, key=None, accept_unknown_key=False):
+        return _param_get(self.host, Network.xe_prefix, self.uuid, param_name, key, accept_unknown_key)
+
+    def param_set(self, param_name, value, key=None):
+        _param_set(self.host, Network.xe_prefix, self.uuid, param_name, value, key)
+
+    def param_add(self, param_name, value, key=None):
+        _param_add(self.host, Network.xe_prefix, self.uuid, param_name, value, key)
+
+    def param_clear(self, param_name):
+        _param_clear(self.host, Network.xe_prefix, self.uuid, param_name)
+
+    def param_remove(self, param_name, key, accept_unknown_key=False):
+        _param_remove(self.host, Network.xe_prefix, self.uuid, param_name, key, accept_unknown_key)
+
+    @staticmethod
+    def create(host: Host, label: str, description: Optional[str] = None) -> Network:
+        args: Dict[str, str | bool] = {
+            'name-label': label,
+        }
+
+        if description is not None:
+            args['name-description'] = description
+
+        logging.info(f"Creating network '{label}'")
+        uuid = host.xe("network-create", args, minimal=True)
+        logging.info(f"New Network: {uuid}")
+
+        return Network(host, uuid)
+
+    def destroy(self):
+        logging.info(f"Destroying network '{self.param_get('name-label')}': {self.uuid}")
+        self.host.xe('network-destroy', {'uuid': self.uuid})
+
+    def PIF_uuids(self) -> List[str]:
+        return safe_split(self.param_get('PIF-uuids'), '; ')
+
+    def VIF_uuids(self) -> List[str]:
+        return safe_split(self.param_get('VIF-uuids'), '; ')
+
+    def is_private(self) -> bool:
+        return len(self.PIF_uuids()) == 0
+
+    def managed(self) -> bool:
+        return self.param_get('managed') == 'true'
+
+    def MTU(self) -> int:
+        return int(self.param_get('MTU') or '0')

lib/pif.py

@@ -1,9 +1,16 @@
+from __future__ import annotations
+
 from lib.common import _param_add, _param_clear, _param_get, _param_remove, _param_set
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from lib.host import Host
+
 class PIF:
     xe_prefix = "pif"
 
-    def __init__(self, uuid, host):
+    def __init__(self, uuid: str, host: Host):
         self.uuid = uuid
         self.host = host
 
@@ -26,3 +33,32 @@ def param_add(self, param_name, value, key=None):
     def param_clear(self, param_name):
         _param_clear(self.host, self.xe_prefix, self.uuid,
                      param_name)
+
+    def is_managed(self) -> bool:
+        return self.param_get("managed") == "true"
+
+    def is_physical(self) -> bool:
+        return self.param_get("physical") == "true"
+
+    def is_currently_attached(self) -> bool:
+        return self.param_get("currently-attached") == "true"
+
+    def is_management(self) -> bool:
+        return self.param_get("management") == "true"
+
+    def network_uuid(self) -> str:
+        uuid = self.param_get("network-uuid")
+        assert uuid is not None, "unexpected PIF without network-uuid"
+        return uuid
+
+    def reconfigure_ip(self, mode: str) -> None:
+        self.host.xe("pif-reconfigure-ip", {
+            "uuid": self.uuid,
+            "mode": mode,
+        })
+
+    def reconfigure_ipv6(self, mode: str) -> None:
+        self.host.xe("pif-reconfigure-ipv6", {
+            "uuid": self.uuid,
+            "mode": mode,
+        })

tests/network/conftest.py

@@ -1,7 +1,21 @@
 import pytest
 
+from lib.host import Host
+from lib.network import Network
+
+from typing import Generator
+
 @pytest.fixture(scope='package')
-def host_no_sdn_controller(host):
+def host_no_sdn_controller(host: Host):
     """ An XCP-ng with no SDN controller. """
     if host.xe('sdn-controller-list', minimal=True):
         pytest.skip("This test requires an XCP-ng with no SDN controller")
+
+
+@pytest.fixture(scope='module')
+def empty_network(host: Host) -> Generator[Network, None, None]:
+    try:
+        net = Network.create(host, label="empty_network for tests")
+        yield net
+    finally:
+        net.destroy()

tests/network/test_bond.py

@@ -0,0 +1,108 @@
+import pytest
+
+import logging
+from contextlib import contextmanager
+
+from lib.bond import Bond
+from lib.host import Host
+from lib.network import Network
+from lib.vm import VM
+
+from typing import List
+
+# Requirements:
+# From --hosts parameter:
+# - host(A1): first XCP-ng host, with at least 3 NICs (1 management, 2 unused)
+# From --vm parameter
+# - A VM to import
+
+@contextmanager
+def managed_bond(host: Host, network: Network, devices: List[str], mode: str):
+    pifs = []
+    for name in devices:
+        [pif] = host.PIFs(device=name)
+        pifs.append(pif)
+
+    bond = Bond.create(host, network, pifs, mode=mode)
+    try:
+        yield bond
+    finally:
+        bond.destroy()
+
+@pytest.mark.small_vm
+class TestNetwork:
+    @pytest.mark.no_vm
+    def test_basic(self, host: Host, empty_network: Network):
+        assert len(empty_network.PIF_uuids()) == 0, "unexpected number of PIFs in network"
+        assert len(empty_network.VIF_uuids()) == 0, "unexpected number of VIFs in network"
+        assert empty_network.is_private(), "empty_network isn't private"
+        assert empty_network.MTU() == 1500, "unexpected MTU"
+
+    def test_private_network(self, host: Host, empty_network: Network, imported_vm: VM):
+        network = empty_network
+
+        try:
+            vm1 = imported_vm.clone()
+            vm2 = imported_vm.clone()
+
+            vif_1_1 = vm1.create_vif(1, network_uuid=network.uuid)
+            vif_2_1 = vm2.create_vif(1, network_uuid=network.uuid)
+
+            assert len(vm1.vifs()) == 2, "VM1 should have 2 NICs"
+            assert len(vm2.vifs()) == 2, "VM2 should have 2 NICs"
+            assert len(network.VIF_uuids()) == 2, "unexpected number of VIFs in network"
+
+            vm1.start()
+            vm2.start()
+
+            vm1.wait_for_vm_running_and_ssh_up()
+            vm2.wait_for_vm_running_and_ssh_up()
+
+            logging.info("Configuring local address on private network")
+            vm1.ssh(f"ifconfig eth{vif_1_1.param_get('device')} inet 169.254.1.1 broadcast 169.254.0.0 up")
+            vm2.ssh(f"ifconfig eth{vif_2_1.param_get('device')} inet 169.254.2.1 broadcast 169.254.0.0 up")
+
+            logging.info("Ping VMs")
+            assert vm1.ssh_with_result(["ping", "-c3", "-w5", "169.254.2.1"]).returncode == 0
+            assert vm2.ssh_with_result(["ping", "-c3", "-w5", "169.254.1.1"]).returncode == 0
+
+        finally:
+            # VIFs are destroyed by VM.destroy()
+            vm2.destroy()
+            vm1.destroy()
+
+@pytest.mark.complex_prerequisites
+@pytest.mark.small_vm
+class TestBond:
+    def test_lacp(self, host: Host, empty_network: Network, imported_vm: VM):
+        try:
+            vm = imported_vm.clone()
+            network = empty_network
+            assert len(network.PIF_uuids()) == 0
+
+            # expect host with eth1 and eth2 NICs free for use
+            with managed_bond(host, network, ["eth1", "eth2"], "lacp") as bond:
+                logging.info(f"Bond = {bond.uuid} mode={bond.mode()} slaves={bond.slaves()}")
+
+                # disable LACP fallback (make Bond to require LACP negociation first)
+                bond.param_set("properties", key="lacp-fallback-ab", value=False)
+
+                # add new vif
+                vm.create_vif(1, network_uuid=bond.master().network_uuid())
+
+                vm.start()
+                vm.wait_for_vm_running_and_ssh_up()
+
+                # XXX check on host side
+                vm.ssh('apk add tcpdump')
+                vm.ssh('ip link set eth1 up')
+
+                logging.info("Waiting for LACP packet")
+                ret = vm.ssh_with_result('timeout 30 tcpdump -i eth1 -n -c1 "ether proto 0x8809"')
+                if ret.returncode == 124:
+                    pytest.fail("timeout, no LACP frame on eth1")
+                elif ret.returncode != 0:
+                    pytest.fail(f"tcpdump error: code={ret.returncode} stdout={ret.stdout}")
+
+        finally:
+            vm.destroy()