class EventStreamService(service.Service): def start(self): super(EventStreamService, self).start() LOG.debug("Starting evenstream thread") self.load_extenstions() self.gerrit = GerritEvents(self._map_gerrit) tpool.execute(self.gerrit.start) def stop(self): super(EventStreamService, self).stop() LOG.debug("Stopping eventstream") def load_extenstions(self): self.manager = DispatchExtensionManager("gerritstreamer.subscribers", lambda i: True) @staticmethod def filter_extension(ext, event): """ Filter what handler the event should be run on """ return isinstance(event, ext.plugin.events) def _from_gerrit(self, ext, event): ext = ext.plugin(self.gerrit) ext.dispatch(event) def _map_gerrit(self, event): LOG.info("Got event from Gerrit: %s" % event) self.manager.map(self.filter_extension, self._from_gerrit, event)
def load(self, invoke_on_load=True): self._manager = DispatchExtensionManager( "csm.plugin", self._check_plugin, invoke_on_load=invoke_on_load, invoke_args=(self._ctx, ), propagate_map_exceptions=True, on_load_failure_callback=self._on_load_failure, ) self._build_plugin_list()
def test_dispatch_map_should_invoke_filter_for_extensions(self): em = DispatchExtensionManager.make_test_instance( [test_extension, test_extension2]) filter_func = Mock(return_value=False) args = ('A', ) kw = {'big': 'Cheese'} em.map(filter_func, None, *args, **kw) filter_func.assert_any_call(test_extension, *args, **kw) filter_func.assert_any_call(test_extension2, *args, **kw)
def test_dispatch_map_should_invoke_filter_for_extensions(self): em = DispatchExtensionManager.make_test_instance([test_extension, test_extension2]) filter_func = Mock(return_value=False) args = ('A',) kw = {'big': 'Cheese'} em.map(filter_func, None, *args, **kw) filter_func.assert_any_call(test_extension, *args, **kw) filter_func.assert_any_call(test_extension2, *args, **kw)
def load(self, invoke_on_load=True): self._manager = DispatchExtensionManager( "csm.plugin", self._check_plugin, invoke_on_load=invoke_on_load, invoke_args=(self._ctx,), propagate_map_exceptions=True, on_load_failure_callback=self._on_load_failure, ) self._build_plugin_list()
def __init__(self, config: Config, invoke_on_load=False): self._logger = logging.getLogger(__name__) self.failed_plugins = list() self._disabled_plugins = config.plugins.disabled self._settings_initialized = False def check(ext: Extension): return self._check_extension(config, ext) self.weather = DriverManager( "blueweather.plugins.weather", config.plugins.weather_driver, on_load_failure_callback=self._on_load_fail ) self.plugins = ExtensionManager( "blueweather.plugins.plugin", on_load_failure_callback=self._on_load_fail ) self.api = EnabledExtensionManager( "blueweather.plugins.api", check_func=check, on_load_failure_callback=self._on_load_fail ) self.startup = EnabledExtensionManager( "blueweather.plugins.startup", check_func=check, on_load_failure_callback=self._on_load_fail ) self.settings = EnabledExtensionManager( "blueweather.plugins.settings", check_func=check, on_load_failure_callback=self._on_load_fail ) self.unitConversion = DispatchExtensionManager( "blueweather.plugins.unitconv", check_func=check, on_load_failure_callback=self._on_load_fail ) if self._logger.isEnabledFor(logging.INFO): extensions = self.getAllExtensions() for k, v in extensions.items(): extensions[k] = '\n\t'.join(v.keys()) extensions = '\n'.join( ["%s: \n\t%s" % (k, v) for k, v in extensions.items()] ) self._logger.info("Discovered Extensions: \n%s", extensions) if invoke_on_load: self.invoke()
def conversions(man: DispatchExtensionManager) -> Dict[str, Set[str]]: """ Get all the basic conversions :param man: UnitConversion Extension Manager :return: Possible Conversions """ units = dict() for name, conversions in man.map(lambda *args, **kwargs: True, UnitConversion.get_conversion_types): if conversions is None: continue for from_type, to_type in conversions: if from_type not in units: units[from_type] = set() units[from_type].add(to_type) return units
def __init__(self, ctx=None, invoke_on_load=True): self._ctx = PluginContext(ctx) try: self._platform = self._ctx.family except AttributeError: self._platform = None try: self._phase = self._ctx.phase except AttributeError: self._phase = None self._name = None self._manager = DispatchExtensionManager( "csm.plugin", self._check_plugin, invoke_on_load=invoke_on_load, invoke_args=(self._ctx,), propagate_map_exceptions=True, on_load_failure_callback=self._on_load_failure, ) self._build_plugin_list()
def test_dispatch_instance_should_use_supplied_extensions(self): extensions = [test_extension, test_extension2] em = DispatchExtensionManager.make_test_instance(extensions) self.assertEqual(extensions, em.extensions)
def test_dispatch_instance_should_use_supplied_extensions(self): extensions = [test_extension, test_extension2] em = DispatchExtensionManager.make_test_instance(extensions) self.assertEqual(extensions, em.extensions)
def load_extenstions(self): self.manager = DispatchExtensionManager("gerritstreamer.subscribers", lambda i: True)
def test_dispatch_instance_should_use_supplied_extensions(): extensions = [test_extension, test_extension2] em = DispatchExtensionManager.make_test_instance(extensions) assert extensions == em.extensions
class CSMPluginManager(object): def __init__(self, ctx=None, invoke_on_load=True): self._ctx = PluginContext(ctx) # The context contains device information after discovery phase # There is no need to load plugins which does not match the family and os try: self._platform = self._ctx.family except AttributeError: self._platform = None try: self._os = self._ctx.os_type except AttributeError: self._os = None self._phase = None self._name = None self.load(invoke_on_load=invoke_on_load) def load(self, invoke_on_load=True): self._manager = DispatchExtensionManager( "csm.plugin", self._check_plugin, invoke_on_load=invoke_on_load, invoke_args=(self._ctx,), propagate_map_exceptions=True, on_load_failure_callback=self._on_load_failure, ) self._build_plugin_list() def __getitem__(self, item): return self._manager.__getitem__(item) def _build_plugin_list(self): self.plugins = {} for ext in self._manager: self.plugins[ext.name] = { # 'package_name': ext.entry_point.dist.project_name, 'package_name': ext.entry_point.module_name.split(".")[0], 'name': ext.plugin.name, 'description': ext.plugin.__doc__, 'phases': ext.plugin.phases, 'platforms': ext.plugin.platforms, 'os': ext.plugin.os } def _filter_func(self, ext, *args, **kwargs): if self._platform and bool(ext.plugin.platforms) and self._platform not in ext.plugin.platforms: return False if self._phase and self._phase not in ext.plugin.phases: return False if self._name and ext.plugin.name not in self._name: return False # if detected os is set and plugin os set is not empty and detected os is not in plugin os then # plugin does not match if self._os and bool(ext.plugin.os) and self._os not in ext.plugin.os: return False return True def _dispatch(self, ext, *args, **kwargs): if self._filter_func(ext): self._ctx.current_plugin = None self._ctx.info("Dispatching: '{}'".format(ext.plugin.name)) self._ctx.post_status(ext.plugin.name) self._ctx.current_plugin = ext.plugin.name return True return False def _on_load_failure(self, manager, entry_point, exc): self._ctx.warning("Plugin load error: {}".format(entry_point)) self._ctx.warning("Exception: {}".format(exc)) def _check_plugin(self, ext, *args, **kwargs): attributes = ['name', 'phases', 'platforms', 'os'] plugin = ext.plugin for attribute in attributes: if not hasattr(plugin, attribute): self._ctx.warning("Attribute '{}' missing in plugin class: {}".format( attribute, ext.entry_point.module_name)) return False return self._filter_func(ext) def get_package_metadata(self, name): try: meta = pkginfo.Installed(name) except ValueError as e: print(e) return None return meta def _get_package_names(self): return self.get_package_metadata().keys() def dispatch(self, func): results = [] current_phase = self._ctx.phase if self._ctx.phase in auto_pre_phases: phase = "Pre-{}".format(self._ctx.phase) self.set_phase_filter(phase) self._ctx.info("Phase: {}".format(self._phase)) try: results = self._manager.map_method(self._dispatch, func) except NoMatches: self._ctx.warning("No {} plugins found".format(phase)) self._ctx.current_plugin = None self.set_phase_filter(current_phase) self._ctx.info("Phase: {}".format(self._phase)) try: results += self._manager.map_method(self._dispatch, func) except NoMatches: self._ctx.post_status("No plugins found for phase {}".format(self._phase)) self._ctx.error("No plugins found for phase {}".format(self._phase)) finally: self._ctx.info("CSM Plugin Manager Finished") self._ctx.finalize() self._ctx.current_plugin = None self._ctx.success = True return results def set_platform_filter(self, platform): self._platform = platform def set_phase_filter(self, phase): self._phase = phase def set_os_filter(self, os): self._os = os def set_name_filter(self, name): if isinstance(name, str) or isinstance(name, unicode): self._name = {name} elif isinstance(name, list): self._name = set(name) elif isinstance(name, set): self._name = name else: self._name = None
def test_dispatch_instance_should_use_supplied_extensions(): extensions = [test_extension, test_extension2] em = DispatchExtensionManager.make_test_instance(extensions) assert extensions == em.extensions
class CSMPluginManager(object): def __init__(self, ctx=None, invoke_on_load=True): self._ctx = PluginContext(ctx) # The context contains device information after discovery phase # There is no need to load plugins which does not match the family and os try: self._platform = self._ctx.family except AttributeError: self._platform = None try: self._os = self._ctx.os_type except AttributeError: self._os = None self._phase = None self._name = None self._vm = "xr" self.load(invoke_on_load=invoke_on_load) def load(self, invoke_on_load=True): self._manager = DispatchExtensionManager( "csm.plugin", self._check_plugin, invoke_on_load=invoke_on_load, invoke_args=(self._ctx, ), propagate_map_exceptions=True, on_load_failure_callback=self._on_load_failure, ) self._build_plugin_list() def __getitem__(self, item): return self._manager.__getitem__(item) def _build_plugin_list(self): self.plugins = {} for ext in self._manager: self.plugins[ext.name] = { # 'package_name': ext.entry_point.dist.project_name, 'package_name': ext.entry_point.module_name.split(".")[0], 'name': ext.plugin.name, 'description': ext.plugin.__doc__, 'phases': ext.plugin.phases, 'platforms': ext.plugin.platforms, 'os': ext.plugin.os } def _filter_func(self, ext, *args, **kwargs): if self._platform and self._platform not in ext.plugin.platforms: return False if self._phase and self._phase not in ext.plugin.phases: return False if self._name and ext.plugin.name not in self._name: return False # if detected os is set and plugin os set is not empty and detected os is not in plugin os then # plugin does not match if self._os and bool(ext.plugin.os) and self._os not in ext.plugin.os: return False return True def _dispatch(self, ext, *args, **kwargs): if self._filter_func(ext): self._ctx.current_plugin = None self._ctx.info("Dispatching: '{}'".format(ext.plugin.name)) self._ctx.post_status(ext.plugin.name) self._ctx.current_plugin = ext.plugin.name return True return False def _on_load_failure(self, manager, entry_point, exc): self._ctx.warning("Plugin load error: {}".format(entry_point)) self._ctx.warning("Exception: {}".format(exc)) def _check_plugin(self, ext, *args, **kwargs): attributes = ['name', 'phases', 'platforms', 'os'] plugin = ext.plugin for attribute in attributes: if not hasattr(plugin, attribute): self._ctx.warning( "Attribute '{}' missing in plugin class: {}".format( attribute, ext.entry_point.module_name)) return False return self._filter_func(ext) def get_package_metadata(self, name): try: meta = pkginfo.Installed(name) except ValueError as e: print(e) return None return meta def _get_package_names(self): return self.get_package_metadata().keys() def dispatch(self, func): try: self._ctx.connect() except ConnectionError as e: self._ctx.post_status(e.message) self._ctx.error(e.message) return False results = [] current_phase = self._ctx.phase if self._ctx.phase in auto_pre_phases: phase = "Pre-{}".format(self._ctx.phase) self.set_phase_filter(phase) self._ctx.info("Phase: {}".format(self._phase)) try: results = self._manager.map_method(self._dispatch, func) except NoMatches: self._ctx.warning("No {} plugins found".format(phase)) self._ctx.current_plugin = None self.set_phase_filter(current_phase) self._ctx.info("Phase: {}".format(self._phase)) try: results += self._manager.map_method(self._dispatch, func) except NoMatches: self._ctx.post_status("No plugins found for phase {}".format( self._phase)) self._ctx.error("No plugins found for phase {}".format( self._phase)) self._ctx.current_plugin = None self._ctx.success = True self._ctx.info("CSM Plugin Manager finished") self._ctx.disconnect() return results def set_platform_filter(self, platform): self._platform = platform def set_phase_filter(self, phase): self._phase = phase def set_os_filter(self, os): self._os = os def set_name_filter(self, name): if isinstance(name, str) or isinstance(name, unicode): self._name = {name} elif isinstance(name, list): self._name = set(name) elif isinstance(name, set): self._name = name else: self._name = None
class CSMPluginManager(object): def __init__(self, ctx=None, invoke_on_load=True): self._ctx = PluginContext(ctx) try: self._platform = self._ctx.family except AttributeError: self._platform = None try: self._phase = self._ctx.phase except AttributeError: self._phase = None self._name = None self._manager = DispatchExtensionManager( "csm.plugin", self._check_plugin, invoke_on_load=invoke_on_load, invoke_args=(self._ctx,), propagate_map_exceptions=True, on_load_failure_callback=self._on_load_failure, ) self._build_plugin_list() def __getitem__(self, item): return self._manager.__getitem__(item) def _build_plugin_list(self): self.plugins = {} for ext in self._manager: self.plugins[ext.name] = { # 'package_name': ext.entry_point.dist.project_name, 'package_name': ext.entry_point.module_name.split(".")[0], 'name': ext.plugin.name, 'description': ext.plugin.__doc__, 'phases': ext.plugin.phases, 'platforms': ext.plugin.platforms, } def _filter_func(self, ext, *args, **kwargs): print(ext.plugin.name) if self._platform and self._platform not in ext.plugin.platforms: return False if self._phase and self._phase not in ext.plugin.phases: return False if self._name and ext.plugin.name not in self._name: return False return True def _dispatch(self, ext, *args, **kwargs): if self._filter_func(ext): self._ctx.current_plugin = None self._ctx.info("Dispatching: '{}'".format(ext.plugin.name)) self._ctx.current_plugin = ext.plugin.name return True return False def _on_load_failure(self, manager, entry_point, exc): self._ctx.warning("Plugin load error: {}".format(entry_point)) self._ctx.warning("Exception: {}".format(exc)) def _check_plugin(self, ext, *args, **kwargs): attributes = ['name', 'phases', 'platforms'] plugin = ext.plugin for attribute in attributes: if not hasattr(plugin, attribute): self._ctx.warning("Attribute '{}' missing in plugin class".format(attribute)) return self._filter_func(ext) def _find_plugin_packages(self): packages = set() for ext in self._manager: dist = ext.entry_point.dist print(dist.__dict__) return list(packages) def get_package_metadata(self, name): try: meta = pkginfo.Installed(name) except ValueError as e: print(e) return None return meta def get_package_names(self): return self.get_package_metadata().keys() def dispatch(self, func): try: self._ctx.connect() except ConnectionError as e: self._ctx.post_status(e.message) self._ctx.error(e.message) return False results = [] if self._phase in auto_pre_phases: current_phase = self._phase phase = "Pre-{}".format(self._phase) self.set_phase_filter(phase) try: results = self._manager.map_method(self._dispatch, func) except NoMatches: self._ctx.warning("No {} plugins found".format(phase)) self._ctx.current_plugin = None self.set_phase_filter(current_phase) try: results += self._manager.map_method(self._dispatch, func) except NoMatches: self._ctx.post_status("No plugins found for phase {}".format(self._phase)) self._ctx.error("No plugins found for phase {}".format(self._phase)) self._ctx.current_plugin = None self._ctx.success = True return results def set_platform_filter(self, platform): self._platform = platform def set_phase_filter(self, phase): self._ctx.info("Phase: {}".format(phase)) self._phase = phase def set_name_filter(self, name): if isinstance(name, str) or isinstance(name, unicode): self._name = set((name,)) elif isinstance(name, list): self._name = set(name) elif isinstance(name, set): self._name = name else: self._name = None