class RouterPluginBase(object):    @abc.abstractmethod    def create_router(self, context, router):        pass    @abc.abstractmethod    def update_router(self, context, id, router):        pass    @abc.abstractmethod    def get_router(self, context, id, fields=None):        pass    @abc.abstractmethod    def delete_router(self, context, id):        pass    @abc.abstractmethod    def get_routers(self, context, filters=None, fields=None,                    sorts=None, limit=None, marker=None, page_reverse=False):        pass    @abc.abstractmethod    def add_router_interface(self, context, router_id, interface_info):        pass    @abc.abstractmethod    def remove_router_interface(self, context, router_id, interface_info):        pass    @abc.abstractmethod    def create_floatingip(self, context, floatingip):        pass    @abc.abstractmethod    def update_floatingip(self, context, id, floatingip):        pass    @abc.abstractmethod    def get_floatingip(self, context, id, fields=None):        pass    @abc.abstractmethod    def delete_floatingip(self, context, id):        pass    @abc.abstractmethod    def get_floatingips(self, context, filters=None, fields=None,                        sorts=None, limit=None, marker=None,                        page_reverse=False):        pass    def get_routers_count(self, context, filters=None):        raise NotImplementedError()    def get_floatingips_count(self, context, filters=None):        raise NotImplementedError()

@property    def l3_rpc_notifier(self):        if not hasattr(self, ‘_l3_rpc_notifier‘):            self._l3_rpc_notifier = l3_rpc_agent_api.L3AgentNotifyAPI()        return self._l3_rpc_notifier

class L3AgentNotifyAPI(n_rpc.RpcProxy):    """API for plugin to notify L3 agent."""    BASE_RPC_API_VERSION = ‘1.0‘    def __init__(self, topic=topics.L3_AGENT):        super(L3AgentNotifyAPI, self).__init__(            topic=topic, default_version=self.BASE_RPC_API_VERSION)    def _notification_host(self, context, method, payload, host):        """Notify the agent that is hosting the router."""        ...    def _agent_notification(self, context, method, router_ids,                            operation, data):        """Notify changed routers to hosting l3 agents."""
        ...
