def make_volume(self, size, storage_type='file', format=sc.RAW_FORMAT):
img_id = make_uuid()
vol_id = make_uuid()
with fake_env(storage_type) as env:
env.make_volume(size, img_id, vol_id, vol_format=format)
vol = env.sd_manifest.produceVolume(img_id, vol_id)
yield vol
def make_volume(self, size, storage_type='file', format=sc.RAW_FORMAT):
img_id = make_uuid()
vol_id = make_uuid()
with fake_env(storage_type) as env:
env.make_volume(size, img_id, vol_id, vol_format=format)
vol = env.sd_manifest.produceVolume(img_id, vol_id)
yield vol
def volume(self):
img_id = make_uuid()
vol_id = make_uuid()
with fake_env('file') as env:
env.make_volume(MB, img_id, vol_id)
vol = env.sd_manifest.produceVolume(img_id, vol_id)
yield vol
def volume(self):
img_id = make_uuid()
vol_id = make_uuid()
with fake_env('file') as env:
env.make_volume(MB, img_id, vol_id)
vol = env.sd_manifest.produceVolume(img_id, vol_id)
yield vol
def make_env(env_type, base, top):
img_id = make_uuid()
base_id = make_uuid()
top_id = make_uuid()
if env_type == "block" and base.format == "raw":
prealloc = sc.PREALLOCATED_VOL
else:
prealloc = sc.SPARSE_VOL
with fake_env(env_type) as env:
env.make_volume(base.virtual * GB, img_id, base_id, vol_format=sc.name2type(base.format), prealloc=prealloc)
env.make_volume(top.virtual * GB, img_id, top_id, parent_vol_id=base_id, vol_format=sc.COW_FORMAT)
env.subchain = merge.SubchainInfo(
dict(sd_id=env.sd_manifest.sdUUID, img_id=img_id, base_id=base_id, top_id=top_id), 0
)
if env_type == "block":
# Simulate allocation by adjusting the LV sizes
env.lvm.extendLV(env.sd_manifest.sdUUID, base_id, base.physical * GB / MB)
env.lvm.extendLV(env.sd_manifest.sdUUID, top_id, top.physical * GB / MB)
rm = FakeResourceManager()
with MonkeyPatchScope(
[
(guarded, "context", fake_guarded_context()),
(merge, "sdCache", env.sdcache),
(blockVolume, "rm", rm),
(blockVolume, "sdCache", env.sdcache),
(image.Image, "getChain", lambda self, sdUUID, imgUUID: [env.subchain.base_vol, env.subchain.top_vol]),
(blockVolume.BlockVolume, "extendSize", partial(fake_blockVolume_extendSize, env)),
(fileVolume.FileVolume, "extendSize", partial(fake_fileVolume_extendSize, env)),
]
):
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'):
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_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_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_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_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_get_info_generation_id(self, orig_gen, info_gen):
img_id = make_uuid()
vol_id = make_uuid()
with fake_env('file') as env:
env.make_volume(MB, img_id, vol_id)
vol = env.sd_manifest.produceVolume(img_id, vol_id)
vol.getLeaseStatus = lambda: 'unused'
if orig_gen is not None:
vol.setMetaParam(sc.GENERATION, orig_gen)
self.assertEqual(info_gen, vol.getInfo()['generation'])
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 test_generation_wrapping(self, first_gen, next_gen):
img_id = make_uuid()
vol_id = make_uuid()
with fake_env('file') as env:
env.make_volume(MB, img_id, vol_id)
vol = env.sd_manifest.produceVolume(img_id, vol_id)
vol.setMetaParam(sc.GENERATION, first_gen)
with vol.operation(first_gen):
pass
self.assertEqual(next_gen, vol.getMetaParam(sc.GENERATION))
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 test_operation_valid_generation(self):
img_id = make_uuid()
vol_id = make_uuid()
generation = 100
with fake_env('file') as env:
env.make_volume(MB, img_id, vol_id)
vol = env.sd_manifest.produceVolume(img_id, vol_id)
vol.setMetaParam(sc.GENERATION, 100)
with vol.operation(generation):
pass
self.assertEqual(generation + 1, vol.getMetaParam(sc.GENERATION))
def test_operation_fail_inside_context(self):
img_id = make_uuid()
vol_id = make_uuid()
with fake_env('file') as env:
env.make_volume(MB, img_id, vol_id)
vol = env.sd_manifest.produceVolume(img_id, vol_id)
self.assertEqual(sc.LEGAL_VOL, vol.getLegality())
with self.assertRaises(ValueError):
with vol.operation():
raise ValueError()
self.assertEqual(sc.ILLEGAL_VOL, vol.getLegality())
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 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):
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 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_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 test_operation(self):
img_id = make_uuid()
vol_id = make_uuid()
with fake_env('file') as env:
env.make_volume(MB, img_id, vol_id)
vol = env.sd_manifest.produceVolume(img_id, vol_id)
vol.setMetadata = CountedInstanceMethod(vol.setMetadata)
self.assertEqual(sc.LEGAL_VOL, vol.getLegality())
with vol.operation():
self.assertEqual(sc.ILLEGAL_VOL, vol.getLegality())
self.assertEqual(1, vol.setMetadata.nr_calls)
self.assertEqual(sc.LEGAL_VOL, vol.getLegality())
self.assertEqual(2, vol.setMetadata.nr_calls)
def test_operation_invalid_generation_raises(self, actual_generation,
requested_generation):
img_id = make_uuid()
vol_id = make_uuid()
with fake_env('file') as env:
env.make_volume(MB, img_id, vol_id)
vol = env.sd_manifest.produceVolume(img_id, vol_id)
vol.setMetaParam(sc.GENERATION, actual_generation)
with self.assertRaises(se.GenerationMismatch):
with vol.operation(requested_generation):
pass
self.assertEqual(actual_generation,
vol.getMetaParam(sc.GENERATION))
def make_env(env_type, base, top):
img_id = make_uuid()
base_id = make_uuid()
top_id = make_uuid()
if env_type == 'block' and base.format == 'raw':
prealloc = sc.PREALLOCATED_VOL
else:
prealloc = sc.SPARSE_VOL
with fake_env(env_type) as env:
env.make_volume(base.virtual * GB,
img_id,
base_id,
vol_format=sc.name2type(base.format),
prealloc=prealloc)
env.make_volume(top.virtual * GB,
img_id,
top_id,
parent_vol_id=base_id,
vol_format=sc.COW_FORMAT)
env.subchain = merge.SubchainInfo(
dict(sd_id=env.sd_manifest.sdUUID,
img_id=img_id,
base_id=base_id,
top_id=top_id), 0)
if env_type == 'block':
# Simulate allocation by adjusting the LV sizes
env.lvm.extendLV(env.sd_manifest.sdUUID, base_id,
base.physical * GB / MB)
env.lvm.extendLV(env.sd_manifest.sdUUID, top_id,
top.physical * GB / MB)
rm = FakeResourceManager()
with MonkeyPatchScope([
(guarded, 'context', fake_guarded_context()),
(merge, 'sdCache', env.sdcache),
(blockVolume, 'rm', rm),
(blockVolume, 'sdCache', env.sdcache),
(image.Image, 'getChain', lambda self, sdUUID, imgUUID:
[env.subchain.base_vol, env.subchain.top_vol]),
(blockVolume.BlockVolume, 'extendSize',
partial(fake_blockVolume_extendSize, env)),
(fileVolume.FileVolume, 'extendSize',
partial(fake_fileVolume_extendSize, env)),
]):
yield env
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 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, 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, 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 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),
(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='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="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 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_domain_version(self, env_type, sd_version):
with fake_env(env_type, sd_version=sd_version) as env:
self.assertEqual(sd_version, env.sd_manifest.getVersion())
def test_default_domain_version(self, env_type):
with fake_env(env_type) as env:
self.assertEqual(3, env.sd_manifest.getVersion())
def test_domain_version(self, env_type, sd_version):
with fake_env(env_type, sd_version=sd_version) as env:
self.assertEqual(sd_version, env.sd_manifest.getVersion())
def test_default_domain_version(self, env_type):
with fake_env(env_type) as env:
self.assertEqual(3, env.sd_manifest.getVersion())
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)
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)
