关于neutron router-update在server端执行流程

输入neutron router-update 参数执行后，neutron-server收到neutronclient发来的http请求后，根据路由映射选择相应的controller下的函数。

1.neutron/api/v2/base.py(493)update()：所有的关于update操作都将在这处理

  def update(self, request, id, body=None, **kwargs):        
        """Updates the specified entity's attributes."""
           parent_id = kwargs.get(self._parent_id_name)
           try:
                payload = body.copy()#body是请求部分，在这里body里包含了传过来的路由信息
           except AttributeError:
                msg = _("Invalid format: %s") % request.body
                raise exceptions.BadRequest(resource='body', msg=msg)
           payload['id'] = id#id是路由器的id
           self._notifier.info(request.context,
           self._resource + '.update.start', payload)
           body = Controller.prepare_request_body(request.context, body, False,
                                                self._resource, self._attr_info,
                                                allow_bulk=self._allow_bulk)#路由信息
           action = self._plugin_handlers[self.UPDATE]
           # Load object to check authz
           # but pass only attributes in the original body and required
           # by the policy engine to the policy 'brain'
           field_list = [name for (name, value) in self._attr_info.iteritems()
                       if (value.get('required_by_policy') or
                           value.get('primary_key') or
                           'default' not in value)] #field_list是orig_obj

     policy.init()
            orig_obj = self._item(request, id, field_list=field_list,
                                  parent_id=parent_id)
            orig_object_copy = copy.copy(orig_obj)
            orig_obj.update(body[self._resource])
           # Ensure policy engine is initialized
           policy.init()orig_obj[const.ATTRIBUTES_TO_UPDATE] = body[self._resource].keys()
   try:
            policy.enforce(request.context,
                            action,
                            orig_obj)
           except exceptions.PolicyNotAuthorized:

                with excutils.save_and_reraise_exception() as ctxt:
                    # If a tenant is modifying it's own object, it's safe to return
                    # a 403. Otherwise, pretend that it doesn't exist to avoid
                    # giving away information.
                    if request.context.tenant_id != orig_obj['tenant_id']:
                           ctxt.reraise = False
                 msg = _('The resource could not be found.')
                 raise webob.exc.HTTPNotFound(msg)

          obj_updater = getattr(self._plugin, action)#bound method L3RouterPlugin.update_router of <neutron.services.l3_router.l3_router_plugin.L3RouterPlugin，实际执行 #update操作的都是class L3RouterPlugin及其父类相应函数
          kwargs = {self._resource: body}

          if parent_id:
              kwargs[self._parent_id_name] = parent_id
          obj = obj_updater(request.context, id, **kwargs)#开始更新，跳转到neutron/db/extraroute_db.py(66)update_router()
          result = {self._resource: self._view(request.context, obj)}
          notifier_method = self._resource + '.update.end'
          self._notifier.info(request.context, notifier_method, result)
          self._send_dhcp_notification(request.context,
                                      result,
                                     notifier_method)
          self._send_nova_notification(action, orig_object_copy, result)
          return result 

2.neutron/db/extraroute_db.py(66)update_router()：处理uodate-router的入口

 def update_router(self, context, id, router):

r = router['router'] #r类型为字典，存储路由表信息

with context.session.begin(subtransactions=True):

 #check if route exists and have permission to access

#检查路由器是否存在并且是否有操作的权限

router_db = self._get_router(context, id)#/跳转到neutron/neutron/db/l3_db.py(120)_get_router()

if 'routes' in r:

self._update_extra_routes(context, router_db, r['routes'])

routes = self._get_extra_routes_by_router_id(context, id)

router_updated = super(ExtraRoute_dbonly_mixin, self).update_router(context, id, router)

router_updated['routes'] = routes

return router_updated

118     def _update_extra_routes(self, context, router, routes):
119         self._validate_routes(context, router['id'],
120                               routes)   
121         old_routes, routes_dict = self._get_extra_routes_dict_by_router_id(
122             context, router['id'])      
123                                         
124         '''                             
125             old_routes:existed routes,is a list,like:
126             [{'nexthop': u'10.0.0.3', 'destination': u'10.0.0.0/24'}, {'nexthop': u'192.168.100.3', 'destination': u'192.168.100.0/24'}]
127             routes:new routes to update,is a list,like:
128             [{u'destination': u'10.0.0.0/24', u'nexthop': u'10.0.0.2'}, {u'destination': u'192.168.100.0/24', u'nexthop': u'192.168.100.2'}]   
129         '''                             
130         added, removed = utils.diff_list_of_dict(old_routes,
131                                                  routes)
132                                         
133         '''                             
134             utils.diff_list_of_dict(old_routes, routes)
135             old_routes and routes change to set type,find new routes to add:added,find routes to delete:removed
136             added,removed both are list,like:
137             [{u'nexthop': u'10.0.0.2', u'destination': u'10.0.0.0/24'}, {u'nexthop': u'192.168.100.2', u'destination': u'192.168.100.0/24'}]
138         '''                             
139                                         
140         LOG.debug(_('Added routes are %s'), added)
141         for route in added:             
142             router_routes = RouterRoute(
143                 router_id=router['id'], 
144                 destination=route['destination'],
145                 nexthop=route['nexthop'])
146             context.session.add(router_routes)
147                                         
148         LOG.debug(_('Removed routes are %s'), removed)
149         for route in removed:           
150             context.session.delete(     
151                 routes_dict[(route['destination'], route['nexthop'])])

3./neutron/neutron/db/l3_db.py(120)_get_router()：

 def    _get_router(self, context, router_id):
          try:
                 router = self._get_by_id(context, Router, router_id)#跳转到neutron/db/common_db_mixin.py(123)_get_by_id()，类型neutron.db.l3_db.Router
          except exc.NoResultFound:
                 raise l3.RouterNotFound(router_id=router_id)
          return router

4.neutron/db/common_db_mixin.py(123)_get_by_id()：

 def   _get_by_id(self, context, model, id):
        query = self._model_query(context, model)
        return query.filter(model.id == id).one()

def _model_query(self, context, model):                                                                                                        
query = context.session.query(model)
  # define basic filter condition for model query
  # NOTE(jkoelker) non-admin queries are scoped to their tenant_id
# NOTE(salvatore-orlando): unless the model allows for shared objects
  query_filter = None

if not context.is_admin and hasattr(model, 'tenant_id'):
               if hasattr(model, 'shared'):
                    query_filter = ((model.tenant_id == context.tenant_id) |
                                    (model.shared == sql.true()))
                else:
                    query_filter = (model.tenant_id == context.tenant_id)
            # Execute query hooks registered from mixins and plugins
            for _name, hooks in self._model_query_hooks.get(model,
                                                            {}).iteritems():
                query_hook = hooks.get('query')
                if isinstance(query_hook, basestring):
                    query_hook = getattr(self, query_hook, None)
                if query_hook:
                    query = query_hook(context, model, query)
         
                filter_hook = hooks.get('filter')
                if isinstance(filter_hook, basestring):
                    filter_hook = getattr(self, filter_hook, None)
                if filter_hook:
                    query_filter = filter_hook(context, model, query_filter)
         
            # NOTE(salvatore-orlando): 'if query_filter' will try to evaluate the
            # condition, raising an exception
            if query_filter is not None:
                query = query.filter(query_filter)
            return query