dockeruser
/
sabnzbd
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Remove wrapper layer from Downloader.

tags/0.6.0
ShyPike 15 years ago
parent
a8d89d4614
commit
3cb5744682
11 changed files with 120 additions and 218 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      SABnzbd.py
  2. 18
      SABnzbdDelegate.py
  3. 36
      sabnzbd/__init__.py
  4. 26
      sabnzbd/api.py
  5. 8
      sabnzbd/decoder.py
  6. 208
      sabnzbd/downloader.py
  7. 16
      sabnzbd/interface.py
  8. 2
      sabnzbd/newswrapper.py
  9. 2
      sabnzbd/nzbqueue.py
  10. 6
      sabnzbd/postproc.py
  11. 12
      sabnzbd/scheduler.py

4
SABnzbd.py
View File

@ -74,7 +74,7 @@ from sabnzbd.misc import get_user_shellfolders, launch_a_browser, real_path, \
import sabnzbd.scheduler as scheduler import sabnzbd.scheduler as scheduler
import sabnzbd.config as config import sabnzbd.config as config
import sabnzbd.cfg import sabnzbd.cfg
import sabnzbd.downloader as downloader import sabnzbd.downloader
from sabnzbd.encoding import unicoder from sabnzbd.encoding import unicoder
from sabnzbd.utils import osx from sabnzbd.utils import osx
@ -1412,7 +1412,7 @@ def main():
sabnzbd.halt() sabnzbd.halt()
cherrypy.engine.exit() cherrypy.engine.exit()
sabnzbd.SABSTOP = True sabnzbd.SABSTOP = True
if downloader.paused(): if sabnzbd.downloader.Downloader.do.paused:
re_argv.append('-p') re_argv.append('-p')
if autorestarted: if autorestarted:
re_argv.append('--autorestarted') re_argv.append('--autorestarted')

18
SABnzbdDelegate.py
View File

@ -41,7 +41,7 @@ from sabnzbd.utils import osx
from sabnzbd.nzbqueue import NzbQueue from sabnzbd.nzbqueue import NzbQueue
import sabnzbd.config as config import sabnzbd.config as config
import sabnzbd.scheduler as scheduler import sabnzbd.scheduler as scheduler
import sabnzbd.downloader as downloader import sabnzbd.downloader
import sabnzbd.dirscanner as dirscanner import sabnzbd.dirscanner as dirscanner
from sabnzbd.bpsmeter import BPSMeter from sabnzbd.bpsmeter import BPSMeter
from sabnzbd.newzbin import Bookmarks from sabnzbd.newzbin import Bookmarks
@ -95,7 +95,7 @@ class SABnzbdDelegate(NSObject):
#Variables #Variables
self.state = "Idle" self.state = "Idle"
self.speed = downloader.get_limit() self.speed = sabnzbd.downloader.Downloader.do.get_limit()
self.version_notify = 1 self.version_notify = 1
self.status_removed = 0 self.status_removed = 0
@ -417,7 +417,7 @@ class SABnzbdDelegate(NSObject):
try: try:
qnfo = NzbQueue.do.queue_info() qnfo = NzbQueue.do.queue_info()
bpsnow = BPSMeter.do.get_bps() bpsnow = BPSMeter.do.get_bps()
if downloader.paused(): if sabnzbd.downloader.Downloader.do.paused:
self.state = T('Paused') self.state = T('Paused')
if sabnzbd.scheduler.pause_int() != "0": if sabnzbd.scheduler.pause_int() != "0":
self.setMenuTitle("\n\n%s\n" % (sabnzbd.scheduler.pause_int())) self.setMenuTitle("\n\n%s\n" % (sabnzbd.scheduler.pause_int()))
@ -454,7 +454,7 @@ class SABnzbdDelegate(NSObject):
def iconUpdate(self): def iconUpdate(self):
try: try:
if downloader.paused(): if sabnzbd.downloader.Downloader.do.paused:
self.status_item.setImage_(self.icons['pause']) self.status_item.setImage_(self.icons['pause'])
else: else:
self.status_item.setImage_(self.icons['idle']) self.status_item.setImage_(self.icons['idle'])
@ -463,7 +463,7 @@ class SABnzbdDelegate(NSObject):
def pauseUpdate(self): def pauseUpdate(self):
try: try:
if downloader.paused(): if sabnzbd.downloader.Downloader.do.paused:
if self.isLeopard: if self.isLeopard:
self.resume_menu_item.setHidden_(NO) self.resume_menu_item.setHidden_(NO)
self.pause_menu_item.setHidden_(YES) self.pause_menu_item.setHidden_(YES)
@ -482,7 +482,7 @@ class SABnzbdDelegate(NSObject):
def speedlimitUpdate(self): def speedlimitUpdate(self):
try: try:
speed = int(downloader.get_limit()) speed = int(sabnzbd.downloader.Downloader.do.get_limit())
if self.speed != speed : if self.speed != speed :
self.speed = speed self.speed = speed
speedsValues = self.menu_speed.numberOfItems() speedsValues = self.menu_speed.numberOfItems()
@ -654,14 +654,14 @@ class SABnzbdDelegate(NSObject):
#logging.info("[osx] speed limit to %s" % (sender.representedObject())) #logging.info("[osx] speed limit to %s" % (sender.representedObject()))
speed = int(sender.representedObject()) speed = int(sender.representedObject())
if speed != self.speed: if speed != self.speed:
downloader.limit_speed(speed) sabnzbd.downloader.Downloader.do.limit_speed(speed)
self.speedlimitUpdate() self.speedlimitUpdate()
def purgeAction_(self, sender): def purgeAction_(self, sender):
mode = sender.representedObject() mode = sender.representedObject()
#logging.info("[osx] purge %s" % (mode)) #logging.info("[osx] purge %s" % (mode))
if mode == "queue": if mode == "queue":
NzbQueue.do.remove_all_nzo() NzbQueue.do.remove_all()
elif mode == "history": elif mode == "history":
history_db = sabnzbd.database.get_history_handle() history_db = sabnzbd.database.get_history_handle()
history_db.remove_history() history_db.remove_history()
@ -672,7 +672,7 @@ class SABnzbdDelegate(NSObject):
if minutes: if minutes:
scheduler.plan_resume(minutes) scheduler.plan_resume(minutes)
else: else:
downloader.pause_downloader() sabnzbd.downloader.Downloader.do.pause()
def resumeAction_(self, sender): def resumeAction_(self, sender):
scheduler.plan_resume(0) scheduler.plan_resume(0)

