def test_address_scope_mark_ids_handling(self):
mark_ids = set(
range(router_info.ADDRESS_SCOPE_MARK_ID_MIN,
router_info.ADDRESS_SCOPE_MARK_ID_MAX))
ri = router_info.RouterInfo(mock.Mock(), _uuid(), {}, **self.ri_kwargs)
# first mark id is used for the default address scope
scope_to_mark_id = {router_info.DEFAULT_ADDRESS_SCOPE: mark_ids.pop()}
self.assertEqual(scope_to_mark_id, ri._address_scope_to_mark_id)
self.assertEqual(mark_ids, ri.available_mark_ids)
# new id should be used for new address scope
ri.get_address_scope_mark_mask('new_scope')
scope_to_mark_id['new_scope'] = mark_ids.pop()
self.assertEqual(scope_to_mark_id, ri._address_scope_to_mark_id)
self.assertEqual(mark_ids, ri.available_mark_ids)
# new router should have it's own mark ids set
new_mark_ids = set(
range(router_info.ADDRESS_SCOPE_MARK_ID_MIN,
router_info.ADDRESS_SCOPE_MARK_ID_MAX))
new_ri = router_info.RouterInfo(mock.Mock(), _uuid(), {},
**self.ri_kwargs)
new_mark_ids.pop()
self.assertEqual(new_mark_ids, new_ri.available_mark_ids)
self.assertNotEqual(ri.available_mark_ids, new_ri.available_mark_ids)
def _prepare_router_data(self, enable_snat=None):
router_id = _uuid()
ex_gw_port = {
'id': _uuid(),
'mac_address': 'ca:fe:de:ad:be:ee',
'network_id': _uuid(),
'fixed_ips': [{
'ip_address': '172.24.4.2',
'subnet_id': _uuid()
}],
'subnet': {
'cidr': '172.24.4.0/24',
'gateway_ip': '172.24.4.1'
},
'ip_cidr': '172.24.4.226/28'
}
int_ports = []
router = {
'id': router_id,
'distributed': False,
l3_constants.INTERFACE_KEY: int_ports,
'routes': [],
'gw_port': ex_gw_port
}
if enable_snat is not None:
router['enable_snat'] = enable_snat
ri = router_info.RouterInfo(router_id=router['id'],
router=router,
**self.ri_kwargs)
return ri
def test_check_and_remove_ecmp_route(self):
ri = router_info.RouterInfo(mock.Mock(), _uuid(), {}, **self.ri_kwargs)
ri.router = {}
fake_old_routes1 = [{'destination': '135.207.111.111/32',
'nexthop': '135.207.111.112'},
{'destination': '135.207.111.111/32',
'nexthop': '135.207.111.113'}]
fake_route1 = {'destination': '135.207.111.111/32',
'nexthop': '135.207.111.113'}
fake_old_routes2 = [{'destination': '135.207.111.111/32',
'nexthop': '135.207.111.112'},
{'destination': '135.207.111.111/32',
'nexthop': '135.207.111.113'},
{'destination': '135.207.111.111/32',
'nexthop': '135.207.111.114'}]
fake_route2 = [{'destination': '135.207.111.111/32',
'nexthop': '135.207.111.113'},
{'destination': '135.207.111.111/32',
'nexthop': '135.207.111.114'}]
fake_remove_route = {'destination': '135.207.111.111/32',
'nexthop': '135.207.111.112'}
ri.update_routing_table = mock.Mock()
ri.check_and_remove_ecmp_route(fake_old_routes1, fake_remove_route)
ri.update_routing_table.assert_called_once_with('replace',
fake_route1)
ri.update_routing_table_ecmp = mock.Mock()
ri.check_and_remove_ecmp_route(fake_old_routes2, fake_remove_route)
ri.update_routing_table_ecmp.assert_called_once_with(fake_route2)
def setUp(self):
super(L3LoggingExtBaseTestCase, self).setUp()
self.agent = l3_agent.L3NATAgent('test_host', self.conf)
self.context = context.get_admin_context()
self.connection = mock.Mock()
self.ex_gw_port = {'id': _uuid()}
self.router = {
'id': _uuid(),
'gw_port': self.ex_gw_port,
'ha': False,
'distributed': False
}
self.router_info = l3router.RouterInfo(self.agent, _uuid(),
self.router, **self.ri_kwargs)
self.router_info.ex_gw_port = self.ex_gw_port
self.agent.router_info[self.router['id']] = self.router_info
def _mock_get_router_info(router_id):
return self.router_info
self.get_router_info = mock.patch(
'neutron.agent.l3.l3_agent_extension_api.'
'L3AgentExtensionAPI.get_router_info').start()
self.get_router_info.side_effect = _mock_get_router_info
self.agent_api = l3_ext_api.L3AgentExtensionAPI(None)
mock.patch(
'neutron.manager.NeutronManager.load_class_for_provider').start()
def _create_router(self, router=None, **kwargs):
if not router:
router = mock.MagicMock()
self.agent_conf = mock.Mock()
self.router_id = _uuid()
return router_info.RouterInfo(self.router_id, router, self.agent_conf,
mock.sentinel.interface_driver, **kwargs)
def setUp(self):
super(NDPProxyExtensionLegacyTestCase, self).setUp()
self.conf.host = HOSTNAME
self.conf.agent_mode = lib_const.L3_AGENT_MODE_LEGACY
self.agent = l3_agent.L3NATAgent(HOSTNAME, self.conf)
self.ext_device_name = 'qg-%s' % self.ext_port_id[0:11]
self.internal_ports = [{'subnets': [{'cidr': '2001::1:0/112'}]}]
self.router = {
'id': self.fake_router_id,
'gw_port': self.ex_gw_port,
'ha': False,
'distributed': False,
'enable_ndp_proxy': True
}
self.router_info = router_info.RouterInfo(self.agent,
self.fake_router_id,
self.router,
**self.ri_kwargs)
self.iptables_manager = self.router_info.iptables_manager
self.router_info.internal_ports = self.internal_ports
self.router_info.ex_gw_port = self.ex_gw_port
self.iptables_manager.ipv6['filter'].chains = []
self.iptables_manager.ipv6['filter'].rules = []
self.agent.router_info[self.router['id']] = self.router_info
self.wrap_name = self.iptables_manager.wrap_name
self.namespace = "qrouter-" + self.fake_router_id
self._mock_iptables_actions()
self.ip_wrapper.reset_mock()
def test_routing_table_update(self):
ri = router_info.RouterInfo(mock.Mock(), _uuid(), {}, **self.ri_kwargs)
ri.router = {}
fake_route1 = {'destination': '135.207.0.0/16',
'nexthop': '1.2.3.4'}
fake_route2 = {'destination': '135.207.111.111/32',
'nexthop': '1.2.3.4'}
ri.update_routing_table('replace', fake_route1)
expected = [['ip', 'route', 'replace', 'to', '135.207.0.0/16',
'via', '1.2.3.4']]
self._check_agent_method_called(expected)
ri.update_routing_table('delete', fake_route1)
expected = [['ip', 'route', 'delete', 'to', '135.207.0.0/16',
'via', '1.2.3.4']]
self._check_agent_method_called(expected)
ri.update_routing_table('replace', fake_route2)
expected = [['ip', 'route', 'replace', 'to', '135.207.111.111/32',
'via', '1.2.3.4']]
self._check_agent_method_called(expected)
ri.update_routing_table('delete', fake_route2)
expected = [['ip', 'route', 'delete', 'to', '135.207.111.111/32',
'via', '1.2.3.4']]
self._check_agent_method_called(expected)
def setUp(self):
super(ConntrackHelperExtensionBaseTestCase, self).setUp()
self.cth_ext = cth.ConntrackHelperAgentExtension()
self.context = context.get_admin_context()
self.connection = mock.Mock()
self.router_id = uuidutils.generate_uuid()
self.conntrack_helper1 = cth_obj.ConntrackHelper(
context=None,
id=uuidutils.generate_uuid(),
protocol='udp',
port=69,
helper='tftp',
router_id=self.router_id)
self.agent = l3_agent.L3NATAgent(HOSTNAME, self.conf)
self.router = {'id': self.router_id, 'ha': False, 'distributed': False}
self.router_info = l3router.RouterInfo(self.agent, self.router_id,
self.router, **self.ri_kwargs)
self.agent.router_info[self.router['id']] = self.router_info
self.get_router_info = mock.patch(
'neutron.agent.l3.l3_agent_extension_api.'
'L3AgentExtensionAPI.get_router_info').start()
self.get_router_info.return_value = self.router_info
self.agent_api = l3_ext_api.L3AgentExtensionAPI(None, None)
self.cth_ext.consume_api(self.agent_api)
self.conntrack_helpers = [self.conntrack_helper1]
def test_routes_updated(self):
ri = router_info.RouterInfo(mock.Mock(), _uuid(), {}, **self.ri_kwargs)
ri.router = {}
fake_old_routes = []
fake_new_routes = [{'destination': "110.100.31.0/24",
'nexthop': "10.100.10.30"},
{'destination': "110.100.30.0/24",
'nexthop': "10.100.10.30"}]
ri.routes = fake_old_routes
ri.router['routes'] = fake_new_routes
ri.routes_updated(fake_old_routes, fake_new_routes)
expected = [['ip', 'route', 'replace', 'to', '110.100.30.0/24',
'via', '10.100.10.30'],
['ip', 'route', 'replace', 'to', '110.100.31.0/24',
'via', '10.100.10.30']]
self._check_agent_method_called(expected)
ri.routes = fake_new_routes
fake_new_routes = [{'destination': "110.100.30.0/24",
'nexthop': "10.100.10.30"}]
ri.router['routes'] = fake_new_routes
ri.routes_updated(ri.routes, fake_new_routes)
expected = [['ip', 'route', 'delete', 'to', '110.100.31.0/24',
'via', '10.100.10.30']]
self._check_agent_method_called(expected)
fake_new_routes = []
ri.router['routes'] = fake_new_routes
ri.routes_updated(ri.routes, fake_new_routes)
expected = [['ip', 'route', 'delete', 'to', '110.100.30.0/24',
'via', '10.100.10.30']]
self._check_agent_method_called(expected)
def _router_added(self, router_id, router):
LOG.debug("_router_added: %s", router_id)
ri = router_info.RouterInfo(router_id=router_id,
router=router,
agent_conf=self.conf,
interface_driver=self.driver)
self.router_info[router_id] = ri
super(vArmourL3NATAgent, self).process_router_add(ri)
def _router_dict_to_obj(self, r):
# The callbacks expect a router-info object
return router_info.RouterInfo(None,
r['id'],
router=r,
agent_conf=None,
interface_driver=None,
use_ipv6=False)
def _create_router(self, router=None, **kwargs):
if not router:
router = mock.MagicMock()
self.agent_conf = mock.Mock()
# NOTE The use_namespaces config will soon be deprecated
self.agent_conf.use_namespaces = True
self.router_id = _uuid()
return router_info.RouterInfo(self.router_id, router, self.agent_conf,
mock.sentinel.interface_driver, **kwargs)
def _router_dict_to_obj(self, r):
# The callbacks expect a router-info object with an agent config
agent_conf = cfg.CONF
agent_conf.metadata_access_mark = '0x1'
return router_info.RouterInfo(
None, r['id'], router=r,
agent_conf=agent_conf,
interface_driver=None,
use_ipv6=False)
def _prepare_router_data(self, ports=None):
self.router_id = uuidutils.generate_uuid()
self.project_id = uuidutils.generate_uuid()
ri_kwargs = {'router': {'id': self.router_id,
'project_id': self.project_id},
'agent_conf': mock.ANY,
'interface_driver': mock.ANY,
'use_ipv6': mock.ANY}
ri = router_info.RouterInfo(mock.Mock(), self.router_id, **ri_kwargs)
ri.internal_ports = ports
return {ri.router_id: ri}, ri
def test_update_routing_table(self):
# Just verify the correct namespace was used in the call
uuid = _uuid()
netns = 'qrouter-' + uuid
fake_route1 = {'destination': '135.207.0.0/16', 'nexthop': '1.2.3.4'}
ri = router_info.RouterInfo(uuid, {'id': uuid}, **self.ri_kwargs)
ri._update_routing_table = mock.Mock()
ri.update_routing_table('replace', fake_route1)
ri._update_routing_table.assert_called_once_with(
'replace', fake_route1, netns)
def test_after_router_updated_called_on_agent_process_update(self):
with mock.patch.object(metadata_driver, 'after_router_updated') as f,\
mock.patch.object(router_info.RouterInfo, 'process'):
agent = l3_agent.L3NATAgent('localhost')
router_id = _uuid()
router = {'id': router_id}
ri = router_info.RouterInfo(mock.Mock(), router_id, router,
agent.conf, mock.ANY)
agent.router_info[router_id] = ri
agent._process_updated_router(router)
f.assert_called_once_with(
'router', 'after_update', agent, router=ri)
def setUp(self):
super(PortForwardingExtensionBaseTestCase, self).setUp()
self.fip_pf_ext = pf.PortForwardingAgentExtension()
self.context = context.get_admin_context()
self.connection = mock.Mock()
self.floatingip2 = router.FloatingIP(context=None, id=_uuid(),
floating_ip_address='172.24.6.12',
floating_network_id=_uuid(),
router_id=_uuid(),
status='ACTIVE')
self.portforwarding1 = pf_obj.PortForwarding(
context=None, id=_uuid(), floatingip_id=self.floatingip2.id,
external_port=1111, protocol='tcp', internal_port_id=_uuid(),
external_port_range='1111:1111',
internal_port_range='11111:11111',
internal_ip_address='1.1.1.1', internal_port=11111,
floating_ip_address=self.floatingip2.floating_ip_address,
router_id=self.floatingip2.router_id)
self.agent = l3_agent.L3NATAgent(HOSTNAME, self.conf)
self.ex_gw_port = {'id': _uuid()}
self.fip = {'id': _uuid(),
'floating_ip_address': TEST_FIP,
'fixed_ip_address': '192.168.0.1',
'floating_network_id': _uuid(),
'port_id': _uuid(),
'host': HOSTNAME}
self.router = {'id': self.floatingip2.router_id,
'gw_port': self.ex_gw_port,
'ha': False,
'distributed': False,
lib_const.FLOATINGIP_KEY: [self.fip]}
self.router_info = l3router.RouterInfo(
self.agent, self.floatingip2.router_id, self.router,
**self.ri_kwargs)
self.centralized_port_forwarding_fip_set = set(
[str(self.floatingip2.floating_ip_address) + '/32'])
self.pf_managed_fips = [self.floatingip2.id]
self.router_info.ex_gw_port = self.ex_gw_port
self.router_info.fip_managed_by_port_forwardings = self.pf_managed_fips
self.agent.router_info[self.router['id']] = self.router_info
self.get_router_info = mock.patch(
'neutron.agent.l3.l3_agent_extension_api.'
'L3AgentExtensionAPI.get_router_info').start()
self.get_router_info.return_value = self.router_info
self.agent_api = l3_ext_api.L3AgentExtensionAPI(None, None)
self.fip_pf_ext.consume_api(self.agent_api)
self.port_forwardings = [self.portforwarding1]
def _prepare_router_data(self, ports=None):
self.router_id = uuidutils.generate_uuid()
self.project_id = uuidutils.generate_uuid()
self.conf = config.setup_conf()
l3_config.register_l3_agent_config_opts(l3_config.OPTS, self.conf)
ri_kwargs = {'router': {'id': self.router_id,
'project_id': self.project_id},
'agent_conf': self.conf,
'interface_driver': mock.ANY,
'use_ipv6': mock.ANY}
ri = l3router.RouterInfo(mock.Mock(), self.router_id, **ri_kwargs)
ri.internal_ports = ports
return {ri.router_id: ri}, ri
def test_update_routing_table_ecmp(self):
ri = router_info.RouterInfo(mock.Mock(), _uuid(), {}, **self.ri_kwargs)
ri.router = {}
fake_route_list = [{'destination': '135.207.111.111/32',
'nexthop': '135.207.111.112'},
{'destination': '135.207.111.111/32',
'nexthop': '135.207.111.113'}]
expected_dst = '135.207.111.111/32'
expected_next_hops = [{'via': '135.207.111.112'},
{'via': '135.207.111.113'}]
ri.update_routing_table_ecmp(fake_route_list)
self.mock_add_ip_route.assert_called_once_with(
ri.ns_name,
expected_dst,
via=expected_next_hops)
def _prepare_router_data(self, ports=None):
self.router_id = str(uuid.uuid4())
self.project_id = str(uuid.uuid4())
ri_kwargs = {
'router': {
'id': self.router_id,
'project_id': self.project_id
},
'agent_conf': mock.ANY,
'interface_driver': mock.ANY,
'use_ipv6': mock.ANY
}
ri = router_info.RouterInfo(self.router_id, **ri_kwargs)
ri.internal_ports = ports
return {ri.router_id: ri}, ri
def test_check_and_add_ecmp_route(self):
ri = router_info.RouterInfo(mock.Mock(), _uuid(), {}, **self.ri_kwargs)
ri.router = {}
fake_old_routes = [{'destination': '135.207.111.111/32',
'nexthop': '135.207.111.112'}]
fake_new_route = {'destination': '135.207.111.111/32',
'nexthop': '135.207.111.113'}
ri.update_routing_table_ecmp = mock.Mock()
ri.check_and_add_ecmp_route(fake_old_routes, fake_new_route)
expected_routes = [{'destination': '135.207.111.111/32',
'nexthop': '135.207.111.112'},
{'destination': '135.207.111.111/32',
'nexthop': '135.207.111.113'}]
ri.update_routing_table_ecmp.assert_called_once_with(expected_routes)
def test_check_if_need_process_no_snat_ns(self):
ex_gw_port = {'id': _uuid()}
router_id = _uuid()
router = {'id': router_id,
'gw_port': ex_gw_port,
'ha': False,
'distributed': True}
router_info = l3router.RouterInfo(
self.agent, router_id, router,
**self.ri_kwargs)
router_info.agent_conf.agent_mode = lib_const.L3_AGENT_MODE_DVR_SNAT
router_info.fip_managed_by_port_forwardings = True
router_info.snat_namespace = mock.Mock()
router_info.snat_namespace.exists.return_value = False
self.assertFalse(self.fip_pf_ext._check_if_need_process(router_info))
def test_process_delete(self):
ri = router_info.RouterInfo(mock.Mock(), _uuid(), {}, **self.ri_kwargs)
ri.router = {'id': _uuid()}
with mock.patch.object(ri, '_process_internal_ports') as p_i_p,\
mock.patch.object(ri, '_process_external_on_delete') as p_e_o_d:
self.mock_ip.netns.exists.return_value = False
ri.process_delete()
self.assertFalse(p_i_p.called)
self.assertFalse(p_e_o_d.called)
p_i_p.reset_mock()
p_e_o_d.reset_mock()
self.mock_ip.netns.exists.return_value = True
ri.process_delete()
p_i_p.assert_called_once_with()
p_e_o_d.assert_called_once_with()
def test_after_router_updated_should_not_call_add_metadata_rules(self):
with mock.patch.object(iptables_manager.IptablesTable,
'add_rule') as f,\
mock.patch.object(iptables_manager.IptablesManager,
'apply'),\
mock.patch.object(metadata_driver.MetadataDriver,
'spawn_monitored_metadata_proxy'),\
mock.patch.object(router_info.RouterInfo, 'process'):
agent = l3_agent.L3NATAgent('localhost')
router_id = _uuid()
router = {'id': router_id}
ri = router_info.RouterInfo(mock.Mock(), router_id, router,
agent.conf, mock.ANY)
agent.router_info[router_id] = ri
f.reset_mock()
agent._process_updated_router(router)
f.assert_not_called()
def test_after_router_updated_called_on_agent_process_update(self):
with mock.patch.object(metadata_driver, 'after_router_updated') as f,\
mock.patch.object(router_info.RouterInfo, 'process'):
agent = l3_agent.L3NATAgent('localhost')
router_id = _uuid()
router = {'id': router_id}
ri = router_info.RouterInfo(mock.Mock(), router_id, router,
agent.conf, mock.ANY)
agent.router_info[router_id] = ri
agent._process_updated_router(router)
f.assert_called_once_with('router',
'after_update',
agent,
payload=mock.ANY)
payload = f.call_args_list[0][1]['payload']
self.assertEqual(ri, payload.latest_state)
self.assertEqual(router_id, payload.resource_id)
def test__process_pd_iptables_rules(self):
subnet_id = _uuid()
ex_gw_port = {'id': _uuid()}
prefix = '2001:db8:cafe::/64'
ri = router_info.RouterInfo(mock.Mock(), _uuid(), {}, **self.ri_kwargs)
ipv6_mangle = ri.iptables_manager.ipv6['mangle'] = mock.MagicMock()
ri.get_ex_gw_port = mock.Mock(return_value=ex_gw_port)
ri.get_external_device_name = mock.Mock(return_value='fake_device')
ri.get_address_scope_mark_mask = mock.Mock(return_value='fake_mark')
ri._process_pd_iptables_rules(prefix, subnet_id)
mangle_rule = '-d %s ' % prefix
mangle_rule += ri.address_scope_mangle_rule('fake_device', 'fake_mark')
ipv6_mangle.add_rule.assert_called_once_with(
'scope', mangle_rule, tag='prefix_delegation_%s' % subnet_id)
def test_add_ports_address_scope_iptables(self):
ri = router_info.RouterInfo(mock.Mock(), _uuid(), {}, **self.ri_kwargs)
port = {
'id': _uuid(),
'fixed_ips': [{'ip_address': '172.9.9.9'}],
'address_scopes': {lib_constants.IP_VERSION_4: '1234'}
}
ipv4_mangle = ri.iptables_manager.ipv4['mangle'] = mock.MagicMock()
ri.get_address_scope_mark_mask = mock.Mock(return_value='fake_mark')
ri.get_internal_device_name = mock.Mock(return_value='fake_device')
ri.rt_tables_manager = mock.MagicMock()
ri.process_external_port_address_scope_routing = mock.Mock()
ri.process_floating_ip_address_scope_rules = mock.Mock()
ri.iptables_manager._apply = mock.Mock()
ri.router[lib_constants.INTERFACE_KEY] = [port]
ri.process_address_scope()
ipv4_mangle.add_rule.assert_called_once_with(
'scope', ri.address_scope_mangle_rule('fake_device', 'fake_mark'))
def test__update_internal_ports_cache(self):
ri = router_info.RouterInfo(mock.Mock(), _uuid(), {}, **self.ri_kwargs)
ri.internal_ports = [
{'id': 'port-id-1', 'mtu': 1500},
{'id': 'port-id-2', 'mtu': 2000}]
initial_internal_ports = ri.internal_ports[:]
# Test add new element to the cache
new_port = {'id': 'new-port-id', 'mtu': 1500}
ri._update_internal_ports_cache(new_port)
self.assertEqual(
initial_internal_ports + [new_port],
ri.internal_ports)
# Test update existing port in cache
updated_port = new_port.copy()
updated_port['mtu'] = 2500
ri._update_internal_ports_cache(updated_port)
self.assertEqual(
initial_internal_ports + [updated_port],
ri.internal_ports)
def _process_router_if_compatible(self, router):
ri = router_info.RouterInfo(router_id=router.get('id'),
router=router,
agent_conf=self.conf,
interface_driver=self.driver)
LOG.debug("process_router: %s", ri.router['id'])
if (self.conf.external_network_bridge and
not ip_lib.device_exists(self.conf.external_network_bridge)):
LOG.error(_LE("The external network bridge '%s' does not exist"),
self.conf.external_network_bridge)
return
# If namespaces are disabled, only process the router associated
# with the configured agent id.
if (not self.conf.use_namespaces
and router['id'] != self.conf.router_id):
raise n_exc.RouterNotCompatibleWithAgent(router_id=router['id'])
# Either ex_net_id or handle_internal_only_routers must be set
ex_net_id = (router['external_gateway_info'] or {}).get('network_id')
if not ex_net_id and not self.conf.handle_internal_only_routers:
raise n_exc.RouterNotCompatibleWithAgent(router_id=router['id'])
# If target_ex_net_id and ex_net_id are set they must be equal
target_ex_net_id = self._fetch_external_net_id()
if (target_ex_net_id and ex_net_id and ex_net_id != target_ex_net_id):
# Double check that our single external_net_id has not changed
# by forcing a check by RPC.
if ex_net_id != self._fetch_external_net_id(force=True):
raise n_exc.RouterNotCompatibleWithAgent(
router_id=router['id'])
if router['id'] not in self.router_info:
self._process_added_router(router)
else:
self._process_updated_router(router)
router_id = ri.router['id']
uuid = router_id[0:8]
sql.sql_init_router(router_id)
self.brin = 'br-in-' + router_id[0:8]
self.brout = 'br-out-' + router_id[0:8]
self.change_rest_url(router_id)
internal_ports = self.get_internal_ports(ri)
for p in internal_ports:
if p['admin_state_up']:
dev = self.get_internal_device_name(p['id'])
int_patch_interface = dev + '-p1'
in_patch_interface = dev + '-p2'
cmd = 'ip netns exec qrouter-' + router_id + ' ifconfig ' + dev + ' 0'
res = os.popen(cmd).read()
if res == '':
LOG.debug('delete ip from device seccessfully')
#get tag
cmd = "ovs-vsctl get port " + dev + " tag"
tag = os.popen(cmd).read()
tag = tag.strip('\n')
br = 'br-in-' + uuid
if sql.sql_tag(dev, router_id) == 'none':
sql.sql_store_tagrif(tag, dev, router_id)
cmd="ovs-vsctl add-port br-int "+int_patch_interface+\
" -- set Interface "+int_patch_interface+" \
type=patch -- set Interface " +int_patch_interface+" options:peer="+in_patch_interface
res = os.popen(cmd).read()
if res == '':
LOG.debug('add ovs port seccessfully')
cmd="ovs-vsctl add-port "+br+" "+in_patch_interface+\
" -- set Interface "+in_patch_interface+" type=patch \
-- set Interface " +in_patch_interface+" options:peer="+int_patch_interface
res = os.popen(cmd).read()
if res == '':
LOG.debug('link nf bridge seccessfully')
cmd = "ovs-vsctl set port " + in_patch_interface + " trunk=" + tag
res = os.popen(cmd).read()
if res == '':
LOG.debug('set trunk port seccessfully')
self.rest.auth()
self._nf_config_intranet(ri)
self._nf_config_extranet(ri)
self._nf_config_router_snat_rules(ri)
self._nf_config_floating_ips(ri)
if 'gw_port' in ri.router:
ex_gw_port = self.get_ex_gw_port(ri)
gw_dev_id = ex_gw_port['id']
gw_dev = self.get_external_device_name(gw_dev_id)
cmd = 'ip netns exec qrouter-' + router_id + ' ifconfig ' + gw_dev + ' 0'
os.system(cmd)
cmd = 'ip netns exec qrouter-' + router_id + ' ifconfig ' + gw_dev + ' 0'
res = os.popen(cmd).read()
if res == '':
LOG.debug('delete ip from device seccessfully')
def setUp(self):
super(QosExtensionBaseTestCase, self).setUp()
self.fip_qos_ext = fip_qos.FipQosAgentExtension()
self.context = context.get_admin_context()
self.connection = mock.Mock()
self.policy = policy.QosPolicy(context=None, name='test1', id=_uuid())
self.ingress_rule = (rule.QosBandwidthLimitRule(
context=None,
id=_uuid(),
qos_policy_id=self.policy.id,
max_kbps=1111,
max_burst_kbps=2222,
direction=lib_const.INGRESS_DIRECTION))
self.egress_rule = (rule.QosBandwidthLimitRule(
context=None,
id=_uuid(),
qos_policy_id=self.policy.id,
max_kbps=3333,
max_burst_kbps=4444,
direction=lib_const.EGRESS_DIRECTION))
self.policy.rules = [self.ingress_rule, self.egress_rule]
self.new_ingress_rule = (rule.QosBandwidthLimitRule(
context=None,
id=_uuid(),
qos_policy_id=self.policy.id,
max_kbps=5555,
max_burst_kbps=6666,
direction=lib_const.INGRESS_DIRECTION))
self.ingress_rule_only_has_max_kbps = (rule.QosBandwidthLimitRule(
context=None,
id=_uuid(),
qos_policy_id=self.policy.id,
max_kbps=5555,
max_burst_kbps=0,
direction=lib_const.INGRESS_DIRECTION))
self.policy2 = policy.QosPolicy(context=None, name='test2', id=_uuid())
self.policy2.rules = [self.ingress_rule]
self.policy3 = policy.QosPolicy(context=None, name='test3', id=_uuid())
self.policy3.rules = [self.egress_rule]
self.policy4 = policy.QosPolicy(context=None, name='test4', id=_uuid())
self.dscp = rule.QosDscpMarkingRule(context=None,
id=_uuid(),
qos_policy_id=self.policy4.id,
dscp_mark=32)
self.dscp.obj_reset_changes()
self.policy4.rules = [self.dscp]
self.qos_policies = {
self.policy.id: self.policy,
self.policy2.id: self.policy2,
self.policy3.id: self.policy3,
self.policy4.id: self.policy4
}
self.agent = l3_agent.L3NATAgent(HOSTNAME, self.conf)
self.ex_gw_port = {'id': _uuid()}
self.fip = {
'id': _uuid(),
'floating_ip_address': TEST_QOS_FIP,
'fixed_ip_address': '192.168.0.1',
'floating_network_id': _uuid(),
'port_id': _uuid(),
'host': HOSTNAME,
'qos_policy_id': self.policy.id
}
self.router = {
'id': _uuid(),
'gw_port': self.ex_gw_port,
'ha': False,
'distributed': False,
lib_const.FLOATINGIP_KEY: [self.fip]
}
self.router_info = l3router.RouterInfo(self.agent, _uuid(),
self.router, **self.ri_kwargs)
self.router_info.ex_gw_port = self.ex_gw_port
self.agent.router_info[self.router['id']] = self.router_info
def _mock_get_router_info(router_id):
return self.router_info
self.get_router_info = mock.patch(
'neutron.agent.l3.l3_agent_extension_api.'
'L3AgentExtensionAPI.get_router_info').start()
self.get_router_info.side_effect = _mock_get_router_info
self.agent_api = l3_ext_api.L3AgentExtensionAPI(None)
self.fip_qos_ext.consume_api(self.agent_api)
