def test_read(self):
node = factory.make_Node()
cache_sets = [
factory.make_CacheSet(node=node)
for _ in range(3)
]
uri = get_bcache_cache_sets_uri(node)
response = self.client.get(uri)
self.assertEqual(
http.client.OK, response.status_code, response.content)
expected_ids = [
cache_set.id
for cache_set in cache_sets
]
expected_names = [
cache_set.name
for cache_set in cache_sets
]
result_ids = [
cache_set["id"]
for cache_set in json_load_bytes(response.content)
]
result_names = [
cache_set["name"]
for cache_set in json_load_bytes(response.content)
]
self.assertItemsEqual(expected_ids, result_ids)
self.assertItemsEqual(expected_names, result_names)
def test_read_404_when_node_mismatch(self):
node = factory.make_Node(owner=self.user)
cache_set = factory.make_CacheSet(node=node)
uri = get_bcache_cache_set_uri(cache_set, node=factory.make_Node())
response = self.client.get(uri)
self.assertEqual(http.client.NOT_FOUND, response.status_code,
response.content)
def test_bcache_creation_with_names(self):
node = factory.make_Node()
backing_size = 10 * 1000**4
cache_set = factory.make_CacheSet(node=node)
backing_device = factory.make_PhysicalBlockDevice(node=node,
size=backing_size)
backing_partition_table = factory.make_PartitionTable(
block_device=backing_device)
backing_partition = backing_partition_table.add_partition()
uuid = str(uuid4())
form = CreateBcacheForm(
node=node,
data={
"name": "bcache0",
"uuid": uuid,
"cache_set": cache_set.name,
"backing_partition": backing_partition.name,
"cache_mode": CACHE_MODE_TYPE.WRITEBACK,
},
)
self.assertTrue(form.is_valid(), form.errors)
bcache = form.save()
self.assertEqual("bcache0", bcache.name)
self.assertEqual(uuid, bcache.uuid)
self.assertEqual(cache_set, bcache.cache_set)
self.assertEqual(
backing_partition.get_effective_filesystem(),
bcache.filesystems.get(fstype=FILESYSTEM_TYPE.BCACHE_BACKING),
)
self.assertEqual(FILESYSTEM_GROUP_TYPE.BCACHE, bcache.group_type)
def test_update_403_when_not_admin(self):
node = factory.make_Node(status=NODE_STATUS.READY)
cache_set = factory.make_CacheSet(node=node)
uri = get_bcache_cache_set_uri(cache_set)
response = self.client.put(uri, {})
self.assertEqual(http.client.FORBIDDEN, response.status_code,
response.content)
def test_get_parents_handles_cache_set(self):
# Regression test for lp1519397
node = factory.make_Node(with_boot_disk=False)
volume_group = factory.make_VolumeGroup(node=node)
name = factory.make_name()
vguuid = "%s" % uuid4()
size = random.randint(MIN_BLOCK_DEVICE_SIZE, volume_group.get_size())
logical_volume = volume_group.create_logical_volume(name=name,
uuid=vguuid,
size=size)
logical_volume = reload_object(logical_volume)
sdb = factory.make_PhysicalBlockDevice(node=node)
factory.make_CacheSet(block_device=sdb, node=node)
self.assertItemsEqual(
[fs.block_device_id for fs in volume_group.filesystems.all()],
[parent.id for parent in logical_volume.get_parents()])
def test_read(self):
node = factory.make_Node()
cache_block_device = factory.make_PhysicalBlockDevice(node=node)
cache_set = factory.make_CacheSet(block_device=cache_block_device)
uri = get_bcache_cache_set_uri(cache_set)
response = self.client.get(uri)
self.assertEqual(
http.client.OK, response.status_code, response.content
)
parsed_cache_set = json_load_bytes(response.content)
self.assertThat(
parsed_cache_set,
ContainsDict(
{
"id": Equals(cache_set.id),
"name": Equals(cache_set.name),
"resource_uri": Equals(
get_bcache_cache_set_uri(cache_set)
),
"cache_device": ContainsDict(
{"id": Equals(cache_block_device.id)}
),
"system_id": Equals(cache_set.get_node().system_id),
}
),
)
def test_get_numa_nodes_indexes_many_devices(self):
node = factory.make_Node()
numa_nodes = [
node.default_numanode,
factory.make_NUMANode(node=node),
factory.make_NUMANode(node=node),
]
block_devices = [
factory.make_PhysicalBlockDevice(numa_node=numa_node)
for numa_node in numa_nodes
]
filesystems = [
factory.make_Filesystem(
fstype=FILESYSTEM_TYPE.LVM_PV, block_device=block_device
)
for block_device in block_devices
]
fsgroup = factory.make_FilesystemGroup(
node=node,
filesystems=filesystems,
group_type=FILESYSTEM_GROUP_TYPE.LVM_VG,
)
virtual_block_device = factory.make_VirtualBlockDevice(
filesystem_group=fsgroup
)
cache_set = factory.make_CacheSet(block_device=virtual_block_device)
self.assertEqual(cache_set.get_numa_node_indexes(), [0, 1, 2])
def test_choices_are_being_populated_correctly(self):
node = factory.make_Node(with_boot_disk=False)
# Make 10 block devices.
bds = [factory.make_PhysicalBlockDevice(node=node) for _ in range(10)]
# Partition the last 5 devices with a single partition.
partitions = [
factory.make_PartitionTable(block_device=bd).add_partition()
for bd in bds[5:]
]
partition_choices = [p.id for p in partitions
] + [p.name for p in partitions]
# Get the chocies of the non-partitioned devices.
block_device_choices = [
bd.id for bd in bds if bd.get_partitiontable() is None
] + [bd.name for bd in bds if bd.get_partitiontable() is None]
cache_set = factory.make_CacheSet(block_device=bds[1])
form = UpdateCacheSetForm(cache_set=cache_set, data={})
# Should allow all devices and partitions, including the one currently
# in use on the cache set.
self.assertItemsEqual(
block_device_choices,
[k for (k, v) in form.fields["cache_device"].choices],
)
self.assertItemsEqual(
partition_choices,
[k for (k, v) in form.fields["cache_partition"].choices],
)
def test_bcache_update_with_boot_disk(self):
node = factory.make_Node(with_boot_disk=False)
boot_disk = factory.make_PhysicalBlockDevice(node=node)
cache_set = factory.make_CacheSet(node=node)
filesystems = [
factory.make_Filesystem(
partition=factory.make_PartitionTable(
block_device=factory.make_PhysicalBlockDevice(
node=node)).add_partition(),
fstype=FILESYSTEM_TYPE.BCACHE_BACKING,
)
]
bcache = factory.make_FilesystemGroup(
group_type=FILESYSTEM_GROUP_TYPE.BCACHE,
cache_set=cache_set,
filesystems=filesystems,
)
form = UpdateBcacheForm(bcache=bcache,
data={"backing_device": boot_disk.id})
self.assertTrue(form.is_valid(), form.errors)
bcache = form.save()
boot_partition = boot_disk.get_partitiontable().partitions.first()
self.assertEqual(
boot_partition.get_effective_filesystem(),
bcache.filesystems.get(fstype=FILESYSTEM_TYPE.BCACHE_BACKING),
)
def test_get_cache_set_by_id_or_name_by_id(self):
node = factory.make_Node()
cache_set = factory.make_CacheSet(node=node)
self.assertEqual(
cache_set,
CacheSet.objects.get_cache_set_by_id_or_name(cache_set.id, node),
)
def test_handler_path(self):
node = factory.make_Node()
cache_set = factory.make_CacheSet(node=node)
self.assertEqual(
'/MAAS/api/2.0/nodes/%s/bcache-cache-set/%s/' %
(node.system_id, cache_set.id),
get_bcache_cache_set_uri(cache_set, node=node))
def test_bcache_creation_on_save(self):
node = factory.make_Node()
backing_size = 10 * 1000**4
cache_set = factory.make_CacheSet(node=node)
backing_device = factory.make_PhysicalBlockDevice(node=node,
size=backing_size)
uuid = str(uuid4())
form = CreateBcacheForm(node=node,
data={
'name': 'bcache0',
'uuid': uuid,
'cache_set': cache_set.id,
'backing_device': backing_device.id,
'cache_mode': CACHE_MODE_TYPE.WRITEBACK,
})
self.assertTrue(form.is_valid(), form.errors)
bcache = form.save()
self.assertEqual('bcache0', bcache.name)
self.assertEqual(uuid, bcache.uuid)
self.assertEqual(cache_set, bcache.cache_set)
self.assertEqual(
backing_device.get_effective_filesystem(),
bcache.filesystems.get(fstype=FILESYSTEM_TYPE.BCACHE_BACKING))
self.assertEqual(backing_size, bcache.get_size())
self.assertEqual(FILESYSTEM_GROUP_TYPE.BCACHE, bcache.group_type)
def test_get_cache_set_for_block_device(self):
block_device = factory.make_PhysicalBlockDevice()
cache_set = factory.make_CacheSet(block_device=block_device)
self.assertEqual(
cache_set,
CacheSet.objects.get_cache_set_for_block_device(block_device),
)
def test_choices_are_being_populated_correctly(self):
node = factory.make_Node(with_boot_disk=False)
# Make 10 block devices.
bds = [
factory.make_PhysicalBlockDevice(node=node, size=10 * 1000**4)
for _ in range(10)
]
# Make 3 cache sets.
cache_sets = [factory.make_CacheSet(node=node) for _ in range(3)]
cache_set_choices = [cache_set.id for cache_set in cache_sets
] + [cache_set.name for cache_set in cache_sets]
# Partition the last 5 devices with a single partition.
partitions = [
factory.make_PartitionTable(block_device=bd).add_partition()
for bd in bds[5:]
]
partition_choices = [partition.id for partition in partitions
] + [partition.name for partition in partitions]
# Get the IDs of the non-partitioned devices.
block_devices = [
bd.id for bd in bds if bd.get_partitiontable() is None
] + [bd.name for bd in bds if bd.get_partitiontable() is None]
form = CreateBcacheForm(node=node, data={})
self.assertItemsEqual(
cache_set_choices,
[k for (k, v) in form.fields["cache_set"].choices],
)
self.assertItemsEqual(
block_devices,
[k for (k, v) in form.fields["backing_device"].choices],
)
self.assertItemsEqual(
partition_choices,
[k for (k, v) in form.fields["backing_partition"].choices],
)
def test_update_change_cache_device(self):
mock_create_audit_event = self.patch(
bcache_cacheset_module, "create_audit_event"
)
self.become_admin()
node = factory.make_Node(status=NODE_STATUS.READY)
cache_set = factory.make_CacheSet(node=node)
new_device = factory.make_PhysicalBlockDevice(node)
uri = get_bcache_cache_set_uri(cache_set)
response = self.client.put(uri, {"cache_device": new_device.id})
self.assertEqual(
http.client.OK, response.status_code, response.content
)
parsed_device = json_load_bytes(response.content)
self.assertEqual(new_device.id, parsed_device["cache_device"]["id"])
self.assertThat(
mock_create_audit_event,
MockCalledOnceWith(
EVENT_TYPES.NODE,
ENDPOINT.API,
ANY,
node.system_id,
"Updated bcache cache set.",
),
)
def test_bcache_with_invalid_block_device_fails(self):
"""Tests allowable device list validation."""
node = factory.make_Node()
cache_set = factory.make_CacheSet(node=node)
filesystems = [
factory.make_Filesystem(
partition=factory.make_PartitionTable(
block_device=factory.make_PhysicalBlockDevice(
node=node)).add_partition(),
fstype=FILESYSTEM_TYPE.BCACHE_BACKING,
)
]
backing_device = factory.make_PhysicalBlockDevice()
bcache = factory.make_FilesystemGroup(
group_type=FILESYSTEM_GROUP_TYPE.BCACHE,
cache_set=cache_set,
filesystems=filesystems,
)
form = UpdateBcacheForm(bcache=bcache,
data={"backing_device": backing_device.id})
self.assertFalse(form.is_valid(), form.errors)
self.assertIn("Select a valid choice.",
form.errors["backing_device"][0])
self.assertIn(
"is not one of the available choices.",
form.errors["backing_device"][0],
)
def test__admin_raises_PermissionDenied_when_user_requests_admin(self):
user = factory.make_User()
node = factory.make_Node()
cache_set = factory.make_CacheSet(node=node)
self.assertRaises(PermissionDenied,
CacheSet.objects.get_cache_set_or_404,
node.system_id, cache_set.id, user,
NodePermission.admin)
def test__edit_raises_PermissionDenied_when_user_not_owner(self):
user = factory.make_User()
node = factory.make_Node(owner=factory.make_User())
cache_set = factory.make_CacheSet(node=node)
self.assertRaises(PermissionDenied,
CacheSet.objects.get_cache_set_or_404,
node.system_id, cache_set.id, user,
NodePermission.edit)
def test_update_409_when_not_ready(self):
self.become_admin()
node = factory.make_Node(status=NODE_STATUS.ALLOCATED)
cache_set = factory.make_CacheSet(node=node)
uri = get_bcache_cache_set_uri(cache_set)
response = self.client.put(uri, {})
self.assertEqual(http.client.CONFLICT, response.status_code,
response.content)
def test_delete_deletes_cache_set(self):
self.become_admin()
node = factory.make_Node(status=NODE_STATUS.READY)
cache_set = factory.make_CacheSet(node=node)
uri = get_bcache_cache_set_uri(cache_set)
response = self.client.delete(uri)
self.assertEqual(http.client.NO_CONTENT, response.status_code,
response.content)
self.assertIsNone(reload_object(cache_set))
def test__admin_returns_device_when_admin(self):
user = factory.make_admin()
node = factory.make_Node()
cache_set = factory.make_CacheSet(node=node)
self.assertEqual(
cache_set.id,
CacheSet.objects.get_cache_set_or_404(node.system_id, cache_set.id,
user,
NodePermission.admin).id)
def test__view_returns_cache_set_when_owner(self):
user = factory.make_User()
node = factory.make_Node(owner=user)
cache_set = factory.make_CacheSet(node=node)
self.assertEqual(
cache_set.id,
CacheSet.objects.get_cache_set_or_404(node.system_id, cache_set.id,
user,
NODE_PERMISSION.VIEW).id)
def test__view_returns_cache_set_when_no_owner(self):
user = factory.make_User()
node = factory.make_Node()
cache_set = factory.make_CacheSet(node=node)
self.assertEqual(
cache_set.id,
CacheSet.objects.get_cache_set_or_404(node.system_id, cache_set.id,
user,
NodePermission.view).id)
def test__edit_returns_device_when_user_is_owner(self):
user = factory.make_User()
node = factory.make_Node(owner=user)
cache_set = factory.make_CacheSet(node=node)
self.assertEqual(
cache_set.id,
CacheSet.objects.get_cache_set_or_404(node.system_id, cache_set.id,
user,
NodePermission.edit).id)
def test_get_cache_set_by_id_or_name_by_id_invalid_for_mismatch_node(self):
node = factory.make_Node()
cache_set = factory.make_CacheSet(node=node)
self.assertRaises(
CacheSet.DoesNotExist,
CacheSet.objects.get_cache_set_by_id_or_name,
cache_set.id,
factory.make_Node(),
)
def test__return_cache_set_by_name(self):
user = factory.make_User()
node = factory.make_Node()
cache_set = factory.make_CacheSet(node=node)
self.assertEqual(
cache_set.id,
CacheSet.objects.get_cache_set_or_404(node.system_id,
cache_set.name, user,
NODE_PERMISSION.VIEW).id)
def test_update_400_when_invalid_id(self):
self.become_admin()
node = factory.make_Node(status=NODE_STATUS.READY)
cache_set = factory.make_CacheSet(node=node)
new_device = factory.make_PhysicalBlockDevice(node=node)
factory.make_Filesystem(block_device=new_device)
uri = get_bcache_cache_set_uri(cache_set)
response = self.client.put(uri, {"cache_device": new_device})
self.assertEqual(http.client.BAD_REQUEST, response.status_code,
response.content)
def test_return_cache_set_by_name(self):
user = factory.make_User()
node = factory.make_Node()
cache_set = factory.make_CacheSet(node=node)
self.assertEqual(
cache_set.id,
CacheSet.objects.get_cache_set_or_404(
node.system_id, cache_set.name, user, NodePermission.view
).id,
)
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_raises_Http404_when_invalid_node(self):
user = factory.make_admin()
cache_set = factory.make_CacheSet()
self.assertRaises(
Http404,
CacheSet.objects.get_cache_set_or_404,
factory.make_name("system_id"),
cache_set.id,
user,
NodePermission.view,
)
