目录

Keystone WSGI 实现

Keystone 项目把每个功能都分到单独的目录下，EXAMPLE:

• token 相关的功能 ===> keystone/token/
• assignment 相关的功能 ===> keystone/assignment/
• auth 相关的功能 ===> keystone/auth/
• catalog 相关的功能 ===> keystone/catalog/
• credential 相关的功能 ===> keystone/credential/
• identity 相关的功能 ===> keystone/identity/
• policy 相关的功能 ===> keystone/policy/
• resource 相关的功能 ===> keystone/resource/

这些功能目录下都一般会有三个文件：routers.py/ controllers.py/ core.py

controllers.py

controllers.py 中的 action 操作函数调用了 core.py 中的底层接口实现来 RESTful API 对应的操作功能。

EXAMPLE：这个例子的代码非官方源码，用于理解。

# controller.py

class AccountController(wsgi.Controller):

    def __init__(self, ext_mgr):

        self.ext_mgr = ext_mgr

        self.account_api = account_api.API()

        super(AccountController, self).__init__()

    @wsgi.serializers()

    def index(self, req):                                     #Action:index ==> HTTP:Get(all)

        context = req.environ['duckbill.context']

        params = req.GET

        qs = {}

        qs['page_count'] = params.get('page_count', DEFAULT_PAGE_COUNT)

        qs['page_num'] = params.get('page_num', 0)

        qs['account_name'] = params.get('account_name', None)

        qs['pubcloud'] = params.get('pubcloud', None)

        qs['user'] = params.get('user', None)

        accounts = self.account_api.list_account(context, qs)    #account_api.list_account()是从core.py中实现的函数

        return {'accounts': accounts}

# core.py

class API(base.Base):

    """API for handling account resources."""

    def __init__(self):

        super(API, self).__init__()

    def list_account(self, context, filter=None):

        """Get account list.

        :param context: class:`RequestContext` instance

        :param filter: select data by filter

        :type: ``dict``

        :return: return a list of class:`AccountInfo` instance.

        """

        return self.db.account_get_all(context, filter)            #调用 db Module 的方法实现对数据库的操作， db Module 使用了 ORM

# db.py

def account_get_all(context, filter=None):

    """Get account list.

    :param context: class:`RequestContext` instance

    :param filter: select data by filter

    :type: ''dict''

    :return: return a list of class:`AccountInfo` instance.

    """

    return IMPL.account_get_all(context, filter=filter)            #IMPL 主要在 oslo.db 通用库中实现

routers.py

routers.py 中实现了 URL 路由，把 URL 和 controllers.py 中的 action 对应起来。

EXAMPLE:

URl == http://hostname:35357/v3/auth/tokens 对 Keystone 而言，/v3 开头的请求会交给 keystone.service.v3_app_factory 这个函数生成的 application 来处理。

routes 的一般用法是创建一个 mapper 对象，然后调用该 Mapper 对象的 connect() 方法把 URL_Path(这里是 /auth/tokens )和 HTTP 内建方法映射到一个 controller 的某个 action 上。如果是这样的话，那么我们就需要先实现 controller 和其 action 操作函数。然后使用 mapper.connect() 将上述的几个关键的参数映射到一起。使得一个请求，在 Client 看起来是 URL ，在程序内部看起来就是一个 Action 操作函数。

keystone.service.v3_app_factory 这个函数说明了路由转发的原理，我们来看代码：

def v3_app_factory(global_conf, **local_conf):    #v3_app_factory()函数中先遍历了所有的模块，将每个模块的路由都添加到同一个mapper对象中

    ...

    mapper = routes.Mapper()             # 创建一个 mapper 对象

    ...

    router_modules = [auth,              # Keystone 功能模块列表

                      assignment,

                      catalog,

                      credential,

                      identity,

                      policy,

                      resource]

    ...

    for module in router_modules:

        routers_instance = module.routers.Routers()

        _routers.append(routers_instance)

        routers_instance.append_v3_routers(mapper, sub_routers)

        #将每个 keystone 功能模块的路由都添加到同一个 mapper 对象中，这样的话每个模块的 routes 都拥有了 mapper 的能力。

    # Add in the v3 version api

    sub_routers.append(routers.VersionV3('public', _routers))

    return wsgi.ComposingRouter(mapper, sub_routers)

    #然后把 mapper 对象作为参数用于初始化 wsgi.ComposingRouter 对象

    # ComposingRouter 对象(在其父类Router中实现)被调用时，会 Return 一个 WSGI application 。

    # 即当调用 keystone.service.v3_app_factory 这个函数时会返回一个 application 对象，用于连接 WSGI Server 和 Application(application参数传递请求)。

这个 wsgi.ComposingRouter 对象一定是一个 WSGI application，我们看看代码就知道了：

class Router(object):

    """WSGI middleware that maps incoming requests to WSGI apps."""

    def __init__(self, mapper):

        self.map = mapper

        self._router = routes.middleware.RoutesMiddleware(self._dispatch,

                                                          self.map)

        #这个 application 中则使用了 routes 模块的中间件来实现了请求路由 (在routes.middleware.RoutesMiddleware中实现)。

        #这里对 Path 进行路由的结果就是返回各个模块的 controllers.py 中定义的 controller (路由的结果就是将请求中的URL的资源和一个 controller 对应起来)。

        #各个模块的 controller 都是一个WSGI application，这个你可以通过这些 controller 的类继承关系看出来

    @webob.dec.wsgify()

    def __call__(self, req):

        return self._router

    ...

class ComposingRouter(Router):

    def __init__(self, mapper=None, routers=None):

        ...

routes 模块把 URL_Path 映射到了一个 controller，但是如何把对 URL_Path 的处理(HTTP方法)映射到 controller 的操作函数(Action)呢？

这个可以从 controller 的父类 keystone.common.wsgi.Application 的实现看出来。

这个 Application 类中使用了 environ[‘wsgiorg.routing_args’] 中的数据来确定调用 controller 的哪个方法，这些数据是由上面提到的routes.middleware.RoutesMiddleware 设置的。所以最近调用哪一个 Controller 的 Action 还是由 routes.middleware.RoutesMiddleware 来决定的。

class Application(BaseApplication):

    @webob.dec.wsgify()

    def __call__(self, req):

        arg_dict = req.environ['wsgiorg.routing_args'][1]

        action = arg_dict.pop('action')

参考文档

routes 库的项目官网

Python Paste 库项目官网

通过demo学习OpenStack开发–API服务

Openstack Restful API 开发框架 Paste + PasteDeploy + Routes + WebOb