openstack Rocky系列之keystone：（二）keystone中API注册

主要说一下initialize_application中的application_factory

     def loadapp():
         app = application.application_factory(name)
         return app

源码如下

 @fail_gracefully
 def application_factory(name='public'):
     if name not in ('admin', 'public'):
         raise RuntimeError('Application name (for base_url lookup) must be '
                            'either `admin` or `public`.')

     # NOTE(morgan): The Flask App actually dispatches nothing until we migrate
     # some routers to Flask-Blueprints, it is simply a placeholder.
     app = flask.Flask(name)
     app.after_request(_add_vary_x_auth_token_header)

     # NOTE(morgan): Configure the Flask Environment for our needs.
     app.config.update(
         # We want to bubble up Flask Exceptions (for now)
         PROPAGATE_EXCEPTIONS=True)

     # TODO(morgan): Convert Subsystems over to Flask-Native, for now, we simply
     # dispatch to another "application" [e.g "keystone"]
     # NOTE(morgan): as each router is converted to flask-native blueprint,
     # remove from this list. WARNING ORDER MATTERS; ordered dict used to
     # ensure sane ordering of the routers in the legacy-dispatch model.
     dispatch_map = collections.OrderedDict()

     # Load in Healthcheck and map it to /healthcheck
     hc_app = healthcheck.Healthcheck.app_factory(
         {}, oslo_config_project='keystone')
     dispatch_map['/healthcheck'] = hc_app

     # More legacy code to instantiate all the magic for the dispatchers.
     # The move to blueprints (FLASK) will allow this to be eliminated.
     _routers = []
     sub_routers = []
     mapper = routes.Mapper()
     for api_routers in ALL_API_ROUTERS:
         moved_found = [pfx for
                        pfx in getattr(api_routers, '_path_prefixes', [])
                        if pfx in _MOVED_API_PREFIXES]
         if moved_found:
             raise RuntimeError('An API Router is trying to register path '
                                'prefix(s) `%(pfx)s` that is handled by the '
                                'native Flask app. Keystone cannot '
                                'start.' %
                                {'pfx': ', '.join([p for p in moved_found])})

         routers_instance = api_routers.Routers()
         _routers.append(routers_instance)
         routers_instance.append_v3_routers(mapper, sub_routers)
     # TODO(morgan): Remove "API version registration". For now this is kept
     # for ease of conversion (minimal changes)
     keystone.api.discovery.register_version('v3')

     # NOTE(morgan): We add in all the keystone.api blueprints here, this
     # replaces (as they are implemented) the legacy dispatcher work.
     for api in keystone.api.__apis__:
         for api_bp in api.APIs:
             api_bp.instantiate_and_register_to_app(app)

     # Build and construct the dispatching for the Legacy dispatching model
     sub_routers.append(_ComposibleRouterStub(_routers))
     legacy_dispatcher = keystone_wsgi.ComposingRouter(mapper, sub_routers)

     for pfx in itertools.chain(*[rtr.Routers._path_prefixes for
                                  rtr in ALL_API_ROUTERS]):
         import pdb;pdb.set_trace()
         dispatch_map['/v3/%s' % pfx] = legacy_dispatcher
     app.wsgi_app = KeystoneDispatcherMiddleware(
         app.wsgi_app,
         dispatch_map)
     return app

fail_gracefully是个装饰器，主要是为了防止函数报错，抓一下exception，并记录报错信息，其中又使用了一个functools.wraps的装饰器,防止fail_gracefully对被装饰的函数造成影响

主要看27行dispatch_map = collections.OrderedDict()，这里创建了一个dispatch_map的变量，这个变量用于记录所有的路由分发

33行创建了一个router.Mapper()的对象mapper

     for api_routers in ALL_API_ROUTERS:
         moved_found = [pfx for
                        pfx in getattr(api_routers, '_path_prefixes', [])
                        if pfx in _MOVED_API_PREFIXES]
         if moved_found:
             raise RuntimeError('An API Router is trying to register path '
                                'prefix(s) `%(pfx)s` that is handled by the '
                                'native Flask app. Keystone cannot '
                                'start.' %
                                {'pfx': ', '.join([p for p in moved_found])})

         routers_instance = api_routers.Routers()
         _routers.append(routers_instance)
         routers_instance.append_v3_routers(mapper, sub_routers)

ALL_API_ROUTER是一个包含所有处理路由的类的列表，这个循环中主要是过滤掉所有的被移除的API，api_routes.Routers()继承wsgi.RoutersBase，并通过append_v3_routers将自己的路由信息记录到mapper中，其中sub_routers是记录顶层路由下的路由

sub_routers.append(_ComposibleRouterStub(_routers))这行代码将_router整合到sub_routers中

legacy_dispatcher = keystone_wsgi.ComposingRouter(mapper, sub_routers)这行代码最终调用的源代码如下

 class Router(wsgi.ComposableRouter):
     def __init__(self, controller, collection_key, key,
                  resource_descriptions=None,
                  is_entity_implemented=True,
                  method_template=None):
         self.controller = controller
         self.key = key
         self.collection_key = collection_key
         self._resource_descriptions = resource_descriptions
         self._is_entity_implemented = is_entity_implemented
         self.method_template = method_template or '%s'

     def add_routes(self, mapper):
         collection_path = '/%(collection_key)s' % {
             'collection_key': self.collection_key}
         entity_path = '/%(collection_key)s/{%(key)s_id}' % {
             'collection_key': self.collection_key,
             'key': self.key}

         mapper.connect(
             collection_path,
             controller=self.controller,
             action=self.method_template % 'create_%s' % self.key,
             conditions=dict(method=['POST']))
         mapper.connect(
             collection_path,
             controller=self.controller,
             action=self.method_template % 'list_%s' % self.collection_key,
             conditions=dict(method=['GET', 'HEAD']))
         mapper.connect(
             entity_path,
             controller=self.controller,
             action=self.method_template % 'get_%s' % self.key,
             conditions=dict(method=['GET', 'HEAD']))
         mapper.connect(
             entity_path,
             controller=self.controller,
             action=self.method_template % 'update_%s' % self.key,
             conditions=dict(method=['PATCH']))
         mapper.connect(
             entity_path,
             controller=self.controller,
             action=self.method_template % 'delete_%s' % self.key,
             conditions=dict(method=['DELETE']))

         # Add the collection resource and entity resource to the resource
         # descriptions.

         collection_rel = json_home.build_v3_resource_relation(
             self.collection_key)
         rel_data = {'href': collection_path, }
         self._resource_descriptions.append((collection_rel, rel_data))
         json_home.JsonHomeResources.append_resource(collection_rel, rel_data)

         if self._is_entity_implemented:
             entity_rel = json_home.build_v3_resource_relation(self.key)
             id_str = '%s_id' % self.key
             id_param_rel = json_home.build_v3_parameter_relation(id_str)
             entity_rel_data = {
                 'href-template': entity_path,
                 'href-vars': {
                     id_str: id_param_rel,
                 },
             }
             self._resource_descriptions.append((entity_rel, entity_rel_data))
             json_home.JsonHomeResources.append_resource(
                 entity_rel, entity_rel_data)

通过add_router为route添加mapper

     for pfx in itertools.chain(*[rtr.Routers._path_prefixes for
                                  rtr in ALL_API_ROUTERS]):
         dispatch_map['/v3/%s' % pfx] = legacy_dispatcher

这里主要添加dispatch_map中的前缀和处理代码的映射关系，涉及到itertools.chain()用法的小技巧

最后一行的KeystoneDispatcherMiddleware类负责API的分发，同样是通过__call__()这个魔法函数