Python utils.diff_list_of_dict函数代码示例

 def update_router(self, context, router_id, old_router, new_router):
     old_routes = old_router['routes'][:]
     new_routes = new_router['routes'][:]
     self._process_gw_port(old_router['gw_port'], old_routes)
     self._process_gw_port(new_router['gw_port'], new_routes)
     added, removed = utils.diff_list_of_dict(old_routes, new_routes)
     if added or removed:
         try:
             # NOTE(amotoki): PFC supports one-by-one route update at now.
             # It means there may be a case where some route is updated but
             # some not. To allow the next call of failures to sync routes
             # with Neutron side, we pass the whole new routes here.
             # PFC should support atomic route update in the future.
             self.ofc.update_ofc_router_route(context, router_id,
                                              new_routes)
             new_status = nconst.ROUTER_STATUS_ACTIVE
             self.plugin._update_resource_status(
                 context, "router", router_id, new_status)
             new_router['status'] = new_status
         except (nexc.OFCException, nexc.OFCMappingNotFound) as exc:
             with excutils.save_and_reraise_exception():
                 LOG.error(_LE("_update_ofc_routes() failed due to %s"),
                           exc)
                 new_status = nconst.ROUTER_STATUS_ERROR
                 self.plugin._update_resource_status(
                     context, "router", router_id, new_status)
     return new_router

    def _routes_updated(self, ri):
        """Update the state of routes in the router.

        Compares the current routes with the (configured) existing routes
        and detect what was removed or added. Then configure the
        logical router in the hosting device accordingly.
        :param ri: RouterInfo corresponding to the router.
        :return: None
        :raises: networking_cisco.plugins.cisco.cfg_agent.cfg_exceptions.
        DriverException if the configuration operation fails.
        """
        new_routes = ri.router['routes']
        old_routes = ri.routes
        adds, removes = common_utils.diff_list_of_dict(old_routes,
                                                       new_routes)
        for route in adds:
            LOG.debug("Added route entry is '%s'", route)
            # remove replaced route from deleted route
            for del_route in removes:
                if route['destination'] == del_route['destination']:
                    removes.remove(del_route)
            driver = self.driver_manager.get_driver(ri.id)
            driver.routes_updated(ri, 'replace', route)

        for route in removes:
            LOG.debug("Removed route entry is '%s'", route)
            driver = self.driver_manager.get_driver(ri.id)
            driver.routes_updated(ri, 'delete', route)
        ri.routes = new_routes

    def process_router_portforwardings(self, ri, ex_gw_port):
        if 'portforwardings' not in ri.router:
            # note(jianingy): return when portforwarding extension
            # is not enabled
            LOG.debug("Portforwarding Extension Not Enabled")
            return None
        if ex_gw_port:
            new_portfwds = ri.router['portforwardings']
            for new_portfwd in new_portfwds:
                new_portfwd['outside_addr'] = (
                    ex_gw_port.get('fixed_ips')[0].get('ip_address'))
                LOG.debug("New Portforwarding: %s" % new_portfwd.values())
            old_portfwds = ri.portforwardings
            for old_portfwd in old_portfwds:
                LOG.debug("Old Portforwarding: %s" % old_portfwd.values())
            adds, removes = common_utils.diff_list_of_dict(old_portfwds,
                            new_portfwds)
            for portfwd in adds:
                LOG.debug("Add Portforwarding: %s" % portfwd.values())
                self._update_portforwardings(ri, 'create', portfwd)
            for portfwd in removes:
                LOG.debug("Del Portforwarding: %s" % portfwd.values())
                self._update_portforwardings(ri, 'delete', portfwd)
            ri.portforwardings = new_portfwds
        else:
            old_portfwds = ri.portforwardings
            for old_portfwd in old_portfwds:
                    LOG.debug("Del Portforwarding: %s" % old_portfwd.values())
                    self._update_portforwardings(ri, 'delete', old_portfwd)
            ri.portforwardings = []

        ri.iptables_manager.apply()

 def test_diff_list_of_dict(self):
     old_list = [{"key1": "value1"},
                 {"key2": "value2"},
                 {"key3": "value3"}]
     new_list = [{"key1": "value1"},
                 {"key2": "value2"},
                 {"key4": "value4"}]
     added, removed = utils.diff_list_of_dict(old_list, new_list)
     self.assertEqual(added, [dict(key4="value4")])
     self.assertEqual(removed, [dict(key3="value3")])

 def routes_updated(self, old_routes, new_routes):
     adds, removes = common_utils.diff_list_of_dict(old_routes, new_routes)
     for route in adds:
         LOG.debug("Added route entry is '%s'", route)
         # remove replaced route from deleted route
         for del_route in removes:
             if route["destination"] == del_route["destination"]:
                 removes.remove(del_route)
         # replace success even if there is no existing route
         self.update_routing_table("replace", route)
     for route in removes:
         LOG.debug("Removed route entry is '%s'", route)
         self.update_routing_table("delete", route)

    def update_router(self, context, id, router):
        original_router = self.get_router(context, id)
        result = super(OVNL3RouterPlugin, self).update_router(
            context, id, router)

        update = {}
        added = []
        removed = []
        router_name = utils.ovn_name(id)
        if 'admin_state_up' in router['router']:
            enabled = router['router']['admin_state_up']
            if enabled != original_router['admin_state_up']:
                update['enabled'] = enabled

        if 'name' in router['router']:
            if router['router']['name'] != original_router['name']:
                external_ids = {ovn_const.OVN_ROUTER_NAME_EXT_ID_KEY:
                                router['router']['name']}
                update['external_ids'] = external_ids

        """ Update static routes """
        if 'routes' in router['router']:
            routes = router['router']['routes']
            added, removed = n_utils.diff_list_of_dict(
                original_router['routes'], routes)

        if update or added or removed:
            try:
                with self._ovn.transaction(check_error=True) as txn:
                    if update:
                        txn.add(self._ovn.update_lrouter(router_name,
                                **update))

                    for route in added:
                        txn.add(self._ovn.add_static_route(router_name,
                                ip_prefix=route['destination'],
                                nexthop=route['nexthop']))

                    for route in removed:
                        txn.add(self._ovn.delete_static_route(router_name,
                                ip_prefix=route['destination'],
                                nexthop=route['nexthop']))
            except Exception:
                LOG.exception(_LE('Unable to update lrouter for %s'), id)
                super(OVNL3RouterPlugin, self).update_router(context,
                                                             id,
                                                             original_router)
                raise n_exc.ServiceUnavailable()

        return result

    def _update_extra_routes(self, context, router, routes):
        self._validate_routes(context, router["id"], routes)
        old_routes, routes_dict = self._get_extra_routes_dict_by_router_id(context, router["id"])
        added, removed = utils.diff_list_of_dict(old_routes, routes)
        LOG.debug("Added routes are %s", added)
        for route in added:
            router_routes = RouterRoute(
                router_id=router["id"], destination=route["destination"], nexthop=route["nexthop"]
            )
            context.session.add(router_routes)

        LOG.debug("Removed routes are %s", removed)
        for route in removed:
            context.session.delete(routes_dict[(route["destination"], route["nexthop"])])

 def process_router_portforwardings(self, ri, ex_gw_port):
     if 'portforwardings' not in ri.router:
         # return when portforwarding extension is not enabled
         return
     new_portfwds = ri.router['portforwardings']
     for new_portfwd in new_portfwds:
         new_portfwd['outside_addr'] = (
             ex_gw_port.get('fixed_ips')[0].get('ip_address'))
     old_portfwds = ri.portforwardings
     adds, removes = common_utils.diff_list_of_dict(old_portfwds,
                                                    new_portfwds)
     for portfwd in adds:
         self._update_portforwardings(ri, 'create', portfwd)
     for portfwd in removes:
         self._update_portforwardings(ri, 'delete', portfwd)
     ri.portforwardings = new_portfwds

 def routes_updated(self, ri):
     new_routes = ri.router['routes']
     old_routes = ri.routes
     adds, removes = common_utils.diff_list_of_dict(old_routes,
                                                    new_routes)
     for route in adds:
         LOG.debug(_("Added route entry is '%s'"), route)
         # remove replaced route from deleted route
         for del_route in removes:
             if route['destination'] == del_route['destination']:
                 removes.remove(del_route)
         #replace success even if there is no existing route
         self._update_routing_table(ri, 'replace', route)
     for route in removes:
         LOG.debug(_("Removed route entry is '%s'"), route)
         self._update_routing_table(ri, 'delete', route)
     ri.routes = new_routes

 def update_ofc_router_route(self, context, router_id, new_routes):
     ofc_router_id = self._get_ofc_id(context, "ofc_router", router_id)
     ofc_routes = self.driver.list_router_routes(ofc_router_id)
     route_dict = {}
     cur_routes = []
     for r in ofc_routes:
         key = ','.join((r['destination'], r['nexthop']))
         route_dict[key] = r['id']
         del r['id']
         cur_routes.append(r)
     added, removed = utils.diff_list_of_dict(cur_routes, new_routes)
     for r in removed:
         key = ','.join((r['destination'], r['nexthop']))
         route_id = route_dict[key]
         self.driver.delete_router_route(route_id)
     for r in added:
         self.driver.add_router_route(ofc_router_id, r['destination'],
                                      r['nexthop'])

 def update_router(self, context, id, router):
     r = router['router']
     with context.session.begin(subtransactions=True):
         if 'routes' in r:
             old_routes = self._get_extra_routes_by_router_id(context,
                                                              id)
             added, removed = utils.diff_list_of_dict(old_routes,
                                                      r['routes'])
             self._validate_nuage_staticroutes(old_routes, added, removed)
             ent_rtr_mapping = nuagedb.get_ent_rtr_mapping_by_rtrid(
                 context.session, id)
             if not ent_rtr_mapping:
                 msg = (_("Router %s does not hold net-partition "
                          "assoc on VSD. extra-route failed") % id)
                 raise n_exc.BadRequest(resource='router', msg=msg)
             # Let it do internal checks first and verify it.
             router_updated = super(NuagePlugin,
                                    self).update_router(context,
                                                        id,
                                                        router)
             for route in removed:
                 rtr_rt_mapping = nuagedb.get_router_route_mapping(
                     context.session, id, route)
                 if rtr_rt_mapping:
                     self.nuageclient.delete_nuage_staticroute(
                         rtr_rt_mapping['nuage_route_id'])
                     nuagedb.delete_static_route(context.session,
                                                 rtr_rt_mapping)
             for route in added:
                 params = {
                     'parent_id': ent_rtr_mapping['nuage_router_id'],
                     'net': netaddr.IPNetwork(route['destination']),
                     'nexthop': route['nexthop']
                 }
                 nuage_rt_id = self.nuageclient.create_nuage_staticroute(
                     params)
                 nuagedb.add_static_route(context.session,
                                          id, nuage_rt_id,
                                          route['destination'],
                                          route['nexthop'])
         else:
             router_updated = super(NuagePlugin, self).update_router(
                 context, id, router)
     return router_updated

    def _update_extra_routes(self, context, router, routes):
        self._validate_routes(context, router['id'],
                              routes)
        old_routes = self._get_extra_routes_by_router_id(
            context, router['id'])
        added, removed = utils.diff_list_of_dict(old_routes,
                                                 routes)
        LOG.debug(_('Added routes are %s'), added)
        for route in added:
            router_routes = RouterRoute(
                router_id=router['id'],
                destination=route['destination'],
                nexthop=route['nexthop'])
            context.session.add(router_routes)

        LOG.debug(_('Removed routes are %s'), removed)
        for route in removed:
            del_context = context.session.query(RouterRoute)
            del_context.filter_by(router_id=router['id'],
                                  destination=route['destination'],
                                  nexthop=route['nexthop']).delete()

    def routes_updated(self, ri):
        LOG.debug("Enter routes updated function")
        data = {}
        data['id'] = ri.router_id
        data['subnets'] = self._get_engine_subnets(ri.router.get(l3_constants.SNAT_ROUTER_INTF_KEY, []))
        ex_gw_port = self._get_ex_gw_port(ri)
        data['ext_net_info'] = {
            'vlan': ex_gw_port['vlan'],
            'ip': ex_gw_port['fixed_ips'][0]['ip_address']
        }
        new_routes = ri.router['routes']
        old_routes = ri.routes
        adds, removes = common_utils.diff_list_of_dict(old_routes,
                                                       new_routes)

        if removes:
            data['routes'] = self._get_engine_routes(removes, ex_gw_port)
            self.dataengine_rpc.router_route_delete(data)
        
        if adds:
            data['routes'] = self._get_engine_routes(adds, ex_gw_port)
            self.dataengine_rpc.router_route_add(data)

 def update_router(self, context, router_id, router):
     """Update the router with static route"""
     r = router['router']
     old_routes, routes_dict = self._get_extra_routes_dict_by_router_id(
         context, router_id)
     added, removed = neutron_utils.diff_list_of_dict(old_routes,
                                                      r['routes'])
     try:
         updated_router = super(BrocadeSVIPlugin, self).\
             update_router(context, router_id, router)
         if 'routes' in r:
             self._invoke_nos_driver_api('update_router',
                                         router_id,
                                         None,
                                         None,
                                         None,
                                         None,
                                         added,
                                         removed)
     except Exception as e:
         LOG.error(_LE("Failed to modify route %s"), str(e))
         raise e
     return updated_router

    def _update_extra_portfwds(self, context, router, portfwds):
        old_fwds = self._get_extra_portfwds_by_router_id(
            context, router['id'])
        added, removed = utils.diff_list_of_dict(old_fwds, portfwds)

        LOG.debug(_('Removed port forwarding rules are %s'), removed)
        for portfwd in removed:
            del_context = context.session.query(PortForwardingRule)
            del_context.filter_by(router_id=router['id'],
                                  outside_port=portfwd['outside_port'],
                                  inside_addr=portfwd['inside_addr'],
                                  inside_port=portfwd['inside_port'],
                                  protocol=portfwd['protocol']).delete()

        LOG.debug(_('Added port forwarding rules are %s'), added)
        for portfwd in added:
            router_fwds = PortForwardingRule(
                router_id=router['id'],
                outside_port=portfwd['outside_port'],
                inside_addr=portfwd['inside_addr'],
                inside_port=portfwd['inside_port'],
                protocol=portfwd['protocol'])

            context.session.add(router_fwds)