def _create_router(self, distributed=True, ha=False):
with self.ctx.session.begin(subtransactions=True):
self.ctx.session.add(l3_models.Router(id=TEST_ROUTER_ID))
l3_objs.RouterExtraAttributes(self.ctx,
router_id=TEST_ROUTER_ID,
distributed=distributed,
ha=ha).create()
def test_add_router_interface_no_interface_info(self):
router_db = l3_models.Router(id='123')
with mock.patch.object(l3_db.L3_NAT_dbonly_mixin,
'_get_router',
return_value=router_db):
self.assertRaises(n_exc.BadRequest, self.db.add_router_interface,
mock.Mock(), router_db.id)
def test_delete_flavor_in_use(self):
# make use of router since it has a flavor id
fl, data = self._create_flavor()
with self.ctx.session.begin():
self.ctx.session.add(l3_models.Router(flavor_id=fl['id']))
self.assertRaises(flavors.FlavorInUse, self.plugin.delete_flavor,
self.ctx, fl['id'])
def test_delete_flavor_in_use(self):
# make use of router since it has a flavor id
fl, data = self._create_flavor()
with db_api.CONTEXT_WRITER.using(self.ctx):
self.ctx.session.add(l3_models.Router(flavor_id=fl['id']))
self.assertRaises(flav_exc.FlavorInUse, self.plugin.delete_flavor,
self.ctx, fl['id'])
def _test_create_router(self, external_gateway_info=None):
router_db = l3_models.Router(id='123')
router_dict = {
'id': '123',
'tenant_id': '456',
'external_gateway_info': external_gateway_info
}
# Need to use a copy here as the create_router method pops the gateway
# information
router_input = {'router': router_dict.copy()}
with mock.patch.object(l3_db.L3_NAT_dbonly_mixin, '_create_router_db',
return_value=router_db) as crd,\
mock.patch.object(l3_db.L3_NAT_dbonly_mixin, '_make_router_dict',
return_value=router_dict),\
mock.patch.object(l3_db.L3_NAT_dbonly_mixin,
'_update_router_gw_info') as urgi,\
mock.patch.object(l3_db.L3_NAT_dbonly_mixin, '_get_router',
return_value=router_db),\
mock.patch.object(l3_db.L3_NAT_db_mixin, 'notify_router_updated')\
as nru:
self.db.create_router(mock.Mock(), router_input)
self.assertTrue(crd.called)
if external_gateway_info:
self.assertTrue(urgi.called)
self.assertTrue(nru.called)
else:
self.assertFalse(urgi.called)
self.assertFalse(nru.called)
def test_vpn_service_validation_router(self):
db_router = l3_models.Router()
nsx_router = {'high_availability_mode': 'ACITVE_ACTIVE'}
db_router.enable_snat = False
with mock.patch.object(self.validator.nsxlib.logical_router,
'get',
return_value=nsx_router):
self.assertRaises(nsx_exc.NsxVpnValidationError,
self.validator.validate_vpnservice, self.context,
self.vpn_service)
nsx_router = {'high_availability_mode': 'ACTIVE_STANDBY'}
db_router.enable_snat = True
with mock.patch.object(self.validator.nsxlib.logical_router, 'get',
return_value=nsx_router),\
mock.patch.object(self.validator._core_plugin, '_get_router',
return_value=db_router):
self.assertRaises(nsx_exc.NsxVpnValidationError,
self.validator.validate_vpnservice, self.context,
self.vpn_service)
nsx_router = {'high_availability_mode': 'ACTIVE_STANDBY'}
db_router.enable_snat = False
with mock.patch.object(self.validator.nsxlib.logical_router, 'get',
return_value=nsx_router),\
mock.patch.object(self.validator._core_plugin, '_get_router',
return_value=db_router):
self.validator.validate_vpnservice(self.context, self.vpn_service)
def _create_router(self, distributed=True, ha=False):
with db_api.CONTEXT_WRITER.using(self.ctx):
self.ctx.session.add(l3_models.Router(id=TEST_ROUTER_ID))
l3_objs.RouterExtraAttributes(self.ctx,
router_id=TEST_ROUTER_ID,
distributed=distributed,
ha=ha).create()
def test__create_gw_port(self):
# NOTE(slaweq): this test is probably wrong
# returing dict as gw_port breaks test later in L334 in
# neutron.db.l3_db file
router_id = '2afb8434-7380-43a2-913f-ba3a5ad5f349'
router = l3_models.Router(id=router_id)
new_network_id = 'net-id'
ext_ips = [{'subnet_id': 'subnet-id', 'ip_address': '1.1.1.1'}]
gw_port = {
'fixed_ips': [{
'subnet_id': 'subnet-id',
'ip_address': '1.1.1.1'
}],
'id': '8742d007-6f05-4b7e-abdb-11818f608959'
}
ctx = context.get_admin_context()
with db_api.CONTEXT_WRITER.using(ctx):
with mock.patch.object(directory, 'get_plugin') as get_p, \
mock.patch.object(get_p(), 'get_subnets_by_network',
return_value=mock.ANY), \
mock.patch.object(get_p(), '_get_port',
return_value=gw_port), \
mock.patch.object(l3_db.L3_NAT_dbonly_mixin,
'_check_for_dup_router_subnets') as \
cfdrs, \
mock.patch.object(plugin_utils, 'create_port',
return_value=gw_port), \
mock.patch.object(ctx.session, 'add'), \
mock.patch.object(base_obj.NeutronDbObject, 'create'), \
mock.patch.object(l3_db.registry, 'publish') as \
mock_notify, \
mock.patch.object(l3_db.L3_NAT_dbonly_mixin, '_get_router',
return_value=router):
self.db._create_gw_port(ctx,
router_id=router_id,
router=router,
new_network_id=new_network_id,
ext_ips=ext_ips)
expected_gw_ips = ['1.1.1.1']
self.assertTrue(cfdrs.called)
mock_notify.assert_called_with(resources.ROUTER_GATEWAY,
events.AFTER_CREATE,
self.db._create_gw_port,
payload=mock.ANY)
cb_payload = mock_notify.mock_calls[1][2]['payload']
self.assertEqual(ctx, cb_payload.context)
self.assertEqual(expected_gw_ips,
cb_payload.metadata.get('gateway_ips'))
self.assertEqual(new_network_id,
cb_payload.metadata.get('network_id'))
self.assertEqual(router_id, cb_payload.resource_id)
def test__create_gw_port(self):
router_id = '2afb8434-7380-43a2-913f-ba3a5ad5f349'
router = l3_models.Router(id=router_id)
new_network_id = 'net-id'
ext_ips = [{'subnet_id': 'subnet-id', 'ip_address': '1.1.1.1'}]
gw_port = {
'fixed_ips': [{
'subnet_id': 'subnet-id',
'ip_address': '1.1.1.1'
}],
'id': '8742d007-6f05-4b7e-abdb-11818f608959'
}
ctx = context.get_admin_context()
with mock.patch.object(directory, 'get_plugin') as get_p, \
mock.patch.object(get_p(), 'get_subnets_by_network',
return_value=mock.ANY), \
mock.patch.object(get_p(), '_get_port',
return_value=gw_port), \
mock.patch.object(l3_db.L3_NAT_dbonly_mixin,
'_check_for_dup_router_subnets') as cfdrs,\
mock.patch.object(plugin_utils, 'create_port',
return_value=gw_port), \
mock.patch.object(ctx.session, 'add'), \
mock.patch.object(base_obj.NeutronDbObject, 'create'), \
mock.patch.object(l3_db.registry, 'notify') as mock_notify:
self.db._create_gw_port(ctx,
router_id=router_id,
router=router,
new_network_id=new_network_id,
ext_ips=ext_ips)
expected_gw_ips = ['1.1.1.1']
self.assertTrue(cfdrs.called)
mock_notify.assert_called_with(resources.ROUTER_GATEWAY,
events.AFTER_CREATE,
self.db._create_gw_port,
context=ctx,
gw_ips=expected_gw_ips,
network_id=new_network_id,
router_id=router_id)
def _create_router(self, gw_port=True, num_ports=2, create_routes=True):
# GW CIDR: 10.0.0.0/24
# Interface CIDRS: 10.0.1.0/24, 10.0.2.0/24, etc.
router_id = uuidutils.generate_uuid()
port_gw_cidr = netaddr.IPNetwork('10.0.0.0/24')
rports = []
if gw_port:
port_gw = models_v2.Port(
id=uuidutils.generate_uuid(),
fixed_ips=[
models_v2.IPAllocation(ip_address=str(port_gw_cidr.ip + 1))
])
rports.append(
l3_models.RouterPort(router_id=router_id, port=port_gw))
else:
port_gw = None
port_cidrs = []
port_subnets = []
for idx in range(num_ports):
cidr = port_gw_cidr.cidr.next(idx + 1)
port = models_v2.Port(
id=uuidutils.generate_uuid(),
fixed_ips=[
models_v2.IPAllocation(ip_address=str(cidr.ip + 1))
])
port_cidrs.append(cidr)
rports.append(l3_models.RouterPort(router_id=router_id, port=port))
port_subnets.append({'cidr': str(cidr)})
routes = []
if create_routes:
for cidr in [*port_cidrs, port_gw_cidr]:
routes.append(
l3_models.RouterRoute(destination=str(cidr.next(100)),
nexthop=str(cidr.ip + 10)))
return (l3_models.Router(id=router_id,
attached_ports=rports,
route_list=routes,
gw_port_id=port_gw.id if port_gw else None),
port_subnets)
def _setup_neutron_router(self):
with self.ctx.session.begin(subtransactions=True):
router = l3_models.Router()
self.ctx.session.add(router)
return router
def setUp(self):
super(TestL3GwModeMixin, self).setUp()
plugin = __name__ + '.' + TestDbIntPlugin.__name__
self.setup_coreplugin(plugin)
self.target_object = TestDbIntPlugin()
# Patch the context
ctx_patcher = mock.patch('neutron_lib.context', autospec=True)
mock_context = ctx_patcher.start()
self.context = mock_context.get_admin_context()
# This ensure also calls to elevated work in unit tests
self.context.elevated.return_value = self.context
self.context.session = db_api.get_writer_session()
# Create sample data for tests
self.ext_net_id = _uuid()
self.int_net_id = _uuid()
self.int_sub_id = _uuid()
self.tenant_id = 'the_tenant'
self.network = net_obj.Network(self.context,
id=self.ext_net_id,
project_id=self.tenant_id,
admin_state_up=True,
status=constants.NET_STATUS_ACTIVE)
self.net_ext = net_obj.ExternalNetwork(self.context,
network_id=self.ext_net_id)
self.network.create()
self.net_ext.create()
self.router = l3_models.Router(id=_uuid(),
name=None,
tenant_id=self.tenant_id,
admin_state_up=True,
status=constants.NET_STATUS_ACTIVE,
enable_snat=True,
gw_port_id=None)
self.context.session.add(self.router)
self.context.session.flush()
self.router_gw_port = port_obj.Port(
self.context,
id=FAKE_GW_PORT_ID,
project_id=self.tenant_id,
device_id=self.router.id,
device_owner=l3_db.DEVICE_OWNER_ROUTER_GW,
admin_state_up=True,
status=constants.PORT_STATUS_ACTIVE,
mac_address=netaddr.EUI(FAKE_GW_PORT_MAC),
network_id=self.ext_net_id)
self.router_gw_port.create()
self.router.gw_port_id = self.router_gw_port.id
self.context.session.add(self.router)
self.context.session.flush()
self.fip_ext_port = port_obj.Port(
self.context,
id=FAKE_FIP_EXT_PORT_ID,
project_id=self.tenant_id,
admin_state_up=True,
device_id=self.router.id,
device_owner=l3_db.DEVICE_OWNER_FLOATINGIP,
status=constants.PORT_STATUS_ACTIVE,
mac_address=netaddr.EUI(FAKE_FIP_EXT_PORT_MAC),
network_id=self.ext_net_id)
self.fip_ext_port.create()
self.context.session.flush()
self.int_net = net_obj.Network(self.context,
id=self.int_net_id,
project_id=self.tenant_id,
admin_state_up=True,
status=constants.NET_STATUS_ACTIVE)
self.int_sub = subnet_obj.Subnet(
self.context,
id=self.int_sub_id,
project_id=self.tenant_id,
ip_version=4,
cidr=utils.AuthenticIPNetwork('3.3.3.0/24'),
gateway_ip=netaddr.IPAddress('3.3.3.1'),
network_id=self.int_net_id)
self.router_port = port_obj.Port(
self.context,
id=FAKE_ROUTER_PORT_ID,
project_id=self.tenant_id,
admin_state_up=True,
device_id=self.router.id,
device_owner=l3_db.DEVICE_OWNER_ROUTER_INTF,
status=constants.PORT_STATUS_ACTIVE,
mac_address=netaddr.EUI(FAKE_ROUTER_PORT_MAC),
network_id=self.int_net_id)
self.router_port_ip_info = port_obj.IPAllocation(
self.context,
port_id=self.router_port.id,
network_id=self.int_net.id,
subnet_id=self.int_sub_id,
ip_address='3.3.3.1')
self.int_net.create()
self.int_sub.create()
self.router_port.create()
self.router_port_ip_info.create()
self.context.session.flush()
self.fip_int_port = port_obj.Port(
self.context,
id=FAKE_FIP_INT_PORT_ID,
project_id=self.tenant_id,
admin_state_up=True,
device_id='something',
device_owner=constants.DEVICE_OWNER_COMPUTE_PREFIX + 'nova',
status=constants.PORT_STATUS_ACTIVE,
mac_address=netaddr.EUI(FAKE_FIP_INT_PORT_MAC),
network_id=self.int_net_id)
self.fip_int_ip_info = port_obj.IPAllocation(
self.context,
port_id=self.fip_int_port.id,
network_id=self.int_net.id,
subnet_id=self.int_sub_id,
ip_address='3.3.3.3')
self.fip = l3_models.FloatingIP(id=_uuid(),
floating_ip_address='1.1.1.2',
floating_network_id=self.ext_net_id,
floating_port_id=FAKE_FIP_EXT_PORT_ID,
fixed_port_id=None,
fixed_ip_address=None,
router_id=None)
self.fip_int_port.create()
self.fip_int_ip_info.create()
self.context.session.add(self.fip)
self.context.session.flush()
self.context.session.expire_all()
self.fip_request = {
'port_id': FAKE_FIP_INT_PORT_ID,
'tenant_id': self.tenant_id
}
def _setup_neutron_router(self):
with db_api.CONTEXT_WRITER.using(self.ctx):
router = l3_models.Router()
self.ctx.session.add(router)
return router
def setUp(self):
super(TestL3GwModeMixin, self).setUp()
plugin = __name__ + '.' + TestDbIntPlugin.__name__
self.setup_coreplugin(plugin)
self.target_object = TestDbIntPlugin()
# Patch the context
ctx_patcher = mock.patch('neutron.context', autospec=True)
mock_context = ctx_patcher.start()
self.context = mock_context.get_admin_context()
# This ensure also calls to elevated work in unit tests
self.context.elevated.return_value = self.context
self.context.session = db_api.get_session()
# Create sample data for tests
self.ext_net_id = _uuid()
self.int_net_id = _uuid()
self.int_sub_id = _uuid()
self.tenant_id = 'the_tenant'
self.network = models_v2.Network(id=self.ext_net_id,
tenant_id=self.tenant_id,
admin_state_up=True,
status=constants.NET_STATUS_ACTIVE)
self.net_ext = ext_net_models.ExternalNetwork(
network_id=self.ext_net_id)
self.context.session.add(self.network)
# The following is to avoid complaints from SQLite on
# foreign key violations
self.context.session.flush()
self.context.session.add(self.net_ext)
self.router = l3_models.Router(id=_uuid(),
name=None,
tenant_id=self.tenant_id,
admin_state_up=True,
status=constants.NET_STATUS_ACTIVE,
enable_snat=True,
gw_port_id=None)
self.context.session.add(self.router)
self.context.session.flush()
self.router_gw_port = models_v2.Port(
id=FAKE_GW_PORT_ID,
tenant_id=self.tenant_id,
device_id=self.router.id,
device_owner=l3_db.DEVICE_OWNER_ROUTER_GW,
admin_state_up=True,
status=constants.PORT_STATUS_ACTIVE,
mac_address=FAKE_GW_PORT_MAC,
network_id=self.ext_net_id)
self.router.gw_port_id = self.router_gw_port.id
self.context.session.add(self.router)
self.context.session.add(self.router_gw_port)
self.context.session.flush()
self.fip_ext_port = models_v2.Port(
id=FAKE_FIP_EXT_PORT_ID,
tenant_id=self.tenant_id,
admin_state_up=True,
device_id=self.router.id,
device_owner=l3_db.DEVICE_OWNER_FLOATINGIP,
status=constants.PORT_STATUS_ACTIVE,
mac_address=FAKE_FIP_EXT_PORT_MAC,
network_id=self.ext_net_id)
self.context.session.add(self.fip_ext_port)
self.context.session.flush()
self.int_net = models_v2.Network(id=self.int_net_id,
tenant_id=self.tenant_id,
admin_state_up=True,
status=constants.NET_STATUS_ACTIVE)
self.int_sub = models_v2.Subnet(id=self.int_sub_id,
tenant_id=self.tenant_id,
ip_version=4,
cidr='3.3.3.0/24',
gateway_ip='3.3.3.1',
network_id=self.int_net_id)
self.router_port = models_v2.Port(
id=FAKE_ROUTER_PORT_ID,
tenant_id=self.tenant_id,
admin_state_up=True,
device_id=self.router.id,
device_owner=l3_db.DEVICE_OWNER_ROUTER_INTF,
status=constants.PORT_STATUS_ACTIVE,
mac_address=FAKE_ROUTER_PORT_MAC,
network_id=self.int_net_id)
self.router_port_ip_info = models_v2.IPAllocation(
port_id=self.router_port.id,
network_id=self.int_net.id,
subnet_id=self.int_sub_id,
ip_address='3.3.3.1')
self.context.session.add(self.int_net)
self.context.session.add(self.int_sub)
self.context.session.add(self.router_port)
self.context.session.add(self.router_port_ip_info)
self.context.session.flush()
self.fip_int_port = models_v2.Port(
id=FAKE_FIP_INT_PORT_ID,
tenant_id=self.tenant_id,
admin_state_up=True,
device_id='something',
device_owner=constants.DEVICE_OWNER_COMPUTE_PREFIX + 'nova',
status=constants.PORT_STATUS_ACTIVE,
mac_address=FAKE_FIP_INT_PORT_MAC,
network_id=self.int_net_id)
self.fip_int_ip_info = models_v2.IPAllocation(
port_id=self.fip_int_port.id,
network_id=self.int_net.id,
subnet_id=self.int_sub_id,
ip_address='3.3.3.3')
self.fip = l3_models.FloatingIP(id=_uuid(),
floating_ip_address='1.1.1.2',
floating_network_id=self.ext_net_id,
floating_port_id=FAKE_FIP_EXT_PORT_ID,
fixed_port_id=None,
fixed_ip_address=None,
router_id=None)
self.context.session.add(self.fip_int_port)
self.context.session.add(self.fip_int_ip_info)
self.context.session.add(self.fip)
self.context.session.flush()
self.fip_request = {
'port_id': FAKE_FIP_INT_PORT_ID,
'tenant_id': self.tenant_id
}
