Merge pull request #390 from xcp-ng/srt/bond

Bond tests

Author: stormi

data.py-dist

@@ -269,3 +269,7 @@ IMAGE_EQUIVS: dict[str, str] = {
 
 # This should be a working DNS server that's not used by any VM images.
 TEST_DNS_SERVER = "1.1.1.1"
+
+# List of NICs available on host for network tests.
+# example: HOST_FREE_NICS: list[str] = ['eth1', 'eth2']
+HOST_FREE_NICS: list[str] = []

jobs.py

@@ -75,6 +75,20 @@ class JobData(TypedDict):
         "paths": ["tests/misc", "tests/migration"],
         "markers": "multi_vms and not flaky and not reboot",
     },
+    "network-advanced": {
+        "description": "a group of network tests with complex prerequisites",
+        "requirements": [
+            "A pool with at least 1 host.",
+            "At least 2 free NICs on every host.",
+            "A small VM that can be imported on the SRs.",
+        ],
+        "nb_pools": 1,
+        "params": {
+            "--vm": "single/small_vm",
+        },
+        "paths": ["tests/network"],
+        "markers": "complex_prerequisites",
+    },
     "packages": {
         "description": "tests that packages can be installed correctly",
         "requirements": [

lib/bond.py

@@ -0,0 +1,63 @@
+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, Literal, overload
+
+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
+
+    @overload
+    def param_get(self, param_name: str, key: str | None = ...,
+                  accept_unknown_key: Literal[False] = ...) -> str:
+        ...
+
+    @overload
+    def param_get(self, param_name: str, key: str | None = ...,
+                  accept_unknown_key: Literal[True] = ...) -> str | None:
+        ...
+
+    def param_get(self, param_name: str, key: str | None = None, accept_unknown_key: bool = False) -> str | None:
+        return _param_get(self.host, self.xe_prefix, self.uuid,
+                          param_name, key, accept_unknown_key)
+
+    def param_set(self, param_name: str, value: str, key: str | None = None) -> None:
+        _param_set(self.host, self.xe_prefix, self.uuid,
+                   param_name, value, key)
+
+    def param_remove(self, param_name: str, key: str, accept_unknown_key: bool = False) -> None:
+        _param_remove(self.host, self.xe_prefix, self.uuid,
+                      param_name, key, accept_unknown_key)
+
+    def param_add(self, param_name: str, value: str, key: str | None = None) -> None:
+        _param_add(self.host, self.xe_prefix, self.uuid,
+                   param_name, value, key)
+
+    def param_clear(self, param_name: str) -> None:
+        _param_clear(self.host, self.xe_prefix, self.uuid,
+                     param_name)
+
+    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'), sep='; ')
+
+    def mode(self) -> str | None:
+        return self.param_get("mode")

lib/common.py

@@ -80,6 +80,7 @@ class PackageManagerEnum(Enum):
     UNKNOWN = 1
     RPM = 2
     APT_GET = 3
+    APK = 4
 
 # Common VM images used in tests
 def vm_image(vm_key: str) -> str:

lib/host.py

@@ -12,6 +12,7 @@
 from packaging import version
 
 import lib.commands as commands
+from lib.bond import Bond
 from lib.common import (
     _param_add,
     _param_clear,
@@ -26,6 +27,7 @@
     wait_for,
 )
 from lib.netutil import wrap_ip
+from lib.network import Network
 from lib.pif import PIF
 from lib.sr import SR
 from lib.vm import VM
@@ -954,3 +956,41 @@ def lvs(self, vgName: str | None = None, ignore_MGT: bool = True) -> list[str]:
                 continue
             ret.append(line.strip())
         return ret
+
+    def pifs(self, device: str | None = None) -> list[PIF]:
+        args: dict[str, str | bool | dict[str, str]] = {
+            "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 create_bond(self, network: Network, pifs: list[PIF], mode: str | None = None) -> Bond:
+        args: dict[str, str | bool | dict[str, str]] = {
+            '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 create_network(self, label: str, description: str | None = None) -> Network:
+        args: dict[str, str | bool | dict[str, str]] = {
+            '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,66 @@
+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, Literal, overload
+
+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
+
+    @overload
+    def param_get(self, param_name: str, key: str | None = ...,
+                  accept_unknown_key: Literal[False] = ...) -> str:
+        ...
+
+    @overload
+    def param_get(self, param_name: str, key: str | None = ...,
+                  accept_unknown_key: Literal[True] = ...) -> str | None:
+        ...
+
+    def param_get(self, param_name: str, key: str | None = None, accept_unknown_key: bool = False) -> str | None:
+        return _param_get(self.host, self.xe_prefix, self.uuid,
+                          param_name, key, accept_unknown_key)
+
+    def param_set(self, param_name: str, value: str, key: str | None = None) -> None:
+        _param_set(self.host, self.xe_prefix, self.uuid,
+                   param_name, value, key)
+
+    def param_remove(self, param_name: str, key: str, accept_unknown_key: bool = False) -> None:
+        _param_remove(self.host, self.xe_prefix, self.uuid,
+                      param_name, key, accept_unknown_key)
+
+    def param_add(self, param_name: str, value: str, key: str | None = None) -> None:
+        _param_add(self.host, self.xe_prefix, self.uuid,
+                   param_name, value, key)
+
+    def param_clear(self, param_name: str) -> None:
+        _param_clear(self.host, self.xe_prefix, self.uuid,
+                     param_name)
+
+    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,6 +1,6 @@
 from __future__ import annotations
 
-from lib.common import _param_add, _param_clear, _param_get, _param_remove, _param_set
+from lib.common import _param_add, _param_clear, _param_get, _param_remove, _param_set, strtobool
 
 from typing import TYPE_CHECKING, Literal, overload
 
@@ -43,3 +43,37 @@ def param_add(self, param_name: str, value: str, key: str | None = None) -> None
     def param_clear(self, param_name: str) -> None:
         _param_clear(self.host, self.xe_prefix, self.uuid,
                      param_name)
+
+    def is_managed(self) -> bool:
+        return strtobool(self.param_get("managed"))
+
+    def is_physical(self) -> bool:
+        return strtobool(self.param_get("physical"))
+
+    def is_currently_attached(self) -> bool:
+        return strtobool(self.param_get("currently-attached"))
+
+    def is_management(self) -> bool:
+        return strtobool(self.param_get("management"))
+
+    def device(self) -> str:
+        device = self.param_get("device")
+        assert device is not None
+        return device
+
+    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,
+        })

lib/vm.py

@@ -502,6 +502,8 @@ def detect_package_manager(self) -> PackageManagerEnum:
             return PackageManagerEnum.RPM
         elif self.file_exists('/usr/bin/apt-get'):
             return PackageManagerEnum.APT_GET
+        elif self.file_exists('/sbin/apk'):
+            return PackageManagerEnum.APK
         else:
             return PackageManagerEnum.UNKNOWN
 

tests/network/conftest.py

@@ -1,9 +1,104 @@
+from __future__ import annotations
+
 import pytest
 
+import logging
+
+from data import HOST_FREE_NICS
+from lib.common import PackageManagerEnum
 from lib.host import Host
+from lib.network import Network
+from lib.vm import VM
+
+from typing import Generator
 
 @pytest.fixture(scope='package')
 def host_no_sdn_controller(host: Host) -> None:
     """ 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.fail("This test requires an XCP-ng with no SDN controller")
+
+# a clone of imported_vm in which we've added tcpdump
+# not to be used by tests directly
+@pytest.fixture(scope='module')
+def vm_with_tcpdump_scope_module(imported_vm: VM):
+    logging.info("Preparing VM with tcpdump installed")
+    vm = imported_vm.clone(name=f"{imported_vm.name()} with tcpdump")
+    vm.start()
+    vm.wait_for_vm_running_and_ssh_up()
+
+    # install tcpdump
+    pkg_mgr = vm.detect_package_manager()
+    if pkg_mgr == PackageManagerEnum.APK:
+        vm.ssh("apk add tcpdump")
+    elif pkg_mgr == PackageManagerEnum.APT_GET:
+        vm.ssh("apt-get install tcpdump")
+    elif pkg_mgr == PackageManagerEnum.RPM:
+        # XXX assume yum for now
+        vm.ssh("yum install tcpdump")
+    else:
+        pytest.fail("Package manager '%s' not supported" % pkg_mgr)
+
+    vm.shutdown(verify=True)
+    yield vm
+    vm.destroy()
+
+@pytest.fixture(scope='function')
+def vm_with_tcpdump_scope_function(vm_with_tcpdump_scope_module: VM):
+    vm = vm_with_tcpdump_scope_module.clone(name=f"{vm_with_tcpdump_scope_module.name()} for tests")
+    yield vm
+    vm.destroy()
+
+@pytest.fixture(scope='module')
+def empty_network(host: Host) -> Generator[Network, None, None]:
+    net = host.create_network(label="empty_network for tests")
+    yield net
+    net.destroy()
+
+@pytest.fixture(scope='function')
+def bond_lacp(host: Host, empty_network: Network):
+    if len(HOST_FREE_NICS) < 2:
+        pytest.fail("This fixture needs at least 2 free NICs")
+
+    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 HOST_FREE_NICS[0:2]:
+        [pif] = host.pifs(device=name)
+        pifs.append(pif)
+
+    bond = host.create_bond(empty_network, pifs, mode="lacp")
+    yield bond
+    bond.destroy()
+
+@pytest.fixture(scope='function')
+def bond_activebackup(host: Host, empty_network: Network):
+    if len(HOST_FREE_NICS) < 2:
+        pytest.fail("This fixture needs at least 2 free NICs")
+
+    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 HOST_FREE_NICS[0:2]:
+        [pif] = host.pifs(device=name)
+        pifs.append(pif)
+
+    bond = host.create_bond(empty_network, pifs, mode="active-backup")
+    yield bond
+    bond.destroy()
+
+@pytest.fixture(scope='function')
+def bond_balanceslb(host: Host, empty_network: Network):
+    if len(HOST_FREE_NICS) < 2:
+        pytest.fail("This fixture needs at least 2 free NICs")
+
+    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 HOST_FREE_NICS[0:2]:
+        [pif] = host.pifs(device=name)
+        pifs.append(pif)
+
+    bond = host.create_bond(empty_network, pifs, mode="balance-slb")
+    yield bond
+    bond.destroy()