def test_provision_vip_port_update_need_update(self, mock_conn):
vip_spec = {
'name': 'network1_virtual_ip',
'network': 'network1',
'ip_address': '11.22.33.44',
'dns_name': 'overcloud'
}
fake_port = stubs.FakeNeutronPort(
id='port_id',
name='network1_virtual_ip',
network_id='network1_id',
fixed_ips=[{
'ip_address': '1.2.3.4'
}],
dns_name='overcloud',
tags=['tripleo_stack_name=stack', 'tripleo_vip_net=network1'])
port_def = {
'dns_name': 'overcloud',
'fixed_ips': [{
'ip_address': '11.22.33.44'
}],
'name': 'network1_virtual_ip'
}
mock_conn.network.ports.return_value = self.a2g([fake_port])
managed_ports = list()
plugin.provision_vip_port(mock_conn, 'stack', NET_MAPS, vip_spec,
managed_ports)
self.assertEqual([fake_port.id], managed_ports)
mock_conn.network.create_port.assert_not_called()
mock_conn.network.update_port.assert_called_with(
fake_port.id, **port_def)
mock_conn.network.set_tags.assert_not_called()
def test_update_port(self, mock_conn):
fixed_ips = [{'subnet': 'test'}]
fake_net = stubs.FakeNeutronNetwork(name='test', id='net_id')
fake_subnet = stubs.FakeNeutronSubnet(name='test', id='subnet_id')
fake_port = stubs.FakeNeutronPort(name='test_virtual_ip',
id='port_id',
fixed_ips=[{
'ip_address': '10.0.0.10',
'subnet_id': 'subnet_id'
}],
tags=[])
mock_conn.network.find_subnet.return_value = fake_subnet
mock_conn.network.ports.return_value = self.a2g([fake_port])
mock_conn.network.update_port.return_value = fake_port
plugin.create_or_update_port(mock_conn,
fake_net,
stack='test',
service='test',
fixed_ips=fixed_ips)
mock_conn.network.create_port.assert_not_called()
mock_conn.network.update_port.assert_called_once_with(
fake_port,
name='test_virtual_ip',
network_id='net_id',
fixed_ips=[{
'subnet_id': 'subnet_id'
}])
mock_conn.network.set_tags.assert_called_once_with(
fake_port, [mock.ANY, mock.ANY])
def test_find_ctlplane_vip(self, mock_conn):
fake_network = stubs.FakeNeutronNetwork(id='ctlplane_id',
name='ctlplane')
fake_subnet = stubs.FakeNeutronSubnet(id='ctlplane_subnet_id',
name='ctlplane-subnet')
fake_vip_port = stubs.FakeNeutronPort(id='ctlplane_vip_id',
name='control_virtual_ip',
fixed_ips=[{
'subnet_id':
'ctlplane_subnet_id',
'ip_address':
'4.3.2.1'
}],
dns_name='ctlplane.localdomain')
mock_conn.network.find_network.return_value = fake_network
mock_conn.network.get_subnet.return_value = fake_subnet
mock_conn.network.ports.return_value = self.a2g([fake_vip_port])
vip_data = list()
plugin.find_ctlplane_vip(mock_conn, vip_data)
self.assertEqual([{
'name': 'control_virtual_ip',
'network': 'ctlplane',
'subnet': 'ctlplane-subnet',
'ip_address': '4.3.2.1',
'dns_name': 'ctlplane.localdomain'
}], vip_data)
def test__tag_metalsmith_instance_ports(self, mock_provisioner, mock_conn):
result = {'changed': False}
tags = {'tripleo_stack_name={}'.format(STACK),
'tripleo_ironic_uuid=ironic_uuid',
'tripleo_role=role',
'tripleo_ironic_vif_port=true'}
expected_tags = copy.deepcopy(tags)
expected_tags.update({'tripleo_default_route=true'})
fake_nic = stubs.FakeNeutronPort(name='hostname-ctlplane',
network_id='ctlplane_id',
id='port_uuid',
tags=[])
fake_instance = mock.Mock()
fake_instance.nics.return_value = [fake_nic]
mock_provisioner.show_instance.return_value = fake_instance
network_config = FAKE_INSTANCE['network_config']
default_route_network = network_config['default_route_network']
plugin._tag_metalsmith_instance_ports(result, mock_conn,
mock_provisioner, 'ironic_uuid',
'hostname', tags,
default_route_network, FAKE_MAPS)
mock_conn.network.set_tags.assert_called_with(fake_nic, mock.ANY)
set_tags_args = mock_conn.network.set_tags.call_args.args
self.assertEqual(set(expected_tags), set(set_tags_args[1]))
self.assertTrue(result['changed'])
def test__tag_metalsmith_instance_ports_tags_already_set(
self, mock_provisioner, mock_conn):
result = {'changed': False}
tags = {'tripleo_stack_name={}'.format(STACK),
'tripleo_ironic_uuid=ironic_uuid',
'tripleo_role=role',
'tripleo_ironic_vif_port=true'}
fake_nic = stubs.FakeNeutronPort(
name='hostname-ctlplane', dns_name='hostname', id='port_uuid',
network_id='ctlplane_id',
tags=['tripleo_stack_name={}'.format(STACK),
'tripleo_ironic_uuid=ironic_uuid',
'tripleo_role=role',
'tripleo_ironic_vif_port=true',
'tripleo_default_route=true'])
fake_instance = mock.Mock()
fake_instance.nics.return_value = [fake_nic]
mock_provisioner.show_instance.return_value = fake_instance
network_config = FAKE_INSTANCE['network_config']
default_route_network = network_config['default_route_network']
plugin._tag_metalsmith_instance_ports(
result, mock_conn, mock_provisioner, 'ironic_uuid', 'hostname',
tags, default_route_network, FAKE_MAPS)
mock_conn.network.set_tags.assert_not_called()
self.assertFalse(result['changed'])
def test__unprovision_ports(self, mock_conn, mock_delete_ports):
result = {'changed': False, 'instance_port_map': {}}
port_foo = stubs.FakeNeutronPort(
name='instance_foo',
dns_name='instance0',
network_id='foo_id',
fixed_ips=[{'subnet_id': 'foo_subnet_id'}])
port_bar = stubs.FakeNeutronPort(
name='instance_bar',
dns_name='instance0',
network_id='bar_id',
fixed_ips=[{'subnet_id': 'bar_subnet_id'}])
mock_conn.network.ports.return_value = self.a2g([port_foo, port_bar])
plugin._unprovision_ports(result, mock_conn, STACK, FAKE_INSTANCE,
None)
mock_delete_ports.assert_called_with(mock_conn, [port_foo, port_bar])
self.assertTrue(result['changed'])
def test_create_ports(self, mock_conn):
result = {'changed': False}
inst_ports = []
network_config = {'default_route_network': ['foo']}
tags = set(['tripleo_stack_name=overcloud',
'tripleo_ironic_uuid=ironic_uuid'])
expected_tags = copy.deepcopy(tags)
port_foo = stubs.FakeNeutronPort(
name='instance0_foo', network_id='foo_id',
fixed_ips=[{'subnet_id': 'foo_subnet_id'}])
port_bar = stubs.FakeNeutronPort(
name='instance0_bar', network_id='bar_id',
fixed_ips=[{'subnet_id': 'bar_subnet_id'}])
create_port_defs = [
dict(name='instance0_foo', network_id='foo_id',
fixed_ips=[{'subnet_id': 'foo_subnet_id'}]),
dict(name='instance0_bar', network_id='bar_id',
fixed_ips=[{'subnet_id': 'bar_subnet_id'}]),
]
mock_conn.network.create_ports.return_value = self.a2g(
[port_foo, port_bar])
plugin.create_ports(result, mock_conn, create_port_defs, inst_ports,
tags, FAKE_MAPS, network_config)
mock_conn.network.create_ports.assert_has_calls([
mock.call([
{'name': 'instance0_foo',
'network_id': 'foo_id',
'fixed_ips': [{'subnet_id': 'foo_subnet_id'}]},
{'name': 'instance0_bar',
'network_id': 'bar_id',
'fixed_ips': [{'subnet_id': 'bar_subnet_id'}]}
])
])
mock_conn.network.set_tags.assert_has_calls([
mock.call(port_foo, mock.ANY),
mock.call(port_bar, mock.ANY)
])
set_tag_args = mock_conn.network.set_tags.call_args_list
self.assertEqual(set(set_tag_args[1][0][1]), expected_tags)
# Default route tag only on the 'foo' network port
expected_tags.update({'tripleo_default_route=true'})
self.assertEqual(set(set_tag_args[0][0][1]), expected_tags)
self.assertEqual([port_foo, port_bar], inst_ports)
self.assertTrue(result['changed'])
def test_generate_port_defs_update(self):
port_foo = stubs.FakeNeutronPort(
name='instance0_Foo', network_id='foo_id',
fixed_ips=[{'subnet_id': 'foo_subnet_id'}])
port_bar = stubs.FakeNeutronPort(
name='instance0_Bar', network_id='bar_id',
fixed_ips=[{'subnet_id': 'bar_subnet_id'}])
inst_ports = [port_foo, port_bar]
create_port_defs, update_port_defs = plugin.generate_port_defs(
FAKE_MAPS, FAKE_INSTANCE, inst_ports)
self.assertEqual([], create_port_defs)
self.assertEqual([
{'name': 'instance0_Foo',
'dns_name': 'instance0',
'network_id': 'foo_id',
'fixed_ips': [{'subnet_id': 'foo_subnet_id'}]},
{'name': 'instance0_Bar',
'dns_name': 'instance0',
'network_id': 'bar_id',
'fixed_ips': [{'subnet_id': 'bar_subnet_id'}]}
], update_port_defs)
def test__provision_ports_update(self, mock_conn, mock_pre_provisioned,
mock_create_ports, mock_update_ports):
port_foo = stubs.FakeNeutronPort(
name='instance0_Foo',
dns_name='instance0',
network_id='foo_id',
fixed_ips=[{'subnet_id': 'foo_subnet_id'}],
tags=[])
port_bar = stubs.FakeNeutronPort(
name='instance0_Bar',
dns_name='instance0',
network_id='bar_id',
fixed_ips=[{'subnet_id': 'bar_subnet_id'}],
tags=[])
update_port_defs = [
dict(name='instance0_Foo',
dns_name='instance0',
network_id='foo_id',
fixed_ips=[{'subnet_id': 'foo_subnet_id'}]),
dict(name='instance0_Bar',
dns_name='instance0',
network_id='bar_id',
fixed_ips=[{'subnet_id': 'bar_subnet_id'}]),
]
expected_tags = {'tripleo_ironic_uuid=ironic_uuid',
'tripleo_role=role',
'tripleo_stack_name=overcloud'}
network_config = FAKE_INSTANCE['network_config']
mock_conn.network.ports.return_value = self.a2g([port_foo, port_bar])
plugin._provision_ports({}, mock_conn, STACK, FAKE_INSTANCE,
FAKE_MAPS, {}, 'ironic_uuid', 'role')
mock_pre_provisioned.assert_called_with(mock.ANY, mock_conn,
FAKE_MAPS, FAKE_INSTANCE,
mock.ANY, expected_tags)
mock_create_ports.assert_not_called()
mock_update_ports.assert_called_with(mock.ANY, mock_conn,
update_port_defs,
[port_foo, port_bar],
expected_tags, FAKE_MAPS,
network_config)
def test_remove_obsolete_ports_does_not_delete_managed(self, mock_conn):
fake_port = stubs.FakeNeutronPort(
id='port_id',
name='network1_virtual_ip',
network_id='network1_id',
fixed_ips=[{
'ip_address': '1.2.3.4'
}],
dns_name='overcloud',
tags=['tripleo_stack_name=stack', 'tripleo_vip_net=network1'])
mock_conn.network.ports.return_value = self.a2g([fake_port])
plugin.remove_obsolete_ports(mock_conn, 'stack', [fake_port.id])
mock_conn.network.delete_port.assert_not_called()
def test_generate_node_port_map(self):
result = dict(node_port_map=dict())
ports_by_node = dict(
node01=[
stubs.FakeNeutronPort(
network_id='foo_id',
fixed_ips=[{'ip_address': '192.168.24.1',
'subnet_id': 'foo_id'}]),
stubs.FakeNeutronPort(
network_id='bar_id',
fixed_ips=[{'ip_address': '2001:DB8:1::1',
'subnet_id': 'bar_id'}])],
node02=[
stubs.FakeNeutronPort(
network_id='foo_id',
fixed_ips=[{'ip_address': '192.168.24.1',
'subnet_id': 'foo_id'}]),
stubs.FakeNeutronPort(
network_id='bar_id',
fixed_ips=[{'ip_address': '2001:DB8:1::2',
'subnet_id': 'bar_id'}])]
)
plugin.generate_node_port_map(result, FAKE_MAPS, ports_by_node)
self.assertEqual(
{'node01': {'bar': {'ip_address': '2001:DB8:1::1',
'ip_address_uri': '[2001:DB8:1::1]',
'ip_subnet': '2001:DB8:1::1/64'},
'foo': {'ip_address': '192.168.24.1',
'ip_address_uri': '192.168.24.1',
'ip_subnet': '192.168.24.1/24'}},
'node02': {'bar': {'ip_address': '2001:DB8:1::2',
'ip_address_uri': '[2001:DB8:1::2]',
'ip_subnet': '2001:DB8:1::2/64'},
'foo': {'ip_address': '192.168.24.1',
'ip_address_uri': '192.168.24.1',
'ip_subnet': '192.168.24.1/24'}}},
result['node_port_map'])
def test_fixed_ips_need_update(self):
fake_port = stubs.FakeNeutronPort(
fixed_ips=[{'ip_address': '192.168.24.24', 'subnet_id': 'foo_id'}])
port_def = {'fixed_ips': [{'ip_address': '192.168.24.24'}]}
self.assertFalse(plugin.fixed_ips_need_update(port_def, fake_port))
port_def = {'fixed_ips': [{'subnet_id': 'foo_id'}]}
self.assertFalse(plugin.fixed_ips_need_update(port_def, fake_port))
port_def = {'fixed_ips': [{'subnet_id': 'bar_id'}]}
self.assertTrue(plugin.fixed_ips_need_update(port_def, fake_port))
port_def = {'fixed_ips': [{'subnet_id': 'foo_id'},
{'ip_address': '192.168.25.24'}]}
self.assertTrue(plugin.fixed_ips_need_update(port_def, fake_port))
def test_is_vip_network_true(self, conn_mock):
net_name = 'external'
net_id = '132f871f-eaec-4fed-9475-0d54465e0f00'
fake_network = stubs.FakeNeutronNetwork(id=net_id, name=net_name)
fake_port = stubs.FakeNeutronPort(name='{}{}'.format(
net_name, plugin.NET_VIP_SUFFIX),
fixed_ips=[{
'ip_address': '10.10.10.10',
'subnet_id': 'foo'
}])
conn_mock.network.get_network.return_value = fake_network
conn_mock.network.ports.return_value = (x for x in [fake_port])
result = plugin.is_vip_network(conn_mock, net_id)
self.assertEqual(True, result)
def test_find_ctlplane_vip_found(self, mock_conn):
tags = ['tripleo_stack_name=overcloud', 'tripleo_vip_net=ctlplane']
fake_port = stubs.FakeNeutronPort(
name='test_virtual_ip',
id='port_id',
fixed_ips=[{
'ip_address': '10.0.0.10',
'subnet_id': 'subnet_id'
}],
tags=['tripleo_stack_name=overcloud', 'tripleo_vip_net=ctlplane'])
mock_conn.network.ports.return_value = self.a2g([fake_port])
port = plugin.find_ctlplane_vip(mock_conn,
stack='overcloud',
service='test')
mock_conn.network.ports.assert_called_once_with(tags=tags)
self.assertEqual(fake_port, port)
def test_find_net_vips(self, mock_conn):
fake_net_resources = {
'StorageNetwork': {
'InternalApiNetwork': {
'physical_resource_id': 'fake-id',
'resource_type': n_utils.TYPE_NET
},
'StorageSubnet': {
'physical_resource_id': 'fake-id',
'resource_type': n_utils.TYPE_SUBNET
},
'StorageSubnet_leaf1': {
'physical_resource_id': 'fake-id',
'resource_type': n_utils.TYPE_SUBNET
}
}
}
fake_network = stubs.FakeNeutronNetwork(id='internal_api_id',
name='internal_api')
fake_subnet = stubs.FakeNeutronSubnet(id='internal_api_subnet_id',
name='internal_api_subnet')
fake_vip_port = stubs.FakeNeutronPort(
id='internal_api_vip_id',
name='internal_api_virtual_ip',
fixed_ips=[{
'subnet_id': 'internal_api_subnet_id',
'ip_address': '1.2.3.4'
}],
dns_name='internalapi.localdomain')
mock_conn.network.get_network.return_value = fake_network
mock_conn.network.get_subnet.return_value = fake_subnet
mock_conn.network.ports.return_value = self.a2g([fake_vip_port])
vip_data = list()
plugin.find_net_vips(mock_conn, fake_net_resources, vip_data)
self.assertEqual([{
'name': 'internal_api_virtual_ip',
'network': 'internal_api',
'subnet': 'internal_api_subnet',
'ip_address': '1.2.3.4',
'dns_name': 'internalapi.localdomain'
}], vip_data)
def test_pre_provisioned_ports(self, mock_conn):
result = {'changed': False}
inst_ports = []
tags = set(['tripleo_stack_name=overcloud',
'tripleo_ironic_uuid=ironic_uuid'])
fake_instance = copy.deepcopy(FAKE_INSTANCE)
fake_instance['networks'] = [{'network': 'foo', 'port': 'some_port'}]
some_port = stubs.FakeNeutronPort(name='some_port',
id='some_port_id',
tags=[])
mock_conn.network.find_port.return_value = some_port
plugin.pre_provisioned_ports(result, mock_conn, FAKE_MAPS,
fake_instance, inst_ports, tags)
mock_conn.network.find_port.assert_called_with(
'some_port', network_id=FAKE_NET_NAME_MAP['foo']['id'])
mock_conn.network.set_tags.assert_called_with(some_port, mock.ANY)
set_tags_args = mock_conn.network.set_tags.call_args.args
self.assertTrue(tags == set(set_tags_args[1]))
self.assertEqual([some_port], inst_ports)
self.assertTrue(result['changed'])
from ansible.module_utils import network_data_v2 as n_utils
except ImportError:
from tripleo_ansible.ansible_plugins.module_utils import network_data_v2 as n_utils # noqa
from tripleo_ansible.ansible_plugins.modules import (tripleo_ovn_mac_addresses
as plugin)
from tripleo_ansible.tests import base as tests_base
from tripleo_ansible.tests import stubs
FAKE_NETWORK = stubs.FakeNeutronNetwork(name=plugin.NET_NAME,
id='fake_ovn_mac_addr_net_id',
description=plugin.NET_DESCRIPTION)
FAKE_PORT = stubs.FakeNeutronPort(name='server-01_ovn_physnet_network01',
dns_name='server-01',
tags=[
'tripleo_ovn_physnet=network01',
'tripleo_stack_name=stack',
'tripleo_role_name=Compute'
])
@mock.patch.object(openstack.connection, 'Connection', autospec=True)
class TestTripleoOVNMacAddresses(tests_base.TestCase):
def setUp(self):
super(TestTripleoOVNMacAddresses, self).setUp()
# Helper function to convert array to generator
self.a2g = lambda x: (n for n in x)
def test_create_ovn_mac_address_network(self, mock_conn):
result = dict(changed=False)
def test_delete_ports(self, mock_conn):
port1 = stubs.FakeNeutronPort(id='port1_id')
port2 = stubs.FakeNeutronPort(id='port2_id')
plugin.delete_ports(mock_conn, [port1, port2])
mock_conn.network.delete_port.assert_has_calls([mock.call('port1_id'),
mock.call('port2_id')])
ip_version=4)
fake_internal_api_subnet = stubs.FakeNeutronSubnet(id='internal_api_subnet_id',
name='internal_api_subnet',
cidr='10.0.1.0/24')
fake_storage_mgmt_subnet = stubs.FakeNeutronSubnet(id='storage_mgmt_subnet_id',
name='storage_mgmt_subnet',
cidr='10.0.3.0/24')
fake_external_subnet = stubs.FakeNeutronSubnet(id='external_subnet_id',
name='external_subnet',
cidr='10.0.5.0/24')
fake_ctlplane_port = stubs.FakeNeutronPort(
name='control_virtual_ip',
id='ctlplane_port_id',
dns_name='overcloud',
fixed_ips=[{
'ip_address': '192.168.24.1',
'subnet_id': 'ctlplane_subnet_id'
}],
tags=['tripleo_stack_name=stack', 'tripleo_vip_net=ctlplane'])
fake_internal_api_port = stubs.FakeNeutronPort(
id='internal_api_port_id',
dns_name='overcloud',
fixed_ips=[{
'ip_address': '10.0.1.1',
'subnet_id': 'internal_api_subnet_id'
}],
tags=['tripleo_stack_name=stack', 'tripleo_vip_net=internal_api'])
fake_storage_mgmt_port = stubs.FakeNeutronPort(
id='storage_mgmt_port_id',
dns_name='overcloud',
