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()
