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::test_bond",
     # 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 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 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,148 @@
+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
+
+# Requirements:
+# From --hosts parameter:
+# - host(A1): first XCP-ng host, with at least 3 NICs (1 management, 2 unused), with tcpdump
+# From --vm parameter
+# - A VM to import (alpine expected)
+
+@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()
+
+def _wait_for_packet(host: Host | VM, interface: str, sfilter: str, timeout: int = 30) -> None:
+    ret = host.ssh_with_result(f"timeout {timeout} tcpdump -i {interface} -n -c1 '{sfilter}'")
+    if ret.returncode != 0:
+        pytest.fail(f"tcpdump error: code={ret.returncode} stdout={ret.stdout}")
+    return None
+
+@pytest.mark.complex_prerequisites
+@pytest.mark.small_vm
+@pytest.mark.parametrize("mode", ["lacp", "active-backup", "balance-slb"])
+def test_bond(host: Host, empty_network: Network, imported_vm: VM, mode):
+    network = empty_network
+    assert len(network.PIF_uuids()) == 0
+
+    assert host.ssh_with_result("which tcpdump").returncode == 0, \
+        "host should have tcpdump installed"
+
+    # expect host with eth1 and eth2 NICs free for use
+    with managed_bond(host, network, ["eth1", "eth2"], mode) as bond:
+        logging.info(f"Bond = {bond.uuid} mode={bond.mode()} slaves={bond.slaves()}")
+
+        # disable LACP fallback (make Bond to require LACP negociation first)
+        if mode == "lacp":
+            bond.param_set("properties", key="lacp-fallback-ab", value=False)
+
+        # check bond0 on the host
+        ret = host.ssh_with_result("ovs-appctl bond/show bond0")
+        if ret.returncode != 0:
+            pytest.fail(f"ovs-appctl bond/show failed: exitcode={ret.returncode} stdout={ret.stdout}")
+
+        if mode == 'lacp':
+            bond_mode = 'balance-tcp'
+        else:
+            bond_mode = mode
+
+        if f"bond_mode: {bond_mode}" not in ret.stdout:
+            pytest.fail(f"unexpected bond_mode: {mode}: stdout={ret.stdout}")
+
+        if mode == 'lacp':
+            if "lacp_fallback_ab: false" not in ret.stdout:
+                pytest.fail(f"unexpected lacp_fallback_ab: stdout={ret.stdout}")
+            elif "lacp_status: configured" not in ret.stdout:
+                pytest.fail(f"unexpected lacp_status: stdout={ret.stdout}")
+        else:
+            if "lacp_status: off" not in ret.stdout:
+                pytest.fail(f"unexpected lacp_status: stdout={ret.stdout}")
+
+        try:
+            # on the VM, add a new NIC using the bond
+            vm = imported_vm.clone()
+            vm.create_vif(1, network_uuid=bond.master().network_uuid())
+            vm.start()
+            vm.wait_for_vm_running_and_ssh_up()
+
+            vm.ssh("apk add tcpdump")
+            vm.ssh("ip link set eth1 up")
+
+            if mode == 'lacp':
+                # we are checking if we are seeing LACP packet on VM side.
+                #
+                # OpenvSwitch will send LACP negociation on host.eth1 and host.eth2
+                # to etablish LACP link. As we don't have other side, it will keep
+                # sending them.
+                # On VM side, we could see such packets. So we are checking the VM.eth1
+                # is properly connected to the Bond just created (but we don't check that
+                # OpenvSwitch is properly setup)
+                logging.info("Waiting for LACP packet")
+                _wait_for_packet(vm, "eth1", "ether proto 0x8809")
+
+            else:
+                # just check if we see a packet on the host side.
+                # theVM kernel is expected to send IPv6 packet for Router Solicitation
+                # as the VM interface is UP.
+                logging.info("Waiting for some IPv6 packet")
+                _wait_for_packet(host, "eth1", "ether proto 0x86dd")
+
+        finally:
+            vm.destroy()