def _run_reporting(self, results, objfile): #options options = dict() # Build the PluginManager reportingPluginManager = PluginManager() reportingPluginManager.setPluginPlaces(["reporting"]) reportingPluginManager.collectPlugins() # Trigger run from the "Reporting" plugins for pluginInfo in reportingPluginManager.getAllPlugins(): reportingModul = pluginInfo.plugin_object reportingModul.set_task(self.task) # Give it the the relevant reporting.conf section. try: options = self.cfgReporting.get(pluginInfo.name) reportingModul.set_options(options) except Exception: log.error("Reporting module %s not found in configuration file", pluginInfo.name) # If the processing module is disabled in the config, skip it. if not options.enabled: continue log.debug("Run Reporting: " + pluginInfo.name) try: # Run the Reporting module reportingModul.run(results, objfile) except Exception as e: log.exception("Failed to run the reporting module \"%s\":", reportingModul.__class__.__name__)
def main(): parser = argparse.ArgumentParser(description='Validates file format') parser.add_argument('files', nargs='+', help='files to be validated') parser.add_argument('--verbose', action='store_true', default=False, help='Shows help about validation') args = parser.parse_args() simplePluginManager = PluginManager() simplePluginManager.setPluginPlaces(["plugins"]) simplePluginManager.collectPlugins() for filename in args.files: supported = False for plugin in simplePluginManager.getAllPlugins(): methods = plugin.plugin_object if methods.should_manage(filename): supported = True try: plugin.plugin_object.validate(filename) print('%s sintax ok for %s' % (filename, plugin.name)) break except Exception as e: print('Invalid file %s for %s' % (filename, plugin.name)) if args.verbose: print(e) if not supported: print('%s cannot be validated' % filename)
def run_output_plugins(**kwargs): logger = logging.getLogger(__name__) logger.info("Begin run_output_plugins") simplePluginManager = PluginManager() logging.getLogger('yapsy').setLevel(logging.DEBUG) simplePluginManager.setCategoriesFilter({ "OutputResults": output_plugin }) # Tell it the default place(s) where to find plugins if logger: logger.debug("Plugin directories: %s" % (kwargs['output_plugin_directories'])) simplePluginManager.setPluginPlaces(kwargs['output_plugin_directories']) simplePluginManager.collectPlugins() plugin_cnt = 0 plugin_start_time = time.time() for plugin in simplePluginManager.getAllPlugins(): if logger: logger.info("Starting plugin: %s" % (plugin.name)) if plugin.plugin_object.initialize_plugin(details=plugin.details): plugin.plugin_object.emit(prediction_date=kwargs['prediction_date'].astimezone(timezone("US/Eastern")).strftime("%Y-%m-%d %H:%M:%S"), execution_date=kwargs['prediction_run_date'].strftime("%Y-%m-%d %H:%M:%S"), ensemble_tests=kwargs['site_model_ensemble']) plugin_cnt += 1 else: logger.error("Failed to initialize plugin: %s" % (plugin.name)) logger.debug("%d output plugins run in %f seconds" % (plugin_cnt, time.time() - plugin_start_time)) logger.info("Finished run_output_plugins")
def __run_reporting_generator(self): # options options = dict() # Build the PluginManager reportingPluginManager = PluginManager() reportingPluginManager.setPluginPlaces(["reporting"]) reportingPluginManager.collectPlugins() # Trigger run from the "Reporting" plugins for pluginInfo in sorted(reportingPluginManager.getAllPlugins(), key=lambda PluginInfo: PluginInfo.name): reportingModulG = pluginInfo.plugin_object reportingModulG.set_task(self.task) # Give it the the relevant reporting.conf section. try: options = self.cfgReporting.get(pluginInfo.name) reportingModulG.set_options(options) except Exception: log.error("Reporting module %s not found in configuration file", pluginInfo.name) # If the processing module is disabled in the config, skip it. if not options.enabled: continue log.debug("Run Reporting: " + pluginInfo.name) yield reportingModulG
def run(): logging.basicConfig(level=logging.INFO) os.chdir('/home/mjolnir/git/PURIKURA') # H A N D L E P L U G I N S pm = PluginManager() pm.setPluginPlaces(['./pyrikura/plugins']) pm.collectPlugins() for pi in pm.getAllPlugins(): logging.info('loading plugin %s', pi.name) pm.activatePluginByName(pi.name) brokers = {} nodes = build() head = nodes[0] for node in nodes: brokers[node] = node.load(pm) for node, broker in brokers.items(): for other in node._listening: broker.subscribe(brokers[other]) start = time.time() last_time = 0 shots = 0 last_trigger = 0 for broker in itertools.cycle(brokers.values()): broker.update()
def getBankRates(): # Load the plugins from the plugin directory. manager = PluginManager() # Server # manager.setPluginPlaces(["./dev/liborWatch/server/plugins"]) # Dev # manager.setPluginPlaces(["./plugins"]) # Local manager.setPluginPlaces(["./dev/NextLevelApps/liborWatch/server/plugins"]) manager.collectPlugins() today = datetime.date.today().strftime('%Y-%m-%d') # Loop round the plugins and get the bank rates for plugin in manager.getAllPlugins(): rates = plugin.plugin_object.getRates() print(rates); if(len(rates) != 10): print('Error: We did not get 10 rates from the plugin ' + plugin.name + ' - ' + str(len(rates))) return newRate = [] iCnt = 0; for rate in rates: iCnt = iCnt + 1 newRate.append((plugin.name, today, iCnt, rate)) # print('execute insert statement ' + plugin.name, str(today), str(iCnt), str(rate)) con = sqlite3.connect('liborWatch.sqlite') with con: cur = con.cursor() cur.execute("CREATE TABLE IF NOT EXISTS BankRate(id INTEGER PRIMARY KEY, bankName TEXT, date TEXT, fixedForYears INTEGER, rate REAL)") cur.executemany("INSERT INTO BankRate VALUES(NULL, ?, ?, ?, ?)", newRate)
class ProfilesManager(object): def __init__(self): self.plugin_location = [PROFILE_MODULE_DIR] self.pluginManager = PluginManager(plugin_info_ext="plugin") self.pluginManager.setPluginPlaces(self.plugin_location) self.pluginManager.collectPlugins() def modules_info(self): """ Get information with regards to each modules loaded. It includes author, category, copyright, description, details, name, version and website. :return: information of all modules loaded """ modules_info = {} for pluginInfo in self.pluginManager.getAllPlugins(): modules_info[pluginInfo.name] = pluginInfo return modules_info def configForms(self, device_serial, module_name=""): """ Get the configuration views of each modules to be displayed on web interface :return: dictionary of pluginInfo as key and form as value """ if module_name: plugin = self.pluginManager.getPluginByName(name=module_name) configForms = plugin.plugin_object.get_view() else: configForms = {} for pluginInfo in self.pluginManager.getAllPlugins(): form = pluginInfo.plugin_object.get_view() configForms[pluginInfo] = form return configForms def run_simulation(self,option, profile_name, duration, device_serial, package_name, session): """ Run profile simulation script :return: """ plugin = self.pluginManager.getPluginByName(name=profile_name) if option == RANDOM_INTERACTION: plugin.plugin_object.runSimulation(duration,package_name, random=True, device_serial=device_serial, session=session) elif option == SCRIPTED_PROFILE_INTERACTION: plugin.plugin_object.runSimulation(duration,package_name, random=False, device_serial=device_serial, session=session) def setup_device(self,module, params, device_serial): """ install profile apk and profile app data onto device :return: """ pluginInfo = self.pluginManager.getPluginByName(name=module) if pluginInfo.name == module: pluginInfo.plugin_object.prepare(params, device_serial) return True
def loadPlugins(pluginfldr,hivesdict): """ Enumerate plugins in the specified directory and return the populated plugin manager and a list of the compatible plugins. Compatibility is determined by checking if the required hives were loaded sucessfully. """ pluginmanager = PluginManager() pluginmanager.setPluginPlaces([pluginfldr]) pluginmanager.collectPlugins() print "" logging.info("[PLUGINS IDENTIFIED: %s]" % len(pluginmanager.getAllPlugins())) compat_plugins = list() incompat_plugins = list() for plugin in pluginmanager.getAllPlugins(): compat = 1 for req in plugin.plugin_object.getRequirements(): if (hivesdict[req][0] <> 1): compat = 0 break if compat: compat_plugins.append(plugin.name) else: incompat_plugins.append(plugin.name) logging.info(" [%s] Compatible Plugins:" % len(compat_plugins)) for plugin in compat_plugins: logging.info(" - %s" % plugin) logging.info(" [%s] Incompatible Plugins:" % len(incompat_plugins)) for plugin in incompat_plugins: logging.info(" - %s" % plugin) return pluginmanager, compat_plugins
class FakeSite(object): def __init__(self): self.template_system = self self.config = {"DISABLED_PLUGINS": [], "EXTRA_PLUGINS": [], "DEFAULT_LANG": "en"} self.EXTRA_PLUGINS = self.config["EXTRA_PLUGINS"] self.plugin_manager = PluginManager( categories_filter={ "Command": Command, "Task": Task, "LateTask": LateTask, "TemplateSystem": TemplateSystem, "PageCompiler": PageCompiler, "TaskMultiplier": TaskMultiplier, "RestExtension": RestExtension, } ) self.loghandlers = [STDERR_HANDLER] self.plugin_manager.setPluginInfoExtension("plugin") if sys.version_info[0] == 3: places = [os.path.join(os.path.dirname(utils.__file__), "plugins")] else: places = [os.path.join(os.path.dirname(utils.__file__), utils.sys_encode("plugins"))] self.plugin_manager.setPluginPlaces(places) self.plugin_manager.collectPlugins() self.timeline = [FakePost(title="Fake post", slug="fake-post")] def render_template(self, name, _, context): return '<img src="IMG.jpg">'
def get_plugins(): plugin_analyzer = PluginFileAnalyzerWithInfoFile(name="torrentstausanalyzer", extensions="plugin-manifest") plugin_locator = PluginFileLocator(analyzers=[plugin_analyzer]) extra_plugins_dir = config.getSettingsAsDict()["extra_plugins_dir"] plugin_extras = os.path.join(get_config_dir(), extra_plugins_dir) directories = [os.path.join(os.path.dirname(os.path.realpath(__file__)), "plugins")] ## ## Allow user defined plugins ## These plugins should be named as ## name.function.{py, plugin-manifest} ## Example: ## MyPlugin.onstart.py ## MyPlguin.onstart.plugin-manifest ## if os.path.exists(plugin_extras): directories.append(plugin_extras) manager = PluginManager(directories_list=directories, plugin_locator=plugin_locator) manager.collectPlugins() plugins = manager.getAllPlugins() # Activate all loaded plugins for pluginInfo in plugins: manager.activatePluginByName(pluginInfo.name) return plugins
def load_plugins(cls): manager = PluginManager() manager.setPluginPlaces([os.path.join(os.getcwd(), "plugins/")]) manager.collectPlugins() ret = manager.getAllPlugins() logger.info('Loaded {} plugins'.format(len(ret))) return ret
class FakeSite(object): def __init__(self): self.template_system = self self.config = { 'DISABLED_PLUGINS': [], 'EXTRA_PLUGINS': [], } self.EXTRA_PLUGINS = self.config['EXTRA_PLUGINS'] self.plugin_manager = PluginManager(categories_filter={ "Command": Command, "Task": Task, "LateTask": LateTask, "TemplateSystem": TemplateSystem, "PageCompiler": PageCompiler, "TaskMultiplier": TaskMultiplier, "RestExtension": RestExtension, }) self.plugin_manager.setPluginInfoExtension('plugin') if sys.version_info[0] == 3: places = [ os.path.join(os.path.dirname(utils.__file__), 'plugins'), ] else: places = [ os.path.join(os.path.dirname(utils.__file__), utils.sys_encode('plugins')), ] self.plugin_manager.setPluginPlaces(places) self.plugin_manager.collectPlugins() def render_template(self, name, _, context): return('<img src="IMG.jpg">')
class FurnivallApplication(tornado.web.Application): def __init__(self): """ Sets up the Tornado web server and loads all the init data """ # Init mongodb database self.dbconnection = Connection() self.db = self.dbconnection['furnivall'] # Init plugins self.plugin_manager = PluginManager() self.plugin_manager.setPluginPlaces(["./plugins"]) self.plugin_manager.collectPlugins() print "Loaded plugins:" for plugin_info in self.plugin_manager.getAllPlugins(): print ' * ' + plugin_info.name # Init routes urls = [ ] + Route.routes() settings = dict( static_path = os.path.join(data_dir, "static"), template_path = os.path.join(data_dir, "templates"), xsrf_cookies = False, cookie_secret = "11oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1ao/Vo=", ) tornado.web.Application.__init__(self, urls, **settings)
class AlgorithmManager(): def __init__(self): self._pluginManager = PluginManager() self._pluginManager.setPluginPlaces(config.PLUGIN_DIR) self._pluginManager.collectPlugins() for pluginInfo in self._pluginManager.getAllPlugins(): self._pluginManager.activatePluginByName(pluginInfo.name) def get_alg_names(self): for plugin in self._pluginManager.getAllPlugins(): plugin.plugin_object.print_name() def execute_calc(self, data): run = [] if not self.__is_sequence(data): raise Exception('Data is no array!') for alg in self._pluginManager.getAllPlugins(): result, prop = alg.plugin_object.calc(data) run.append({alg.name : (result, prop)}) return run def __is_sequence(self, arg): return (not hasattr(arg, "strip") and hasattr(arg, "__getitem__") or hasattr(arg, "__iter__"))
def loadPlugins(root_folder, plugin_name, categories_filter): from yapsy.PluginManager import PluginManager plugin_dirs = [] plugin_dirs.append(configuration.fabfile_basedir + '/.fabalicious/plugins') plugin_dirs.append(expanduser("~") + '/.fabalicious/plugins') plugin_dirs.append(root_folder + '/plugins') log.debug("Looking for %s-plugins in %s" % (plugin_name, ", ".join(plugin_dirs))) manager = PluginManager() manager.setPluginPlaces(plugin_dirs) manager.setCategoriesFilter(categories_filter) manager.collectPlugins() # Activate all loaded plugins for pluginInfo in manager.getAllPlugins(): manager.activatePluginByName(pluginInfo.name) result = {} for plugin in manager.getAllPlugins(): if hasattr(plugin.plugin_object, 'aliases') and isinstance(plugin.plugin_object.aliases, list): for alias in plugin.plugin_object.aliases: result[alias] = plugin.plugin_object elif hasattr(plugin.plugin_object, 'alias'): result[plugin.plugin_object.alias] = plugin.plugin_object else: result[plugin.name] = plugin.plugin_object return result
def pane_data(self): list = [] # Holds the filter tuples (name, activated=True) # Get the default plugin directory, using XML path = os.path.expanduser("~") xml = xml_controller.Controller(path + "\.cxvrc.xml") xml.load_file() if os.path.exists(os.path.expanduser("~") + os.sep + "plugins"): default_dir = os.path.expanduser("~") + os.sep + "plugins" else: default_dir = self.dicom_view.get_main_dir() + os.sep + "plugins" if xml.get_plugin_directory() == "" or xml.get_plugin_directory() is None: directory = [default_dir] else: directory = [default_dir, xml.get_plugin_directory()] # Load the plugins from the default plugin directory. manager = PluginManager() manager.setPluginPlaces(directory) manager.setPluginInfoExtension("plugin") manager.collectPlugins() # Append tuple with plugin name and enabled=True to the list for plugin in manager.getAllPlugins(): list.append((plugin.name, True)) return list
def runCrawler(): mapURL = {} cfgCrawler = Config(os.path.join(RAGPICKER_ROOT, 'config', 'crawler.conf')) # Build the PluginManager crawlerPluginManager = PluginManager() crawlerPluginManager.setPluginPlaces(["crawler"]) crawlerPluginManager.collectPlugins() # Trigger run from the "Crawler" plugins for pluginInfo in sorted(crawlerPluginManager.getAllPlugins(), key=lambda PluginInfo: PluginInfo.name): crawlerModul = pluginInfo.plugin_object # Config for crawler module try: options = cfgCrawler.get(pluginInfo.name) crawlerModul.set_options(options) except Exception: log.error("Crawler module %s not found in configuration file", pluginInfo.name) # If the crawler module is disabled in the config, skip it. if not options.enabled: continue try: log.debug("Run Crawler: " + pluginInfo.name) returnMap = crawlerModul.run() mapURL.update(returnMap) except Exception as e: log.error('Error (%s) in %s', e, pluginInfo.name) return mapURL
def group_dashboard(request, group_id): # check user is allowed to access this user = request.user config_installed = 'config' in settings.INSTALLED_APPS user_level = user.userprofile.level machine_group = get_object_or_404(MachineGroup, pk=group_id) business_unit = machine_group.business_unit if business_unit not in user.businessunit_set.all(): if user_level != 'GA': return redirect(index) if user_level == 'GA' or user_level == 'RW': is_editor = True else: is_editor = False machines = machine_group.machine_set.all() # Build the manager manager = PluginManager() # Tell it the default place(s) where to find plugins manager.setPluginPlaces([settings.PLUGIN_DIR, os.path.join(settings.PROJECT_DIR, 'server/plugins')]) # Load all plugins manager.collectPlugins() output = [] for plugin in manager.getAllPlugins(): data = {} data['name'] = plugin.name (data['html'], data['width']) = plugin.plugin_object.show_widget('group_dashboard', machines, machine_group.id) output.append(data) output = utils.orderPluginOutput(output, 'group_dashboard', machine_group.id) c = {'user': request.user, 'machine_group': machine_group, 'user_level': user_level, 'is_editor': is_editor, 'business_unit': business_unit, 'output':output, 'config_installed':config_installed, 'request':request} return render_to_response('server/group_dashboard.html', c, context_instance=RequestContext(request))
def main(): # Read configuration config = SafeConfigParser( defaults = {'port':'15915', 'plugins_directory':'./plugins', 'plugins_enabled':'', }) config.read(['./conf/cm15d.conf', '/etc/cm15d.conf', '/etc/cm15d/cm15d.conf', '/etc/cm15d/conf.d/local.conf', ]) # Activate enabled plugins plugins = PluginManager() plugins.setPluginPlaces(config.get('cm15d', 'plugins_directory').split(',')) plugins.collectPlugins() plugins_enabled = config.get('cm15d', 'plugins_enabled').split(',') for plugin in plugins.getAllPlugins(): if plugin.name in plugins_enabled: plugins.activatePluginByName(plugin.name) print("Plugin %s enabled" % plugin.name) # Start server port = int(config.get('cm15d', 'port')) endpoint = TCP4ServerEndpoint(reactor, port) endpoint.listen(CM15DaemonFactory(plugins)) print("Server listening on port %s" % port) reactor.run()
def collect_data(self, **kwargs): self.logger.info("Begin collect_data") simplePluginManager = PluginManager() logging.getLogger('yapsy').setLevel(logging.DEBUG) simplePluginManager.setCategoriesFilter({ "DataCollector": data_collector_plugin }) # Tell it the default place(s) where to find plugins self.logger.debug("Plugin directories: %s" % (kwargs['data_collector_plugin_directories'])) simplePluginManager.setPluginPlaces(kwargs['data_collector_plugin_directories']) simplePluginManager.collectPlugins() plugin_cnt = 0 plugin_start_time = time.time() for plugin in simplePluginManager.getAllPlugins(): self.logger.info("Starting plugin: %s" % (plugin.name)) if plugin.plugin_object.initialize_plugin(details=plugin.details): plugin.plugin_object.start() else: self.logger.error("Failed to initialize plugin: %s" % (plugin.name)) plugin_cnt += 1 #Wait for the plugings to finish up. self.logger.info("Waiting for %d plugins to complete." % (plugin_cnt)) for plugin in simplePluginManager.getAllPlugins(): plugin.plugin_object.join() self.logger.info("%d Plugins completed in %f seconds" % (plugin_cnt, time.time() - plugin_start_time))
def init_manager(): anl = PluginFileAnalyzerMathingRegex('custom_res_handler_plugins', r'^[A-Za-z0-9]+\.py$') res = PluginFileLocator(plugin_info_cls=CFCustomResourceHandler) res.setAnalyzers([anl]) manager = PluginManager(plugin_locator=res, categories_filter={'CFHandlers' : CFCustomResourceHandler}) manager.setPluginPlaces([dirname(__file__) + '/plugins']) manager.collectPlugins() return manager
class BotInteraction(): def __init__(self, config): self.channel = config['channel'] self.nickname = config['nickname'] self.prompt = config['prompt'] self.parts = "" self.ping = "" self.username = "" self.message = "" self.manager = PluginManager() self.manager.setPluginPlaces(["plugins"]) self.manager.collectPlugins() def handle_line(self, username, message, parts): print(username + ": " + message) if self.nickname not in parts[1] and message[0:1] == self.prompt: message = message.replace(">", " ").split(None, 1) for plugin in self.manager.getAllPlugins(): # Collect all plugins try: # Message[0] - search plugin_name plugin_yapsy = self.manager.getPluginByName(message[0]) command = [] # If the message has arguments - message[1] add to command if len(message) == 2: command = message[1] # To found plugin send arguments. return plugin_yapsy.plugin_object.execute(self.channel, username, command) except: continue def check_ping(self, line): if line.find("PING") != -1: # If server pings then pong line = string.split(line, " ") self.ping = "PONG " + line[1] else: self.ping = "" self.parts = string.split(line, ":") if "QUIT" not in self.parts[1] and \ "JOIN" not in self.parts[1] and \ "PART" not in self.parts[1]: try: # Sets the message variable to the actual message sent self.message = self.parts[2][:len(self.parts[2]) - 1] except: self.message = "" # Sets the username variable to the actual username usernamesplit = string.split(self.parts[1], "!") self.username = usernamesplit[0]
def main(): # Load the plugins from the plugin directory. manager = PluginManager(plugin_info_ext='cfg') manager.setPluginPlaces(["../plugins"]) manager.collectPlugins() # Loop round the plugins and print their names. for plugin in manager.getAllPlugins(): plugin.plugin_object.print_name()
class Plugins(): ''' Plugins ''' def __init__(self): ''' Constructor ''' super(Plugins, self).__init__() self.write_tab_dock_plugin_dict = {} self.write_panel_dock_plugin_dict = {} # Build the manager self._plugin_manager = PluginManager() # List all sub-directories of "plugins" plugin_path = os.path.sep.join([os.getcwd(), "plugins"]) plugin_places = [plugin_path] for dirname, dirnames, filenames in os.walk(plugin_path): # print path to all subdirectories first. for subdirname in dirnames: plugin_places.append(os.path.join(dirname, subdirname)) # Tell it the default place(s) where to find plugins self._plugin_manager.setPluginPlaces(plugin_places) sys.path.append(plugin_path) # Define the various categories corresponding to the different # kinds of plugins you have defined self._plugin_manager.setCategoriesFilter({ "GuiWriteTabDockPlugin": GuiWriteTabDockPlugin, "GuiWritePanelDockPlugin": GuiWritePanelDockPlugin }) self._plugin_manager.collectPlugins() self.load_plugins( ["GuiWriteTabDockPlugin", "GuiWritePanelDockPlugin"]) def load_plugins(self, categories): ''' function:: load_plugins(categories) :param categories: list ''' for category in categories: for pluginInfo in self._plugin_manager.getPluginsOfCategory(category): setattr(self, pluginInfo.plugin_object.gui_class( ).__name__, pluginInfo.plugin_object.gui_class()) if category is "GuiWriteTabDockPlugin": self.write_tab_dock_plugin_dict[pluginInfo.plugin_object.gui_class().dock_name] \ = pluginInfo.plugin_object.gui_class() if category is "GuiWritePanelDockPlugin": self.write_panel_dock_plugin_dict[pluginInfo.plugin_object.gui_class().dock_name] \ = pluginInfo.plugin_object.gui_class()
def main(): # Create plugin manager manager = PluginManager() manager.setPluginPlaces([PluginFolder]) # Collect plugins manager.collectPlugins() for plugin in manager.getAllPlugins(): plugin.plugin_object.say_hello()
def index(request): # Get the current user's Business Units user = request.user # Count the number of users. If there is only one, they need to be made a GA if User.objects.count() == 1: # The first user created by syncdb won't have a profile. If there isn't one, make sure they get one. try: profile = UserProfile.objects.get(user=user) except UserProfile.DoesNotExist: profile = UserProfile(user=user) profile.level = "GA" profile.save() user_level = user.userprofile.level now = datetime.now() hour_ago = now - timedelta(hours=1) today = date.today() week_ago = today - timedelta(days=7) month_ago = today - timedelta(days=30) three_months_ago = today - timedelta(days=90) if user_level != "GA": # user has many BU's display them all in a friendly manner business_units = user.businessunit_set.all() if user.businessunit_set.count() == 1: # user only has one BU, redirect to it for bu in user.businessunit_set.all(): return redirect("server.views.bu_dashboard", bu_id=bu.id) break else: machines = Machine.objects.all() # Build the manager manager = PluginManager() # Tell it the default place(s) where to find plugins manager.setPluginPlaces([settings.PLUGIN_DIR, os.path.join(settings.PROJECT_DIR, "server/plugins")]) # Load all plugins manager.collectPlugins() output = [] # Loop round the plugins and print their names. for plugin in manager.getAllPlugins(): data = {} data["name"] = plugin.name (data["html"], data["width"]) = plugin.plugin_object.show_widget("front", machines) # output.append(plugin.plugin_object.show_widget('front')) output.append(data) output = utils.orderPluginOutput(output) # get the user level - if they're a global admin, show all of the machines. If not, show only the machines they have access to business_units = BusinessUnit.objects.all() config_installed = "config" in settings.INSTALLED_APPS c = { "user": request.user, "business_units": business_units, "output": output, "config_installed": config_installed, } return render_to_response("server/index.html", c, context_instance=RequestContext(request))
class PluginHandler: def __init__(self): self._plugin_manager = PluginManager() self._category_active = {"Modifier": False, "Analyzer": False, "Comparator": False} self._plugin_from_category = {"Modifier": [], "Analyzer": [], "Comparator": []} self._modifier_plugins = [] self._analyzer_plugins = [] self._collect_all_plugins() def _collect_all_plugins(self): self._plugin_manager.setPluginPlaces( ["hugin/analyze/modifier", "hugin/analyze/analyzer", "hugin/analyze/comparator"] ) # setting filter categories for pluginmanager self._plugin_manager.setCategoriesFilter( { # movie metadata provider "Modifier": IModifier, # movie metadata provider "Comparator": IComparator, # sub metadata provider "Analyzer": IAnalyzer, } ) self._plugin_manager.collectPlugins() def activate_plugins_by_category(self, category): self._toggle_activate_plugins_by_category(category) def deactivate_plugins_by_category(self, category): self._toggle_activate_plugins_by_category(category) def _toggle_activate_plugins_by_category(self, category): plugins = self._plugin_manager.getPluginsOfCategory(category) is_active = self._category_active[category] for pluginInfo in plugins: if is_active: self._plugin_manager.deactivatePluginByName(name=pluginInfo.name, category=category) self._plugin_from_category[category].remove(pluginInfo) else: self._plugin_manager.activatePluginByName(name=pluginInfo.name, category=category) self._plugin_from_category[category].append(pluginInfo) self._category_active[category] = not is_active def get_plugins_from_category(self, category): plugins = [] for plugin in self._plugin_from_category[category]: plugin.plugin_object.name = plugin.name plugin.plugin_object.description = plugin.description plugins.append(plugin.plugin_object) return plugins def is_activated(self, category): """ True if category is activated. """ return self._category_active[category]
def plugins(): # Load the plugins from the plugin directory. manager = PluginManager() manager.setPluginPlaces(["plugins"]) manager.collectPlugins() # Loop round the plugins and print their names. for p in manager.getAllPlugins(): p.plugin_object.print_name() p.plugin_object.activate()
def main(): # Load the plugins from the plugin directory. manager = PluginManager() manager.setPluginPlaces(["orthos/plugins"]) manager.collectPlugins() # Loop round the plugins and print their names. for plugin in manager.getAllPlugins(): print "Fo" plugin.plugin_object.print_name()
def main(): """docstring for main""" # Load the plugins from the plugin directory. manager = PluginManager() manager.setPluginPlaces(["plugins"]) manager.collectPlugins() # Loop round the plugins executing them. for plugin in manager.getAllPlugins(): plugin.plugin_object.run()
def initialize_plugins(self): self.__log.info("Collecting and loading plugins") try: plugin_manager = PluginManager() # TODO: change plugin descriptor extensions, plugin_manager.setPluginInfoExtension(AGENT_PLUGIN_EXT) plugin_manager.setCategoriesFilter({ CARTRIDGE_AGENT_PLUGIN: ICartridgeAgentPlugin, ARTIFACT_MGT_PLUGIN: IArtifactManagementPlugin }) plugin_manager.setPluginPlaces( [self.__config.read_property(constants.PLUGINS_DIR)]) plugin_manager.collectPlugins() # activate cartridge agent plugins plugins = plugin_manager.getPluginsOfCategory( CARTRIDGE_AGENT_PLUGIN) grouped_plugins = {} for plugin_info in plugins: self.__log.debug("Found plugin [%s] at [%s]" % (plugin_info.name, plugin_info.path)) plugin_manager.activatePluginByName(plugin_info.name) self.__log.info("Activated plugin [%s]" % plugin_info.name) mapped_events = plugin_info.description.split(",") for mapped_event in mapped_events: if mapped_event.strip() != "": if grouped_plugins.get(mapped_event) is None: grouped_plugins[mapped_event] = [] grouped_plugins[mapped_event].append(plugin_info) # activate artifact management plugins artifact_mgt_plugins = plugin_manager.getPluginsOfCategory( ARTIFACT_MGT_PLUGIN) for plugin_info in artifact_mgt_plugins: self.__log.debug( "Found artifact management plugin [%s] at [%s]" % (plugin_info.name, plugin_info.path)) plugin_manager.activatePluginByName(plugin_info.name) self.__log.info("Activated artifact management plugin [%s]" % plugin_info.name) return plugin_manager, grouped_plugins, artifact_mgt_plugins except ParameterNotFoundException as e: self.__log.exception( "Could not load plugins. Plugins directory not set: %s" % e) return None, None, None except Exception as e: self.__log.exception("Error while loading plugin: %s" % e) return None, None, None
def bu_dashboard(request, bu_id): user = request.user user_level = user.userprofile.level business_unit = get_object_or_404(BusinessUnit, pk=bu_id) bu = business_unit config_installed = 'config' in settings.INSTALLED_APPS if business_unit not in user.businessunit_set.all() and user_level != 'GA': print 'not letting you in ' + user_level return redirect(index) # Get the groups within the Business Unit machine_groups = business_unit.machinegroup_set.all() if user_level == 'GA' or user_level == 'RW': is_editor = True else: is_editor = False machines = utils.getBUmachines(bu_id) now = datetime.now() hour_ago = now - timedelta(hours=1) today = date.today() week_ago = today - timedelta(days=7) month_ago = today - timedelta(days=30) three_months_ago = today - timedelta(days=90) # Build the manager manager = PluginManager() # Tell it the default place(s) where to find plugins manager.setPluginPlaces([ settings.PLUGIN_DIR, os.path.join(settings.PROJECT_DIR, 'server/plugins') ]) # Load all plugins manager.collectPlugins() output = [] # Loop round the plugins and print their names. for plugin in manager.getAllPlugins(): data = {} data['name'] = plugin.name (data['html'], data['width']) = plugin.plugin_object.show_widget( 'bu_dashboard', machines, bu.id) output.append(data) output = utils.orderPluginOutput(output, 'bu_dashboard', bu.id) c = { 'user': request.user, 'machine_groups': machine_groups, 'is_editor': is_editor, 'business_unit': business_unit, 'user_level': user_level, 'output': output, 'config_installed': config_installed } return render_to_response('server/bu_dashboard.html', c, context_instance=RequestContext(request))
def machine_list(request, pluginName, data, page='front', theID=None): user = request.user title = None # Build the manager manager = PluginManager() # Tell it the default place(s) where to find plugins manager.setPluginPlaces([ settings.PLUGIN_DIR, os.path.join(settings.PROJECT_DIR, 'server/plugins') ]) # Load all plugins manager.collectPlugins() # get a list of machines (either from the BU or the group) if page == 'front': # get all machines machines = Machine.objects.all() if page == 'bu_dashboard': # only get machines for that BU # Need to make sure the user is allowed to see this business_unit = get_object_or_404(BusinessUnit, pk=theID) machine_groups = MachineGroup.objects.filter( business_unit=business_unit).prefetch_related('machine_set').all() if machine_groups.count() != 0: machines_unsorted = machine_groups[0].machine_set.all() for machine_group in machine_groups[1:]: machines_unsorted = machines_unsorted | machine_group.machine_set.all( ) else: machines_unsorted = None machines = machines_unsorted if page == 'group_dashboard': # only get machines from that group machine_group = get_object_or_404(MachineGroup, pk=theID) # check that the user has access to this machines = Machine.objects.filter(machine_group=machine_group) # send the machines and the data to the plugin for plugin in manager.getAllPlugins(): if plugin.name == pluginName: (machines, title) = plugin.plugin_object.filter_machines(machines, data) c = { 'user': user, 'machines': machines, 'req_type': page, 'title': title, 'bu_id': theID, 'request': request } return render_to_response('server/overview_list_all.html', c, context_instance=RequestContext(request))
def init_manager(): anl = PluginFileAnalyzerMathingRegex('custom_res_handler_plugins', r'^[A-Za-z0-9]+\.py$') res = PluginFileLocator(plugin_info_cls=CFCustomResourceHandler) res.setAnalyzers([anl]) manager = PluginManager( plugin_locator=res, categories_filter={'CFHandlers': CFCustomResourceHandler}) manager.setPluginPlaces([dirname(__file__) + '/plugins']) manager.collectPlugins() return manager
def main(): global p # Load the plugins from the plugin directory. manager = PluginManager() manager.setPluginPlaces(["plugins"]) manager.collectPlugins() # Loop round the plugins and print their names. for plugin in manager.getAllPlugins(): p = plugin.plugin_object.print_name() print("path is:", p) plugin.plugin_object.convert_from_xml(p)
def main(): # Load the plugins from the plugin directory. manager = PluginManager() manager.setPluginPlaces(["storage_plugin/consul"]) manager.collectPlugins() # Loop round the plugins and print their names. for plugin in manager.getAllPlugins(): # plugin.plugin_object.put_record('ikepolicies',Dog('12345','hello')) plugin.plugin_object.get_record('ikepolicies', '12345') plugin.plugin_object.get_record('ikepolicies', 'hello', 'name')
def get_plugins(category_filter={}, plugin_places=['plugins']): pm = PluginManager(plugin_info_ext='plugin') # Normalize the paths to the location of this file. # XXX-ricarkol: there has to be a better way to do this. plugin_places = [misc.execution_path(x) for x in plugin_places] pm.setPluginPlaces(plugin_places) pm.setCategoriesFilter(category_filter) pm.collectPlugins() return pm.getAllPlugins()
class FakeSite(object): def __init__(self): self.template_system = self self.invariant = False self.config = { 'DISABLED_PLUGINS': [], 'EXTRA_PLUGINS': [], 'EXTRA_PLUGINS_DIRS': [extra_v6_plugin_dir], 'DEFAULT_LANG': 'en', 'MARKDOWN_EXTENSIONS': ['fenced_code', 'codehilite'], 'TRANSLATIONS_PATTERN': '{path}.{lang}.{ext}', 'LISTINGS_FOLDERS': {}, } self.EXTRA_PLUGINS = self.config['EXTRA_PLUGINS'] self.plugin_manager = PluginManager( categories_filter={ "Command": Command, "Task": Task, "LateTask": LateTask, "TemplateSystem": TemplateSystem, "PageCompiler": PageCompiler, "TaskMultiplier": TaskMultiplier, "RestExtension": RestExtension, "MarkdownExtension": MarkdownExtension, }) self.loghandlers = [nikola.utils.STDERR_HANDLER] self.plugin_manager.setPluginInfoExtension('plugin') extra_plugins_dirs = self.config['EXTRA_PLUGINS_DIRS'] if sys.version_info[0] == 3: places = [ os.path.join(os.path.dirname(nikola.utils.__file__), 'plugins'), ] + [path for path in extra_plugins_dirs if path] else: places = [ os.path.join(os.path.dirname(nikola.utils.__file__), nikola.utils.sys_encode('plugins')), ] + [ nikola.utils.sys_encode(path) for path in extra_plugins_dirs if path ] self.plugin_manager.setPluginPlaces(places) self.plugin_manager.collectPlugins() self.timeline = [FakePost(title='Fake post', slug='fake-post')] self.debug = True self.rst_transforms = [] # This is to make plugin initialization happy self.template_system = self self.name = 'mako' def render_template(self, name, _, context): return ('<img src="IMG.jpg">')
def disabled_plugins(plugin_kind='main'): enabled_plugins = Plugin.objects.all() # Build the manager manager = PluginManager() # Tell it the default place(s) where to find plugins manager.setPluginPlaces([ settings.PLUGIN_DIR, os.path.join(settings.PROJECT_DIR, 'server/plugins') ]) # Load all plugins manager.collectPlugins() output = [] if plugin_kind == 'main': for plugin in manager.getAllPlugins(): try: plugin_type = plugin.plugin_object.plugin_type() except: plugin_type = 'builtin' if plugin_type == 'builtin': try: item = Plugin.objects.get(name=plugin.name) except Plugin.DoesNotExist: output.append(plugin.name) if plugin_kind == 'report': for plugin in manager.getAllPlugins(): try: plugin_type = plugin.plugin_object.plugin_type() except: plugin_type = 'builtin' if plugin_type == 'report': try: item = Report.objects.get(name=plugin.name) except Report.DoesNotExist: output.append(plugin.name) if plugin_kind == 'machine_detail': for plugin in manager.getAllPlugins(): try: plugin_type = plugin.plugin_object.plugin_type() except: plugin_type = 'builtin' if plugin_type == 'machine_detail': try: item = MachineDetailPlugin.objects.get(name=plugin.name) except MachineDetailPlugin.DoesNotExist: output.append(plugin.name) return output
def load_plugin(self): manager = PluginManager() manager.setPluginPlaces(["plugins"]) manager.collectPlugins() # Loop round the plugins and print their names. for plugin in manager.getAllPlugins(): print("==========> ", format(plugin.plugin_object)) #p="C:\Python34\directory1" #print("path is:======>",p) self.p1 = plugin.plugin_object.print_name() print(self.p1) self.p2 = PluginOne() self.p2.g()
def parse_url(url): plugins_folder = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'plugins') manager = PluginManager() manager.setPluginPlaces([plugins_folder]) manager.collectPlugins() plugins = [ x for x in manager.getAllPlugins() if hasattr(x.plugin_object, 'parse_url') ] for plugin in plugins: for item in plugin.plugin_object.parse_url(url): yield item
def index(request): # Get the current user's Business Units user = request.user # Count the number of users. If there is only one, they need to be made a GA if User.objects.count() == 1: # The first user created by syncdb won't have a profile. If there isn't one, make sure they get one. try: profile = UserProfile.objects.get(user=user) except UserProfile.DoesNotExist: profile = UserProfile(user=user) profile.level = 'GA' profile.save() user_level = user.userprofile.level now = datetime.now() hour_ago = now - timedelta(hours=1) today = date.today() week_ago = today - timedelta(days=7) month_ago = today - timedelta(days=30) three_months_ago = today - timedelta(days=90) if user_level != 'GA': # user has many BU's display them all in a friendly manner business_units = user.businessunit_set.all() if user.businessunit_set.count() == 1: # user only has one BU, redirect to it for bu in user.businessunit_set.all(): return redirect('server.views.bu_dashboard', bu_id=bu.id) break else: machines = Machine.objects.all() # Build the manager manager = PluginManager() # Tell it the default place(s) where to find plugins manager.setPluginPlaces([settings.PLUGIN_DIR, os.path.join(settings.PROJECT_DIR, 'server/plugins')]) # Load all plugins manager.collectPlugins() output = [] # Loop round the plugins and print their names. for plugin in manager.getAllPlugins(): data = {} data['name'] = plugin.name (data['html'], data['width']) = plugin.plugin_object.show_widget('front', machines) #output.append(plugin.plugin_object.show_widget('front')) output.append(data) output = utils.orderPluginOutput(output) # get the user level - if they're a global admin, show all of the machines. If not, show only the machines they have access to business_units = BusinessUnit.objects.all() c = {'user': request.user, 'business_units': business_units, 'output': output} return render_to_response('server/index.html', c, context_instance=RequestContext(request))
def create_plugin_manager(category_filter, plugin_place): """ Creates a PluginManager object from the given folder according to the given filter :param category_filter: :param plugin_place: :return: :rtype: PluginManager """ plugin_manager = PluginManager() plugin_manager.setCategoriesFilter(category_filter) plugin_manager.setPluginPlaces([plugin_place]) plugin_manager.collectPlugins() return plugin_manager
def ConfigurePluginManager(categories=None, pluginLocation=None): if categories is None: categories = dict(Test=ITestPlugin, DAQ=IDAQPlugin, App=IAppPlugin, Decoder=IDecoderPlugin) if pluginLocation is None: pluginLocation = ["plugins"] manager = PluginManager() # todo: plugin directory and categories should be set some other way (command line arg parsing?) manager.setPluginPlaces(pluginLocation) manager.setCategoriesFilter(categories) manager.collectPlugins() return manager
def output_results(self, **kwargs): self.logger.info("Begin run_output_plugins") simplePluginManager = PluginManager() logging.getLogger('yapsy').setLevel(logging.DEBUG) simplePluginManager.setCategoriesFilter( {"OutputResults": data_collector_plugin}) # Tell it the default place(s) where to find plugins self.logger.debug("Plugin directories: %s" % (kwargs['output_plugin_directories'])) simplePluginManager.setPluginPlaces( kwargs['output_plugin_directories']) yapsy_logger = logging.getLogger('yapsy') yapsy_logger.setLevel(logging.DEBUG) # yapsy_logger.parent.level = logging.DEBUG yapsy_logger.disabled = False simplePluginManager.collectPlugins() plugin_cnt = 0 plugin_start_time = time.time() for plugin in simplePluginManager.getAllPlugins(): try: self.logger.info("Starting plugin: %s" % (plugin.name)) if plugin.plugin_object.initialize_plugin( details=plugin.details, prediction_date=kwargs['prediction_date'].astimezone( timezone("US/Eastern")).strftime( "%Y-%m-%d %H:%M:%S"), execution_date=kwargs['prediction_run_date'].strftime( "%Y-%m-%d %H:%M:%S"), ensemble_tests=kwargs['site_model_ensemble']): plugin.plugin_object.start() plugin_cnt += 1 else: self.logger.error("Failed to initialize plugin: %s" % (plugin.details)) except Exception as e: self.logger.exception(e) #Wait for the plugings to finish up. self.logger.info("Waiting for %d plugins to complete." % (plugin_cnt)) for plugin in simplePluginManager.getAllPlugins(): plugin.plugin_object.join() plugin.plugin_object.finalize() self.logger.debug("%d output plugins run in %f seconds" % (plugin_cnt, time.time() - plugin_start_time)) self.logger.info("Finished output_results")
def testMultipleCategoriesForASamePlugin(self): """ Test that associating a plugin to multiple categories works as expected. """ class AnotherPluginIfce(object): def __init__(self): pass def activate(self): pass def deactivate(self): pass spm = PluginManager(categories_filter={ "Default": IPlugin, "IP": IPlugin, "Other": AnotherPluginIfce, }, directories_list=[ os.path.join( os.path.dirname(os.path.abspath(__file__)), "plugins") ]) # load the plugins that may be found spm.collectPlugins() # check that the getCategories works self.assertEqual(len(spm.getCategories()), 3) categories = spm.getCategories() self.assertTrue("Default" in categories) # check the getPluginsOfCategory self.assertEqual(len(spm.getPluginsOfCategory("Default")), 1) plugin_info = spm.getPluginsOfCategory("Default")[0] self.assertTrue("Default" in plugin_info.categories) self.assertTrue("IP" in plugin_info.categories) self.assertTrue("IP" in categories) # check the getPluginsOfCategory self.assertEqual(len(spm.getPluginsOfCategory("IP")), 1) self.assertTrue("Other" in categories) # check the getPluginsOfCategory self.assertEqual(len(spm.getPluginsOfCategory("Other")), 0) # try to remove the plugin from one category and check the # other category spm.removePluginFromCategory(plugin_info, "Default") self.assertEqual(len(spm.getPluginsOfCategory("Default")), 0) self.assertEqual(len(spm.getPluginsOfCategory("IP")), 1) # now re-add this plugin the to same category spm.appendPluginToCategory(plugin_info, "Default") self.assertEqual(len(spm.getPluginsOfCategory("Default")), 1) self.assertEqual(len(spm.getPluginsOfCategory("IP")), 1)
def modelBehaviorImplementations(paths): """ Return an iterable of plugin-info for every locatable implementation of this interface on a given path. PyDev for Eclipse reports a compilation error here on a line that is actually legal Python due to the schedule upon which module resolution and imports happen. """ manager = PluginManager() manager.setPluginPlaces(paths) from fakeDataGenerator.model import IModelBehavior as foreignModelBehavior #hey PyDev: the previous line is weird, but is actually legal manager.setCategoriesFilter({ "ModelBehavior" : foreignModelBehavior, }) manager.collectPlugins() return manager.getPluginsOfCategory("ModelBehavior")
def load_directory(plugin_folder): """Loads and imports a directory of plugins. :param plugin_folder: The folder to look for plugin files. :type plugin_folder: String :rtype: Dictionary :returns: A dictionary of imported plugins. """ manager = PluginManager() manager.setPluginPlaces([plugin_folder]) manager.collectPlugins() return manager
def testRecursivePluginlocation(self): """ Test detection of plugins which by default must be recusrive. Here we give the test directory as a plugin place whereas we expect the plugins to be in test/plugins. """ spm = PluginManager( directories_list=[os.path.dirname(os.path.abspath(__file__))]) # load the plugins that may be found spm.collectPlugins() # check that the getCategories works self.assertEqual(len(spm.getCategories()), 1) sole_category = spm.getCategories()[0] # check the getPluginsOfCategory self.assertEqual(len(spm.getPluginsOfCategory(sole_category)), 1)
def main(): # Load the plugins from the plugin directory. manager = PluginManager() manager.setPluginPlaces(["plugins\\plugins1", "plugins\\plugins2"]) manager.setCategoriesFilter({ "PluginOne": category.PluginOne, "PluginTwo": category.PluginTwo, }) print { "PluginOne": category.PluginOne, "PluginTwo": category.PluginTwo } manager.collectPlugins() print manager.getPluginsOfCategory("PluginTwo") for plugin in manager.getPluginsOfCategory("PluginTwo"): plugin.plugin_object.print_name()
def get_manager(): categories = { catg.ApkChecker.category: catg.ApkChecker, catg.Unpacker.category: catg.Unpacker, catg.ProtectChecker.category: catg.ProtectChecker, catg.Auditor.category: catg.Auditor, } manager = PluginManager() plugin_paths = map(lambda e: os.path.join(settings.PLUGINS_DIR, e), categories.keys()) manager.setPluginPlaces(plugin_paths) manager.setCategoriesFilter(categories) manager.collectPlugins() return manager
def main(): global p1 # Load the plugins from the plugin directory. manager = PluginManager() manager.setPluginPlaces(["plugins"]) manager.collectPlugins() # Loop round the plugins and print their names. for plugin in manager.getAllPlugins(): print("==========> ", format(plugin.plugin_object)) #p="C:\Python34\directory1" #print("path is:======>",p) p1 = plugin.plugin_object.print_name() print(p1) p2 = PluginOne() p2.g()
def collect_data(self, **kwargs): self.logger.info("Begin collect_data") try: simplePluginManager = PluginManager() yapsy_log = logging.getLogger('yapsy') yapsy_log.setLevel(logging.DEBUG) yapsy_log.disabled = False simplePluginManager.setCategoriesFilter( {"DataCollector": data_collector_plugin}) # Tell it the default place(s) where to find plugins self.logger.debug("Plugin directories: %s" % (kwargs['data_collector_plugin_directories'])) simplePluginManager.setPluginPlaces( kwargs['data_collector_plugin_directories']) simplePluginManager.collectPlugins() output_queue = Queue() plugin_cnt = 0 plugin_start_time = time.time() for plugin in simplePluginManager.getAllPlugins(): self.logger.info("Starting plugin: %s" % (plugin.name)) if plugin.plugin_object.initialize_plugin( details=plugin.details, queue=output_queue): plugin.plugin_object.start() else: self.logger.error("Failed to initialize plugin: %s" % (plugin.name)) plugin_cnt += 1 #Wait for the plugings to finish up. self.logger.info("Waiting for %d plugins to complete." % (plugin_cnt)) for plugin in simplePluginManager.getAllPlugins(): plugin.plugin_object.join() plugin.plugin_object.finalize() while not output_queue.empty(): results = output_queue.get() if results[0] == data_result_types.MODEL_DATA_TYPE: self.site_data = results[1] self.logger.info("%d Plugins completed in %f seconds" % (plugin_cnt, time.time() - plugin_start_time)) except Exception as e: self.logger.exception(e)
def run(): # pragma: no cover plugin_manager = PluginManager( categories_filter={'py2swagger': Py2SwaggerPlugin}, directories_list=[os.path.join(os.path.dirname(__file__), 'plugins')], plugin_info_ext='py2swagger' ) plugin_manager.collectPlugins() parser = argparse.ArgumentParser(description='Swagger schema builder') parser.add_argument('-c', '--config', action='store', dest='config', help='Path to config file') parser.add_argument('-r', '--root', action='store', dest='root', help='Path to project root. Default is current directory or configuration file location') parser.add_argument('-o', '--output', action='store', dest='output', help='Output file (Default stdout)') sub_parsers = parser.add_subparsers(title='plugins', dest='plugin') # set arguments from plugins for plugin in plugin_manager.getAllPlugins(): sub_parser = sub_parsers.add_parser(plugin.name, help=plugin.plugin_object.summary, description=plugin.plugin_object.description) plugin.plugin_object.set_parser_arguments(sub_parser) args = parser.parse_args() sys.path.append(_get_project_root_path(args.root, args.config)) swagger_settings, plugin_settings = get_settings(args.config) plugin = plugin_manager.getPluginByName(args.plugin, category='py2swagger') if not plugin: sys.stderr.write('Plugin not available\n') sys.exit(1) try: swagger_settings_part = plugin.plugin_object.run(args, **plugin_settings) except Py2SwaggerPluginException as e: sys.stderr.write('{}\n'.format(e)) sys.exit(1) swagger_settings = update_settings(swagger_settings, swagger_settings_part) builder = SchemaBuilder(**swagger_settings) swagger_schema = json.dumps(builder.schema, indent=2) if args.output: with codecs.open(args.output, 'wb', encoding='utf-8') as f: f.write(swagger_schema) else: sys.stdout.write(swagger_schema)
def load_plugins(): """Loads plugins from the puglins folder""" plugins = PluginManager() plugins_folder = os.path.join(os.environ['LOOKDEVTOOLS'], 'python', 'ldtplugins') print plugins_folder plugins.setPluginPlaces([plugins_folder]) plugins.collectPlugins() plugins.locatePlugins() logger.info('Plugin candidates %s' % plugins.getPluginCandidates()) for pluginInfo in plugins.getAllPlugins(): plugins.activatePluginByName(pluginInfo.name) logger.info('Plugin activated %s' % plugins.activatePluginByName(pluginInfo.name)) return plugins
def loadTechniques(self, techniquesPath, controls=None): # Build the manager, set load location, and then collect them pm = PluginManager() pm.updatePluginPlaces([techniquesPath]) pm.collectPlugins() self.techniques = dict() for pluginInfo in pm.getAllPlugins(): print('loading ' + pluginInfo.name + ' for: ' + self.name) # Get the object and store in dictionary self.techniques[pluginInfo.name] = pluginInfo.plugin_object self.techniques[pluginInfo.name].controlPlugins = controls
def process_text(): if not request.json or not 'transcript' in request.json: abort(400) transcript = request.json['transcript'] # Initialize the plugin manager. simplePluginManager = PluginManager() simplePluginManager.setPluginPlaces(["./plugins"]) simplePluginManager.getPluginLocator().setPluginInfoExtension('plugin.info') # Load and activate plugins. simplePluginManager.collectPlugins() response = { } for pluginInfo in simplePluginManager.getAllPlugins(): returnValue = pluginInfo.plugin_object.process(transcript) response.update(returnValue) return jsonify(response), 200
def get_plugin_manager(config): plugin_manager = PluginManager() plugin_manager.setPluginPlaces( [config.get("GENERAL", "PLUGIN_DIRECTORY")] ) plugin_manager.setCategoriesFilter({ PluginTypeName.SENSOR: ISensorPlugin, PluginTypeName.REPOSITORY: IRepositoryPlugin, PluginTypeName.DISPLAY: IDisplayPlugin }) plugin_manager.collectPlugins() return plugin_manager
def disabled_plugins(): enabled_plugins = Plugin.objects.all() # Build the manager manager = PluginManager() # Tell it the default place(s) where to find plugins manager.setPluginPlaces([settings.PLUGIN_DIR, os.path.join(settings.PROJECT_DIR, 'server/plugins')]) # Load all plugins manager.collectPlugins() output = [] for plugin in manager.getAllPlugins(): try: item = Plugin.objects.get(name=plugin.name) except Plugin.DoesNotExist: output.append(plugin.name) return output
def printRagpickerInfos(print_options=False): infolog = logging.getLogger("Info") infolog.info(color("RAGPICKER_VERSION: " + RAGPICKER_VERSION, RED)) infolog.info(color("RAGPICKER_BUILD_DATE: " + RAGPICKER_BUILD_DATE, RED)) infolog.info(color("RAGPICKER_ROOT: " + RAGPICKER_ROOT, RED)) infolog.info("") pluginPlaces = ["crawler", "preProcessing", "processing", "reporting"] for place in pluginPlaces: infolog.info( color("%s| " % (place + " ").upper().ljust(14, '-'), MAGENTA)) cfg = Config(os.path.join(RAGPICKER_ROOT, 'config', place + '.conf')) ragpickerPluginManager = PluginManager() ragpickerPluginManager.setPluginPlaces([place]) ragpickerPluginManager.collectPlugins() for pluginInfo in sorted(ragpickerPluginManager.getAllPlugins(), key=lambda PluginInfo: PluginInfo.name): options = cfg.get(pluginInfo.name) if options.enabled: infolog.info( color("%s V%s %s", MAGENTA) % (" |----[+] " + pluginInfo.name.ljust(25), pluginInfo.version, pluginInfo.description)) if print_options: for key, value in options.iteritems(): if key != "enabled": infolog.info( color(" |-- %s = %s", MAGENTA) % (key, str(value))) else: infolog.info( color("%s V%s %s", BLUE) % (" |----[-] " + pluginInfo.name.ljust(25), pluginInfo.version, pluginInfo.description)) infolog.info("") infolog.info( " %s %s" % (color("([+] = enabled)", MAGENTA), color("([-] = disabled)", BLUE))) infolog.info("") checkVersion() sys.stdout.flush()