storage: avoid removing the xva before going in the debugger

In case of exception, the cleanup code in try…finally was removing the
xva image before getting in the debugger, making impossible to look at
the xva content.

Signed-off-by: Gaëtan Lehmann <gaetan.lehmann@vates.tech>

Author: glehmann

tests/storage/ext/test_ext_sr.py

@@ -92,8 +92,8 @@ def test_coalesce(self, storage_test_vm: VM, vdi_on_ext_sr: VDI, vdi_op: Coalesc
 
     @pytest.mark.small_vm
     @pytest.mark.parametrize("compression", ["none", "gzip", "zstd"])
-    def test_xva_export_import(self, vm_on_ext_sr: VM, compression: XVACompression):
-        xva_export_import(vm_on_ext_sr, compression)
+    def test_xva_export_import(self, vm_on_ext_sr: VM, compression: XVACompression, request: pytest.FixtureRequest):
+        xva_export_import(vm_on_ext_sr, compression, request)
 
     @pytest.mark.small_vm
     def test_vdi_export_import(self, storage_test_vm: VM, ext_sr: SR, image_format: ImageFormat):

tests/storage/lvm/test_lvm_sr.py

@@ -145,8 +145,8 @@ def test_coalesce(self, storage_test_vm: VM, vdi_on_lvm_sr: VDI, vdi_op: Coalesc
 
     @pytest.mark.small_vm
     @pytest.mark.parametrize("compression", ["none", "gzip", "zstd"])
-    def test_xva_export_import(self, vm_on_lvm_sr: VM, compression: XVACompression):
-        xva_export_import(vm_on_lvm_sr, compression)
+    def test_xva_export_import(self, vm_on_lvm_sr: VM, compression: XVACompression, request: pytest.FixtureRequest):
+        xva_export_import(vm_on_lvm_sr, compression, request)
 
     @pytest.mark.small_vm
     def test_vdi_export_import(self, storage_test_vm: VM, lvm_sr: SR, image_format: ImageFormat):

tests/storage/lvmoiscsi/test_lvmoiscsi_sr.py

@@ -69,8 +69,10 @@ def test_coalesce(self, storage_test_vm: 'VM', vdi_on_lvmoiscsi_sr: 'VDI', vdi_o
 
     @pytest.mark.small_vm
     @pytest.mark.parametrize("compression", ["none", "gzip", "zstd"])
-    def test_xva_export_import(self, vm_on_lvmoiscsi_sr: VM, compression: XVACompression):
-        xva_export_import(vm_on_lvmoiscsi_sr, compression)
+    def test_xva_export_import(
+        self, vm_on_lvmoiscsi_sr: VM, compression: XVACompression, request: pytest.FixtureRequest
+    ):
+        xva_export_import(vm_on_lvmoiscsi_sr, compression, request)
 
     @pytest.mark.small_vm
     def test_vdi_export_import(self, storage_test_vm: VM, lvmoiscsi_sr: SR, image_format: ImageFormat):

tests/storage/nfs/test_nfs_sr.py

@@ -123,8 +123,8 @@ def test_coalesce(self, storage_test_vm: VM, dispatch_nfs: VDI, vdi_op: Coalesce
     @pytest.mark.usefixtures('vm_ref')
     @pytest.mark.parametrize('dispatch_nfs', ['vm_on_nfs_sr', 'vm_on_nfs4_sr'], indirect=True)
     @pytest.mark.parametrize("compression", ["none", "gzip", "zstd"])
-    def test_xva_export_import(self, dispatch_nfs: VM, compression: XVACompression):
-        xva_export_import(dispatch_nfs, compression)
+    def test_xva_export_import(self, dispatch_nfs: VM, compression: XVACompression, request: pytest.FixtureRequest):
+        xva_export_import(dispatch_nfs, compression, request)
 
     @pytest.mark.small_vm
     @pytest.mark.parametrize('dispatch_nfs', ['nfs_sr', 'nfs4_sr'], indirect=True)

tests/storage/storage.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import pytest
+
 import logging
 
 from lib.commands import SSHCommandFailed
@@ -201,32 +203,31 @@ def coalesce_integrity(vm: VM, vdi: VDI, vdi_op: CoalesceOperation):
 
 XVACompression = Literal['none', 'gzip', 'zstd']
 
-def xva_export_import(vm: VM, compression: XVACompression):
+def xva_export_import(vm: VM, compression: XVACompression, request: pytest.FixtureRequest):
     # The tests using this function are using specific fixtures to create the VM on the expected SR
     # In consequence, we can't use the storage_test_vm, so we have to start the VM explicitly and install randstream
     vm.start()
     vm.wait_for_vm_running_and_ssh_up()
     install_randstream(vm)
+
     # 500MiB, so we have some data to check and some empty spaces in the exported image
     vm.ssh("randstream generate -v --size 500MiB /root/data")
     vm.ssh("randstream validate -v --expected-checksum 24e905d6 /root/data")
     vm.shutdown(verify=True)
+
     xva_path = f'/tmp/{vm.uuid}.xva'
-    imported_vm = None
-    try:
-        vm.export(xva_path, compression)
-        # check that the zero blocks are not part of the result. Most of the data is from the random stream, so
-        # compression has little effect. We just check the result is between 500 and 700 MiB
-        size_mb = int(vm.host.ssh(f'du -sm --apparent-size {xva_path}').split()[0])
-        assert 500 < size_mb < 700, f"unexpected xva size: {size_mb}"
-        imported_vm = vm.host.import_vm(xva_path, vm.vdis[0].sr.uuid)
-        imported_vm.start()
-        imported_vm.wait_for_vm_running_and_ssh_up()
-        imported_vm.ssh("randstream validate -v --expected-checksum 24e905d6 /root/data")
-    finally:
-        if imported_vm is not None:
-            imported_vm.destroy()
-        vm.host.ssh(f'rm -f {xva_path}')
+    request.addfinalizer(lambda: vm.host.ssh(f'rm -f {xva_path}'))
+    vm.export(xva_path, compression)
+    # check that the zero blocks are not part of the result. Most of the data is from the random stream, so
+    # compression has little effect. We just check the result is between 500 and 700 MiB
+    size_mb = int(vm.host.ssh(f'du -sm --apparent-size {xva_path}').split()[0])
+    assert 500 < size_mb < 700, f"unexpected xva size: {size_mb}"
+
+    imported_vm = vm.host.import_vm(xva_path, vm.vdis[0].sr.uuid)
+    request.addfinalizer(lambda: imported_vm.destroy())
+    imported_vm.start()
+    imported_vm.wait_for_vm_running_and_ssh_up()
+    imported_vm.ssh("randstream validate -v --expected-checksum 24e905d6 /root/data")
 
 def vdi_export_import(vm: VM, sr: SR, image_format: ImageFormat):
     vdi = sr.create_vdi(image_format=image_format)

tests/storage/xfs/test_xfs_sr.py

@@ -109,8 +109,8 @@ def test_coalesce(self, storage_test_vm: VM, vdi_on_xfs_sr: VDI, vdi_op: Coalesc
 
     @pytest.mark.small_vm
     @pytest.mark.parametrize("compression", ["none", "gzip", "zstd"])
-    def test_xva_export_import(self, vm_on_xfs_sr: VM, compression: XVACompression):
-        xva_export_import(vm_on_xfs_sr, compression)
+    def test_xva_export_import(self, vm_on_xfs_sr: VM, compression: XVACompression, request: pytest.FixtureRequest):
+        xva_export_import(vm_on_xfs_sr, compression, request)
 
     @pytest.mark.small_vm
     def test_vdi_export_import(self, storage_test_vm: VM, xfs_sr: SR, image_format: ImageFormat):

tests/storage/zfs/test_zfs_sr.py

@@ -111,8 +111,8 @@ def test_coalesce(self, storage_test_vm: VM, vdi_on_zfs_sr: VDI, vdi_op: Coalesc
 
     @pytest.mark.small_vm
     @pytest.mark.parametrize("compression", ["none", "gzip", "zstd"])
-    def test_xva_export_import(self, vm_on_zfs_sr: VM, compression: XVACompression):
-        xva_export_import(vm_on_zfs_sr, compression)
+    def test_xva_export_import(self, vm_on_zfs_sr: VM, compression: XVACompression, request: pytest.FixtureRequest):
+        xva_export_import(vm_on_zfs_sr, compression, request)
 
     @pytest.mark.small_vm
     def test_vdi_export_import(self, storage_test_vm: VM, zfs_sr: SR, image_format: ImageFormat):

tests/storage/zfsvol/test_zfsvol_sr.py

@@ -68,8 +68,8 @@ def test_coalesce(self, storage_test_vm: VM, vdi_on_zfsvol_sr: VDI, vdi_op: Coal
 
     @pytest.mark.small_vm
     @pytest.mark.parametrize("compression", ["none", "gzip", "zstd"])
-    def test_xva_export_import(self, vm_on_zfsvol_sr: VM, compression: XVACompression):
-        xva_export_import(vm_on_zfsvol_sr, compression)
+    def test_xva_export_import(self, vm_on_zfsvol_sr: VM, compression: XVACompression, request: pytest.FixtureRequest):
+        xva_export_import(vm_on_zfsvol_sr, compression, request)
 
     @pytest.mark.small_vm
     def test_vdi_export_import(self, storage_test_vm: VM, zfsvol_sr: SR, image_format: ImageFormat):