openstack/ironic
Code Issues Proposed changes

Remove the unused plugin framework

Browse Source 
This framework is used by Nova to allow adding API extensions and
notification drivers. Ironic doesn't use the code at all.

Change-Id: I09e4f14a65b162d5d0571da0b724d0f8a8f11646
This commit is contained in:
Mark McLoughlin
2013-06-19 07:11:48 +01:00
parent 376310c83b
commit 8c7e9c25db
5 changed files with 0 additions and 272 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
ironic/openstack/common/plugin/__init__.py
View File

@@ -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.

93
ironic/openstack/common/plugin/callbackplugin.py
View File

@@ -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 ironic.openstack.common import log as logging
from ironic.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)

86
ironic/openstack/common/plugin/plugin.py
View File

@@ -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 ironic.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 = []

78
ironic/openstack/common/plugin/pluginmanager.py
View File

@@ -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 ironic.openstack.common.gettextutils import _
from ironic.openstack.common import log as logging
from ironic.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)

1
openstack-common.conf
View File

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