raoul/openlp
1
0
Fork 0
forked from openlp/openlp
Code Issues Pull Requests Projects Releases Wiki Activity

Clean up PluginManager and complete logging

Browse Source
This commit is contained in:
Tim Bentley 2013-12-14 08:12:41 +00:00
parent d684359e59
commit e93b825ab4
2 changed files with 57 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
openlp/core/common/openlpmixin.py
View File

@ -27,33 +27,64 @@
# Temple Place, Suite 330, Boston, MA 02111-1307 USA #
###############################################################################
"""
Provide Error Handling Services
Provide Error Handling and login Services
"""
import logging
import inspect
from openlp.core.common import trace_error_handler
DO_NOT_TRACE_EVENTS = ['timerEvent', 'paintEvent']
class OpenLPMixin(object):
"""
Base Calling object for OpenLP classes.
"""
def __init__(self, parent=None):
super(OpenLPMixin, self).__init__(parent)
print(self.__class__, self.__module__)
def __init__(self):
super().__init__()
self.logger = logging.getLogger(self.__module__)
for name, m in inspect.getmembers(self, inspect.ismethod):
if name not in DO_NOT_TRACE_EVENTS:
if not name.startswith("_") and not name.startswith("log_"):
setattr(self, name, self.logging_wrapper(m, self))
def logging_wrapper(self, func, parent):
"""
Code to added debug wrapper to work on called functions within a decorated class.
"""
def wrapped(*args, **kwargs):
if parent.logger.getEffectiveLevel() == logging.DEBUG:
parent.logger.debug("Entering %s" % func.__name__)
try:
return func(*args, **kwargs)
except Exception as e:
if parent.logger.getEffectiveLevel() <= logging.ERROR:
parent.logger.error('Exception in %s : %s' % (func.__name__, e))
raise e
return wrapped
def log_debug(self, message):
"""
Common log debug handler which prints the calling path
"""
self.logger.debug(message)
def log_info(self, message):
"""
Common log info handler which prints the calling path
"""
self.logger.info(message)
def log_error(self, message):
"""
Common log error handler which prints the calling path
"""
log = logging.getLogger(self.__module__)
trace_error_handler(log)
log.error(message)
trace_error_handler(self.logger)
self.logger.error(message)
def log_exception(self, message):
"""
Common log exception handler which prints the calling path
"""
log = logging.getLogger(self.__module__)
trace_error_handler(log)
log.exception(message)
trace_error_handler(self.logger)
self.logger.exception(message)

46
openlp/core/lib/pluginmanager.py
View File

