Add the plugin framework from common; use and test.

For blueprint novaplugins.

Change-Id: Id4a5ae3ebb91f941956e2f73ecfd9ea1d290a235

4 files changed, 289 insertions, 0 deletions

diff --git a/nova/openstack/common/plugin/__init__.py b/nova/openstack/common/plugin/__init__.py
new file mode 100644
index 000000000..63c3905e2
--- /dev/null
+++ b/nova/openstack/common/plugin/__init__.py
@@ -0,0 +1,14 @@
+# Copyright 2012 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
diff --git a/nova/openstack/common/plugin/callbackplugin.py b/nova/openstack/common/plugin/callbackplugin.py
new file mode 100644
index 000000000..d19a1cf48
--- /dev/null
+++ b/nova/openstack/common/plugin/callbackplugin.py
@@ -0,0 +1,93 @@
+# Copyright 2012 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from nova.openstack.common import log as logging
+from nova.openstack.common.plugin import plugin
+
+
+LOG = logging.getLogger(__name__)
+
+
+class _CallbackNotifier(object):
+    """Manages plugin-defined notification callbacks.
+
+    For each Plugin, a CallbackNotifier will be added to the
+    notification driver list.  Calls to notify() with appropriate
+    messages will be hooked and prompt callbacks.
+
+    A callback should look like this:
+      def callback(context, message, user_data)
+    """
+
+    def __init__(self):
+        self._callback_dict = {}
+
+    def _add_callback(self, event_type, callback, user_data):
+        callback_list = self._callback_dict.get(event_type, [])
+        callback_list.append({'function': callback,
+                              'user_data': user_data})
+        self._callback_dict[event_type] = callback_list
+
+    def _remove_callback(self, callback):
+        for callback_list in self._callback_dict.values():
+            for entry in callback_list:
+                if entry['function'] == callback:
+                    callback_list.remove(entry)
+
+    def notify(self, context, message):
+        if message.get('event_type') not in self._callback_dict:
+            return
+
+        for entry in self._callback_dict[message.get('event_type')]:
+            entry['function'](context, message, entry.get('user_data'))
+
+    def callbacks(self):
+        return self._callback_dict
+
+
+class CallbackPlugin(plugin.Plugin):
+    """ Plugin with a simple callback interface.
+
+    This class is provided as a convenience for producing a simple
+    plugin that only watches a couple of events.  For example, here's
+    a subclass which prints a line the first time an instance is created.
+
+    class HookInstanceCreation(CallbackPlugin):
+
+        def __init__(self, _service_name):
+            super(HookInstanceCreation, self).__init__()
+            self._add_callback(self.magic, 'compute.instance.create.start')
+
+        def magic(self):
+            print "An instance was created!"
+            self._remove_callback(self, self.magic)
+    """
+
+    def __init__(self, service_name):
+        super(CallbackPlugin, self).__init__(service_name)
+        self._callback_notifier = _CallbackNotifier()
+        self._add_notifier(self._callback_notifier)
+
+    def _add_callback(self, callback, event_type, user_data=None):
+        """Add callback for a given event notification.
+
+        Subclasses can call this as an alternative to implementing
+        a fullblown notify notifier.
+        """
+        self._callback_notifier._add_callback(event_type, callback, user_data)
+
+    def _remove_callback(self, callback):
+        """Remove all notification callbacks to specified function."""
+        self._callback_notifier._remove_callback(callback)
diff --git a/nova/openstack/common/plugin/plugin.py b/nova/openstack/common/plugin/plugin.py
new file mode 100644
index 000000000..3db753d65
--- /dev/null
+++ b/nova/openstack/common/plugin/plugin.py
@@ -0,0 +1,87 @@
+# Copyright 2012 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from nova.openstack.common import log as logging
+from nova.openstack.common.notifier import list_notifier
+
+
+LOG = logging.getLogger(__name__)
+
+
+class Plugin(object):
+    """Defines an interface for adding functionality to an OpenStack service.
+
+    A plugin interacts with a service via the following pathways:
+
+    - An optional set of notifiers, managed by calling add_notifier()
+      or by overriding _notifiers()
+
+    - A set of api extensions, managed via add_api_extension_descriptor()
+
+    - Direct calls to service functions.
+
+    - Whatever else the plugin wants to do on its own.
+
+    This is the reference implementation.
+    """
+
+    # The following functions are provided as convenience methods
+    # for subclasses.  Subclasses should call them but probably not
+    # override them.
+    def _add_api_extension_descriptor(self, descriptor):
+        """Subclass convenience method which adds an extension descriptor.
+
+           Subclass constructors should call this method when
+           extending a project's REST interface.
+
+           Note that once the api service has loaded, the
+           API extension set is more-or-less fixed, so
+           this should mainly be called by subclass constructors.
+        """
+        self._api_extension_descriptors.append(descriptor)
+
+    def _add_notifier(self, notifier):
+        """Subclass convenience method which adds a notifier.
+
+           Notifier objects should implement the function notify(message).
+           Each notifier receives a notify() call whenever an openstack
+           service broadcasts a notification.
+
+           Best to call this during construction.  Notifiers are enumerated
+           and registered by the pluginmanager at plugin load time.
+        """
+        self._notifiers.append(notifier)
+
+    # The following methods are called by OpenStack services to query
+    #  plugin features.  Subclasses should probably not override these.
+    def _notifiers(self):
+        """Returns list of notifiers for this plugin."""
+        return self._notifiers
+
+    notifiers = property(_notifiers)
+
+    def _api_extension_descriptors(self):
+        """Return a list of API extension descriptors.
+
+           Called by a project API during its load sequence.
+        """
+        return self._api_extension_descriptors
+
+    api_extension_descriptors = property(_api_extension_descriptors)
+
+    # Most plugins will override this:
+    def __init__(self, service_name):
+        self._notifiers = []
+        self._api_extension_descriptors = []
diff --git a/nova/openstack/common/plugin/pluginmanager.py b/nova/openstack/common/plugin/pluginmanager.py
new file mode 100644
index 000000000..6b921656a
--- /dev/null
+++ b/nova/openstack/common/plugin/pluginmanager.py
@@ -0,0 +1,95 @@
+# Copyright 2012 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import imp
+import os
+import pkg_resources
+
+from nova.openstack.common import cfg
+from nova.openstack.common import log as logging
+from nova.openstack.common.notifier import list_notifier
+
+
+CONF = cfg.CONF
+LOG = logging.getLogger(__name__)
+
+
+class PluginManager(object):
+    """Manages plugin entrypoints and loading.
+
+    For a service to implement this plugin interface for callback purposes:
+
+      - Make use of the openstack-common notifier system
+      - Instantiate this manager in each process (passing in
+        project and service name)
+
+    For an API service to extend itself using this plugin interface,
+    it needs to query the plugin_extension_factory provided by
+    the already-instantiated PluginManager.
+    """
+
+    def __init__(self, project_name, service_name):
+        """ Construct Plugin Manager; load and initialize plugins.
+
+        project_name (e.g. 'nova' or 'glance') is used
+        to construct the entry point that identifies plugins.
+
+        The service_name (e.g. 'compute') is passed on to
+        each plugin as a raw string for it to do what it will.
+        """
+        self._project_name = project_name
+        self._service_name = service_name
+        self.plugins = []
+
+    def _force_use_list_notifier(self):
+        if (CONF.notification_driver !=
+            'nova.openstack.common.notifier.list_notifier'):
+            if not hasattr(CONF, "list_notifier_drivers"):
+                CONF.list_notifier_drivers = []
+            old_notifier = CONF.notification_driver
+            drvstring = 'nova.openstack.common.notifier.list_notifier'
+            CONF.notification_driver = drvstring
+            if old_notifier:
+                list_notifier.add_driver(old_notifier)
+
+    def load_plugins(self):
+        self.plugins = []
+
+        for entrypoint in pkg_resources.iter_entry_points('%s.plugin' %
+                                                          self._project_name):
+            try:
+                pluginclass = entrypoint.load()
+                plugin = pluginclass(self._service_name)
+                self.plugins.append(plugin)
+            except Exception, exc:
+                LOG.error(_("Failed to load plugin %(plug)s: %(exc)s") %
+                          {'plug': entrypoint, 'exc': exc})
+
+        # See if we need to turn on the list notifier
+        for plugin in self.plugins:
+            if plugin.notifiers:
+                self._force_use_list_notifier()
+                break
+
+        # Register individual notifiers.
+        for plugin in self.plugins:
+            for notifier in plugin.notifiers:
+                list_notifier.add_driver(notifier)
+
+    def plugin_extension_factory(self, ext_mgr):
+        for plugin in self.plugins:
+            descriptors = plugin.api_extension_descriptors
+            for descriptor in descriptors:
+                ext_mgr.load_extension(descriptor)