def make_env(self, storage_type, src_fmt, dst_fmt, chain_length=1, size=DEFAULT_SIZE, sd_version=3, src_qcow2_compat='0.10'): with fake_env(storage_type, sd_version=sd_version) as env: rm = FakeResourceManager() with MonkeyPatchScope([ (guarded, 'context', fake_guarded_context()), (storage.sdm.api.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) # 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) env.src_chain = src_vols env.dst_chain = dst_vols yield env
def get_vols(self, storage_type, src_fmt, dst_fmt, chain_length=1): with fake_env(storage_type) as env: rm = FakeResourceManager() with MonkeyPatchScope([ (storage.sdm.api.copy_data, 'sdCache', env.sdcache), (blockVolume, 'rmanager', rm), ]): src_vols = make_qemu_chain(env, self.SIZE, src_fmt, chain_length) dst_vols = make_qemu_chain(env, self.SIZE, dst_fmt, chain_length) yield (src_vols, dst_vols)
def get_vols(self, storage_type, src_fmt, dst_fmt, chain_length=1, size=DEFAULT_SIZE): with fake_env(storage_type) as env: rm = FakeResourceManager() with MonkeyPatchScope([ (guarded, 'context', fake_guarded_context()), (storage.sdm.api.copy_data, 'sdCache', env.sdcache), (blockVolume, 'rm', rm), ]): src_vols = make_qemu_chain(env, size, src_fmt, chain_length) dst_vols = make_qemu_chain(env, size, dst_fmt, chain_length) yield (src_vols, dst_vols)
def get_vol(self, storage_type): with fake_env(storage_type) as env: with MonkeyPatchScope([ (guarded, 'context', fake_guarded_context()), (storage.sdm.api.copy_data, 'sdCache', env.sdcache), ]): vols = make_qemu_chain(env, self.SIZE, sc.RAW_FORMAT, 1) yield vols[0]
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(ChainVerificationError, verify_qemu_chain, vol_list)
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_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_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_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_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, sd_type, chain_len=2): size = 1048576 base_fmt = sc.RAW_FORMAT with fake_env(sd_type) as env: rm = FakeResourceManager() with MonkeyPatchScope([ (guarded, 'context', fake_guarded_context()), (image, 'sdCache', env.sdcache), (merge, 'sdCache', env.sdcache), (blockVolume, 'rm', rm), (image, 'Image', FakeImage), ]): env.chain = make_qemu_chain(env, size, base_fmt, chain_len) def fake_chain(sdUUID, imgUUID, volUUID=None): return env.chain image.Image.getChain = fake_chain 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: rm = FakeResourceManager() with MonkeyPatchScope([ (guarded, 'context', fake_guarded_context()), (merge, 'sdCache', env.sdcache), (blockVolume, 'rm', rm), ]): 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="file", format="raw", chain_len=2, shared=False): size = 1048576 base_fmt = sc.name2type(format) with fake_env(sd_type) as env: rm = FakeResourceManager() with MonkeyPatchScope( [ (guarded, "context", fake_guarded_context()), (merge, "sdCache", env.sdcache), (blockVolume, "rm", rm), (volume.VolumeManifest, "isShared", lambda self: shared), ] ): 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: rm = FakeResourceManager() with MonkeyPatchScope( [ (guarded, "context", fake_guarded_context()), (merge, "sdCache", env.sdcache), (blockVolume, "rm", rm), (image, "Image", FakeImage), ] ): 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 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: rm = FakeResourceManager() with MonkeyPatchScope([ (guarded, 'context', fake_guarded_context()), (merge, 'sdCache', env.sdcache), (blockVolume, 'rm', rm), (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_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(ChainVerificationError, verify_qemu_chain, vol_list)