def test_delete_not_allowed_if_part_of_filesystem_group(self):
partition = factory.make_Partition(size=1024**3,
block_device_size=2 * 1024**3)
VolumeGroup.objects.create_volume_group(factory.make_name("vg"), [],
[partition])
error = self.assertRaises(ValidationError, partition.delete)
self.assertEqual(
"Cannot delete partition because its part of a volume group.",
error.message)
def make_partition(self, node):
device = factory.make_PhysicalBlockDevice(
node=node,
size=(MIN_PARTITION_SIZE * 4) + PARTITION_TABLE_EXTRA_SPACE,
)
partition_table = factory.make_PartitionTable(block_device=device)
return factory.make_Partition(
partition_table=partition_table, size=MIN_PARTITION_SIZE
)
def test_get_effective_filesystem(self):
mock_get_effective_filesystem = self.patch_autospec(
partition_module, "get_effective_filesystem"
)
mock_get_effective_filesystem.return_value = sentinel.filesystem
partition = factory.make_Partition()
self.assertEqual(
sentinel.filesystem, partition.get_effective_filesystem()
)
def test_remove_invalid_spare_partition_fails(self):
raid = _make_interesting_RAID(node=factory.make_Node())
ids = [factory.make_Partition().id for _ in range(2)]
form = UpdateRaidForm(raid, data={'remove_spare_partitions': ids})
self.assertFalse(form.is_valid(), form.errors)
self.assertIn('remove_spare_partitions', form.errors)
self.assertIn(
'is not one of the available choices.',
form.errors['remove_spare_partitions'][0])
def test_add_valid_partition(self):
raid = factory.make_FilesystemGroup(
group_type=FILESYSTEM_GROUP_TYPE.RAID_6)
# Add 5 new partitions to the node.
part_ids = [
factory.make_Partition(node=raid.get_node()).id for _ in range(5)
]
form = UpdateRaidForm(raid, data={"add_partitions": part_ids})
self.assertTrue(form.is_valid(), form.errors)
def test_get_partition_by_id_or_name_invalid_part_seperator(self):
partition = factory.make_Partition()
self.assertRaises(
Partition.DoesNotExist,
Partition.objects.get_partition_by_id_or_name,
"%spart%s" % (
partition.partition_table.block_device.get_name(),
partition.get_partition_number()
))
def test_update_updates_volume_group(self):
self.become_admin()
node = factory.make_Node(status=NODE_STATUS.READY)
volume_group = factory.make_VolumeGroup(node=node)
delete_block_device = factory.make_PhysicalBlockDevice(node=node)
factory.make_Filesystem(
fstype=FILESYSTEM_TYPE.LVM_PV, block_device=delete_block_device,
filesystem_group=volume_group)
delete_bd_for_partition = factory.make_PhysicalBlockDevice(node=node)
delete_table = factory.make_PartitionTable(
block_device=delete_bd_for_partition)
delete_partition = factory.make_Partition(partition_table=delete_table)
factory.make_Filesystem(
fstype=FILESYSTEM_TYPE.LVM_PV, partition=delete_partition,
filesystem_group=volume_group)
new_name = factory.make_name("vg")
new_uuid = "%s" % uuid.uuid4()
new_block_device = factory.make_PhysicalBlockDevice(node=node)
new_bd_for_partition = factory.make_PhysicalBlockDevice(node=node)
new_table = factory.make_PartitionTable(
block_device=new_bd_for_partition)
new_partition = factory.make_Partition(partition_table=new_table)
uri = get_volume_group_uri(volume_group)
response = self.client.put(uri, {
"name": new_name,
"uuid": new_uuid,
"add_block_devices": [new_block_device.id],
"remove_block_devices": [delete_block_device.id],
"add_partitions": [new_partition.id],
"remove_partitions": [delete_partition.id],
})
self.assertEqual(
http.client.OK, response.status_code, response.content)
volume_group = reload_object(volume_group)
self.assertEqual(new_name, volume_group.name)
self.assertEqual(new_uuid, volume_group.uuid)
self.assertEqual(
volume_group.id,
new_block_device.get_effective_filesystem().filesystem_group.id)
self.assertEqual(
volume_group.id,
new_partition.get_effective_filesystem().filesystem_group.id)
self.assertIsNone(delete_block_device.get_effective_filesystem())
self.assertIsNone(delete_partition.get_effective_filesystem())
def test_get_partition_by_id_or_name_by_name_invalid_table(self):
partition_table = factory.make_PartitionTable()
other_table = factory.make_PartitionTable()
partition = factory.make_Partition(partition_table=partition_table)
self.assertRaises(
Partition.DoesNotExist,
Partition.objects.get_partition_by_id_or_name,
partition.name,
other_table,
)
def test_add_invalid_spare_partition_fails(self):
raid = factory.make_FilesystemGroup(
group_type=FILESYSTEM_GROUP_TYPE.RAID_6)
# Add 5 new partitions to other nodes.
part_ids = [factory.make_Partition().id for _ in range(5)]
form = UpdateRaidForm(raid, data={'add_spare_partitions': part_ids})
self.assertFalse(form.is_valid(), form.errors)
self.assertIn('add_spare_partitions', form.errors)
self.assertIn('is not one of the available choices.',
form.errors['add_spare_partitions'][0])
def test_is_not_valid_if_invalid_uuid(self):
fstype = factory.pick_filesystem_type()
partition = factory.make_Partition()
data = {
'fstype': fstype,
'uuid': factory.make_string(size=32),
}
form = FormatPartitionForm(partition, data=data)
self.assertFalse(form.is_valid(),
"Should be invalid because of an invalid uuid.")
self.assertEqual({'uuid': ["Enter a valid value."]}, form._errors)
def test_save_updates_the_cache_set_with_partition(self):
node = factory.make_Node()
cache_device = factory.make_PhysicalBlockDevice(node=node)
cache_set = factory.make_CacheSet(block_device=cache_device)
new_partition = factory.make_Partition(node=node)
form = UpdateCacheSetForm(cache_set=cache_set,
data={"cache_partition": new_partition.id})
self.assertTrue(form.is_valid(), form.errors)
cache_set = form.save()
self.assertEqual(new_partition, cache_set.get_device())
self.assertIsNone(cache_device.get_effective_filesystem())
def test_save_updates_the_cache_set_with_boot_disk(self):
node = factory.make_Node(with_boot_disk=False)
boot_disk = factory.make_PhysicalBlockDevice(node=node)
partition = factory.make_Partition(node=node)
cache_set = factory.make_CacheSet(partition=partition)
form = UpdateCacheSetForm(cache_set=cache_set,
data={"cache_device": boot_disk.id})
self.assertTrue(form.is_valid(), form.errors)
cache_set = form.save()
boot_partition = boot_disk.get_partitiontable().partitions.first()
self.assertEqual(boot_partition, cache_set.get_device())
self.assertIsNone(partition.get_effective_filesystem())
def test_cache_set_creation_with_partition(self):
node = factory.make_Node()
block_device = factory.make_PhysicalBlockDevice(node=node)
partition_table = factory.make_PartitionTable(
block_device=block_device)
partition = factory.make_Partition(partition_table=partition_table)
form = CreateCacheSetForm(node=node,
data={"cache_partition": partition.id})
self.assertTrue(form.is_valid(), form.errors)
cache_set = form.save()
self.assertEqual(partition, cache_set.get_device())
def test_creates_filesystem(self):
fsuuid = "%s" % uuid.uuid4()
fstype = factory.pick_filesystem_type()
partition = factory.make_Partition()
data = {"uuid": fsuuid, "fstype": fstype}
form = FormatPartitionForm(partition, data=data)
self.assertTrue(form.is_valid(), form._errors)
form.save()
filesystem = get_one(Filesystem.objects.filter(partition=partition))
self.assertIsNotNone(filesystem)
self.assertEqual(fstype, filesystem.fstype)
self.assertEqual(fsuuid, filesystem.uuid)
def test_max_possible_size_if_not_specified(self):
block_device = factory.make_PhysicalBlockDevice()
partition_table = factory.make_PartitionTable(
block_device=block_device)
first_partition = factory.make_Partition(
partition_table=partition_table, size=10 * 1024 * 1024)
data = {"uuid": str(uuid.uuid4())}
form = AddPartitionForm(block_device, data=data)
self.assertTrue(form.is_valid(), form.errors)
partition = form.save()
self.assertEqual(partition.size,
partition_table.get_size() - first_partition.size)
def test_list_partitions(self):
device = factory.make_PhysicalBlockDevice(
size=(MIN_PARTITION_SIZE * 4) + PARTITION_TABLE_EXTRA_SPACE)
partition_table = factory.make_PartitionTable(block_device=device)
partition1 = factory.make_Partition(partition_table=partition_table,
size=MIN_PARTITION_SIZE)
partition2 = factory.make_Partition(partition_table=partition_table,
size=MIN_PARTITION_SIZE)
uri = get_partitions_uri(device)
response = self.client.get(uri)
self.assertEqual(http.client.OK, response.status_code,
response.content)
partitions = json.loads(
response.content.decode(settings.DEFAULT_CHARSET))
p1 = [p for p in partitions if p["id"] == partition1.id][0]
p2 = [p for p in partitions if p["id"] == partition2.id][0]
self.assertEqual(partition1.size, p1["size"])
self.assertEqual(partition1.uuid, p1["uuid"])
self.assertEqual(partition2.size, p2["size"])
self.assertEqual(partition2.uuid, p2["uuid"])
def test_adds_partition_by_name(self):
node = make_Node_with_VMFS6_layout()
vmfs = factory.make_VMFS(node=node)
block_device = factory.make_PhysicalBlockDevice(node=node)
partition_table = factory.make_PartitionTable(
block_device=block_device)
partition = factory.make_Partition(partition_table=partition_table)
data = {"add_partitions": [partition.name]}
form = UpdateVMFSForm(vmfs, data=data)
self.assertTrue(form.is_valid(), form._errors)
vmfs = form.save()
self.assertEqual(
vmfs.id,
partition.get_effective_filesystem().filesystem_group.id)
def test_get_physical_block_device_raid_on_part(self):
# Regression test for LP:1849580
node = factory.make_Node(with_boot_disk=False)
block_devices = []
partitions = []
for _ in range(2):
block_device = factory.make_PhysicalBlockDevice(node=node)
block_devices.append(block_device)
pt = factory.make_PartitionTable(block_device=block_device)
partitions.append(factory.make_Partition(partition_table=pt))
fs_group = RAID.objects.create_raid(
level=FILESYSTEM_GROUP_TYPE.RAID_1, partitions=partitions
)
fs = factory.make_Filesystem(block_device=fs_group.virtual_device)
self.assertItemsEqual(fs.get_physical_block_devices(), block_devices)
def test_will_not_unmount_filesystem_on_partition(self):
node = factory.make_Node()
partition = factory.make_Partition(node=node)
filesystem = factory.make_Filesystem(
mount_point=factory.make_absolute_path(), partition=partition)
form = UnmountNonStorageFilesystemForm(
node, data={"mount_point": filesystem.mount_point})
self.assertFalse(form.is_valid())
self.assertThat(
form.errors,
Equals({
"mount_point":
["No special filesystem is mounted at this path."]
}),
)
def _make_interesting_RAID(
node,
level=FILESYSTEM_GROUP_TYPE.RAID_6,
num_devices=10,
num_partitions=10,
num_spare_devices=2,
num_spare_partitions=2,
):
"""Returns a RAID that is interesting for our tests."""
size = 1000**4 # A Terabyte.
block_devices = [
factory.make_BlockDevice(node=node, size=size)
for _ in range(num_devices)
]
partitions = [
factory.make_Partition(node=node, block_device_size=size)
for _ in range(num_partitions)
]
spare_devices = [
factory.make_BlockDevice(node=node, size=size)
for _ in range(num_spare_devices)
]
spare_partitions = [
factory.make_Partition(node=node, block_device_size=size)
for _ in range(num_spare_partitions)
]
return RAID.objects.create_raid(
name="md%d" % random.randint(1, 1000),
level=level,
uuid=uuid4(),
block_devices=block_devices,
partitions=partitions,
spare_devices=spare_devices,
spare_partitions=spare_partitions,
)
def test_adds_partition(self):
node = factory.make_Node()
volume_group = factory.make_VolumeGroup(node=node)
block_device = factory.make_PhysicalBlockDevice(node=node)
partition_table = factory.make_PartitionTable(
block_device=block_device)
partition = factory.make_Partition(partition_table=partition_table)
data = {"add_partitions": [partition.id]}
form = UpdateVolumeGroupForm(volume_group, data=data)
self.assertTrue(form.is_valid(), form._errors)
volume_group = form.save()
self.assertEqual(
volume_group.id,
partition.get_effective_filesystem().filesystem_group.id,
)
def test_is_not_valid_if_invalid_format_fstype(self):
partition = factory.make_Partition()
data = {"fstype": FILESYSTEM_TYPE.LVM_PV}
form = FormatPartitionForm(partition, data=data)
self.assertFalse(form.is_valid(),
"Should be invalid because of an invalid fstype.")
self.assertEqual(
{
"fstype": [
"Select a valid choice. lvm-pv is not one of the "
"available choices."
]
},
form._errors,
)
def test_get_partitions_in_filesystem_group(self):
node = factory.make_Node()
filesystem_group = factory.make_FilesystemGroup(
group_type=FILESYSTEM_GROUP_TYPE.LVM_VG)
block_device_with_partitions = factory.make_PhysicalBlockDevice(
node=node)
partition_table = factory.make_PartitionTable(
block_device=block_device_with_partitions)
partition = factory.make_Partition(partition_table=partition_table)
factory.make_Filesystem(fstype=FILESYSTEM_TYPE.LVM_PV,
partition=partition,
filesystem_group=filesystem_group)
partitions_in_filesystem_group = (
Partition.objects.get_partitions_in_filesystem_group(
filesystem_group))
self.assertItemsEqual([partition], partitions_in_filesystem_group)
def test_deletes_old_filesystem_and_creates_new_one(self):
fstype = factory.pick_filesystem_type()
partition = factory.make_Partition()
prev_filesystem = factory.make_Filesystem(partition=partition)
data = {"fstype": fstype}
form = FormatPartitionForm(partition, data=data)
self.assertTrue(form.is_valid(), form._errors)
form.save()
self.assertEqual(
1,
Filesystem.objects.filter(partition=partition).count(),
"Should only be one filesystem that exists for partition.",
)
self.assertIsNone(reload_object(prev_filesystem))
filesystem = get_one(Filesystem.objects.filter(partition=partition))
self.assertIsNotNone(filesystem)
self.assertEqual(fstype, filesystem.fstype)
def test_filter_by_node(self):
node = factory.make_Node()
boot_bd = node.blockdevice_set.first()
root_partition = boot_bd.partitiontable_set.first().partitions.first()
root_fs = root_partition.filesystem_set.first()
block_device = factory.make_PhysicalBlockDevice(node=node)
bd_for_partitions = factory.make_PhysicalBlockDevice(node=node)
partition_table = factory.make_PartitionTable(
block_device=bd_for_partitions)
partition = factory.make_Partition(partition_table=partition_table)
filesystem_on_bd = factory.make_Filesystem(block_device=block_device)
filesystem_on_partition = factory.make_Filesystem(partition=partition)
filesystem_on_node = factory.make_Filesystem(node=node)
self.assertItemsEqual([
root_fs, filesystem_on_bd, filesystem_on_partition,
filesystem_on_node
], Filesystem.objects.filter_by_node(node))
def test_removes_partition(self):
node = factory.make_Node()
volume_group = factory.make_VolumeGroup(node=node)
block_device = factory.make_PhysicalBlockDevice(node=node)
partition_table = factory.make_PartitionTable(
block_device=block_device)
partition = factory.make_Partition(partition_table=partition_table)
factory.make_Filesystem(fstype=FILESYSTEM_TYPE.LVM_PV,
partition=partition,
filesystem_group=volume_group)
data = {
'remove_partitions': [partition.id],
}
form = UpdateVolumeGroupForm(volume_group, data=data)
self.assertTrue(form.is_valid(), form._errors)
volume_group = form.save()
self.assertIsNone(partition.get_effective_filesystem())
def test_is_not_valid_if_partition_does_not_belong_to_node(self):
node = make_Node_with_VMFS6_layout()
partition = factory.make_Partition()
data = {
'name': factory.make_name('name'),
'partitions': [partition.id],
}
form = CreateVMFSForm(node, data=data)
self.assertFalse(
form.is_valid(),
'Should be invalid because of partition does not '
'belonging to node.')
self.assertEqual({
'partitions': [
'Select a valid choice. %s is not one of the available '
'choices.' % partition.id,
]}, form._errors)
def test_removes_partition_by_name(self):
node = make_Node_with_VMFS6_layout()
vmfs = factory.make_VMFS(node=node)
block_device = factory.make_PhysicalBlockDevice(node=node)
partition_table = factory.make_PartitionTable(
block_device=block_device)
partition = factory.make_Partition(partition_table=partition_table)
factory.make_Filesystem(
fstype=FILESYSTEM_TYPE.LVM_PV, partition=partition,
filesystem_group=vmfs)
data = {
'remove_partitions': [partition.name],
}
form = UpdateVMFSForm(vmfs, data=data)
self.assertTrue(form.is_valid(), form._errors)
vmfs = form.save()
self.assertIsNone(partition.get_effective_filesystem())
def test_read_partition_by_name(self):
device = factory.make_PhysicalBlockDevice(
size=(MIN_PARTITION_SIZE * 4) + PARTITION_TABLE_EXTRA_SPACE)
partition_table = factory.make_PartitionTable(block_device=device)
partition = factory.make_Partition(
partition_table=partition_table,
size=MIN_PARTITION_SIZE,
bootable=True)
uri = get_partition_uri(partition, by_name=True)
response = self.client.get(uri)
self.assertEqual(
http.client.OK, response.status_code, response.content)
parsed_partition = json.loads(
response.content.decode(settings.DEFAULT_CHARSET))
self.assertTrue(parsed_partition['bootable'])
self.assertEqual(partition.id, parsed_partition['id'])
self.assertEqual(partition.size, parsed_partition['size'])
def test_is_not_valid_if_partition_does_not_belong_to_node(self):
node = factory.make_Node()
partition = factory.make_Partition()
data = {
'name': factory.make_name("name"),
'partitions': [partition.id],
}
form = CreateVolumeGroupForm(node, data=data)
self.assertFalse(
form.is_valid(), "Should be invalid because of partition does not "
"belonging to node.")
self.assertEqual(
{
'partitions': [
"Select a valid choice. %s is not one of the available "
"choices." % partition.id,
]
}, form._errors)
