tests: microvm: drop create_jailed_resource

Now the function always tries to do the right thing.

Signed-off-by: Pablo Barbáchano <[email protected]>

Author: pb8o

tests/framework/jailer.py

@@ -127,7 +127,7 @@ def api_socket_path(self):
         """Return the MicroVM API socket path."""
         return self.chroot / self.api_socket_name
 
-    def jailed_path(self, file_path, create=False, subdir="."):
+    def jailed_path(self, file_path, subdir="."):
         """Create a hard link or block special device owned by uid:gid.
 
         Create a hard link or block special device from the specified file,
@@ -138,7 +138,7 @@ def jailed_path(self, file_path, create=False, subdir="."):
         global_p = self.chroot / subdir / file_path.name
         global_p.parent.mkdir(parents=True, exist_ok=True)
         jailed_p = Path("/") / subdir / file_path.name
-        if create and not global_p.exists():
+        if not global_p.exists():
             stat_src = file_path.stat()
             if file_path.is_block_device():
                 perms = stat.S_IRUSR | stat.S_IWUSR
@@ -160,7 +160,7 @@ def setup(self):
         """Set up this jailer context."""
         os.makedirs(self.chroot, exist_ok=True)
         # Copy the /etc/localtime file in the jailer root
-        self.jailed_path("/etc/localtime", create=True, subdir="etc")
+        self.jailed_path("/etc/localtime", subdir="etc")
 
     def cleanup(self):
         """Clean up this jailer context."""

tests/framework/microvm.py

@@ -450,15 +450,12 @@ def flush_metrics(self):
         # get the latest metrics
         return self.get_all_metrics()[-1]
 
-    def create_jailed_resource(self, path):
-        """Create a hard link to some resource inside this microvm."""
-        return self.jailer.jailed_path(path, create=True)
-
     def jail_path(self, path):
-        """Get the relative jailed path to a resource.
+        """Return a path relative to the chroot
 
-        Also fix permissions if needed"""
-        return self.jailer.jailed_path(path, create=False)
+        Copies/hardlinks and fixes permissions as needed.
+        """
+        return self.jailer.jailed_path(path)
 
     @property
     def chroot(self):
@@ -562,7 +559,7 @@ def spawn(
         if self.metadata_file:
             if os.path.exists(self.metadata_file):
                 LOG.debug("metadata file exists, adding as a jailed resource")
-                self.create_jailed_resource(self.metadata_file)
+                self.jail_path(self.metadata_file)
             self.jailer.extra_args.update(
                 {"metadata": os.path.basename(self.metadata_file)}
             )
@@ -676,14 +673,12 @@ def basic_config(
         if boot_args is not None:
             self.boot_args = boot_args
         boot_source_args = {
-            "kernel_image_path": self.create_jailed_resource(self.kernel_file),
+            "kernel_image_path": self.jail_path(self.kernel_file),
             "boot_args": self.boot_args,
         }
 
         if use_initrd and self.initrd_file is not None:
-            boot_source_args.update(
-                initrd_path=self.create_jailed_resource(self.initrd_file)
-            )
+            boot_source_args.update(initrd_path=self.jail_path(self.initrd_file))
 
         self.api.boot.put(**boot_source_args)
 
@@ -727,10 +722,9 @@ def add_drive(
     ):
         """Add a block device."""
 
-        path_on_jail = self.create_jailed_resource(path_on_host)
         self.api.drive.put(
             drive_id=drive_id,
-            path_on_host=path_on_jail,
+            path_on_host=self.jail_path(path_on_host),
             is_root_device=is_root_device,
             is_read_only=is_read_only,
             partuuid=partuuid,
@@ -779,7 +773,7 @@ def patch_drive(self, drive_id, file=None):
         if file:
             self.api.drive.patch(
                 drive_id=drive_id,
-                path_on_host=self.create_jailed_resource(file),
+                path_on_host=self.jail_path(file),
             )
             self.disks[drive_id] = Path(file)
         else:
@@ -891,7 +885,7 @@ def restore_from_snapshot(
         assert len(snapshot_disks) > 0, "Snapshot requires at least one disk."
         jailed_disks = []
         for disk in snapshot_disks:
-            jailed_disks.append(self.create_jailed_resource(disk))
+            jailed_disks.append(self.jail_path(disk))
         self.disks = snapshot.disks
         self.ssh_key = snapshot.ssh_key
 

tests/integration_tests/functional/test_api.py

@@ -60,7 +60,7 @@ def test_drive_io_engine(uvm_plain):
 
     kwargs = {
         "drive_id": "rootfs",
-        "path_on_host": test_microvm.create_jailed_resource(test_microvm.rootfs_file),
+        "path_on_host": test_microvm.jail_path(test_microvm.rootfs_file),
         "is_root_device": True,
         "is_read_only": True,
     }

tests/integration_tests/functional/test_cmd_line_start.py

@@ -27,8 +27,8 @@ def _configure_vm_from_json(test_microvm, vm_config_file):
     parameter to this helper function.
     """
     # since we don't use basic-config, we do it by hand
-    test_microvm.create_jailed_resource(test_microvm.kernel_file)
-    test_microvm.create_jailed_resource(test_microvm.rootfs_file)
+    test_microvm.jail_path(test_microvm.kernel_file)
+    test_microvm.jail_path(test_microvm.rootfs_file)
 
     vm_config_file = Path(vm_config_file)
     obj = json.load(vm_config_file.open(encoding="UTF-8"))

tests/integration_tests/functional/test_drive_virtio.py

