Ryu代码解析（一）

转载：http://geekwei.com/2014/11/27/ryu-source-analysis-1/

http://www.muzixing.com/pages/2014/12/27/ryujie-du-ofphandlercontrollerryuapphe-appmanager.html

RYU main函数

Ryu的main函数位于cmd\manager.py文件中，main函数如下：

def main(args=None, prog=None):
    try:
        CONF(args=args, prog=prog,
             project='ryu', version='ryu-manager %s' % version,
             default_config_files=['/usr/local/etc/ryu/ryu.conf'])
    except cfg.ConfigFilesNotFoundError:
        CONF(args=args, prog=prog,
             project='ryu', version='ryu-manager %s' % version)
    log.init_log()
    if CONF.pid_file:
        import os
        with open(CONF.pid_file, 'w') as pid_file:
            pid_file.write(str(os.getpid()))
    app_lists = CONF.app_lists + CONF.app //从用户命令行获取的app列表
    # keep old behaivor, run ofp if no application is specified.
    if not app_lists:
        app_lists = ['ryu.controller.ofp_handler'] //添加默认的应用
    app_mgr = AppManager.get_instance() //获取appManager实例，是单体类
    app_mgr.load_apps(app_lists) //加载所有app
    contexts = app_mgr.create_contexts() //加载context
    services = []
    services.extend(app_mgr.instantiate_apps(**contexts)) //以context作为参数，实例化app
    webapp = wsgi.start_service(app_mgr)
    if webapp:
        thr = hub.spawn(webapp)
        services.append(thr)
    try:
        hub.joinall(services)
    finally:
        app_mgr.close()

AppManager

AppManager中get_instance()函数，典型的单体类实现方法

 def get_instance():
    if not AppManager._instance:
        AppManager._instance = AppManager()
    return AppManager._instance

load_app函数：加载app，本质是找到app名字对应的类
用到的python 基础：inspect.getmembers()和inspect例子

def load_app(self, name):
    mod = utils.import_module(name)
    clses = inspect.getmembers(mod,
                               lambda cls: (inspect.isclass(cls) and
                                            issubclass(cls, RyuApp) and
                                            mod.__name__ ==
                                            cls.__module__)) //过滤函数是lambda表达式
    if clses:
        return clses[0][1] //只与符合条件的第一个！！！文档里就这么要求的
    return None

load_apps函数：加载app，说是加载，其实就是找到这个类，并把其存到applications_cls中，key是app类的名字，值就是这个类，加载的过程中顺便加载每个app依赖的app类，而且把每个app的context保存到context_cls中。

python 基础 python map函数浅析

def load_apps(self, app_lists):
    app_lists = [app for app
                 in itertools.chain.from_iterable(app.split(',')
                                                  for app in app_lists)]
    while len(app_lists) > 0:
        app_cls_name = app_lists.pop(0)

        context_modules = map(lambda x: x.__module__,
                              self.contexts_cls.values()) //获取所有context类所在的模块
        if app_cls_name in context_modules: //不加载属于context的类，因为之后在create_context函数中会加载
            continue

        LOG.info('loading app %s', app_cls_name)

        cls = self.load_app(app_cls_name) //找到app的类，cls就是这个app的类
        if cls is None:
            continue

        self.applications_cls[app_cls_name] = cls //将app添加到字典

        services = []
        for key, context_cls in cls.context_iteritems(): //便利这个app类的context，将其context加入contexts_cls字典
            v = self.contexts_cls.setdefault(key, context_cls)
            assert v == context_cls
            context_modules.append(context_cls.__module__)

            if issubclass(context_cls, RyuApp): //感觉这里写错了，其实context的类在之后会加载，和前面的描述不符
                services.extend(get_dependent_services(context_cls))

        # we can't load an app that will be initiataed for
        # contexts.
        for i in get_dependent_services(cls): //加载这个app的依赖app，依赖app不在context_modules字典中
            if i not in context_modules:
                services.append(i)
        if services:
            app_lists.extend([s for s in set(services)
                              if s not in app_lists]) //将依赖的app都加入app_lists,在之后的循环中加载

create_contexts函数：实例化context_cls中的context，如果这个context是app，就实例化该app。记得在load_apps中没有管属于context_cls的app吗，在这里直接初始化了。

 def create_contexts(self):
    for key, cls in self.contexts_cls.items():
        if issubclass(cls, RyuApp):
            # hack for dpset
            context = self._instantiate(None, cls) //初始化app
        else:
            context = cls() //实例化context
        LOG.info('creating context %s', key)
        assert key not in self.contexts
        self.contexts[key] = context //加入contexts字典
    return self.contexts //返回contexts字典

_instantiate函数：

def _instantiate(self, app_name, cls, *args, **kwargs):
    # for now, only single instance of a given module
    # Do we need to support multiple instances?
    # Yes, maybe for slicing.
    LOG.info('instantiating app %s of %s', app_name, cls.__name__)

    if hasattr(cls, 'OFP_VERSIONS') and cls.OFP_VERSIONS is not None:
        ofproto_protocol.set_app_supported_versions(cls.OFP_VERSIONS)

    if app_name is not None:
        assert app_name not in self.applications
    app = cls(*args, **kwargs) //实例化app类，kwargs参数是context字典
    register_app(app) //注册app对象，主要是通过inspect组件获取其中的handler，详见下文
    assert app.name not in self.applications
    self.applications[app.name] = app //将app对象保存到applications字典中
    return app

register_app函数中调用regester_instance函数（该函数在handler.py文件中）,在该函数中通过inspect.getmembers函数，获取app类中的方法，并通过app的register_handler将handler注册到app的event_handlers成员变量中

def register_instance(i):
    for _k, m in inspect.getmembers(i, inspect.ismethod):
        # LOG.debug('instance %s k %s m %s', i, _k, m)
        if _has_caller(m):
            for ev_cls, c in m.callers.iteritems():
                i.register_handler(ev_cls, m)

到这儿可能还比较迷惑，handler是如何挂到每个事件上的，将在后面的Ryu事件处理函数的挂接方式分析中专门介绍一下。

instantiate_apps函数：实例化app，并且启动每个app

def instantiate_apps(self, *args, **kwargs):
    for app_name, cls in self.applications_cls.items():
        self._instantiate(app_name, cls, *args, **kwargs)

    self._update_bricks() //将app更新到全局变量SERVICE_BRICK中
    self.report_bricks()

    threads = []
    for app in self.applications.values():
        t = app.start() //启动APP
        if t is not None:
            threads.append(t)
    return threads