def test_create_server_with_server_error(self):
"""
Test that a server error before we return or begin waiting for the
server instance spawn raises an exception in create_server.
"""
build_server = fakes.make_fake_server('1234', '', 'BUILD')
error_server = fakes.make_fake_server('1234', '', 'ERROR')
self.register_uris([
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'networks.json']),
json={'networks': []}),
dict(method='POST',
uri=self.get_mock_url(
'compute', 'public', append=['servers']),
json={'server': build_server},
validate=dict(
json={'server': {
u'flavorRef': u'flavor-id',
u'imageRef': u'image-id',
u'max_count': 1,
u'min_count': 1,
u'name': u'server-name'}})),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234']),
json={'server': error_server}),
])
self.assertRaises(
exc.OpenStackCloudException, self.cloud.create_server,
'server-name', {'id': 'image-id'}, {'id': 'flavor-id'})
self.assert_calls()
def test_create_server_nics_port_id(self):
'''Verify port-id in nics input turns into port in REST.'''
build_server = fakes.make_fake_server('1234', '', 'BUILD')
active_server = fakes.make_fake_server('1234', '', 'BUILD')
image_id = uuid.uuid4().hex
port_id = uuid.uuid4().hex
self.register_uris([
dict(method='POST',
uri=self.get_mock_url(
'compute', 'public', append=['servers']),
json={'server': build_server},
validate=dict(
json={'server': {
u'flavorRef': fakes.FLAVOR_ID,
u'imageRef': image_id,
u'max_count': 1,
u'min_count': 1,
u'networks': [{u'port': port_id}],
u'name': u'server-name'}})),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234']),
json={'server': active_server}),
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'networks.json']),
json={'networks': []}),
])
self.cloud.create_server(
'server-name', dict(id=image_id), dict(id=fakes.FLAVOR_ID),
nics=[{'port-id': port_id}], wait=False)
self.assert_calls()
def test_create_server_no_addresses(
self, mock_add_ips_to_server):
"""
Test that create_server with a wait throws an exception if the
server doesn't have addresses.
"""
build_server = fakes.make_fake_server('1234', '', 'BUILD')
fake_server = fakes.make_fake_server(
'1234', '', 'ACTIVE', addresses={})
self.register_uris([
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'networks.json']),
json={'networks': []}),
dict(method='POST',
uri=self.get_mock_url(
'compute', 'public', append=['servers']),
json={'server': build_server},
validate=dict(
json={'server': {
u'flavorRef': u'flavor-id',
u'imageRef': u'image-id',
u'max_count': 1,
u'min_count': 1,
u'name': u'server-name'}})),
self.get_nova_discovery_mock_dict(),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']),
json={'servers': [build_server]}),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']),
json={'servers': [fake_server]}),
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'ports.json'],
qs_elements=['device_id=1234']),
json={'ports': []}),
dict(method='DELETE',
uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234'])),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']),
json={'servers': []}),
])
mock_add_ips_to_server.return_value = fake_server
self.cloud._SERVER_AGE = 0
self.assertRaises(
exc.OpenStackCloudException, self.cloud.create_server,
'server-name', {'id': 'image-id'}, {'id': 'flavor-id'},
wait=True)
self.assert_calls()
def setUp(self):
super(TestRebuildServer, self).setUp()
self.server_id = str(uuid.uuid4())
self.server_name = self.getUniqueString('name')
self.fake_server = fakes.make_fake_server(
self.server_id, self.server_name)
self.rebuild_server = fakes.make_fake_server(
self.server_id, self.server_name, 'REBUILD')
self.error_server = fakes.make_fake_server(
self.server_id, self.server_name, 'ERROR')
def test_create_boot_attach_volume(self):
build_server = fakes.make_fake_server('1234', '', 'BUILD')
active_server = fakes.make_fake_server('1234', '', 'BUILD')
vol = {'id': 'volume001', 'status': 'available',
'name': '', 'attachments': []}
volume = meta.obj_to_munch(fakes.FakeVolume(**vol))
self.register_uris([
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'networks.json']),
json={'networks': []}),
dict(method='POST',
uri=self.get_mock_url(
'compute', 'public', append=['os-volumes_boot']),
json={'server': build_server},
validate=dict(
json={'server': {
u'flavorRef': 'flavor-id',
u'imageRef': 'image-id',
u'max_count': 1,
u'min_count': 1,
u'block_device_mapping_v2': [
{
u'boot_index': 0,
u'delete_on_termination': True,
u'destination_type': u'local',
u'source_type': u'image',
u'uuid': u'image-id'
},
{
u'boot_index': u'-1',
u'delete_on_termination': False,
u'destination_type': u'volume',
u'source_type': u'volume',
u'uuid': u'volume001'
}
],
u'name': u'server-name'}})),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234']),
json={'server': active_server}),
])
self.cloud.create_server(
name='server-name',
image=dict(id='image-id'),
flavor=dict(id='flavor-id'),
boot_from_volume=False,
volumes=[volume],
wait=False)
self.assert_calls()
def test_create_server_wait(self, mock_wait):
"""
Test that create_server with a wait actually does the wait.
"""
# TODO(mordred) Make this a full proper response
fake_server = fakes.make_fake_server('1234', '', 'BUILD')
self.register_uris([
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'networks.json']),
json={'networks': []}),
dict(method='POST',
uri=self.get_mock_url(
'compute', 'public', append=['servers']),
json={'server': fake_server},
validate=dict(
json={'server': {
u'flavorRef': u'flavor-id',
u'imageRef': u'image-id',
u'max_count': 1,
u'min_count': 1,
u'name': u'server-name'}})),
])
self.cloud.create_server(
'server-name',
dict(id='image-id'), dict(id='flavor-id'), wait=True),
mock_wait.assert_called_once_with(
fake_server,
auto_ip=True, ips=None,
ip_pool=None, reuse=True, timeout=180,
nat_destination=None,
)
self.assert_calls()
def test_create_server_with_get_exception(self):
"""
Test that a bad status code when attempting to get the server instance
raises an exception in create_server.
"""
build_server = fakes.make_fake_server('1234', '', 'BUILD')
self.register_uris([
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'networks.json']),
json={'networks': []}),
dict(method='POST',
uri=self.get_mock_url(
'compute', 'public', append=['servers']),
json={'server': build_server},
validate=dict(
json={'server': {
u'flavorRef': u'flavor-id',
u'imageRef': u'image-id',
u'max_count': 1,
u'min_count': 1,
u'name': u'server-name'}})),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234']),
status_code=404),
])
self.assertRaises(
exc.OpenStackCloudException, self.cloud.create_server,
'server-name', {'id': 'image-id'}, {'id': 'flavor-id'})
self.assert_calls()
def test_create_server_with_timeout(self):
"""
Test that a timeout while waiting for the server to spawn raises an
exception in create_server.
"""
fake_server = fakes.make_fake_server('1234', '', 'BUILD')
self.register_uris([
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'networks.json']),
json={'networks': []}),
dict(method='POST',
uri=self.get_mock_url(
'compute', 'public', append=['servers']),
json={'server': fake_server},
validate=dict(
json={'server': {
u'flavorRef': u'flavor-id',
u'imageRef': u'image-id',
u'max_count': 1,
u'min_count': 1,
u'name': u'server-name'}})),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']),
json={'servers': [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)
# We poll at the end, so we don't know real counts
self.assert_calls(do_count=False)
def setUp(self):
super(TestImageSnapshot, self).setUp()
self.server_id = str(uuid.uuid4())
self.image_id = str(uuid.uuid4())
self.server_name = self.getUniqueString('name')
self.fake_server = fakes.make_fake_server(
self.server_id, self.server_name)
def test_update_server_name(self):
"""
Test that update_server updates the name without raising any exception
"""
fake_update_server = fakes.make_fake_server(
self.server_id, self.updated_server_name)
self.register_uris([
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']),
json={'servers': [self.fake_server]}),
dict(method='PUT',
uri=self.get_mock_url(
'compute', 'public', append=['servers', self.server_id]),
json={'server': fake_update_server},
validate=dict(
json={'server': {'name': self.updated_server_name}})),
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'networks.json']),
json={'networks': []}),
])
self.assertEqual(
self.updated_server_name,
self.cloud.update_server(
self.server_name, name=self.updated_server_name)['name'])
self.assert_calls()
def setUp(self):
super(TestUpdateServer, self).setUp()
self.server_id = str(uuid.uuid4())
self.server_name = self.getUniqueString('name')
self.updated_server_name = self.getUniqueString('name2')
self.fake_server = fakes.make_fake_server(
self.server_id, self.server_name)
def test_remove_security_group_from_server_neutron(self):
# fake to get server by name, server-name must match
fake_server = fakes.make_fake_server('1234', 'server-name', 'ACTIVE')
# use neutron for secgroup list and return an existing fake
self.cloud.secgroup_source = 'neutron'
validate = {'removeSecurityGroup': {'name': 'neutron-sec-group'}}
self.register_uris([
self.get_nova_discovery_mock_dict(),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public',
append=['servers', 'detail']),
json={'servers': [fake_server]}),
dict(method='GET',
uri=self.get_mock_url(
'network', 'public',
append=['v2.0', 'security-groups.json']),
json={'security_groups': [neutron_grp_dict]}),
dict(method='POST',
uri='%s/servers/%s/action' % (fakes.COMPUTE_ENDPOINT, '1234'),
validate=dict(json=validate)),
])
self.assertTrue(self.cloud.remove_server_security_groups(
'server-name', 'neutron-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 = fakes.make_fake_server('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([
self.get_nova_discovery_mock_dict(),
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_get_server_private_ip_devstack(
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': []}),
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(fakes.make_fake_server(
server_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'])
self.assert_calls()
def test_get_server_external_none_ipv4_neutron(self):
# Testing Clouds with Neutron
self.register_uris([
dict(method='GET',
uri='https://network.example.com/v2.0/networks.json',
json={'networks': [{
'id': 'test-net-id',
'name': 'test-net',
'router:external': False,
}]}),
dict(method='GET',
uri='https://network.example.com/v2.0/subnets.json',
json={'subnets': SUBNETS_WITH_NAT})
])
srv = fakes.make_fake_server(
server_id='test-id', name='test-name', status='ACTIVE',
addresses={'test-net': [{
'addr': PUBLIC_V4,
'version': 4}]},
)
ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv)
self.assertIsNone(ip)
self.assert_calls()
def test_from_session(self):
config = cloud_region.from_session(
self.cloud.session, region_name=self.test_region)
self.assertEqual(config.name, 'identity.example.com')
if not self.test_region:
self.assertIsNone(config.region_name)
else:
self.assertEqual(config.region_name, self.test_region)
server_id = str(uuid.uuid4())
server_name = self.getUniqueString('name')
fake_server = fakes.make_fake_server(server_id, server_name)
self.register_uris([
self.get_nova_discovery_mock_dict(),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']),
json={'servers': [fake_server]}),
])
conn = connection.Connection(config=config)
s = next(conn.compute.servers())
self.assertEqual(s.id, server_id)
self.assertEqual(s.name, server_name)
self.assert_calls()
def test_get_server_external_ipv4_neutron_accessIPv6(self):
srv = fakes.make_fake_server(
server_id='test-id', name='test-name', status='ACTIVE')
srv['accessIPv6'] = PUBLIC_V6
ip = meta.get_server_external_ipv6(server=srv)
self.assertEqual(PUBLIC_V6, ip)
def test_delete_server_wait_for_deleted(self):
"""
Test that delete_server waits for the server to be gone
"""
server = fakes.make_fake_server('9999', 'wily', 'ACTIVE')
self.register_uris([
self.get_nova_discovery_mock_dict(),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']),
json={'servers': [server]}),
dict(method='DELETE',
uri=self.get_mock_url(
'compute', 'public', append=['servers', '9999'])),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']),
json={'servers': [server]}),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']),
json={'servers': []}),
])
self.assertTrue(self.cloud.delete_server('wily', wait=True))
self.assert_calls()
def test_delete_server_no_cinder(self):
"""
Test that deleting server works when cinder is not available
"""
orig_has_service = self.cloud.has_service
def fake_has_service(service_type):
if service_type == 'volume':
return False
return orig_has_service(service_type)
self.cloud.has_service = fake_has_service
server = fakes.make_fake_server('1234', 'porky', 'ACTIVE')
self.register_uris([
self.get_nova_discovery_mock_dict(),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']),
json={'servers': [server]}),
dict(method='DELETE',
uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234'])),
])
self.assertTrue(self.cloud.delete_server('porky', wait=False))
self.assert_calls()
def test_delete_server_delete_ips_bad_neutron(self):
"""
Test that deleting server with a borked neutron doesn't bork
"""
server = fakes.make_fake_server('1234', 'porky', 'ACTIVE')
self.register_uris([
self.get_nova_discovery_mock_dict(),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']),
json={'servers': [server]}),
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'floatingips.json'],
qs_elements=['floating_ip_address=172.24.5.5']),
complete_qs=True,
status_code=404),
dict(method='DELETE',
uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234'])),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']),
json={'servers': []}),
])
self.assertTrue(self.cloud.delete_server(
'porky', wait=True, delete_ips=True))
self.assert_calls()
def test_add_ips_to_server_rackspace_local_ipv4(
self, mock_add_auto_ip,
mock_get_floating_ip,
mock_has_service):
self.cloud._floating_ip_source = None
self.cloud.force_ipv4 = False
self.cloud._local_ipv6 = False
mock_has_service.return_value = False
server = fakes.make_fake_server(
server_id='server-id', name='test-server', status="ACTIVE",
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
}]
}
)
server_dict = meta.add_server_interfaces(self.cloud, server)
new_server = self.cloud.add_ips_to_server(server=server_dict)
mock_get_floating_ip.assert_not_called()
mock_add_auto_ip.assert_not_called()
self.assertEqual(new_server['interface_ip'], '104.130.246.91')
def test_get_server(self):
server1 = fakes.make_fake_server('123', 'mickey')
server2 = fakes.make_fake_server('345', 'mouse')
self.register_uris([
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']),
json={'servers': [server1, server2]}),
])
r = self.cloud.get_server('mickey')
self.assertIsNotNone(r)
self.assertEqual(server1['name'], r['name'])
self.assert_calls()
def test_get_server_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-name'}]}
),
dict(method='GET',
uri='https://network.example.com/v2.0/subnets.json',
json={'subnets': SUBNETS_WITH_NAT})
])
srv = fakes.make_fake_server(
server_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}]}
)
self.assertEqual(
PRIVATE_V4, meta.get_server_private_ip(srv, self.cloud))
self.assert_calls()
def test_add_ips_to_server_ipv6_only(
self, mock_add_auto_ip,
mock_get_floating_ip,
mock_has_service):
self.cloud._floating_ip_source = None
self.cloud.force_ipv4 = False
self.cloud._local_ipv6 = True
mock_has_service.return_value = False
server = fakes.make_fake_server(
server_id='server-id', name='test-server', status="ACTIVE",
addresses={
'private': [{
'addr': "10.223.160.141",
'version': 4
}],
'public': [{
u'OS-EXT-IPS-MAC:mac_addr': u'fa:16:3e:ae:7d:42',
u'OS-EXT-IPS:type': u'fixed',
'addr': "2001:4800:7819:103:be76:4eff:fe05:8525",
'version': 6
}]
}
)
server_dict = meta.add_server_interfaces(self.cloud, server)
new_server = self.cloud.add_ips_to_server(server=server_dict)
mock_get_floating_ip.assert_not_called()
mock_add_auto_ip.assert_not_called()
self.assertEqual(
new_server['interface_ip'],
'2001:4800:7819:103:be76:4eff:fe05:8525')
self.assertEqual(new_server['private_v4'], '10.223.160.141')
self.assertEqual(new_server['public_v4'], '')
self.assertEqual(
new_server['public_v6'], '2001:4800:7819:103:be76:4eff:fe05:8525')
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 = fakes.make_fake_server(
server_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 setUp(self):
super(TestServerConsole, self).setUp()
self.server_id = str(uuid.uuid4())
self.server_name = self.getUniqueString('name')
self.server = fakes.make_fake_server(
server_id=self.server_id, name=self.server_name)
self.output = self.getUniqueString('output')
def test_create_server_get_flavor_image(self):
self.use_glance()
image_id = str(uuid.uuid4())
fake_image_dict = fakes.make_fake_image(image_id=image_id)
fake_image_search_return = {'images': [fake_image_dict]}
build_server = fakes.make_fake_server('1234', '', 'BUILD')
active_server = fakes.make_fake_server('1234', '', 'BUILD')
self.register_uris([
dict(method='GET',
uri='https://image.example.com/v2/images',
json=fake_image_search_return),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['flavors', 'detail'],
qs_elements=['is_public=None']),
json={'flavors': fakes.FAKE_FLAVOR_LIST}),
dict(method='POST',
uri=self.get_mock_url(
'compute', 'public', append=['servers']),
json={'server': build_server},
validate=dict(
json={'server': {
u'flavorRef': fakes.FLAVOR_ID,
u'imageRef': image_id,
u'max_count': 1,
u'min_count': 1,
u'networks': [{u'uuid': u'some-network'}],
u'name': u'server-name'}})),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234']),
json={'server': active_server}),
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'networks.json']),
json={'networks': []}),
])
self.cloud.create_server(
'server-name', image_id, 'vanilla',
nics=[{'net-id': 'some-network'}], wait=False)
self.assert_calls()
def test_create_server_with_admin_pass_wait(self, mock_wait):
"""
Test that a server with an admin_pass passed returns the password
"""
admin_pass = self.getUniqueString('password')
fake_server = fakes.make_fake_server('1234', '', 'BUILD')
fake_server_with_pass = fakes.make_fake_server(
'1234', '', 'BUILD', admin_pass=admin_pass)
self.register_uris([
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'networks.json']),
json={'networks': []}),
dict(method='POST',
uri=self.get_mock_url(
'compute', 'public', append=['servers']),
json={'server': fake_server_with_pass},
validate=dict(
json={'server': {
u'flavorRef': u'flavor-id',
u'imageRef': u'image-id',
u'max_count': 1,
u'min_count': 1,
u'adminPass': admin_pass,
u'name': u'server-name'}})),
])
# The wait returns non-password server
mock_wait.return_value = self.cloud._normalize_server(fake_server)
server = self.cloud.create_server(
name='server-name', image=dict(id='image-id'),
flavor=dict(id='flavor-id'),
admin_pass=admin_pass, wait=True)
# Assert that we did wait
self.assertTrue(mock_wait.called)
# Even with the wait, we should still get back a passworded server
self.assertEqual(
server['adminPass'],
self.cloud._normalize_server(fake_server_with_pass)['adminPass']
)
self.assert_calls()
def test_get_server_external_ipv4_nova_public(self):
# Testing Clouds w/o Neutron and a network named public
self.cloud.config.config['has_network'] = False
srv = fakes.make_fake_server(
server_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)
def test_get_server_external_ipv4_nova_none(self):
# Testing Clouds w/o Neutron or a globally routable IP
self.cloud.config.config['has_network'] = False
srv = fakes.make_fake_server(
server_id='test-id', name='test-name', status='ACTIVE',
addresses={'test-net': [{'addr': PRIVATE_V4}]})
ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv)
self.assertIsNone(ip)
def test_list_servers_no_herd(self):
self.cloud._SERVER_AGE = 2
fake_server = fakes.make_fake_server('1234', 'name')
self.register_uris([
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']),
json={'servers': [fake_server]}),
])
with concurrent.futures.ThreadPoolExecutor(16) as pool:
for i in range(16):
pool.submit(lambda: self.cloud.list_servers(bare=True))
# It's possible to race-condition 16 threads all in the
# single initial lock without a tiny sleep
time.sleep(0.001)
self.assert_calls()
def test_get_server_private_ip_no_fip(
self,
mock_get_flavor_name, mock_get_image_name,
mock_get_volumes):
self.cloud._floating_ip_source = None
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 = []
self.register_uris([
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(fakes.make_fake_server(
server_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'])
self.assert_calls()
def test_get_server_cloud_rackspace_v6(
self, mock_get_flavor_name, mock_get_image_name,
mock_get_volumes):
self.cloud.cloud_config.config['has_network'] = False
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_get_volumes.return_value = []
self.register_uris([
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(fakes.make_fake_server(
server_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'])
self.assert_calls()
def test_add_security_group_to_bad_server(self):
# fake to get server by name, server-name must match
fake_server = fakes.make_fake_server('1234', 'server-name', 'ACTIVE')
self.register_uris([
dict(
method='GET',
uri='{endpoint}/servers/detail'.format(
endpoint=fakes.COMPUTE_ENDPOINT),
json={'servers': [fake_server]}),
])
ret = self.cloud.add_server_security_groups('unknown-server-name',
'nova-sec-group')
self.assertFalse(ret)
self.assert_calls()
def test_create_server_user_data_base64(self):
"""
Test that a server passed user-data sends it base64 encoded.
"""
user_data = self.getUniqueString('user_data')
user_data_b64 = base64.b64encode(
user_data.encode('utf-8')).decode('utf-8')
fake_server = fakes.make_fake_server('1234', '', 'BUILD')
fake_server['user_data'] = user_data
self.register_uris([
dict(method='GET',
uri=self.get_mock_url('network',
'public',
append=['v2.0', 'networks.json']),
json={'networks': []}),
dict(method='POST',
uri=self.get_mock_url('compute', 'public',
append=['servers']),
json={'server': fake_server},
validate=dict(
json={
'server': {
u'flavorRef': u'flavor-id',
u'imageRef': u'image-id',
u'max_count': 1,
u'min_count': 1,
u'user_data': user_data_b64,
u'name': u'server-name'
}
})),
dict(method='GET',
uri=self.get_mock_url('compute',
'public',
append=['servers', '1234']),
json={'server': fake_server}),
])
self.cloud.create_server(name='server-name',
image=dict(id='image-id'),
flavor=dict(id='flavor-id'),
userdata=user_data,
wait=False)
self.assert_calls()
def test_list_servers(self):
server_id = str(uuid.uuid4())
server_name = self.getUniqueString('name')
fake_server = fakes.make_fake_server(server_id, server_name)
self.register_uris([
self.get_nova_discovery_mock_dict(),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']),
json={'servers': [fake_server]}),
])
r = self.cloud.list_servers()
self.assertEqual(1, len(r))
self.assertEqual(server_name, r[0]['name'])
self.assert_calls()
def test_create_server_network_with_empty_nics(self):
"""
Verify that if 'network' is supplied, along with an empty 'nics' list,
it's treated the same as if 'nics' were not included.
"""
network = {
'id': 'network-id',
'name': 'network-name'
}
build_server = fakes.make_fake_server('1234', '', 'BUILD')
self.register_uris([
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'networks']),
json={'networks': [network]}),
dict(method='POST',
uri=self.get_mock_url(
'compute', 'public', append=['servers']),
json={'server': build_server},
validate=dict(
json={'server': {
u'flavorRef': u'flavor-id',
u'imageRef': u'image-id',
u'max_count': 1,
u'min_count': 1,
u'networks': [{u'uuid': u'network-id'}],
u'name': u'server-name'}})),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234']),
json={'server': build_server}),
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'networks']),
json={'networks': [network]}),
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'subnets']),
json={'subnets': []}),
])
self.cloud.create_server(
'server-name', dict(id='image-id'), dict(id='flavor-id'),
network='network-name', nics=[])
self.assert_calls()
def test_create_server_network_with_no_nics(self):
"""
Verify that if 'network' is supplied, and 'nics' is not, that we
attempt to get the network for the server.
"""
build_server = fakes.make_fake_server('1234', '', 'BUILD')
network = {
'id': 'network-id',
'name': 'network-name'
}
self.register_uris([
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'networks']),
json={'networks': [network]}),
dict(method='POST',
uri=self.get_mock_url(
'compute', 'public', append=['servers']),
json={'server': build_server},
validate=dict(
json={'server': {
u'flavorRef': u'flavor-id',
u'imageRef': u'image-id',
u'max_count': 1,
u'min_count': 1,
u'networks': [{u'uuid': u'network-id'}],
u'name': u'server-name'}})),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234']),
json={'server': build_server}),
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'networks']),
json={'networks': [network]}),
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'subnets']),
json={'subnets': []}),
])
self.cloud.create_server(
'server-name',
dict(id='image-id'), dict(id='flavor-id'), network='network-name')
self.assert_calls()
def test_delete_server(self):
"""
Test that server delete is called when wait=False
"""
server = fakes.make_fake_server('1234', 'daffy', 'ACTIVE')
self.register_uris([
dict(method='GET',
uri=self.get_mock_url('compute',
'public',
append=['servers', 'detail']),
json={'servers': [server]}),
dict(method='DELETE',
uri=self.get_mock_url('compute',
'public',
append=['servers', '1234'])),
])
self.assertTrue(self.cloud.delete_server('daffy', wait=False))
self.assert_calls()
def test_create_server_network_v6_fixed_ip(self):
"""
Verify that if 'v6-fixed-ip' is supplied in nics, we pass it to
networks appropriately.
"""
network = {
'id': 'network-id',
'name': 'network-name'
}
# Note - it doesn't actually have to be a v6 address - it's just
# an alias.
fixed_ip = 'fe80::28da:5fff:fe57:13ed'
build_server = fakes.make_fake_server('1234', '', 'BUILD')
self.register_uris([
dict(method='POST',
uri=self.get_mock_url(
'compute', 'public', append=['servers']),
json={'server': build_server},
validate=dict(
json={'server': {
u'flavorRef': u'flavor-id',
u'imageRef': u'image-id',
u'max_count': 1,
u'min_count': 1,
u'networks': [{'fixed_ip': fixed_ip}],
u'name': u'server-name'}})),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234']),
json={'server': build_server}),
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'networks']),
json={'networks': [network]}),
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'subnets']),
json={'subnets': []}),
])
self.cloud.create_server(
'server-name', dict(id='image-id'), dict(id='flavor-id'),
nics=[{'fixed_ip': fixed_ip}])
self.assert_calls()
def test_add_ips_to_server_auto_ip(self, mock_add_auto_ip,
mock_needs_floating_ip):
server_dict = fakes.make_fake_server(server_id='server-id',
name='test-server',
status="ACTIVE",
addresses={})
# TODO(mordred) REMOVE THIS MOCK WHEN THE NEXT PATCH LANDS
# SERIOUSLY THIS TIME. NEXT PATCH - WHICH SHOULD ADD MOCKS FOR
# list_ports AND list_networks AND list_subnets. BUT THAT WOULD
# BE NOT ACTUALLY RELATED TO THIS PATCH. SO DO IT NEXT PATCH
mock_needs_floating_ip.return_value = True
self.cloud.add_ips_to_server(server_dict)
mock_add_auto_ip.assert_called_with(server_dict,
wait=False,
timeout=60,
reuse=True)
def test_create_server_wait(self, mock_wait):
"""
Test that create_server with a wait actually does the wait.
"""
# TODO(mordred) Make this a full proper response
fake_server = fakes.make_fake_server('1234', '', 'BUILD')
self.register_uris([
dict(method='GET',
uri=self.get_mock_url('network',
'public',
append=['v2.0', 'networks.json']),
json={'networks': []}),
dict(method='POST',
uri=self.get_mock_url('compute', 'public',
append=['servers']),
json={'server': fake_server},
validate=dict(
json={
'server': {
u'flavorRef': u'flavor-id',
u'imageRef': u'image-id',
u'max_count': 1,
u'min_count': 1,
u'name': u'server-name'
}
})),
])
self.cloud.create_server('server-name',
dict(id='image-id'),
dict(id='flavor-id'),
wait=True),
mock_wait.assert_called_once_with(
fake_server,
auto_ip=True,
ips=None,
ip_pool=None,
reuse=True,
timeout=180,
nat_destination=None,
)
self.assert_calls()
def test_create_server_with_timeout(self):
"""
Test that a timeout while waiting for the server to spawn raises an
exception in create_server.
"""
fake_server = fakes.make_fake_server('1234', '', 'BUILD')
self.register_uris([
dict(method='GET',
uri=self.get_mock_url('network',
'public',
append=['v2.0', 'networks.json']),
json={'networks': []}),
dict(method='POST',
uri=self.get_mock_url('compute', 'public',
append=['servers']),
json={'server': fake_server},
validate=dict(
json={
'server': {
u'flavorRef': u'flavor-id',
u'imageRef': u'image-id',
u'max_count': 1,
u'min_count': 1,
u'name': u'server-name'
}
})),
self.get_nova_discovery_mock_dict(),
dict(method='GET',
uri=self.get_mock_url('compute',
'public',
append=['servers', 'detail']),
json={'servers': [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)
# We poll at the end, so we don't know real counts
self.assert_calls(do_count=False)
def test_delete_server_delete_fips_nova(self):
"""
Test that deleting server with a borked neutron doesn't bork
"""
self.cloud._floating_ip_source = 'nova'
server = fakes.make_fake_server('1234', 'porky', 'ACTIVE')
self.register_uris([
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']),
json={'servers': [server]}),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['os-floating-ips']),
json={'floating_ips': [
{
'fixed_ip': None,
'id': 1,
'instance_id': None,
'ip': '172.24.5.5',
'pool': 'nova'
}]}),
dict(method='DELETE',
uri=self.get_mock_url(
'compute', 'public', append=['os-floating-ips', '1'])),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['os-floating-ips']),
json={'floating_ips': []}),
dict(method='DELETE',
uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234'])),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']),
json={'servers': []}),
])
self.assertTrue(self.cloud.delete_server(
'porky', wait=True, delete_ips=True))
self.assert_calls()
def test_create_server_config_drive(self):
"""
Test that config_drive gets passed in properly
"""
fake_server = fakes.make_fake_server('1234', '', 'BUILD')
self.register_uris([
dict(method='GET',
uri=self.get_mock_url('network',
'public',
append=['v2.0', 'networks.json']),
json={'networks': []}),
dict(method='POST',
uri=self.get_mock_url('compute', 'public',
append=['servers']),
json={'server': fake_server},
validate=dict(
json={
'server': {
u'flavorRef': u'flavor-id',
u'imageRef': u'image-id',
u'config_drive': True,
u'max_count': 1,
u'min_count': 1,
u'name': u'server-name'
}
})),
dict(method='GET',
uri=self.get_mock_url('compute',
'public',
append=['servers', '1234']),
json={'server': fake_server}),
])
normalized = self.cloud._expand_server(
self.cloud._normalize_server(fake_server), False, False)
self.assertEqual(
normalized,
self.cloud.create_server(name='server-name',
image=dict(id='image-id'),
flavor=dict(id='flavor-id'),
config_drive=True))
self.assert_calls()
def test_get_server_external_ipv4_neutron_exception(self):
# Testing Clouds with a non working Neutron
self.register_uris([
dict(method='GET',
uri='https://network.example.com/v2.0/networks.json',
status_code=404)
])
srv = fakes.make_fake_server(
server_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_network_fixed_ip(self):
"""
Verify that if 'fixed_ip' is supplied in nics, we pass it to networks
appropriately.
"""
network = {
'id': 'network-id',
'name': 'network-name'
}
fixed_ip = '10.0.0.1'
build_server = fakes.make_fake_server('1234', '', 'BUILD')
self.register_uris([
dict(method='POST',
uri=self.get_mock_url(
'compute', 'public', append=['servers']),
json={'server': build_server},
validate=dict(
json={'server': {
u'flavorRef': u'flavor-id',
u'imageRef': u'image-id',
u'max_count': 1,
u'min_count': 1,
u'networks': [{'fixed_ip': fixed_ip}],
u'name': u'server-name'}})),
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', '1234']),
json={'server': build_server}),
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'networks']),
json={'networks': [network]}),
dict(method='GET',
uri=self.get_mock_url(
'network', 'public', append=['v2.0', 'subnets']),
json={'subnets': []}),
])
self.cloud.create_server(
'server-name', dict(id='image-id'), dict(id='flavor-id'),
nics=[{'fixed_ip': fixed_ip}])
self.assert_calls()
def test_create_server_no_wait(self):
"""
Test that create_server with no wait and no exception in the
create call returns the server instance.
"""
fake_server = fakes.make_fake_server('1234', '', 'BUILD')
self.register_uris([
dict(method='GET',
uri=self.get_mock_url('network',
'public',
append=['v2.0', 'networks.json']),
json={'networks': []}),
dict(method='POST',
uri=self.get_mock_url('compute', 'public',
append=['servers']),
json={'server': fake_server},
validate=dict(
json={
'server': {
u'flavorRef': u'flavor-id',
u'imageRef': u'image-id',
u'max_count': 1,
u'min_count': 1,
u'name': u'server-name'
}
})),
dict(method='GET',
uri=self.get_mock_url('compute',
'public',
append=['servers', '1234']),
json={'server': fake_server}),
])
normalized = self.cloud._expand_server(
self.cloud._normalize_server(fake_server), False, False)
self.assertEqual(
normalized,
self.cloud.create_server(name='server-name',
image=dict(id='image-id'),
flavor=dict(id='flavor-id')))
self.assert_calls()
def setUp(self):
super(TestFloatingIP, self).setUp()
self.fake_server = fakes.make_fake_server(
'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_add_bad_security_group_to_server_neutron(self):
# fake to get server by name, server-name must match
fake_server = fakes.make_fake_server('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': [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_delete_server_fails(self):
"""
Test that delete_server raises non-404 exceptions
"""
server = fakes.make_fake_server('1212', 'speedy', 'ACTIVE')
self.register_uris([
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']),
json={'servers': [server]}),
dict(method='DELETE',
uri=self.get_mock_url(
'compute', 'public', append=['servers', '1212']),
status_code=400),
])
self.assertRaises(
shade_exc.OpenStackCloudException,
self.cloud.delete_server, 'speedy',
wait=False)
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 = fakes.make_fake_server('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_get_server_external_ipv4_neutron(self):
# Testing Clouds with Neutron
self.register_uris([
dict(method='GET',
uri='https://network.example.com/v2.0/networks.json',
json={'networks': [{
'id': 'test-net-id',
'name': 'test-net',
'router:external': True
}]}),
dict(method='GET',
uri='https://network.example.com/v2.0/subnets.json',
json={'subnets': SUBNETS_WITH_NAT})
])
srv = fakes.make_fake_server(
server_id='test-id', name='test-name', status='ACTIVE',
addresses={'test-net': [{
'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_add_auto_ip(
self, mock_available_floating_ip, mock_attach_ip_to_server,
mock_get_floating_ip):
server_dict = fakes.make_fake_server(
server_id='server-id', name='test-server', status="ACTIVE",
addresses={}
)
floating_ip_dict = {
"id": "this-is-a-floating-ip-id",
"fixed_ip_address": None,
"internal_network": None,
"floating_ip_address": "203.0.113.29",
"network": "this-is-a-net-or-pool-id",
"attached": False,
"status": "ACTIVE"
}
mock_available_floating_ip.return_value = floating_ip_dict
self.cloud.add_auto_ip(server=server_dict)
mock_attach_ip_to_server.assert_called_with(
timeout=60, wait=False, server=server_dict,
floating_ip=floating_ip_dict, skip_attach=False)
def test_from_session(self):
config = cloud_region.from_session(
self.cloud.keystone_session, region_name=self.test_region)
self.assertEqual(config.name, 'identity.example.com')
if not self.test_region:
self.assertIsNone(config.region_name)
else:
self.assertEqual(config.region_name, self.test_region)
server_id = str(uuid.uuid4())
server_name = self.getUniqueString('name')
fake_server = fakes.make_fake_server(server_id, server_name)
self.register_uris([
dict(method='GET',
uri=self.get_mock_url(
'compute', 'public', append=['servers', 'detail']),
json={'servers': [fake_server]}),
])
conn = connection.Connection(config=config)
s = next(conn.compute.servers())
self.assertEqual(s.id, server_id)
self.assertEqual(s.name, server_name)
self.assert_calls()
def test_list_server_security_groups_nova(self):
self.has_neutron = False
server = fakes.make_fake_server('1234', 'server-name', 'ACTIVE')
self.register_uris([
self.get_nova_discovery_mock_dict(),
dict(method='GET',
uri=self.get_mock_url('compute',
'public',
append=['servers', server['id']]),
json=server),
dict(method='GET',
uri='{endpoint}/servers/{id}/os-security-groups'.format(
endpoint=fakes.COMPUTE_ENDPOINT, id=server['id']),
json={'security_groups': [nova_grp_dict]}),
])
groups = self.cloud.list_server_security_groups(server)
self.assertIn('location', groups[0])
self.assertEqual(
groups[0]['security_group_rules'][0]['remote_ip_prefix'],
nova_grp_dict['rules'][0]['ip_range']['cidr'])
self.assert_calls()
def test_create_server_with_get_exception(self):
"""
Test that a bad status code when attempting to get the server instance
raises an exception in create_server.
"""
build_server = fakes.make_fake_server('1234', '', 'BUILD')
self.register_uris([
dict(method='GET',
uri=self.get_mock_url('network',
'public',
append=['v2.0', 'networks.json']),
json={'networks': []}),
dict(method='POST',
uri=self.get_mock_url('compute', 'public',
append=['servers']),
json={'server': build_server},
validate=dict(
json={
'server': {
u'flavorRef': u'flavor-id',
u'imageRef': u'image-id',
u'max_count': 1,
u'min_count': 1,
u'name': u'server-name'
}
})),
dict(method='GET',
uri=self.get_mock_url('compute',
'public',
append=['servers', '1234']),
status_code=404),
])
self.assertRaises(exc.OpenStackCloudException,
self.cloud.create_server, 'server-name',
{'id': 'image-id'}, {'id': 'flavor-id'})
self.assert_calls()
def test_get_server_cloud_osic_split(self, mock_get_flavor_name,
mock_get_image_name,
mock_get_volumes):
self.cloud._floating_ip_source = None
self.cloud.force_ipv4 = False
self.cloud._local_ipv6 = True
self.cloud._external_ipv4_names = ['GATEWAY_NET']
self.cloud._external_ipv6_names = ['GATEWAY_NET_V6']
self.cloud._internal_ipv4_names = ['GATEWAY_NET_V6']
self.cloud._internal_ipv6_names = []
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 = []
fake_server = fakes.make_fake_server(
server_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.register_uris([
dict(method='GET',
uri='https://network.example.com/v2.0/networks.json',
json={'networks': OSIC_NETWORKS}),
dict(method='GET',
uri='https://network.example.com/v2.0/subnets.json',
json={'subnets': OSIC_SUBNETS}),
self.get_nova_discovery_mock_dict(),
dict(method='GET',
uri=self.get_mock_url('compute',
'public',
append=['servers', fake_server['id']]),
json=fake_server),
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(fake_server)
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'])
self.assert_calls()
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
fake_server = fakes.make_fake_server(
server_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.register_uris([
# self.get_nova_discovery_mock_dict(),
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}),
self.get_nova_discovery_mock_dict(),
dict(method='GET',
uri=self.get_mock_url('compute',
'public',
append=['servers', fake_server['id']]),
json=fake_server),
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(fake_server)
self.assertEqual(PUBLIC_V4, srv['public_v4'])
self.assert_calls()
return []
def get_default_network(self):
return None
standard_fake_server = fakes.make_fake_server(
server_id='test-id-0',
name='test-id-0',
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
}]
},
flavor={'id': '101'},
image={'id': '471c2475-da2f-47ac-aba5-cb4aa3d546f5'},
)
standard_fake_server['metadata'] = {'group': 'test-group'}
SUBNETS_WITH_NAT = [
{
u'name': u'',
u'enable_dhcp': True,
