refactor(test): Store binary_dir inside microvm

Just store the binary dir inside the microvm class instead of separate
paths to firecracker and jailer binaries. This centralizes the existance
assertions, but means we cant theoretically use jailer and firecracker
binaries from different locations anymore (however, nothing in the test
framework was doing this, as MicroVMFactory already did not support this
and hardcoded the binary names relative to the --binary-dir option).

Signed-off-by: Patrick Roy <[email protected]>

Author: roypat

tests/conftest.py

@@ -33,6 +33,7 @@
 import host_tools.cargo_build as build_tools
 from framework import defs, utils
 from framework.artifacts import disks, kernel_params
+from framework.defs import DEFAULT_BINARY_DIR
 from framework.microvm import MicroVMFactory
 from framework.properties import global_props
 from framework.utils_cpu_templates import (
@@ -293,14 +294,9 @@ def get(self, _netns_id):
 def microvm_factory(request, record_property, results_dir, netns_factory):
     """Fixture to create microvms simply."""
 
-    if binary_dir := request.config.getoption("--binary-dir"):
-        fc_binary_path = Path(binary_dir) / "firecracker"
-        jailer_binary_path = Path(binary_dir) / "jailer"
-        if not fc_binary_path.exists():
-            raise RuntimeError("Firecracker binary does not exist")
-    else:
-        fc_binary_path, jailer_binary_path = build_tools.get_firecracker_binaries()
-    record_property("firecracker_bin", str(fc_binary_path))
+    binary_dir = request.config.getoption("--binary-dir") or DEFAULT_BINARY_DIR
+
+    record_property("firecracker_bin", str(binary_dir / "firecracker"))
 
     # If `--custom-cpu-template` option is provided, the given CPU template will
     # be applied afterwards unless overwritten.
@@ -316,8 +312,7 @@ def microvm_factory(request, record_property, results_dir, netns_factory):
     # We could override the chroot base like so
     # jailer_kwargs={"chroot_base": "/srv/jailo"}
     uvm_factory = MicroVMFactory(
-        fc_binary_path,
-        jailer_binary_path,
+        binary_dir,
         netns_factory=netns_factory,
         custom_cpu_template=custom_cpu_template,
     )

tests/framework/defs.py

@@ -26,6 +26,13 @@
 # Absolute path to the test results folder
 TEST_RESULTS_DIR = FC_WORKSPACE_DIR / "test_results"
 
+DEFAULT_BINARY_DIR = (
+    LOCAL_BUILD_PATH
+    / "cargo_target"
+    / f"{platform.machine()}-unknown-linux-musl"
+    / "release"
+)
+
 # The minimum required host kernel version for which io_uring is supported in
 # Firecracker.
 MIN_KERNEL_VERSION_FOR_IO_URING = "5.10.51"

tests/framework/microvm.py

@@ -1073,13 +1073,25 @@ def wait_for_ssh_up(self):
 class MicroVMFactory:
     """MicroVM factory"""
 
-    def __init__(self, fc_binary_path: Path, jailer_binary_path: Path, **kwargs):
+    def __init__(self, binary_path: Path, **kwargs):
         self.vms = []
-        self.fc_binary_path = Path(fc_binary_path)
-        self.jailer_binary_path = Path(jailer_binary_path)
+        self.binary_path = binary_path
         self.netns_factory = kwargs.pop("netns_factory", net_tools.NetNs)
         self.kwargs = kwargs
 
+        assert self.fc_binary_path.exists(), "missing firecracker binary"
+        assert self.jailer_binary_path.exists(), "missing jailer binary"
+
+    @property
+    def fc_binary_path(self):
+        """The path to the firecracker binary from which this factory will build VMs"""
+        return self.binary_path / "firecracker"
+
+    @property
+    def jailer_binary_path(self):
+        """The path to the jailer binary using which this factory will build VMs"""
+        return self.binary_path / "jailer"
+
     def build(self, kernel=None, rootfs=None, **kwargs):
         """Build a microvm"""
         kwargs = self.kwargs | kwargs

tests/host_tools/cargo_build.py

@@ -65,17 +65,6 @@ def get_binary(name, *, workspace_dir=FC_WORKSPACE_DIR, example=None):
     return bin_path
 
 
-def get_firecracker_binaries(*, workspace_dir=FC_WORKSPACE_DIR):
-    """Build the Firecracker and Jailer binaries if they don't exist.
-
-    Returns the location of the firecracker related binaries eventually after
-    building them in case they do not exist at the specified root_path.
-    """
-    return get_binary("firecracker", workspace_dir=workspace_dir), get_binary(
-        "jailer", workspace_dir=workspace_dir
-    )
-
-
 def get_example(name, *args, package="firecracker", **kwargs):
     """Build an example binary"""
     return get_binary(package, *args, **kwargs, example=name)

tools/sandbox.py

@@ -14,8 +14,8 @@
 from pathlib import Path
 
 from framework.artifacts import disks, kernels
+from framework.defs import DEFAULT_BINARY_DIR
 from framework.microvm import MicroVMFactory
-from host_tools.cargo_build import get_firecracker_binaries
 
 kernels = list(kernels("vmlinux-*"))
 rootfs = list(disks("ubuntu*ext4"))
@@ -61,17 +61,16 @@ def parse_byte_size(param):
 args = parser.parse_args()
 print(args)
 
-bins = None
+binary_dir = None
 if args.binary_dir:
     binary_dir = Path(args.binary_dir).resolve()
-    bins = binary_dir / "firecracker", binary_dir / "jailer"
 else:
-    bins = get_firecracker_binaries()
+    binary_dir = DEFAULT_BINARY_DIR
 
 cpu_template = None
 if args.cpu_template_path is not None:
     cpu_template = json.loads(args.cpu_template_path.read_text())
-vmfcty = MicroVMFactory(*bins)
+vmfcty = MicroVMFactory(binary_dir)
 
 print(f"uvm with kernel {args.kernel} ...")
 uvm = vmfcty.build(args.kernel, args.rootfs)

tools/test-popular-containers/test-docker-rootfs.py

@@ -17,16 +17,16 @@
 
 # pylint: disable=wrong-import-position
 from framework.artifacts import kernels
+from framework.defs import DEFAULT_BINARY_DIR
 from framework.microvm import MicroVMFactory
-from host_tools.cargo_build import get_firecracker_binaries
 
 # pylint: enable=wrong-import-position
 
 kernels = list(kernels("vmlinux-*"))
 # Use the latest guest kernel
 kernel = kernels[-1]
 
-vmfcty = MicroVMFactory(*get_firecracker_binaries())
+vmfcty = MicroVMFactory(DEFAULT_BINARY_DIR)
 # (may take a while to compile Firecracker...)
 
 for rootfs in Path(".").glob("*.ext4"):