def _notification(self, context, method, router_ids, operation, data):        """Notify all the agents that are hosting the routers."""        ...def _notification_fanout(self, context, method, router_id):        """Fanout the deleted router to all L3 agents."""        ...def agent_updated(self, context, admin_state_up, host):        self._notification_host(context, ‘agent_updated‘,                                {‘admin_state_up‘: admin_state_up},                                host)    def router_deleted(self, context, router_id):        self._notification_fanout(context, ‘router_deleted‘, router_id)    def routers_updated(self, context, router_ids, operation=None, data=http://www.mamicode.com/None):        if router_ids:            self._notification(context, ‘routers_updated‘, router_ids,                               operation, data)    def router_removed_from_agent(self, context, router_id, host):        self._notification_host(context, ‘router_removed_from_agent‘,                                {‘router_id‘: router_id}, host)    def router_added_to_agent(self, context, router_ids, host):        self._notification_host(context, ‘router_added_to_agent‘,                                router_ids, host)

   def __init__(self, host, conf=None):        if conf:            self.conf = conf        else:            self.conf = cfg.CONF        self.root_helper = config.get_root_helper(self.conf)        self.router_info = {}        self._check_config_params()        try:
　　　　　　  # import driver from l3_agent.init 
            # Example: interface_driver = neutron.agent.linux.interface.OVSInterfaceDriver            self.driver = importutils.import_object(                self.conf.interface_driver,                self.conf            )        except Exception:            msg = _("Error importing interface driver "                    "‘%s‘") % self.conf.interface_driver            LOG.error(msg)            raise SystemExit(1)        self.context = context.get_admin_context_without_session()
       ＃ Agent side of the l3 agent RPC API, topic is ‘q-l3-plugin‘        self.plugin_rpc = L3PluginApi(topics.L3PLUGIN, host)        self.fullsync = True        self.updated_routers = set()        self.removed_routers = set()        self.sync_progress = False        self._clean_stale_namespaces = self.conf.use_namespaces        # Start RPC Loop         self.rpc_loop = loopingcall.FixedIntervalLoopingCall(            self._rpc_loop)        self.rpc_loop.start(interval=RPC_LOOP_INTERVAL)        super(L3NATAgent, self).__init__(conf=self.conf)        self.target_ex_net_id = None

neutron.service_plugins =    dummy = neutron.tests.unit.dummy_plugin:DummyServicePlugin    router = neutron.services.l3_router.l3_router_plugin:L3RouterPlugin    firewall = neutron.services.firewall.fwaas_plugin:FirewallPlugin    lbaas = neutron.services.loadbalancer.plugin:LoadBalancerPlugin    vpnaas = neutron.services.vpn.plugin:VPNDriverPlugin    metering = neutron.services.metering.metering_plugin:MeteringPlugin

  @lockutils.synchronized(‘l3-agent‘, ‘neutron-‘)    def _rpc_loop(self):        # _rpc_loop and _sync_routers_task will not be        # executed in the same time because of lock.        # so we can clear the value of updated_routers        # and removed_routers, but they can be updated by        # updated_routers and removed_routers rpc call        try:            LOG.debug(_("Starting RPC loop for %d updated routers"),                      len(self.updated_routers))            if self.updated_routers:  # 保存了需要本次处理的router信息                # We‘re capturing and clearing the list, and will                # process the "captured" updates in this loop,                # and any updates that happen due to a context switch                # will be picked up on the next pass.                updated_routers = set(self.updated_routers)                self.updated_routers.clear()                router_ids = list(updated_routers)                routers = self.plugin_rpc.get_routers(                    self.context, router_ids)                # routers with admin_state_up=false will not be in the fetched                fetched = set([r[‘id‘] for r in routers])
                ＃不在fetched中而在updated_routers中，说明需删除                self.removed_routers.update(updated_routers - fetched)                   self._process_routers(routers)            self._process_router_delete()            LOG.debug(_("RPC loop successfully completed"))        except Exception:            LOG.exception(_("Failed synchronizing routers"))            self.fullsync = True

    def process_router(self, ri):        ri.iptables_manager.defer_apply_on()        ex_gw_port = self._get_ex_gw_port(ri)        internal_ports = ri.router.get(l3_constants.INTERFACE_KEY, [])        existing_port_ids = set([p[‘id‘] for p in ri.internal_ports])        current_port_ids = set([p[‘id‘] for p in internal_ports                                if p[‘admin_state_up‘]])        new_ports = [p for p in internal_ports if                     p[‘id‘] in current_port_ids and                     p[‘id‘] not in existing_port_ids]        old_ports = [p for p in ri.internal_ports if                     p[‘id‘] not in current_port_ids]        for p in new_ports:            self._set_subnet_info(p)            self.internal_network_added(ri, p[‘network_id‘], p[‘id‘],                                        p[‘ip_cidr‘], p[‘mac_address‘])            ri.internal_ports.append(p)        for p in old_ports:            self.internal_network_removed(ri, p[‘id‘], p[‘ip_cidr‘])            ri.internal_ports.remove(p)        existing_devices = self._get_existing_devices(ri)        current_internal_devs = set([n for n in existing_devices                                     if n.startswith(INTERNAL_DEV_PREFIX)])        current_port_devs = set([self.get_internal_device_name(id) for                                 id in current_port_ids])        stale_devs = current_internal_devs - current_port_devs        for stale_dev in stale_devs:            LOG.debug(_(‘Deleting stale internal router device: %s‘),                      stale_dev)            self.driver.unplug(stale_dev,                               namespace=ri.ns_name,                               prefix=INTERNAL_DEV_PREFIX)        # Get IPv4 only internal CIDRs        internal_cidrs = [p[‘ip_cidr‘] for p in ri.internal_ports                          if netaddr.IPNetwork(p[‘ip_cidr‘]).version == 4]        # TODO(salv-orlando): RouterInfo would be a better place for        # this logic too        ex_gw_port_id = (ex_gw_port and ex_gw_port[‘id‘] or                         ri.ex_gw_port and ri.ex_gw_port[‘id‘])        interface_name = None        if ex_gw_port_id:            interface_name = self.get_external_device_name(ex_gw_port_id)        if ex_gw_port and ex_gw_port != ri.ex_gw_port:            self._set_subnet_info(ex_gw_port)            self.external_gateway_added(ri, ex_gw_port,                                        interface_name, internal_cidrs)        elif not ex_gw_port and ri.ex_gw_port:            self.external_gateway_removed(ri, ri.ex_gw_port,                                          interface_name, internal_cidrs)        stale_devs = [dev for dev in existing_devices                      if dev.startswith(EXTERNAL_DEV_PREFIX)                      and dev != interface_name]        for stale_dev in stale_devs:            LOG.debug(_(‘Deleting stale external router device: %s‘),                      stale_dev)            self.driver.unplug(stale_dev,                               bridge=self.conf.external_network_bridge,                               namespace=ri.ns_name,                               prefix=EXTERNAL_DEV_PREFIX)        # Process static routes for router        self.routes_updated(ri)        # Process SNAT rules for external gateway        ri.perform_snat_action(self._handle_router_snat_rules,                               internal_cidrs, interface_name)        # Process SNAT/DNAT rules for floating IPs        fip_statuses = {}        try:            if ex_gw_port:                existing_floating_ips = ri.floating_ips                self.process_router_floating_ip_nat_rules(ri)                ri.iptables_manager.defer_apply_off()                # Once NAT rules for floating IPs are safely in place                # configure their addresses on the external gateway port                fip_statuses = self.process_router_floating_ip_addresses(                    ri, ex_gw_port)        except Exception:            # TODO(salv-orlando): Less broad catching            # All floating IPs must be put in error state            for fip in ri.router.get(l3_constants.FLOATINGIP_KEY, []):                fip_statuses[fip[‘id‘]] = l3_constants.FLOATINGIP_STATUS_ERROR        if ex_gw_port:            # Identify floating IPs which were disabled            ri.floating_ips = set(fip_statuses.keys())            for fip_id in existing_floating_ips - ri.floating_ips:                fip_statuses[fip_id] = l3_constants.FLOATINGIP_STATUS_DOWN            # Update floating IP status on the neutron server            self.plugin_rpc.update_floatingip_statuses(                self.context, ri.router_id, fip_statuses)        # Update ex_gw_port and enable_snat on the router info cache        ri.ex_gw_port = ex_gw_port        ri.enable_snat = ri.router.get(‘enable_snat‘)