def _get_router_info_list_router_without_router_info_helper(
self, rtr_with_ri):
# ri.router with associated router_info (ri)
# rtr2 has no router_info
ri = self._prepare_router_data()
rtr2 = {
'id': uuidutils.generate_uuid(),
'tenant_id': ri.router['tenant_id']
}
routers = [rtr2]
router_info = {}
ri_expected = []
if rtr_with_ri:
router_info[ri.router_id] = ri
routers.append(ri.router)
ri_expected.append(ri)
self.api.router_info = router_info
router_ids = [router['id'] for router in routers]
with mock.patch.object(ip_lib.IPWrapper,
'get_namespaces') as mock_get_namespaces:
mock_get_namespaces.return_value = [ri.ns_name]
api_object = l3_agent_api.L3AgentExtensionAPI(router_info)
self.api.consume_api(api_object)
router_info_list = self.api._get_router_info_list_for_tenant(
router_ids, ri.router['tenant_id'])
self.assertEqual(ri_expected, router_info_list)
def init_extension_manager(self, connection):
l3_ext_manager.register_opts(self.conf)
self.agent_api = l3_ext_api.L3AgentExtensionAPI(self.router_info)
self.l3_ext_manager = (l3_ext_manager.L3AgentExtensionsManager(
self.conf))
self.l3_ext_manager.initialize(connection, lib_const.L3_AGENT_MODE,
self.agent_api)
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 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 test_is_router_in_namespace_for_not_in_ns(self):
router_info, ri = self._prepare_router_data()
with mock.patch.object(ip_lib,
'list_network_namespaces') as mock_list_netns:
mock_list_netns.return_value = [uuidutils.generate_uuid()]
api_object = l3_agent_api.L3AgentExtensionAPI(router_info)
router_in_ns = api_object.is_router_in_namespace(ri.router_id)
self.assertFalse(router_in_ns)
def test_is_router_in_namespace_for_in_ns(self):
router_info, ri = self._prepare_router_data()
with mock.patch.object(ip_lib,
'list_network_namespaces') as mock_list_netns:
mock_list_netns.return_value = [ri.ns_name]
api_object = l3_agent_api.L3AgentExtensionAPI(router_info, None)
router_in_ns = api_object.is_router_in_namespace(ri.router_id)
self.assertTrue(router_in_ns)
def test_is_router_in_namespace_for_not_in_ns(self):
router_info, ri = self._prepare_router_data()
with mock.patch.object(ip_lib.IPWrapper,
'get_namespaces') as mock_get_namespaces:
mock_get_namespaces.return_value = [str(uuid.uuid4())]
api_object = l3_agent_api.L3AgentExtensionAPI(router_info)
router_in_ns = api_object.is_router_in_namespace(ri.router_id)
self.assertFalse(router_in_ns)
def test_get_routers_in_project(self):
router_info, ri = self._prepare_router_data()
with mock.patch.object(ip_lib,
'list_network_namespaces') as mock_list_netns:
mock_list_netns.return_value = [ri.ns_name]
api_object = l3_agent_api.L3AgentExtensionAPI(router_info)
routers = api_object.get_routers_in_project(self.project_id)
self.assertEqual([ri], routers)
def test_get_router_hosting_port_for_router_in_ns(self):
port_ids = [1, 2]
ports = [{'id': pid} for pid in port_ids]
router_info, ri = self._prepare_router_data(ports)
with mock.patch.object(ip_lib,
'list_network_namespaces') as mock_list_netns:
mock_list_netns.return_value = [ri.ns_name]
api_object = l3_agent_api.L3AgentExtensionAPI(router_info)
router = api_object.get_router_hosting_port(port_ids[0])
self.assertEqual(ri, router)
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 test_register_router(self):
router_info, ri = self._prepare_router_data()
router_info_cls = l3router.BaseRouterInfo
router_factory = agent.RouterFactory()
api_object = l3_agent_api.L3AgentExtensionAPI(router_info,
router_factory)
self.assertIsNone(
api_object.register_router([], router_info_cls))
self.assertIsNone(
api_object.register_router(['ha'], router_info_cls))
self.assertIsNone(
api_object.register_router(['distributed'], router_info_cls))
self.assertIsNone(
api_object.register_router(['ha', 'distributed'], router_info_cls))
def test_get_router_hosting_port_for_router_not_in_ns(self):
port_ids = [1, 2]
ports = [{'id': pid} for pid in port_ids]
router_info, ri = self._prepare_router_data(ports)
with mock.patch.object(ip_lib.IPWrapper,
'get_namespaces') as mock_get_namespaces:
mock_get_namespaces.return_value = []
api_object = l3_agent_api.L3AgentExtensionAPI(router_info)
router = api_object.get_router_hosting_port(port_ids[0])
mock_get_namespaces.assert_called_once_with()
self.assertFalse(router)
def test_get_in_ns_ports_for_fw(self):
port_ids = [1, 2]
ports = [{'id': pid} for pid in port_ids]
ri = self._prepare_router_data()
ri.internal_ports = ports
router_info = {}
router_info[ri.router_id] = ri
api_object = l3_agent_api.L3AgentExtensionAPI(router_info)
self.api.consume_api(api_object)
fw_port_ids = port_ids
ports_for_fw_expected = [(ri, port_ids)]
with mock.patch.object(ip_lib.IPWrapper,
'get_namespaces') as mock_get_namespaces:
mock_get_namespaces.return_value = [ri.ns_name]
ports_for_fw_actual = self.api._get_in_ns_ports(fw_port_ids)
self.assertEqual(ports_for_fw_expected, ports_for_fw_actual)
def test_get_in_ns_ports_for_non_ns_fw(self):
port_ids = [1, 2]
ports = [{'id': pid} for pid in port_ids]
ri = self._prepare_router_data()
ri.internal_ports = ports
router_info = {ri.router_id: ri}
api_object = l3_agent_api.L3AgentExtensionAPI(router_info)
self.api.consume_api(api_object)
fw_port_ids = port_ids
with mock.patch.object(ip_lib,
'list_network_namespaces') as mock_list_netns:
mock_list_netns.return_value = []
ports_for_fw_list = self.api._get_in_ns_ports(fw_port_ids)
mock_list_netns.assert_called_with()
self.assertFalse(ports_for_fw_list)
def test_get_router_info_list_for_tenant(self):
ri = self._prepare_router_data()
router_info = {ri.router_id: ri}
self.api.router_info = router_info
api_object = l3_agent_api.L3AgentExtensionAPI(router_info)
self.api.consume_api(api_object)
routers = [ri.router]
router_ids = [router['id'] for router in routers]
with mock.patch.object(ip_lib.IPWrapper,
'get_namespaces') as mock_get_namespaces:
mock_get_namespaces.return_value = []
router_info_list = self.api._get_router_info_list_for_tenant(
router_ids, ri.router['tenant_id'])
mock_get_namespaces.assert_called_once_with()
self.assertFalse(router_info_list)
def setUp(self):
super(NDPProxyExtensionTestCaseBase, self).setUp()
self.context = context.get_admin_context()
self.connection = mock.Mock()
self.ext_port_id = _uuid()
self.ex_net_id = _uuid()
self.ex_gw_port = {
'id': self.ext_port_id,
'network_id': self.ex_net_id,
'gw_port_host': HOSTNAME
}
self.fake_router_id = _uuid()
self.port_id = _uuid()
self.agent_api = l3_ext_api.L3AgentExtensionAPI(None, None)
self.np_ext = np.NDPProxyAgentExtension()
self.np_ext.consume_api(self.agent_api)
self.np_ext.initialize(self.connection, lib_const.L3_AGENT_MODE)
self.ndpproxy = np_obj.NDPProxy(context=None,
id=_uuid(),
router_id=self.fake_router_id,
port_id=self.port_id,
ip_address='2002::1:3')
port_binding = ports_obj.PortBinding(port_id=self.port_id,
host=HOSTNAME)
port_obj = ports_obj.Port(id=self.port_id, bindings=[port_binding])
self.ndp_proxies = [self.ndpproxy]
self.ports = [port_obj]
agent_configurations = {
'agent_mode': lib_const.L3_AGENT_MODE_DVR_NO_EXTERNAL
}
self.agent_obj = agent_obj.Agent(id=_uuid(),
host=HOSTNAME,
agent_type=lib_const.AGENT_TYPE_L3,
configurations=agent_configurations)
self.ip_wrapper = mock.patch('neutron.agent.linux.'
'ip_lib.IPWrapper').start()
self._set_pull_mock()
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)
def _initialize_iptables_log(self):
self.agent_api = l3_ext_api.L3AgentExtensionAPI({})
log_driver = log.IptablesLoggingDriver(self.agent_api)
log_driver.initialize(self.resource_rpc)
log_driver.conf = self.conf
return log_driver
def test_get_router_info(self):
router_info, ri = self._prepare_router_data()
api_object = l3_agent_api.L3AgentExtensionAPI(router_info)
self.assertEqual(ri, api_object.get_router_info(self.router_id))
def test_get_router_info_nonexistent(self):
router_info, ri = self._prepare_router_data()
api_object = l3_agent_api.L3AgentExtensionAPI(router_info)
self.assertIsNone(
api_object.get_router_info(uuidutils.generate_uuid()))
