summaryrefslogtreecommitdiffstats
path: root/pyLoadCore.py
diff options
context:
space:
mode:
Diffstat (limited to 'pyLoadCore.py')
-rwxr-xr-xpyLoadCore.py1014
1 files changed, 603 insertions, 411 deletions
diff --git a/pyLoadCore.py b/pyLoadCore.py
index 94a57aa70..7aa38b9b1 100755
--- a/pyLoadCore.py
+++ b/pyLoadCore.py
@@ -1,411 +1,603 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-#Copyright (C) 2009 spoob, sebnapi, RaNaN
-#
-#This program is free software; you can redistribute it and/or modify
-#it under the terms of the GNU General Public License as published by
-#the Free Software Foundation; either version 3 of the License,
-#or (at your option) any later version.
-#
-#This program is distributed in the hope that it will be useful,
-#but WITHOUT ANY WARRANTY; without even the implied warranty of
-#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-#See the GNU General Public License for more details.
-#
-#You should have received a copy of the GNU General Public License
-# along with this program; if not, see <http://www.gnu.org/licenses/>.
-#
-###
-CURRENT_VERSION = '0.2.3.2'
-
-import ConfigParser
-import gettext
-from glob import glob
-import logging
-import logging.handlers
-from os import mkdir
-from os import sep
-from os import chdir
-from os.path import basename
-from os.path import exists
-from os.path import dirname
-from os.path import abspath
-import subprocess
-from sys import argv
-from sys import exit
-from sys import path
-from sys import stdout
-import time
-from time import sleep
-import urllib2
-from imp import find_module
-try:
- find_module("Crypto")
-except ImportError:
- print "Install pycrypto to use pyLoad"
- exit()
-from module.file_list import File_List
-from module.remote.RequestObject import RequestObject
-from module.remote.SocketServer import ServerThread
-from module.thread_list import Thread_List
-from module.web.WebServer import WebServer
-
-class Core(object):
- """ pyLoad main
- """
- def __init__(self):
-
- chdir(dirname(abspath(__file__)) + sep)
-
- self.config = {}
- self.plugin_folder = "module" + sep + "plugins"
- self.plugins_avaible = {}
-
- self.read_config()
-
- self.do_kill = False
- translation = gettext.translation("pyLoad", "locale", languages=[self.config['general']['language']])
- translation.install(unicode=True)
-
- self.check_installs("pycurl", "pycurl for lower memory footprint while downloading")
- self.check_installs("tesseract", "tesseract for captcha reading", False)
- self.check_installs("gocr", "gocr for captcha reading", False)
- self.check_create(self.config['log']['log_folder'], _("folder for logs"))
- self.check_create(self.config['general']['download_folder'], _("folder for downloads"))
- self.check_create(self.config['general']['link_file'], _("file for links"), False)
- self.check_create(self.config['general']['failed_file'], _("file for failed links"), False)
-
- if self.config['general']['debug_mode']:
- self.init_logger(logging.DEBUG) # logging level
- self.print_test_status = True
- else:
- self.init_logger(logging.INFO) # logging level
- self.print_test_status = False
-
- self.check_update()
-
- self.logger.info(_("Downloadtime: %s") % self.is_dltime()) # debug only
-
- path.append(self.plugin_folder)
- self.create_plugin_index()
-
- self.init_server()
-
- self.file_list = File_List(self)
- self.thread_list = Thread_List(self)
-
- #Webserver
-
- self.init_webserver()
-
- def check_installs(self, check_name, legend, python=True, essential=False):
- """check wether needed tools are installed"""
- try:
- if python:
- find_module(check_name)
- else:
- pipe = subprocess.PIPE
- subprocess.Popen(check_name, stdout=pipe, stderr=pipe)
- except:
- print "Install", legend
- if essential: exit()
-
- def check_create(self, check_name, legend, folder=True):
- """check wether needed files are exists"""
- if not exists(check_name):
- try:
- if folder:
- mkdir(check_name)
- else:
- open(check_name, "w")
- print _("%s created") % legend
- except:
- print _("could not create %s") % legend
- exit()
-
- def read_config(self):
- """ read config and sets preferences
- """
- self.configfile = ConfigParser.SafeConfigParser()
- self.configfile.read('config')
- for section in self.configfile.sections():
- self.config[section] = {}
- for option in self.configfile.options(section):
- self.config[section][option] = self.configfile.get(section, option)
- self.config[section][option] = False if self.config[section][option].lower() == 'false' else self.config[section][option]
-
- def set_option(self, section, option, value):
- self.config[option] = value
- self.configfile.set(section, option, str(value))
- self.configfile.write(open('config', "wb"))
-
- def read_option(self):
- return self.config
-
- def create_plugin_index(self):
- for file_handler in glob(self.plugin_folder + sep + '*.py') + glob(self.plugin_folder + sep + 'DLC.pyc'):
- plugin_pattern = ""
- plugin_file = basename(file_handler).replace('.pyc', '').replace('.py', '')
- if plugin_file == "DLC":
- plugin_pattern = "(?!http://).*\.dlc"
- else:
- for line in open(file_handler, "r").readlines():
- if "props['pattern']" in line:
- plugin_pattern = line.split("r\"")[1].split("\"")[0]
- break
- if plugin_pattern != "":
- self.plugins_avaible[plugin_file] = plugin_pattern
- self.logger.debug(plugin_file + _(" added"))
- self.logger.info(_("created index of plugins"))
-
- def read_links(self):
- """read links from txt"""
- txt = open(self.config['general']['link_file'], 'r')
- new_links = 0
- links = txt.readlines()
- for link in links:
- if link != "\n":
- self.file_list.append(link)
- new_links += 1
-
- txt.close()
-
- self.file_list.save()
- if new_links:
- self.logger.info("Parsed link from %s: %i" % (self.config['general']['link_file'], new_links))
-
- txt = open(self.config['general']['link_file'], 'w')
- txt.write("")
- txt.close()
-
- def check_update(self):
- """checks newst version
- """
- if not self.config['updates']['search_updates']:
- return False
-
- newst_version = urllib2.urlopen("http://update.pyload.org/index.php?do=" + CURRENT_VERSION).readline()
- if newst_version == "True":
- if not self.config['updates']['install_updates']:
- self.logger.info("New version available, please run Updater")
- else:
- updater = __import__("pyLoadUpdater")
- updater.main()
- else:
- self.logger.info("pyLoad is up-to-date")
-
- def init_logger(self, level):
-
- file_handler = logging.handlers.RotatingFileHandler(self.config['log']['log_folder'] + sep + 'log.txt', maxBytes=102400, backupCount=int(self.config['log']['log_count'])) #100 kib each
- console = logging.StreamHandler(stdout)
-
- frm = logging.Formatter("%(asctime)s: %(levelname)-8s %(message)s", "%d.%m.%Y %H:%M:%S")
- file_handler.setFormatter(frm)
- console.setFormatter(frm)
-
- self.logger = logging.getLogger("log") # settable in config
-
- if self.config['log']['file_log']:
- self.logger.addHandler(file_handler)
-
- self.logger.addHandler(console) #if console logging
- self.logger.setLevel(level)
-
- def is_dltime(self):
- start = self.config['downloadTime']['start'].split(":")
- end = self.config['downloadTime']['end'].split(":")
-
- return self.compare_time(start, end)
-
- def is_reconnect_time(self):
-
- start = self.config['reconnectTime']['start'].split(":")
- end = self.config['reconnectTime']['end'].split(":")
-
- return self.compare_time(start, end)
-
- def compare_time(self, start, end):
-
- if start == end:
- return True
-
- now = time.localtime()[3:5]
-
- if start < now and end > now:
- return True
- elif start > end and (now > start or now < end):
- return True
- elif start < now and end < now and start > end:
- return True
- else:
- return False
-
- def format_time(self, seconds):
- seconds = int(seconds)
- if seconds > 60:
- hours, seconds = divmod(seconds, 3600)
- minutes, seconds = divmod(seconds, 60)
- return "%.2i:%.2i:%.2i" % (hours, minutes, seconds)
- return _("%i seconds") % seconds
-
- def get_downloads(self):
- list = []
- for pyfile in self.thread_list.py_downloading:
- download = {}
- download['id'] = pyfile.id
- download['name'] = pyfile.status.filename
- download['speed'] = pyfile.status.get_speed()
- download['eta'] = pyfile.status.get_ETA()
- download['kbleft'] = pyfile.status.kB_left()
- download['size'] = pyfile.status.size()
- download['percent'] = pyfile.status.percent()
- download['status'] = pyfile.status.type
- download['wait_until'] = pyfile.status.waituntil
- download['plugin'] = pyfile.status.plugin
- list.append(download)
-
- return list
-
- def server_send_status(self):
- obj = RequestObject()
- obj.command = "update"
- obj.data = self.get_downloads()
- obj.status = self.server_status()
- self.server.push_all(obj)
-
- def server_status(self):
- status = {}
- status['pause'] = self.thread_list.pause
- status['queue'] = len(self.file_list.files)
- status['speed'] = 0
-
- for pyfile in self.thread_list.py_downloading:
- status['speed'] += pyfile.status.get_speed()
-
- return status
-
- def init_server(self):
-
- try:
- self.server = ServerThread(self)
- self.server.start()
- except Exception, e:
- self.logger.error("Failed starting socket server, CLI and GUI will not be available: %s" % str(e))
- exit()
-
- def init_webserver(self):
-
- if not self.config['webinterface']['activated']:
- return False
-
- try:
- self.webserver = WebServer(self)
- self.webserver.start()
- except Exception, e:
- self.logger.error("Failed starting webserver, no webinterface available: %s" % str(e))
- exit()
-
- def kill(self):
- self.do_kill = True
- self.logger.info("Going to kill pyLoad")
- exit()
- return True
-
- def shutdown(self):
- "abort all downloads and exit"
- self.thread_list.pause = True
-
- for pyfile in self.thread_list.py_downloading:
- pyfile.plugin.req.abort = True
-
- while self.thread_list.py_downloading:
- sleep(1)
- self.logger.info("Going to shutdown pyLoad")
- exit()
-
- def add_links(self, links):
- self.file_list.extend(links)
- self.file_list.save()
-
- def remove_links(self, ids):
- for id in ids:
- self.file_list.remove_id(id)
- self.file_list.save()
-
- def get_links(self):
- return self.file_list.data
-
- def move_links_up(self, ids):
-
- for id in ids:
- self.file_list.move(id)
-
- self.file_list.save()
-
- def move_links_down(self, ids):
-
- for id in ids:
- self.file_list.move(id, 1)
-
- self.file_list.save()
-
- def toggle_pause(self):
- if self.thread_list.pause:
- self.thread_list.pause = False
- return False
- elif not self.thread_list.pause:
- self.thread_list.pause = True
- return True
-
- def start(self):
- """ starts the machine
- """
- if len(argv) > 1:
- shortOptions = 'pu:l:'
- longOptions = ['print', 'url=', 'list=']
-
- opts, extraparams = __import__("getopt").getopt(argv[1:], shortOptions, longOptions)
- for option, params in opts:
- if option in ("-p", "--print"):
- print "Print test output"
- self.print_test_status = True
- elif option in ("-u", "--url"):
- self.logger.info("Add url: " + params)
- self.add_links([params])
- elif option in ("-l", "--list"):
- list = open(params, 'r').readlines()
- self.add_links(list)
- self.logger.info("Add list:" + params)
-
- self.read_links()
-
- while True:
- #self.thread_list.status()
- if self.print_test_status:
- self._test_print_status()
- self.server_send_status()
- sleep(2)
- if self.do_kill:
- self.logger.info("pyLoad quits")
- exit()
-
- def _test_print_status(self):
-
- if self.thread_list.py_downloading:
- for pyfile in self.thread_list.py_downloading:
- if pyfile.status.type == 'downloading':
- print pyfile.status.filename + ": speed is", int(pyfile.status.get_speed()), "kb/s"
- print pyfile.status.filename + ": finished in", self.format_time(pyfile.status.get_ETA())
- elif pyfile.status.type == 'waiting':
- print pyfile.status.filename + ": wait", self.format_time(pyfile.status.waituntil - time.time())
-
-if __name__ == "__main__":
- if len(argv) > 1:
- if argv[1] == "-v":
- print "pyLoad", CURRENT_VERSION
- exit()
-
- testLoader = Core()
- testLoader.start()
-
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License,
+ or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, see <http://www.gnu.org/licenses/>.
+
+ @author: spoob
+ @author: sebnapi
+ @author: RaNaN
+ @author: mkaay
+ @version: v0.3
+"""
+
+CURRENT_VERSION = '0.3'
+from getopt import getopt
+import gettext
+from glob import glob
+from imp import find_module
+import logging
+import logging.handlers
+from operator import attrgetter
+from os import execv
+from os import makedirs
+from os import remove
+from os import sep
+from os.path import basename
+from os.path import dirname
+from os.path import exists
+from os.path import join
+from re import sub
+import subprocess
+from sys import argv
+from sys import executable
+from sys import exit
+from sys import path
+from sys import stdout
+from tempfile import NamedTemporaryFile
+import thread
+import time
+from time import sleep
+from xmlrpclib import Binary
+
+from module.CaptchaManager import CaptchaManager
+from module.HookManager import HookManager
+from module.XMLConfigParser import XMLConfigParser
+from module.file_list import File_List
+from module.network.Request import Request
+import module.remote.SecureXMLRPCServer as Server
+from module.thread_list import Thread_List
+from module.web.ServerThread import WebServer
+
+class Core(object):
+ """ pyLoad Core """
+ def __init__(self):
+ self.arg_links = []
+ if len(argv) > 1:
+ try:
+ options, arguments = getopt(argv[1:], 'vcl:')
+ for option, argument in options:
+ if option == "-v":
+ print "pyLoad", CURRENT_VERSION
+ exit()
+ elif option == "-c":
+ remove(join("module", "links.pkl"))
+ print "Removed Linkliste"
+ elif option == "-l":
+ self.arg_links.append(argument)
+ print "Added %s" % argument
+ except:
+ print 'Unknown Argument(s) "%s"' % " ".join(argv[1:])
+
+ def toggle_pause(self):
+ if self.thread_list.pause:
+ self.thread_list.pause = False
+ return False
+ elif not self.thread_list.pause:
+ self.thread_list.pause = True
+ return True
+
+ def start(self):
+ """ starts the machine"""
+ self.path = dirname(__file__)
+
+ self.config = {}
+ self.plugins_avaible = {}
+
+ self.plugin_folder = join("module", "plugins")
+
+ self.xmlconfig = XMLConfigParser(join(self.path, "module", "config", "core.xml"))
+ self.config = self.xmlconfig.getConfig()
+ self.parser_plugins = XMLConfigParser(join(self.path, "module", "config", "plugin.xml"))
+ #~ self.config_plugins = self.parser_plugins.getConfig()
+
+ self.do_kill = False
+ self.do_restart = False
+ translation = gettext.translation("pyLoad", join(self.path, "locale"), languages=[self.config['general']['language']])
+ translation.install(unicode=True)
+
+ self.check_install("Crypto", "pycrypto to decode container files")
+ self.check_install("Image", "Python Image Libary (PIL) for captha reading")
+ self.check_install("pycurl", "pycurl for lower memory footprint while downloading")
+ self.check_install("django", "Django for webinterface")
+ self.check_install("tesseract", "tesseract for captcha reading", False)
+ self.check_install("gocr", "gocr for captcha reading", False)
+
+ self.check_file(self.config['log']['log_folder'], _("folder for logs"), True)
+ self.check_file(self.config['general']['download_folder'], _("folder for downloads"), True)
+ self.check_file(self.config['general']['link_file'], _("file for links"))
+ self.check_file(self.config['general']['failed_file'], _("file for failed links"))
+
+ if self.config['ssl']['activated']:
+ self.check_install("OpenSSL", "OpenSSL for secure connection", True)
+ self.check_file(self.config['ssl']['cert'], _("ssl certificate"), False, True)
+ self.check_file(self.config['ssl']['key'], _("ssl key"), False, True)
+
+ self.downloadSpeedLimit = int(self.xmlconfig.get("general", "download_speed_limit", 0))
+
+ if self.config['general']['debug_mode']:
+ self.init_logger(logging.DEBUG) # logging level
+ else:
+ self.init_logger(logging.INFO) # logging level
+
+ self.init_hooks()
+ path.append(self.plugin_folder)
+ self.create_plugin_index()
+
+ self.lastGuiConnected = 0
+
+ self.server_methods = ServerMethods(self)
+ self.file_list = File_List(self)
+ self.thread_list = Thread_List(self)
+ self.captchaManager = CaptchaManager(self)
+
+ self.last_update_check = 0
+ self.update_check_interval = 1800
+ self.update_available = self.check_update()
+ self.logger.info(_("Downloadtime: %s") % self.server_methods.is_time_download())
+
+ self.init_server()
+ self.init_webserver()
+
+ linkFile = self.config['general']['link_file']
+ packs = self.server_methods.get_queue()
+ found = False
+ for data in packs:
+ if data["package_name"] == linkFile:
+ found = data["id"]
+ break
+ if found == False:
+ pid = self.file_list.packager.addNewPackage(package_name=linkFile)
+ else:
+ pid = found
+ lid = self.file_list.collector.addLink(linkFile)
+ self.file_list.packager.addFileToPackage(pid, self.file_list.collector.popFile(lid))
+ if self.arg_links:
+ for link in self.arg_links:
+ lid = self.file_list.collector.addLink(link)
+ self.file_list.packager.addFileToPackage(pid, self.file_list.collector.popFile(lid))
+
+ self.file_list.packager.pushPackage2Queue(pid)
+ self.file_list.continueAborted()
+
+ while True:
+ sleep(2)
+ if self.do_restart:
+ self.logger.info("restarting pyLoad")
+ self.restart()
+ if self.do_kill:
+ self.shutdown()
+ self.logger.info("pyLoad quits")
+ exit()
+ if self.last_update_check + self.update_check_interval <= time.time():
+ self.update_available = self.check_update()
+
+ def init_server(self):
+ try:
+ server_addr = (self.config['remote']['listenaddr'], int(self.config['remote']['port']))
+ usermap = {self.config['remote']['username']: self.config['remote']['password']}
+ if self.config['ssl']['activated']:
+ self.server = Server.SecureXMLRPCServer(server_addr, self.config['ssl']['cert'], self.config['ssl']['key'], usermap)
+ self.logger.info("Secure XMLRPC Server Started")
+ else:
+ self.server = Server.AuthXMLRPCServer(server_addr, usermap)
+ self.logger.info("Auth XMLRPC Server Started")
+
+ self.server.register_instance(self.server_methods)
+
+ thread.start_new_thread(self.server.serve_forever, ())
+ except Exception, e:
+ self.logger.error("Failed starting socket server, CLI and GUI will not be available: %s" % str(e))
+ if self.config['general']['debug_mode']:
+ import traceback
+ traceback.print_exc()
+
+
+ def init_webserver(self):
+ #pyloadDBFile = join(self.path, "module", "web", "pyload.db")
+ #pyloadDefaultDBFile = join(self.path, "module", "web", "pyload_default.db")
+ #if not exists(pyloadDBFile):
+ # copyfile(pyloadDefaultDBFile, pyloadDBFile)
+ if self.config['webinterface']['activated']:
+ self.webserver = WebServer(self)
+ self.webserver.start()
+
+ def init_logger(self, level):
+ console = logging.StreamHandler(stdout)
+ frm = logging.Formatter("%(asctime)s: %(levelname)-8s %(message)s", "%d.%m.%Y %H:%M:%S")
+ console.setFormatter(frm)
+ self.logger = logging.getLogger("log") # settable in config
+
+ if self.config['log']['file_log']:
+ file_handler = logging.handlers.RotatingFileHandler(self.config['log']['log_folder'] + sep + 'log.txt', maxBytes=102400, backupCount=int(self.config['log']['log_count'])) #100 kib each
+ file_handler.setFormatter(frm)
+ self.logger.addHandler(file_handler)
+
+ self.logger.addHandler(console) #if console logging
+ self.logger.setLevel(level)
+
+ def init_hooks(self):
+ self.hookManager = HookManager(self)
+
+ def check_install(self, check_name, legend, python=True, essential=False):
+ """check wether needed tools are installed"""
+ try:
+ if python:
+ find_module(check_name)
+ else:
+ pipe = subprocess.PIPE
+ subprocess.Popen(check_name, stdout=pipe, stderr=pipe)
+ except:
+ print "Install", legend
+ if essential: exit()
+
+ def check_file(self, check_names, description="", folder=False, empty=True, essential=False):
+ """check wether needed files are exists"""
+ tmp_names = []
+ if not type(check_names) == list:
+ tmp_names.append(check_names)
+ else:
+ tmp_names.extend(check_names)
+ file_created = True
+ file_exists = True
+ for tmp_name in tmp_names:
+ if not exists(tmp_name):
+ file_exists = False
+ if empty:
+ try:
+ if folder:
+ tmp_name = tmp_name.replace("/", sep)
+ makedirs(tmp_name)
+ else:
+ open(tmp_name, "w")
+ except:
+ file_created = False
+ else:
+ file_created = False
+ if not file_exists:
+ if file_created:
+ print _("%s created") % description
+ else:
+ if not empty:
+ print _("could not find %s: %s") % (description, tmp_name)
+ else:
+ print _("could not create %s: %s") % (description, tmp_name)
+ if essential:
+ exit()
+
+ def isGUIConnected(self):
+ return self.lastGuiConnected + 10 > time.time()
+
+ def restart(self):
+ self.shutdown()
+ execv(executable, [executable, "pyLoadCore.py"])
+
+ def create_plugin_index(self):
+ plugins = glob(join(self.plugin_folder, "hoster", "*.py"))
+ plugins += glob(join(self.plugin_folder, "decrypter", "*.py"))
+ plugins += glob(join(self.plugin_folder, "container", "*.py"))
+ plugins += glob(join(self.plugin_folder, "container", "DLC.pyc"))
+ for file_handler in plugins:
+ plugin_pattern = ""
+ plugin_file = sub("(\.pyc|\.py)", "", basename(file_handler))
+ if plugin_file == "DLC":
+ plugin_pattern = "(?!http://).*\.dlc"
+ else:
+ for line in open(file_handler, "r").readlines():
+ if "props['pattern']" in line:
+ plugin_pattern = line.split("r\"")[1].split("\"")[0]
+ break
+ if plugin_pattern != "":
+ self.plugins_avaible[plugin_file] = plugin_pattern
+ self.logger.debug(plugin_file + _(" added"))
+ self.logger.info(_("created index of plugins"))
+
+ def compare_time(self, start, end):
+
+ start = map(int, start)
+ end = map(int, end)
+
+ if start == end: return True
+
+ now = time.localtime()[3:5]
+ if start < now and end > now: return True
+ elif start > end and (now > start or now < end): return True
+ elif start < now and end < now and start > end: return True
+ else: return False
+
+ def getMaxSpeed(self):
+ return self.downloadSpeedLimit
+
+ def shutdown(self):
+ self.logger.info("shutting down...")
+ if self.config['webinterface']['activated']:
+ self.webserver.quit()
+ self.webserver.join()
+ for thread in self.thread_list.threads:
+ thread.shutdown = True
+ self.thread_list.stopAllDownloads()
+ for thread in self.thread_list.threads:
+ thread.join(15)
+ self.file_list.save()
+
+ def check_update(self):
+ try:
+ if self.config['updates']['search_updates']:
+ version_check = Request().load("http://get.pyload.org/check/%s/" % (CURRENT_VERSION, ))
+ if version_check == "":
+ self.logger.info("No Updates for pyLoad")
+ return False
+ else:
+ self.logger.info("New pyLoad Version %s available" % version_check)
+ return True
+ else:
+ return False
+ finally:
+ self.last_update_check = time.time()
+
+ def install_update(self):
+ if self.config['updates']['search_updates']:
+ if self.core.config['updates']['install_updates']:
+ version_check = Request().load("http://get.pyload.org/get/update/%s/" % (CURRENT_VERSION, ))
+ else:
+ version_check = Request().load("http://get.pyload.org/check/%s/" % (CURRENT_VERSION, ))
+ if version_check == "":
+ return False
+ else:
+ if self.config['updates']['install_updates']:
+ try:
+ tmp_zip_name = __import__("tempfile").NamedTemporaryFile(suffix=".zip").name
+ tmp_zip = open(tmp_zip_name, 'wb')
+ tmp_zip.write(version_check)
+ tmp_zip.close()
+ __import__("module.Unzip", globals(), locals(), "Unzip", -1).Unzip().extract(tmp_zip_name, "Test/")
+ return True
+ except:
+ self.logger.info("Auto install Failed")
+ return False
+ else:
+ return False
+ else:
+ return False
+
+ ####################################
+ ########## XMLRPC Methods ##########
+ ####################################
+
+class ServerMethods():
+ def __init__(self, core):
+ self.core = core
+
+ def status_downloads(self):
+ downloads = []
+ for pyfile in self.core.thread_list.py_downloading:
+ download = {}
+ download['id'] = pyfile.id
+ download['name'] = pyfile.status.filename
+ download['speed'] = pyfile.status.get_speed()
+ download['eta'] = pyfile.status.get_ETA()
+ download['kbleft'] = pyfile.status.kB_left()
+ download['size'] = pyfile.status.size()
+ download['percent'] = pyfile.status.percent()
+ download['status'] = pyfile.status.type
+ download['wait_until'] = pyfile.status.waituntil
+ download['package'] = pyfile.package.data["package_name"]
+ downloads.append(download)
+ return downloads
+
+ def get_conf_val(self, cat, var):
+ if var != "username" and var != "password":
+ return self.core.config[cat][var]
+ else:
+ raise Exception("not allowed!")
+
+ def pause_server(self):
+ self.core.thread_list.pause = True
+
+ def unpause_server(self):
+ self.core.thread_list.pause = False
+
+ def toggle_pause(self):
+ if self.core.thread_list.pause:
+ self.core.thread_list.pause = False
+ else:
+ self.core.thread_list.pause = True
+ return self.core.thread_list.pause
+
+ def status_server(self):
+ status = {}
+ status['pause'] = self.core.thread_list.pause
+ status['activ'] = len(self.core.thread_list.py_downloading)
+ status['queue'] = self.core.file_list.countDownloads()
+ status['total'] = len(self.core.file_list.data['queue'])
+ status['speed'] = 0
+
+ for pyfile in self.core.thread_list.py_downloading:
+ status['speed'] += pyfile.status.get_speed()
+
+ return status
+
+ def file_exists(self, path): #@XXX: security?!
+ return exists(path)
+
+ def get_server_version(self):
+ return CURRENT_VERSION
+
+ def add_urls(self, links):
+ for link in links:
+ link = link.strip()
+ if link.startswith("http") or exists(link):
+ self.core.file_list.collector.addLink(link)
+ self.core.file_list.save()
+
+ def add_package(self, name, links):
+ pid = self.new_package(name)
+ self.core.file_list.packager.pushPackage2Queue(pid)
+ fids = map(self.core.file_list.collector.addLink, links)
+ map(lambda fid: self.move_file_2_package(fid, pid), fids)
+ self.push_package_2_queue(pid)
+ self.core.file_list.save()
+
+ def new_package(self, name):
+ id = self.core.file_list.packager.addNewPackage(name)
+ self.core.file_list.save()
+ return id
+
+ def get_package_data(self, id):
+ return self.core.file_list.packager.getPackageData(id)
+
+ def get_package_files(self, id):
+ return self.core.file_list.packager.getPackageFiles(id)
+
+ def get_file_info(self, id):
+ return self.core.file_list.getFileInfo(id)
+
+ def del_links(self, ids):
+ for id in ids:
+ try:
+ self.core.file_list.collector.removeFile(id)
+ except:
+ self.core.file_list.packager.removeFile(id)
+ self.core.file_list.save()
+
+ def del_packages(self, ids):
+ map(self.core.file_list.packager.removePackage, ids)
+ self.core.file_list.save()
+
+ def kill(self):
+ self.core.do_kill = True
+ return True
+
+ def restart(self):
+ self.core.do_restart = True
+
+ def get_queue(self):
+ return map(attrgetter("data"), self.core.file_list.data["queue"])
+
+ def get_collector_packages(self):
+ return map(attrgetter("data"), self.core.file_list.data["packages"])
+
+ def get_collector_files(self):
+ return map(attrgetter("id"), self.core.file_list.data["collector"])
+
+ def move_file_2_package(self, fid, pid):
+ try:
+ pyfile = self.core.file_list.collector.getFile(fid)
+ self.core.file_list.packager.addFileToPackage(pid, pyfile)
+ except:
+ return
+ else:
+ self.core.file_list.collector.removeFile(fid)
+
+ def push_package_2_queue(self, id):
+ self.core.file_list.packager.pushPackage2Queue(id)
+
+ def restart_package(self, packid):
+ map(self.core.file_list.packager.resetFileStatus, self.core.file_list.packager.getPackageFiles(packid))
+
+ def restart_file(self, fileid):
+ self.core.file_list.packager.resetFileStatus(fileid)
+
+ def upload_container(self, filename, type, content):
+ th = NamedTemporaryFile(mode="w", suffix="." + type, delete=False)
+ th.write(content)
+ path = th.name
+ th.close()
+ pid = self.core.file_list.packager.addNewPackage(filename)
+ cid = self.core.file_list.collector.addLink(path)
+ self.move_file_2_package(cid, pid)
+ self.core.file_list.save()
+
+ def get_log(self, offset=0):
+ filename = self.core.config['log']['log_folder'] + sep + 'log.txt'
+ fh = open(filename, "r")
+ content = fh.read()
+ fh.close()
+ lines = content.splitlines()
+ if offset >= len(lines):
+ return None
+ return lines[offset:]
+
+ def stop_downloads(self):
+ self.core.thread_list.stopAllDownloads()
+
+ def stop_download(self, type, id):
+ if type == "pack":
+ ids = self.core.file_list.getPackageFiles(id)
+ for fid in ids:
+ self.core.file_list.packager.abortFile(fid)
+ else:
+ self.core.file_list.packager.abortFile(id)
+
+ def update_available(self):
+ return self.core.update_available
+
+ def set_package_name(self, pid, name):
+ self.core.file_list.packager.setPackageData(pid, package_name=name)
+
+ def pull_out_package(self, pid):
+ self.core.file_list.packager.pullOutPackage(pid)
+
+ def is_captcha_waiting(self):
+ self.core.lastGuiConnected = time.time()
+ task = self.core.captchaManager.getTask()
+ return not task == None
+
+ def get_captcha_task(self):
+ task = self.core.captchaManager.getTask()
+ if task:
+ task.setWatingForUser()
+ c = task.getCaptcha()
+ return str(task.getID()), Binary(c[0]), str(c[1])
+ else:
+ return None, None, None
+
+ def set_captcha_result(self, tid, result):
+ task = self.core.captchaManager.getTaskFromID(tid)
+ if task:
+ task.setResult(result)
+ task.setDone()
+ return True
+ else:
+ return False
+
+ #def move_urls_up(self, ids):
+ # for id in ids:
+ # self.core.file_list.move(id)
+ # self.core.file_list.save()
+
+ #def move_urls_down(self, ids):
+ # for id in ids:
+ # self.core.file_list.move(id, 1)
+ # self.core.file_list.save()
+
+ def is_time_download(self):
+ start = self.core.config['downloadTime']['start'].split(":")
+ end = self.core.config['downloadTime']['end'].split(":")
+ return self.core.compare_time(start, end)
+
+ def is_time_reconnect(self):
+ start = self.core.config['reconnect']['startTime'].split(":")
+ end = self.core.config['reconnect']['endTime'].split(":")
+ return self.core.compare_time(start, end)
+
+# And so it begins...
+if __name__ == "__main__":
+ pyload_core = Core()
+ try:
+ pyload_core.start()
+ except KeyboardInterrupt:
+ pyload_core.shutdown()
+ pyload_core.logger.info("killed pyLoad from Terminal")
+ exit()
generated by cgit v1.2.3 (git 2.25.1) at 2025-02-02 10:55:15 +0100