nikon/tuned
1
0
Fork 0
Code Activity Actions

plugins, monitors: inherit from PluginLoader

Browse source
This commit is contained in:
Jan Vcelak 2012-10-09 15:49:17 +02:00
parent 2275777fe0
commit d891e3f2ee
9 changed files with 78 additions and 125 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
tuned/application.py
View file

@ -38,8 +38,8 @@ class Application(object):
self._storage_provider = storage.PickleProvider()
self._storage_factory = storage.Factory(self._storage_provider)
self._plugins_repository = plugins.Repository(self._storage_factory)
self._monitors_repository = monitors.Repository()
self._plugins_repository = plugins.Repository(self._storage_factory, self._monitors_repository)
self._unit_manager = units.Manager(self._plugins_repository, self._monitors_repository)
self._profile_loader = profiles.Loader()

25
tuned/monitors/repository.py
View file

@ -1,34 +1,33 @@
import tuned.patterns
import tuned.utils
import tuned.logs
import tuned.monitors
from tuned.utils.plugin_loader import PluginLoader
log = tuned.logs.get()
__all__ = ["Repository"]
class Repository(object):
class Repository(PluginLoader):
def __init__(self):
super(self.__class__, self).__init__()
self._loader = tuned.utils.PluginLoader("tuned.monitors", "monitor_", tuned.monitors.Monitor)
self._monitors = set()
def _set_loader_parameters(self):
self._namespace = "tuned.monitors"
self._prefix = "monitor_"
self._interface = tuned.monitors.Monitor
def create(self, plugin_name, devices):
log.debug("creating monitor %s" % plugin_name)
# TODO: exception handling
monitor_cls = self._loader.load(plugin_name)
monitor_cls = self.load_plugin(plugin_name)
monitor_instance = monitor_cls(devices)
if not monitor_cls in self._monitors:
self._monitors.add(monitor_cls)
self._monitors.add(monitor_instance)
return monitor_instance
def delete(self, monitor):
assert isinstance(monitor, self._loader.interface)
monitor.cleanup()
log.info(monitor._instances)
if len(monitor._instances) == 0:
self._monitors.remove(type(monitor))
self._monitors.remove(monitor)
def update(self):
for monitor in self._monitors:

1
tuned/plugins/__init__.py
View file

@ -1,2 +1 @@
from repository import *
from exceptions import *

22
tuned/plugins/exceptions.py
View file

@ -1,22 +0,0 @@
import tuned.exceptions
class LoadPluginException(tuned.exceptions.TunedException):
def __init__(self, plugin_name, inner_exception = None):
super(self.__class__, self).__init__()
self._plugin_name = plugin_name
self._inner_exception = inner_exception
@property
def plugin_name(self):
return self._plugin_name
@property
def inner_exception(self):
return self._inner_exception
def __str__(self):
message = "Unable to load plugin '%s'" % self._plugin_name
if self._inner_exception is not None:
message += " (%s)" % str(self._inner_exception)
return message[0].lower() + message[1:]

51
tuned/plugins/repository.py
View file

