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)