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)