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,48 @@
+from __future__ import annotations
+
+import logging
+
+from lib.common import _param_add, _param_clear, _param_get, _param_remove, _param_set, safe_split
+from lib.pif import PIF
+
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from lib.host import Host
+
+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)
+
+    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

@@ -16,6 +16,7 @@
 if TYPE_CHECKING:
     from lib.pool import Pool
 
+from lib.bond import Bond
 from lib.common import (
     DiskDevName,
     _param_add,
@@ -32,6 +33,7 @@
     wait_for_not,
 )
 from lib.netutil import wrap_ip
+from lib.network import Network
 from lib.pif import PIF
 from lib.sr import SR
 from lib.vdi import VDI
@@ -768,3 +770,41 @@ 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]:
+        args: Dict[str, str | bool] = {
+            "host-uuid": self.uuid,
+        }
+
+        if device is not None:
+            args["device"] = device
+
+        return [PIF(uuid, self) for uuid in safe_split(self.xe("pif-list", args, minimal=True))]
+
+    def bond_create(self, 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 = self.xe("bond-create", args, minimal=True)
+        logging.info(f"New Bond: {uuid}")
+
+        return Bond(self, uuid)
+
+    def network_create(self, 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 = self.xe("network-create", args, minimal=True)
+        logging.info(f"New Network: {uuid}")
+
+        return Network(self, uuid)

lib/network.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import logging
+
+from lib.common import _param_add, _param_clear, _param_get, _param_remove, _param_set, safe_split
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from lib.host import Host
+
+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)
+
+    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,46 @@
 import pytest
 
+import logging
+
+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 = host.network_create(label="empty_network for tests")
+        yield net
+    finally:
+        net.destroy()
+
+@pytest.fixture(params=[])
+def bond_devices(request: pytest.FixtureRequest) -> list[str]:
+    return request.param
+
+@pytest.fixture(params=["lacp"])
+def bond_mode(request: pytest.FixtureRequest) -> str:
+    return request.param
+
+@pytest.fixture
+def bond(host: Host, empty_network: Network, bond_devices: list[str], bond_mode: str):
+    pifs = []
+    logging.info(f"bond: resolve PIFs on {host.hostname_or_ip} using \
+        {[(pif.network_uuid(), pif.param_get('device')) for pif in host.pifs()]}")
+    for name in bond_devices:
+        [pif] = host.pifs(device=name)
+        pifs.append(pif)
+
+    bond = host.bond_create(empty_network, pifs, mode=bond_mode)
+    try:
+        yield bond
+    finally:
+        bond.destroy()

tests/network/test_bond.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import pytest
+
+import logging
+
+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)
+
+@pytest.mark.small_vm
+class TestNetwork:
+    @pytest.mark.no_vm
+    def test_basic(self, host: Host, empty_network: Network):
+        assert empty_network.PIF_uuids() == [], "PIF list must be empty"
+        assert empty_network.VIF_uuids() == [], "VIF list must be empty"
+        assert empty_network.is_private(), "empty_network must be 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("bond_devices", [["eth1", "eth2"]])
+@pytest.mark.parametrize("bond_mode", ["lacp", "active-backup", "balance-slb"])
+def test_bond(host: Host, imported_vm: VM, bond_devices: list[str], bond_mode: str, bond: Bond):
+    # expect host with eth1 and eth2 NICs free for use
+    logging.info(f"Bond = {bond.uuid} mode={bond.mode()} slaves={bond.slaves()}")
+
+    # disable LACP fallback (make Bond to require LACP negociation first)
+    if bond_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 bond_mode == 'lacp':
+        bond_mode_output = 'balance-tcp'
+    else:
+        bond_mode_output = bond_mode
+
+    if f"bond_mode: {bond_mode_output}" not in ret.stdout:
+        pytest.fail(f"unexpected bond_mode: {bond_mode}: stdout={ret.stdout}")
+
+    if bond_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 bond_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()