Keystone controller.py & routers.py代码解析

目录

目录

Keystone WSGI 实现
controllerspy

routerspy

参考文档

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