diff --git a/neutron/agent/l3/agent.py b/neutron/agent/l3/agent.py index 142b209b6ce..a2c7c7dcea3 100644 --- a/neutron/agent/l3/agent.py +++ b/neutron/agent/l3/agent.py @@ -308,6 +308,7 @@ class L3NATAgent(ha.AgentMixin, def _create_router(self, router_id, router): args = [] kwargs = { + 'agent': self, 'router_id': router_id, 'router': router, 'use_ipv6': self.use_ipv6, @@ -316,7 +317,6 @@ class L3NATAgent(ha.AgentMixin, } if router.get('distributed'): - kwargs['agent'] = self kwargs['host'] = self.host if router.get('distributed') and router.get('ha'): @@ -368,7 +368,7 @@ class L3NATAgent(ha.AgentMixin, registry.notify(resources.ROUTER, events.BEFORE_DELETE, self, router=ri) - ri.delete(self) + ri.delete() del self.router_info[router_id] registry.notify(resources.ROUTER, events.AFTER_DELETE, self, router=ri) @@ -443,7 +443,7 @@ class L3NATAgent(ha.AgentMixin, self._router_added(router['id'], router) ri = self.router_info[router['id']] ri.router = router - ri.process(self) + ri.process() registry.notify(resources.ROUTER, events.AFTER_CREATE, self, router=ri) self.l3_ext_manager.add_router(self.context, router) @@ -452,7 +452,7 @@ class L3NATAgent(ha.AgentMixin, ri.router = router registry.notify(resources.ROUTER, events.BEFORE_UPDATE, self, router=ri) - ri.process(self) + ri.process() registry.notify(resources.ROUTER, events.AFTER_UPDATE, self, router=ri) self.l3_ext_manager.update_router(self.context, router) diff --git a/neutron/agent/l3/dvr_edge_ha_router.py b/neutron/agent/l3/dvr_edge_ha_router.py index b87e4bdc6b3..e24effaecfd 100644 --- a/neutron/agent/l3/dvr_edge_ha_router.py +++ b/neutron/agent/l3/dvr_edge_ha_router.py @@ -26,8 +26,8 @@ class DvrEdgeHaRouter(dvr_edge_router.DvrEdgeRouter, DVR router with HA capabilities. """ - def __init__(self, agent, host, *args, **kwargs): - super(DvrEdgeHaRouter, self).__init__(agent, host, + def __init__(self, host, *args, **kwargs): + super(DvrEdgeHaRouter, self).__init__(host, *args, **kwargs) self.enable_snat = None diff --git a/neutron/agent/l3/dvr_edge_router.py b/neutron/agent/l3/dvr_edge_router.py index a35fdfd8783..e7f63f40112 100644 --- a/neutron/agent/l3/dvr_edge_router.py +++ b/neutron/agent/l3/dvr_edge_router.py @@ -27,8 +27,8 @@ LOG = logging.getLogger(__name__) class DvrEdgeRouter(dvr_local_router.DvrLocalRouter): - def __init__(self, agent, host, *args, **kwargs): - super(DvrEdgeRouter, self).__init__(agent, host, *args, **kwargs) + def __init__(self, host, *args, **kwargs): + super(DvrEdgeRouter, self).__init__(host, *args, **kwargs) self.snat_namespace = dvr_snat_ns.SnatNamespace( self.router_id, self.agent_conf, self.driver, self.use_ipv6) self.snat_iptables_manager = None @@ -211,8 +211,8 @@ class DvrEdgeRouter(dvr_local_router.DvrLocalRouter): "the router."), ns_name) super(DvrEdgeRouter, self).update_routing_table(operation, route) - def delete(self, agent): - super(DvrEdgeRouter, self).delete(agent) + def delete(self): + super(DvrEdgeRouter, self).delete() if self.snat_namespace.exists(): self.snat_namespace.delete() diff --git a/neutron/agent/l3/dvr_local_router.py b/neutron/agent/l3/dvr_local_router.py index deba6ab113b..2bd11df99f4 100644 --- a/neutron/agent/l3/dvr_local_router.py +++ b/neutron/agent/l3/dvr_local_router.py @@ -39,8 +39,8 @@ Arp_entry = collections.namedtuple( class DvrLocalRouter(dvr_router_base.DvrRouterBase): - def __init__(self, agent, host, *args, **kwargs): - super(DvrLocalRouter, self).__init__(agent, host, *args, **kwargs) + def __init__(self, host, *args, **kwargs): + super(DvrLocalRouter, self).__init__(host, *args, **kwargs) self.floating_ips_dict = {} # Linklocal subnet for router and floating IP namespace link @@ -505,11 +505,11 @@ class DvrLocalRouter(dvr_router_base.DvrRouterBase): ext_scope_mark) return ports_scopemark - def process_external(self, agent): + def process_external(self): ex_gw_port = self.get_ex_gw_port() if ex_gw_port: self.create_dvr_fip_interfaces(ex_gw_port) - super(DvrLocalRouter, self).process_external(agent) + super(DvrLocalRouter, self).process_external() def create_dvr_fip_interfaces(self, ex_gw_port): floating_ips = self.get_floating_ips() @@ -562,10 +562,10 @@ class DvrLocalRouter(dvr_router_base.DvrRouterBase): return {common_utils.ip_to_cidr(route['cidr']) for route in exist_routes} - def process(self, agent): + def process(self): ex_gw_port = self.get_ex_gw_port() if ex_gw_port: - self.fip_ns = agent.get_fip_ns(ex_gw_port['network_id']) + self.fip_ns = self.agent.get_fip_ns(ex_gw_port['network_id']) self.fip_ns.scan_fip_ports(self) - super(DvrLocalRouter, self).process(agent) + super(DvrLocalRouter, self).process() diff --git a/neutron/agent/l3/dvr_router_base.py b/neutron/agent/l3/dvr_router_base.py index 56b26253174..8aec99f3d2e 100644 --- a/neutron/agent/l3/dvr_router_base.py +++ b/neutron/agent/l3/dvr_router_base.py @@ -20,15 +20,14 @@ LOG = logging.getLogger(__name__) class DvrRouterBase(router.RouterInfo): - def __init__(self, agent, host, *args, **kwargs): + def __init__(self, host, *args, **kwargs): super(DvrRouterBase, self).__init__(*args, **kwargs) - self.agent = agent self.host = host self.snat_ports = None - def process(self, agent): - super(DvrRouterBase, self).process(agent) + def process(self): + super(DvrRouterBase, self).process() # NOTE: Keep a copy of the interfaces around for when they are removed self.snat_ports = self.get_snat_interfaces() diff --git a/neutron/agent/l3/ha_router.py b/neutron/agent/l3/ha_router.py index b87929faa57..9028b020b87 100644 --- a/neutron/agent/l3/ha_router.py +++ b/neutron/agent/l3/ha_router.py @@ -401,14 +401,14 @@ class HaRouter(router.RouterInfo): namespace=self.ns_name, prefix=router.EXTERNAL_DEV_PREFIX) - def delete(self, agent): + def delete(self): self.destroy_state_change_monitor(self.process_monitor) self.disable_keepalived() self.ha_network_removed() - super(HaRouter, self).delete(agent) + super(HaRouter, self).delete() - def process(self, agent): - super(HaRouter, self).process(agent) + def process(self): + super(HaRouter, self).process() self.ha_port = self.router.get(n_consts.HA_INTERFACE_KEY) if (self.ha_port and diff --git a/neutron/agent/l3/router_info.py b/neutron/agent/l3/router_info.py index 7c69a1f5388..7670984e71f 100644 --- a/neutron/agent/l3/router_info.py +++ b/neutron/agent/l3/router_info.py @@ -43,11 +43,13 @@ DEFAULT_ADDRESS_SCOPE = "noscope" class RouterInfo(object): def __init__(self, + agent, router_id, router, agent_conf, interface_driver, use_ipv6=False): + self.agent = agent self.router_id = router_id self.ex_gw_port = None self._snat_enabled = None @@ -374,11 +376,11 @@ class RouterInfo(object): fip_statuses[fip['id']] = lib_constants.FLOATINGIP_STATUS_ERROR return fip_statuses - def delete(self, agent): + def delete(self): self.router['gw_port'] = None self.router[lib_constants.INTERFACE_KEY] = [] self.router[lib_constants.FLOATINGIP_KEY] = [] - self.process_delete(agent) + self.process_delete() self.disable_radvd() self.router_namespace.delete() @@ -493,7 +495,7 @@ class RouterInfo(object): return '-o %s -m mark ! --mark %s -j DROP' % ( device_name, mark_mask) - def _process_internal_ports(self, pd): + def _process_internal_ports(self): existing_port_ids = set(p['id'] for p in self.internal_ports) internal_ports = self.router.get(lib_constants.INTERFACE_KEY, []) @@ -516,7 +518,7 @@ class RouterInfo(object): for subnet in p['subnets']: if ipv6_utils.is_ipv6_pd_enabled(subnet): interface_name = self.get_internal_device_name(p['id']) - pd.enable_subnet(self.router_id, subnet['id'], + self.agent.pd.enable_subnet(self.router_id, subnet['id'], subnet['cidr'], interface_name, p['mac_address']) @@ -527,7 +529,7 @@ class RouterInfo(object): enable_ra = enable_ra or self._port_has_ipv6_subnet(p) for subnet in p['subnets']: if ipv6_utils.is_ipv6_pd_enabled(subnet): - pd.disable_subnet(self.router_id, subnet['id']) + self.agent.pd.disable_subnet(self.router_id, subnet['id']) updated_cidrs = [] if updated_ports: @@ -547,7 +549,8 @@ class RouterInfo(object): if p['id'] in (set(current_port_ids) & set(existing_port_ids)): for subnet in p.get('subnets', []): if ipv6_utils.is_ipv6_pd_enabled(subnet): - old_prefix = pd.update_subnet(self.router_id, + old_prefix = self.agent.pd.update_subnet( + self.router_id, subnet['id'], subnet['cidr']) if old_prefix: @@ -570,7 +573,7 @@ class RouterInfo(object): for stale_dev in stale_devs: LOG.debug('Deleting stale internal router device: %s', stale_dev) - pd.remove_stale_ri_ifname(self.router_id, stale_dev) + self.agent.pd.remove_stale_ri_ifname(self.router_id, stale_dev) self.driver.unplug(stale_dev, namespace=self.ns_name, prefix=INTERNAL_DEV_PREFIX) @@ -681,11 +684,13 @@ class RouterInfo(object): def external_gateway_added(self, ex_gw_port, interface_name): preserve_ips = self._list_floating_ip_cidrs() + preserve_ips.extend(self.agent.pd.get_preserve_ips(self.router_id)) self._external_gateway_added( ex_gw_port, interface_name, self.ns_name, preserve_ips) def external_gateway_updated(self, ex_gw_port, interface_name): preserve_ips = self._list_floating_ip_cidrs() + preserve_ips.extend(self.agent.pd.get_preserve_ips(self.router_id)) self._external_gateway_added( ex_gw_port, interface_name, self.ns_name, preserve_ips) @@ -708,7 +713,7 @@ class RouterInfo(object): def _gateway_ports_equal(port1, port2): return port1 == port2 - def _process_external_gateway(self, ex_gw_port, pd): + def _process_external_gateway(self, ex_gw_port): # TODO(Carl) Refactor to clarify roles of ex_gw_port vs self.ex_gw_port ex_gw_port_id = (ex_gw_port and ex_gw_port['id'] or self.ex_gw_port and self.ex_gw_port['id']) @@ -719,12 +724,13 @@ class RouterInfo(object): if ex_gw_port: if not self.ex_gw_port: self.external_gateway_added(ex_gw_port, interface_name) - pd.add_gw_interface(self.router['id'], interface_name) + self.agent.pd.add_gw_interface(self.router['id'], + interface_name) elif not self._gateway_ports_equal(ex_gw_port, self.ex_gw_port): self.external_gateway_updated(ex_gw_port, interface_name) elif not ex_gw_port and self.ex_gw_port: self.external_gateway_removed(self.ex_gw_port, interface_name) - pd.remove_gw_interface(self.router['id']) + self.agent.pd.remove_gw_interface(self.router['id']) elif not ex_gw_port and not self.ex_gw_port: for p in self.internal_ports: interface_name = self.get_internal_device_name(p['id']) @@ -736,7 +742,7 @@ class RouterInfo(object): and dev != interface_name] for stale_dev in stale_devs: LOG.debug('Deleting stale external router device: %s', stale_dev) - pd.remove_gw_interface(self.router['id']) + self.agent.pd.remove_gw_interface(self.router['id']) self.driver.unplug(stale_dev, bridge=self.agent_conf.external_network_bridge, namespace=self.ns_name, @@ -820,11 +826,11 @@ class RouterInfo(object): self.iptables_manager, interface_name) - def _process_external_on_delete(self, agent): + def _process_external_on_delete(self): fip_statuses = {} try: ex_gw_port = self.get_ex_gw_port() - self._process_external_gateway(ex_gw_port, agent.pd) + self._process_external_gateway(ex_gw_port) if not ex_gw_port: return @@ -837,14 +843,14 @@ class RouterInfo(object): LOG.exception(_LE("Failed to process floating IPs.")) fip_statuses = self.put_fips_in_error_state() finally: - self.update_fip_statuses(agent, fip_statuses) + self.update_fip_statuses(fip_statuses) - def process_external(self, agent): + def process_external(self): fip_statuses = {} try: with self.iptables_manager.defer_apply(): ex_gw_port = self.get_ex_gw_port() - self._process_external_gateway(ex_gw_port, agent.pd) + self._process_external_gateway(ex_gw_port) if not ex_gw_port: return @@ -863,9 +869,9 @@ class RouterInfo(object): LOG.exception(_LE("Failed to process floating IPs.")) fip_statuses = self.put_fips_in_error_state() finally: - self.update_fip_statuses(agent, fip_statuses) + self.update_fip_statuses(fip_statuses) - def update_fip_statuses(self, agent, fip_statuses): + def update_fip_statuses(self, fip_statuses): # Identify floating IPs which were disabled existing_floating_ips = self.floating_ips self.floating_ips = set(fip_statuses.keys()) @@ -878,8 +884,8 @@ class RouterInfo(object): return LOG.debug('Sending floating ip statuses: %s', fip_statuses) # Update floating IP status on the neutron server - agent.plugin_rpc.update_floatingip_statuses( - agent.context, self.router_id, fip_statuses) + self.agent.plugin_rpc.update_floatingip_statuses( + self.agent.context, self.router_id, fip_statuses) def initialize_address_scope_iptables(self): self._initialize_address_scope_iptables(self.iptables_manager) @@ -1035,7 +1041,7 @@ class RouterInfo(object): self.process_floating_ip_address_scope_rules() @common_utils.exception_logger() - def process_delete(self, agent): + def process_delete(self): """Process the delete of this router This method is the point where the agent requests that this router @@ -1047,15 +1053,15 @@ class RouterInfo(object): """ LOG.debug("process router delete") if self.router_namespace.exists(): - self._process_internal_ports(agent.pd) - agent.pd.sync_router(self.router['id']) - self._process_external_on_delete(agent) + self._process_internal_ports() + self.agent.pd.sync_router(self.router['id']) + self._process_external_on_delete() else: LOG.warning(_LW("Can't gracefully delete the router %s: " "no router namespace found."), self.router['id']) @common_utils.exception_logger() - def process(self, agent): + def process(self): """Process updates to this router This method is the point where the agent requests that updates be @@ -1064,9 +1070,9 @@ class RouterInfo(object): :param agent: Passes the agent in order to send RPC messages. """ LOG.debug("process router updates") - self._process_internal_ports(agent.pd) - agent.pd.sync_router(self.router['id']) - self.process_external(agent) + self._process_internal_ports() + self.agent.pd.sync_router(self.router['id']) + self.process_external() self.process_address_scope() # Process static routes for router self.routes_updated(self.routes, self.router['routes']) diff --git a/neutron/agent/linux/pd.py b/neutron/agent/linux/pd.py index 7ab83cafc5b..4c8f4b4aaaa 100644 --- a/neutron/agent/linux/pd.py +++ b/neutron/agent/linux/pd.py @@ -158,6 +158,15 @@ class PrefixDelegation(object): router['gw_interface'] = None self.delete_router_pd(router) + @utils.synchronized("l3-agent-pd") + def get_preserve_ips(self, router_id): + preserve_ips = [] + router = self.routers.get(router_id) + if router is not None: + for subnet_id, pd_info in router['subnets'].items(): + preserve_ips.append(pd_info.get_bind_lla_with_mask()) + return preserve_ips + @utils.synchronized("l3-agent-pd") def sync_router(self, router_id): router = self.routers.get(router_id) diff --git a/neutron/tests/functional/agent/l3/framework.py b/neutron/tests/functional/agent/l3/framework.py index 5dd479bbab5..2683a95fe5f 100644 --- a/neutron/tests/functional/agent/l3/framework.py +++ b/neutron/tests/functional/agent/l3/framework.py @@ -135,7 +135,7 @@ class L3AgentTestFramework(base.BaseSudoTestCase): clean_fips(router) self._add_fip(router, client_address, fixed_address=server_address) - router.process(self.agent) + router.process() router_ns = ip_lib.IPWrapper(namespace=router.ns_name) netcat = net_helpers.NetcatTester( @@ -159,7 +159,7 @@ class L3AgentTestFramework(base.BaseSudoTestCase): assert_num_of_conntrack_rules(1) clean_fips(router) - router.process(self.agent) + router.process() assert_num_of_conntrack_rules(0) with testtools.ExpectedException(RuntimeError): @@ -237,7 +237,7 @@ class L3AgentTestFramework(base.BaseSudoTestCase): count=2, ip_version=6, ipv6_subnet_modes=subnet_modes) - router.process(self.agent) + router.process() if enable_ha: port = router.get_ex_gw_port() diff --git a/neutron/tests/functional/agent/l3/test_dvr_router.py b/neutron/tests/functional/agent/l3/test_dvr_router.py index 56911e8ed5f..09a2d3cb14e 100644 --- a/neutron/tests/functional/agent/l3/test_dvr_router.py +++ b/neutron/tests/functional/agent/l3/test_dvr_router.py @@ -1042,7 +1042,7 @@ class TestDvrRouter(framework.L3AgentTestFramework): subnet['gateway_ip'] = None router.router[n_const.FLOATINGIP_AGENT_INTF_KEY] = [new_fg_port] - router.process(self.agent) + router.process() self.assertIsNone(ex_gw_device.route.get_gateway()) self.assertIsNone(fg_device.route.get_gateway()) @@ -1133,7 +1133,7 @@ class TestDvrRouter(framework.L3AgentTestFramework): fixed_address=machine_diff_scope.ip, host=self.agent.conf.host, fixed_ip_address_scope='scope2') - router.process(self.agent) + router.process() br_ex = framework.get_ovs_bridge( self.agent.conf.external_network_bridge) diff --git a/neutron/tests/functional/agent/l3/test_ha_router.py b/neutron/tests/functional/agent/l3/test_ha_router.py index fd434be1aef..e98955cefcc 100644 --- a/neutron/tests/functional/agent/l3/test_ha_router.py +++ b/neutron/tests/functional/agent/l3/test_ha_router.py @@ -112,7 +112,7 @@ class L3HATestCase(framework.L3AgentTestFramework): _ext_dev_name, ex_port = l3_test_common.prepare_ext_gw_test( mock.Mock(), router) router_info['gw_port'] = ex_port - router.process(self.agent) + router.process() self._assert_ipv6_accept_ra(router) def test_keepalived_configuration(self): @@ -138,7 +138,7 @@ class L3HATestCase(framework.L3AgentTestFramework): router.router['gw_port']['subnets'] = subnets router.router['gw_port']['fixed_ips'] = fixed_ips - router.process(self.agent) + router.process() # Get the updated configuration and assert that both FIPs are in, # and that the GW IP address was updated. @@ -220,7 +220,7 @@ class L3HATestCase(framework.L3AgentTestFramework): self._add_internal_interface_by_subnet(router.router, count=1, ip_version=6, ipv6_subnet_modes=[slaac_mode], interface_id=interface_id) - router.process(self.agent) + router.process() common_utils.wait_until_true(lambda: router.ha_state == 'master') # Verify that router internal interface is present and is configured @@ -240,7 +240,7 @@ class L3HATestCase(framework.L3AgentTestFramework): subnets.append(interfaces[0]['subnets'][0]) interfaces[0].update({'fixed_ips': fixed_ips, 'subnets': subnets}) router.router[constants.INTERFACE_KEY] = interfaces - router.process(self.agent) + router.process() # Verify that router internal interface has a single ipaddress internal_iface = router.router[constants.INTERFACE_KEY][0] @@ -269,7 +269,7 @@ class L3HATestCase(framework.L3AgentTestFramework): interface_name = router.get_external_device_interface_name(ex_gw_port) common_utils.wait_until_true(lambda: router.ha_state == 'master') self._add_fip(router, '172.168.1.20', fixed_address='10.0.0.3') - router.process(self.agent) + router.process() router.router[constants.FLOATINGIP_KEY] = [] # The purpose of the test is to simply make sure no exception is raised # Because router.process will consume the FloatingIpSetupException, diff --git a/neutron/tests/functional/agent/l3/test_legacy_router.py b/neutron/tests/functional/agent/l3/test_legacy_router.py index d79cd7a4618..fe6f7135012 100644 --- a/neutron/tests/functional/agent/l3/test_legacy_router.py +++ b/neutron/tests/functional/agent/l3/test_legacy_router.py @@ -93,7 +93,7 @@ class L3AgentTestCase(framework.L3AgentTestFramework): router.ex_gw_port = copy.deepcopy(router.ex_gw_port) for subnet in gw_port['subnets']: subnet['gateway_ip'] = None - router.process(self.agent) + router.process() self.assertIsNone(device.route.get_gateway()) @@ -267,7 +267,7 @@ class L3AgentTestCase(framework.L3AgentTestFramework): dst_fip = '19.4.4.10' router.router[lib_constants.FLOATINGIP_KEY] = [] self._add_fip(router, dst_fip, fixed_address=dst_machine.ip) - router.process(self.agent) + router.process() return src_machine, dst_machine, dst_fip @@ -365,7 +365,7 @@ class L3AgentTestCase(framework.L3AgentTestFramework): self._add_fip(router, fip_diff_scope, fixed_address=machine_diff_scope.ip, fixed_ip_address_scope='scope2') - router.process(self.agent) + router.process() br_ex = framework.get_ovs_bridge( self.agent.conf.external_network_bridge) @@ -403,7 +403,7 @@ class L3AgentTestCase(framework.L3AgentTestFramework): self._add_fip(router, fip, fixed_address=machine_diff_scope.ip, fixed_ip_address_scope='scope2') - router.process(self.agent) + router.process() # For the internal networks that are in the same address scope as # external network, they should be able to reach the floating ip diff --git a/neutron/tests/unit/agent/l3/test_agent.py b/neutron/tests/unit/agent/l3/test_agent.py index 55609f2ca62..402150fba69 100644 --- a/neutron/tests/unit/agent/l3/test_agent.py +++ b/neutron/tests/unit/agent/l3/test_agent.py @@ -181,7 +181,7 @@ class BasicRouterOperationsFramework(base.BaseTestCase): agent.process_monitor, ri.get_internal_device_name, self.conf) - ri.process(agent) + ri.process() class TestBasicRouterOperations(BasicRouterOperationsFramework): @@ -281,7 +281,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): def test_router_info_create(self): id = _uuid() - ri = l3router.RouterInfo(id, {}, **self.ri_kwargs) + agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) + ri = l3router.RouterInfo(agent, id, {}, **self.ri_kwargs) self.assertTrue(ri.ns_name.endswith(id)) @@ -301,7 +302,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): 'enable_snat': True, 'routes': [], 'gw_port': ex_gw_port} - ri = l3router.RouterInfo(ns_id, router, **self.ri_kwargs) + agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) + ri = l3router.RouterInfo(agent, ns_id, router, **self.ri_kwargs) self.assertTrue(ri.ns_name.endswith(ns_id)) self.assertEqual(router, ri.router) @@ -311,7 +313,9 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): def _test_internal_network_action(self, action): router = l3_test_common.prepare_router_data(num_internal_ports=2) router_id = router['id'] - ri = l3router.RouterInfo(router_id, router, **self.ri_kwargs) + agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) + ri = l3router.RouterInfo(agent, router_id, + router, **self.ri_kwargs) port = {'network_id': _uuid(), 'id': _uuid(), 'mac_address': 'ca:fe:de:ad:be:ef', @@ -342,10 +346,9 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): def _test_internal_network_action_dist(self, action): router = l3_test_common.prepare_router_data(num_internal_ports=2) - router_id = router['id'] agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) - ri = dvr_router.DvrEdgeRouter( - agent, HOSTNAME, router_id, router, **self.ri_kwargs) + self._set_ri_kwargs(agent, router['id'], router) + ri = dvr_router.DvrEdgeRouter(HOSTNAME, **self.ri_kwargs) subnet_id = _uuid() port = {'network_id': _uuid(), 'id': _uuid(), @@ -472,6 +475,11 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): ri._create_dvr_gateway.assert_called_once_with( ex_gw_port, interface_name) + def _set_ri_kwargs(self, agent, router_id, router): + self.ri_kwargs['agent'] = agent + self.ri_kwargs['router_id'] = router_id + self.ri_kwargs['router'] = router + def _test_external_gateway_action(self, action, router, dual_stack=False): agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) ex_net_id = _uuid() @@ -480,11 +488,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): if router.get('distributed'): agent.conf.agent_mode = 'dvr_snat' agent.host = HOSTNAME - ri = dvr_router.DvrEdgeRouter(agent, - HOSTNAME, - router['id'], - router, - **self.ri_kwargs) + self._set_ri_kwargs(agent, router['id'], router) + ri = dvr_router.DvrEdgeRouter(HOSTNAME, **self.ri_kwargs) ri._create_dvr_gateway = mock.Mock() ri.get_snat_interfaces = mock.Mock(return_value=self.snat_ports) ri.snat_ports = self.snat_ports @@ -493,7 +498,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): ri.internal_ports = self.snat_ports else: ri = l3router.RouterInfo( - router['id'], router, + agent, router['id'], router, **self.ri_kwargs) ri.use_ipv6 = False @@ -577,8 +582,10 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): raise Exception("Invalid action %s" % action) def _test_external_gateway_updated(self, dual_stack=False): + agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) router = l3_test_common.prepare_router_data(num_internal_ports=2) - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, router['id'], + router, **self.ri_kwargs) ri.use_ipv6 = False interface_name, ex_gw_port = l3_test_common.prepare_ext_gw_test( self, ri, dual_stack=dual_stack) @@ -619,11 +626,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): def test_dvr_edge_router_init_for_snat_namespace_object(self): router = {'id': _uuid()} - ri = dvr_router.DvrEdgeRouter(mock.Mock(), - HOSTNAME, - router['id'], - router, - **self.ri_kwargs) + self._set_ri_kwargs(mock.Mock(), router['id'], router) + ri = dvr_router.DvrEdgeRouter(HOSTNAME, **self.ri_kwargs) # Make sure that ri.snat_namespace object is created when the # router is initialized self.assertIsNotNone(ri.snat_namespace) @@ -637,11 +641,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): snat_namespace when the gw_port_host mismatches or none. """ router = l3_test_common.prepare_router_data(num_internal_ports=2) - ri = dvr_router.DvrEdgeRouter(mock.Mock(), - HOSTNAME, - router['id'], - router, - **self.ri_kwargs) + self._set_ri_kwargs(mock.Mock(), router['id'], router) + ri = dvr_router.DvrEdgeRouter(HOSTNAME, **self.ri_kwargs) with mock.patch.object(dvr_snat_ns.SnatNamespace, 'delete') as snat_ns_delete: interface_name, ex_gw_port = l3_test_common.prepare_ext_gw_test( @@ -666,11 +667,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): it tries to delete. """ router = l3_test_common.prepare_router_data(num_internal_ports=2) - ri = dvr_router.DvrEdgeRouter(mock.Mock(), - HOSTNAME, - router['id'], - router, - **self.ri_kwargs) + self._set_ri_kwargs(mock.Mock(), router['id'], router) + ri = dvr_router.DvrEdgeRouter(HOSTNAME, **self.ri_kwargs) # Make sure we set a return value to emulate the non existence # of the namespace. self.mock_ip.netns.exists.return_value = False @@ -691,11 +689,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): snat for the router """ router = l3_test_common.prepare_router_data(num_internal_ports=2) - ri = dvr_router.DvrEdgeRouter(mock.Mock(), - HOSTNAME, - router['id'], - router, - **self.ri_kwargs) + self._set_ri_kwargs(mock.Mock(), router['id'], router) + ri = dvr_router.DvrEdgeRouter(HOSTNAME, **self.ri_kwargs) if snat_hosted_before: ri._create_snat_namespace() snat_ns_name = ri.snat_namespace.name @@ -830,11 +825,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): def test_get_snat_port_for_internal_port(self): router = l3_test_common.prepare_router_data(num_internal_ports=4) - ri = dvr_router.DvrEdgeRouter(mock.sentinel.agent, - HOSTNAME, - router['id'], - router, - **self.ri_kwargs) + self._set_ri_kwargs(mock.Mock(), router['id'], router) + ri = dvr_router.DvrEdgeRouter(HOSTNAME, **self.ri_kwargs) test_port = { 'mac_address': '00:12:23:34:45:56', 'fixed_ips': [{'subnet_id': l3_test_common.get_subnet_id( @@ -855,17 +847,15 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): def test_process_cent_router(self): router = l3_test_common.prepare_router_data() agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, router['id'], + router, **self.ri_kwargs) self._test_process_router(ri, agent) def test_process_dist_router(self): router = l3_test_common.prepare_router_data() agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) - ri = dvr_router.DvrEdgeRouter(agent, - HOSTNAME, - router['id'], - router, - **self.ri_kwargs) + self._set_ri_kwargs(agent, router['id'], router) + ri = dvr_router.DvrEdgeRouter(HOSTNAME, **self.ri_kwargs) subnet_id = l3_test_common.get_subnet_id( router[lib_constants.INTERFACE_KEY][0]) ri.router['distributed'] = True @@ -893,7 +883,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): 'fixed_ip_address': '7.7.7.7', 'port_id': _uuid(), 'host': HOSTNAME}]} - ri.process(agent) + ri.process() ri.process_floating_ip_addresses.assert_called_with(mock.ANY) ri.process_floating_ip_addresses.reset_mock() ri.process_floating_ip_nat_rules.assert_called_with() @@ -905,7 +895,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): fake_floatingips2['floatingips'][0]['fixed_ip_address'] = '7.7.7.8' router[lib_constants.FLOATINGIP_KEY] = fake_floatingips2['floatingips'] - ri.process(agent) + ri.process() ri.process_floating_ip_addresses.assert_called_with(mock.ANY) ri.process_floating_ip_addresses.reset_mock() ri.process_floating_ip_nat_rules.assert_called_with() @@ -922,7 +912,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): ['fixed_ips'][0]['ip_address'])) ri.router['gw_port']['fixed_ips'][0]['ip_address'] = str(old_ip + 1) - ri.process(agent) + ri.process() ri.process_floating_ip_addresses.reset_mock() ri.process_floating_ip_nat_rules.reset_mock() self.assertEqual(0, ri.external_gateway_added.call_count) @@ -930,7 +920,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): # remove just the floating ips del router[lib_constants.FLOATINGIP_KEY] - ri.process(agent) + ri.process() ri.process_floating_ip_addresses.assert_called_with(mock.ANY) ri.process_floating_ip_addresses.reset_mock() ri.process_floating_ip_nat_rules.assert_called_with() @@ -939,7 +929,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): # now no ports so state is torn down del router[lib_constants.INTERFACE_KEY] del router['gw_port'] - ri.process(agent) + ri.process() self.assertEqual(1, self.send_adv_notif.call_count) distributed = ri.router.get('distributed', False) self.assertEqual(distributed, ri.process_floating_ip_addresses.called) @@ -996,8 +986,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): router[n_const.FLOATINGIP_AGENT_INTF_KEY] = agent_gateway_port router['distributed'] = True agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) - ri = dvr_router.DvrEdgeRouter( - agent, HOSTNAME, router['id'], router, **self.ri_kwargs) + self._set_ri_kwargs(agent, router['id'], router) + ri = dvr_router.DvrEdgeRouter(HOSTNAME, **self.ri_kwargs) ext_gw_port = ri.router.get('gw_port') ri.fip_ns = agent.get_fip_ns(ext_gw_port['network_id']) ri.dist_fip_count = 0 @@ -1062,8 +1052,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): router[n_const.FLOATINGIP_AGENT_INTF_KEY] = [] router['distributed'] = True agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) - ri = dvr_router.DvrEdgeRouter( - agent, HOSTNAME, router['id'], router, **self.ri_kwargs) + self._set_ri_kwargs(agent, router['id'], router) + ri = dvr_router.DvrEdgeRouter(HOSTNAME, **self.ri_kwargs) ext_gw_port = ri.router.get('gw_port') ri.fip_ns = agent.get_fip_ns(ext_gw_port['network_id']) @@ -1107,8 +1097,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): router[n_const.FLOATINGIP_AGENT_INTF_KEY] = agent_gateway_port router['distributed'] = True agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) - ri = dvr_router.DvrEdgeRouter( - agent, HOSTNAME, router['id'], router, **self.ri_kwargs) + self._set_ri_kwargs(agent, router['id'], router) + ri = dvr_router.DvrEdgeRouter(HOSTNAME, **self.ri_kwargs) ext_gw_port = ri.router.get('gw_port') ri.fip_ns = agent.get_fip_ns(ext_gw_port['network_id']) @@ -1158,8 +1148,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): router[n_const.FLOATINGIP_AGENT_INTF_KEY] = agent_gateway_port router['distributed'] = True agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) - ri = dvr_router.DvrEdgeRouter( - agent, HOSTNAME, router['id'], router, **self.ri_kwargs) + self._set_ri_kwargs(agent, router['id'], router) + ri = dvr_router.DvrEdgeRouter(HOSTNAME, **self.ri_kwargs) ext_gw_port = ri.router.get('gw_port') ri.fip_ns = agent.get_fip_ns(ext_gw_port['network_id']) ri.fip_ns.subscribe = mock.Mock(return_value=True) @@ -1192,7 +1182,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): router = l3_test_common.prepare_router_data(enable_snat=True) router[lib_constants.FLOATINGIP_KEY] = fake_floatingips['floatingips'] agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, router['id'], + router, **self.ri_kwargs) ri.iptables_manager.ipv4['nat'] = mock.MagicMock() ri.get_external_device_name = mock.Mock(return_value='exgw') self._test_process_floating_ip_addresses_add(ri, agent) @@ -1200,17 +1191,17 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): def test_process_router_snat_disabled(self): agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) router = l3_test_common.prepare_router_data(enable_snat=True) - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, router['id'], router, **self.ri_kwargs) ri.external_gateway_added = mock.Mock() # Process with NAT - ri.process(agent) + ri.process() orig_nat_rules = ri.iptables_manager.ipv4['nat'].rules[:] orig_mangle_rules = ri.iptables_manager.ipv4['mangle'].rules[:] # Reprocess without NAT router['enable_snat'] = False # Reassign the router object to RouterInfo ri.router = router - ri.process(agent) + ri.process() # For some reason set logic does not work well with # IpTablesRule instances nat_rules_delta = [r for r in orig_nat_rules @@ -1227,17 +1218,17 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): def test_process_router_snat_enabled(self): agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) router = l3_test_common.prepare_router_data(enable_snat=False) - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, router['id'], router, **self.ri_kwargs) ri.external_gateway_added = mock.Mock() # Process without NAT - ri.process(agent) + ri.process() orig_nat_rules = ri.iptables_manager.ipv4['nat'].rules[:] orig_mangle_rules = ri.iptables_manager.ipv4['mangle'].rules[:] # Reprocess with NAT router['enable_snat'] = True # Reassign the router object to RouterInfo ri.router = router - ri.process(agent) + ri.process() # For some reason set logic does not work well with # IpTablesRule instances nat_rules_delta = [r for r in ri.iptables_manager.ipv4['nat'].rules @@ -1260,12 +1251,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): 'nexthop': '19.4.4.200'} calls = [mock.call('replace', fake_route1, q_netns)] agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) - ri = dvr_router.DvrEdgeRouter( - agent, - HOSTNAME, - uuid, - router, - **self.ri_kwargs) + self._set_ri_kwargs(agent, uuid, router) + ri = dvr_router.DvrEdgeRouter(HOSTNAME, **self.ri_kwargs) ri._update_routing_table = mock.Mock() with mock.patch.object(ri, '_is_this_snat_host') as snat_host: @@ -1285,15 +1272,15 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): def test_process_router_interface_added(self): agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) router = l3_test_common.prepare_router_data() - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, router['id'], router, **self.ri_kwargs) ri.external_gateway_added = mock.Mock() # Process with NAT - ri.process(agent) + ri.process() # Add an interface and reprocess l3_test_common.router_append_interface(router) # Reassign the router object to RouterInfo ri.router = router - ri.process(agent) + ri.process() # send_ip_addr_adv_notif is called both times process is called self.assertEqual(2, self.send_adv_notif.call_count) @@ -1304,14 +1291,14 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): # Get NAT rules without the gw_port gw_port = router['gw_port'] router['gw_port'] = None - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, router['id'], router, **self.ri_kwargs) ri.external_gateway_added = mock.Mock() self._process_router_instance_for_agent(agent, ri, router) orig_nat_rules = ri.iptables_manager.ipv4['nat'].rules[:] # Get NAT rules with the gw_port router['gw_port'] = gw_port - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, router['id'], router, **self.ri_kwargs) p = ri.external_gateway_nat_fip_rules s = ri.external_gateway_nat_snat_rules attrs_to_mock = dict( @@ -1348,10 +1335,10 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): def _process_router_ipv6_interface_added( self, router, ra_mode=None, addr_mode=None): agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, router['id'], router, **self.ri_kwargs) ri.external_gateway_added = mock.Mock() # Process with NAT - ri.process(agent) + ri.process() orig_nat_rules = ri.iptables_manager.ipv4['nat'].rules[:] # Add an IPv6 interface and reprocess l3_test_common.router_append_interface(router, count=1, @@ -1381,7 +1368,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): def _process_router_ipv6_subnet_added(self, router, ipv6_subnet_modes=None, dns_nameservers=None, network_mtu=0): agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, router['id'], router, **self.ri_kwargs) agent.external_gateway_added = mock.Mock() self._process_router_instance_for_agent(agent, ri, router) # Add an IPv6 interface with len(ipv6_subnet_modes) subnets @@ -1455,7 +1442,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): def test_process_router_ipv6_subnets_added_to_existing_port(self): agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) router = l3_test_common.prepare_router_data() - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, router['id'], router, **self.ri_kwargs) agent.external_gateway_added = mock.Mock() self._process_router_instance_for_agent(agent, ri, router) # Add the first subnet on a new interface @@ -1497,10 +1484,10 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): def test_process_router_ipv6v4_interface_added(self): agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) router = l3_test_common.prepare_router_data() - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, router['id'], router, **self.ri_kwargs) ri.external_gateway_added = mock.Mock() # Process with NAT - ri.process(agent) + ri.process() # Add an IPv4 and IPv6 interface and reprocess l3_test_common.router_append_interface(router, count=1, ip_version=4) l3_test_common.router_append_interface(router, count=1, ip_version=6) @@ -1511,22 +1498,22 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): def test_process_router_interface_removed(self): agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) router = l3_test_common.prepare_router_data(num_internal_ports=2) - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, router['id'], router, **self.ri_kwargs) ri.external_gateway_added = mock.Mock() # Process with NAT - ri.process(agent) + ri.process() # Add an interface and reprocess del router[lib_constants.INTERFACE_KEY][1] # Reassign the router object to RouterInfo ri.router = router - ri.process(agent) + ri.process() # send_ip_addr_adv_notif is called both times process is called self.assertEqual(2, self.send_adv_notif.call_count) def test_process_router_ipv6_interface_removed(self): agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) router = l3_test_common.prepare_router_data() - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, router['id'], router, **self.ri_kwargs) ri.external_gateway_added = mock.Mock() self._process_router_instance_for_agent(agent, ri, router) # Add an IPv6 interface and reprocess @@ -1544,7 +1531,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): def test_process_router_ipv6_subnet_removed(self): agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) router = l3_test_common.prepare_router_data() - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, router['id'], router, **self.ri_kwargs) agent.external_gateway_added = mock.Mock() self._process_router_instance_for_agent(agent, ri, router) # Add an IPv6 interface with two subnets and reprocess @@ -1576,7 +1563,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): def test_process_router_internal_network_added_unexpected_error(self): agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) router = l3_test_common.prepare_router_data() - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, router['id'], router, **self.ri_kwargs) ri.external_gateway_added = mock.Mock() with mock.patch.object( ri, @@ -1584,7 +1571,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): # raise RuntimeError to simulate that an unexpected exception # occurs internal_network_added.side_effect = RuntimeError - self.assertRaises(RuntimeError, ri.process, agent) + self.assertRaises(RuntimeError, ri.process) self.assertNotIn( router[lib_constants.INTERFACE_KEY][0], ri.internal_ports) @@ -1593,7 +1580,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): # periodic_sync_routers_task finds out that _rpc_loop failed to # process the router last time, it will retry in the next run. - ri.process(agent) + ri.process() # We were able to add the port to ri.internal_ports self.assertIn( router[lib_constants.INTERFACE_KEY][0], ri.internal_ports) @@ -1601,10 +1588,10 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): def test_process_router_internal_network_removed_unexpected_error(self): agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) router = l3_test_common.prepare_router_data() - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, router['id'], router, **self.ri_kwargs) ri.external_gateway_added = mock.Mock() # add an internal port - ri.process(agent) + ri.process() with mock.patch.object( ri, @@ -1614,7 +1601,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): internal_net_removed.side_effect = RuntimeError ri.internal_ports[0]['admin_state_up'] = False # The above port is set to down state, remove it. - self.assertRaises(RuntimeError, ri.process, agent) + self.assertRaises(RuntimeError, ri.process) self.assertIn( router[lib_constants.INTERFACE_KEY][0], ri.internal_ports) @@ -1623,7 +1610,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): # periodic_sync_routers_task finds out that _rpc_loop failed to # process the router last time, it will retry in the next run. - ri.process(agent) + ri.process() # We were able to remove the port from ri.internal_ports self.assertNotIn( router[lib_constants.INTERFACE_KEY][0], ri.internal_ports) @@ -1639,7 +1626,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): 'floating_ip_address': '9.9.9.9'}) router[lib_constants.FLOATINGIP_KEY] = [fip1, fip2] - ri = legacy_router.LegacyRouter(router['id'], router, + ri = legacy_router.LegacyRouter(agent, router['id'], router, **self.ri_kwargs) ri.external_gateway_added = mock.Mock() with mock.patch.object( @@ -1648,7 +1635,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): mock.patch.object(ri, 'get_router_cidrs') as mock_get_cidrs: mock_get_cidrs.return_value = set( [fip1['floating_ip_address'] + '/32']) - ri.process(agent) + ri.process() # make sure only the one that wasn't in existing cidrs was sent mock_update_fip_status.assert_called_once_with( mock.ANY, ri.router_id, {fip2['id']: 'ACTIVE'}) @@ -1663,7 +1650,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): fip2.update({'id': _uuid(), 'status': 'DOWN', }) router[lib_constants.FLOATINGIP_KEY] = [fip1, fip2] - ri = legacy_router.LegacyRouter(router['id'], router, + ri = legacy_router.LegacyRouter(agent, router['id'], router, **self.ri_kwargs) ri.external_gateway_added = mock.Mock() with mock.patch.object( @@ -1671,7 +1658,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): ) as mock_update_fip_status,\ mock.patch.object(ri, 'get_router_cidrs') as mock_get_cidrs: mock_get_cidrs.return_value = set() - ri.process(agent) + ri.process() # make sure both was sent since not existed in existing cidrs mock_update_fip_status.assert_called_once_with( mock.ANY, ri.router_id, {fip1['id']: 'ACTIVE', @@ -1691,11 +1678,11 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): 'status': 'DOWN', 'port_id': router[lib_constants.INTERFACE_KEY][0]['id']}] - ri = legacy_router.LegacyRouter(router['id'], + ri = legacy_router.LegacyRouter(agent, router['id'], router, **self.ri_kwargs) ri.external_gateway_added = mock.Mock() - ri.process(agent) + ri.process() # Assess the call for putting the floating IP up was performed mock_update_fip_status.assert_called_once_with( mock.ANY, ri.router_id, @@ -1704,7 +1691,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): # Process the router again, this time without floating IPs router[lib_constants.FLOATINGIP_KEY] = [] ri.router = router - ri.process(agent) + ri.process() # Assess the call for putting the floating IP up was performed mock_update_fip_status.assert_called_once_with( mock.ANY, ri.router_id, @@ -1723,11 +1710,12 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): 'fixed_ip_address': '7.7.7.7', 'port_id': router[lib_constants.INTERFACE_KEY][0]['id']}] - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, router['id'], + router, **self.ri_kwargs) ri.process_floating_ip_addresses = mock.Mock( side_effect=RuntimeError) ri.external_gateway_added = mock.Mock() - ri.process(agent) + ri.process() # Assess the call for putting the floating IP into Error # was performed mock_update_fip_status.assert_called_once_with( @@ -1747,9 +1735,10 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): 'fixed_ip_address': '7.7.7.7', 'port_id': router[lib_constants.INTERFACE_KEY][0]['id']}] - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, router['id'], + router, **self.ri_kwargs) ri.iptables_manager._apply = mock.Mock(side_effect=Exception) - ri.process_external(agent) + ri.process_external() # Assess the call for putting the floating IP into Error # was performed mock_update_fip_status.assert_called_once_with( @@ -1760,12 +1749,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): def test_handle_router_snat_rules_distributed_without_snat_manager(self): agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) - ri = dvr_router.DvrEdgeRouter( - agent, - HOSTNAME, - 'foo_router_id', - {}, - **self.ri_kwargs) + self._set_ri_kwargs(agent, 'foo_router_id', {}) + ri = dvr_router.DvrEdgeRouter(HOSTNAME, **self.ri_kwargs) ri.iptables_manager = mock.MagicMock() ri._is_this_snat_host = mock.Mock(return_value=True) ri.get_ex_gw_port = mock.Mock(return_value=None) @@ -1775,7 +1760,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): self.assertFalse(ri.iptables_manager.called) def test_handle_router_snat_rules_add_back_jump(self): - ri = l3router.RouterInfo(_uuid(), {}, **self.ri_kwargs) + agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) + ri = l3router.RouterInfo(agent, _uuid(), {}, **self.ri_kwargs) ri.iptables_manager = mock.MagicMock() port = {'fixed_ips': [{'ip_address': '192.168.1.4'}]} @@ -1792,7 +1778,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): break def test_handle_router_snat_rules_add_rules(self): - ri = l3router.RouterInfo(_uuid(), {}, **self.ri_kwargs) + agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) + ri = l3router.RouterInfo(agent, _uuid(), {}, **self.ri_kwargs) ex_gw_port = {'fixed_ips': [{'ip_address': '192.168.1.4'}]} ri.router = {'distributed': False} ri._handle_router_snat_rules(ex_gw_port, "iface") @@ -1835,7 +1822,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): router = l3_test_common.prepare_router_data(enable_snat=True, num_internal_ports=1) - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, router['id'], router, **self.ri_kwargs) internal_ports = ri.router.get(lib_constants.INTERFACE_KEY, []) self.assertEqual(1, len(internal_ports)) @@ -1850,7 +1837,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): mock.patch.object(ri, 'external_gateway_added' ) as external_gateway_added: - ri.process(agent) + ri.process() self.assertEqual(1, external_gateway_added.call_count) self.assertFalse(external_gateway_removed.called) @@ -1872,11 +1859,11 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): router = l3_test_common.prepare_router_data(enable_snat=True, num_internal_ports=1) del router['gw_port'] - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, router['id'], router, **self.ri_kwargs) self.mock_ip.get_devices.return_value = stale_devlist - ri.process(agent) + ri.process() self.mock_driver.unplug.assert_called_with( stale_devnames[0], @@ -2072,7 +2059,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): self.assertFalse(router_processor.fetched_and_processed.called) agent._resync_router.assert_called_with(update) else: - router_info.delete.assert_called_once_with(agent) + router_info.delete.assert_called_once_with() self.assertFalse(agent.router_info) self.assertFalse(agent._resync_router.called) router_processor.fetched_and_processed.assert_called_once_with( @@ -2245,11 +2232,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): def test_create_dvr_gateway(self): agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) router = l3_test_common.prepare_router_data() - ri = dvr_router.DvrEdgeRouter(agent, - HOSTNAME, - router['id'], - router, - **self.ri_kwargs) + self._set_ri_kwargs(agent, router['id'], router) + ri = dvr_router.DvrEdgeRouter(HOSTNAME, **self.ri_kwargs) port_id = _uuid() subnet_id = _uuid() @@ -2281,11 +2265,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): router['gw_port_host'] = HOSTNAME agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) - ri = dvr_router.DvrEdgeRouter(agent, - HOSTNAME, - router['id'], - router, - **self.ri_kwargs) + self._set_ri_kwargs(agent, router['id'], router) + ri = dvr_router.DvrEdgeRouter(HOSTNAME, **self.ri_kwargs) ri.get_ex_gw_port = mock.Mock(return_value=None) # Make sure the code doesn't crash if ri.snat_iptables_manager is None. @@ -2332,8 +2313,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): self.mock_driver.unplug.reset_mock() external_net_id = router['gw_port']['network_id'] - ri = dvr_router.DvrEdgeRouter( - agent, HOSTNAME, router['id'], router, **self.ri_kwargs) + self._set_ri_kwargs(agent, router['id'], router) + ri = dvr_router.DvrEdgeRouter(HOSTNAME, **self.ri_kwargs) ri.remove_floating_ip = mock.Mock() agent._fetch_external_net_id = mock.Mock(return_value=external_net_id) ri.ex_gw_port = ri.router['gw_port'] @@ -2487,10 +2468,11 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): def _pd_setup_agent_router(self): router = l3_test_common.prepare_router_data() - ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs) agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) + ri = l3router.RouterInfo(agent, router['id'], + router, **self.ri_kwargs) agent.external_gateway_added = mock.Mock() - ri.process(agent) + ri.process() agent._router_added(router['id'], router) # Make sure radvd monitor is created if not ri.radvd: @@ -2561,7 +2543,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): # Process the router for removed interfaces agent.pd.notifier = pd_notifier - ri.process(agent) + ri.process() # The number of external process calls takes radvd into account. # This is because there is no ipv6 interface any more after removing @@ -2677,7 +2659,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): # Create one pd-enabled subnet and add router interface intfs = l3_test_common.router_append_pd_enabled_subnet(router) - ri.process(agent) + ri.process() # No client should be started since there is no gateway port self.assertFalse(self.external_process.call_count) @@ -2690,7 +2672,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): self._pd_get_prefixes(agent, router, ri, [], intfs, mock_get_prefix) # Update the router with the new prefix - ri.process(agent) + ri.process() # Check that radvd is started and the router port is configured # with the new prefix @@ -2716,7 +2698,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): # Create one pd-enabled subnet and add router interface intfs = l3_test_common.router_append_pd_enabled_subnet(router) - ri.process(agent) + ri.process() # Add the gateway interface self._pd_add_gw_interface(agent, router, ri) @@ -2725,7 +2707,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): self._pd_get_prefixes(agent, router, ri, [], intfs, mock_get_prefix) # Update the router with the new prefix - ri.process(agent) + ri.process() # Check that radvd is started self._pd_assert_radvd_calls(ri) @@ -2734,7 +2716,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): self._pd_remove_gw_interface(intfs, agent, router, ri) # There will be a router update - ri.process(agent) + ri.process() @mock.patch.object(dibbler.PDDibbler, 'get_prefix', autospec=True) @mock.patch.object(dibbler.os, 'getpid', return_value=1234) @@ -2753,7 +2735,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): # Create 2 pd-enabled subnets and add router interfaces intfs = l3_test_common.router_append_pd_enabled_subnet(router, count=2) - ri.process(agent) + ri.process() # No client should be started self.assertFalse(self.external_process.call_count) @@ -2766,7 +2748,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): self._pd_get_prefixes(agent, router, ri, [], intfs, mock_get_prefix) # Update the router with the new prefix - ri.process(agent) + ri.process() # Check that radvd is started and the router port is configured # with the new prefix @@ -2795,13 +2777,13 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): # Create 1 pd-enabled subnet and add router interface intfs = l3_test_common.router_append_pd_enabled_subnet(router, count=1) - ri.process(agent) + ri.process() # Get prefixes self._pd_get_prefixes(agent, router, ri, [], intfs, mock_get_prefix) # Update the router with the new prefix - ri.process(agent) + ri.process() # Check that radvd is started self._pd_assert_radvd_calls(ri) @@ -2810,14 +2792,14 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): # Create one pd-enabled subnet and add router interface intfs1 = l3_test_common.router_append_pd_enabled_subnet(router, count=1) - ri.process(agent) + ri.process() # Get prefixes self._pd_get_prefixes(agent, router, ri, intfs, intfs1, mock_get_prefix) # Update the router with the new prefix - ri.process(agent) + ri.process() # Check that radvd is notified for the new prefix self._pd_assert_radvd_calls(ri) @@ -2825,7 +2807,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): # Now remove the gw interface self._pd_remove_gw_interface(intfs + intfs1, agent, router, ri) - ri.process(agent) + ri.process() def _verify_address_scopes_iptables_rule(self, mock_iptables_manager): filter_calls = [mock.call.add_chain('scope'), @@ -2855,20 +2837,18 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework): def test_initialize_address_scope_iptables_rules(self): id = _uuid() + agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) with mock.patch('neutron.agent.linux.iptables_manager.' 'IptablesManager'): - ri = l3router.RouterInfo(id, {}, **self.ri_kwargs) + ri = l3router.RouterInfo(agent, id, {}, **self.ri_kwargs) self._verify_address_scopes_iptables_rule(ri.iptables_manager) def test_initialize_address_scope_iptables_rules_dvr(self): router = l3_test_common.prepare_router_data() with mock.patch('neutron.agent.linux.iptables_manager.' 'IptablesManager'): - ri = dvr_router.DvrEdgeRouter(mock.Mock(), - HOSTNAME, - router['id'], - router, - **self.ri_kwargs) + self._set_ri_kwargs(mock.Mock(), router['id'], router) + ri = dvr_router.DvrEdgeRouter(HOSTNAME, **self.ri_kwargs) self._verify_address_scopes_iptables_rule(ri.iptables_manager) interface_name, ex_gw_port = l3_test_common.prepare_ext_gw_test( self, ri) diff --git a/neutron/tests/unit/agent/l3/test_dvr_local_router.py b/neutron/tests/unit/agent/l3/test_dvr_local_router.py index 6b6c58e9857..bf484996893 100644 --- a/neutron/tests/unit/agent/l3/test_dvr_local_router.py +++ b/neutron/tests/unit/agent/l3/test_dvr_local_router.py @@ -152,13 +152,17 @@ class TestDvrRouterOperations(base.BaseTestCase): self.router_id = _uuid() if not router: router = mock.MagicMock() - return dvr_router.DvrLocalRouter(agent, - HOSTNAME, - self.router_id, - router, - self.conf, - mock.Mock(), - **kwargs) + kwargs['agent'] = agent + kwargs['router_id'] = self.router_id + kwargs['router'] = router + kwargs['agent_conf'] = self.conf + kwargs['interface_driver'] = mock.Mock() + return dvr_router.DvrLocalRouter(HOSTNAME, **kwargs) + + def _set_ri_kwargs(self, agent, router_id, router): + self.ri_kwargs['agent'] = agent + self.ri_kwargs['router_id'] = router_id + self.ri_kwargs['router'] = router def test_create_dvr_fip_interfaces_update(self): ri = self._create_router() @@ -374,8 +378,8 @@ class TestDvrRouterOperations(base.BaseTestCase): agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) router = l3_test_common.prepare_router_data(num_internal_ports=2) router['distributed'] = True - ri = dvr_router.DvrLocalRouter( - agent, HOSTNAME, router['id'], router, **self.ri_kwargs) + self._set_ri_kwargs(agent, router['id'], router) + ri = dvr_router.DvrLocalRouter(HOSTNAME, **self.ri_kwargs) ports = ri.router.get(lib_constants.INTERFACE_KEY, []) subnet_id = l3_test_common.get_subnet_id(ports[0]) test_ports = [{'mac_address': '00:11:22:33:44:55', @@ -431,12 +435,10 @@ class TestDvrRouterOperations(base.BaseTestCase): agent.add_arp_entry(None, payload) def test__update_arp_entry_with_no_subnet(self): - ri = dvr_router.DvrLocalRouter( - mock.sentinel.agent, - HOSTNAME, - 'foo_router_id', - {'distributed': True, 'gw_port_host': HOSTNAME}, - **self.ri_kwargs) + self._set_ri_kwargs(mock.sentinel.agent, + 'foo_router_id', + {'distributed': True, 'gw_port_host': HOSTNAME}) + ri = dvr_router.DvrLocalRouter(HOSTNAME, **self.ri_kwargs) with mock.patch.object(l3_agent.ip_lib, 'IPDevice') as f: ri._update_arp_entry(mock.ANY, mock.ANY, 'foo_subnet_id', 'add') self.assertFalse(f.call_count) @@ -445,8 +447,8 @@ class TestDvrRouterOperations(base.BaseTestCase): agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) router = l3_test_common.prepare_router_data(num_internal_ports=2) router['distributed'] = True - ri = dvr_router.DvrLocalRouter( - agent, HOSTNAME, router['id'], router, **self.ri_kwargs) + self._set_ri_kwargs(agent, router['id'], router) + ri = dvr_router.DvrLocalRouter(HOSTNAME, **self.ri_kwargs) subnet_id = l3_test_common.get_subnet_id( ri.router[lib_constants.INTERFACE_KEY][0]) return ri, subnet_id @@ -524,8 +526,8 @@ class TestDvrRouterOperations(base.BaseTestCase): router[n_const.FLOATINGIP_AGENT_INTF_KEY] = agent_gateway_port router['distributed'] = True agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) - ri = dvr_router.DvrLocalRouter( - agent, HOSTNAME, router['id'], router, **self.ri_kwargs) + self._set_ri_kwargs(agent, router['id'], router) + ri = dvr_router.DvrLocalRouter(HOSTNAME, **self.ri_kwargs) self.assertEqual( agent_gateway_port[0], ri.get_floating_agent_gw_interface(fake_network_id)) @@ -549,11 +551,8 @@ class TestDvrRouterOperations(base.BaseTestCase): router[lib_constants.FLOATINGIP_KEY] = fake_floatingips['floatingips'] router['distributed'] = True agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) - ri = dvr_router.DvrLocalRouter(agent, - HOSTNAME, - router['id'], - router, - **self.ri_kwargs) + self._set_ri_kwargs(agent, router['id'], router) + ri = dvr_router.DvrLocalRouter(HOSTNAME, **self.ri_kwargs) ri.iptables_manager.ipv4['nat'] = mock.MagicMock() ri.dist_fip_count = 0 fip_ns = agent.get_fip_ns(mock.sentinel.ext_net_id) @@ -573,11 +572,8 @@ class TestDvrRouterOperations(base.BaseTestCase): agent_mode, expected_call_count): router = l3_test_common.prepare_router_data(num_internal_ports=2) agent = l3_agent.L3NATAgent(HOSTNAME, self.conf) - ri = dvr_router.DvrLocalRouter(agent, - HOSTNAME, - router['id'], - router, - **self.ri_kwargs) + self._set_ri_kwargs(agent, router['id'], router) + ri = dvr_router.DvrLocalRouter(HOSTNAME, **self.ri_kwargs) interface_name, ex_gw_port = l3_test_common.prepare_ext_gw_test(self, ri) @@ -609,8 +605,8 @@ class TestDvrRouterOperations(base.BaseTestCase): self.mock_driver.unplug.reset_mock() external_net_id = router['gw_port']['network_id'] - ri = dvr_router.DvrLocalRouter( - agent, HOSTNAME, router['id'], router, **self.ri_kwargs) + self._set_ri_kwargs(agent, router['id'], router) + ri = dvr_router.DvrLocalRouter(HOSTNAME, **self.ri_kwargs) ri.remove_floating_ip = mock.Mock() agent._fetch_external_net_id = mock.Mock(return_value=external_net_id) ri.ex_gw_port = ri.router['gw_port'] diff --git a/neutron/tests/unit/agent/l3/test_ha_router.py b/neutron/tests/unit/agent/l3/test_ha_router.py index 37e13efe365..3f056975097 100644 --- a/neutron/tests/unit/agent/l3/test_ha_router.py +++ b/neutron/tests/unit/agent/l3/test_ha_router.py @@ -34,6 +34,7 @@ class TestBasicRouterOperations(base.BaseTestCase): self.agent_conf = mock.Mock() self.router_id = _uuid() return ha_router.HaRouter(mock.sentinel.enqueue_state, + mock.sentinel.agent, self.router_id, router, self.agent_conf, diff --git a/neutron/tests/unit/agent/l3/test_l3_agent_extension_api.py b/neutron/tests/unit/agent/l3/test_l3_agent_extension_api.py index a175a16b2df..f4618afbe62 100644 --- a/neutron/tests/unit/agent/l3/test_l3_agent_extension_api.py +++ b/neutron/tests/unit/agent/l3/test_l3_agent_extension_api.py @@ -34,7 +34,7 @@ class TestL3AgentExtensionApi(base.BaseTestCase): 'agent_conf': mock.ANY, 'interface_driver': mock.ANY, 'use_ipv6': mock.ANY} - ri = router_info.RouterInfo(self.router_id, **ri_kwargs) + ri = router_info.RouterInfo(mock.Mock(), self.router_id, **ri_kwargs) ri.internal_ports = ports return {ri.router_id: ri}, ri diff --git a/neutron/tests/unit/agent/l3/test_legacy_router.py b/neutron/tests/unit/agent/l3/test_legacy_router.py index 77f41df4cbd..c8da05ceadd 100644 --- a/neutron/tests/unit/agent/l3/test_legacy_router.py +++ b/neutron/tests/unit/agent/l3/test_legacy_router.py @@ -30,7 +30,8 @@ class BasicRouterTestCaseFramework(base.BaseTestCase): self.agent_conf = mock.Mock() self.driver = mock.Mock() self.router_id = _uuid() - return legacy_router.LegacyRouter(self.router_id, + return legacy_router.LegacyRouter(mock.Mock(), + self.router_id, router, self.agent_conf, self.driver, diff --git a/neutron/tests/unit/agent/l3/test_router_info.py b/neutron/tests/unit/agent/l3/test_router_info.py index ee05f2d7cda..b05ec4c4425 100644 --- a/neutron/tests/unit/agent/l3/test_router_info.py +++ b/neutron/tests/unit/agent/l3/test_router_info.py @@ -43,7 +43,7 @@ class TestRouterInfo(base.BaseTestCase): any_order=True) def test_routing_table_update(self): - ri = router_info.RouterInfo(_uuid(), {}, **self.ri_kwargs) + ri = router_info.RouterInfo(mock.Mock(), _uuid(), {}, **self.ri_kwargs) ri.router = {} fake_route1 = {'destination': '135.207.0.0/16', @@ -78,7 +78,8 @@ class TestRouterInfo(base.BaseTestCase): fake_route1 = {'destination': '135.207.0.0/16', 'nexthop': '1.2.3.4'} - ri = router_info.RouterInfo(uuid, {'id': uuid}, **self.ri_kwargs) + ri = router_info.RouterInfo(mock.Mock(), uuid, + {'id': uuid}, **self.ri_kwargs) ri._update_routing_table = mock.Mock() ri.update_routing_table('replace', fake_route1) @@ -87,7 +88,7 @@ class TestRouterInfo(base.BaseTestCase): netns) def test_routes_updated(self): - ri = router_info.RouterInfo(_uuid(), {}, **self.ri_kwargs) + ri = router_info.RouterInfo(mock.Mock(), _uuid(), {}, **self.ri_kwargs) ri.router = {} fake_old_routes = [] @@ -123,7 +124,7 @@ class TestRouterInfo(base.BaseTestCase): self._check_agent_method_called(expected) def test_add_ports_address_scope_iptables(self): - ri = router_info.RouterInfo(_uuid(), {}, **self.ri_kwargs) + ri = router_info.RouterInfo(mock.Mock(), _uuid(), {}, **self.ri_kwargs) port = { 'id': _uuid(), 'fixed_ips': [{'ip_address': '172.9.9.9'}], @@ -146,7 +147,7 @@ class TestRouterInfo(base.BaseTestCase): 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(_uuid(), {}, **self.ri_kwargs) + 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) @@ -161,27 +162,28 @@ class TestRouterInfo(base.BaseTestCase): # 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(_uuid(), {}, **self.ri_kwargs) + 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.assertTrue(ri.available_mark_ids != new_ri.available_mark_ids) def test_process_delete(self): - ri = router_info.RouterInfo(_uuid(), {}, **self.ri_kwargs) + 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(mock.Mock()) + 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(mock.Mock()) - p_i_p.assert_called_once_with(mock.ANY) - p_e_o_d.assert_called_once_with(mock.ANY) + ri.process_delete() + p_i_p.assert_called_once_with() + p_e_o_d.assert_called_once_with() class BasicRouterTestCaseFramework(base.BaseTestCase): @@ -190,7 +192,8 @@ class BasicRouterTestCaseFramework(base.BaseTestCase): router = mock.MagicMock() self.agent_conf = mock.Mock() self.router_id = _uuid() - return router_info.RouterInfo(self.router_id, + return router_info.RouterInfo(mock.Mock(), + self.router_id, router, self.agent_conf, mock.sentinel.interface_driver, diff --git a/neutron/tests/unit/agent/metadata/test_driver.py b/neutron/tests/unit/agent/metadata/test_driver.py index be928d610b2..35b951e4b5c 100644 --- a/neutron/tests/unit/agent/metadata/test_driver.py +++ b/neutron/tests/unit/agent/metadata/test_driver.py @@ -86,7 +86,7 @@ class TestMetadataDriverProcess(base.BaseTestCase): agent = l3_agent.L3NATAgent('localhost') router_id = _uuid() router = {'id': router_id} - ri = router_info.RouterInfo(router_id, router, + ri = router_info.RouterInfo(mock.Mock(), router_id, router, agent.conf, mock.ANY) agent.router_info[router_id] = ri agent._process_updated_router(router)