def test_simple_vdev(self):
""" 1 single vdev
"""
# create a single 64M file
f1 = "/var/tmp/ti_file_1"
self.create_file(f1)
# create a new Disk object
d = Disk("disk")
d.ctd = f1
d.in_zpool = "ti_zpool_test"
d.whole_disk = True
self.target.insert_children(d)
# create a new Zpool object
zpool = self.logical.add_zpool("ti_zpool_test")
# create the zpool and store it for later teardown
try:
t = instantiation.TargetInstantiation("test_ti")
t.execute(dry_run=False)
self.zpool_list.append(zpool)
except Exception as err:
import traceback
print traceback.print_exc()
self.fail(str(err))
# pull the vdevs and verify
vdev_map = vdevs._get_vdev_mapping(zpool.name)
# verify the map is correct
self.assertTrue("none" in vdev_map)
self.assertEquals(1, len(vdev_map["none"]))
self.assertEquals([f1], vdev_map["none"])
def test_slice_on_part(self):
self.disk.geometry.nheads = 24
self.disk.geometry.nsectors = 848
self.disk.geometry.blocksize = 512
self.disk.geometry.ncyl = 14089
part = Partition(2)
part.action = "create"
part.start_sector = 0
part.size = Size("50" + Size.gb_units)
part.part_type = "primary"
part.bootid = Partition.ACTIVE
self.disk.insert_children(part)
slice1 = Slice(1)
slice1.action = "create"
slice1.size = Size(str(GBSECTOR) + Size.sector_units)
slice1.start_sector = CYLSIZE
slice1.tag = const.V_USR
slice1.flag = 0
part.insert_children(slice1)
t = instantiation.TargetInstantiation("test_ti")
try:
t.execute(dry_run=True)
except Exception as err:
self.fail(str(err))
def test_mirror_log(self):
""" test the logmirror vdev label
"""
# create three 64M files
f1 = "/var/tmp/ti_file_1"
self.create_file(f1)
f2 = "/var/tmp/ti_file_2"
self.create_file(f2)
f3 = "/var/tmp/ti_file_3"
self.create_file(f3)
# create two disk objects
d1 = Disk("disk1")
d1.ctd = f1
d1.in_zpool = "ti_zpool_test"
d1.in_vdev = "none"
d1.whole_disk = True
d2 = Disk("disk2")
d2.ctd = f2
d2.in_zpool = "ti_zpool_test"
d2.in_vdev = "mirror-1"
d2.whole_disk = True
d3 = Disk("disk3")
d3.ctd = f3
d3.in_zpool = "ti_zpool_test"
d3.in_vdev = "mirror-1"
d3.whole_disk = True
self.target.insert_children([d1, d2, d3])
# create a new Zpool object
zpool = self.logical.add_zpool("ti_zpool_test")
zpool.add_vdev("none", "none")
zpool.add_vdev("mirror-1", "logmirror")
# create the zpool and store it for later teardown
try:
t = instantiation.TargetInstantiation("test_ti")
t.execute(dry_run=False)
self.zpool_list.append(zpool)
except Exception as err:
import traceback
print traceback.print_exc()
self.fail(str(err))
# pull the vdevs and verify
vdev_map = vdevs._get_vdev_mapping(zpool.name)
# verify the map is correct
self.assertTrue("mirror-1" in vdev_map)
self.assertEquals(2, len(vdev_map["mirror-1"]))
self.assertEquals([f2, f3], vdev_map["mirror-1"])
def test_empty_zpool_preserve(self):
zpool = Zpool("test_zpool")
zpool.action = "preserve"
self.logical.insert_children(zpool)
self.target.insert_children(self.logical)
t = instantiation.TargetInstantiation("test_ti")
try:
t.execute(dry_run=True)
except Exception as err:
self.fail(str(err))
def test_one_disk_zpool_create(self):
self.disk1.in_zpool = "test_zpool"
zpool = Zpool("test_zpool")
zpool.action = "create"
self.logical.insert_children(zpool)
self.target.insert_children([self.disk1, self.logical])
t = instantiation.TargetInstantiation("test_ti")
try:
t.execute(dry_run=True)
except Exception as err:
self.fail(str(err))
def test_invalid_vdev_labels(self):
# create four 64M files
f1 = "/var/tmp/ti_file_1"
self.create_file(f1)
f2 = "/var/tmp/ti_file_2"
self.create_file(f2)
f3 = "/var/tmp/ti_file_3"
self.create_file(f3)
f4 = "/var/tmp/ti_file_4"
self.create_file(f4)
# create four disk objects. D1 has no in_zpool set
d1 = Disk("disk1")
d1.ctd = f1
d1.in_vdev = "datavdev"
d1.whole_disk = True
# d2 and d3 have no in_vdev set
d2 = Disk("disk2")
d2.ctd = f2
d2.in_zpool = "ti_myroot"
d2.whole_disk = True
d3 = Disk("disk3")
d3.ctd = f3
d3.in_zpool = "ti_data"
d3.whole_disk = True
# d4 has both set
d4 = Disk("disk4")
d4.ctd = f4
d4.in_zpool = "ti_data"
d4.in_vdev = "datavdev"
d4.whole_disk = True
self.target.insert_children([d1, d2, d3, d4])
# create two new Zpool object
zpool1 = self.logical.add_zpool("ti_myroot")
zpool1.add_vdev("datavdev", redundancy="none")
zpool2 = self.logical.add_zpool("ti_data")
zpool2.add_vdev("datavdev", "mirror")
self.zpool_list.append(zpool1)
self.zpool_list.append(zpool2)
t = instantiation.TargetInstantiation("test_ti")
self.assertRaises(RuntimeError, t.execute)
def test_two_be_create(self):
zpool = Zpool("test_zpool")
zpool.action = "preserve"
be1 = BE("be1")
be2 = BE("be2")
zpool.insert_children([be1, be2])
self.logical.insert_children(zpool)
self.target.insert_children(self.logical)
t = instantiation.TargetInstantiation("test_ti")
try:
t.execute(dry_run=True)
except Exception as err:
self.fail(str(err))
def test_full_zpool_delete(self):
zpool = Zpool("test_zpool")
zpool.action = "delete"
fs1 = Filesystem("test_zpool/fs1")
fs2 = Filesystem("test_zpool/fs2")
fs3 = Filesystem("test_zpool/fs3")
zpool.insert_children([fs1, fs2, fs3])
self.logical.insert_children(zpool)
self.target.insert_children(self.logical)
t = instantiation.TargetInstantiation("test_ti")
try:
t.execute(dry_run=True)
except Exception as err:
self.fail(str(err))
def test_full_zpool_create(self):
zpool = Zpool("test_zpool")
zpool.action = "create"
fs1 = Filesystem("test_zpool/swap")
fs1.action = "create"
fs2 = Filesystem("test_zpool/dump")
fs2.action = "create"
zpool.insert_children([fs1, fs2])
self.logical.insert_children(zpool)
self.target.insert_children(self.logical)
t = instantiation.TargetInstantiation("test_ti")
try:
t.execute(dry_run=True)
except Exception as err:
self.fail(str(err))
def test_create_single_partition(self):
part = Partition(2)
part.action = "create"
part.start_sector = 0
part.size = Size("50" + Size.gb_units)
part.part_type = "primary"
part.bootid = Partition.ACTIVE
self.disk.insert_children(part)
t = instantiation.TargetInstantiation("test_ti")
try:
t.execute(dry_run=True)
except Exception as err:
self.fail(str(err))
def test_two_disk_vdev_create(self):
self.disk1.in_zpool = "test_zpool"
self.disk1.in_vdev = "test_mirror"
self.disk2.in_zpool = "test_zpool"
self.disk2.in_vdev = "test_mirror"
zpool = Zpool("test_zpool")
zpool.action = "create"
vdev = Vdev("test_mirror")
vdev.redundancy = "mirror"
zpool.insert_children(vdev)
self.logical.insert_children(zpool)
self.target.insert_children([self.disk1, self.disk2, self.logical])
t = instantiation.TargetInstantiation("test_ti")
try:
t.execute(dry_run=True)
except Exception as err:
self.fail(str(err))
def test_multi_disk_multi_vdev_create(self):
self.disk1.in_zpool = "test_zpool"
self.disk1.in_vdev = "test_mirror"
self.disk2.in_zpool = "test_zpool"
self.disk2.in_vdev = "test_mirror"
self.disk3 = Disk("disk3")
self.disk3.ctd = "c8t3d0"
self.disk3.in_zpool = "test_zpool"
self.disk3.in_vdev = "test_raidz"
self.disk4 = Disk("disk4")
self.disk4.ctd = "c8t4d0"
self.disk4.in_zpool = "test_zpool"
self.disk4.in_vdev = "test_raidz"
self.disk5 = Disk("disk5")
self.disk5.ctd = "c8t5d0"
self.disk5.in_zpool = "test_zpool"
self.disk5.in_vdev = "test_raidz"
self.disk6 = Disk("disk6")
self.disk6.ctd = "c8t6d0"
self.disk6.in_zpool = "test_zpool"
self.disk6.in_vdev = "test_spare"
self.disk7 = Disk("disk7")
self.disk7.ctd = "c8t7d0"
self.disk7.in_zpool = "test_zpool"
self.disk7.in_vdev = "test_log"
zpool1 = Zpool("test_zpool")
zpool1.action = "create"
vdev1 = Vdev("test_mirror")
vdev1.redundancy = "mirror"
vdev2 = Vdev("test_raidz")
vdev2.redundancy = "raidz"
vdev3 = Vdev("test_log")
vdev3.redundancy = "log"
vdev4 = Vdev("test_spare")
vdev4.redundancy = "spare"
zpool1.insert_children([vdev1, vdev2, vdev3, vdev4])
self.logical.insert_children(zpool1)
self.target.insert_children([self.disk1, self.disk2, self.disk3, \
self.disk4, self.disk5, self.disk6, self.disk7, self.logical])
t = instantiation.TargetInstantiation("test_ti")
try:
t.execute(dry_run=True)
except Exception as err:
self.fail(str(err))
def test_part_not_preserve(self):
part = Partition(1)
part.action = "create"
part.part_type = "primary"
part.bootid = Partition.ACTIVE
part.size = Size("2gb")
part2 = Partition(2)
part2.action = "destroy"
part2.part_type = "primary"
part2.bootid = 0
part2.size = Size("2gb")
self.disk.insert_children([part, part2])
t = instantiation.TargetInstantiation("test_ti")
try:
t.execute(dry_run=True)
except Exception as err:
self.fail(str(err))
def test_create_multiple_partitions(self):
part = Partition(2)
part.action = "create"
part.start_sector = 0
part.size = Size("20" + Size.gb_units)
part.part_type = "primary"
part.bootid = Partition.ACTIVE
part2 = Partition(4)
part2.action = "create"
part2.start_sector = 50 * GBSECTOR + 50
part2.size = Size("50" + Size.gb_units)
part2.part_type = "extended"
part2.bootid = 0
self.disk.insert_children([part, part2])
t = instantiation.TargetInstantiation("test_ti")
try:
t.execute(dry_run=True)
except Exception as err:
self.fail(str(err))
def test_pool_and_dataset_options(self):
zpool = Zpool("test_zpool")
zpool.action = "preserve"
fs1 = Filesystem("test_zpool/fs1")
fs1.action = "create"
fs2 = Filesystem("test_zpool/fs2")
fs2.action = "create"
fs3 = Filesystem("test_zpool/fs3")
fs3.action = "create"
pool_options = PoolOptions("pool options", dict())
fs_options = DatasetOptions("fs options", dict())
pool_options.data_dict["autoexpand"] = "off"
fs_options.data_dict["atime"] = "on"
zpool.insert_children([fs1, fs2, fs3, pool_options, fs_options])
self.logical.insert_children(zpool)
self.target.insert_children(self.logical)
self.doc.insert_children(self.target)
t = instantiation.TargetInstantiation("test_ti")
try:
t.execute(dry_run=True)
except Exception as err:
self.fail(str(err))
def test_slice_on_part_not_preserve(self):
part = Partition(1)
part.action = "preserve"
part.part_type = "primary"
part.bootid = Partition.ACTIVE
part.size = Size("50" + Size.gb_units)
part.start_sector = 0
part2 = Partition(2)
part2.action = "preserve"
part2.part_type = "primary"
part2.bootid = 0
part2.size = Size("50" + Size.gb_units)
part2.start_sector = 50 * GBSECTOR + 50
self.disk.insert_children([part, part2])
slice1 = Slice(1)
slice1.action = "create"
slice1.size = Size(str(GBSECTOR) + Size.sector_units)
slice1.start_sector = CYLSIZE
slice2 = Slice(2)
slice2.action = "create"
slice2.size = Size(str(GBSECTOR) + Size.sector_units)
slice2.start_sector = CYLSIZE + GBSECTOR + 1
slice3 = Slice(3)
slice3.action = "destroy"
slice3.size = Size(str(GBSECTOR) + Size.sector_units)
slice3.start_sector = CYLSIZE + (2 * GBSECTOR + 2)
part.insert_children([slice1, slice2, slice3])
t = instantiation.TargetInstantiation("test_ti")
try:
t.execute(dry_run=True)
except Exception as err:
self.fail(str(err))
def test_slice_not_preserve(self):
slice1 = Slice(1)
slice1.action = "create"
slice1.size = Size(str(GBSECTOR) + Size.sector_units)
slice1.start_sector = CYLSIZE
slice2 = Slice(2)
slice2.action = "create"
slice2.size = Size(str(GBSECTOR) + Size.sector_units)
slice2.start_sector = CYLSIZE + GBSECTOR + 1
slice3 = Slice(3)
slice3.action = "destroy"
slice3.size = Size(str(GBSECTOR) + Size.sector_units)
slice3.start_sector = CYLSIZE + (2 * GBSECTOR + 2)
self.disk.insert_children([slice1, slice2, slice3])
t = instantiation.TargetInstantiation("test_ti")
try:
t.execute(dry_run=True)
except Exception as err:
self.fail(str(err))
def test_duplicate_in_vdev(self):
# create four 64M files
f1 = "/var/tmp/ti_file_1"
self.create_file(f1)
f2 = "/var/tmp/ti_file_2"
self.create_file(f2)
f3 = "/var/tmp/ti_file_3"
self.create_file(f3)
f4 = "/var/tmp/ti_file_4"
self.create_file(f4)
# create four disk objects
d1 = Disk("disk1")
d1.ctd = f1
d1.in_zpool = "ti_myroot"
d1.in_vdev = "datavdev"
d1.whole_disk = True
# match the in_vdev for d2 and d3 with d1, but use a different pool and
# a different redundancy
d2 = Disk("disk2")
d2.ctd = f2
d2.in_zpool = "ti_data"
d2.in_vdev = "datavdev"
d2.whole_disk = True
d3 = Disk("disk3")
d3.ctd = f3
d3.in_zpool = "ti_data"
d3.in_vdev = "datavdev"
d3.whole_disk = True
d4 = Disk("disk4")
d4.ctd = f4
d4.in_zpool = "ti_data"
d4.in_vdev = "sparevdev"
d4.whole_disk = True
self.target.insert_children([d1, d2, d3, d4])
# create two new Zpool object
zpool1 = self.logical.add_zpool("ti_myroot")
zpool1.add_vdev("datavdev", redundancy="none")
zpool2 = self.logical.add_zpool("ti_data")
zpool2.add_vdev("datavdev", "mirror")
zpool2.add_vdev("sparevdev", "spare")
# create the zpools and store it for later teardown
try:
t = instantiation.TargetInstantiation("test_ti")
t.execute(dry_run=False)
self.zpool_list.append(zpool1)
self.zpool_list.append(zpool2)
except Exception as err:
import traceback
print traceback.print_exc()
self.fail(str(err))
# pull the vdevs and verify
zpool1_vdev_map = vdevs._get_vdev_mapping(zpool1.name)
zpool2_vdev_map = vdevs._get_vdev_mapping(zpool2.name)
# verify both maps are correct
self.assertTrue("none" in zpool1_vdev_map)
self.assertEquals([f1], zpool1_vdev_map["none"])
self.assertTrue("mirror-0" in zpool2_vdev_map)
self.assertTrue("spare" in zpool2_vdev_map)
self.assertEquals(2, len(zpool2_vdev_map["mirror-0"]))
self.assertEquals([f2, f3], zpool2_vdev_map["mirror-0"])
self.assertEquals(1, len(zpool2_vdev_map["spare"]))
self.assertEquals([f4], zpool2_vdev_map["spare"])
def test_complex_vdevs1(self):
""" 10 disks: Mirrored root + raidz datapool with log and spare
"""
# create 10 files
for i in range(1, 11):
f = "/var/tmp/ti_file_%d" % i
self.create_file(f)
# create 10 disk objects
for i in range(1, 11):
d = Disk("disk%d" % i)
d.ctd = self.file_list[i - 1]
if i in [1, 2]:
d.in_zpool = "ti_zpool_test_root"
d.in_vdev = "root-mirror"
elif i in [3, 4, 5, 6]:
d.in_zpool = "ti_zpool_test_datapool"
d.in_vdev = "datapool-raidz"
elif i in [7, 8]:
d.in_zpool = "ti_zpool_test_datapool"
d.in_vdev = "datapool-log"
elif i in [9, 10]:
d.in_zpool = "ti_zpool_test_datapool"
d.in_vdev = "datapool-spare"
self.target.insert_children(d)
# create two new zpool objects
zpool1 = self.logical.add_zpool("ti_zpool_test_root")
zpool1.add_vdev("root-mirror", "mirror")
zpool2 = self.logical.add_zpool("ti_zpool_test_datapool")
zpool2.add_vdev("datapool-raidz", "raidz")
zpool2.add_vdev("datapool-log", "log")
zpool2.add_vdev("datapool-spare", "spare")
# create the zpools and store it for later teardown
try:
t = instantiation.TargetInstantiation("test_ti")
t.execute(dry_run=False)
self.zpool_list.append(zpool1)
self.zpool_list.append(zpool2)
except Exception as err:
import traceback
print traceback.print_exc()
self.fail(str(err))
# pull the vdevs and verify
vdev_map1 = vdevs._get_vdev_mapping(zpool1.name)
# verify the map is correct
self.assertTrue("mirror-0" in vdev_map1)
self.assertTrue(len(vdev_map1["mirror-0"]) == 2)
self.assertTrue(vdev_map1["mirror-0"] == self.file_list[:2])
vdev_map2 = vdevs._get_vdev_mapping(zpool2.name)
self.assertTrue("spare" in vdev_map2)
self.assertTrue("logs" in vdev_map2)
self.assertTrue("raidz-0" in vdev_map2)
self.assertTrue(2, len(vdev_map2["spare"]))
self.assertTrue(2, len(vdev_map2["logs"]))
self.assertTrue(4, len(vdev_map2["raidz-0"]))
self.assertEquals(self.file_list[-2:], vdev_map2["spare"])
self.assertEquals(self.file_list[6:8], vdev_map2["logs"])
self.assertEquals(self.file_list[2:6], vdev_map2["raidz-0"])
