def test_make_qemu_chain(self, storage_type): with fake_env(storage_type) as env: vol_list = make_qemu_chain(env, 0, sc.RAW_FORMAT, 2) self.assertTrue(vol_list[0].isInternal(), "Internal volume has wrong type: %s" % vol_list[0].getVolType()) self.assertTrue(vol_list[1].isLeaf(), "Leaf volume has wrong type: %s" % vol_list[1].getVolType())
def test_get_children(self): remote_path = "[2001:db8:85a3::8a2e:370:7334]:1234:/path" size = 5 * MEGAB # Simulate a domain with an ipv6 address with fake_env(storage_type='file', remote_path=remote_path) as env: env.chain = make_qemu_chain(env, size, sc.name2type('raw'), 2) base_vol = env.chain[0] assert (env.chain[1].volUUID,) == base_vol.getChildren()
def test_pattern_written_to_base_raises(self, storage_type): with fake_env(storage_type) as env: vol_list = make_qemu_chain(env, MB, sc.RAW_FORMAT, 3) # Writes the entire pattern into the base volume bad_list = vol_list[:1] * 3 write_qemu_chain(bad_list) self.assertRaises(qemuio.VerificationError, verify_qemu_chain, vol_list)
def test_missing_backing_file(self): with fake_file_env() as env: vol = make_qemu_chain(env, self.SIZE, sc.COW_FORMAT, 2)[1] # Simulate upload of image without backing file to a a snapshot op = qemuimg.create(vol.volumePath, size=self.SIZE, format=qemuimg.FORMAT.QCOW2) op.run() h = FakeHSM() with pytest.raises(se.ImageVerificationError): h.verify_untrusted_volume( 'sp', vol.sdUUID, vol.imgUUID, vol.volUUID)
def test_optimal_size_cow_internal(self, actual_size, optimal_size): def fake_check(path, format): return {'offset': actual_size} with fake_env('block') as env: # In order to test edge cases, mainly of volumes with big data, we # fake qemuimg check to return big volumes size, instead of writing # big data to volumes, an operation that takes long time. with MonkeyPatchScope([(qemuimg, 'check', fake_check)]): env.chain = make_qemu_chain(env, actual_size, sc.COW_FORMAT, 3) self.assertEqual(env.chain[1].optimal_size(), optimal_size)
def make_volume(self, size, storage_type='block', format=sc.RAW_FORMAT): img_id = make_uuid() vol_id = make_uuid() # TODO fix make_volume helper to create the qcow image when needed with fake_env(storage_type) as env: if format == sc.RAW_FORMAT: env.make_volume(size, img_id, vol_id, vol_format=format) vol = env.sd_manifest.produceVolume(img_id, vol_id) yield vol else: chain = make_qemu_chain(env, size, format, 1) yield chain[0]
def make_env(self, storage_type, fmt=sc.name2type('cow'), chain_length=1, size=DEFAULT_SIZE, qcow2_compat='0.10'): with fake_env(storage_type, sd_version=4) as env: rm = FakeResourceManager() with MonkeyPatchScope([ (guarded, 'context', fake_guarded_context()), (copy_data, 'sdCache', env.sdcache), (blockVolume, 'rm', rm), ]): env.chain = make_qemu_chain(env, size, fmt, chain_length, qcow2_compat=qcow2_compat) yield env
def make_env(self, storage_type, src_fmt, dst_fmt, chain_length=1, size=DEFAULT_SIZE, sd_version=3, src_qcow2_compat='0.10', prealloc=sc.SPARSE_VOL): with fake_env(storage_type, sd_version=sd_version) as env: rm = FakeResourceManager() with MonkeyPatchScope([ (guarded, 'context', fake_guarded_context()), (copy_data, 'sdCache', env.sdcache), (blockVolume, 'rm', rm), ]): # Create existing volume - may use compat 0.10 or 1.1. src_vols = make_qemu_chain(env, size, src_fmt, chain_length, qcow2_compat=src_qcow2_compat, prealloc=prealloc) # New volumes are always created using the domain # prefered format. sd_compat = env.sd_manifest.qcow2_compat() dst_vols = make_qemu_chain(env, size, dst_fmt, chain_length, qcow2_compat=sd_compat, prealloc=prealloc) env.src_chain = src_vols env.dst_chain = dst_vols yield env
def make_env(self, sd_type='file', format='raw', chain_len=2, shared=False): size = 1048576 base_fmt = sc.name2type(format) with fake_env(sd_type) as env: with MonkeyPatch().context() as mp: mp.setattr(guarded, 'context', fake_guarded_context()) mp.setattr(merge, 'sdCache', env.sdcache) mp.setattr(blockVolume, 'rm', FakeResourceManager()) env.chain = make_qemu_chain(env, size, base_fmt, chain_len) def fake_chain(self, sdUUID, imgUUID, volUUID=None): return env.chain image.Image.getChain = fake_chain yield env
def make_env(self, sd_type='block', format='raw', chain_len=2): size = 1048576 base_fmt = sc.name2type(format) with fake_env(sd_type) as env: with MonkeyPatch().context() as mp: mp.setattr(guarded, 'context', fake_guarded_context()) mp.setattr(merge, 'sdCache', env.sdcache) mp.setattr(blockVolume, 'rm', FakeResourceManager()) mp.setattr(image, 'Image', FakeImage) env.chain = make_qemu_chain(env, size, base_fmt, chain_len) volumes = {(vol.imgUUID, vol.volUUID): FakeVolume() for vol in env.chain} env.sdcache.domains[env.sd_manifest.sdUUID].volumes = volumes def fake_chain(self, sdUUID, imgUUID, volUUID=None): return env.chain image.Image.getChain = fake_chain image.Image.syncVolumeChain = FakeSyncVolumeChain() yield env
def make_env(self, sd_type='block', format='raw', chain_len=2): size = 1048576 base_fmt = sc.name2type(format) with fake_env(sd_type) as env: with MonkeyPatch().context() as mp: mp.setattr(guarded, 'context', fake_guarded_context()) mp.setattr(merge, 'sdCache', env.sdcache) mp.setattr(blockVolume, 'rm', FakeResourceManager()) mp.setattr(image, 'Image', FakeImage) env.chain = make_qemu_chain(env, size, base_fmt, chain_len) volumes = {(vol.imgUUID, vol.volUUID): FakeVolume() for vol in env.chain} env.sdcache.domains[env.sd_manifest.sdUUID].volumes = volumes def fake_chain(self, sdUUID, imgUUID, volUUID=None): return env.chain image.Image.getChain = fake_chain image.Image.syncVolumeChain = FakeSyncVolumeChain() yield env
def test_valid_without_backingfile(self): with fake_file_env() as env: vol = make_qemu_chain(env, self.SIZE, sc.COW_FORMAT, 2)[0] h = FakeHSM() self.assertNotRaises(h.verify_untrusted_volume, 'sp', vol.sdUUID, vol.imgUUID, vol.volUUID)
def test_valid_with_backingfile(self): with fake_file_env() as env: vol = make_qemu_chain(env, self.SIZE, sc.COW_FORMAT, 2)[1] h = FakeHSM() h.verify_untrusted_volume( 'sp', vol.sdUUID, vol.imgUUID, vol.volUUID)
def test_valid_without_backingfile(self): with fake_file_env() as env: vol = make_qemu_chain(env, self.SIZE, sc.COW_FORMAT, 2)[0] h = FakeHSM() h.verify_untrusted_volume( 'sp', vol.sdUUID, vol.imgUUID, vol.volUUID)
def test_reversed_chain_raises(storage_type): with fake_env(storage_type) as env: vol_list = make_qemu_chain(env, MiB, sc.RAW_FORMAT, 2) write_qemu_chain(reversed(vol_list)) with pytest.raises(qemuio.VerificationError): verify_qemu_chain(vol_list)
def test_verify_chain(storage_type): with fake_env(storage_type) as env: vol_list = make_qemu_chain(env, MiB, sc.RAW_FORMAT, 2) write_qemu_chain(vol_list) verify_qemu_chain(vol_list)
def test_reversed_chain_raises(self, storage_type): with fake_env(storage_type) as env: vol_list = make_qemu_chain(env, MB, sc.RAW_FORMAT, 2) write_qemu_chain(reversed(vol_list)) self.assertRaises(qemuio.VerificationError, verify_qemu_chain, vol_list)
def test_verify_chain(self, storage_type): with fake_env(storage_type) as env: vol_list = make_qemu_chain(env, MB, sc.RAW_FORMAT, 2) write_qemu_chain(vol_list) verify_qemu_chain(vol_list)
def test_reversed_chain_raises(self, storage_type): with fake_env(storage_type) as env: vol_list = make_qemu_chain(env, MB, sc.RAW_FORMAT, 2) write_qemu_chain(reversed(vol_list)) self.assertRaises(qemuio.VerificationError, verify_qemu_chain, vol_list)