def set_download_speed(self, speed): if speed == 0: abort = self.config.get('abort') self.log_info( _("Stopping download server. (Running downloads will be aborted.)") if abort else _("Stopping download server. (Running downloads will not be aborted.)") ) self.pyload.api.pauseServer() if abort: self.pyload.api.stopAllDownloads() else: self.pyload.api.unpauseServer() if speed > 0: self.log_info(_("Setting download speed to %d kB/s") % speed) self.pyload.config.set('download', 'limit_speed', 1) self.pyload.config.set('download', 'max_speed', speed) else: self.log_info(_("Setting download speed to FULL")) self.pyload.config.set('download', 'limit_speed', 0) self.pyload.config.set('download', 'max_speed', -1) # Make new speed values take effect get_request_factory().updateBucket()
def _setup(self): #@TODO: Remove in 0.4.10 self.pyfile.error = "" self.data = "" self.last_html = "" self.last_header = {} if self.config.get('use_premium', True): self.load_account() # @TODO: Move to PluginThread in 0.4.10 else: self.account = False self.user = None # @TODO: Remove in 0.4.10 try: self.req.close() except Exception: pass if self.account: self.req = get_request_factory().getRequest( self.classname, self.account.user) # @NOTE: Avoid one unnecessary get_info call by `self.account.premium` here self.premium = self.account.info['data']['premium'] else: self.req = get_request_factory().getRequest(self.classname) self.premium = False self.req.setOption("timeout", 60) # @TODO: Remove in 0.4.10 self.setup_base() self.grab_info() self.setup() self.check_status()
def choose(self, user=None): """ Choose a valid account """ if not user: user = self.select()[0] elif user not in self.accounts: self.log_error( _("Error choosing user `%s`") % user, _("User does not exists")) return False if self.req and user == self.user: return True self.user = user self.info.clear() self.clean() if user is None: return False else: if not self.logged: self.relogin() else: self.req = get_request_factory().getRequest(self.classname, self.user) return True
def activate(self): request_factory = get_request_factory() self.old_get_request = request_factory.getRequest new_get_request = self.build_get_request() request_factory.getRequest = lambda *args: new_get_request(*args)
def _override_get_url(self): self.log_debug("Overriding get_url()") request_factory = get_request_factory() self.old_get_url = request_factory.getURL request_factory.getURL = self.my_get_url
def __init__(self, pyfile): Base.__init__(self, pyfile.m.core) self.wantReconnect = False #: enables simultaneous processing of multiple downloads self.multiDL = True self.limitDL = 0 #: chunk limit self.chunkLimit = 1 self.resumeDownload = False #: time() + wait in seconds self.waitUntil = 0 self.waiting = False self.ocr = None #captcha reader instance #: account handler instance, see :py:class:`Account` self.account = get_account_manager().getAccountPlugin(self.__name__) #: premium status self.premium = False #: username/login self.user = None if self.account and not self.account.canUse(): self.account = None if self.account: self.user, data = self.account.selectAccount() #: Browser instance, see `network.Browser` self.req = self.account.getAccountRequest(self.user) self.chunkLimit = -1 # chunk limit, -1 for unlimited #: enables resume (will be ignored if server dont accept chunks) self.resumeDownload = True self.multiDL = True #every hoster with account should provide multiple downloads #: premium status self.premium = self.account.isPremium(self.user) else: self.req = get_request_factory().getRequest(self.__name__) #: associated pyfile instance, see `PyFile` self.pyfile = pyfile self.thread = None # holds thread in future #: location where the last call to download was saved self.lastDownload = "" #: re match of the last call to `checkDownload` self.lastCheck = None #: js engine, see `JsEngine` self.js = self.core.js self.cTask = None #captcha task self.retries = 0 # amount of retries already made self.html = None # some plugins store html code here self.init()
def setConfigValue(self, category, option, value, section="core"): """Set new config value. :param category: :param option: :param value: new config value :param section: 'plugin' or 'core """ get_hook_manager().dispatchEvent("configChanged", category, option, value, section) if section == "core": self.core.config[category][option] = value if option in ("limit_speed", "max_speed"): # not so nice to update the limit get_request_factory().updateBucket() elif section == "plugin": self.core.config.setPlugin(category, option, value)
def setup(self): self.urls = [] try: self.req.http.close() except Exception: pass self.req.http = BIGHTTPRequest( cookies=CookieJar(None), options=get_request_factory().getOptions(), limit=2000000)
def setup(self): self.resume_download = True self.multiDL = True try: self.req.http.close() except Exception: pass self.req.http = BIGHTTPRequest( cookies=CookieJar(None), options=get_request_factory().getOptions(), limit=2000000)
def setup_base(self): XFSCrypter.setup_base(self) request_factory = get_request_factory() if self.account: self.req = request_factory.getRequest(self.PLUGIN_NAME, self.account.user) # @NOTE: Don't call get_info here to reduce overhead self.premium = self.account.info['data']['premium'] else: self.req = request_factory.getRequest(self.classname) self.premium = False
def get_request(self, plugin_name, account=None): iface = self.best_interface(plugin_name, account) if iface is None: self.log_warning(_("Best interface not found")) return self.old_get_request(plugin_name, account) iface.use_for(plugin_name, account) request_factory = get_request_factory() request_factory.iface = lambda: iface.address self.log_debug("Using address", iface.address) return self.old_get_request(plugin_name, account)
def setup_base(self): account_name = self.classname.rsplit("Folder", 1)[0] request_factory = get_request_factory() if self.account: self.req = request_factory.getRequest( account_name, self.account.user) # @NOTE: Don't call get_info here to reduce overhead self.premium = self.account.info['data']['premium'] else: self.req = request_factory.getRequest(account_name) self.premium = False Crypter.setup_base(self)
def _init(self, core): #: Internal modules self.pyload = core self.db = DB(self) self.config = Config(self) #: Provide information in dict here self.info = {} #: Browser instance, see `network.Browser` self.req = get_request_factory().getRequest(self.classname) self.req.setOption("timeout", 60) # @TODO: Remove in 0.4.10 #: Last loaded html self.last_html = "" self.last_header = {}
def login(self): if not self.req: self.log_info(_("Login user `%s`...") % self.user) else: self.log_info(_("Relogin user `%s`...") % self.user) self.clean() self.req = get_request_factory().getRequest(self.classname, self.user) self.sync() self.setup() timestamp = time.time() try: self.signin( self.user, self.info['login']['password'], self.info['data'], ) except Skip as e: self.log_warning(_("Skipped login user `%s`") % self.user, e) self.info['login']['valid'] = True new_timeout = timestamp - self.info['login']['timestamp'] if self.TUNE_TIMEOUT and new_timeout > self.timeout: self.timeout = new_timeout except Exception as e: self.log_error(_("Could not login user `%s`") % self.user, e) self.info['login']['valid'] = False else: self.info['login']['valid'] = True finally: #: Set timestamp for login self.info['login']['timestamp'] = timestamp self.syncback() return bool(self.info['login']['valid'])
def process(self, pyfile): server = self.info['pattern']['SERVER'] chan = self.info['pattern']['CHAN'] bot = self.info['pattern']['BOT'] pack = self.info['pattern']['PACK'] temp = server.split(':') ln = len(temp) if ln == 2: host, port = temp[0], int(temp[1]) elif ln == 1: host, port = temp[0], 6667 else: self.fail(_("Invalid hostname for IRC Server: %s") % server) nick = self.config.get('nick') nick_pw = self.config.get('nick_pw') ident = self.config.get('ident') realname = self.config.get('realname') invite_opts = [ _x.split('/') for _x in self.config.get('invite_opts').strip().split(',') if len(_x.split('/')) == 4 ] #: Remove leading '#' from channel name for opt in invite_opts: if opt[1].startswith('#'): opt[1] = opt[1][1:] #: Change request type self.req.close() self.req = get_request_factory().getRequest(self.classname, type="XDCC") self.pyfile.setCustomStatus("connect irc") self.irc_client = IRC(self, nick, ident, realname) for _i in xrange(0, 3): try: if self.irc_client.connect_server(host, port): try: if nick_pw: self.irc_client.nickserv_identify(nick_pw) for opt in invite_opts: if opt[0].lower() == host.lower() and opt[1].lower( ) == chan.lower(): self.irc_client.send_invite_request( opt[2], opt[1], opt[3]) break if not self.irc_client.join_channel(chan): self.fail(_("Cannot join channel")) if not self.irc_client.is_bot_online(bot): self.fail(_("Bot is offline")) self.pyfile.setStatus("waiting") self.irc_client.xdcc_request_pack(bot, pack) # Main IRC loop while (not self.pyfile.abort or self.dl_started) and not self.dl_finished: if not self.dl_started: if self.request_again: if time.time( ) - self.irc_client.xdcc_request_time > 300: self.irc_client.xdcc_request_pack( bot, pack) self.request_again = False else: if self.irc_client.xdcc_request_time and time.time( ) - self.irc_client.xdcc_request_time > 90: self.irc_client.disconnect_server() self.log_error( _("XDCC Bot did not answer")) self.retry( 3, 60, _("XDCC Bot did not answer")) origin, command, args = self.irc_client.get_irc_command( ) self.proccess_irc_command(origin, command, args) if self.exc_info: raise self.exc_info[1].with_traceback( self.exc_info[2]) finally: self.irc_client.disconnect_server() return except socket.error as e: if hasattr(e, "errno") and e.errno is not None: err_no = e.errno if err_no in (10054, 10061): self.log_warning( "Server blocked our ip, retry in 5 min") self.wait(300) continue else: self.log_error( _("Failed due to socket errors. Code: %s") % err_no) self.fail( _("Failed due to socket errors. Code: %s") % err_no) else: err_msg = e.args[0] self.log_error( _("Failed due to socket errors: '%s'") % err_msg) self.fail(_("Failed due to socket errors: '%s'") % err_msg) self.log_error(_("Server blocked our ip, retry again later manually")) self.fail(_("Server blocked our ip, retry again later manually"))
def _update_plugins(self, server_data): """ Check for plugin updates """ updated = [] updatelist, blacklist = self.parse_updates(server_data) url = server_data[1] req = get_request_factory().getRequest(self.classname) if blacklist: #@NOTE: Protect UpdateManager from self-removing if IS_WINDOWS: #@NOTE: Windows filesystem is case insensitive, make sure we do not delete legitimate plugins whitelisted_plugins = [ (plugin['type'], plugin['name'].upper()) for plugin in updatelist] blacklisted_plugins = [(plugin['type'], plugin['name']) for plugin in blacklist if not (plugin['name'] == self.classname and plugin['type'] == self.__type__) and (plugin['type'], plugin['name'].upper()) not in whitelisted_plugins] else: blacklisted_plugins = [(plugin['type'], plugin['name']) for plugin in blacklist if not (plugin['name'] == self.classname and plugin['type'] == self.__type__)] c = 1 l = len(blacklisted_plugins) for idx, plugin in enumerate(updatelist): if c > l: break plugin_name = plugin['name'] plugin_type = plugin['type'] for t, n in blacklisted_plugins: if n != plugin_name or t != plugin_type: continue updatelist.pop(idx) c += 1 break for t, n in self.remove_plugins(blacklisted_plugins): self.log_info(_("Removed blacklisted plugin: %(type)s %(name)s") % {'type': t.upper(), 'name': n,}) plugin_manager = get_plugin_manager() for plugin in updatelist: plugin_name = plugin['name'] plugin_type = plugin['type'] plugin_version = plugin['version'] # @TODO: Remove rstrip in 0.4.10 plugins = getattr(plugin_manager, "%sPlugins" % plugin_type.rstrip('s')) oldver = float(plugins[plugin_name]['v']) if plugin_name in plugins else None try: newver = float(plugin_version) except ValueError: self.log_error(_("Error updating plugin: %s %s") % (plugin_type.rstrip('s').upper(), plugin_name), _("Bad version number on the server")) continue if not oldver: msg = "New plugin: %(type)s %(name)s (v%(newver).2f)" elif newver > oldver: msg = "New version of plugin: %(type)s %(name)s (v%(oldver).2f -> v%(newver).2f)" else: continue self.log_info(_(msg) % {'type': plugin_type.rstrip('s').upper(), # @TODO: Remove rstrip in 0.4.10 'name': plugin_name, 'oldver': oldver, 'newver': newver}) try: content = self.load(url % plugin + ".py", decode=False, req=req) if req.code == 404: raise Exception(_("URL not found")) m = self._VERSION.search(content) if m and m.group(2) == plugin_version: with open(fsjoin("userplugins", plugin_type, plugin_name + ".py"), "wb") as f: f.write(encode(content)) updated.append((plugin_type, plugin_name)) else: raise Exception(_("Version mismatch")) except Exception as e: self.log_error(_("Error updating plugin: %s %s") % (plugin_type.rstrip('s').upper(), plugin_name), e) # @TODO: Remove rstrip in 0.4.10 return updated
def resetAccount(self): """ dont use account and retry download """ self.account = None self.req = get_request_factory().getRequest(self.__name__) self.retry()
def getURL(*args, **kwargs): return get_request_factory().getURL(*args, **kwargs)
def _unoverride_get_url(self): self.log_debug("Unoverriding get_url()") request_factory = get_request_factory() request_factory.getURL = self.old_get_url
def getRequest(*args, **kwargs): return get_request_factory().getHTTPRequest()