def test__changes_power_state(self):
power_state = factory.pick_enum(POWER_STATE)
node = yield deferToDatabase(self.create_node, power_state)
new_state = factory.pick_enum(POWER_STATE, but_not=power_state)
yield call_responder(
Region(), UpdateNodePowerState,
{'system_id': node.system_id, 'power_state': new_state})
db_state = yield deferToDatabase(
self.get_node_power_state, node.system_id)
self.assertEqual(new_state, db_state)
def test_read(self):
node = factory.make_Node()
volume_groups = [
factory.make_FilesystemGroup(
node=node, group_type=FILESYSTEM_GROUP_TYPE.LVM_VG)
for _ in range(3)
]
# Not volume groups. Should not be in the output.
for _ in range(3):
factory.make_FilesystemGroup(
node=node,
group_type=factory.pick_enum(
FILESYSTEM_GROUP_TYPE,
but_not=FILESYSTEM_GROUP_TYPE.LVM_VG),
)
uri = get_volume_groups_uri(node)
response = self.client.get(uri)
self.assertEqual(http.client.OK, response.status_code,
response.content)
expected_ids = [vg.id for vg in volume_groups]
result_ids = [
vg["id"] for vg in json.loads(
response.content.decode(settings.DEFAULT_CHARSET))
]
self.assertItemsEqual(expected_ids, result_ids)
def test_read(self):
node = factory.make_Node()
bcaches = [
factory.make_FilesystemGroup(
node=node, group_type=FILESYSTEM_GROUP_TYPE.BCACHE
)
for _ in range(3)
]
# Not bcache. Should not be in the output.
for _ in range(3):
factory.make_FilesystemGroup(
node=node,
group_type=factory.pick_enum(
FILESYSTEM_GROUP_TYPE, but_not=FILESYSTEM_GROUP_TYPE.BCACHE
),
)
uri = get_bcache_devices_uri(node)
response = self.client.get(uri)
self.assertEqual(
http.client.OK, response.status_code, response.content
)
expected_ids = [bcache.id for bcache in bcaches]
result_ids = [
bcache["id"] for bcache in json_load_bytes(response.content)
]
self.assertItemsEqual(expected_ids, result_ids)
def test_read_404_when_not_bcache(self):
not_bcache = factory.make_FilesystemGroup(group_type=factory.pick_enum(
FILESYSTEM_GROUP_TYPE, but_not=FILESYSTEM_GROUP_TYPE.BCACHE))
uri = get_bcache_device_uri(not_bcache)
response = self.client.get(uri)
self.assertEqual(http.client.NOT_FOUND, response.status_code,
response.content)
def make_device_with_ip_address(
self, ip_assignment=None, owner=None):
"""The `DEVICE_IP_ASSIGNMENT` is based on what data exists in the model
for a device. This will setup the model to make sure the device will
match `ip_assignment`."""
if ip_assignment is None:
ip_assignment = factory.pick_enum(DEVICE_IP_ASSIGNMENT_TYPE)
if owner is None:
owner = factory.make_User()
device = factory.make_Node(
node_type=NODE_TYPE.DEVICE,
interface=True, owner=owner)
interface = device.get_boot_interface()
if ip_assignment == DEVICE_IP_ASSIGNMENT_TYPE.EXTERNAL:
subnet = factory.make_Subnet()
factory.make_StaticIPAddress(
alloc_type=IPADDRESS_TYPE.USER_RESERVED,
ip=factory.pick_ip_in_network(subnet.get_ipnetwork()),
subnet=subnet, user=owner)
elif ip_assignment == DEVICE_IP_ASSIGNMENT_TYPE.DYNAMIC:
factory.make_StaticIPAddress(
alloc_type=IPADDRESS_TYPE.DHCP, ip="", interface=interface)
else:
subnet = factory.make_Subnet(vlan=interface.vlan)
factory.make_StaticIPAddress(
alloc_type=IPADDRESS_TYPE.STICKY,
ip=factory.pick_ip_in_Subnet(subnet),
interface=interface, subnet=subnet)
return device
def test_link_subnet_calls_link_subnet_if_not_link_id(self):
user = factory.make_admin()
node = factory.make_Node(node_type=NODE_TYPE.DEVICE)
handler = DeviceHandler(user, {})
interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
subnet = factory.make_Subnet()
ip_assignment = factory.pick_enum(DEVICE_IP_ASSIGNMENT_TYPE)
if ip_assignment == DEVICE_IP_ASSIGNMENT_TYPE.STATIC:
mode = INTERFACE_LINK_TYPE.STATIC
elif ip_assignment == DEVICE_IP_ASSIGNMENT_TYPE.DYNAMIC:
mode = INTERFACE_LINK_TYPE.DHCP
else:
mode = INTERFACE_LINK_TYPE.LINK_UP
ip_address = factory.make_ip_address()
self.patch_autospec(Interface, "link_subnet")
handler.link_subnet({
"system_id": node.system_id,
"interface_id": interface.id,
"subnet": subnet.id,
"ip_assignment": ip_assignment,
"ip_address": ip_address,
})
if ip_assignment == DEVICE_IP_ASSIGNMENT_TYPE.STATIC:
self.assertThat(
Interface.link_subnet,
MockCalledOnceWith(
ANY, mode, subnet, ip_address=ip_address))
else:
self.assertThat(Interface.link_subnet, MockNotCalled())
def test_update_interface_updates(self):
user = factory.make_admin()
node = factory.make_Node(interface=False, node_type=NODE_TYPE.DEVICE)
handler = DeviceHandler(user, {})
name = factory.make_name("eth")
mac_address = factory.make_mac_address()
ip_assignment = factory.pick_enum(DEVICE_IP_ASSIGNMENT_TYPE)
params = {
"system_id": node.system_id,
"name": name,
"mac_address": mac_address,
"ip_assignment": ip_assignment,
}
if ip_assignment == DEVICE_IP_ASSIGNMENT_TYPE.STATIC:
subnet = factory.make_Subnet()
params['subnet'] = subnet.id
ip_address = str(IPAddress(IPNetwork(subnet.cidr).first))
params['ip_address'] = ip_address
elif ip_assignment == DEVICE_IP_ASSIGNMENT_TYPE.EXTERNAL:
ip_address = factory.make_ip_address()
params['ip_address'] = ip_address
handler.create_interface(params)
interface = node.interface_set.first()
self.assertIsNotNone(interface)
new_name = factory.make_name("eth")
new_ip_assignment = factory.pick_enum(DEVICE_IP_ASSIGNMENT_TYPE)
new_params = {
"system_id": node.system_id,
"interface_id": interface.id,
"name": new_name,
"mac_address": mac_address,
"ip_assignment": new_ip_assignment,
}
if new_ip_assignment == DEVICE_IP_ASSIGNMENT_TYPE.STATIC:
new_subnet = factory.make_Subnet()
new_params['subnet'] = new_subnet.id
new_ip_address = str(IPAddress(IPNetwork(new_subnet.cidr).first))
new_params['ip_address'] = new_ip_address
elif new_ip_assignment == DEVICE_IP_ASSIGNMENT_TYPE.EXTERNAL:
new_ip_address = factory.make_ip_address()
new_params['ip_address'] = new_ip_address
handler.update_interface(new_params)
data = self.dehydrate_device(node, user)['interfaces']
self.assertEqual(1, len(data))
self.assertEqual(data[0]['ip_assignment'], new_ip_assignment)
if new_ip_assignment != DEVICE_IP_ASSIGNMENT_TYPE.DYNAMIC:
self.assertEqual(data[0]['ip_address'], new_ip_address)
def test_deletes_filesystem_group_when_virtual_block_device_deleted(self):
filesystem_group = factory.make_FilesystemGroup(
group_type=factory.pick_enum(
FILESYSTEM_GROUP_TYPE, but_not=FILESYSTEM_GROUP_TYPE.LVM_VG
)
)
filesystem_group.virtual_device.delete()
self.assertIsNone(reload_object(filesystem_group))
def test_pick_enum_returns_enum_value(self):
random_value = random.randint(0, 99999)
class Enum:
VALUE = random_value
OTHER_VALUE = random_value + 3
self.assertIn(factory.pick_enum(Enum), [Enum.VALUE, Enum.OTHER_VALUE])
def test_get_name_returns_just_name(self):
filesystem_group = factory.make_FilesystemGroup(
group_type=factory.pick_enum(
FILESYSTEM_GROUP_TYPE, but_not=FILESYSTEM_GROUP_TYPE.LVM_VG
)
)
virtual_device = filesystem_group.virtual_device
self.assertEqual(virtual_device.name, virtual_device.get_name())
def test_read_404_when_not_volume_group(self):
not_volume_group = factory.make_FilesystemGroup(
group_type=factory.pick_enum(FILESYSTEM_GROUP_TYPE,
but_not=FILESYSTEM_GROUP_TYPE.LVM_VG))
uri = get_volume_group_uri(not_volume_group)
response = self.client.get(uri)
self.assertEqual(http.client.NOT_FOUND, response.status_code,
response.content)
def make_complete_boot_resource_set(self, resource):
resource_set = factory.make_BootResourceSet(resource)
filename = factory.make_name('name')
filetype = factory.pick_enum(BOOT_RESOURCE_FILE_TYPE)
largefile = factory.make_LargeFile()
factory.make_BootResourceFile(
resource_set, largefile, filename=filename, filetype=filetype)
return resource_set
def test_DELETE_404_when_not_vmfs(self):
self.become_admin()
node = factory.make_Machine(status=NODE_STATUS.READY)
not_vmfs = factory.make_FilesystemGroup(
node=node,
group_type=factory.pick_enum(FILESYSTEM_GROUP_TYPE,
but_not=FILESYSTEM_GROUP_TYPE.VMFS6))
response = self.client.delete(self.get_vmfs_uri(not_vmfs))
self.assertThat(response, HasStatusCode(http.client.NOT_FOUND))
def test__updates_filesystem_group_name_when_not_volume_group(self):
filesystem_group = factory.make_FilesystemGroup(
group_type=factory.pick_enum(FILESYSTEM_GROUP_TYPE,
but_not=FILESYSTEM_GROUP_TYPE.LVM_VG))
virtual_device = filesystem_group.virtual_device
newname = factory.make_name("name")
virtual_device.name = newname
virtual_device.save()
self.assertEqual(newname, reload_object(filesystem_group).name)
def test_delete_returns_409_when_the_nodes_not_ready(self):
self.become_admin()
node = factory.make_Node(
status=factory.pick_enum(NODE_STATUS, but_not=[NODE_STATUS.READY]))
block_device = factory.make_VirtualBlockDevice(node=node)
uri = get_blockdevice_uri(block_device)
response = self.client.delete(uri)
self.assertEqual(http.client.CONFLICT, response.status_code,
response.content)
def test_delete_returns_409_for_not_ready_node(self):
self.become_admin()
node = factory.make_Node(
status=factory.pick_enum(NODE_STATUS, but_not=[NODE_STATUS.READY]))
partition = self.make_partition(node)
uri = get_partition_uri(partition)
response = self.client.delete(uri)
self.assertEqual(http.client.CONFLICT, response.status_code,
response.content)
def make_service(self, service_name, status=None, status_info=None):
if status is None:
status = factory.pick_enum(SERVICE_STATUS)
if status_info is None:
status_info = factory.make_name("status_info")
return {
"name": service_name,
"status": status,
"status_info": status_info,
}
def test_unmount_returns_409_if_not_allocated_or_ready(self):
status = factory.pick_enum(
NODE_STATUS, but_not=[NODE_STATUS.READY, NODE_STATUS.ALLOCATED])
node = factory.make_Node(status=status, owner=self.user)
block_device = factory.make_VirtualBlockDevice(node=node)
factory.make_Filesystem(block_device=block_device, mount_point="/mnt")
uri = get_blockdevice_uri(block_device)
response = self.client.post(uri, {"op": "unmount"})
self.assertEqual(http.client.CONFLICT, response.status_code,
response.content)
def test_delete_logical_volume_404_when_not_volume_group(self):
self.become_admin()
node = factory.make_Node(status=NODE_STATUS.READY)
not_volume_group = factory.make_FilesystemGroup(
node=node, group_type=factory.pick_enum(
FILESYSTEM_GROUP_TYPE, but_not=FILESYSTEM_GROUP_TYPE.LVM_VG))
uri = get_volume_group_uri(not_volume_group)
response = self.client.post(uri, {"op": "delete_logical_volume"})
self.assertEqual(
http.client.NOT_FOUND, response.status_code, response.content)
def test_unmount_returns_409_if_not_allocated_or_ready(self):
self.become_admin()
status = factory.pick_enum(
NODE_STATUS, but_not=[NODE_STATUS.READY, NODE_STATUS.ALLOCATED])
node = factory.make_Node(status=status, owner=self.user)
partition = self.make_partition(node)
factory.make_Filesystem(partition=partition, mount_point="/mnt")
uri = get_partition_uri(partition)
response = self.client.post(uri, {"op": "unmount"})
self.assertEqual(http.client.CONFLICT, response.status_code,
response.content)
def test_delete_404_when_not_bcache(self):
self.become_admin()
node = factory.make_Node(status=NODE_STATUS.READY)
not_bcache = factory.make_FilesystemGroup(
node=node,
group_type=factory.pick_enum(FILESYSTEM_GROUP_TYPE,
but_not=FILESYSTEM_GROUP_TYPE.BCACHE))
uri = get_bcache_device_uri(not_bcache)
response = self.client.delete(uri)
self.assertEqual(http.client.NOT_FOUND, response.status_code,
response.content)
def test_pick_enum_can_exclude_choices(self):
random_value = random.randint(0, 99999)
class Enum:
FIRST_VALUE = random_value
SECOND_VALUE = random_value + 1
THIRD_VALUE = random_value + 2
self.assertEqual(
Enum.FIRST_VALUE,
factory.pick_enum(Enum,
but_not=(Enum.SECOND_VALUE, Enum.THIRD_VALUE)))
def test_update_returns_409_for_non_ready_node(self):
"""Check update block device with a virtual one fails for a normal
user."""
self.become_admin()
node = factory.make_Node(
status=factory.pick_enum(NODE_STATUS, but_not=[NODE_STATUS.READY]))
newname = factory.make_name("lv")
block_device = factory.make_VirtualBlockDevice(node=node)
uri = get_blockdevice_uri(block_device)
response = self.client.put(uri, {"name": newname})
self.assertEqual(http.client.CONFLICT, response.status_code,
response.content)
def test_remove_tag_returns_409_when_the_nodes_not_ready(self):
self.become_admin()
node = factory.make_Node(
status=factory.pick_enum(NODE_STATUS, but_not=[NODE_STATUS.READY]))
block_device = factory.make_PhysicalBlockDevice(node=node)
uri = get_blockdevice_uri(block_device)
response = self.client.post(uri, {
"op": "remove_tag",
"tag": factory.make_name("tag")
})
self.assertEqual(http.client.CONFLICT, response.status_code,
response.content)
def test_get_parents_finds_devices(self):
node = factory.make_Node()
factory.make_FilesystemGroup(node=node,
group_type=factory.pick_enum(
FILESYSTEM_GROUP_TYPE,
but_not=FILESYSTEM_GROUP_TYPE.LVM_VG))
fs_group_disks = [
block_device.blockdevice_ptr
for block_device in node.physicalblockdevice_set.all()
if not block_device.is_boot_disk()
]
virtualblockdevice = node.virtualblockdevice_set.first()
self.assertEqual(len(fs_group_disks),
len(virtualblockdevice.get_parents()))
def test_format_returns_409_if_not_allocated_or_ready(self):
status = factory.pick_enum(
NODE_STATUS, but_not=[NODE_STATUS.READY, NODE_STATUS.ALLOCATED])
node = factory.make_Node(status=status, owner=self.user)
block_device = factory.make_VirtualBlockDevice(node=node)
fstype = factory.pick_filesystem_type()
fsuuid = "%s" % uuid.uuid4()
uri = get_blockdevice_uri(block_device)
response = self.client.post(uri, {
"op": "format",
"fstype": fstype,
"uuid": fsuuid
})
self.assertEqual(http.client.CONFLICT, response.status_code,
response.content)
def test__errors_if_node_cannot_be_found(self):
system_id = factory.make_name('unknown-system-id')
power_state = factory.pick_enum(POWER_STATE)
d = call_responder(
Region(), UpdateNodePowerState,
{'system_id': system_id, 'power_state': power_state})
def check(error):
self.assertIsInstance(error, Failure)
self.assertIsInstance(error.value, NoSuchNode)
# The error message contains a reference to system_id.
self.assertIn(system_id, str(error.value))
return d.addErrback(check)
def test_list_num_queries_is_independent_of_num_devices(self):
owner = factory.make_User()
handler = DeviceHandler(owner, {})
ip_assignment = factory.pick_enum(DEVICE_IP_ASSIGNMENT_TYPE)
self.make_devices(10, owner=owner, ip_assignment=ip_assignment)
query_10_count, _ = count_queries(handler.list, {})
self.make_devices(10, owner=owner, ip_assignment=ip_assignment)
query_20_count, _ = count_queries(handler.list, {})
# This check is to notify the developer that a change was made that
# affects the number of queries performed when doing a node listing.
# It is important to keep this number as low as possible. A larger
# number means regiond has to do more work slowing down its process
# and slowing down the client waiting for the response.
self.assertEqual(
query_10_count, query_20_count,
"Number of queries is not independent to the number of nodes.")
def test_mount_returns_409_if_not_allocated_or_ready(self):
self.become_admin()
status = factory.pick_enum(
NODE_STATUS, but_not=[NODE_STATUS.READY, NODE_STATUS.ALLOCATED])
node = factory.make_Node(status=status, owner=self.user)
block_device = factory.make_PhysicalBlockDevice(node=node)
partition_table = factory.make_PartitionTable(
block_device=block_device)
partition = partition_table.add_partition()
factory.make_Filesystem(
partition=partition)
uri = get_partition_uri(partition)
mount_point = '/mnt'
response = self.client.post(
uri, {'op': 'mount', 'mount_point': mount_point})
self.assertEqual(
http.client.CONFLICT, response.status_code, response.content)
def test_format_returns_409_if_not_allocated_or_ready(self):
self.become_admin()
status = factory.pick_enum(
NODE_STATUS, but_not=[NODE_STATUS.READY, NODE_STATUS.ALLOCATED])
node = factory.make_Node(status=status, owner=self.user)
partition = self.make_partition(node)
uri = get_partition_uri(partition)
fs_uuid = str(uuid4())
fstype = factory.pick_filesystem_type()
response = self.client.post(uri, {
'op': 'format',
'uuid': fs_uuid,
'fstype': fstype,
'label': 'mylabel',
})
self.assertEqual(
http.client.CONFLICT, response.status_code, response.content)
