From 68fa2f9fa35f3d5a27c88e8890a4cae443fa8060 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gina=20H=C3=A4u=C3=9Fge?= Date: Wed, 1 Apr 2015 11:51:08 +0200 Subject: [PATCH] WIP --- src/octoprint/plugin/core.py | 75 +++++++++++++++++------------------- 1 file changed, 35 insertions(+), 40 deletions(-) diff --git a/src/octoprint/plugin/core.py b/src/octoprint/plugin/core.py index 814c93b5..8a6218ce 100644 --- a/src/octoprint/plugin/core.py +++ b/src/octoprint/plugin/core.py @@ -276,11 +276,11 @@ class PluginInfo(object): @property def implementation(self): """ - Implementations provided by the plugin. Will be taken from the implementations attribute of the plugin module - as defined in :attr:`attr_implementations` if available, otherwise an empty list is returned. + Implementation provided by the plugin. Will be taken from the implementation attribute of the plugin module + as defined in :attr:`attr_implementation` if available, otherwise None is returned. Returns: - list: Implementations provided by the plugin. + object: Implementation provided by the plugin. """ return self._get_instance_attribute(self.__class__.attr_implementation, default=None) @@ -524,7 +524,9 @@ class PluginManager(object): return key in self.plugin_disabled_list or key.endswith('disabled') def reload_plugins(self): - self.logger.info("Loading plugins from {folders} and installed plugin packages...".format(folders=", ".join(map(lambda x: x[0] if isinstance(x, tuple) else str(x), self.plugin_folders)))) + self.logger.info("Loading plugins from {folders} and installed plugin packages...".format( + folders=", ".join(map(lambda x: x[0] if isinstance(x, tuple) else str(x), self.plugin_folders)) + )) plugins, disabled_plugins = self._find_plugins() self.disabled_plugins = disabled_plugins @@ -532,17 +534,6 @@ class PluginManager(object): for name, plugin in plugins.items(): self.load_plugin(name, plugin) - # evaluate registered implementations - for plugin_type in self.plugin_types: - implementations = plugin.get_implementations(plugin_type) - self.plugin_implementations_by_type[plugin_type] += ( (name, implementation) for implementation in implementations ) - - plugin_implementations = plugin.get_implementations() - if len(plugin_implementations): - self.plugin_implementations[name].update(plugin_implementations) - except: - self.logger.exception("There was an error loading plugin %s" % name) - if len(self.plugins) <= 0: self.logger.info("No plugins found") else: @@ -639,14 +630,13 @@ class PluginManager(object): for hook, callback in plugin.hooks.items(): self.plugin_hooks[hook].append((name, callback)) - # evaluate registered implementations - for plugin_type in self.plugin_types: - implementations = plugin.get_implementations(plugin_type) - self.plugin_implementations_by_type[plugin_type] += ( (name, implementation) for implementation in implementations ) + # evaluate registered implementation + if plugin.implementation: + for plugin_type in self.plugin_types: + if isinstance(plugin.implementation, plugin_type): + self.plugin_implementations_by_type[plugin_type].append((name, plugin.implementation)) - plugin_implementations = plugin.get_implementations() - if len(plugin_implementations): - self.plugin_implementations[name].update(plugin_implementations) + self.plugin_implementations[name] = plugin.implementation self.on_plugin_activated(name, plugin) @@ -655,31 +645,32 @@ class PluginManager(object): for hook, callback in plugin.hooks.items(): self.plugin_hooks[hook].remove((name, callback)) - for plugin_type in self.plugin_types: - implementations = plugin.get_implementations(plugin_type) - map(lambda x: self.plugin_implementations_by_type[plugin_type].remove(x), - ( (name, implementation) for implementation in implementations )) + if plugin.implementation is not None: + del self.plugin_implementations[name] + for plugin_type in self.plugin_types: + try: + self.plugin_implementations_by_type[plugin_type].remove((name, plugin.implementation)) + except ValueError: + # that's ok, the plugin was just not registered for the type + pass - del self.plugin_implementations[name] self.on_plugin_deactivated(name, plugin) def initialize_implementations(self, additional_injects=None, additional_inject_factories=None): - for name, implementations in self.plugin_implementations.items(): - plugin = self.plugins[name] - self.initialize_implementations_of_plugin(name, plugin, - additional_injects=additional_injects, - additional_inject_factories=additional_inject_factories) + for name, plugin in self.plugins.items(): + self.initialize_implementation_of_plugin(name, plugin, + additional_injects=additional_injects, + additional_inject_factories=additional_inject_factories) self.logger.info("Initialized {count} plugin(s)".format(count=len(self.plugin_implementations))) - def initialize_implementations_of_plugin(self, name, plugin, additional_injects=None, additional_inject_factories=None): - if not plugin.implementations: + def initialize_implementation_of_plugin(self, name, plugin, additional_injects=None, additional_inject_factories=None): + if plugin.implementation is None: return - for implementation in plugin.implementations: - self.initialize_implementation(name, plugin, implementation, - additional_injects=additional_injects, - additional_inject_factories=additional_inject_factories) + self.initialize_implementation(name, plugin, plugin.implementation, + additional_injects=additional_injects, + additional_inject_factories=additional_inject_factories) def initialize_implementation(self, name, plugin, implementation, additional_injects=None, additional_inject_factories=None): if additional_injects is None: @@ -720,14 +711,18 @@ class PluginManager(object): for arg, value in return_value.items(): setattr(implementation, "_" + arg, value) - implementation.initialize() + result = implementation.initialize() + if result is not None and not result: + self.logger.warn("Initialization of {name} returned False, disabling it".format(**locals())) + self._deactivate_plugin(name, plugin) + return except: self.logger.exception("Exception while initializing plugin {name}, disabling it".format(**locals())) self._deactivate_plugin(name, plugin) else: self.on_plugin_implementations_initialized(name, plugin) - self.logger.debug("Initialized {count} plugin mixin implementation(s)".format(count=len(self.plugin_implementations))) + self.logger.debug("Initialized plugin mixin implementation for plugin {name}".format(**locals())) def log_all_plugins(self, show_bundled=True, bundled_str=(" (bundled)", ""), show_location=True, location_str=" = {location}", show_enabled=True, enabled_str=(" ", "!")):