@@ -54,7 +54,7 @@ def test_rescan_file(uvm_plain_any, io_engine):
 
     test_microvm.api.drive.patch(
         drive_id="scratch",
-        path_on_host=test_microvm.create_jailed_resource(fs.path),
+        path_on_host=test_microvm.jail_path(fs.path),
     )
 
     _check_block_size(test_microvm.ssh, "/dev/vdb", fs.size())
@@ -132,7 +132,7 @@ def test_rescan_dev(uvm_plain_any, io_engine):
     try:
         test_microvm.api.drive.patch(
             drive_id="scratch",
-            path_on_host=test_microvm.create_jailed_resource(loopback_device),
+            path_on_host=test_microvm.jail_path(loopback_device),
         )
 
         _check_block_size(test_microvm.ssh, "/dev/vdb", fs2.size())
@@ -262,7 +262,7 @@ def test_patch_drive(uvm_plain_any, io_engine):
     # Updates to `path_on_host` with a valid path are allowed.
     fs2 = drive_tools.FilesystemFile(test_microvm.chroot / "otherscratch", size=512)
     test_microvm.api.drive.patch(
-        drive_id="scratch", path_on_host=test_microvm.create_jailed_resource(fs2.path)
+        drive_id="scratch", path_on_host=test_microvm.jail_path(fs2.path)
     )
 
     _check_mount(test_microvm.ssh, "/dev/vdb")

tests/integration_tests/functional/test_snapshot_basic.py

@@ -239,8 +239,8 @@ def test_load_snapshot_failure_handling(uvm_plain):
     snapshot_vmstate.touch()
 
     # Hardlink the snapshot files into the microvm jail.
-    jailed_mem = vm.create_jailed_resource(snapshot_mem)
-    jailed_vmstate = vm.create_jailed_resource(snapshot_vmstate)
+    jailed_mem = vm.jail_path(snapshot_mem)
+    jailed_vmstate = vm.jail_path(snapshot_vmstate)
 
     # Load the snapshot
     expected_msg = (

tests/integration_tests/functional/test_uffd.py

@@ -2,8 +2,8 @@
 # SPDX-License-Identifier: Apache-2.0
 """Test UFFD related functionality when resuming from snapshot."""
 
-import os
 import re
+from pathlib import Path
 
 import pytest
 import requests
@@ -39,10 +39,10 @@ def snapshot_fxt(microvm_factory, guest_kernel_linux_5_10, rootfs):
 def spawn_pf_handler(vm, handler_path, mem_path):
     """Spawn page fault handler process."""
     # Copy snapshot memory file into chroot of microVM.
-    jailed_mem = vm.create_jailed_resource(mem_path)
+    jailed_mem = vm.jail_path(mem_path)
     # Copy the valid page fault binary into chroot of microVM.
-    jailed_handler = vm.create_jailed_resource(handler_path)
-    handler_name = os.path.basename(jailed_handler)
+    jailed_handler = Path(vm.jail_path(handler_path))
+    handler_name = jailed_handler.name
 
     uffd_handler = UffdHandler(
         handler_name, SOCKET_PATH, jailed_mem, vm.chroot, "uffd.log"
@@ -58,7 +58,7 @@ def test_bad_socket_path(uvm_plain, snapshot):
     """
     vm = uvm_plain
     vm.spawn()
-    jailed_vmstate = vm.create_jailed_resource(snapshot.vmstate)
+    jailed_vmstate = vm.jail_path(snapshot.vmstate)
 
     expected_msg = re.escape(
         "Load snapshot error: Failed to restore from snapshot: Failed to load guest "
@@ -81,7 +81,7 @@ def test_unbinded_socket(uvm_plain, snapshot):
     vm = uvm_plain
     vm.spawn()
 
-    jailed_vmstate = vm.create_jailed_resource(snapshot.vmstate)
+    jailed_vmstate = vm.jail_path(snapshot.vmstate)
     socket_path = vm.chroot / "firecracker-uffd.sock"
     socket_path.touch()
     jailed_sock_path = vm.jail_path(socket_path)

tests/integration_tests/functional/test_vsock.py

@@ -250,7 +250,7 @@ def test_vsock_transport_reset_g2h(uvm_nano, microvm_factory):
         # Give some time for host socat to create socket
         time.sleep(0.5)
         assert Path(host_socket_path).exists()
-        new_vm.create_jailed_resource(host_socket_path)
+        new_vm.jail_path(host_socket_path)
 
         # Create a socat process in the guest which will connect to the host socat
         guest_socat_commmand = (

tests/integration_tests/performance/test_process_startup_time.py

@@ -80,5 +80,5 @@ def _test_startup_time(microvm, metrics, test_suffix: str):
 def _custom_filter_setup(test_microvm):
     bpf_path = test_microvm.chroot / "bpf.out"
     run_seccompiler_bin(bpf_path)
-    test_microvm.create_jailed_resource(bpf_path)
+    test_microvm.jail_path(bpf_path)
     test_microvm.jailer.extra_args.update({"seccomp-filter": "bpf.out"})

tests/integration_tests/performance/test_vsock_ab.py

@@ -52,7 +52,7 @@ def spawn_iperf3_client(self, client_idx, client_mode_flag):
         uds_path = self._microvm.chroot / make_host_port_path(
             VSOCK_UDS_PATH, self._base_port + client_idx
         )
-        self._microvm.create_jailed_resource(uds_path)
+        self._microvm.jail_path(uds_path)
         # The rootfs does not have iperf3-vsock
         iperf3_guest = "/tmp/iperf3-vsock"