openstack
/
heat
Code Issues Proposed changes

Merge "Remove deprecated nova api calls from EIP/EIPAssociation"

This commit is contained in:
Zuul 2018-03-01 13:10:27 +00:00 committed by Gerrit Code Review
parent 930a93fdc1 6ea991f26a
commit fbe3c0f898
3 changed files with 237 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
heat/engine/clients/os/nova.py
View File

@ -704,6 +704,26 @@ echo -e '%s\tALL=(ALL)\tNOPASSWD: ALL' >> /etc/sudoers
self.clients.client('neutron').update_floatingip(floatingip_id,
request_body)
def associate_floatingip_address(self, server_id, fip_address):
fips = self.clients.client(
'neutron').list_floatingips(
floating_ip_address=fip_address)['floatingips']
if len(fips) == 0:
args = {'ip_address': fip_address}
raise client_exception.EntityMatchNotFound(entity='floatingip',
args=args)
self.associate_floatingip(server_id, fips[0]['id'])
def dissociate_floatingip_address(self, fip_address):
fips = self.clients.client(
'neutron').list_floatingips(
floating_ip_address=fip_address)['floatingips']
if len(fips) == 0:
args = {'ip_address': fip_address}
raise client_exception.EntityMatchNotFound(entity='floatingip',
args=args)
self.dissociate_floatingip(fips[0]['id'])
def interface_detach(self, server_id, port_id):
with self.ignore_not_found:
server = self.fetch_server(server_id)

111
heat/engine/resources/aws/ec2/eip.py
View File

