tests(vhost-user-block): added initial integration test

Added a simple test that boots a VM with vhost-user-block
as root block device.

Signed-off-by: Egor Lazarchuk <[email protected]>

Author: ShadowCurse

tests/framework/defs.py

@@ -29,6 +29,9 @@
 # Default test session root directory path
 DEFAULT_TEST_SESSION_ROOT_PATH = "/srv"
 
+# Default test session artifacts path
+LOCAL_BUILD_PATH = FC_WORKSPACE_DIR / "build/"
+
 # Absolute path to the test results folder
 TEST_RESULTS_DIR = FC_WORKSPACE_DIR / "test_results"
 
@@ -46,6 +49,6 @@
 
 # fall-back to the local directory
 if not IMG_DIR.exists():
-    IMG_DIR = Path(__file__).joinpath("../../../build/img").resolve()
+    IMG_DIR = LOCAL_BUILD_PATH / "img"
 
 ARTIFACT_DIR = IMG_DIR / platform.machine()

tests/framework/microvm.py

@@ -666,6 +666,24 @@ def add_drive(
         )
         self.disks[drive_id] = path_on_host
 
+    def add_vhost_user_block(
+        self,
+        drive_id,
+        socket,
+        partuuid=None,
+        is_root_device=False,
+        cache_type=None,
+    ):
+        """Add a vhost-user block device."""
+
+        self.api.drive.put(
+            drive_id=drive_id,
+            socket=socket,
+            partuuid=partuuid,
+            is_root_device=is_root_device,
+            cache_type=cache_type,
+        )
+
     def patch_drive(self, drive_id, file):
         """Modify/patch an existing block device."""
         self.api.drive.patch(

tests/framework/utils.py

@@ -24,7 +24,11 @@
 from retry import retry
 from retry.api import retry_call
 
-from framework.defs import MIN_KERNEL_VERSION_FOR_IO_URING
+from framework.defs import (
+    MIN_KERNEL_VERSION_FOR_IO_URING,
+    DEFAULT_TEST_SESSION_ROOT_PATH,
+    LOCAL_BUILD_PATH,
+)
 
 FLUSH_CMD = 'screen -S {session} -X colon "logfile flush 0^M"'
 CommandReturn = namedtuple("CommandReturn", "returncode stdout stderr")
@@ -376,6 +380,16 @@ def __str__(self):
         return "\n\n".join(self.failures)
 
 
+def to_local_dir_path(tmp_dir_path: str) -> str:
+    """
+    Converts path from tmp dir to path on the host.
+    """
+
+    return tmp_dir_path.replace(
+        str(DEFAULT_TEST_SESSION_ROOT_PATH), str(LOCAL_BUILD_PATH)
+    )
+
+
 def search_output_from_cmd(cmd: str, find_regex: typing.Pattern) -> typing.Match:
     """
     Run a shell command and search a given regex object in stdout.

tests/integration_tests/build/test_binary_static_linking.py

@@ -8,15 +8,15 @@
 import host_tools.cargo_build as host
 from framework import utils
 
+
 @pytest.mark.timeout(500)
 def test_firecracker_binary_static_linking():
     """
     Test to make sure the firecracker binary is statically linked.
     """
     fc_binary_path = host.get_binary("firecracker")
-    _, stdout,stderr = utils.run_cmd(f"file {fc_binary_path}")
+    _, stdout, stderr = utils.run_cmd(f"file {fc_binary_path}")
     assert "" in stderr
     # expected "statically linked" for aarch64 and
     # "static-pie linked" for x86_64
-    assert "statically linked" in stdout or \
-           "static-pie linked" in stdout
+    assert "statically linked" in stdout or "static-pie linked" in stdout

tests/integration_tests/functional/test_vhost_user_block.py

@@ -0,0 +1,69 @@
+# Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+"""Tests for vhost-user-block device."""
+
+import os
+import platform
+import subprocess
+import stat
+import time
+import shutil
+from pathlib import Path
+
+import pytest
+
+import host_tools.cargo_build as host
+from framework import utils
+
+VHOST_USER_SOCKET = "/vub.socket"
+
+
+def spawn_vhost_user_backend(vm, host_mem_path):
+    """Spawn vhost-user-block backend."""
+
+    uid = vm.jailer.uid
+    gid = vm.jailer.gid
+
+    sp = f"{vm.chroot()}{VHOST_USER_SOCKET}"
+    args = ["vhost-user-blk", "-s", sp, "-b", host_mem_path, "-r"]
+    proc = subprocess.Popen(args)
+
+    time.sleep(1)
+    if proc is None or proc.poll() is not None:
+        print("vub is not running")
+
+    with utils.chroot(vm.chroot()):
+        # The backend will create the socket path with root rights.
+        # Change rights to the jailer's.
+        os.chown(VHOST_USER_SOCKET, uid, gid)
+    return proc
+
+
+def test_vhost_user_block(microvm_factory, guest_kernel, rootfs_ubuntu_22):
+    """
+    This test simply tries to boot a VM with
+    vhost-user-block as a root device.
+    """
+
+    vm = microvm_factory.build(guest_kernel, None, monitor_memory=False)
+
+    vm.jailer.extra_args.update({"no-seccomp": None})
+    ssh_key = rootfs_ubuntu_22.with_suffix(".id_rsa")
+    vm.ssh_key = ssh_key
+
+    vm.spawn()
+
+    # Converting path from tmp dir ("./srv/..") to local
+    # path on the host ("../build/..")
+    rootfs_path = utils.to_local_dir_path(str(rootfs_ubuntu_22))
+    backend = spawn_vhost_user_backend(vm, rootfs_path)
+
+    vm.basic_config()
+    vm.add_vhost_user_block("1", VHOST_USER_SOCKET, is_root_device=True)
+    vm.add_net_iface()
+    vm.start()
+
+    # Attempt to connect to the VM.
+    # Verify if guest can run commands.
+    exit_code, _, _ = vm.ssh.run("ls")
+    assert exit_code == 0