def handle_free(self, pyfile):
# step 1: get essential information: the media URL and the javascript
# translating the URL
m = re.search(self.MEDIA_URL_PATTERN, self.data)
if m is None:
self.fail(_("Could not find any media URLs"))
encoded_media_url = m.group(1)
self.log_debug("Found encoded media URL: %s" % encoded_media_url)
m = re.search(self.COMMUNITY_JS_PATTERN, self.data)
if m is None:
self.fail(_("Could not find necessary javascript script to load"))
community_js_url = m.group(1)
self.log_debug("Found community js at %s" % community_js_url)
community_js_code = self.load(community_js_url)
# step 2: from the js code, parse the necessary parts: the decoder function and the headers
# as the jscript is fairly long, we'll split it to make parsing easier
community_js_code = community_js_code.partition(self.JS_SPLIT_WORD)[0]
m = re.search(self.JS_HEADER_PATTERN, community_js_code)
if m is None:
self.fail(
_("Could not parse the necessary parts off the javascript"))
decoder_function = m.group('decoder')
initialization = m.group('initvars')
m = re.search(self.JS_PROCESS_PATTERN, community_js_code)
if m is None:
self.fail(
_("Could not parse the processing function off the javascript")
)
process_function = m.group(0)
# step 3: assemble the new js code
js = JsEngine()
new_js_code = decoder_function + '; ' + initialization + '; var ' + \
process_function + \
'; processRecording("' + encoded_media_url + '");'
self.log_debug("Running js script: %s" % new_js_code)
js_result = js.eval(new_js_code)
self.log_debug("Result is: %s" % js_result)
self.link = js_result
def handle_free(self, pyfile):
# step 1: get essential information: the media URL and the javascript translating the URL
m = re.search(self.MEDIA_URL_PATTERN, self.data)
if m is None:
self.fail(_("Could not find any media URLs"))
encoded_media_url = m.group(1)
self.log_debug(_("Found encoded media URL: %s") % encoded_media_url)
m = re.search(self.COMMUNITY_JS_PATTERN, self.data)
if m is None:
self.fail(_("Could not find necessary javascript script to load"))
community_js_url = m.group(1)
self.log_debug(_("Found community js at %s") % community_js_url)
community_js_code = self.load(community_js_url)
# step 2: from the js code, parse the necessary parts: the decoder function and the headers
# as the jscript is fairly long, we'll split it to make parsing easier
community_js_code = community_js_code.partition(self.JS_SPLIT_WORD)[0]
m = re.search(self.JS_HEADER_PATTERN, community_js_code)
if m is None:
self.fail(_("Could not parse the necessary parts off the javascript"))
decoder_function = m.group('decoder')
initialization = m.group('initvars')
m = re.search(self.JS_PROCESS_PATTERN, community_js_code)
if m is None:
self.fail(_("Could not parse the processing function off the javascript"))
process_function = m.group(0)
# step 3: assemble the new js code
js = JsEngine()
new_js_code = decoder_function + '; ' + initialization + '; var ' + process_function + '; processRecording("' + encoded_media_url + '");'
self.log_debug(_("Running js script: %s") % new_js_code)
js_result = js.eval(new_js_code)
self.log_debug(_("Result is: %s") % js_result)
self.link = js_result
def __init__(self):
self.log = NoLog()
self.api = self.core = self
self.threadManager = self
self.debug = True
self.captcha = True
self.config = ConfigParser()
self.pluginManager = PluginManager(self)
self.requestFactory = RequestFactory(self)
__builtin__.pyreq = self.requestFactory
self.accountManager = AccountManager()
self.addonManager = AddonManager()
self.eventManager = self.interActionManager = NoopClass()
self.js = JsEngine()
self.cache = {}
self.packageCache = {}
self.statusMsg = defaultdict(lambda: "statusmsg")
self.log = LogStub()
from module.web import ServerThread
if not ServerThread.core:
if ServerThread.setup:
SETUP = ServerThread.setup
config = SETUP.config
else:
raise Exception("Could not access pyLoad Core")
else:
PYLOAD = ServerThread.core.api
config = ServerThread.core.config
from module.common.JsEngine import JsEngine
JS = JsEngine()
TEMPLATE = config.get('webinterface', 'template')
DL_ROOT = config.get('general', 'download_folder')
LOG_ROOT = config.get('log', 'log_folder')
PREFIX = config.get('webinterface', 'prefix')
if PREFIX:
PREFIX = PREFIX.rstrip("/")
if PREFIX and not PREFIX.startswith("/"):
PREFIX = "/" + PREFIX
DEBUG = config.get("general", "debug_mode") or "-d" in sys.argv or "--debug" in sys.argv
bottle.debug(DEBUG)
cache = join("tmp", "jinja_cache")
def start(self, rpc=True, web=True):
""" starts the fun :D """
self.version = CURRENT_VERSION
if not exists("pyload.conf"):
from module.setup import Setup
print("This is your first start, running configuration assistent now.")
self.config = ConfigParser()
s = Setup(pypath, self.config)
res = False
try:
res = s.start()
except SystemExit:
pass
except KeyboardInterrupt:
print("\nSetup interrupted")
except:
res = False
print_exc()
print("Setup failed")
if not res:
remove("pyload.conf")
exit()
try: signal.signal(signal.SIGQUIT, self.quit)
except: pass
self.config = ConfigParser()
gettext.setpaths([join(os.sep, "usr", "share", "pyload", "locale"), None])
translation = gettext.translation("pyLoad", self.path("locale"),
languages=[self.config['general']['language'],"en"],fallback=True)
install_translation(translation)
self.debug = self.doDebug or self.config['general']['debug_mode']
self.remote &= self.config['remote']['activated']
pid = self.isAlreadyRunning()
if pid:
print(_("pyLoad already running with pid %s") % pid)
exit()
if not IS_WINDOWS and self.config["general"]["renice"]:
os.system("renice %d %d" % (self.config["general"]["renice"], os.getpid()))
if self.config["permission"]["change_group"]:
if not IS_WINDOWS:
try:
from grp import getgrnam
group = getgrnam(self.config["permission"]["group"])
os.setgid(group[2])
except Exception as e:
print(_("Failed changing group: %s") % e)
if self.config["permission"]["change_user"]:
if not IS_WINDOWS:
try:
from pwd import getpwnam
user = getpwnam(self.config["permission"]["user"])
os.setuid(user[2])
except Exception as e:
print(_("Failed changing user: %s") % e)
self.check_file(
self.config['log']['log_folder'],
_("folder for logs"),
is_folder=True,
)
if self.debug:
self.init_logger(logging.DEBUG) # logging level
else:
self.init_logger(logging.INFO) # logging level
sys.excepthook = exceptHook
self.do_kill = False
self.do_restart = False
self.shuttedDown = False
self.log.info(_("Starting") + " pyLoad %s" % CURRENT_VERSION)
self.log.info(_("Using home directory: %s") % getcwd())
self.writePidFile()
#@TODO refractor
remote.activated = self.remote
self.log.debug("Remote activated: %s" % self.remote)
self.check_install("Crypto", _("pycrypto to decode container files"))
#img = self.check_install("Image", _("Python Image Libary (PIL) for captcha reading"))
#self.check_install("pycurl", _("pycurl to download any files"), True, True)
self.check_file("tmp", _("folder for temporary files"), is_folder=True)
#tesser = self.check_install("tesseract", _("tesseract for captcha reading"), False) if not IS_WINDOWS else True
self.captcha = True # checks seems to fail, althoug tesseract is available
self.check_file(
self.config['general']['download_folder'],
_("folder for downloads"),
is_folder=True,
)
if self.config['ssl']['activated']:
self.check_install("OpenSSL", _("OpenSSL for secure connection"))
self.setupDB()
if self.deleteLinks:
self.log.info(_("All links removed"))
self.db.purgeLinks()
set_request_factory(RequestFactory(self))
self.lastClientConnected = 0
# later imported because they would trigger api import, and remote value not set correctly
from module import Api
from module.HookManager import HookManager
from module.ThreadManager import ThreadManager
if Api.activated != self.remote:
self.log.warning("Import error: API remote status not correct.")
self.api = Api.Api(self)
self.scheduler = Scheduler(self)
#hell yeah, so many important managers :D
set_plugin_manager(PluginManager(self))
set_pull_manager(PullManager(self))
set_thread_manager(ThreadManager(self))
set_account_manager(AccountManager(self))
set_captcha_manager(CaptchaManager(self))
# HookManager sets itself as a singleton
HookManager(self)
set_remote_manager(RemoteManager(self))
thread_manager = get_thread_manager()
self.js = JsEngine()
self.log.info(_("Downloadtime: %s") % self.api.isTimeDownload())
if rpc:
get_remote_manager().startBackends()
if web:
self.init_webserver()
spaceLeft = freeSpace(self.config["general"]["download_folder"])
self.log.info(_("Free space: %s") % formatSize(spaceLeft))
self.config.save() #save so config files gets filled
link_file = join(pypath, "links.txt")
if exists(link_file):
f = open(link_file, "rb")
if f.read().strip():
self.api.addPackage("links.txt", [link_file], 1)
f.close()
link_file = "links.txt"
if exists(link_file):
f = open(link_file, "rb")
if f.read().strip():
self.api.addPackage("links.txt", [link_file], 1)
f.close()
#self.scheduler.addJob(0, get_account_manager().getAccountInfos)
self.log.info(_("Activating Accounts..."))
get_account_manager().getAccountInfos()
thread_manager.pause = False
self.running = True
self.log.info(_("Activating Plugins..."))
get_hook_manager().coreReady()
self.log.info(_("pyLoad is up and running"))
#test api
# from module.common.APIExerciser import startApiExerciser
# startApiExerciser(self, 3)
#some memory stats
# from guppy import hpy
# hp=hpy()
# import objgraph
# objgraph.show_most_common_types(limit=20)
# import memdebug
# memdebug.start(8002)
locals().clear()
while True:
try:
sleep(2)
except IOError as e:
if e.errno != 4: # errno.EINTR
raise
if self.do_restart:
self.log.info(_("restarting pyLoad"))
self.restart()
if self.do_kill:
self.shutdown()
self.log.info(_("pyLoad quits"))
self.removeLogger()
_exit(0) #@TODO thrift blocks shutdown
thread_manager.work()
self.scheduler.work()