@ -17,6 +17,7 @@ import six
from heat.common import exception
from heat.common.i18n import _
from heat.engine import attributes
from heat.engine.clients import client_exception
from heat.engine import constraints
from heat.engine import properties
from heat.engine import resource
@ -98,36 +99,27 @@ class ElasticIp(resource.Resource):
props = {'floating_network_id': ext_net}
ips = self.neutron().create_floatingip({
'floatingip': props})['floatingip']
self.ipaddress = ips['floating_ip_address']
self.resource_id_set(ips['id'])
self.ipaddress = ips['floating_ip_address']
LOG.info('ElasticIp create %s', str(ips))
instance_id = self.properties[self.INSTANCE_ID]
if instance_id:
server = self.client().servers.get(instance_id)
server.add_floating_ip(self._ipaddress())
self.client_plugin().associate_floatingip(instance_id,
ips['id'])
def handle_delete(self):
if self.resource_id is None:
return
# may be just create an eip when creation, or create the association
# failed when creation, there will no association, if we attempt to
# failed when creation, there will be no association, if we attempt to
# disassociate, an exception will raised, we need
# to catch and ignore it, and then to deallocate the eip
instance_id = self.properties[self.INSTANCE_ID]
if instance_id:
try:
server = self.client().servers.get(instance_id)
if server:
server.remove_floating_ip(self._ipaddress())
except Exception as e:
is_not_found = self.client_plugin('nova').is_not_found(e)
is_unprocessable_entity = self.client_plugin(
'nova').is_unprocessable_entity(e)
if (not is_not_found and not is_unprocessable_entity):
raise
with self.client_plugin().ignore_not_found:
self.client_plugin().dissociate_floatingip(self.resource_id)
# deallocate the eip
with self.client_plugin('neutron').ignore_not_found:
self.neutron().delete_floatingip(self.resource_id)
@ -135,19 +127,13 @@ class ElasticIp(resource.Resource):
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
if prop_diff:
if self.INSTANCE_ID in prop_diff:
instance_id = prop_diff.get(self.INSTANCE_ID)
instance_id = prop_diff[self.INSTANCE_ID]
if instance_id:
# no need to remove the floating ip from the old instance,
# nova does this automatically when calling
# add_floating_ip().
server = self.client().servers.get(instance_id)
server.add_floating_ip(self._ipaddress())
self.client_plugin().associate_floatingip(
instance_id, self.resource_id)
else:
# to remove the floating_ip from the old instance
instance_id_old = self.properties[self.INSTANCE_ID]
if instance_id_old:
server = self.client().servers.get(instance_id_old)
server.remove_floating_ip(self._ipaddress())
self.client_plugin().dissociate_floatingip(
self.resource_id)
def get_reference_id(self):
eip = self._ipaddress()
@ -251,45 +237,31 @@ class ElasticIpAssociation(resource.Resource):
allocationId,
{'floatingip': {'port_id': port_id}})
except Exception as e:
if ignore_not_found:
self.client_plugin('neutron').ignore_not_found(e)
else:
if not (ignore_not_found and self.client_plugin(
'neutron').is_not_found(e)):
raise
def _nova_remove_floating_ip(self, instance_id, eip,
ignore_not_found=False):
server = None
def _remove_floating_ip_address(self, eip, ignore_not_found=False):
try:
server = self.client().servers.get(instance_id)
server.remove_floating_ip(eip)
self.client_plugin().dissociate_floatingip_address(eip)
except Exception as e:
is_not_found = self.client_plugin('nova').is_not_found(e)
iue = self.client_plugin('nova').is_unprocessable_entity(e)
if ((not ignore_not_found and is_not_found) or
(not is_not_found and not iue)):
addr_not_found = isinstance(
e, client_exception.EntityMatchNotFound)
fip_not_found = self.client_plugin().is_not_found(e)
not_found = addr_not_found or fip_not_found
if not (ignore_not_found and not_found):
raise
return server
def _floatingIp_detach(self,
nova_ignore_not_found=False,
neutron_ignore_not_found=False):
def _floatingIp_detach(self):
eip = self.properties[self.EIP]
allocation_id = self.properties[self.ALLOCATION_ID]
instance_id = self.properties[self.INSTANCE_ID]
server = None
if eip:
# if has eip_old, to remove the eip_old from the instance
server = self._nova_remove_floating_ip(instance_id,
eip,
nova_ignore_not_found)
self._remove_floating_ip_address(eip)
else:
# if hasn't eip_old, to update neutron floatingIp
self._neutron_update_floating_ip(allocation_id,
None,
neutron_ignore_not_found)
return server
None)
def _handle_update_eipInfo(self, prop_diff):
eip_update = prop_diff.get(self.EIP)
@ -297,13 +269,12 @@ class ElasticIpAssociation(resource.Resource):
instance_id = self.properties[self.INSTANCE_ID]
ni_id = self.properties[self.NETWORK_INTERFACE_ID]
if eip_update:
server = self._floatingIp_detach(neutron_ignore_not_found=True)
if server:
# then to attach the eip_update to the instance
server.add_floating_ip(eip_update)
self.resource_id_set(eip_update)
self._floatingIp_detach()
self.client_plugin().associate_floatingip_address(instance_id,
eip_update)
self.resource_id_set(eip_update)
elif allocation_id_update:
self._floatingIp_detach(nova_ignore_not_found=True)
self._floatingIp_detach()
port_id, port_rsrc = self._get_port_info(ni_id, instance_id)
if not port_id or not port_rsrc:
LOG.error('Port not specified.')
@ -323,8 +294,8 @@ class ElasticIpAssociation(resource.Resource):
# if update portInfo, no need to detach the port from
# old instance/floatingip.
if eip:
server = self.client().servers.get(instance_id_update)
server.add_floating_ip(eip)
self.client_plugin().associate_floatingip_address(
instance_id_update, eip)
else:
port_id, port_rsrc = self._get_port_info(ni_id_update,
instance_id_update)
@ -339,15 +310,15 @@ class ElasticIpAssociation(resource.Resource):
def handle_create(self):
"""Add a floating IP address to a server."""
if self.properties[self.EIP]:
server = self.client().servers.get(
self.properties[self.INSTANCE_ID])
server.add_floating_ip(self.properties[self.EIP])
self.resource_id_set(self.properties[self.EIP])
eip = self.properties[self.EIP]
if eip:
self.client_plugin().associate_floatingip_address(
self.properties[self.INSTANCE_ID], eip)
self.resource_id_set(eip)
LOG.debug('ElasticIpAssociation '
'%(instance)s.add_floating_ip(%(eip)s)',
{'instance': self.properties[self.INSTANCE_ID],
'eip': self.properties[self.EIP]})
'eip': eip})
elif self.properties[self.ALLOCATION_ID]:
ni_id = self.properties[self.NETWORK_INTERFACE_ID]
instance_id = self.properties[self.INSTANCE_ID]
@ -370,11 +341,9 @@ class ElasticIpAssociation(resource.Resource):
return
if self.properties[self.EIP]:
instance_id = self.properties[self.INSTANCE_ID]
eip = self.properties[self.EIP]
self._nova_remove_floating_ip(instance_id,
eip,
ignore_not_found=True)
self._remove_floating_ip_address(eip,
ignore_not_found=True)
elif self.properties[self.ALLOCATION_ID]:
float_id = self.properties[self.ALLOCATION_ID]
self._neutron_update_floating_ip(float_id,

274
heat/tests/aws/test_eip.py
View File

@ -14,6 +14,7 @@
import copy
import mock
from neutronclient.common import exceptions as q_exceptions
from neutronclient.v2_0 import client as neutronclient
import six
@ -174,6 +175,8 @@ class EIPTest(common.HeatTestCase):
self.m.StubOutWithMock(nova.NovaClientPlugin, '_create')
self.m.StubOutWithMock(neutronclient.Client, 'list_networks')
self.m.StubOutWithMock(self.fc.servers, 'get')
self.m.StubOutWithMock(neutronclient.Client,
'list_floatingips')
self.m.StubOutWithMock(neutronclient.Client,
'create_floatingip')
self.m.StubOutWithMock(neutronclient.Client,
@ -183,7 +186,22 @@ class EIPTest(common.HeatTestCase):
self.m.StubOutWithMock(neutronclient.Client,
'delete_floatingip')
def mock_interface(self, port, ip):
class MockIface(object):
def __init__(self, port_id, fixed_ip):
self.port_id = port_id
self.fixed_ips = [{'ip_address': fixed_ip}]
return MockIface(port, ip)
def mock_list_floatingips(self):
neutronclient.Client.list_floatingips(
floating_ip_address='11.0.0.1').AndReturn({
'floatingips': [{'id':
"fc68ea2c-b60b-4b4f-bd82-94ec81110766"}]})
def mock_create_floatingip(self):
nova.NovaClientPlugin._create().AndReturn(self.fc)
neutronclient.Client.list_networks(
**{'router:external': True}).AndReturn({'networks': [{
'status': 'ACTIVE',
@ -217,6 +235,22 @@ class EIPTest(common.HeatTestCase):
'id': 'ffff'
}})
def mock_update_floatingip(self,
fip='fc68ea2c-b60b-4b4f-bd82-94ec81110766',
delete_assc=False):
if delete_assc:
request_body = {
'floatingip': {
'port_id': None,
'fixed_ip_address': None}}
else:
request_body = {
'floatingip': {
'port_id': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa',
'fixed_ip_address': '1.2.3.4'}}
neutronclient.Client.update_floatingip(
fip, request_body).AndReturn(None)
def mock_delete_floatingip(self):
id = 'fc68ea2c-b60b-4b4f-bd82-94ec81110766'
neutronclient.Client.delete_floatingip(id).AndReturn(None)
@ -245,23 +279,18 @@ class EIPTest(common.HeatTestCase):
rsrc.node_data())
return rsrc
def _mock_server_get(self, server='WebServer', mock_server=None,
multiple=False, mock_again=False):
if not mock_again:
nova.NovaClientPlugin._create().AndReturn(self.fc)
if multiple:
self.fc.servers.get(server).MultipleTimes().AndReturn(
mock_server)
else:
self.fc.servers.get(server).AndReturn(mock_server)
def test_eip(self):
mock_server = self.fc.servers.list()[0]
self._mock_server_get(mock_server=mock_server)
self._mock_server_get(mock_again=True)
self.patchobject(self.fc.servers, 'get',
return_value=mock_server)
self.mock_create_floatingip()
self.mock_update_floatingip()
self.mock_update_floatingip(delete_assc=True)
self.mock_delete_floatingip()
self.m.ReplayAll()
iface = self.mock_interface('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa',
'1.2.3.4')
self.patchobject(mock_server, 'interface_list', return_value=[iface])
t = template_format.parse(eip_template)
stack = utils.parse_stack(t)
@ -285,13 +314,18 @@ class EIPTest(common.HeatTestCase):
self.m.VerifyAll()
def test_eip_update(self):
server_old = self.fc.servers.list()[0]
self._mock_server_get(mock_server=server_old)
server_update = self.fc.servers.list()[1]
self._mock_server_get(server='5678', mock_server=server_update,
multiple=True, mock_again=True)
mock_server = self.fc.servers.list()[0]
self.patchobject(self.fc.servers, 'get',
return_value=mock_server)
self.mock_create_floatingip()
self.mock_update_floatingip()
self.mock_update_floatingip()
self.mock_update_floatingip(delete_assc=True)
iface = self.mock_interface('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa',
'1.2.3.4')
self.patchobject(mock_server, 'interface_list', return_value=[iface])
self.m.ReplayAll()
t = template_format.parse(eip_template)
stack = utils.parse_stack(t)
@ -299,6 +333,13 @@ class EIPTest(common.HeatTestCase):
rsrc = self.create_eip(t, stack, 'IPAddress')
self.assertEqual('11.0.0.1', rsrc.FnGetRefId())
# update with the new InstanceId
server_update = self.fc.servers.list()[1]
self.patchobject(self.fc.servers, 'get',
return_value=server_update)
iface = self.mock_interface('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa',
'1.2.3.4')
self.patchobject(server_update, 'interface_list', return_value=[iface])
props = copy.deepcopy(rsrc.properties.data)
update_server_id = '5678'
props['InstanceId'] = update_server_id
@ -317,12 +358,20 @@ class EIPTest(common.HeatTestCase):
self.m.VerifyAll()
def test_association_eip(self):
server = self.fc.servers.list()[0]
self._mock_server_get(mock_server=server, multiple=True)
mock_server = self.fc.servers.list()[0]
self.patchobject(self.fc.servers, 'get',
return_value=mock_server)
self.mock_create_floatingip()
self.mock_delete_floatingip()
self.mock_show_floatingip('fc68ea2c-b60b-4b4f-bd82-94ec81110766')
self.mock_update_floatingip()
self.mock_list_floatingips()
self.mock_list_floatingips()
self.mock_update_floatingip(delete_assc=True)
self.mock_delete_floatingip()
iface = self.mock_interface('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa',
'1.2.3.4')
self.patchobject(mock_server, 'interface_list', return_value=[iface])
self.m.ReplayAll()
t = template_format.parse(eip_template_ipassoc)
@ -424,6 +473,8 @@ class AllocTest(common.HeatTestCase):
'show_floatingip')
self.m.StubOutWithMock(neutronclient.Client,
'update_floatingip')
self.m.StubOutWithMock(neutronclient.Client,
'list_floatingips')
self.m.StubOutWithMock(neutronclient.Client,
'delete_floatingip')
self.m.StubOutWithMock(neutronclient.Client,
@ -435,6 +486,14 @@ class AllocTest(common.HeatTestCase):
self.m.StubOutWithMock(neutronclient.Client,
'remove_gateway_router')
def mock_interface(self, port, ip):
class MockIface(object):
def __init__(self, port_id, fixed_ip):
self.port_id = port_id
self.fixed_ips = [{'ip_address': fixed_ip}]
return MockIface(port, ip)
def _setup_test_stack_validate(self, stack_name):
t = template_format.parse(ipassoc_template_validate)
template = tmpl.Template(t)
@ -469,15 +528,18 @@ class AllocTest(common.HeatTestCase):
"id": "22c26451-cf27-4d48-9031-51f5e397b84e"
}})
def _mock_server_get(self, server='WebServer', mock_server=None,
multiple=False, mock_again=False):
if not mock_again:
nova.NovaClientPlugin._create().AndReturn(self.fc)
if multiple:
self.fc.servers.get(server).MultipleTimes().AndReturn(
mock_server)
else:
self.fc.servers.get(server).AndReturn(mock_server)
def _mock_server(self, mock_interface=False, mock_server=None):
self.patchobject(nova.NovaClientPlugin, '_create',
return_value=self.fc)
if not mock_server:
mock_server = self.fc.servers.list()[0]
self.patchobject(self.fc.servers, 'get',
return_value=mock_server)
if mock_interface:
iface = self.mock_interface('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa',
'1.2.3.4')
self.patchobject(mock_server,
'interface_list', return_value=[iface])
def create_eip(self, t, stack, resource_name):
rsrc = eip.ElasticIp(resource_name,
@ -502,11 +564,6 @@ class AllocTest(common.HeatTestCase):
rsrc.node_data())
return rsrc
def mock_update_floatingip(self, port='the_nic'):
neutronclient.Client.update_floatingip(
'fc68ea2c-b60b-4b4f-bd82-94ec81110766',
{'floatingip': {'port_id': port}}).AndReturn(None)
def mock_create_gateway_attachment(self):
neutronclient.Client.add_gateway_router(
'bbbb', {'network_id': 'eeee'}).AndReturn(None)
@ -532,6 +589,29 @@ class AllocTest(common.HeatTestCase):
"floating_ip_address": "11.0.0.1"
}})
def mock_update_floatingip(self,
fip='fc68ea2c-b60b-4b4f-bd82-94ec81110766',
port_id='aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa',
ex=None,
with_address=True,
delete_assc=False):
if delete_assc:
request_body = {
'floatingip': {'port_id': None}}
if with_address:
request_body['floatingip']['fixed_ip_address'] = None
else:
request_body = {
'floatingip': {'port_id': port_id}}
if with_address:
request_body['floatingip']['fixed_ip_address'] = '1.2.3.4'
if ex:
neutronclient.Client.update_floatingip(
fip, request_body).AndRaise(ex)
else:
neutronclient.Client.update_floatingip(
fip, request_body).AndReturn(None)
def mock_show_floatingip(self, refid):
neutronclient.Client.show_floatingip(
refid,
@ -545,6 +625,12 @@ class AllocTest(common.HeatTestCase):
'id': 'ffff'
}})
def mock_list_floatingips(self, ip_addr='11.0.0.1'):
neutronclient.Client.list_floatingips(
floating_ip_address=ip_addr).AndReturn({
'floatingips': [{'id':
"fc68ea2c-b60b-4b4f-bd82-94ec81110766"}]})
def mock_delete_floatingip(self):
id = 'fc68ea2c-b60b-4b4f-bd82-94ec81110766'
neutronclient.Client.delete_floatingip(id).AndReturn(None)
@ -620,9 +706,10 @@ class AllocTest(common.HeatTestCase):
self.mock_list_ports()
self.mock_show_floatingip('fc68ea2c-b60b-4b4f-bd82-94ec81110766')
self.mock_update_floatingip()
self.mock_update_floatingip(port_id='the_nic',
with_address=False)
self.mock_update_floatingip(port=None)
self.mock_update_floatingip(delete_assc=True, with_address=False)
self.mock_delete_floatingip()
self.m.ReplayAll()
@ -639,10 +726,7 @@ class AllocTest(common.HeatTestCase):
self.m.VerifyAll()
def test_association_allocationid_with_instance(self):
server = self.fc.servers.list()[0]
self._mock_server_get(server='1fafbe59-2332-4f5f-bfa4-517b4d6c1b65',
mock_server=server,
multiple=True)
self._mock_server()
self.mock_show_network()
self.mock_create_floatingip()
@ -650,9 +734,10 @@ class AllocTest(common.HeatTestCase):
self.mock_no_router_for_vpc()
self.mock_update_floatingip(
port='a000228d-b40b-4124-8394-a4082ae1b76c')
port_id='a000228d-b40b-4124-8394-a4082ae1b76c',
with_address=False)
self.mock_update_floatingip(port=None)
self.mock_update_floatingip(delete_assc=True, with_address=False)
self.mock_delete_floatingip()
self.m.ReplayAll()
@ -669,9 +754,9 @@ class AllocTest(common.HeatTestCase):
self.m.VerifyAll()
def test_validate_properties_EIP_and_AllocationId(self):
self._mock_server_get(server='1fafbe59-2332-4f5f-bfa4-517b4d6c1b65',
multiple=True)
self._mock_server()
self.m.ReplayAll()
template, stack = self._setup_test_stack_validate(
stack_name='validate_EIP_AllocationId')
@ -689,8 +774,7 @@ class AllocTest(common.HeatTestCase):
self.m.VerifyAll()
def test_validate_EIP_and_InstanceId(self):
self._mock_server_get(server='1fafbe59-2332-4f5f-bfa4-517b4d6c1b65',
multiple=True)
self._mock_server()
self.m.ReplayAll()
template, stack = self._setup_test_stack_validate(
stack_name='validate_EIP_InstanceId')
@ -703,8 +787,7 @@ class AllocTest(common.HeatTestCase):
self.m.VerifyAll()
def test_validate_without_NetworkInterfaceId_and_InstanceId(self):
self._mock_server_get(server='1fafbe59-2332-4f5f-bfa4-517b4d6c1b65',
multiple=True)
self._mock_server()
self.m.ReplayAll()
template, stack = self._setup_test_stack_validate(
stack_name='validate_EIP_InstanceId')
@ -727,15 +810,12 @@ class AllocTest(common.HeatTestCase):
self.m.VerifyAll()
def test_delete_association_successful_if_create_failed(self):
server = self.fc.servers.list()[0]
self._mock_server_get(mock_server=server, multiple=True)
self.m.StubOutWithMock(self.fc.servers, 'add_floating_ip')
self.fc.servers.add_floating_ip(server, '11.0.0.1').AndRaise(
fakes_nova.fake_exception(400))
self._mock_server(mock_interface=True)
self.mock_create_floatingip()
self.mock_show_floatingip('fc68ea2c-b60b-4b4f-bd82-94ec81110766')
self.mock_list_floatingips()
self.mock_update_floatingip(ex=q_exceptions.NotFound('Not Found'))
self.m.ReplayAll()
t = template_format.parse(eip_template_ipassoc)
stack = utils.parse_stack(t)
@ -755,16 +835,12 @@ class AllocTest(common.HeatTestCase):
self.m.VerifyAll()
def test_update_association_with_InstanceId(self):
server = self.fc.servers.list()[0]
self._mock_server_get(mock_server=server, multiple=True)
server_update = self.fc.servers.list()[1]
self._mock_server_get(server='5678',
mock_server=server_update,
multiple=True,
mock_again=True)
self._mock_server(mock_interface=True)
self.mock_create_floatingip()
self.mock_list_floatingips()
self.mock_update_floatingip()
self.mock_list_floatingips()
self.mock_update_floatingip()
self.m.ReplayAll()
t = template_format.parse(eip_template_ipassoc)
@ -772,7 +848,8 @@ class AllocTest(common.HeatTestCase):
self.create_eip(t, stack, 'IPAddress')
ass = self.create_association(t, stack, 'IPAssoc')
self.assertEqual('11.0.0.1', ass.properties['EIP'])
server_update = self.fc.servers.list()[1]
self._mock_server(mock_interface=True, mock_server=server_update)
# update with the new InstanceId
props = copy.deepcopy(ass.properties.data)
update_server_id = '5678'
@ -786,9 +863,14 @@ class AllocTest(common.HeatTestCase):
self.m.VerifyAll()
def test_update_association_with_EIP(self):
server = self.fc.servers.list()[0]
self._mock_server_get(mock_server=server, multiple=True)
self._mock_server(mock_interface=True)
self.mock_create_floatingip()
self.mock_list_floatingips()
self.mock_update_floatingip()
self.mock_list_floatingips()
self.mock_update_floatingip(delete_assc=True)
self.mock_list_floatingips(ip_addr='11.0.0.2')
self.mock_update_floatingip()
self.m.ReplayAll()
t = template_format.parse(eip_template_ipassoc)
@ -809,17 +891,22 @@ class AllocTest(common.HeatTestCase):
self.m.VerifyAll()
def test_update_association_with_AllocationId_or_EIP(self):
server = self.fc.servers.list()[0]
self._mock_server_get(mock_server=server, multiple=True)
self._mock_server(mock_interface=True)
self.mock_create_floatingip()
self.mock_list_instance_ports('WebServer')
self.mock_show_network()
self.mock_no_router_for_vpc()
self.mock_update_floatingip(
port='a000228d-b40b-4124-8394-a4082ae1b76c')
self.mock_list_floatingips()
self.mock_update_floatingip()
self.mock_update_floatingip(port=None)
self.mock_list_floatingips()
self.mock_update_floatingip(delete_assc=True)
self.mock_update_floatingip(
port_id='a000228d-b40b-4124-8394-a4082ae1b76c',
with_address=False)
self.mock_list_floatingips(ip_addr='11.0.0.2')
self.mock_update_floatingip(delete_assc=True, with_address=False)
self.mock_update_floatingip()
self.m.ReplayAll()
t = template_format.parse(eip_template_ipassoc)
@ -854,17 +941,11 @@ class AllocTest(common.HeatTestCase):
self.m.VerifyAll()
def test_update_association_needs_update_InstanceId(self):
server = self.fc.servers.list()[0]
self._mock_server_get(mock_server=server, multiple=True)
self._mock_server(mock_interface=True)
self.mock_create_floatingip()
self.mock_list_floatingips()
self.mock_show_floatingip('fc68ea2c-b60b-4b4f-bd82-94ec81110766')
server_update = self.fc.servers.list()[1]
self._mock_server_get(server='5678',
mock_server=server_update,
multiple=True,
mock_again=True)
self.mock_update_floatingip()
self.m.ReplayAll()
t = template_format.parse(eip_template_ipassoc)
@ -875,6 +956,8 @@ class AllocTest(common.HeatTestCase):
after_props = {'InstanceId': {'Ref': 'WebServer2'},
'EIP': '11.0.0.1'}
before = self.create_association(t, stack, 'IPAssoc')
update_server = self.fc.servers.list()[1]
self._mock_server(mock_interface=False, mock_server=update_server)
after = rsrc_defn.ResourceDefinition(before.name, before.type(),
after_props)
self.assertTrue(resource.UpdateReplace,
@ -882,17 +965,11 @@ class AllocTest(common.HeatTestCase):
before_props, None))
def test_update_association_needs_update_InstanceId_EIP(self):
server = self.fc.servers.list()[0]
self._mock_server_get(mock_server=server, multiple=True)
self._mock_server(mock_interface=True)
self.mock_create_floatingip()
self.mock_list_floatingips()
self.mock_show_floatingip('fc68ea2c-b60b-4b4f-bd82-94ec81110766')
server_update = self.fc.servers.list()[1]
self._mock_server_get(server='5678',
mock_server=server_update,
multiple=True,
mock_again=True)
self.mock_update_floatingip()
self.m.ReplayAll()
t = template_format.parse(eip_template_ipassoc)
@ -901,6 +978,8 @@ class AllocTest(common.HeatTestCase):
after_props = {'InstanceId': '5678',
'EIP': '11.0.0.2'}
before = self.create_association(t, stack, 'IPAssoc')
update_server = self.fc.servers.list()[1]
self._mock_server(mock_interface=False, mock_server=update_server)
after = rsrc_defn.ResourceDefinition(before.name, before.type(),
after_props)
updater = scheduler.TaskRunner(before.update, after)
@ -911,21 +990,19 @@ class AllocTest(common.HeatTestCase):
self.mock_list_ports()
self.mock_show_network()
self.mock_no_router_for_vpc()
self.mock_update_floatingip()
self.mock_update_floatingip(port_id='the_nic', with_address=False)
self.mock_list_ports(id='a000228d-b40b-4124-8394-a4082ae1b76b')
self.mock_show_network()
self.mock_no_router_for_vpc()
self.mock_update_floatingip(
port='a000228d-b40b-4124-8394-a4082ae1b76b')
port_id='a000228d-b40b-4124-8394-a4082ae1b76b', with_address=False)
update_server = self.fc.servers.list()[0]
self._mock_server_get(server='5678', mock_server=update_server)
self.mock_list_instance_ports('5678')
self.mock_show_network()
self.mock_no_router_for_vpc()
self.mock_update_floatingip(
port='a000228d-b40b-4124-8394-a4082ae1b76c')
port_id='a000228d-b40b-4124-8394-a4082ae1b76c', with_address=False)
self.m.ReplayAll()
@ -946,6 +1023,9 @@ class AllocTest(common.HeatTestCase):
self.assertEqual((ass.UPDATE, ass.COMPLETE), ass.state)
# update with the InstanceId
update_server = self.fc.servers.list()[1]
self._mock_server(mock_server=update_server)
props = copy.deepcopy(ass.properties.data)
instance_id = '5678'
props.pop('NetworkInterfaceId')