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__()这个魔法函数