Refactor file transfer and disk free space utilities

hholoubk · hholoubk · commit 72929094d1fd · 2026-03-24T12:18:47.000+01:00
Move run_file_transfer and run_virtio_serial_file_transfer from
utils_test/__init__.py into new utils_test/file_transfer.py module.
Re-exports in __init__.py preserve backward compatibility.

Convert utils_disk.py to utils_disk/ package. Move get_free_disk
from utils_misc.py to utils_disk/free_space.py and add new
check_free_disk helper. Re-exports in utils_disk/__init__.py and
utils_misc.py preserve backward compatibility.

Add guest disk free space validation in run_file_transfer to fail
early with a clear error when the VM has insufficient space for
the transfer.

Assisted-by: Claude AI (cursor) human design
Signed-off-by: hholoubk &lt;hholoubk@redhat.com&gt;
Made-with: Cursor
diff --git a/virttest/utils_disk/__init__.py b/virttest/utils_disk/__init__.py
@@ -1754,3 +1754,7 @@ def close(self):
         """
         if self.g:
             self.g.close()
+
+
+from virttest.utils_disk.free_space import check_free_disk  # noqa: E402,F401
+from virttest.utils_disk.free_space import get_free_disk  # noqa: E402,F401
diff --git a/virttest/utils_disk/free_space.py b/virttest/utils_disk/free_space.py
@@ -0,0 +1,50 @@
+"""Guest disk free space utilities."""
+
+import re
+
+from avocado.core import exceptions
+
+from virttest.utils_numeric import normalize_data_size
+
+
+def get_free_disk(session, mount):
+    """Get FreeSpace for given mount point.
+
+    :param session: shell Object.
+    :type session: aexpect.ShellSession
+    :param mount: mount point(eg. C:, /mnt)
+    :type mount: str
+    :return: freespace in M-bytes
+    :rtype: int
+    """
+    if re.match(r"[a-zA-Z]:", mount):
+        cmd = f"wmic logicaldisk where \"DeviceID='{mount}'\" "
+        cmd += "get FreeSpace"
+        output = session.cmd_output(cmd)
+        digits = re.findall(r"\d+", output)[0]
+        free = f"{digits}K"
+    else:
+        cmd = f"df -h {mount}"
+        output = session.cmd_output(cmd)
+        free = re.findall(r"\b([\d.]+[BKMGPETZ])\b", output, re.M | re.I)[2]
+    free = float(normalize_data_size(free, order_magnitude="M"))
+    return int(free)
+
+
+def check_free_disk(session, mount, required_mb):
+    """Check that a guest mount point has enough free space.
+
+    :param session: Guest shell session object.
+    :type session: aexpect.ShellSession
+    :param mount: Mount point or drive letter (e.g. "/var/tmp", "C:").
+    :type mount: str
+    :param required_mb: Minimum required free space in MB.
+    :type required_mb: int
+    :raises exceptions.TestError: When free space is below required_mb.
+    """
+    free_mb = get_free_disk(session, mount)
+    if free_mb < required_mb:
+        raise exceptions.TestError(
+            f"Not enough space on guest '{mount}': {free_mb}MB free, "
+            f"{required_mb}MB required"
+        )
diff --git a/virttest/utils_misc.py b/virttest/utils_misc.py
@@ -2343,26 +2343,7 @@ def __get_unit_index(M):
         return ("%.20f" % data_size).rstrip("0")
 
 
-def get_free_disk(session, mount):
-    """
-    Get FreeSpace for given mount point.
-
-    :param session: shell Object.
-    :param mount: mount point(eg. C:, /mnt)
-
-    :return string: freespace M-bytes
-    """
-    if re.match(r"[a-zA-Z]:", mount):
-        cmd = "wmic logicaldisk where \"DeviceID='%s'\" " % mount
-        cmd += "get FreeSpace"
-        output = session.cmd_output(cmd)
-        free = "%sK" % re.findall(r"\d+", output)[0]
-    else:
-        cmd = "df -h %s" % mount
-        output = session.cmd_output(cmd)
-        free = re.findall(r"\b([\d.]+[BKMGPETZ])\b", output, re.M | re.I)[2]
-    free = float(normalize_data_size(free, order_magnitude="M"))
-    return int(free)
+from virttest.utils_disk.free_space import get_free_disk  # noqa: F811,E402,F401
 
 
 def get_free_mem(session, os_type):
diff --git a/virttest/utils_test/__init__.py b/virttest/utils_test/__init__.py
@@ -750,250 +750,10 @@ def run_image_copy(test, params, env):
             run_virt_sub_test(test, params, env, params.get("sub_type"))
 
 
-@error_context.context_aware
-def run_file_transfer(test, params, env):
-    """
-    Transfer a file back and forth between host and guest.
-
-    1) Boot up a VM.
-    2) Create a large file by dd on host.
-    3) Copy this file from host to guest.
-    4) Copy this file from guest to host.
-    5) Check if file transfers ended good.
-
-    :param test: QEMU test object.
-    :param params: Dictionary with the test parameters.
-    :param env: Dictionary with test environment.
-    """
-    vm = env.get_vm(params["main_vm"])
-    vm.verify_alive()
-    login_timeout = int(params.get("login_timeout", 360))
-    session = vm.wait_for_login(timeout=login_timeout)
-    error_context.context("Login to guest", LOG.info)
-    transfer_timeout = int(params.get("transfer_timeout", 1000))
-    clean_cmd = params.get("clean_cmd", "rm -f")
-    filesize = int(params.get("filesize", 4000))
-    count = int(filesize / 10) or 1
-    host_path = tempfile.mktemp(prefix="tmp-", dir=data_dir.get_tmp_dir())
-    if params.get("os_type") != "windows":
-        tmp_dir = params.get("tmp_dir", "/var/tmp")
-        guest_path = tempfile.mktemp(prefix="transferred-", dir=tmp_dir)
-    else:
-        tmp_dir = params.get("tmp_dir", "c:\\")
-        guest_path = "\\".join([tmp_dir, utils_misc.generate_random_string(8)])
-        guest_path = "\\".join(filter(None, re.split(r"\\+", guest_path)))
-    cmd = "dd if=/dev/zero of=%s bs=10M count=%d" % (host_path, count)
-    try:
-        error_context.context("Creating %dMB file on host" % filesize, LOG.info)
-        process.run(cmd)
-        original_md5 = crypto.hash_file(host_path, algorithm="md5")
-        error_context.context(
-            "Transferring file host -> guest, " "timeout: %ss" % transfer_timeout,
-            LOG.info,
-        )
-        vm.copy_files_to(
-            host_path, guest_path, timeout=transfer_timeout, filesize=filesize
-        )
-
-        error_context.context(
-            "Transferring file guest -> host, " "timeout: %ss" % transfer_timeout,
-            LOG.info,
-        )
-        vm.copy_files_from(
-            guest_path, host_path, timeout=transfer_timeout, filesize=filesize
-        )
-        current_md5 = crypto.hash_file(host_path, algorithm="md5")
-
-        error_context.context(
-            "Compare md5sum between original file and " "transferred file", LOG.info
-        )
-        if original_md5 != current_md5:
-            raise exceptions.TestFail(
-                "File changed after transfer host -> guest " "and guest -> host"
-            )
-    finally:
-        try:
-            os.remove(host_path)
-        except OSError as detail:
-            LOG.warning("Could not remove temp files in host: '%s'", detail)
-        LOG.info("Cleaning temp file on guest")
-        try:
-            session.cmd("%s %s" % (clean_cmd, guest_path))
-        except aexpect.ShellError as detail:
-            LOG.warning("Could not remove temp files in guest: '%s'", detail)
-        finally:
-            session.close()
-
-
-@error_context.context_aware
-def run_virtio_serial_file_transfer(
-    test, params, env, port_name=None, sender="guest", md5_check=True
-):
-    """
-    Transfer file between host and guest through virtio serial.
-
-    :param test: QEMU test object.
-    :param params: Dictionary with the test parameters.
-    :param env: Dictionary with test environment.
-    :param port_name: VM's serial port name used to transfer data.
-    :param sender: Who is data sender. guest, host or both.
-    :param md5_check: Check md5 or not.
-    """
-
-    def get_virtio_port_host_file(vm, port_name):
-        """
-        Returns separated virtserialports
-        :param vm: VM object
-        :return: All virtserialports
-        """
-        for port in vm.virtio_ports:
-            if isinstance(port, qemu_virtio_port.VirtioSerial):
-                if port.name == port_name:
-                    return port.hostfile
-
-    def run_host_cmd(host_cmd, timeout=720):
-        return process.run(host_cmd, shell=True, timeout=timeout).stdout_text
-
-    def transfer_data(session, host_cmd, guest_cmd, n_time, timeout, md5_check, action):
-        for num in xrange(n_time):
-            md5_host = "1"
-            md5_guest = "2"
-            LOG.info("Data transfer repeat %s/%s." % (num + 1, n_time))
-            try:
-                args = (host_cmd, timeout)
-                host_thread = utils_misc.InterruptedThread(run_host_cmd, args)
-                host_thread.start()
-                g_output = session.cmd_output(guest_cmd, timeout=timeout)
-                if action == "both":
-                    if "Md5MissMatch" in g_output:
-                        err = "Data lost during file transfer. Md5 miss match."
-                        err += " Script output:\n%s" % g_output
-                        if md5_check:
-                            raise exceptions.TestFail(err)
-                        else:
-                            LOG.warning(err)
-                else:
-                    md5_re = "md5_sum = (\w{32})"
-                    try:
-                        md5_guest = re.findall(md5_re, g_output)[0]
-                    except Exception:
-                        err = "Fail to get md5, script may fail."
-                        err += " Script output:\n%s" % g_output
-                        raise exceptions.TestError(err)
-            finally:
-                if host_thread:
-                    output = ""
-                    output = host_thread.join(10)
-                    if action == "both":
-                        if "Md5MissMatch" in output:
-                            err = "Data lost during file transfer. Md5 miss "
-                            err += "match. Script output:\n%s" % output
-                            if md5_check:
-                                raise exceptions.TestFail(err)
-                            else:
-                                LOG.warning(err)
-                    else:
-                        md5_re = "md5_sum = (\w{32})"
-                        try:
-                            md5_host = re.findall(md5_re, output)[0]
-                        except Exception:
-                            err = "Fail to get md5, script may fail."
-                            err += " Script output:\n%s" % output
-                            raise exceptions.TestError(err)
-                if action != "both" and md5_host != md5_guest:
-                    err = "Data lost during file transfer. Md5 miss match."
-                    err += " Guest script output:\n %s" % g_output
-                    err += " Host script output:\n%s" % output
-                    if md5_check:
-                        raise exceptions.TestFail(err)
-                    else:
-                        LOG.warning(err)
-
-    env["serial_file_transfer_start"] = False
-    vm = env.get_vm(params["main_vm"])
-    vm.verify_alive()
-    timeout = int(params.get("login_timeout", 360))
-    session = vm.wait_for_login(timeout=timeout)
-
-    if not port_name:
-        port_name = params["file_transfer_serial_port"]
-    guest_scripts = params["guest_scripts"]
-    guest_path = params.get("guest_script_folder", "C:\\")
-    error_context.context("Copy test scripts to guest.", LOG.info)
-    for script in guest_scripts.split(";"):
-        link = os.path.join(data_dir.get_root_dir(), "shared", "deps", "serial", script)
-        vm.copy_files_to(link, guest_path, timeout=60)
-    host_device = get_virtio_port_host_file(vm, port_name)
-
-    dir_name = data_dir.get_tmp_dir()
-    transfer_timeout = int(params.get("transfer_timeout", 720))
-    tmp_dir = params.get("tmp_dir", "/var/tmp/")
-    filesize = int(params.get("filesize", 10))
-    count = int(filesize)
-
-    host_data_file = os.path.join(
-        dir_name, "tmp-%s" % utils_misc.generate_random_string(8)
-    )
-    guest_data_file = os.path.join(
-        tmp_dir, "tmp-%s" % utils_misc.generate_random_string(8)
-    )
-
-    if sender == "host" or sender == "both":
-        cmd = "dd if=/dev/zero of=%s bs=1M count=%d" % (host_data_file, count)
-        error_context.context("Creating %dMB file on host" % filesize, LOG.info)
-        process.run(cmd)
-    else:
-        guest_file_create_cmd = "dd if=/dev/zero of=%s bs=1M count=%d"
-        guest_file_create_cmd = params.get(
-            "guest_file_create_cmd", guest_file_create_cmd
-        )
-        cmd = guest_file_create_cmd % (guest_data_file, count)
-        error_context.context("Creating %dMB file on host" % filesize, LOG.info)
-        session.cmd(cmd, timeout=600)
-
-    if sender == "host":
-        action = "send"
-        guest_action = "receive"
-        txt = "Transfer data from host to guest"
-    elif sender == "guest":
-        action = "receive"
-        guest_action = "send"
-        txt = "Transfer data from guest to host"
-    else:
-        action = "both"
-        guest_action = "both"
-        txt = "Transfer data between guest and host"
-
-    host_script = params.get("host_script", "serial_host_send_receive.py")
-    host_script = os.path.join(
-        data_dir.get_root_dir(), "shared", "deps", "serial", host_script
-    )
-    host_cmd = "`command -v python python3 | head -1` %s -s %s -f %s -a %s" % (
-        host_script,
-        host_device,
-        host_data_file,
-        action,
-    )
-    guest_script = params.get("guest_script", "VirtIoChannel_guest_send_receive.py")
-    guest_script = os.path.join(guest_path, guest_script)
-
-    guest_cmd = "`command -v python python3 | head -1` %s -d %s -f %s -a %s" % (
-        guest_script,
-        port_name,
-        guest_data_file,
-        guest_action,
-    )
-    n_time = int(params.get("repeat_times", 1))
-    txt += " for %s times" % n_time
-    try:
-        env["serial_file_transfer_start"] = True
-        transfer_data(
-            session, host_cmd, guest_cmd, n_time, transfer_timeout, md5_check, action
-        )
-    finally:
-        env["serial_file_transfer_start"] = False
-    if session:
-        session.close()
+from virttest.utils_test.file_transfer import (  # noqa: F401
+    run_file_transfer,
+    run_virtio_serial_file_transfer,
+)
 
 
 def session_handler(func):
diff --git a/virttest/utils_test/file_transfer.py b/virttest/utils_test/file_transfer.py
