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

@@ -5,7 +5,7 @@
 import logging
 
 from lib.commands import SSHCommandFailed
-from lib.common import vm_image, wait_for
+from lib.common import Defer, vm_image, wait_for
 from lib.fistpoint import FistPoint
 from lib.host import Host
 from lib.sr import SR
@@ -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, defer: Defer):
+        xva_export_import(vm_on_ext_sr, compression, defer)
 
     @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

@@ -5,7 +5,7 @@
 import logging
 
 from lib.commands import SSHCommandFailed
-from lib.common import vm_image, wait_for
+from lib.common import Defer, vm_image, wait_for
 from lib.fistpoint import FistPoint
 from lib.host import Host
 from lib.sr import SR
@@ -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, defer: Defer):
+        xva_export_import(vm_on_lvm_sr, compression, defer)
 
     @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

@@ -1,6 +1,6 @@
 import pytest
 
-from lib.common import vm_image, wait_for
+from lib.common import Defer, vm_image, wait_for
 from lib.sr import SR
 from lib.vdi import VDI
 from lib.vm import VM
@@ -69,8 +69,8 @@ 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, defer: Defer):
+        xva_export_import(vm_on_lvmoiscsi_sr, compression, defer)
 
     @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

@@ -3,7 +3,7 @@
 import pytest
 
 from lib.commands import SSHCommandFailed
-from lib.common import vm_image, wait_for
+from lib.common import Defer, vm_image, wait_for
 from lib.sr import SR
 from lib.vdi import VDI
 from lib.vm import VM
@@ -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, defer: Defer):
+        xva_export_import(dispatch_nfs, compression, defer)
 
     @pytest.mark.small_vm
     @pytest.mark.parametrize('dispatch_nfs', ['nfs_sr', 'nfs4_sr'], indirect=True)

tests/storage/storage.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
+import pytest
+
 import logging
 
 from lib.commands import SSHCommandFailed
-from lib.common import GiB, strtobool, wait_for, wait_for_not
+from lib.common import Defer, GiB, strtobool, wait_for, wait_for_not
 from lib.host import Host
 from lib.sr import SR
 from lib.vdi import VDI, ImageFormat
@@ -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, defer: Defer):
     # 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}')
+    defer(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)
+    defer(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

@@ -6,7 +6,7 @@
 import time
 
 from lib.commands import SSHCommandFailed
-from lib.common import vm_image, wait_for
+from lib.common import Defer, vm_image, wait_for
 from lib.host import Host
 from lib.sr import SR
 from lib.vdi import VDI
@@ -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, defer: Defer):
+        xva_export_import(vm_on_xfs_sr, compression, defer)
 
     @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

@@ -6,7 +6,7 @@
 import time
 
 from lib.commands import SSHCommandFailed
-from lib.common import vm_image, wait_for
+from lib.common import Defer, vm_image, wait_for
 from lib.sr import SR
 from lib.vdi import VDI
 from lib.vm import VM
@@ -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, defer: Defer):
+        xva_export_import(vm_on_zfs_sr, compression, defer)
 
     @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

@@ -4,7 +4,7 @@
 
 import logging
 
-from lib.common import vm_image, wait_for
+from lib.common import Defer, vm_image, wait_for
 from lib.sr import SR
 from lib.vdi import VDI
 from lib.vm import VM
@@ -69,8 +69,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, defer: Defer):
+        xva_export_import(vm_on_zfsvol_sr, compression, defer)
 
     @pytest.mark.small_vm
     def test_vdi_export_import(self, storage_test_vm: VM, zfsvol_sr: SR, image_format: ImageFormat):