def test_create_server_with_timeout(self):
"""
Test that a timeout while waiting for the server to spawn raises an
exception in create_server.
"""
with patch("shade.OpenStackCloud"):
fake_server = fakes.FakeServer('1234', '', 'BUILD')
config = {
"servers.create.return_value": fake_server,
"servers.get.return_value": fake_server,
"servers.list.return_value": [fake_server],
}
OpenStackCloud.nova_client = Mock(**config)
self.assertRaises(
OpenStackCloudTimeout,
self.client.create_server,
'server-name', 'image-id', 'flavor-id', wait=True, timeout=1)
def test_get_server_cloud_rackspace_v6(
self, mock_list_networks, mock_has_service, mock_get_flavor_name,
mock_get_image_name, mock_list_server_security_groups,
mock_list_subnets, mock_list_floating_ips):
self.cloud._floating_ip_source = None
self.cloud.force_ipv4 = False
self.cloud._local_ipv6 = True
mock_get_image_name.return_value = 'cirros-0.3.4-x86_64-uec'
mock_get_flavor_name.return_value = 'm1.tiny'
mock_has_service.return_value = False
srv = self.cloud.get_openstack_vars(
meta.obj_to_dict(
fakes.FakeServer(
id='test-id',
name='test-name',
status='ACTIVE',
flavor={u'id': u'1'},
image={
'name': u'cirros-0.3.4-x86_64-uec',
u'id': u'f93d000b-7c29-4489-b375-3641a1758fe1'
},
addresses={
'private': [{
'addr': "10.223.160.141",
'version': 4
}],
'public': [{
'addr': "104.130.246.91",
'version': 4
}, {
'addr': "2001:4800:7819:103:be76:4eff:fe05:8525",
'version': 6
}]
})))
self.assertEqual("10.223.160.141", srv['private_v4'])
self.assertEqual("104.130.246.91", srv['public_v4'])
self.assertEqual("2001:4800:7819:103:be76:4eff:fe05:8525",
srv['public_v6'])
self.assertEqual("2001:4800:7819:103:be76:4eff:fe05:8525",
srv['interface_ip'])
mock_list_subnets.assert_not_called()
mock_list_networks.assert_not_called()
mock_list_floating_ips.assert_not_called()
def setUp(self):
super(TestFloatingIP, self).setUp()
self.floating_ips = [
fakes.FakeFloatingIP(**ip) for ip in self.mock_floating_ip_list_rep
]
self.fake_server = meta.obj_to_dict(
fakes.FakeServer(
'server-id', '', 'ACTIVE',
addresses={u'test_pnztt_net': [{
u'OS-EXT-IPS:type': u'fixed',
u'addr': '192.0.2.129',
u'version': 4,
u'OS-EXT-IPS-MAC:mac_addr':
u'fa:16:3e:ae:7d:42'}]}))
self.floating_ip = _utils.normalize_nova_floating_ips(
meta.obj_list_to_dict(self.floating_ips))[0]
def test_list_hosts_no_detail(self, mock_cloud, mock_add, mock_config):
mock_config.return_value.get_all_clouds.return_value = [{}]
inv = inventory.OpenStackInventory()
server = _utils.normalize_server(meta.obj_to_dict(
fakes.FakeServer('1234', 'test', 'ACTIVE', addresses={})),
region_name='',
cloud_name='')
self.assertIsInstance(inv.clouds, list)
self.assertEqual(1, len(inv.clouds))
inv.clouds[0].list_servers.return_value = [server]
inv.list_hosts(expand=False)
inv.clouds[0].list_servers.assert_called_once_with()
self.assertFalse(inv.clouds[0].get_openstack_vars.called)
mock_add.assert_called_once_with(inv.clouds[0], server)
def test_rebuild_server_timeout(self):
"""
Test that a timeout while waiting for the server to rebuild raises an
exception in rebuild_server.
"""
rebuild_server = fakes.FakeServer('1234', '', 'REBUILD')
with patch("shade.OpenStackCloud"):
config = {
"servers.rebuild.return_value": rebuild_server,
"servers.list.return_value": [rebuild_server],
}
OpenStackCloud.nova_client = Mock(**config)
self.assertRaises(OpenStackCloudTimeout,
self.cloud.rebuild_server,
"a",
"b",
wait=True,
timeout=0.001)
def test_rebuild_server_with_admin_pass_no_wait(self):
"""
Test that a server with an admin_pass passed returns the password
"""
with patch("shade.OpenStackCloud"):
rebuild_server = fakes.FakeServer('1234',
'',
'REBUILD',
adminPass='******')
config = {
"servers.rebuild.return_value": rebuild_server,
}
OpenStackCloud.nova_client = Mock(**config)
self.assertEqual(
meta.obj_to_dict(rebuild_server),
self.cloud.rebuild_server('a',
'b',
admin_pass='******'))
def test_get_server_external_ipv4_nova_none(self, mock_get_server_ip,
mock_has_service):
# Testing Clouds w/o Neutron and a globally routable IP
mock_has_service.return_value = False
mock_get_server_ip.return_value = None
srv = meta.obj_to_dict(
fakes.FakeServer(id='test-id',
name='test-name',
status='ACTIVE',
addresses={'test-net': [{
'addr': PRIVATE_V4
}]}))
ip = meta.get_server_external_ipv4(
cloud=shade.openstack_cloud(validate=False), server=srv)
self.assertIsNone(ip)
self.assertTrue(mock_get_server_ip.called)
def test_get_server_multiple_private_ip(self):
self.register_uris([
dict(
method='GET',
uri='https://network.example.com/v2.0/networks.json',
json={'networks': [{
'id': 'test-net-id',
'name': 'test-net'
}]}),
dict(method='GET',
uri='https://network.example.com/v2.0/subnets.json',
json={'subnets': SUBNETS_WITH_NAT})
])
shared_mac = '11:22:33:44:55:66'
distinct_mac = '66:55:44:33:22:11'
srv = meta.obj_to_dict(
fakes.FakeServer(id='test-id',
name='test-name',
status='ACTIVE',
addresses={
'test-net': [{
'OS-EXT-IPS:type': 'fixed',
'OS-EXT-IPS-MAC:mac_addr': distinct_mac,
'addr': '10.0.0.100',
'version': 4
}, {
'OS-EXT-IPS:type': 'fixed',
'OS-EXT-IPS-MAC:mac_addr': shared_mac,
'addr': '10.0.0.101',
'version': 4
}],
'public': [{
'OS-EXT-IPS:type': 'floating',
'OS-EXT-IPS-MAC:mac_addr': shared_mac,
'addr': PUBLIC_V4,
'version': 4
}]
}))
self.assertEqual('10.0.0.101',
meta.get_server_private_ip(srv, self.cloud))
self.assert_calls()
def test_get_server_external_ipv4_neutron_exception(self):
# Testing Clouds with a non working Neutron
self.register_uri('GET',
'https://network.example.com/v2.0/networks.json',
status_code=404)
srv = meta.obj_to_dict(
fakes.FakeServer(
id='test-id',
name='test-name',
status='ACTIVE',
addresses={'public': [{
'addr': PUBLIC_V4,
'version': 4
}]}))
ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv)
self.assertEqual(PUBLIC_V4, ip)
self.assert_calls()
def test_create_server_no_wait(self):
"""
Test that create_server with no wait and no exception in the
novaclient create call returns the server instance.
"""
with patch("shade.OpenStackCloud"):
fake_server = fakes.FakeServer('1234', '', 'BUILD')
config = {
"servers.create.return_value": fake_server,
"servers.get.return_value": fake_server
}
OpenStackCloud.nova_client = Mock(**config)
self.assertEqual(
_utils.normalize_server(meta.obj_to_dict(fake_server),
cloud_name=self.client.name,
region_name=self.client.region_name),
self.client.create_server(name='server-name',
image='image=id',
flavor='flavor-id'))
def test_delete_server_fails(self, nova_mock):
"""
Test that delete_server wraps novaclient exceptions
"""
nova_mock.servers.list.return_value = [fakes.FakeServer('1212',
'speedy',
'ACTIVE')]
for fail in self.novaclient_exceptions:
def _raise_fail(server):
raise fail(code=fail.http_status)
nova_mock.servers.delete.side_effect = _raise_fail
exc = self.assertRaises(shade_exc.OpenStackCloudException,
self.cloud.delete_server, 'speedy',
wait=False)
# Note that message is deprecated from Exception, but not in
# the novaclient exceptions.
self.assertIn(fail.message, str(exc))
def test_get_server_external_ipv4_neutron(
self, mock_search_networks,
mock_has_service):
# Testing Clouds with Neutron
mock_has_service.return_value = True
mock_search_networks.return_value = [{
'id': 'test-net-id',
'name': 'test-net'
}]
srv = meta.obj_to_dict(fakes.FakeServer(
id='test-id', name='test-name', status='ACTIVE',
addresses={'test-net': [{
'addr': PUBLIC_V4,
'version': 4}]},
))
ip = meta.get_server_external_ipv4(
cloud=shade.openstack_cloud(validate=False), server=srv)
self.assertEqual(PUBLIC_V4, ip)
def test_create_server_no_wait(self):
"""
Test that create_server with no wait and no exception in the
novaclient create call returns the server instance.
"""
with patch("shade.OpenStackCloud.nova_client"):
fake_server = fakes.FakeServer('1234', '', 'BUILD')
fake_floating_ip = fakes.FakeFloatingIP('1234', 'ippool',
'1.1.1.1', '2.2.2.2',
'5678')
config = {
"servers.create.return_value": fake_server,
"servers.get.return_value": fake_server,
"floating_ips.list.return_value": [fake_floating_ip]
}
OpenStackCloud.nova_client = Mock(**config)
self.assertEqual(
self.cloud._normalize_server(meta.obj_to_dict(fake_server)),
self.cloud.create_server(name='server-name',
image=dict(id='image=id'),
flavor=dict(id='flavor-id')))
def setUp(self):
super(TestFloatingIP, self).setUp()
self.fake_server = meta.obj_to_dict(
fakes.FakeServer('server-id',
'',
'ACTIVE',
addresses={
u'test_pnztt_net': [{
u'OS-EXT-IPS:type':
u'fixed',
u'addr':
'192.0.2.129',
u'version':
4,
u'OS-EXT-IPS-MAC:mac_addr':
u'fa:16:3e:ae:7d:42'
}]
}))
self.floating_ip = self.cloud._normalize_floating_ips(
self.mock_floating_ip_list_rep['floatingips'])[0]
def test_delete_server_wait_for_notfound(self, nova_mock):
"""
Test that delete_server waits for NotFound from novaclient
"""
server = fakes.FakeServer('9999', 'wily', 'ACTIVE')
nova_mock.servers.list.return_value = [server]
def _delete_wily(*args, **kwargs):
self.assertIn('server', kwargs)
self.assertEqual('9999', kwargs['server'])
nova_mock.servers.list.return_value = []
def _raise_notfound(*args, **kwargs):
self.assertIn('server', kwargs)
self.assertEqual('9999', kwargs['server'])
raise nova_exc.NotFound(code='404')
nova_mock.servers.get.side_effect = _raise_notfound
nova_mock.servers.delete.side_effect = _delete_wily
self.cloud.delete_server('wily', wait=True)
nova_mock.servers.delete.assert_called_with(server=server.id)
def test_get_server_external_ipv4_nova_public(
self, mock_is_globally_routable_ipv4, mock_get_server_ip,
mock_has_service):
# Testing Clouds w/o Neutron and a network named public
mock_has_service.return_value = False
mock_get_server_ip.return_value = None
mock_is_globally_routable_ipv4.return_value = True
srv = meta.obj_to_dict(
fakes.FakeServer(id='test-id',
name='test-name',
status='ACTIVE',
addresses={'test-net': [{
'addr': PUBLIC_V4
}]}))
ip = meta.get_server_external_ipv4(cloud=shade.openstack_cloud(),
server=srv)
self.assertEqual(PUBLIC_V4, ip)
self.assertTrue(mock_get_server_ip.called)
self.assertTrue(mock_is_globally_routable_ipv4.called)
def setUp(self):
super(TestFloatingIP, self).setUp()
self.fake_server = meta.obj_to_munch(
fakes.FakeServer('server-id',
'',
'ACTIVE',
addresses={
u'test_pnztt_net': [{
u'OS-EXT-IPS:type':
u'fixed',
u'addr':
'192.0.2.129',
u'version':
4,
u'OS-EXT-IPS-MAC:mac_addr':
u'fa:16:3e:ae:7d:42'
}]
}))
self.cloud.has_service = get_fake_has_service(self.cloud.has_service)
def test_get_server_private_ip_devstack(
self, mock_search_networks, mock_has_service,
mock_get_flavor_name, mock_get_image_name,
mock_list_server_security_groups):
mock_get_image_name.return_value = 'cirros-0.3.4-x86_64-uec'
mock_get_flavor_name.return_value = 'm1.tiny'
mock_has_service.return_value = True
mock_search_networks.return_value = [
{
'id': 'test_pnztt_net',
'name': 'test_pnztt_net'
},
{
'id': 'private',
'name': 'private',
},
]
cloud = shade.openstack_cloud(validate=False)
srv = cloud.get_openstack_vars(meta.obj_to_dict(fakes.FakeServer(
id='test-id', name='test-name', status='ACTIVE',
flavor={u'id': u'1'},
image={
'name': u'cirros-0.3.4-x86_64-uec',
u'id': u'f93d000b-7c29-4489-b375-3641a1758fe1'},
addresses={u'test_pnztt_net': [{
u'OS-EXT-IPS:type': u'fixed',
u'addr': PRIVATE_V4,
u'version': 4,
u'OS-EXT-IPS-MAC:mac_addr':
u'fa:16:3e:ae:7d:42'
}]}
)))
self.assertEqual(PRIVATE_V4, srv['private_v4'])
mock_has_service.assert_called_with('volume')
mock_search_networks.assert_called_with(
filters={'router:external': False}
)
def test_add_bad_security_group_to_server_neutron(self):
# fake to get server by name, server-name must match
fake_server = fakes.FakeServer('1234', 'server-name', 'ACTIVE')
# use neutron for secgroup list and return an existing fake
self.cloud.secgroup_source = 'neutron'
self.register_uris([
dict(method='GET',
uri=self.get_mock_url('compute',
'public',
append=['servers', 'detail']),
json={'servers': [meta.obj_to_munch(fake_server)]}),
dict(method='GET',
uri=self.get_mock_url('network',
'public',
append=['v2.0',
'security-groups.json']),
json={'security_groups': [neutron_grp_dict]})
])
self.assertFalse(
self.cloud.add_server_security_groups('server-name',
'unknown-sec-group'))
self.assert_calls()
def test_add_bad_security_group_to_server_nova(self):
# fake to get server by name, server-name must match
fake_server = meta.obj_to_munch(
fakes.FakeServer('1234', 'server-name', 'ACTIVE'))
# use nova for secgroup list and return an existing fake
self.has_neutron = False
self.cloud.secgroup_source = 'nova'
self.register_uris([
dict(method='GET',
uri='{endpoint}/servers/detail'.format(
endpoint=fakes.COMPUTE_ENDPOINT),
json={'servers': [fake_server]}),
dict(method='GET',
uri='{endpoint}/os-security-groups'.format(
endpoint=fakes.COMPUTE_ENDPOINT),
json={'security_groups': [nova_grp_dict]}),
])
ret = self.cloud.add_server_security_groups('server-name',
'unknown-sec-group')
self.assertFalse(ret)
self.assert_calls()
def test_create_server_no_wait(self, mock_nova):
"""
Test that create_server with no wait and no exception in the
novaclient create call returns the server instance.
"""
fake_server = fakes.FakeServer('1234', '', 'BUILD')
fake_floating_ip = fakes.FakeFloatingIP('1234', 'ippool', '1.1.1.1',
'2.2.2.2', '5678')
mock_nova.servers.create.return_value = fake_server
mock_nova.servers.get.return_value = fake_server
self.register_uris([
dict(method='GET',
uri=self.get_mock_url('network',
'public',
append=['v2.0', 'networks.json']),
json={'networks': []}),
dict(method='GET',
uri=self.get_mock_url('network',
'public',
append=['v2.0', 'ports.json'],
qs_elements=['device_id=1234']),
json={'ports': []}),
dict(method='GET',
uri=self.get_mock_url('network',
'public',
append=['v2.0', 'floatingips.json']),
json={'floatingips': [fake_floating_ip]})
])
self.assertEqual(
self.cloud._normalize_server(meta.obj_to_dict(fake_server)),
self.cloud.create_server(name='server-name',
image=dict(id='image=id'),
flavor=dict(id='flavor-id')))
# TODO(slaweq): change do_count to True when all nova mocks will be
# replaced with request_mocks also
self.assert_calls(do_count=False)
def test_create_server_with_timeout(self, mock_nova):
"""
Test that a timeout while waiting for the server to spawn raises an
exception in create_server.
"""
fake_server = fakes.FakeServer('1234', '', 'BUILD')
self.register_uris([
dict(method='GET',
uri=self.get_mock_url('network',
'public',
append=['v2.0', 'networks.json']),
json={'networks': []})
])
mock_nova.servers.create.return_value = fake_server
mock_nova.servers.get.return_value = fake_server
mock_nova.servers.list.return_value = [fake_server]
self.assertRaises(exc.OpenStackCloudTimeout,
self.cloud.create_server,
'server-name',
dict(id='image-id'),
dict(id='flavor-id'),
wait=True,
timeout=0.01)
self.assert_calls()
def test_get_server_external_ipv4_neutron(self, mock_get_server_ip,
mock_search_networks,
mock_search_ports,
mock_has_service):
# Testing Clouds with Neutron
mock_has_service.return_value = True
mock_search_ports.return_value = [{
'network_id':
'test-net-id',
'fixed_ips': [{
'ip_address': PUBLIC_V4
}],
'device_id':
'test-id'
}]
mock_search_networks.return_value = [{'id': 'test-net-id'}]
srv = meta.obj_to_dict(
fakes.FakeServer(id='test-id', name='test-name', status='ACTIVE'))
ip = meta.get_server_external_ipv4(cloud=shade.openstack_cloud(),
server=srv)
self.assertEqual(PUBLIC_V4, ip)
self.assertFalse(mock_get_server_ip.called)
def test_get_server_private_ip(
self, mock_search_networks, mock_has_service):
mock_has_service.return_value = True
mock_search_networks.return_value = [{
'id': 'test-net-id',
'name': 'test-net-name'
}]
srv = meta.obj_to_dict(fakes.FakeServer(
id='test-id', name='test-name', status='ACTIVE',
addresses={'private': [{'OS-EXT-IPS:type': 'fixed',
'addr': PRIVATE_V4,
'version': 4}],
'public': [{'OS-EXT-IPS:type': 'floating',
'addr': PUBLIC_V4,
'version': 4}]}
))
cloud = shade.openstack_cloud(validate=False)
self.assertEqual(PRIVATE_V4, meta.get_server_private_ip(srv, cloud))
mock_has_service.assert_called_with('network')
mock_search_networks.assert_called_with(
filters={'router:external': False}
)
def get_default_network(self):
return None
standard_fake_server = fakes.FakeServer(
id='test-id-0',
name='test-id-0',
status='ACTIVE',
metadata={'group': 'test-group'},
addresses={
'private': [{
'OS-EXT-IPS:type': 'fixed',
'addr': PRIVATE_V4,
'version': 4
}],
'public': [{
'OS-EXT-IPS:type': 'floating',
'addr': PUBLIC_V4,
'version': 4
}]
},
flavor={'id': '101'},
image={'id': '471c2475-da2f-47ac-aba5-cb4aa3d546f5'},
accessIPv4='',
accessIPv6='',
)
SUBNETS_WITH_NAT = [
{
u'name': u'',
u'enable_dhcp': True,
def test_get_server_cloud_missing_fips(self, mock_get_flavor_name,
mock_get_image_name,
mock_get_volumes, mock_has_service):
mock_get_image_name.return_value = 'cirros-0.3.4-x86_64-uec'
mock_get_flavor_name.return_value = 'm1.tiny'
mock_get_volumes.return_value = []
mock_has_service.return_value = True
self.register_uris([
dict(method='GET',
uri=('https://network.example.com/v2.0/ports.json?'
'device_id=test-id'),
json={
'ports': [{
'id': 'test_port_id',
'mac_address': 'fa:16:3e:ae:7d:42',
'device_id': 'test-id'
}]
}),
dict(method='GET',
uri=('https://network.example.com/v2.0/floatingips.json'
'?port_id=test_port_id'),
json={
'floatingips': [{
'id': 'floating-ip-id',
'port_id': 'test_port_id',
'fixed_ip_address': PRIVATE_V4,
'floating_ip_address': PUBLIC_V4,
}]
}),
dict(method='GET',
uri='https://network.example.com/v2.0/networks.json',
json={
'networks': [{
'id': 'test_pnztt_net',
'name': 'test_pnztt_net',
'router:external': False,
}, {
'id': 'private',
'name': 'private',
}]
}),
dict(method='GET',
uri='https://network.example.com/v2.0/subnets.json',
json={'subnets': SUBNETS_WITH_NAT}),
dict(method='GET',
uri='{endpoint}/servers/test-id/os-security-groups'.format(
endpoint=fakes.COMPUTE_ENDPOINT),
json={'security_groups': []})
])
srv = self.cloud.get_openstack_vars(
meta.obj_to_dict(
fakes.FakeServer(id='test-id',
name='test-name',
status='ACTIVE',
flavor={u'id': u'1'},
image={
'name': u'cirros-0.3.4-x86_64-uec',
u'id':
u'f93d000b-7c29-4489-b375-3641a1758fe1'
},
addresses={
u'test_pnztt_net': [{
u'addr':
PRIVATE_V4,
u'version':
4,
'OS-EXT-IPS-MAC:mac_addr':
'fa:16:3e:ae:7d:42',
}]
})))
self.assertEqual(PUBLIC_V4, srv['public_v4'])
self.assert_calls()
