base/app_manager: introduce application context

The ryu-manager creates structures which applications share.
Currently it is hard-coded in ryu-managers. Concretely network.Network and
dpset.DPSet. It is difficult to maintain the code appropriately by hand.
When the application is changed or new application comes in, ryu-manager
also must be updated.
So introduce the notion of application context so that application manager
can determine what structures applications want to share and create them.

Signed-off-by: Isaku Yamahata <yamahata@valinux.co.jp>
Signed-off-by: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>

bin/ryu-manager

@@ -49,11 +49,18 @@ def main():
     _args = FLAGS(sys.argv)
     log.init_log()
 
-    nw = network.Network()
+    # to make non-converted apps work. Once all of them converted,
-    dpset_ = dpset.DPSet()
+    # this will be removed.
+    kwargs = {
+        'network': network.Network(),
+        'dpset': dpset.DPSet(),
+        }
 
     app_mgr = AppManager()
-    app_mgr.load_apps(FLAGS.app_lists, network=nw, dpset=dpset_)
+    app_mgr.load_apps(FLAGS.app_lists)
+    contexts = app_mgr.create_contexts()
+    contexts.update(kwargs)
+    app_mgr.instantiate_apps(**contexts)
 
     services = []
 
@@ -67,6 +74,8 @@ def main():
     services.append(thr)
 
     gevent.joinall(services)
+    app_mgr.close()
+
 
 if __name__ == "__main__":
     main()

ryu/base/app_manager.py

@@ -23,24 +23,93 @@ from ryu.controller.handler import register_instance
 LOG = logging.getLogger('ryu.base.app_manager')
 
 
+class RyuAppContext(object):
+    """
+    Base class for Ryu application context
+    """
+    def __init__(self):
+        super(RyuAppContext, self).__init__()
+
+    def close(self):
+        """
+        teardown method
+        The method name, close, is chosen for python context manager
+        """
+        pass
+
+
+class RyuApp(object):
+    """
+    Base class for Ryu network application
+    """
+    _CONTEXTS = {}
+
+    @classmethod
+    def context_iteritems(cls):
+        """
+        Return iterator over the (key, contxt class) of application context
+        """
+        return cls._CONTEXTS.iteritems()
+
+    def __init__(self, *_args, **_kwargs):
+        super(RyuApp, self).__init__()
+
+    def close(self):
+        """
+        teardown method.
+        The method name, close, is chosen for python context manager
+        """
+        pass
+
+
 class AppManager(object):
     def __init__(self):
+        self.applications_cls = {}
         self.applications = {}
+        self.contexts_cls = {}
+        self.contexts = {}
 
-    def load(self, app_mod_name, *args, **kwargs):
+    def load_apps(self, app_lists):
-        # for now, only single instance of a given module
+        for app_cls_name in itertools.chain.from_iterable([app_list.split(',')
-        # Do we need to support multiple instances?
+                                                           for app_list
-        # Yes, maybe for slicing.
+                                                           in app_lists]):
-        assert app_mod_name not in self.applications
+            LOG.info('loading app %s', app_cls_name)
 
-        cls = utils.import_object(app_mod_name)
+            # for now, only single instance of a given module
-        app = cls(*args, **kwargs)
+            # Do we need to support multiple instances?
-        register_instance(app)
+            # Yes, maybe for slicing.
+            assert app_cls_name not in self.applications_cls
 
-        self.applications[app_mod_name] = app
+            cls = utils.import_object(app_cls_name)
+            self.applications_cls[app_cls_name] = cls
 
-    def load_apps(self, app_lists, *args, **kwargs):
+            for key, context_cls in cls.context_iteritems():
-        for app in itertools.chain.from_iterable([app_list.split(',')
+                cls = self.contexts_cls.setdefault(key, context_cls)
-                                                  for app_list in app_lists]):
+                assert cls == context_cls
-            self.load(app, *args, **kwargs)
+
-            LOG.info('loading app %s', app)
+    def create_contexts(self):
+        for key, cls in self.contexts_cls.items():
+            self.contexts[key] = cls()
+        return self.contexts
+
+    def instantiate_apps(self, *args, **kwargs):
+        for app_name, cls in self.applications_cls.items():
+            # 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', app_name)
+            assert app_name not in self.applications
+            app = cls(*args, **kwargs)
+            register_instance(app)
+            self.applications[app_name] = app
+
+    def close(self):
+        def close_all(close_dict):
+            for app in close_dict:
+                close_method = getattr(app, 'close', None)
+                if callable(close_method):
+                    close_method()
+            close_dict.clear()
+
+        close_all(self.applications)
+        close_all(self.contexts)