def test_lvmthin_snap_shot_device_init(self):
pv = StorageDevice("pv1", fmt=blivet.formats.get_format("lvmpv"),
size=Size("1 GiB"))
vg = LVMVolumeGroupDevice("testvg", parents=[pv])
pool = LVMLogicalVolumeDevice("pool1", parents=[vg], size=Size("500 MiB"), seg_type="thin-pool")
thinlv = LVMLogicalVolumeDevice("thinlv", parents=[pool], size=Size("200 MiB"), seg_type="thin")
with self.assertRaisesRegex(ValueError, "lvm snapshot origin volume must already exist"):
LVMLogicalVolumeDevice("snap1", parents=[pool], origin=thinlv, seg_type="thin")
with self.assertRaisesRegex(ValueError, "lvm snapshot origin must be a logical volume"):
LVMLogicalVolumeDevice("snap1", parents=[pool], origin=pv, seg_type="thin")
# now make the constructor succeed so we can test some properties
thinlv.exists = True
snap1 = LVMLogicalVolumeDevice("snap1", parents=[pool], origin=thinlv, seg_type="thin")
self.assertEqual(snap1.isleaf, True)
self.assertEqual(snap1.direct, True)
self.assertEqual(thinlv.isleaf, True)
self.assertEqual(thinlv.direct, True)
self.assertEqual(snap1.depends_on(thinlv), True)
self.assertEqual(thinlv.depends_on(snap1), False)
# existing thin snapshots do not depend on their origin
snap1.exists = True
self.assertEqual(snap1.depends_on(thinlv), False)
def test_lvmsnap_shot_device_init(self):
pv = StorageDevice("pv1",
fmt=blivet.formats.get_format("lvmpv"),
size=Size("1 GiB"))
vg = LVMVolumeGroupDevice("testvg", parents=[pv])
lv = LVMLogicalVolumeDevice("testlv",
parents=[vg],
fmt=blivet.formats.get_format("xfs"))
with self.assertRaisesRegex(
ValueError, "lvm snapshot origin volume must already exist"):
LVMLogicalVolumeDevice("snap1", parents=[vg], origin=lv)
with self.assertRaisesRegex(
ValueError, "lvm snapshot origin must be a logical volume"):
LVMLogicalVolumeDevice("snap1", parents=[vg], origin=pv)
with self.assertRaisesRegex(
ValueError, "only existing vorigin snapshots are supported"):
LVMLogicalVolumeDevice("snap1", parents=[vg], vorigin=True)
lv.exists = True
snap1 = LVMLogicalVolumeDevice("snap1", parents=[vg], origin=lv)
self.assertEqual(snap1.format.type, lv.format.type)
lv.format = blivet.formats.get_format("DM_snapshot_cow", exists=True)
self.assertEqual(snap1.format.type, lv.format.type)
self.assertEqual(snap1.isleaf, True)
self.assertEqual(snap1.direct, True)
self.assertEqual(lv.isleaf, False)
self.assertEqual(lv.direct, True)
self.assertEqual(snap1.depends_on(lv), True)
self.assertEqual(lv.depends_on(snap1), False)
def test_lvmsnap_shot_device_init(self):
pv = StorageDevice("pv1", fmt=blivet.formats.get_format("lvmpv"),
size=Size("1 GiB"))
vg = LVMVolumeGroupDevice("testvg", parents=[pv])
lv = LVMLogicalVolumeDevice("testlv", parents=[vg],
fmt=blivet.formats.get_format("xfs"))
with self.assertRaisesRegex(ValueError, "lvm snapshot origin must be a logical volume"):
LVMLogicalVolumeDevice("snap1", parents=[vg], origin=pv)
with self.assertRaisesRegex(ValueError, "only existing vorigin snapshots are supported"):
LVMLogicalVolumeDevice("snap1", parents=[vg], vorigin=True)
lv.exists = True
snap1 = LVMLogicalVolumeDevice("snap1", parents=[vg], origin=lv)
self.assertEqual(snap1.format.type, lv.format.type)
lv.format = blivet.formats.get_format("DM_snapshot_cow", exists=True)
self.assertEqual(snap1.format.type, lv.format.type)
self.assertEqual(snap1.isleaf, True)
self.assertEqual(snap1.direct, True)
self.assertEqual(lv.isleaf, False)
self.assertEqual(lv.direct, True)
self.assertEqual(snap1.depends_on(lv), True)
self.assertEqual(lv.depends_on(snap1), False)
def test_lvmthin_snap_shot_device_init(self):
pv = StorageDevice("pv1",
fmt=blivet.formats.get_format("lvmpv"),
size=Size("1 GiB"))
vg = LVMVolumeGroupDevice("testvg", parents=[pv])
pool = LVMLogicalVolumeDevice("pool1",
parents=[vg],
size=Size("500 MiB"),
seg_type="thin-pool")
thinlv = LVMLogicalVolumeDevice("thinlv",
parents=[pool],
size=Size("200 MiB"),
seg_type="thin")
with self.assertRaisesRegex(
ValueError, "lvm snapshot origin volume must already exist"):
LVMLogicalVolumeDevice("snap1",
parents=[pool],
origin=thinlv,
seg_type="thin")
with self.assertRaisesRegex(
ValueError, "lvm snapshot origin must be a logical volume"):
LVMLogicalVolumeDevice("snap1",
parents=[pool],
origin=pv,
seg_type="thin")
# now make the constructor succeed so we can test some properties
thinlv.exists = True
snap1 = LVMLogicalVolumeDevice("snap1",
parents=[pool],
origin=thinlv,
seg_type="thin")
self.assertEqual(snap1.isleaf, True)
self.assertEqual(snap1.direct, True)
self.assertEqual(thinlv.isleaf, True)
self.assertEqual(thinlv.direct, True)
self.assertEqual(snap1.depends_on(thinlv), True)
self.assertEqual(thinlv.depends_on(snap1), False)
# existing thin snapshots do not depend on their origin
snap1.exists = True
self.assertEqual(snap1.depends_on(thinlv), False)
def test_new_lv_from_non_existing_lvs(self):
# same test as above, just with non-existing LVs used to create the new one
b = blivet.Blivet()
pv = StorageDevice("pv1",
fmt=blivet.formats.get_format("lvmpv"),
size=Size("1 GiB"),
exists=True)
vg = LVMVolumeGroupDevice("testvg", parents=[pv], exists=True)
lv1 = LVMLogicalVolumeDevice("data_lv",
parents=[vg],
size=Size("500 MiB"),
exists=False)
lv2 = LVMLogicalVolumeDevice("metadata_lv",
parents=[vg],
size=Size("50 MiB"),
exists=False)
for dev in (pv, vg, lv1, lv2):
b.devicetree._add_device(dev)
# check that all the above devices are in the expected places
self.assertEqual(set(b.devices), {pv, vg, lv1, lv2})
self.assertEqual(set(b.vgs), {vg})
self.assertEqual(set(b.lvs), {lv1, lv2})
self.assertEqual(set(b.vgs[0].lvs), {lv1, lv2})
self.assertEqual(vg.size, Size("1020 MiB"))
self.assertEqual(lv1.size, Size("500 MiB"))
self.assertEqual(lv2.size, Size("50 MiB"))
# combine the two LVs into a thin pool (the LVs should become its internal LVs)
pool = b.new_lv_from_lvs(vg,
name="pool",
seg_type="thin-pool",
from_lvs=(lv1, lv2))
# add the pool LV into the devicetree
b.devicetree._add_device(pool)
self.assertEqual(set(b.devices), {pv, vg, pool})
self.assertEqual(set(b.vgs), {vg})
self.assertEqual(set(b.lvs), {pool})
self.assertEqual(set(b.vgs[0].lvs), {pool})
self.assertEqual(set(b.vgs[0].lvs[0]._internal_lvs), {lv1, lv2})
self.assertTrue(lv1.is_internal_lv)
self.assertEqual(lv1.int_lv_type, LVMInternalLVtype.data)
self.assertEqual(lv1.size, Size("500 MiB"))
self.assertTrue(lv2.is_internal_lv)
self.assertEqual(lv2.int_lv_type, LVMInternalLVtype.meta)
self.assertEqual(lv2.size, Size("50 MiB"))
self.assertTrue(pool.depends_on(lv1))
self.assertTrue(pool.depends_on(lv2))
self.assertEqual(pool.name, "testvg-pool")
self.assertEqual(pool.size, Size("500 MiB"))
self.assertEqual(pool.metadata_size, Size("50 MiB"))
self.assertIs(pool.vg, vg)
# both component LVs don't exist
with self.assertRaises(errors.DeviceError):
with patch("blivet.devices.lvm.blockdev.lvm") as lvm:
pool.create()
# lv2 will still not exist
lv1.exists = True
with self.assertRaises(errors.DeviceError):
with patch("blivet.devices.lvm.blockdev.lvm") as lvm:
pool.create()
# both component LVs exist, should just work
lv2.exists = True
with patch("blivet.devices.lvm.blockdev.lvm") as lvm:
with patch.object(pool, "_pre_create"):
pool.create()
self.assertTrue(lvm.thpool_convert.called)
def test_new_lv_from_non_existing_lvs(self):
# same test as above, just with non-existing LVs used to create the new one
b = blivet.Blivet()
pv = StorageDevice("pv1", fmt=blivet.formats.get_format("lvmpv"),
size=Size("1 GiB"), exists=True)
vg = LVMVolumeGroupDevice("testvg", parents=[pv], exists=True)
lv1 = LVMLogicalVolumeDevice("data_lv", parents=[vg], size=Size("500 MiB"), exists=False)
lv2 = LVMLogicalVolumeDevice("metadata_lv", parents=[vg], size=Size("50 MiB"), exists=False)
for dev in (pv, vg, lv1, lv2):
b.devicetree._add_device(dev)
# check that all the above devices are in the expected places
self.assertEqual(set(b.devices), {pv, vg, lv1, lv2})
self.assertEqual(set(b.vgs), {vg})
self.assertEqual(set(b.lvs), {lv1, lv2})
self.assertEqual(set(b.vgs[0].lvs), {lv1, lv2})
self.assertEqual(vg.size, Size("1020 MiB"))
self.assertEqual(lv1.size, Size("500 MiB"))
self.assertEqual(lv2.size, Size("50 MiB"))
# combine the two LVs into a thin pool (the LVs should become its internal LVs)
pool = b.new_lv_from_lvs(vg, name="pool", seg_type="thin-pool", from_lvs=(lv1, lv2))
# add the pool LV into the devicetree
b.devicetree._add_device(pool)
self.assertEqual(set(b.devices), {pv, vg, pool})
self.assertEqual(set(b.vgs), {vg})
self.assertEqual(set(b.lvs), {pool})
self.assertEqual(set(b.vgs[0].lvs), {pool})
self.assertEqual(set(b.vgs[0].lvs[0]._internal_lvs), {lv1, lv2})
self.assertTrue(lv1.is_internal_lv)
self.assertEqual(lv1.int_lv_type, LVMInternalLVtype.data)
self.assertEqual(lv1.size, Size("500 MiB"))
self.assertTrue(lv2.is_internal_lv)
self.assertEqual(lv2.int_lv_type, LVMInternalLVtype.meta)
self.assertEqual(lv2.size, Size("50 MiB"))
self.assertTrue(pool.depends_on(lv1))
self.assertTrue(pool.depends_on(lv2))
self.assertEqual(pool.name, "testvg-pool")
self.assertEqual(pool.size, Size("500 MiB"))
self.assertEqual(pool.metadata_size, Size("50 MiB"))
self.assertIs(pool.vg, vg)
# both component LVs don't exist
with self.assertRaises(errors.DeviceError):
with patch("blivet.devices.lvm.blockdev.lvm") as lvm:
pool.create()
# lv2 will still not exist
lv1.exists = True
with self.assertRaises(errors.DeviceError):
with patch("blivet.devices.lvm.blockdev.lvm") as lvm:
pool.create()
# both component LVs exist, should just work
lv2.exists = True
with patch("blivet.devices.lvm.blockdev.lvm") as lvm:
with patch.object(pool, "_pre_create"):
pool.create()
self.assertTrue(lvm.thpool_convert.called)
