Remove the unused plugins framework

This framework was merged a year ago and AFAICT hasn't seen use beyond
the two initial wikimedia extensions.

The framework basically allows a way for a single plugin to register API
extensions and notification drivers. Both of these can be done by
directly using config opts like osapi_compute_extension and
notification_driver so this framework really only helps if we expected
to (and wanted to) lots of these plugins in the wild.

Change-Id: I09a11f9931ee0436a56e8b0d925683b54f73b104

nova/api/openstack/compute/extensions.py

@@ -19,7 +19,6 @@ from oslo.config import cfg
 
 from nova.api.openstack import extensions as base_extensions
 from nova.openstack.common import log as logging
-from nova.openstack.common.plugin import pluginmanager
 
 ext_opts = [
     cfg.MultiStrOpt('osapi_compute_extension',
@@ -38,10 +37,6 @@ class ExtensionManager(base_extensions.ExtensionManager):
     def __init__(self):
         LOG.audit(_('Initializing extension manager.'))
         self.cls_list = CONF.osapi_compute_extension
-        self.PluginManager = pluginmanager.PluginManager('nova',
-                                                         'compute-extensions')
-        self.PluginManager.load_plugins()
-        self.cls_list.append(self.PluginManager.plugin_extension_factory)
         self.extensions = {}
         self.sorted_ext_list = []
         self._load_extensions()

nova/manager.py

@@ -60,7 +60,6 @@ from nova.db import base
 from nova.objects import base as objects_base
 from nova.openstack.common import log as logging
 from nova.openstack.common import periodic_task
-from nova.openstack.common.plugin import pluginmanager
 from nova.openstack.common.rpc import dispatcher as rpc_dispatcher
 from nova.scheduler import rpcapi as scheduler_rpcapi
 
@@ -78,15 +77,10 @@ class Manager(base.Base, periodic_task.PeriodicTasks):
         if not host:
             host = CONF.host
         self.host = host
-        self.load_plugins()
         self.backdoor_port = None
         self.service_name = service_name
         super(Manager, self).__init__(db_driver)
 
-    def load_plugins(self):
-        pluginmgr = pluginmanager.PluginManager('nova', self.__class__)
-        pluginmgr.load_plugins()
-
     def create_rpc_dispatcher(self, backdoor_port=None, additional_apis=None):
         '''Get the rpc dispatcher for this manager.
 
@@ -151,10 +145,6 @@ class SchedulerDependentManager(Manager):
         super(SchedulerDependentManager, self).__init__(host, db_driver,
                 service_name)
 
-    def load_plugins(self):
-        pluginmgr = pluginmanager.PluginManager('nova', self.service_name)
-        pluginmgr.load_plugins()
-
     def update_service_capabilities(self, capabilities):
         """Remember these capabilities to send on next periodic update."""
         if not isinstance(capabilities, list):

nova/openstack/common/plugin/__init__.py

@@ -1,14 +0,0 @@
-# Copyright 2012 OpenStack Foundation.
-# 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.

nova/openstack/common/plugin/callbackplugin.py

@@ -1,93 +0,0 @@
-# Copyright 2012 OpenStack Foundation.
-# 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)

nova/openstack/common/plugin/plugin.py

@@ -1,86 +0,0 @@
-# Copyright 2012 OpenStack Foundation.
-# 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
-
-
-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 = []

nova/openstack/common/plugin/pluginmanager.py

@@ -1,78 +0,0 @@
-# Copyright 2012 OpenStack Foundation.
-# 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 pkg_resources
-
-from oslo.config import cfg
-
-from nova.openstack.common.gettextutils import _
-from nova.openstack.common import log as logging
-from nova.openstack.common.notifier import api as notifier_api
-
-
-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 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 as exc:
-                LOG.error(_("Failed to load plugin %(plug)s: %(exc)s") %
-                          {'plug': entrypoint, 'exc': exc})
-
-        # Register individual notifiers.
-        for plugin in self.plugins:
-            for notifier in plugin.notifiers:
-                notifier_api.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)

nova/tests/api/openstack/compute/extensions/test_plugin_api_extensions.py

@@ -1,87 +0,0 @@
-# Copyright 2011 OpenStack Foundation
-# 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 pkg_resources
-
-from nova.api.openstack.compute import extensions as computeextensions
-from nova.api.openstack import extensions
-from nova.openstack.common.plugin import plugin
-from nova import test
-
-
-class StubController(object):
-
-    def i_am_the_stub(self):
-        pass
-
-
-class StubControllerExtension(extensions.ExtensionDescriptor):
-    """This is a docstring.  We need it."""
-    name = 'stubextension'
-    alias = 'stubby'
-
-    def get_resources(self):
-        resources = []
-        res = extensions.ResourceExtension('testme',
-                                           StubController())
-        resources.append(res)
-        return resources
-
-
-service_list = []
-
-
-class TestPluginClass(plugin.Plugin):
-
-    def __init__(self, service_name):
-        super(TestPluginClass, self).__init__(service_name)
-        self._add_api_extension_descriptor(StubControllerExtension)
-        service_list.append(service_name)
-
-
-class MockEntrypoint(pkg_resources.EntryPoint):
-    def load(self):
-        return TestPluginClass
-
-
-class APITestCase(test.TestCase):
-    """Test case for the plugin api extension interface."""
-    def test_add_extension(self):
-        def mock_load(_s):
-            return TestPluginClass()
-
-        def mock_iter_entry_points(_t):
-            return [MockEntrypoint("fake", "fake", ["fake"])]
-
-        self.stubs.Set(pkg_resources, 'iter_entry_points',
-                mock_iter_entry_points)
-        global service_list
-        service_list = []
-
-        # Marking out the default extension paths makes this test MUCH faster.
-        self.flags(osapi_compute_extension=[])
-
-        found = False
-        mgr = computeextensions.ExtensionManager()
-        for res in mgr.get_resources():
-            # We have to use this weird 'dir' check because
-            #  the plugin framework muddies up the classname
-            #  such that 'isinstance' doesn't work right.
-            if 'i_am_the_stub' in dir(res.controller):
-                found = True
-
-        self.assertTrue(found)
-        self.assertEqual(len(service_list), 1)
-        self.assertEqual(service_list[0], 'compute-extensions')

openstack-common.conf

@@ -24,7 +24,6 @@ module=network_utils
 module=notifier
 module=patch_tox_venv
 module=periodic_task
-module=plugin
 module=policy
 module=processutils
 module=redhat-eventlet.patch