@ -31,68 +31,58 @@ Provide plugin management
"""
import os
import sys
import logging
import imp
from openlp.core.lib import Plugin, PluginStatus
from openlp.core.common import AppLocation, Registry
log = logging.getLogger(__name__)
from openlp.core.common import AppLocation, Registry, OpenLPMixin
class PluginManager(object):
class PluginManager(OpenLPMixin):
"""
This is the Plugin manager, which loads all the plugins,
and executes all the hooks, as and when necessary.
"""
log.info('Plugin manager loaded')
def __init__(self):
"""
The constructor for the plugin manager. Passes the controllers on to
the plugins for them to interact with via their ServiceItems.
"""
log.info('Plugin manager Initialising')
super(PluginManager, self).__init__()
self.log_info('Plugin manager Initialising')
Registry().register('plugin_manager', self)
Registry().register_function('bootstrap_initialise', self.bootstrap_initialise)
self.base_path = os.path.abspath(AppLocation.get_directory(AppLocation.PluginsDir))
log.debug('Base path %s ', self.base_path)
self.log_debug('Base path %s ' % self.base_path)
self.plugins = []
log.info('Plugin manager Initialised')
self.log_info('Plugin manager Initialised')
def bootstrap_initialise(self):
"""
Bootstrap all the plugin manager functions
"""
log.info('bootstrap_initialise')
self.find_plugins()
# hook methods have to happen after find_plugins. Find plugins needs
# the controllers hence the hooks have moved from setupUI() to here
# Find and insert settings tabs
log.info('hook settings')
self.hook_settings_tabs()
# Find and insert media manager items
log.info('hook media')
self.hook_media_manager()
# Call the hook method to pull in import menus.
log.info('hook menus')
self.hook_import_menu()
# Call the hook method to pull in export menus.
self.hook_export_menu()
# Call the hook method to pull in tools menus.
self.hook_tools_menu()
# Call the initialise method to setup plugins.
log.info('initialise plugins')
self.initialise_plugins()
def find_plugins(self):
"""
Scan a directory for objects inheriting from the ``Plugin`` class.
"""
log.info('Finding plugins')
start_depth = len(os.path.abspath(self.base_path).split(os.sep))
present_plugin_dir = os.path.join(self.base_path, 'presentations')
log.debug('finding plugins in %s at depth %d', str(self.base_path), start_depth)
self.log_debug('finding plugins in %s at depth %d' % (self.base_path, start_depth))
for root, dirs, files in os.walk(self.base_path):
if sys.platform == 'darwin' and root.startswith(present_plugin_dir):
# TODO Presentation plugin is not yet working on Mac OS X.
@ -108,7 +98,7 @@ class PluginManager(object):
break
module_name = name[:-3]
# import the modules
log.debug('Importing %s from %s. Depth %d', module_name, root, this_depth)
self.log_debug('Importing %s from %s. Depth %d' % (module_name, root, this_depth))
try:
# Use the "imp" library to try to get around a problem with the PyUNO library which
# monkey-patches the __import__ function to do some magic. This causes issues with our tests.
@ -117,20 +107,21 @@ class PluginManager(object):
# Then load the module (do the actual import) using the details from find_module()
imp.load_module(module_name, fp, path_name, description)
except ImportError as e:
log.exception('Failed to import module %s on path %s: %s', module_name, path, e.args[0])
self.log_exception('Failed to import module %s on path %s: %s'
% (module_name, path, e.args[0]))
plugin_classes = Plugin.__subclasses__()
plugin_objects = []
for p in plugin_classes:
try:
plugin = p()
log.debug('Loaded plugin %s', str(p))
self.log_debug('Loaded plugin %s' % str(p))
plugin_objects.append(plugin)
except TypeError:
log.exception('Failed to load plugin %s', str(p))
self.log_exception('Failed to load plugin %s' % str(p))
plugins_list = sorted(plugin_objects, key=lambda plugin: plugin.weight)
for plugin in plugins_list:
if plugin.check_pre_conditions():
log.debug('Plugin %s active', str(plugin.name))
self.log_debug('Plugin %s active' % str(plugin.name))
plugin.set_status()
else:
plugin.status = PluginStatus.Disabled
@ -199,24 +190,21 @@ class PluginManager(object):
Loop through all the plugins and give them an opportunity to
initialise themselves.
"""
log.info('Initialise Plugins - Started')
for plugin in self.plugins:
log.info('initialising plugins %s in a %s state' % (plugin.name, plugin.is_active()))
self.log_info('initialising plugins %s in a %s state' % (plugin.name, plugin.is_active()))
if plugin.is_active():
plugin.initialise()
log.info('Initialisation Complete for %s ' % plugin.name)
log.info('Initialise Plugins - Finished')
self.log_info('Initialisation Complete for %s ' % plugin.name)
def finalise_plugins(self):
"""
Loop through all the plugins and give them an opportunity to
clean themselves up
"""
log.info('finalising plugins')
for plugin in self.plugins:
if plugin.is_active():
plugin.finalise()
log.info('Finalisation Complete for %s ' % plugin.name)
self.log_info('Finalisation Complete for %s ' % plugin.name)
def get_plugin_by_name(self, name):
"""
@ -231,7 +219,6 @@ class PluginManager(object):
"""
Loop through all the plugins and give them an opportunity to handle a new service
"""
log.info('plugins - new service created')
for plugin in self.plugins:
if plugin.is_active():
plugin.new_service_created()
@ -255,4 +242,3 @@ class PluginManager(object):
return self._main_window
main_window = property(_get_main_window)