@ -1,49 +1,38 @@
import base
import exceptions
from tuned.utils.plugin_loader import PluginLoader
import tuned.plugins.base
import tuned.logs
import tuned.utils
log = tuned.logs.get()
__all__ = ["Repository"]
class Repository(object):
class Repository(PluginLoader):
__slots__ = ["_loader", "_plugins", "_storage_factory"]
def __init__(self, storage_factory):
def __init__(self, storage_factory, monitor_repository):
super(self.__class__, self).__init__()
self._loader = tuned.utils.PluginLoader("tuned.plugins", "plugin_", base.Plugin)
self._plugins = set()
self._storage_factory = storage_factory
self._monitor_repository = monitor_repository
def create(self, monitor_repository, plugin_name, devices, options):
def _set_loader_parameters(self):
self._namespace = "tuned.plugins"
self._prefix = "plugin_"
self._interface = tuned.plugins.base.Plugin
def create(self, plugin_name, devices, options):
log.debug("creating plugin %s" % plugin_name)
try:
plugin_cls = self._loader.load(plugin_name)
plugin_instance = plugin_cls(monitor_repository, self._storage_factory, devices, options)
self._plugins.add(plugin_instance)
return plugin_instance
except Exception as exception:
plugin_exception = exceptions.LoadPluginException(plugin_name, exception)
raise plugin_exception
plugin_cls = self.load_plugin(plugin_name)
plugin_instance = plugin_cls(self._monitor_repository, self._storage_factory, devices, options)
self._plugins.add(plugin_instance)
return plugin_instance
def tunable_devices(self, plugin_name):
try:
plugin_cls = self._loader.load(plugin_name)
return plugin_cls.tunable_devices()
except Exception as e:
plugin_exception = exceptions.LoadPluginException(plugin_name, e)
raise plugin_exception
plugin_cls = self.load_plugin(plugin_name)
return plugin_cls.tunable_devices()
def is_supported(self, plugin_name):
try:
plugin_cls = self._loader.load(plugin_name)
return plugin_cls.is_supported()
except Exception as e:
plugin_exception = exceptions.LoadPluginException(plugin_name, e)
raise plugin_exception
plugin_cls = self.load_plugin(plugin_name)
return plugin_cls.is_supported()
def do_static_tuning(self):
for plugin in self._plugins:
@ -53,7 +42,7 @@ class Repository(object):
plugin.execute_commands()
def delete(self, plugin):
assert isinstance(plugin, self._loader.interface)
assert isinstance(plugin, self._interface)
log.debug("removing plugin %s" % plugin)
plugin.cleanup_commands()
plugin.cleanup()

2
tuned/units/unit.py
View file

@ -21,7 +21,7 @@ class Unit(object):
self._name = name
(devices, options) = self._get_plugin_params(config)
self._plugin = self._plugin_repository.create(monitor_repository, plugin_name, devices, options)
self._plugin = self._plugin_repository.create(plugin_name, devices, options)
@property
def name(self):

1
tuned/utils/__init__.py
View file

@ -17,4 +17,3 @@
from signals import *
from daemon import *
from pluginloader import *

44
tuned/utils/plugin_loader.py Normal file
View file

@ -0,0 +1,44 @@
import tuned.logs
__all__ = ["PluginLoader"]
log = tuned.logs.get()
class PluginLoader(object):
__slots__ = ["_namespace", "_prefix", "_interface"]
def _set_loader_parameters(self):
"""
This method has to be implemented in child class and should
set _namespace, _prefix, and _interface member attributes.
"""
raise NotImplementedError()
def __init__(self):
super(PluginLoader, self).__init__()
self._set_loader_parameters()
assert type(self._namespace) is str
assert type(self._prefix) is str
assert type(self._interface) is type and issubclass(self._interface, object)
def load_plugin(self, plugin_name):
assert type(plugin_name) is str
module_name = "%s.%s%s" % (self._namespace, self._prefix, plugin_name)
return self._get_class(module_name)
def _get_class(self, module_name):
log.debug("loading module %s" % module_name)
module = __import__(module_name)
path = module_name.split(".")
path.pop(0)
while len(path) > 0:
module = getattr(module, path.pop(0))
for name in module.__dict__:
cls = getattr(module, name)
if type(cls) is type and issubclass(cls, self._interface):
return cls
raise ImportError("Cannot find the plugin class.")

55
tuned/utils/pluginloader.py
View file

@ -1,55 +0,0 @@
import tuned.logs
__all__ = ["PluginLoader"]
log = tuned.logs.get()
class PluginLoader(object):
__slots__ = ["_namespace", "_prefix", "_interface"]
def __init__(self, namespace, prefix, interface):
super(self.__class__, self).__init__()
assert type(namespace) is str
assert type(prefix) is str
assert type(interface) is type and issubclass(interface, object)
self._namespace = namespace
self._prefix = prefix
self._interface = interface
@property
def namespace(self):
return self._namespace
@property
def prefix(self):
return self._prefix
@property
def interface(self):
return self._interface
def load(self, plugin_name):
assert type(plugin_name) is str
module_name = "%s.%s%s" % (self._namespace, self._prefix, plugin_name)
module = self._get_module(module_name)
return module
def _get_module(self, module_name):
log.debug("loading module %s" % module_name)
module = __import__(module_name)
path = module_name.split(".")
path.pop(0)
while len(path) > 0:
module = getattr(module, path.pop(0))
for name in module.__dict__:
obj = getattr(module, name)
if type(obj) is type and issubclass(obj, self._interface):
return obj
raise ImportError("Cannot find the plugin class.")