def __init__(self, core): self.core = core self.log = core.log # cached modules (type, name) self.modules = {} # match history to speedup parsing (type, name) self.history = [] #register for import addon sys.meta_path.append(self) # add to path, so we can import from userplugins sys.path.append(abspath("")) self.loader = LoaderFactory( PluginLoader(abspath(self.LOCALROOT), self.LOCALROOT, self.core.config), PluginLoader(abspath(join(pypath, "pyload", "plugins")), self.ROOT, self.core.config)) self.loader.checkVersions() # plugin matcher to overwrite some behaviour self.matcher = []
def __init__(self, core): self.core = core self.log = core.log # cached modules (type, name) self.modules = {} # match history to speedup parsing (type, name) self.history = [] #register for import addon sys.meta_path.append(self) # add to path, so we can import from userplugins sys.path.append(abspath("")) self.loader = LoaderFactory(PluginLoader(abspath(self.LOCALROOT), self.LOCALROOT, self.core.config), PluginLoader(abspath(join(pypath, "pyload", "plugins")), self.ROOT, self.core.config)) self.loader.checkVersions() # plugin matcher to overwrite some behaviour self.matcher = []
class PluginManager: ROOT = "pyload.plugins" LOCALROOT = "localplugins" MATCH_HISTORY = 10 DEFAULT_PLUGIN = "BasePlugin" def __init__(self, core): self.core = core self.log = core.log # cached modules (type, name) self.modules = {} # match history to speedup parsing (type, name) self.history = [] #register for import addon sys.meta_path.append(self) # add to path, so we can import from userplugins sys.path.append(abspath("")) self.loader = LoaderFactory( PluginLoader(abspath(self.LOCALROOT), self.LOCALROOT, self.core.config), PluginLoader(abspath(join(pypath, "pyload", "plugins")), self.ROOT, self.core.config)) self.loader.checkVersions() # plugin matcher to overwrite some behaviour self.matcher = [] def addMatcher(self, matcher, index=0): """ Inserts matcher at given index, first position by default """ if not isinstance(matcher, PluginMatcher): raise TypeError( "Expected type of PluginMatcher, got '%s' instead" % type(matcher)) if matcher in self.matcher: self.matcher.remove(matcher) self.matcher.insert(index, matcher) def removeMatcher(self, matcher): """ Removes a matcher if it exists """ if matcher in self.matcher: self.matcher.remove(matcher) def parseUrls(self, urls): """parse plugins for given list of urls, separate to crypter and hoster""" res = {"hoster": [], "crypter": []} # tupels of (url, plugin) for url in urls: if type(url) not in (str, unicode, buffer): self.log.debug("Parsing invalid type %s" % type(url)) continue found = False # search the history for ptype, name in self.history: if self.loader.getPlugin(ptype, name).re.match(url): res[ptype].append((url, name)) found = (ptype, name) break # need to exit this loop first if found: # found match if self.history[0] != found: #update history self.history.remove(found) self.history.insert(0, found) continue # matcher are tried secondly, they won't go to history for m in self.matcher: match = m.matchURL(url) if match and match[0] in res: ptype, name = match res[ptype].append((url, name)) found = True break if found: continue for ptype in ("crypter", "hoster"): for loader in self.loader: for name, plugin in loader.getPlugins(ptype).iteritems(): if plugin.re.match(url): res[ptype].append((url, name)) self.history.insert(0, (ptype, name)) del self.history[ self.MATCH_HISTORY:] # cut down to size found = True break if found: break if found: break if not found: res["hoster"].append((url, self.DEFAULT_PLUGIN)) return res["hoster"], res["crypter"] def findPlugin(self, name): """ Finds the type to a plugin name """ return self.loader.findPlugin(name) def getPlugin(self, plugin, name): """ Retrieves the plugin tuple for a single plugin or none """ return self.loader.getPlugin(plugin, name) def getPlugins(self, plugin): """ Get all plugins of a certain type in a dict """ plugins = {} for loader in self.loader: plugins.update(loader.getPlugins(plugin)) return plugins def getPluginClass(self, plugin, name, overwrite=True): """Gives the plugin class of a hoster or crypter plugin :param overwrite: allow the use of overwritten plugins """ if overwrite: for m in self.matcher: match = m.matchPlugin(plugin, name) if match: plugin, name = match return self.loadClass(plugin, name) def loadAttributes(self, plugin, name): for loader in self.loader: if loader.hasPlugin(plugin, name): return loader.loadAttributes(plugin, name) return {} def loadModule(self, plugin, name): """ Returns loaded module for plugin :param plugin: plugin type, subfolder of module.plugins """ if (plugin, name) in self.modules: return self.modules[(plugin, name)] for loader in self.loader: if loader.hasPlugin(plugin, name): try: module = loader.loadModule(plugin, name) # cache import self.modules[(plugin, name)] = module return module except Exception, e: self.log.error( _("Error importing %(name)s: %(msg)s") % { "name": name, "msg": str(e) }) self.core.print_exc()
class PluginManager: ROOT = "pyload.plugins" LOCALROOT = "localplugins" MATCH_HISTORY = 10 DEFAULT_PLUGIN = "BasePlugin" def __init__(self, core): self.core = core self.log = core.log # cached modules (type, name) self.modules = {} # match history to speedup parsing (type, name) self.history = [] #register for import addon sys.meta_path.append(self) # add to path, so we can import from userplugins sys.path.append(abspath("")) self.loader = LoaderFactory(PluginLoader(abspath(self.LOCALROOT), self.LOCALROOT, self.core.config), PluginLoader(abspath(join(pypath, "pyload", "plugins")), self.ROOT, self.core.config)) self.loader.checkVersions() # plugin matcher to overwrite some behaviour self.matcher = [] def addMatcher(self, matcher, index=0): """ Inserts matcher at given index, first position by default """ if not isinstance(matcher, PluginMatcher): raise TypeError("Expected type of PluginMatcher, got %s instead" % type(matcher)) if matcher in self.matcher: self.matcher.remove(matcher) self.matcher.insert(index, matcher) def removeMatcher(self, matcher): """ Removes a matcher if it exists """ if matcher in self.matcher: self.matcher.remove(matcher) def parseUrls(self, urls): """parse plugins for given list of urls, separate to crypter and hoster""" res = {"hoster": [], "crypter": []} # tupels of (url, plugin) for url in urls: if type(url) not in (str, unicode, buffer): self.log.debug("Parsing invalid type %s" % type(url)) continue found = False # search the history for ptype, name in self.history: if self.loader.getPlugin(ptype, name).re.match(url): res[ptype].append((url, name)) found = (ptype, name) break # need to exit this loop first if found: # found match if self.history[0] != found: #update history self.history.remove(found) self.history.insert(0, found) continue # matcher won't go to history for m in self.matcher: match = m.matchURL(url) if match and match[0] in res: ptype, name = match res[ptype].append((url, name)) found = True break if found: continue for ptype in ("crypter", "hoster"): for loader in self.loader: for name, plugin in loader.getPlugins(ptype).iteritems(): if plugin.re.match(url): res[ptype].append((url, name)) self.history.insert(0, (ptype, name)) del self.history[self.MATCH_HISTORY:] # cut down to size of 10 found = True break if found: break if found: break if not found: res["hoster"].append((url, self.DEFAULT_PLUGIN)) return res["hoster"], res["crypter"] def getPlugins(self, plugin): """ Get all plugins of a certain type in a dict """ plugins = {} for loader in self.loader: plugins.update(loader.getPlugins(plugin)) return plugins def getPluginClass(self, plugin, name, overwrite=True): """Gives the plugin class of a hoster or crypter plugin :param overwrite: allow the use of overwritten plugins """ if overwrite: for m in self.matcher: match = m.matchPlugin(plugin, name) if match: plugin, name = match return self.loadClass(plugin, name) def loadAttributes(self, plugin, name): for loader in self.loader: if loader.hasPlugin(plugin, name): return loader.loadAttributes(plugin, name) return {} def loadModule(self, plugin, name): """ Returns loaded module for plugin :param plugin: plugin type, subfolder of module.plugins """ if (plugin, name) in self.modules: return self.modules[(plugin, name)] for loader in self.loader: if loader.hasPlugin(plugin, name): try: module = loader.loadModule(plugin, name) # cache import self.modules[(plugin, name)] = module return module except Exception, e: self.log.error(_("Error importing %(name)s: %(msg)s") % {"name": name, "msg": str(e)}) self.core.print_exc()