36
sabnzbd/__init__.py
View File

@ -64,7 +64,7 @@ elif os.name == 'posix':
from sabnzbd.nzbqueue import NzbQueue from sabnzbd.nzbqueue import NzbQueue
from sabnzbd.postproc import PostProcessor from sabnzbd.postproc import PostProcessor
import sabnzbd.downloader as downloader from sabnzbd.downloader import Downloader
from sabnzbd.assembler import Assembler from sabnzbd.assembler import Assembler
from sabnzbd.newzbin import Bookmarks, MSGIDGrabber from sabnzbd.newzbin import Bookmarks, MSGIDGrabber
import sabnzbd.misc as misc import sabnzbd.misc as misc
@ -268,7 +268,7 @@ def initialize(pause_downloader = False, clean_up = False, evalSched=False, repa
Assembler() Assembler()
downloader.init(pause_downloader) Downloader(pause_downloader)
DirScanner() DirScanner()
@ -297,7 +297,7 @@ def start():
Assembler.do.start() Assembler.do.start()
logging.debug('Starting downloader') logging.debug('Starting downloader')
downloader.start() Downloader.do.start()
scheduler.start() scheduler.start()
@ -346,7 +346,7 @@ def halt():
## Stop Required Objects ## ## Stop Required Objects ##
logging.debug('Stopping downloader') logging.debug('Stopping downloader')
downloader.stop() Downloader.stop()
logging.debug('Stopping assembler') logging.debug('Stopping assembler')
Assembler.do.stop() Assembler.do.stop()
@ -392,7 +392,7 @@ def guard_restart():
def guard_speedlimit(): def guard_speedlimit():
""" Callback for change of bandwidth_limit, sets actual speed """ """ Callback for change of bandwidth_limit, sets actual speed """
downloader.limit_speed(cfg.bandwidth_limit()) Downloader.do.limit_speed(cfg.bandwidth_limit())
def guard_top_only(): def guard_top_only():
""" Callback for change of top_only option """ """ Callback for change of top_only option """
@ -404,7 +404,7 @@ def guard_pause_on_pp():
pass # Not safe to idle downloader, because we don't know pass # Not safe to idle downloader, because we don't know
# if post-processing is active now # if post-processing is active now
else: else:
downloader.unidle_downloader() Downloader.do.resume_from_postproc()
def add_msgid(msgid, pp=None, script=None, cat=None, priority=None, nzbname=None): def add_msgid(msgid, pp=None, script=None, cat=None, priority=None, nzbname=None):
""" Add NZB based on newzbin report number, attributes optional """ Add NZB based on newzbin report number, attributes optional
@ -456,7 +456,7 @@ def pause_all():
""" """
global PAUSED_ALL global PAUSED_ALL
PAUSED_ALL = True PAUSED_ALL = True
sabnzbd.downloader.pause_downloader() Downloader.do.pause()
logging.debug('PAUSED_ALL active') logging.debug('PAUSED_ALL active')
def unpause_all(): def unpause_all():
@ -464,7 +464,7 @@ def unpause_all():
""" """
global PAUSED_ALL global PAUSED_ALL
PAUSED_ALL = False PAUSED_ALL = False
sabnzbd.downloader.resume_downloader() Downloader.do.resume()
logging.debug('PAUSED_ALL inactive') logging.debug('PAUSED_ALL inactive')
@ -577,7 +577,7 @@ def enable_server(server):
logging.warning(Ta('Trying to set status of non-existing server %s'), server) logging.warning(Ta('Trying to set status of non-existing server %s'), server)
return return
config.save_config() config.save_config()
downloader.update_server(server, server) Downloader.do.update_server(server, server)
def disable_server(server): def disable_server(server):
@ -589,7 +589,7 @@ def disable_server(server):
logging.warning(Ta('Trying to set status of non-existing server %s'), server) logging.warning(Ta('Trying to set status of non-existing server %s'), server)
return return
config.save_config() config.save_config()
downloader.update_server(server, server) Downloader.do.update_server(server, server)
def system_shutdown(): def system_shutdown():
@ -708,7 +708,7 @@ def keep_awake():
""" If we still have work to do, keep Windows system awake """ If we still have work to do, keep Windows system awake
""" """
global KERNEL32 global KERNEL32
if KERNEL32 and not downloader.paused(): if KERNEL32 and not sabnzbd.downloader.Downloader.do.paused:
if (not PostProcessor.do.empty()) or not NzbQueue.do.is_empty(): if (not PostProcessor.do.empty()) or not NzbQueue.do.is_empty():
# set ES_SYSTEM_REQUIRED # set ES_SYSTEM_REQUIRED
KERNEL32.SetThreadExecutionState(ctypes.c_int(0x00000001)) KERNEL32.SetThreadExecutionState(ctypes.c_int(0x00000001))
@ -717,11 +717,11 @@ def keep_awake():
def CheckFreeSpace(): def CheckFreeSpace():
""" Check if enough disk space is free, if not pause downloader and send email """ Check if enough disk space is free, if not pause downloader and send email
""" """
if cfg.download_free() and not downloader.paused(): if cfg.download_free() and not sabnzbd.downloader.Downloader.do.paused:
if misc.diskfree(cfg.download_dir.get_path()) < cfg.download_free.get_float() / GIGI: if misc.diskfree(cfg.download_dir.get_path()) < cfg.download_free.get_float() / GIGI:
logging.warning(Ta('Too little diskspace forcing PAUSE')) logging.warning(Ta('Too little diskspace forcing PAUSE'))
# Pause downloader, but don't save, since the disk is almost full! # Pause downloader, but don't save, since the disk is almost full!
downloader.pause_downloader(save=False) Downloader.do.pause(save=False)
emailer.diskfull() emailer.diskfull()
@ -927,7 +927,7 @@ def check_all_tasks():
if not sabnzbd.PostProcessor.do.isAlive(): if not sabnzbd.PostProcessor.do.isAlive():
logging.info('Restarting because of crashed postprocessor') logging.info('Restarting because of crashed postprocessor')
return False return False
if not sabnzbd.downloader.alive(): if not Downloader.do.isAlive():
logging.info('Restarting because of crashed downloader') logging.info('Restarting because of crashed downloader')
return False return False
if not Assembler.do.isAlive(): if not Assembler.do.isAlive():
@ -935,10 +935,10 @@ def check_all_tasks():
return False return False
# Kick the downloader, in case it missed the semaphore # Kick the downloader, in case it missed the semaphore
sabnzbd.downloader.wakeup() Downloader.do.wakeup()
# Make sure the right servers are active # Make sure the right servers are active
sabnzbd.downloader.check() Downloader.do.check_timers()
# Restartable threads # Restartable threads
if not DirScanner.do.isAlive(): if not DirScanner.do.isAlive():
@ -953,7 +953,7 @@ def check_all_tasks():
if not sabnzbd.scheduler.sched_check(): if not sabnzbd.scheduler.sched_check():
logging.info('Restarting crashed scheduler') logging.info('Restarting crashed scheduler')
sabnzbd.scheduler.init() sabnzbd.scheduler.init()
sabnzbd.downloader.unblock_all() sabnzbd.downloader.Downloader.do.unblock_all()
# Check one-shot pause # Check one-shot pause
sabnzbd.scheduler.pause_check() sabnzbd.scheduler.pause_check()
@ -963,7 +963,7 @@ def check_all_tasks():
# Required wrapper because nzbstuff.py cannot import downloader.py # Required wrapper because nzbstuff.py cannot import downloader.py
def active_primaries(): def active_primaries():
return sabnzbd.downloader.active_primaries() return sabnzbd.downloader.Downloader.do.active_primaries()
def proxy_postproc(nzo): def proxy_postproc(nzo):

26
sabnzbd/api.py
View File

@ -31,7 +31,7 @@ import sabnzbd
from sabnzbd.constants import * from sabnzbd.constants import *
import sabnzbd.config as config import sabnzbd.config as config
import sabnzbd.cfg as cfg import sabnzbd.cfg as cfg
import sabnzbd.downloader as downloader from sabnzbd.downloader import Downloader
from sabnzbd.nzbqueue import NzbQueue, set_priority, sort_queue, scan_jobs, repair_job from sabnzbd.nzbqueue import NzbQueue, set_priority, sort_queue, scan_jobs, repair_job
import sabnzbd.nzbstuff as nzbstuff import sabnzbd.nzbstuff as nzbstuff
import sabnzbd.scheduler as scheduler import sabnzbd.scheduler as scheduler
@ -439,7 +439,7 @@ def _api_addid(name, output, kwargs):
def _api_pause(name, output, kwargs): def _api_pause(name, output, kwargs):
""" API: accepts output """ """ API: accepts output """
scheduler.plan_resume(0) scheduler.plan_resume(0)
downloader.pause_downloader() Downloader.do.pause()
return report(output) return report(output)
@ -519,7 +519,7 @@ def _api_restart_repair(name, output, kwargs):
def _api_disconnect(name, output, kwargs): def _api_disconnect(name, output, kwargs):
""" API: accepts output """ """ API: accepts output """
downloader.disconnect() Downloader.do.disconnect()
return report(output) return report(output)
@ -557,7 +557,7 @@ def _api_config_speedlimit(output, kwargs):
value = int(value) value = int(value)
except: except:
return report(output, _MSG_NO_VALUE) return report(output, _MSG_NO_VALUE)
downloader.limit_speed(value) Downloader.do.limit_speed(value)
return report(output) return report(output)
else: else:
return report(output, _MSG_NO_VALUE) return report(output, _MSG_NO_VALUE)
@ -565,7 +565,7 @@ def _api_config_speedlimit(output, kwargs):
def _api_config_get_speedlimit(output, kwargs): def _api_config_get_speedlimit(output, kwargs):
""" API: accepts output """ """ API: accepts output """
return report(output, keyword='speedlimit', data=int(downloader.get_limit())) return report(output, keyword='speedlimit', data=int(Downloader.do.get_limit()))
def _api_config_set_colorscheme(output, kwargs): def _api_config_set_colorscheme(output, kwargs):
@ -805,7 +805,7 @@ def handle_server_api(output, kwargs):
else: else:
config.ConfigServer(name, kwargs) config.ConfigServer(name, kwargs)
old_name = None old_name = None
downloader.update_server(old_name, name) Downloader.do.update_server(old_name, name)
return name return name
@ -912,7 +912,7 @@ def build_queue(web_dir=None, root=None, verbose=False, prim=True, verbose_list=
slot['mb'] = "%.2f" % mb slot['mb'] = "%.2f" % mb
slot['size'] = format_bytes(bytes) slot['size'] = format_bytes(bytes)
slot['sizeleft'] = format_bytes(bytesleft) slot['sizeleft'] = format_bytes(bytesleft)
if not downloader.paused() and status != 'Paused' and status != 'Fetching' and not found_active: if not Downloader.do.paused and status != 'Paused' and status != 'Fetching' and not found_active:
slot['status'] = "Downloading" slot['status'] = "Downloading"
found_active = True found_active = True
else: else:
@ -1057,14 +1057,14 @@ def qstatus_data():
"timeleft":calc_timeleft(bytesleftprogess, bpsnow) } ) "timeleft":calc_timeleft(bytesleftprogess, bpsnow) } )
state = "IDLE" state = "IDLE"
if downloader.paused(): if Downloader.do.paused:
state = "PAUSED" state = "PAUSED"
elif qnfo[QNFO_BYTES_LEFT_FIELD] / MEBI > 0: elif qnfo[QNFO_BYTES_LEFT_FIELD] / MEBI > 0:
state = "DOWNLOADING" state = "DOWNLOADING"
status = { status = {
"state" : state, "state" : state,
"paused" : downloader.paused(), "paused" : Downloader.do.paused,
"pause_int" : scheduler.pause_int(), "pause_int" : scheduler.pause_int(),
"kbpersec" : BPSMeter.do.get_bps() / KIBI, "kbpersec" : BPSMeter.do.get_bps() / KIBI,
"speed" : to_units(BPSMeter.do.get_bps(), dec_limit=1), "speed" : to_units(BPSMeter.do.get_bps(), dec_limit=1),
@ -1310,10 +1310,10 @@ def build_header(prim):
else: else:
color = '' color = ''
header = { 'T': Ttemplate, 'Tspec': Tspec, 'Tx' : Ttemplate, 'version':sabnzbd.__version__, 'paused':downloader.paused(), header = { 'T': Ttemplate, 'Tspec': Tspec, 'Tx' : Ttemplate, 'version':sabnzbd.__version__, 'paused': Downloader.do.paused,
'pause_int': scheduler.pause_int(), 'paused_all': sabnzbd.PAUSED_ALL, 'pause_int': scheduler.pause_int(), 'paused_all': sabnzbd.PAUSED_ALL,
'uptime':uptime, 'color_scheme':color } 'uptime':uptime, 'color_scheme':color }
speed_limit = downloader.get_limit() speed_limit = Downloader.do.get_limit()
if speed_limit <= 0: if speed_limit <= 0:
speed_limit = '' speed_limit = ''
@ -1354,7 +1354,7 @@ def build_header(prim):
header['size'] = format_bytes(bytes) header['size'] = format_bytes(bytes)
status = '' status = ''
if downloader.paused(): if Downloader.do.paused:
status = 'Paused' status = 'Paused'
elif bytespersec > 0: elif bytespersec > 0:
status = 'Downloading' status = 'Downloading'
@ -1676,7 +1676,7 @@ def del_from_section(kwargs):
del item del item
config.save_config() config.save_config()
if section == 'servers': if section == 'servers':
downloader.update_server(keyword, None) Downloader.do.update_server(keyword, None)
return True return True
else: else:
return False return False

8
sabnzbd/decoder.py
View File

@ -63,7 +63,7 @@ class Decoder(Thread):
def decode(self, article, lines): def decode(self, article, lines):
self.queue.put((article, lines)) self.queue.put((article, lines))
if self.queue.qsize() > MAX_DECODE_QUEUE: if self.queue.qsize() > MAX_DECODE_QUEUE:
sabnzbd.downloader.delay_downloader() sabnzbd.downloader.Downloader.do.delay()
def stop(self): def stop(self):
self.queue.put(None) self.queue.put(None)
@ -75,8 +75,8 @@ class Decoder(Thread):
if not art_tup: if not art_tup:
break break
if self.queue.qsize() < MIN_DECODE_QUEUE and sabnzbd.downloader.delayed(): if self.queue.qsize() < MIN_DECODE_QUEUE and sabnzbd.downloader.Downloader.do.delayed:
sabnzbd.downloader.undelay_downloader() sabnzbd.downloader.Downloader.do.undelay()
article, lines = art_tup article, lines = art_tup
nzf = article.nzf nzf = article.nzf
@ -96,7 +96,7 @@ class Decoder(Thread):
except IOError, e: except IOError, e:
logme = Ta('Decoding %s failed') % article logme = Ta('Decoding %s failed') % article
logging.info(logme) logging.info(logme)
sabnzbd.downloader.pause_downloader() sabnzbd.downloader.Downloader.do.pause()
article.fetcher = None article.fetcher = None

208
sabnzbd/downloader.py
View File

@ -50,151 +50,6 @@ _PENALTY_SHORT = 1 # Minimal penalty when no_penalties is set
TIMER_LOCK = RLock() TIMER_LOCK = RLock()
#------------------------------------------------------------------------------ #------------------------------------------------------------------------------
# Wrapper functions
__DOWNLOADER = None # Global pointer to post-proc instance
def init(paused):
global __DOWNLOADER
if __DOWNLOADER:
__DOWNLOADER.__init__(paused or __DOWNLOADER.paused)
else:
__DOWNLOADER = Downloader(paused)
def start():
global __DOWNLOADER
if __DOWNLOADER: __DOWNLOADER.start()
def servers():
global __DOWNLOADER
if __DOWNLOADER: return __DOWNLOADER.servers
def stop():
global __DOWNLOADER
CV.acquire()
try:
__DOWNLOADER.stop()
finally:
CV.notifyAll()
CV.release()
try:
__DOWNLOADER.join()
except:
pass
def alive():
global __DOWNLOADER
if __DOWNLOADER:
return __DOWNLOADER.isAlive()
else:
return False
#------------------------------------------------------------------------------
@synchronized_CV
def check():
global __DOWNLOADER
if __DOWNLOADER:
__DOWNLOADER.check_timers()
@synchronized_CV
def pause_downloader(save=True):
global __DOWNLOADER
if __DOWNLOADER:
__DOWNLOADER.pause()
if cfg.autodisconnect():
__DOWNLOADER.disconnect()
if save:
sabnzbd.save_state()
@synchronized_CV
def resume_downloader():
global __DOWNLOADER
if __DOWNLOADER: __DOWNLOADER.resume()
@synchronized_CV
def delay_downloader():
global __DOWNLOADER
if __DOWNLOADER: __DOWNLOADER.delay()
@synchronized_CV
def undelay_downloader():
global __DOWNLOADER
if __DOWNLOADER: __DOWNLOADER.undelay()
@synchronized_CV
def idle_downloader():
global __DOWNLOADER
if __DOWNLOADER: __DOWNLOADER.wait_postproc()
@synchronized_CV
def unidle_downloader():
global __DOWNLOADER
if __DOWNLOADER: __DOWNLOADER.resume_postproc()
@synchronized_CV
def limit_speed(value):
global __DOWNLOADER
if __DOWNLOADER: __DOWNLOADER.limit_speed(int(value))
logging.info("Bandwidth limit set to %s", value)
def update_server(oldserver, newserver):
global __DOWNLOADER
try:
CV.acquire()
try:
__DOWNLOADER.init_server(oldserver, newserver)
finally:
CV.notifyAll()
CV.release()
except:
logging.exception("Error accessing DOWNLOADER?")
@synchronized_CV
def set_paused(state):
global __DOWNLOADER
if __DOWNLOADER: __DOWNLOADER.paused = state
@synchronized_CV
def unblock(server):
global __DOWNLOADER
if __DOWNLOADER: return __DOWNLOADER.unblock(server)
@synchronized_CV
def unblock_all():
global __DOWNLOADER
if __DOWNLOADER: __DOWNLOADER.unblock_all()
@synchronized_CV
def wakeup():
# Just let the decorator rattle the semaphore
pass
#------------------------------------------------------------------------------
def paused():
global __DOWNLOADER
if __DOWNLOADER: return __DOWNLOADER.paused
def get_limit():
global __DOWNLOADER
if __DOWNLOADER: return __DOWNLOADER.get_limit()
def disconnect():
global __DOWNLOADER
if __DOWNLOADER: __DOWNLOADER.disconnect()
def delayed():
global __DOWNLOADER
if __DOWNLOADER: return __DOWNLOADER.delayed
def active_primaries():
global __DOWNLOADER
if __DOWNLOADER: return __DOWNLOADER.active_primaries()
#------------------------------------------------------------------------------
class Server(object): class Server(object):
def __init__(self, id, host, port, timeout, threads, fillserver, ssl, username = None, def __init__(self, id, host, port, timeout, threads, fillserver, ssl, username = None,
password = None, optional=False, retention=0): password = None, optional=False, retention=0):
@ -245,6 +100,10 @@ class Server(object):
#------------------------------------------------------------------------------ #------------------------------------------------------------------------------
class Downloader(Thread): class Downloader(Thread):
""" Singleton Downloader Thread
"""
do = None
def __init__(self, paused=False): def __init__(self, paused=False):
Thread.__init__(self) Thread.__init__(self)
@ -280,7 +139,7 @@ class Downloader(Thread):
self.init_server(None, server) self.init_server(None, server)
self.decoder = Decoder(self.servers) self.decoder = Decoder(self.servers)
Downloader.do = self
def init_server(self, oldserver, newserver): def init_server(self, oldserver, newserver):
""" Setup or re-setup single server """ Setup or re-setup single server
@ -325,42 +184,54 @@ class Downloader(Thread):
return primary return primary
def stop(self): @synchronized_CV
self.shutdown = True def set_paused(self, state):
osx.sendGrowlMsg("SABnzbd",T('Shutting down'),osx.NOTIFICATION['startup']) self.paused = state
@synchronized_CV
def resume(self): def resume(self):
logging.info("Resuming") logging.info("Resuming")
self.paused = False self.paused = False
def pause(self): @synchronized_CV
def pause(self, save=True):
logging.info("Pausing") logging.info("Pausing")
osx.sendGrowlMsg("SABnzbd",T('Paused'),osx.NOTIFICATION['download']) osx.sendGrowlMsg("SABnzbd",T('Paused'),osx.NOTIFICATION['download'])
self.paused = True self.paused = True
if self.is_paused(): if self.is_paused():
BPSMeter.do.reset() BPSMeter.do.reset()
if cfg.autodisconnect():
self.disconnect()
if save:
sabnzbd.save_state()
@synchronized_CV
def delay(self): def delay(self):
logging.debug("Delaying") logging.debug("Delaying")
self.delayed = True self.delayed = True
@synchronized_CV
def undelay(self): def undelay(self):
logging.debug("Undelaying") logging.debug("Undelaying")
self.delayed = False self.delayed = False
def wait_postproc(self): @synchronized_CV
def wait_for_postproc(self):
logging.info("Waiting for post-processing to finish") logging.info("Waiting for post-processing to finish")
self.postproc = True self.postproc = True
def resume_postproc(self): @synchronized_CV
def resume_from_postproc(self):
logging.info("Post-processing finished, resuming download") logging.info("Post-processing finished, resuming download")
self.postproc = False self.postproc = False
def disconnect(self): def disconnect(self):
self.force_disconnect = True self.force_disconnect = True
@synchronized_CV
def limit_speed(self, value): def limit_speed(self, value):
self.bandwidth_limit = value self.bandwidth_limit = int(value)
logging.info("Bandwidth limit set to %s", value)
def get_limit(self): def get_limit(self):
return self.bandwidth_limit return self.bandwidth_limit
@ -812,6 +683,7 @@ class Downloader(Thread):
del self._timers[server_id] del self._timers[server_id]
self.init_server(server_id, server_id) self.init_server(server_id, server_id)
@synchronized_CV
@synchronized(TIMER_LOCK) @synchronized(TIMER_LOCK)
def unblock(self, server_id): def unblock(self, server_id):
# Remove timer # Remove timer
@ -826,10 +698,12 @@ class Downloader(Thread):
self.init_server(server_id, server_id) self.init_server(server_id, server_id)
break break
def unblock_all(self): def unblock_all(self):
for server_id in self._timers.keys(): for server_id in self._timers.keys():
self.unblock(server_id) self.unblock(server_id)
@synchronized_CV
@synchronized(TIMER_LOCK) @synchronized(TIMER_LOCK)
def check_timers(self): def check_timers(self):
""" Make sure every server without a non-expired timer is active """ """ Make sure every server without a non-expired timer is active """
@ -849,6 +723,34 @@ class Downloader(Thread):
logging.debug('Forcing activation of server %s', server.id) logging.debug('Forcing activation of server %s', server.id)
self.init_server(server.id, server.id) self.init_server(server.id, server.id)
@synchronized_CV
def update_server(self, oldserver, newserver):
self.init_server(oldserver, newserver)
@synchronized_CV
def wakeup(self):
""" Just rattle the semaphore
"""
pass
def stop(self):
self.shutdown = True
osx.sendGrowlMsg("SABnzbd",T('Shutting down'),osx.NOTIFICATION['startup'])
def stop():
CV.acquire()
try:
Downloader.do.stop()
finally:
CV.notifyAll()
CV.release()
try:
Downloader.do.join()
except:
pass
#------------------------------------------------------------------------------ #------------------------------------------------------------------------------
def clues_login(text): def clues_login(text):
""" Check for any "failed login" clues in the response code """ Check for any "failed login" clues in the response code

16
sabnzbd/interface.py
View File

@ -45,7 +45,7 @@ import sabnzbd.config as config
import sabnzbd.cfg as cfg import sabnzbd.cfg as cfg
import sabnzbd.newsunpack import sabnzbd.newsunpack
from sabnzbd.postproc import PostProcessor from sabnzbd.postproc import PostProcessor
import sabnzbd.downloader as downloader from sabnzbd.downloader import Downloader
from sabnzbd.nzbqueue import NzbQueue from sabnzbd.nzbqueue import NzbQueue
import sabnzbd.wizard import sabnzbd.wizard
from sabnzbd.utils.servertests import test_nntp_server_dict from sabnzbd.utils.servertests import test_nntp_server_dict
@ -344,7 +344,7 @@ class MainPage(object):
if msg: return msg if msg: return msg
scheduler.plan_resume(0) scheduler.plan_resume(0)
downloader.pause_downloader() Downloader.do.pause()
raise dcRaiser(self.__root, kwargs) raise dcRaiser(self.__root, kwargs)
@cherrypy.expose @cherrypy.expose
@ -752,7 +752,7 @@ class QueuePage(object):
msg = check_session(kwargs) msg = check_session(kwargs)
if msg: return msg if msg: return msg
scheduler.plan_resume(0) scheduler.plan_resume(0)
downloader.pause_downloader() Downloader.do.pause()
raise queueRaiser(self.__root, kwargs) raise queueRaiser(self.__root, kwargs)
@cherrypy.expose @cherrypy.expose
@ -811,7 +811,7 @@ class QueuePage(object):
def set_speedlimit(self, **kwargs): def set_speedlimit(self, **kwargs):
msg = check_session(kwargs) msg = check_session(kwargs)
if msg: return msg if msg: return msg
downloader.limit_speed(int_conv(kwargs.get('value'))) Downloader.do.limit_speed(int_conv(kwargs.get('value')))
raise dcRaiser(self.__root, kwargs) raise dcRaiser(self.__root, kwargs)
@cherrypy.expose @cherrypy.expose
@ -1443,7 +1443,7 @@ def handle_server(kwargs, root=None):
config.ConfigServer(server, kwargs) config.ConfigServer(server, kwargs)
config.save_config() config.save_config()
downloader.update_server(old_server, server) Downloader.do.update_server(old_server, server)
if root: if root:
raise dcRaiser(root, kwargs) raise dcRaiser(root, kwargs)
@ -2066,7 +2066,7 @@ class ConnectionInfo(object):
header['servers'] = [] header['servers'] = []
for server in downloader.servers()[:]: for server in Downloader.do.servers[:]:
busy = [] busy = []
connected = 0 connected = 0
@ -2121,7 +2121,7 @@ class ConnectionInfo(object):
def disconnect(self, **kwargs): def disconnect(self, **kwargs):
msg = check_session(kwargs) msg = check_session(kwargs)
if msg: return msg if msg: return msg
downloader.disconnect() Downloader.do.disconnect()
raise dcRaiser(self.__root, kwargs) raise dcRaiser(self.__root, kwargs)
@cherrypy.expose @cherrypy.expose
@ -2177,7 +2177,7 @@ class ConnectionInfo(object):
def unblock_server(self, **kwargs): def unblock_server(self, **kwargs):
msg = check_session(kwargs) msg = check_session(kwargs)
if msg: return msg if msg: return msg
downloader.unblock(kwargs.get('server')) Downloader.do.unblock(kwargs.get('server'))
# Short sleep so that UI shows new server status # Short sleep so that UI shows new server status
time.sleep(1.0) time.sleep(1.0)
raise dcRaiser(self.__root, kwargs) raise dcRaiser(self.__root, kwargs)

2
sabnzbd/newswrapper.py
View File

@ -72,7 +72,7 @@ def _retrieve_info(server):
else: else:
server.bad_cons = 0 server.bad_cons = 0
(server.info, server.request) = (info, False) (server.info, server.request) = (info, False)
sabnzbd.downloader.wakeup() sabnzbd.downloader.Downloader.do.wakeup()
def request_server_info(server): def request_server_info(server):

2
sabnzbd/nzbqueue.py
View File

@ -688,7 +688,7 @@ class NzbQueue(TryList):
if not self.__nzo_list: if not self.__nzo_list:
# Close server connections # Close server connections
if cfg.autodisconnect(): if cfg.autodisconnect():
sabnzbd.downloader.disconnect() sabnzbd.downloader.Downloader.do.disconnect()
# Sets the end-of-queue back on if disabled # Sets the end-of-queue back on if disabled
# adding an nzb and re-adding for more blocks disables it # adding an nzb and re-adding for more blocks disables it

6
sabnzbd/postproc.py
View File

@ -159,7 +159,7 @@ class PostProcessor(Thread):
## Pause downloader, if users wants that ## Pause downloader, if users wants that
if cfg.pause_on_post_processing(): if cfg.pause_on_post_processing():
sabnzbd.downloader.idle_downloader() sabnzbd.downloader.Downloader.do.wait_for_postproc()
cfg.complete_dir.set_create() cfg.complete_dir.set_create()
self.__busy = True self.__busy = True
@ -167,7 +167,7 @@ class PostProcessor(Thread):
self.remove(nzo) self.remove(nzo)
## Allow download to proceed ## Allow download to proceed
sabnzbd.downloader.unidle_downloader() sabnzbd.downloader.Downloader.do.resume_from_postproc()
#end PostProcessor class #end PostProcessor class
@ -485,7 +485,7 @@ def parring(nzo, workdir):
sabnzbd.QUEUECOMPLETEACTION_GO = False sabnzbd.QUEUECOMPLETEACTION_GO = False
nzo.priority = TOP_PRIORITY nzo.priority = TOP_PRIORITY
sabnzbd.nzbqueue.add_nzo(nzo) sabnzbd.nzbqueue.add_nzo(nzo)
sabnzbd.downloader.unidle_downloader() sabnzbd.downloader.Downloader.do.resume_from_postproc()
logging.info('Par2 check finished on %s', filename) logging.info('Par2 check finished on %s', filename)

12
sabnzbd/scheduler.py
View File

@ -90,7 +90,7 @@ def init():
action = scheduled_resume action = scheduled_resume
arguments = [] arguments = []
elif action_name == 'pause': elif action_name == 'pause':
action = sabnzbd.downloader.pause_downloader action = sabnzbd.downloader.Downloader.do.pause
arguments = [] arguments = []
elif action_name == 'pause_all': elif action_name == 'pause_all':
action = sabnzbd.pause_all action = sabnzbd.pause_all
@ -106,7 +106,7 @@ def init():
elif action_name == 'resume_post': elif action_name == 'resume_post':
action = pp_resume action = pp_resume
elif action_name == 'speedlimit' and arguments != []: elif action_name == 'speedlimit' and arguments != []:
action = sabnzbd.downloader.limit_speed action = sabnzbd.downloader.Downloader.do.limit_speed
elif action_name == 'enable_server' and arguments != []: elif action_name == 'enable_server' and arguments != []:
action = sabnzbd.enable_server action = sabnzbd.enable_server
elif action_name == 'disable_server' and arguments != []: elif action_name == 'disable_server' and arguments != []:
@ -185,7 +185,7 @@ def restart(force=False):
SCHEDULE_GUARD_FLAG = False SCHEDULE_GUARD_FLAG = False
stop() stop()
analyse(sabnzbd.downloader.paused()) analyse(sabnzbd.sabnzbd.downloader.Downloader.do.paused)
init() init()
start() start()
@ -299,11 +299,11 @@ def analyse(was_paused=False):
sabnzbd.pause_all() sabnzbd.pause_all()
else: else:
sabnzbd.unpause_all() sabnzbd.unpause_all()
sabnzbd.downloader.set_paused(paused or paused_all) sabnzbd.downloader.Downloader.do.set_paused(paused or paused_all)
PostProcessor.do.pause = pause_post PostProcessor.do.pause = pause_post
if speedlimit: if speedlimit:
sabnzbd.downloader.limit_speed(speedlimit) sabnzbd.downloader.Downloader.do.limit_speed(speedlimit)
for serv in servers: for serv in servers:
try: try:
config.get_config('servers', serv).enable.set(servers[serv]) config.get_config('servers', serv).enable.set(servers[serv])
@ -346,7 +346,7 @@ def plan_resume(interval):
__PAUSE_END = time.time() + (interval * 60) __PAUSE_END = time.time() + (interval * 60)
logging.debug('Schedule resume at %s', __PAUSE_END) logging.debug('Schedule resume at %s', __PAUSE_END)
__SCHED.add_single_task(__oneshot_resume, '', interval*60, kronos.method.sequential, [__PAUSE_END], None) __SCHED.add_single_task(__oneshot_resume, '', interval*60, kronos.method.sequential, [__PAUSE_END], None)
sabnzbd.downloader.pause_downloader() sabnzbd.downloader.Downloader.do.pause()
else: else:
__PAUSE_END = None __PAUSE_END = None
sabnzbd.unpause_all() sabnzbd.unpause_all()

Write Preview
Loading…
Cancel
Save