def test_missing_key(self):
del self.spec["physical_devices"][0]["name"]
with self.assertRaises(MissingRequiredKeysError) as context:
list(parse(self.spec))
self.assertEqual(context.exception.name, "PhysicalDevice")
self.assertSetEqual(context.exception.keys, {"name"})
def test_illegal_key(self):
self.spec["physical_devices"][0]["foo"] = "bar"
with self.assertRaises(FoundIllegalKeysError) as context:
list(parse(self.spec))
self.assertEqual(context.exception.name, "PhysicalDevice")
self.assertSetEqual(context.exception.keys, {"foo"})
def test_illegal_key_2(self):
spec = self.spec["lvm_volume_groups"][0]["lvm_logical_volumes"][0]
spec["foo"] = "bar"
with self.assertRaises(FoundIllegalKeysError) as context:
list(parse(self.spec))
self.assertEqual(context.exception.name, "LvmLogicalVolume")
self.assertSetEqual(context.exception.keys, {"foo"})
def test_illegal_key(self):
spec = self.spec["raid_volumes"][0]
spec["foo"] = "bar"
with self.assertRaises(FoundIllegalKeysError) as context:
list(parse(self.spec))
self.assertEqual(context.exception.name, "RaidVolume")
self.assertSetEqual(context.exception.keys, {"foo"})
def test_missing_key(self):
spec = self.spec["physical_devices"][2]["lvm_physical_volume"]
del spec["name"]
with self.assertRaises(MissingRequiredKeysError) as context:
list(parse(self.spec))
self.assertEqual(context.exception.name, "LvmPhysicalVolume")
self.assertSetEqual(context.exception.keys, {"name"})
def test_missing_key_2(self):
spec = self.spec["physical_devices"][0]["partition_table"]
del spec["partitions"]
with self.assertRaises(MissingRequiredKeysError) as context:
list(parse(self.spec))
self.assertEqual(context.exception.name, "PartitionTable")
self.assertSetEqual(context.exception.keys, {"partitions"})
def test_illegal_key_2(self):
spec = self.spec["physical_devices"][2]["lvm_physical_volume"]
spec["foo"] = "bar"
with self.assertRaises(FoundIllegalKeysError) as context:
list(parse(self.spec))
self.assertEqual(context.exception.name, "LvmPhysicalVolume")
self.assertSetEqual(context.exception.keys, {"foo"})
def test_missing_key(self):
spec = self.spec["lvm_volume_groups"][0]["lvm_logical_volumes"][0]
del spec["name"]
with self.assertRaises(MissingRequiredKeysError) as context:
list(parse(self.spec))
self.assertEqual(context.exception.name, "LvmLogicalVolume")
self.assertSetEqual(context.exception.keys, {"name"})
def test_illegal_key_2(self):
spec = self.spec["physical_devices"][0]["partition_table"]
spec = spec["partitions"][1]["crypt_volume"]["filesystem"]
spec["foo"] = "bar"
with self.assertRaises(FoundIllegalKeysError) as context:
list(parse(self.spec))
self.assertEqual(context.exception.name, "Filesystem")
self.assertSetEqual(context.exception.keys, {"foo"})
def test_illegal_key_1(self):
# These keys are restricted before parsing the rest of the
# lvm_logical_volume spec.
spec = self.spec["lvm_volume_groups"][0]["lvm_logical_volumes"][0]
spec["lvm_volume_group"] = "lvm_volume_group"
with self.assertRaises(FoundIllegalKeysError) as context:
list(parse(self.spec))
self.assertEqual(context.exception.name, "LvmLogicalVolume")
self.assertSetEqual(context.exception.keys, {"lvm_volume_group"})
def test_illegal_key_1(self):
# These keys are restricted before parsing the rest of the
# lvm_physical_volume spec.
spec = self.spec["physical_devices"][2]["lvm_physical_volume"]
spec["device"] = "device"
with self.assertRaises(FoundIllegalKeysError) as context:
list(parse(self.spec))
self.assertEqual(context.exception.name, "LvmPhysicalVolume")
self.assertSetEqual(context.exception.keys, {"device"})
def test_missing_key(self):
spec = self.spec["physical_devices"][0]["partition_table"]
spec = spec["partitions"][1]["crypt_volume"]["filesystem"]
spec = spec["mount"]["files"][0]["crypt_volume"]["swap_volume"]
del spec["name"]
with self.assertRaises(MissingRequiredKeysError) as context:
list(parse(self.spec))
self.assertEqual(context.exception.name, "SwapVolume")
self.assertSetEqual(context.exception.keys, {"name"})
def test_illegal_key_1(self):
# These keys are restricted before parsing the rest of the
# partition_table spec.
spec = self.spec["physical_devices"][0]["partition_table"]
spec["name"] = "name"
spec["device"] = "device"
with self.assertRaises(FoundIllegalKeysError) as context:
list(parse(self.spec))
self.assertEqual(context.exception.name, "PartitionTable")
self.assertSetEqual(context.exception.keys, {"name", "device"})
def test_illegal_key_1(self):
# These keys are restricted before parsing the rest of the filesystem
# spec.
spec = self.spec["physical_devices"][0]["partition_table"]
spec = spec["partitions"][1]["crypt_volume"]["filesystem"]
spec["device"] = "device"
with self.assertRaises(FoundIllegalKeysError) as context:
list(parse(self.spec))
self.assertEqual(context.exception.name, "Filesystem")
self.assertSetEqual(context.exception.keys, {"device"})
def main(argv):
args = parse_args(argv)
logging.basicConfig(level=args.log_level)
config = load_config(args.config)
graph = Graph(parse(load_spec(args.specification)))
run(config, graph, args.action, args.mode)
return 0
def test_missing_key(self):
spec = self.spec["raid_volumes"][0]
del spec["name"]
del spec["devices"]
del spec["level"]
del spec["metadata"]
with self.assertRaises(MissingRequiredKeysError) as context:
list(parse(self.spec))
self.assertEqual(context.exception.name, "RaidVolume")
self.assertSetEqual(context.exception.keys,
{"name", "devices", "level", "metadata"})
def test_exclusive_keys_1(self):
spec = self.spec["lvm_volume_groups"][0]["lvm_logical_volumes"][0]
spec["size"] = "size"
spec["extents"] = "extents"
with self.assertRaises(FoundIncompatibleKeysError) as context:
list(parse(self.spec))
self.assertEqual(context.exception.name, "LvmLogicalVolume")
self.assertSetEqual(
context.exception.keys,
{"size", "extents"},
)
def test_exclusive_keys_2(self):
spec = self.spec["physical_devices"][0]["partition_table"]
spec = spec["partitions"][1]["crypt_volume"]
spec["keyfile"] = "/keyfile"
spec["keysize"] = "swap_volume"
with self.assertRaises(FoundIncompatibleKeysError) as context:
list(parse(self.spec))
self.assertEqual(context.exception.name, "CryptVolume")
self.assertSetEqual(
context.exception.keys,
{"keyfile", "keysize"},
)
def test_exclusive_keys(self):
spec = self.spec["physical_devices"][0]["partition_table"]
spec = spec["partitions"][1]["crypt_volume"]["filesystem"]
spec = spec["mount"]["files"][0]
spec["loop_device"] = "loop_device"
spec["crypt_volume"] = "crypt_volume"
spec["swap_volume"] = "swap_volume"
with self.assertRaises(FoundIncompatibleKeysError) as context:
list(parse(self.spec))
self.assertEqual(context.exception.name, "File")
self.assertSetEqual(
context.exception.keys,
{"loop_device", "crypt_volume", "swap_volume"},
)
def test_exclusive_keys_2(self):
spec = self.spec["lvm_volume_groups"][0]["lvm_logical_volumes"][0]
spec["lvm_poolmetadata_volume"] = "lvm_poolmetadata_volume"
spec["lvm_cachepool_volume"] = "lvm_cachepool_volume"
spec["lvm_thinpool_volume"] = "lvm_thinpool_volume"
with self.assertRaises(FoundIncompatibleKeysError) as context:
list(parse(self.spec))
self.assertEqual(context.exception.name, "LvmLogicalVolume")
self.assertSetEqual(
context.exception.keys,
{
"lvm_poolmetadata_volume",
"lvm_cachepool_volume",
"lvm_thinpool_volume",
},
)
def test_complete(self):
expected = [
Root(),
PhysicalDevice("sda"),
PartitionTable(name="sda:pt", device="sda", type="gpt", glue="p"),
Partition(
name="sda:pt:1",
partition_table="sda:pt",
align=None,
number=1,
type="primary",
start="1",
end="3",
label=None,
unit=None,
flags=["bios_grub"],
),
Partition(
name="sda:pt:2",
partition_table="sda:pt",
align=None,
number=2,
type="primary",
start="3",
end="-1",
label=None,
unit=None,
flags=[],
),
CryptVolume(
name="cryptroot",
device="sda:pt:2",
identify="partuuid",
type="luks2",
keyfile="fsroot:mount:keyfile",
keysize="2048",
password="******",
options=[],
),
Filesystem(
name="fsroot",
device="cryptroot",
type="ext4",
options=[],
),
Mount(
name="fsroot:mount",
device="fsroot",
identify="device",
mountpoint="//",
type="ext4",
options=[],
dump_frequency=None,
fsck_order=None,
),
Directory(
name="fsroot:mount:raid",
mount="fsroot:mount",
relative_path="raid",
owner="root",
group="root",
mode="0755",
),
Directory(
name="fsroot:mount:loop",
mount="fsroot:mount",
relative_path="loop",
owner=None,
group=None,
mode=None,
),
File(
name="fsroot:mount:swapfile",
mount="fsroot:mount",
relative_path="swapfile",
owner="root",
group="root",
mode="0755",
size="10",
),
CryptVolume(
name="cryptswap1",
device="fsroot:mount:swapfile",
identify="device",
type="luks2",
keyfile="/dev/urandom",
keysize=None,
password=None,
options=["swap", "cipher=aes-cbc-essiv:sha256", "size=256"],
),
SwapVolume(
name="swap1",
device="cryptswap1",
identify="device",
label=None,
pagesize=None,
uuid=None,
),
File(
name="fsroot:mount:loopfile",
mount="fsroot:mount",
relative_path="loopfile",
owner=None,
group=None,
mode=None,
size="10",
),
LoopDevice(
name="loop",
file="fsroot:mount:loopfile",
args=["-e", "18"],
),
Filesystem(
name="fsloop",
device="loop",
type="ext4",
options=[],
),
Mount(
name="fsloop:mount",
device="fsloop",
identify="device",
mountpoint="/loop",
type="ext4",
options=["noatime"],
dump_frequency=None,
fsck_order=None,
),
File(
name="fsroot:mount:randomfile",
mount="fsroot:mount",
relative_path="randomfile",
owner=None,
group=None,
mode=None,
size=None,
),
File(
name="fsroot:mount:keyfile",
mount="fsroot:mount",
relative_path="keyfile",
owner=None,
group=None,
mode=None,
size=None,
),
Link(
name="fsroot:mount:hardlink",
mount="fsroot:mount",
relative_path="hardlink",
source="/keyfile",
owner=None,
group=None,
mode=None,
symbolic=False,
),
Link(
name="fsroot:mount:symlink",
mount="fsroot:mount",
relative_path="symlink",
source="/randomfile",
owner=None,
group=None,
mode=None,
symbolic=True,
),
PhysicalDevice("sdb"),
SwapVolume(
name="swap2",
device="sdb",
identify="uuid",
label=None,
pagesize=None,
uuid=None,
),
PhysicalDevice("sdc"),
LvmPhysicalVolume(name="lvmpv", device="sdc"),
PhysicalDevice("sdd"),
LvmVolumeGroup(name="lvmvg", lvm_physical_volumes=["lvmpv"]),
LvmLogicalVolume(
name="lvmlv",
size=None,
extents=None,
type=None,
args=[],
lvm_volume_group="lvmvg",
lvm_physical_volumes=[],
lvm_poolmetadata_volume=None,
lvm_cachepool_volume=None,
lvm_thinpool_volume=None,
),
CryptVolume(
name="crypt_lvm",
device="lvmlv",
identify="device",
type="luks2",
keyfile="fsroot:mount:randomfile",
keysize="2048",
password=None,
options=[],
),
RaidVolume(
name="raidarray",
devices=["sdc"],
level="1",
metadata="1.2",
),
Filesystem(
name="fsraid",
device="raidarray",
type="ext4",
options=[],
),
Mount(
name="fsraid:mount",
device="fsraid",
identify="device",
mountpoint="/raid",
type="ext4",
options=[],
dump_frequency=None,
fsck_order=None,
),
]
self.assertListEqual(list(parse(self.spec)), expected)
