def test_update_ips_for_port_passes_port_dict_to_factory(self, pool_mock):
address_factory = mock.Mock()
mocks = self._prepare_mocks_with_pool_mock(
pool_mock, address_factory=address_factory)
context = mock.Mock()
new_ips = mock.Mock()
original_ips = mock.Mock()
mac = mock.Mock()
ip_dict = {
'ip_address': '192.1.1.10',
'subnet_id': uuidutils.generate_uuid()
}
changes = ipam_pluggable_backend.IpamPluggableBackend.Changes(
add=[ip_dict], original=[], remove=[])
changes_mock = mock.Mock(return_value=changes)
fixed_ips_mock = mock.Mock(return_value=changes.add)
mocks['ipam'] = ipam_pluggable_backend.IpamPluggableBackend()
mocks['ipam']._get_changed_ips_for_port = changes_mock
mocks['ipam']._test_fixed_ips_for_port = fixed_ips_mock
port_dict = {
'device_owner': uuidutils.generate_uuid(),
'network_id': uuidutils.generate_uuid()
}
mocks['ipam']._update_ips_for_port(context, port_dict, original_ips,
new_ips, mac)
mocks['driver'].get_address_request_factory.assert_called_once_with()
# Validate port_dict is passed into address_factory
address_factory.get_request.assert_called_once_with(
context, port_dict, ip_dict)
def _test_update_db_subnet(self, pool_mock, subnet, expected_subnet,
old_pools):
subnet_factory = mock.Mock()
context = mock.Mock()
mocks = self._prepare_mocks_with_pool_mock(
pool_mock, subnet_factory=subnet_factory)
mocks['ipam'] = ipam_pluggable_backend.IpamPluggableBackend()
mocks['ipam'].update_db_subnet(context, id, subnet, old_pools)
mocks['driver'].get_subnet_request_factory.assert_called_once_with()
subnet_factory.get_request.assert_called_once_with(
context, expected_subnet, None)
def test_test_fixed_ips_for_port_pd_gateway(self):
pluggable_backend = ipam_pluggable_backend.IpamPluggableBackend()
with self.subnet(cidr=constants.PROVISIONAL_IPV6_PD_PREFIX,
ip_version=constants.IP_VERSION_6) as subnet:
subnet = subnet['subnet']
fixed_ips = [{'subnet_id': subnet['id'], 'ip_address': '::1'}]
filtered_ips = (pluggable_backend._test_fixed_ips_for_port(
subnet['network_id'], fixed_ips,
constants.DEVICE_OWNER_ROUTER_INTF, [subnet]))
# Assert that ports created on prefix delegation subnets
# will be returned without an ip address. This prevents router
# interfaces being given the ::1 gateway address.
self.assertEqual(1, len(filtered_ips))
self.assertEqual(subnet['id'], filtered_ips[0]['subnet_id'])
self.assertNotIn('ip_address', filtered_ips[0])
def test_update_db_subnet_new_pools_exception(self, pool_mock):
context = mock.Mock()
mocks = self._prepare_mocks_with_pool_mock(pool_mock)
mocks['ipam'] = ipam_pluggable_backend.IpamPluggableBackend()
new_port = {'fixed_ips': [{'ip_address': '192.168.1.20',
'subnet_id': uuidutils.generate_uuid()},
{'ip_address': '192.168.1.50',
'subnet_id': uuidutils.generate_uuid()}]}
db_port = port_obj.Port(context,
id=uuidutils.generate_uuid(),
network_id=uuidutils.generate_uuid())
old_port = {'fixed_ips': [{'ip_address': '192.168.1.10',
'subnet_id': uuidutils.generate_uuid()},
{'ip_address': '192.168.1.50',
'subnet_id': uuidutils.generate_uuid()}]}
changes = mocks['ipam'].Changes(
add=[{'ip_address': '192.168.1.20',
'subnet_id': uuidutils.generate_uuid()}],
original=[{'ip_address': '192.168.1.50',
'subnet_id': uuidutils.generate_uuid()}],
remove=[{'ip_address': '192.168.1.10',
'subnet_id': uuidutils.generate_uuid()}])
mocks['ipam']._delete_ip_allocation = mock.Mock()
mocks['ipam']._make_port_dict = mock.Mock(return_value=old_port)
mocks['ipam']._update_ips_for_port = mock.Mock(return_value=changes)
mocks['ipam']._update_db_port = mock.Mock(
side_effect=db_exc.DBDeadlock)
# emulate raising exception on rollback actions
mocks['ipam']._ipam_deallocate_ips = mock.Mock(side_effect=ValueError)
mocks['ipam']._ipam_allocate_ips = mock.Mock(side_effect=ValueError)
# Validate original exception (DBDeadlock) is not overridden by
# exception raised on rollback (ValueError)
with mock.patch.object(port_obj.IPAllocation, 'create'):
self.assertRaises(db_exc.DBDeadlock,
mocks['ipam'].update_port_with_ips,
context,
None,
db_port,
new_port,
mock.Mock())
mocks['ipam']._ipam_deallocate_ips.assert_called_once_with(
context, mocks['driver'], db_port,
changes.add, revert_on_fail=False)
mocks['ipam']._ipam_allocate_ips.assert_called_once_with(
context, mocks['driver'], db_port,
changes.remove, revert_on_fail=False)
def test_update_ips_for_port_passes_port_id_to_factory(self, pool_mock):
port_id = uuidutils.generate_uuid()
network_id = uuidutils.generate_uuid()
address_factory = mock.Mock()
mocks = self._prepare_mocks_with_pool_mock(
pool_mock, address_factory=address_factory)
context = mock.Mock()
ip_dict = {
'ip_address': '192.1.1.10',
'subnet_id': uuidutils.generate_uuid()
}
port_dict = {
'port': {
'device_owner': uuidutils.generate_uuid(),
'network_id': network_id,
'fixed_ips': [ip_dict]
}
}
subnets = [{
'id': ip_dict['subnet_id'],
'network_id': network_id,
'cidr': '192.1.1.0/24',
'ip_version': constants.IP_VERSION_4,
'ipv6_address_mode': None,
'ipv6_ra_mode': None
}]
get_subnets_mock = mock.Mock(return_value=subnets)
get_subnet_mock = mock.Mock(return_value=subnets[0])
mocks['ipam'] = ipam_pluggable_backend.IpamPluggableBackend()
mocks['ipam']._ipam_get_subnets = get_subnets_mock
mocks['ipam']._get_subnet = get_subnet_mock
with mock.patch.object(port_obj.IPAllocation, 'create'):
mocks['ipam'].allocate_ips_for_port_and_store(
context, port_dict, port_id)
mocks['driver'].get_address_request_factory.assert_called_once_with()
port_dict_with_id = port_dict['port'].copy()
port_dict_with_id['id'] = port_id
# Validate port id is added to port dict before address_factory call
ip_dict.pop('device_owner')
address_factory.get_request.assert_called_once_with(
context, port_dict_with_id, ip_dict)
# Verify incoming port dict is not changed ('id' is not added to it)
self.assertIsNone(port_dict['port'].get('id'))
def _test_update_db_subnet(self, pool_mock, subnet, expected_subnet,
old_pools):
subnet_factory = mock.Mock()
context = self.admin_context
if 'cidr' in subnet:
subnet['cidr'] = netaddr.IPNetwork(subnet['cidr'])
if 'cidr' in expected_subnet:
expected_subnet['cidr'] = netaddr.IPNetwork(
expected_subnet['cidr'])
mocks = self._prepare_mocks_with_pool_mock(
pool_mock, subnet_factory=subnet_factory)
mocks['ipam'] = ipam_pluggable_backend.IpamPluggableBackend()
mocks['ipam'].update_db_subnet(context, subnet['id'], subnet,
old_pools)
mocks['driver'].get_subnet_request_factory.assert_called_once_with()
subnet_factory.get_request.assert_called_once_with(
context, expected_subnet, None)
def test_update_ips_for_port_ovn_distributed_svc(self, pool_mock):
address_factory = mock.Mock()
mocks = self._prepare_mocks_with_pool_mock(
pool_mock, address_factory=address_factory)
context = mock.Mock()
new_ips = mock.Mock()
original_ips = mock.Mock()
mac = mock.Mock()
ip_dict = {
'ip_address': '192.1.1.10',
'subnet_id': uuidutils.generate_uuid()
}
changes = ipam_pluggable_backend.IpamPluggableBackend.Changes(
add=[ip_dict], original=[], remove=[])
changes_mock = mock.Mock(return_value=changes)
fixed_ips_mock = mock.Mock(return_value=changes.add)
mocks['ipam'] = ipam_pluggable_backend.IpamPluggableBackend()
mocks['ipam']._get_changed_ips_for_port = changes_mock
mocks['ipam']._ipam_get_subnets = mock.Mock(return_value=[])
mocks['ipam']._test_fixed_ips_for_port = fixed_ips_mock
mocks['ipam']._update_ips_for_pd_subnet = mock.Mock(return_value=[])
port_dict = {
'device_owner': constants.DEVICE_OWNER_DISTRIBUTED,
'device_id': 'ovnmeta-%s' % uuidutils.generate_uuid(),
'network_id': uuidutils.generate_uuid()
}
mocks['ipam']._update_ips_for_port(context, port_dict, None,
original_ips, new_ips, mac)
mocks['ipam']._ipam_get_subnets.assert_called_once_with(
context,
network_id=port_dict['network_id'],
fixed_configured=True,
fixed_ips=[ip_dict],
host=None,
service_type=port_dict['device_owner'],
distributed_service=True)
def _prepare_ipam(self):
mocks = self._prepare_mocks()
mocks['ipam'] = ipam_pluggable_backend.IpamPluggableBackend()
return mocks
def set_ipam_backend(self):
if cfg.CONF.ipam_driver:
self.ipam = ipam_pluggable_backend.IpamPluggableBackend()
else:
self.ipam = ipam_non_pluggable_backend.IpamNonPluggableBackend()