def test_get_server_external_ipv4_neutron_accessIPv4(self):
srv = fakes.make_fake_server(
server_id='test-id', name='test-name', status='ACTIVE')
srv['accessIPv4'] = PUBLIC_V4
ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv)
self.assertEqual(PUBLIC_V4, ip)
def test_get_server_external_provider_ipv4_neutron(self):
# Testing Clouds with Neutron
self.register_uri('GET',
'https://network.example.com/v2.0/networks.json',
json={
'networks': [{
'id': 'test-net-id',
'name': 'test-net',
'provider:network_type': 'vlan',
'provider:physical_network': 'vlan',
}]
})
self.register_uri('GET',
'https://network.example.com/v2.0/subnets.json',
json={'subnets': SUBNETS_WITH_NAT})
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=self.cloud, server=srv)
self.assertEqual(PUBLIC_V4, ip)
self.assert_calls()
def test_detach_ip_from_server(self):
self._setup_networks()
new_server = self.user_cloud.create_server(wait=True,
name=self.new_item_name +
'_server',
image=self.image,
flavor=self.flavor,
nics=[self.nic])
# ToDo: remove the following iteration when create_server waits for
# the IP to be attached
ip = None
for _ in _utils._iterate_timeout(
self.timeout, "Timeout waiting for IP address to be attached"):
ip = meta.get_server_external_ipv4(self.user_cloud, new_server)
if ip is not None:
break
new_server = self.user_cloud.get_server(new_server.id)
self.addCleanup(self._cleanup_ips, new_server)
f_ip = self.user_cloud.get_floating_ip(
id=None, filters={'floating_ip_address': ip})
self.user_cloud.detach_ip_from_server(server_id=new_server.id,
floating_ip_id=f_ip['id'])
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.assertEqual(None, ip)
self.assert_calls()
def test_get_server_external_ipv4_neutron_accessIPv4(self):
srv = meta.obj_to_dict(fakes.FakeServer(
id='test-id', name='test-name', status='ACTIVE',
accessIPv4=PUBLIC_V4))
ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv)
self.assertEqual(PUBLIC_V4, ip)
def test_get_server_internal_provider_ipv4_neutron(
self, mock_list_networks, mock_list_subnets,
mock_has_service):
# Testing Clouds with Neutron
mock_has_service.return_value = True
mock_list_subnets.return_value = SUBNETS_WITH_NAT
mock_list_networks.return_value = [{
'id': 'test-net-id',
'name': 'test-net',
'router:external': False,
'provider:network_type': 'vxlan',
'provider:physical_network': None,
}]
srv = meta.obj_to_dict(fakes.FakeServer(
id='test-id', name='test-name', status='ACTIVE',
addresses={'test-net': [{
'addr': PRIVATE_V4,
'version': 4}]},
))
self.assertIsNone(
meta.get_server_external_ipv4(cloud=self.cloud, server=srv))
int_ip = meta.get_server_private_ip(cloud=self.cloud, server=srv)
self.assertEqual(PRIVATE_V4, int_ip)
def test_get_server_internal_provider_ipv4_neutron(self,
mock_list_networks,
mock_list_subnets,
mock_has_service):
# Testing Clouds with Neutron
mock_has_service.return_value = True
mock_list_subnets.return_value = SUBNETS_WITH_NAT
mock_list_networks.return_value = [{
'id': 'test-net-id',
'name': 'test-net',
'router:external': False,
'provider:network_type': 'vxlan',
'provider:physical_network': None,
}]
srv = meta.obj_to_dict(
fakes.FakeServer(
id='test-id',
name='test-name',
status='ACTIVE',
addresses={'test-net': [{
'addr': PRIVATE_V4,
'version': 4
}]},
))
self.assertIsNone(
meta.get_server_external_ipv4(cloud=self.cloud, server=srv))
int_ip = meta.get_server_private_ip(cloud=self.cloud, server=srv)
self.assertEqual(PRIVATE_V4, int_ip)
def test_get_server_external_none_ipv4_neutron(self, mock_list_networks,
mock_list_subnets,
mock_has_service):
# Testing Clouds with Neutron
mock_has_service.return_value = True
mock_list_subnets.return_value = SUBNETS_WITH_NAT
mock_list_networks.return_value = [{
'id': 'test-net-id',
'name': 'test-net',
'router:external': False,
}]
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=self.cloud, server=srv)
self.assertEqual(None, ip)
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_get_server_internal_provider_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,
'provider:network_type': 'vxlan',
'provider:physical_network': None,
}]
}),
dict(method='GET',
uri='https://network.example.com/v2.0/subnets.json',
json={'subnets': SUBNETS_WITH_NAT})
])
srv = meta.obj_to_dict(
fakes.FakeServer(
id='test-id',
name='test-name',
status='ACTIVE',
addresses={'test-net': [{
'addr': PRIVATE_V4,
'version': 4
}]},
))
self.assertIsNone(
meta.get_server_external_ipv4(cloud=self.cloud, server=srv))
int_ip = meta.get_server_private_ip(cloud=self.cloud, server=srv)
self.assertEqual(PRIVATE_V4, int_ip)
self.assert_calls()
def test_get_server_external_ipv4_neutron_accessIPv4(self):
srv = meta.obj_to_dict(fakes.FakeServer(
id='test-id', name='test-name', status='ACTIVE',
accessIPv4=PUBLIC_V4))
ip = meta.get_server_external_ipv4(
cloud=shade.openstack_cloud(validate=False), server=srv)
self.assertEqual(PUBLIC_V4, ip)
def test_get_server_external_ipv4_neutron_accessIPv4(self):
srv = meta.obj_to_munch(
fakes.FakeServer(id='test-id',
name='test-name',
status='ACTIVE',
accessIPv4=PUBLIC_V4))
ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv)
self.assertEqual(PUBLIC_V4, ip)
def test_get_server_external_ipv4_nova_public(self):
# Testing Clouds w/o Neutron and a network named public
self.cloud.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.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_get_server_external_ipv4_neutron_exception(self, mock_get_server_ip, mock_search_ports, mock_has_service):
# Testing Clouds with a non working Neutron
mock_has_service.return_value = True
mock_search_ports.side_effect = neutron_exceptions.NotFound()
mock_get_server_ip.return_value = PUBLIC_V4
srv = 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.assertTrue(mock_get_server_ip.called)
def test_get_server_external_ipv4_nova_public(
self, mock_has_service):
# Testing Clouds w/o Neutron and a network named public
mock_has_service.return_value = False
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)
def test_get_server_external_ipv4_nova_public(
self, mock_has_service):
# Testing Clouds w/o Neutron and a network named public
mock_has_service.return_value = False
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=shade.openstack_cloud(validate=False), server=srv)
self.assertEqual(PUBLIC_V4, ip)
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=self.cloud, server=srv)
self.assertIsNone(ip)
self.assertTrue(mock_get_server_ip.called)
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_external_ipv4_neutron_exception(
self, mock_get_server_ip, mock_search_ports, mock_has_service):
# Testing Clouds with a non working Neutron
mock_has_service.return_value = True
mock_search_ports.side_effect = neutron_exceptions.NotFound()
mock_get_server_ip.return_value = PUBLIC_V4
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.assertTrue(mock_get_server_ip.called)
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_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 = 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_external_ipv4_neutron_exception(
self, mock_get_server_ip, mock_search_ports,
mock_search_networks,
mock_has_service):
# Testing Clouds with a non working Neutron
mock_has_service.return_value = True
mock_search_networks.return_value = []
mock_search_ports.side_effect = neutron_exceptions.NotFound()
mock_get_server_ip.return_value = PUBLIC_V4
srv = meta.obj_to_dict(fakes.FakeServer(
id='test-id', name='test-name', status='ACTIVE'))
ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv)
self.assertEqual(PUBLIC_V4, ip)
self.assertTrue(mock_get_server_ip.called)
def test_get_server_external_ipv4_nova_none(
self, mock_is_globally_routable_ipv4, 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
mock_is_globally_routable_ipv4.return_value = False
srv = 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(), server=srv)
self.assertIsNone(ip)
self.assertTrue(mock_get_server_ip.called)
self.assertTrue(mock_is_globally_routable_ipv4.called)
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 test_add_auto_ip(self):
self._setup_networks()
new_server = self.cloud.create_server(
wait=True, name=self.new_item_name + '_server',
image=self.image,
flavor=self.flavor, nics=[self.nic])
# ToDo: remove the following iteration when create_server waits for
# the IP to be attached
ip = None
for _ in _utils._iterate_timeout(
self.timeout, "Timeout waiting for IP address to be attached"):
ip = meta.get_server_external_ipv4(self.cloud, new_server)
if ip is not None:
break
new_server = self.cloud.get_server(new_server.id)
self.addCleanup(self._cleanup_ips, new_server)
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=self.cloud, server=srv)
self.assertEqual(PUBLIC_V4, ip)
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_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_add_auto_ip(self):
self._setup_networks()
new_server = self.cloud.create_server(wait=True,
name=self.new_item_name +
'_server',
image=self.image,
flavor=self.flavor,
nics=[self.nic])
# ToDo: remove the following iteration when create_server waits for
# the IP to be attached
ip = None
for _ in _iterate_timeout(
self.timeout, "Timeout waiting for IP address to be attached"):
ip = meta.get_server_external_ipv4(self.cloud, new_server)
if ip is not None:
break
new_server = self.cloud.get_server(new_server.id)
self.addCleanup(self._cleanup_ips, new_server)
def test_get_server_external_none_ipv4_neutron(
self, mock_list_networks, mock_list_subnets,
mock_has_service):
# Testing Clouds with Neutron
mock_has_service.return_value = True
mock_list_subnets.return_value = SUBNETS_WITH_NAT
mock_list_networks.return_value = [{
'id': 'test-net-id',
'name': 'test-net',
'router:external': False,
}]
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=self.cloud, server=srv)
self.assertEqual(None, ip)
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 test_detach_ip_from_server(self):
self._setup_networks()
new_server = self.cloud.create_server(
wait=True, name=self.new_item_name + '_server',
image=self.image,
flavor=self.flavor, nics=[self.nic])
# ToDo: remove the following iteration when create_server waits for
# the IP to be attached
ip = None
for _ in _iterate_timeout(
self.timeout, "Timeout waiting for IP address to be attached"):
ip = meta.get_server_external_ipv4(self.cloud, new_server)
if ip is not None:
break
new_server = self.cloud.get_server(new_server.id)
self.addCleanup(self._cleanup_ips, [ip])
f_ip = self.cloud.get_floating_ip(
id=None, filters={'floating_ip_address': ip})
self.cloud.detach_ip_from_server(
server_id=new_server.id, floating_ip_id=f_ip['id'])
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_ip(self):
srv = meta.obj_to_dict(FakeServer())
self.assertEqual(PRIVATE_V4,
meta.get_server_private_ip(srv, self.cloud))
self.assertEqual(PUBLIC_V4,
meta.get_server_external_ipv4(self.cloud, srv))
def test_get_server_ip(self):
srv = meta.obj_to_dict(FakeServer())
self.assertEqual(
PRIVATE_V4, meta.get_server_private_ip(srv, self.cloud))
self.assertEqual(
PUBLIC_V4, meta.get_server_external_ipv4(self.cloud, srv))
def test_get_server_ip(self):
srv = meta.obj_to_dict(FakeServer())
cloud = shade.openstack_cloud(validate=False)
self.assertEqual(PRIVATE_V4, meta.get_server_private_ip(srv, cloud))
self.assertEqual(PUBLIC_V4, meta.get_server_external_ipv4(cloud, srv))
