def test_acquire_contextmanager(self):
expected_calls = []
rm = FakeResourceManager()
acquire_args = ('ns', 'name', 'locktype')
with rm.acquireResource(*acquire_args):
expected_calls.append(('acquireResource', acquire_args, {}))
self.assertEqual(expected_calls, rm.__calls__)
expected_calls.append(('releaseResource', acquire_args, {}))
self.assertEqual(expected_calls, rm.__calls__)
def test_acquire_contextmanager(self):
expected_calls = []
rm = FakeResourceManager()
acquire_args = ('ns', 'name', 'locktype')
with rm.acquireResource(*acquire_args):
expected_calls.append(('acquireResource', acquire_args, {}))
self.assertEqual(expected_calls, rm.__calls__)
expected_calls.append(('releaseResource', acquire_args, {}))
self.assertEqual(expected_calls, rm.__calls__)
def make_env(self,
sd_type,
chain_len=2,
base_format=sc.RAW_FORMAT,
qcow2_compat='0.10'):
size = MiB
base_fmt = base_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,
qcow2_compat=qcow2_compat)
def fake_chain(sdUUID, imgUUID, volUUID=None):
return env.chain
image.Image.getChain = fake_chain
yield env
def make_env(self,
sd_type='block',
format='raw',
prealloc=sc.SPARSE_VOL,
chain_len=2):
size = 2 * GiB
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,
prealloc=prealloc)
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,
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
class TestResourceManagerLock(VdsmTestCase):
def test_properties(self):
a = rm.ResourceManagerLock('ns', 'name', 'mode')
self.assertEqual('ns', a.ns)
self.assertEqual('name', a.name)
self.assertEqual('mode', a.mode)
@permutations((
(('nsA', 'nameA', 'mode'), ('nsB', 'nameA', 'mode')),
(('nsA', 'nameA', 'mode'), ('nsA', 'nameB', 'mode')),
))
def test_less_than(self, a, b):
b = rm.ResourceManagerLock(*b)
a = rm.ResourceManagerLock(*a)
self.assertLess(a, b)
def test_equality(self):
a = rm.ResourceManagerLock('ns', 'name', 'mode')
b = rm.ResourceManagerLock('ns', 'name', 'mode')
self.assertEqual(a, b)
def test_mode_used_for_equality(self):
a = rm.ResourceManagerLock('nsA', 'nameA', 'modeA')
b = rm.ResourceManagerLock('nsA', 'nameA', 'modeB')
self.assertNotEqual(a, b)
def test_mode_ignored_for_sorting(self):
a = rm.ResourceManagerLock('nsA', 'nameA', 'modeA')
b = rm.ResourceManagerLock('nsA', 'nameA', 'modeB')
self.assertFalse(a < b)
self.assertFalse(b < a)
@MonkeyPatch(rm, "_manager", FakeResourceManager())
def test_acquire_release(self):
lock = rm.ResourceManagerLock('ns_A', 'name_A', rm.SHARED)
expected = []
lock.acquire()
expected.append(('acquireResource',
(lock.ns, lock.name, lock.mode),
{"timeout": None}))
self.assertEqual(expected, rm._manager.__calls__)
lock.release()
expected.append(('releaseResource', (lock.ns, lock.name), {}))
self.assertEqual(expected, rm._manager.__calls__)
def test_repr(self):
mode = rm.SHARED
lock = rm.ResourceManagerLock('ns', 'name', mode)
lock_string = str(lock)
self.assertIn("ResourceManagerLock", lock_string)
self.assertIn("ns=ns", lock_string)
self.assertIn("name=name", lock_string)
self.assertIn("mode=" + mode, lock_string)
self.assertIn("%x" % id(lock), lock_string)
class TestResourceManagerLock:
def test_properties(self):
a = rm.ResourceManagerLock('ns', 'name', 'mode')
assert a.ns == 'ns'
assert a.name == 'name'
assert a.mode == 'mode'
@pytest.mark.parametrize('a, b', [
(('nsA', 'nameA', 'mode'), ('nsB', 'nameA', 'mode')),
(('nsA', 'nameA', 'mode'), ('nsA', 'nameB', 'mode')),
])
def test_less_than(self, a, b):
b = rm.ResourceManagerLock(*b)
a = rm.ResourceManagerLock(*a)
assert a < b
def test_equality(self):
a = rm.ResourceManagerLock('ns', 'name', 'mode')
b = rm.ResourceManagerLock('ns', 'name', 'mode')
assert a == b
def test_mode_used_for_equality(self):
a = rm.ResourceManagerLock('nsA', 'nameA', 'modeA')
b = rm.ResourceManagerLock('nsA', 'nameA', 'modeB')
assert a != b
def test_mode_ignored_for_sorting(self):
a = rm.ResourceManagerLock('nsA', 'nameA', 'modeA')
b = rm.ResourceManagerLock('nsA', 'nameA', 'modeB')
assert not a < b
assert not b < a
@MonkeyPatch(rm, "_manager", FakeResourceManager())
def test_acquire_release(self):
lock = rm.ResourceManagerLock('ns_A', 'name_A', rm.SHARED)
expected = []
lock.acquire()
expected.append(('acquireResource', (lock.ns, lock.name, lock.mode), {
"timeout": None
}))
assert expected == rm._manager.__calls__
lock.release()
expected.append(('releaseResource', (lock.ns, lock.name), {}))
assert expected == rm._manager.__calls__
def test_repr(self):
mode = rm.SHARED
lock = rm.ResourceManagerLock('ns', 'name', mode)
lock_string = str(lock)
assert "ResourceManagerLock" in lock_string
assert "ns=ns" in lock_string
assert "name=name" in lock_string
assert "mode=" + mode in lock_string
assert "%x" % id(lock) in lock_string
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 test_acquire_release(self, monkeypatch):
monkeypatch.setattr(rm, "_manager", FakeResourceManager())
lock = rm.ResourceManagerLock('ns_A', 'name_A', rm.SHARED)
expected = []
lock.acquire()
expected.append(('acquireResource', (lock.ns, lock.name, lock.mode), {
"timeout": None
}))
assert expected == rm._manager.__calls__
lock.release()
expected.append(('releaseResource', (lock.ns, lock.name), {}))
assert expected == rm._manager.__calls__
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:
with MonkeyPatch().context() as mp:
mp.setattr(guarded, 'context', fake_guarded_context())
mp.setattr(merge, 'sdCache', env.sdcache)
mp.setattr(blockVolume, "config", CONFIG)
mp.setattr(blockVolume, 'rm', FakeResourceManager())
mp.setattr(blockVolume, 'sdCache', env.sdcache)
mp.setattr(
image.Image, 'getChain', lambda self, sdUUID, imgUUID:
[env.subchain.base_vol, env.subchain.top_vol])
env.make_volume(base.virtual * GiB,
img_id,
base_id,
vol_format=sc.name2type(base.format),
prealloc=prealloc,
vol_type=sc.INTERNAL_VOL)
env.make_volume(
top.virtual * GiB,
img_id,
top_id,
parent_vol_id=base_id,
vol_format=sc.COW_FORMAT,
vol_type=sc.LEAF_VOL if top.leaf else sc.INTERNAL_VOL)
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 * GiB // MiB)
env.lvm.extendLV(env.sd_manifest.sdUUID, top_id,
top.physical * GiB // MiB)
yield env
def test_with_release_error(self, monkeypatch):
monkeypatch.setattr(rm, "_manager", FakeResourceManager())
lock = rm.Lock('ns_A', 'name_A', rm.SHARED)
class ReleaseError(Exception):
pass
def releaseResource(ns, name):
raise ReleaseError
rm._manager.releaseResource = releaseResource
with pytest.raises(ReleaseError):
with lock:
pass
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 test_with(self, monkeypatch):
monkeypatch.setattr(rm, "_manager", FakeResourceManager())
lock = rm.Lock('ns_A', 'name_A', rm.SHARED)
with lock:
# Resource should be aquired here.
assert rm._manager.__calls__ == [
('acquireResource', (lock.ns, lock.name, lock.mode), {
"timeout": None
})
]
rm._manager.__calls__.clear()
# Resource should be released here.
assert rm._manager.__calls__ == [('releaseResource', (lock.ns,
lock.name), {})]
def test_with_user_error(self, monkeypatch):
monkeypatch.setattr(rm, "_manager", FakeResourceManager())
lock = rm.Lock('ns_A', 'name_A', rm.SHARED)
class UserError(Exception):
pass
with pytest.raises(UserError):
with lock:
raise UserError
assert rm._manager.__calls__ == [
('acquireResource', (lock.ns, lock.name, lock.mode), {
"timeout": None
}), ('releaseResource', (lock.ns, lock.name), {})
]
def make_env(self, sd_type='file', format='raw', chain_len=2,
shared=False):
size = MiB
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='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(storage_type,
fmt,
chain_length=1,
size=DEFAULT_SIZE,
sd_version=5,
qcow2_compat='1.1'):
with fake_env(storage_type, sd_version=sd_version) as env:
rm = FakeResourceManager()
with MonkeyPatchScope([
(guarded, 'context', fake_guarded_context()),
(volume_info, '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='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 _fake_env(self):
self.rm = FakeResourceManager()
with MonkeyPatchScope([(create_volume, 'rm', self.rm)]):
yield
