def test_vg_invalidate_lvs(tmp_storage):
dev_size = 1 * GiB
dev = tmp_storage.create_device(dev_size)
vg_name = str(uuid.uuid4())
lvm.set_read_only(False)
lvm.createVG(vg_name, [dev], "initial-tag", 128)
lvm.createLV(vg_name, "lv1", 128, activate=False)
# Reload cache.
pv = lvm.getPV(dev)
vg = lvm.getVG(vg_name)
lv = lvm.getLV(vg_name)[0]
assert lvm._lvminfo._pvs == {dev: pv}
assert lvm._lvminfo._vgs == {vg_name: vg}
assert lvm._lvminfo._lvs == {(vg_name, "lv1"): lv}
# Invalidate VG including LVs.
lvm.invalidateVG(vg_name)
assert lvm._lvminfo._pvs == {dev: pv}
assert lvm._lvminfo._vgs == {vg_name: lvm.Stale(vg_name)}
assert lvm._lvminfo._lvs == {(vg_name, "lv1"): lvm.Stale("lv1")}
def test_lv_reload_error_all_stale_other_vgs(fake_devices, no_delay):
fake_runner = FakeRunner(rc=5, err=b"Fake lvm error")
lc = lvm.LVMCache(fake_runner)
lc._lvs = {
("vg-name", "lv-name"): lvm.Stale("lv-name"),
("other-vg", "other-lv"): lvm.Stale("other-lv"),
}
lc.getLv("vg-name")
# Should not affect other vg lvs.
other_lv = lc._lvs[("other-vg", "other-lv")]
assert not isinstance(other_lv, lvm.Unreadable)
def test_lv_reload_error_one_stale(fake_devices, no_delay):
fake_runner = FakeRunner(rc=5, err=b"Fake lvm error")
lc = lvm.LVMCache(fake_runner)
lc._lvs = {
("vg-name", "lv-name"): lvm.Stale("lv-name"),
("vg-name", "other-lv"): lvm.Stale("other-lv"),
}
lv = lc.getLv("vg-name", "lv-name")
# Mark lv as unreadable. Because we always reload all lvs, the other lvs is
# also marked as unreadable.
assert lc._lvs == {
("vg-name", "lv-name"): lvm.Unreadable("lv-name"),
("vg-name", "other-lv"): lvm.Unreadable("other-lv"),
}
# Report the unreadbale lv.
assert lv.name == "lv-name"
assert isinstance(lv, lvm.Unreadable)
def test_lv_reload_error_all_other_vg(fake_devices, no_delay):
fake_runner = FakeRunner(rc=5, err=b"Fake lvm error")
lc = lvm.LVMCache(fake_runner)
lc._lvs = {("vg-name", "lv-name"): lvm.Stale("lv-name")}
lvs = lc.getLv("vg-name")
# Mark lv as unreadable.
assert lc._lvs == {("vg-name", "lv-name"): lvm.Unreadable("lv-name")}
# Currnetly we don't report stales or unreadables lvs. This is not
# consistent with getLv(vg_name, lv_name).
assert lvs == []
def test_vg_invalidate(tmp_storage):
dev_size = 1 * GiB
dev1 = tmp_storage.create_device(dev_size)
dev2 = tmp_storage.create_device(dev_size)
vg1_name = str(uuid.uuid4())
vg2_name = str(uuid.uuid4())
lvm.set_read_only(False)
lvm.createVG(vg1_name, [dev1], "initial-tag", 128)
lvm.createLV(vg1_name, "lv1", 128, activate=False)
lvm.createVG(vg2_name, [dev2], "initial-tag", 128)
lvm.createLV(vg2_name, "lv2", 128, activate=False)
# Reload cache.
pv1 = lvm.getPV(dev1)
vg1 = lvm.getVG(vg1_name)
lv1 = lvm.getLV(vg1_name)[0]
pv2 = lvm.getPV(dev2)
vg2 = lvm.getVG(vg2_name)
lv2 = lvm.getLV(vg2_name)[0]
assert lvm._lvminfo._pvs == {dev1: pv1, dev2: pv2}
assert lvm._lvminfo._vgs == {vg1_name: vg1, vg2_name: vg2}
assert lvm._lvminfo._lvs == {
(vg1_name, "lv1"): lv1,
(vg2_name, "lv2"): lv2,
}
# Invalidate VG including LVs.
lvm.invalidateVG(vg1_name, invalidateLVs=False)
assert lvm._lvminfo._pvs == {dev1: pv1, dev2: pv2}
assert lvm._lvminfo._vgs == {
vg1_name: lvm.Stale(vg1_name),
vg2_name: vg2,
}
assert lvm._lvminfo._lvs == {
(vg1_name, "lv1"): lv1,
(vg2_name, "lv2"): lv2,
}
# getVGs() always reloads the cache.
clear_stats()
lvm.getVGs([vg1_name, vg2_name])
check_stats(hits=0, misses=1)
assert lvm._lvminfo._vgs == {vg1_name: vg1, vg2_name: vg2}
def test_vg_invalidate_lvs_pvs(tmp_storage):
dev_size = 1 * GiB
dev = tmp_storage.create_device(dev_size)
vg_name = str(uuid.uuid4())
lvm.set_read_only(False)
lvm.createVG(vg_name, [dev], "initial-tag", 128)
lvm.createLV(vg_name, "lv1", 128, activate=False)
# Reload cache.
pv = lvm.getPV(dev)
vg = lvm.getVG(vg_name)
lv = lvm.getLV(vg_name)[0]
assert lvm._lvminfo._pvs == {dev: pv}
clear_stats()
lvm._lvminfo.getPvs(vg_name)
# getPVs() first finds the VG using getVG(), so there is a cache hit.
# No stale PVs for the VG so getPVs() will have another cache hit.
check_stats(hits=2, misses=0)
assert lvm._lvminfo._vgs == {vg_name: vg}
assert lvm._lvminfo._lvs == {(vg_name, "lv1"): lv}
# Invalidate VG including LVs and PVs.
lvm.invalidateVG(vg_name, invalidatePVs=True)
assert lvm._lvminfo._vgs == {vg_name: lvm.Stale(vg_name)}
assert lvm._lvminfo._pvs == {dev: lvm.Stale(dev)}
clear_stats()
lvm._lvminfo.getPvs(vg_name)
# getPVs() will not find the invalidated VG in cache, so there is a miss.
# There are stale PVs for the VG so getPVs() will have another cache miss.
check_stats(hits=0, misses=2)
assert lvm._lvminfo._lvs == {(vg_name, "lv1"): lvm.Stale("lv1")}
def test_vg_invalidate_lvs(tmp_storage):
dev_size = 1 * GiB
dev = tmp_storage.create_device(dev_size)
vg_name = str(uuid.uuid4())
lvm.set_read_only(False)
lvm.createVG(vg_name, [dev], "initial-tag", 128)
lvm.createLV(vg_name, "lv1", 128, activate=False)
# Reload cache.
pv = lvm.getPV(dev)
vg = lvm.getVG(vg_name)
clear_stats()
lv = lvm.getLV(vg_name)[0]
check_stats(hits=0, misses=1)
# Accessing LVs always access storage.
# TODO: Use cache if VG did not change.
lvm.getLV(vg_name)
check_stats(hits=0, misses=2)
assert lvm._lvminfo._pvs == {dev: pv}
assert lvm._lvminfo._vgs == {vg_name: vg}
assert lvm._lvminfo._lvs == {(vg_name, "lv1"): lv}
# Invalidate VG including LVs.
lvm.invalidateVG(vg_name)
assert lvm._lvminfo._pvs == {dev: pv}
assert lvm._lvminfo._vgs == {vg_name: lvm.Stale(vg_name)}
assert lvm._lvminfo._lvs == {(vg_name, "lv1"): lvm.Stale("lv1")}
# Accessing LVs always access storage.
# TODO: Use cache if VG did not change.
clear_stats()
lvm.getLV(vg_name)
check_stats(hits=0, misses=1)
def test_lv_reload_fresh_vg(fake_devices, no_delay):
fake_runner = FakeRunner()
lc = lvm.LVMCache(fake_runner, cache_lvs=True)
lv1 = make_lv("lv1", "vg1")
# vg1's lvs are fresh, vg2's lvs were invalidated.
lc._freshlv = {"vg1", "vg2"}
lc._lvs = {
("vg1", "lv1"): lv1,
("vg2", "lv2"): lvm.Stale("lv2"),
}
assert not lc._lvs_needs_reload("vg1")
assert lc._lvs_needs_reload("vg2")
# getLv for vg1 should use cache without reload lvs.
assert lc.getLv("vg1") == [lv1]
assert not lc._lvs_needs_reload("vg1")
assert lc._lvs_needs_reload("vg2")
# getLv for vg2 should reload lvs.
assert lc.getLv("vg2") == []
assert not lc._lvs_needs_reload("vg1")
assert not lc._lvs_needs_reload("vg2")
