def test_interface_attach_detach(self):
min_kbps = 1000
min_kpps = 100
policy = self._create_qos_policy_with_bw_and_pps_rules(
min_kbps, min_kpps)
port = self._create_port_with_qos_policy(policy=None)
port2 = self._create_port_with_qos_policy(policy=policy)
server = self.create_server(networks=[{
'port': port['id']
}],
wait_until='ACTIVE')
self.assert_allocations(server, port, 0, 0)
self.interface_client.create_interface(server_id=server['id'],
port_id=port2['id'])
waiters.wait_for_interface_status(self.interface_client, server['id'],
port2['id'], 'ACTIVE')
self.assert_allocations(server, port2, min_kbps, min_kpps)
req_id = self.interface_client.delete_interface(
server_id=server['id'],
port_id=port2['id']).response['x-openstack-request-id']
waiters.wait_for_interface_detach(self.servers_client, server['id'],
port2['id'], req_id)
self.assert_allocations(server, port2, 0, 0)
def test_tagged_attachment(self):
# Create network
net = self.networks_client.create_network(
name=data_utils.rand_name(
'tagged-attachments-test-net'))['network']
self.addCleanup(self.networks_client.delete_network, net['id'])
# Create subnet
subnet = self.subnets_client.create_subnet(
network_id=net['id'],
cidr='10.10.10.0/24',
ip_version=4)['subnet']
self.addCleanup(self.subnets_client.delete_subnet, subnet['id'])
# Create volume
volume = self.create_volume()
# Boot test server
config_drive_enabled = CONF.compute_feature_enabled.config_drive
validation_resources = self.get_test_validation_resources(
self.os_primary)
server = self.create_test_server(
validatable=True,
validation_resources=validation_resources,
config_drive=config_drive_enabled,
name=data_utils.rand_name('device-tagging-server'),
networks=[{'uuid': self.get_tenant_network()['id']}],
wait_until='ACTIVE')
self.addCleanup(self.delete_server, server['id'])
# NOTE(mgoddard): Get detailed server to ensure addresses are present
# in fixed IP case.
server = self.servers_client.show_server(server['id'])['server']
# Attach tagged nic and volume
interface = self.interfaces_client.create_interface(
server['id'], net_id=net['id'],
tag='nic-tag')['interfaceAttachment']
self.attach_volume(server, volume, tag='volume-tag')
ssh_client = remote_client.RemoteClient(
self.get_server_ip(server, validation_resources),
CONF.validation.image_ssh_user,
pkey=validation_resources['keypair']['private_key'],
server=server,
servers_client=self.servers_client)
self.verify_metadata_from_api(server, ssh_client,
self.verify_device_metadata)
# Detach tagged nic and volume
self.servers_client.detach_volume(server['id'], volume['id'])
waiters.wait_for_volume_resource_status(self.volumes_client,
volume['id'], 'available')
self.interfaces_client.delete_interface(server['id'],
interface['port_id'])
waiters.wait_for_interface_detach(self.interfaces_client,
server['id'],
interface['port_id'])
def test_delete_interface(self):
"""Test delete interface, part of os-attach-interfaces."""
interface = self._attach_interface_to_server()
with self.override_role():
self.interfaces_client.delete_interface(self.server['id'],
interface['port_id'])
waiters.wait_for_interface_detach(self.interfaces_client,
self.server['id'],
interface['port_id'])
def test_wait_for_interface_detach(self):
self.client.list_interfaces.side_effect = [
self._two_interfaces(),
self._one_interface()
]
with mock.patch.object(time, 'sleep') as sleep_mock:
start_time = int(time.time())
waiters.wait_for_interface_detach(self.client, 'server_id',
'port_two')
end_time = int(time.time())
self.assertLess(end_time, (start_time + self.client.build_timeout))
sleep_mock.assert_called_once_with(self.client.build_interval)
def test_delete_interface(self):
"""Test delete interface, part of os-attach-interfaces."""
interface = self._attach_interface_to_server()
with self.override_role():
req_id = self.interfaces_client.delete_interface(
self.server['id'], interface['port_id'])
try:
# interface may be not found - we need to ignore that
waiters.wait_for_interface_detach(self.servers_admin_client,
self.server['id'],
interface['port_id'], req_id)
except lib_exc.NotFound:
pass
def test_wait_for_interface_detach(self):
no_event = {
'instanceAction': {
'events': []
}
}
one_event_without_result = {
'instanceAction': {
'events': [
{
'event': 'compute_detach_interface',
'result': None
}
]
}
}
one_event_successful = {
'instanceAction': {
'events': [
{
'event': 'compute_detach_interface',
'result': 'Success'
}
]
}
}
show_instance_action = mock.MagicMock(
# there is an extra call to return the result from the waiter
side_effect=[
no_event,
one_event_without_result,
one_event_successful,
one_event_successful,
]
)
client = self.mock_client(show_instance_action=show_instance_action)
self.patch('time.time', return_value=0.)
sleep = self.patch('time.sleep')
result = waiters.wait_for_interface_detach(
client, mock.sentinel.server_id, mock.sentinel.port_id,
mock.sentinel.detach_request_id
)
self.assertIs(one_event_successful['instanceAction'], result)
show_instance_action.assert_has_calls(
# there is an extra call to return the result from the waiter
[
mock.call(
mock.sentinel.server_id, mock.sentinel.detach_request_id)
] * 4
)
sleep.assert_has_calls([mock.call(client.build_interval)] * 2)
def test_wait_for_interface_detach(self):
list_interfaces = mock.MagicMock(
side_effect=[self.two_interfaces, self.one_interface])
client = self.mock_client(list_interfaces=list_interfaces)
self.patch('time.time', return_value=0.)
sleep = self.patch('time.sleep')
result = waiters.wait_for_interface_detach(
client, 'server_id', 'port_two')
self.assertIs(self.one_interface['interfaceAttachments'], result)
list_interfaces.assert_has_calls([mock.call('server_id'),
mock.call('server_id')])
sleep.assert_called_once_with(client.build_interval)
def _delete_and_wait_for_interface_detach(self, server_id, port_id):
req_id = self.interfaces_client.delete_interface(
server_id, port_id).response['x-openstack-request-id']
waiters.wait_for_interface_detach(self.servers_admin_client, server_id,
port_id, req_id)
