From e93b825ab4e25875801dd7e41d619955c34d74b5 Mon Sep 17 00:00:00 2001 From: Tim Bentley Date: Sat, 14 Dec 2013 08:12:41 +0000 Subject: [PATCH] Clean up PluginManager and complete logging --- openlp/core/common/openlpmixin.py | 51 +++++++++++++++++++++++++------ openlp/core/lib/pluginmanager.py | 46 ++++++++++------------------ 2 files changed, 57 insertions(+), 40 deletions(-) diff --git a/openlp/core/common/openlpmixin.py b/openlp/core/common/openlpmixin.py index dc6da03ad..65d642f2c 100644 --- a/openlp/core/common/openlpmixin.py +++ b/openlp/core/common/openlpmixin.py @@ -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) \ No newline at end of file + trace_error_handler(self.logger) + self.logger.exception(message) \ No newline at end of file diff --git a/openlp/core/lib/pluginmanager.py b/openlp/core/lib/pluginmanager.py index 3f7143faf..49e41d1f5 100644 --- a/openlp/core/lib/pluginmanager.py +++ b/openlp/core/lib/pluginmanager.py @@ -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) -