之前我们了解了neutron的结构，plugin 和 extension等信息。这一章我们看一下neutron如何加载这些plugin和extension。也就是neutron的启动过程。本文涉及的代码较多，而且调用过程复杂... 所以你手头最好有一份liberty版本的neutron代码，参考来看
回顾一下neutron的paste配置文件
[composite:neutron]
use = egg:Paste#urlmap
/: neutronversions
/v2.0: neutronapi_v2_0
[composite:neutronapi_v2_0]
use = call:neutron.auth:pipeline_factory
noauth = request_id catch_errors extensions neutronapiapp_v2_0
keystone = request_id catch_errors authtoken keystonecontext extensions neutronapiapp_v2_0
[filter:request_id]
paste.filter_factory = oslo_middleware:RequestId.factory
[filter:catch_errors]
paste.filter_factory = oslo_middleware:CatchErrors.factory
[filter:keystonecontext]
paste.filter_factory = neutron.auth:NeutronKeystoneContext.factory
[filter:authtoken]
paste.filter_factory = keystonemiddleware.auth_token:filter_factory
[filter:extensions]
paste.filter_factory = neutron.api.extensions:plugin_aware_extension_middleware_factory
[app:neutronversions]
paste.app_factory = neutron.api.versions:Versions.factory
[app:neutronapiapp_v2_0]
paste.app_factory = neutron.api.v2.router:APIRouter.factory
最重要的是extensions neutronapiapp_v2_0这两个组件。前一个是wsgi middleware， 后一个是wsgi app。 我们先看后一个，因为按照加载顺序，也必然是它先加载
neutronapiapp_v2_0
从配置文件不难定义到其代码在 neutron.api.v2.router.py 的 APIRouter类的factory函数。这是设计模式中的工厂函数。虽然python可能不太适用JAVA设计模式，但。。可能这些程序员之前是java程序员。该factory函数的作用就是构建APIRouter类的一个实例。我们看一下构造函数
def __init__(self, **local_config):
mapper = routes_mapper.Mapper()
plugin = manager.NeutronManager.get_plugin()
ext_mgr = extensions.PluginAwareExtensionManager.get_instance()
ext_mgr.extend_resources("2.0", attributes.RESOURCE_ATTRIBUTE_MAP)
col_kwargs = dict(collection_actions=COLLECTION_ACTIONS,
member_actions=MEMBER_ACTIONS)
def _map_resource(collection, resource, params, parent=None):
allow_bulk = cfg.CONF.allow_bulk
allow_pagination = cfg.CONF.allow_pagination
allow_sorting = cfg.CONF.allow_sorting
controller = base.create_resource(
collection, resource, plugin, params, allow_bulk=allow_bulk,
parent=parent, allow_pagination=allow_pagination,
allow_sorting=allow_sorting)
path_prefix = None
if parent:
path_prefix = "/%s/{%s_id}/%s" % (parent['collection_name'],
parent['member_name'],
collection)
mapper_kwargs = dict(controller=controller,
requirements=REQUIREMENTS,
path_prefix=path_prefix,
**col_kwargs)
return mapper.collection(collection, resource,
**mapper_kwargs)
mapper.connect('index', '/', controller=Index(RESOURCES))
for resource in RESOURCES:
_map_resource(RESOURCES[resource], resource,
attributes.RESOURCE_ATTRIBUTE_MAP.get(
RESOURCES[resource], dict()))
resource_registry.register_resource_by_name(resource)
for resource in SUB_RESOURCES:
_map_resource(SUB_RESOURCES[resource]['collection_name'], resource,
attributes.RESOURCE_ATTRIBUTE_MAP.get(
SUB_RESOURCES[resource]['collection_name'],
dict()),
SUB_RESOURCES[resource]['parent'])
# Certain policy checks require that the extensions are loaded
# and the RESOURCE_ATTRIBUTE_MAP populated before they can be
# properly initialized. This can only be claimed with certainty
# once this point in the code has been reached. In the event
# that the policies have been initialized before this point,
# calling reset will cause the next policy check to
# re-initialize with all of the required data in place.
policy.reset()
super(APIRouter, self).__init__(mapper)
这部分代码调用若要展开详细说明会非常多，所以我们只挑重点部分，分为几个小节大概说明。
mapper是routes的mapper。它的后面会把url 和 逻辑处理模块映射起来。这里先创建，后面会增加映射。
NeutronManager
plugin = manager.NeutronManager.get_plugin() 比较关键。 所以我们这里单独用一个小节来说明。这里最关键的就是neutron manager这个类
"""Neutron's Manager class.
Neutron's Manager class is responsible for parsing a config file and
instantiating the correct plugin that concretely implements
neutron_plugin_base class.
The caller should make sure that NeutronManager is a singleton.
"""
上面是NeutronManager的注释，有几点内容注意：
singleton： 就是说在使用该类时要确保它是单实例的
instantiating plugin: 就是说该类是用来加载plugin的
这里说加载所有正确实施了neutron_plugin_base接口并且在配置文件中配置了的plugin，有点不太准确。因为core plugin 和service plugin的接口其实是不一样的。不过，我们只要知道它加载plugin的就可以了。这里plugin 包括core和service
单实例是确保这个class只实例化一次，这样plugin也就只会被加载一次。 下面我们看一下这个class 如何加载plugin。其构造函数代码如下
def __init__(self, options=None, config_file=None):
# If no options have been provided, create an empty dict
if not options:
options = {}
msg = validate_pre_plugin_load()
if msg:
LOG.critical(msg)
raise Exception(msg)
# NOTE(jkoelker) Testing for the subclass with the __subclasshook__
# breaks tach monitoring. It has been removed
# intentionally to allow v2 plugins to be monitored
# for performance metrics.
plugin_provider = cfg.CONF.core_plugin
LOG.info(_LI("Loading core plugin: %s"), plugin_provider)
self.plugin = self._get_plugin_instance(CORE_PLUGINS_NAMESPACE,
plugin_provider)
msg = validate_post_plugin_load()
if msg:
LOG.critical(msg)
raise Exception(msg)
# core plugin as a part of plugin collection simplifies
# checking extensions
# TODO(enikanorov): make core plugin the same as
# the rest of service plugins
self.service_plugins = {constants.CORE: self.plugin}
self._load_service_plugins()
# Used by pecan WSGI
self.resource_plugin_mappings = {}
self.resource_controller_mappings = {}
plugin_provider = cfg.CONF.core_plugin就是配置文件/etc/neutron/neutron.conf中
[default]
core_plugin =
的内容。通常这里是ml2。不管是什么，这里是core plugin注册在neutron.core_plugins下的entry point名字。如果你继续追踪self._get_plugin_instance的代码，就会发现是我们之前讲过的stevedore调用。
下面比较关键的地方是这段注释和代码
# core plugin as a part of plugin collection simplifies
# checking extensions
# TODO(enikanorov): make core plugin the same as
# the rest of service plugins
self.service_plugins = {constants.CORE: self.plugin}
self._load_service_plugins()
从注释中可知core plugin将会被当作service plugin处理。这是个趋势.
这个类的service_plugins属性是一个字典，字典的key是service type而value是service_plugin实例。 这里把core plugin当作一种service plugin加了进去。下面的self._load_service_plugins会继续填充这个字典，加载配置文件中配置的所有service plugin。
假设我们配置文件中配置了
core_plugin = ml2
service_plugin = router, zoo
那么现在这个字典的值就是
{‘CORE’: <ML2 instance>, 'ROUTER': <ROUTER instance>, 'ZOO': <ZOO instance>}
ok，说了那么多。我们现在总结一个重点就是，NeutronManager负责加载所有的配置在配置文件中的core plugin和service plugin。我们继续看
ExtensionManager
接着看ext_mgr = extensions.PluginAwareExtensionManager.get_instance()这行代码。这里最关键的自然是PluginAwareExtensionManager这个类。但为什么这一小节不是说它呢？因为它继承自ExtensionManager。
extensions.PluginAwareExtensionManager.get_instance()
这里的get_instance猜也可以猜到是获取PluginAwareExtensionManager的实例的。不过还是有一点玄机的：
@classmethod
def get_instance(cls):
if cls._instance is None:
service_plugins = manager.NeutronManager.get_service_plugins()
cls._instance = cls(get_extensions_path(service_plugins),
service_plugins)
return cls._instance
最初状态下，需要先获取service_plugins这个字典。然后调用get_extensions_path获取系统中存放所有extension的路径。再然后才是运行PluginAwareExtension的构造函数
def __init__(self, path, plugins):
self.plugins = plugins
super(PluginAwareExtensionManager, self).__init__(path)
self.check_if_plugin_extensions_loaded()
而这个构造函数就三行。大部分的工作都是第二行，也就是我们这一小节的主角ExtensionManager的构造函数。 OK。。。我们这一小节的主题终于开始了。
def _load_all_extensions_from_path(self, path):
# Sorting the extension list makes the order in which they
# are loaded predictable across a cluster of load-balanced
# Neutron Servers
for f in sorted(os.listdir(path)):
try:
LOG.debug('Loading extension file: %s', f)
mod_name, file_ext = os.path.splitext(os.path.split(f)[-1])
ext_path = os.path.join(path, f)
if file_ext.lower() == '.py' and not mod_name.startswith('_'):
mod = imp.load_source(mod_name, ext_path)
ext_name = mod_name[0].upper() + mod_name[1:]
new_ext_class = getattr(mod, ext_name, None)
if not new_ext_class:
LOG.warn(_LW('Did not find expected name '
'"%(ext_name)s" in %(file)s'),
{'ext_name': ext_name,
'file': ext_path})
continue
new_ext = new_ext_class()
self.add_extension(new_ext)
except Exception as exception:
LOG.warn(_LW("Extension file %(f)s wasn't loaded due to "
"%(exception)s"),
{'f': f, 'exception': exception})
根据构造函数追踪，可以追踪到上面这个类，读代码可知，该类会加载系统中extension path，默认是neutron/extensions下所有的extension。加载的时候有几个条件
- extension的名字必须是file名和class同名，不过class名字的首字母要大写
- extension的文件名不能开头是_
这些也正符合我们之前说的写extension要符合的几个要求。
OK, 总结重点，ExtensionManager加载了所有的extension，存在它的extensions属性中。该属性是一个字典，key是extension的别名，value是extension的实例。
PluginAwareExtensionManager
上面我们已经说了PluignAwareExtensionManager的构造函数是下面这样。
def __init__(self, path, plugins):
self.plugins = plugins
super(PluginAwareExtensionManager, self).__init__(path)
self.check_if_plugin_extensions_loaded()
目前为止，我们知道了NeutronManager加载所有plugin, ExtensionManager加载extension，那么这个类是干嘛的呢？从名字看它说Plugin aware Extension，其实正是这样。
之前的blog中我们说extension有三种
- resource extension 新增资源
- action extension 新增action
- request extension 扩充request
很多plugin独自不能实现所需的api功能，这些plugin就需要extension。plugin有一个supported_extension_alias记录了它需要的extension的列表。这个类就会根据这个列表检查plugin所需的extension是否加载了。
看这个构造函数，第一行获取所有的plugin，第二行获取所有的extension，第三行不言而喻，就是根据plugin来check extension是否加载
ExtensionManager.extend_resource
我们看看下面的代码。
ext_mgr.extend_resources("2.0", attributes.RESOURCE_ATTRIBUTE_MAP)
目前为止我们加载了所有的plugin，所有的extension，并且确保了plugin所需的extension都加载了。这一行代码其实是跟我们之前说的request extension相关
我们知道request extension的作用是为request添加一些参数。这些参数落到RESTful的资源中其实就是资源的属性，既然是资源的属性，那么就需要在RESOURCE_ATTRIBUTE_MAP定义的资源中有相应的内容。比如
最初的RESOURCE_ATTRIBUTE_MAP定义可能如下：
RESOURCE_ATTRIBUTE_MAP = {
NETWORKS: {
'id': {'allow_post': False, 'allow_put': False,
'validate': {'type:uuid': None},
'is_visible': True,
'primary_key': True},
'name': {'allow_post': True, 'allow_put': True,
'validate': {'type:string': NAME_MAX_LEN},
'default': '', 'is_visible': True},
'subnets': {'allow_post': False, 'allow_put': False,
'default': [],
'is_visible': True},
'admin_state_up': {'allow_post': True, 'allow_put': True,
'default': True,
'convert_to': convert_to_boolean,
'is_visible': True},
'status': {'allow_post': False, 'allow_put': False,
'is_visible': True},
'tenant_id': {'allow_post': True, 'allow_put': False,
'validate': {'type:string': TENANT_ID_MAX_LEN},
'required_by_policy': True,
'is_visible': True},
SHARED: {'allow_post': True,
'allow_put': True,
'default': False,
'convert_to': convert_to_boolean,
'is_visible': True,
'required_by_policy': True,
'enforce_policy': True},
},
这里并没有 some_attr这个属性，所以你在创建网络的时候如果带了这个属性就会报错。而resource extension会update这个字典，添加这个属性。
ext_mgr是ExtensionManager的实例，它拥有所有的extension，因此通过遍历自己的extension，找到所有的request extension并用其update RESOURCE_ATTRIBUTE_MAP，可以把API需要的属性注册到系统中。换句话说，到了这里，所有的resource extension 的最主要任务完成了。
_map_resource
接下来最重要的是这个函数。该函数的作用是把resource的URL 和 controller映射起来。 Resource是作为参数传入的，重点是controller。它是由
controller = base.create_resource(
collection, resource, plugin, params, allow_bulk=allow_bulk,
parent=parent, allow_pagination=allow_pagination,
allow_sorting=allow_sorting)
这段话创建的。这个controller最后会包装成一个wsgi的资源。这一过程中 POST/GET 等HTTP method 被翻译成create 和 get等action，而controller由通过这些action去调用plugin中对应的方法，进而完成api操作。
重要的是这里处理的只有核心资源
到这里APIRouter的主要内容就分析完了。接下来看 extension middleware
ExtensionMiddleware
从paste的文件首先找到这个工厂函数
def plugin_aware_extension_middleware_factory(global_config, **local_config):
"""Paste factory."""
def _factory(app):
ext_mgr = PluginAwareExtensionManager.get_instance()
return ExtensionMiddleware(app, ext_mgr=ext_mgr)
return _factory
它返回了一个PluginAwareExtensionManager的实例。这个实例我们之前说过，没什么特殊的。重要的是它拥有所有的配置的plugin和extension。重点看ExtensionMiddleware。其构造函数如下
def __init__(self, application, ext_mgr=None):
self.ext_mgr = (ext_mgr or ExtensionManager(get_extensions_path()))
mapper = routes.Mapper()
# extended resources
for resource in self.ext_mgr.get_resources():
path_prefix = resource.path_prefix
if resource.parent:
path_prefix = (resource.path_prefix +
"/%s/{%s_id}" %
(resource.parent["collection_name"],
resource.parent["member_name"]))
LOG.debug('Extended resource: %s',
resource.collection)
for action, method in six.iteritems(resource.collection_actions):
conditions = dict(method=[method])
path = "/%s/%s" % (resource.collection, action)
with mapper.submapper(controller=resource.controller,
action=action,
path_prefix=path_prefix,
conditions=conditions) as submap:
submap.connect(path_prefix + path, path)
submap.connect(path_prefix + path + "_format",
"%s.:(format)" % path)
mapper.resource(resource.collection, resource.collection,
controller=resource.controller,
member=resource.member_actions,
parent_resource=resource.parent,
path_prefix=path_prefix)
# extended actions
action_controllers = self._action_ext_controllers(application,
self.ext_mgr, mapper)
for action in self.ext_mgr.get_actions():
LOG.debug('Extended action: %s', action.action_name)
controller = action_controllers[action.collection]
controller.add_action(action.action_name, action.handler)
# extended requests
req_controllers = self._request_ext_controllers(application,
self.ext_mgr, mapper)
for request_ext in self.ext_mgr.get_request_extensions():
LOG.debug('Extended request: %s', request_ext.key)
controller = req_controllers[request_ext.key]
controller.add_handler(request_ext.handler)
self._router = routes.middleware.RoutesMiddleware(self._dispatch,
mapper)
super(ExtensionMiddleware, self).__init__(application)
我们挑重点说。这里仅有的三个注释其实已经说明了这个middleware的重点。extension有三种，这里对应着这三条extension的处理
首先是resource extension
self.ext_mgr.get_resources是extension manager的函数，它遍历所有的resource extension，获取它们定义的所有resource，返回一个resource列表。接下来的内容就简单了，生成controller，映射url。
其次是action extension
同上。。
接着request extension
同上。。
OK 上面就是neutron启动加载所有plugin和extension的过程