Browse Source

Remove wrapper layer from Downloader.

tags/0.6.0
ShyPike 15 years ago
parent
commit
3cb5744682
  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

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

18
SABnzbdDelegate.py

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

36
sabnzbd/__init__.py

@ -64,7 +64,7 @@ elif os.name == 'posix':
from sabnzbd.nzbqueue import NzbQueue
from sabnzbd.postproc import PostProcessor
import sabnzbd.downloader as downloader
from sabnzbd.downloader import Downloader
from sabnzbd.assembler import Assembler
from sabnzbd.newzbin import Bookmarks, MSGIDGrabber
import sabnzbd.misc as misc
@ -268,7 +268,7 @@ def initialize(pause_downloader = False, clean_up = False, evalSched=False, repa
Assembler()
downloader.init(pause_downloader)
Downloader(pause_downloader)
DirScanner()
@ -297,7 +297,7 @@ def start():
Assembler.do.start()
logging.debug('Starting downloader')
downloader.start()
Downloader.do.start()
scheduler.start()
@ -346,7 +346,7 @@ def halt():
## Stop Required Objects ##
logging.debug('Stopping downloader')
downloader.stop()
Downloader.stop()
logging.debug('Stopping assembler')
Assembler.do.stop()
@ -392,7 +392,7 @@ def guard_restart():
def guard_speedlimit():
""" 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():
""" 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
# if post-processing is active now
else:
downloader.unidle_downloader()
Downloader.do.resume_from_postproc()
def add_msgid(msgid, pp=None, script=None, cat=None, priority=None, nzbname=None):
""" Add NZB based on newzbin report number, attributes optional
@ -456,7 +456,7 @@ def pause_all():
"""
global PAUSED_ALL
PAUSED_ALL = True
sabnzbd.downloader.pause_downloader()
Downloader.do.pause()
logging.debug('PAUSED_ALL active')
def unpause_all():
@ -464,7 +464,7 @@ def unpause_all():
"""
global PAUSED_ALL
PAUSED_ALL = False
sabnzbd.downloader.resume_downloader()
Downloader.do.resume()
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)
return
config.save_config()
downloader.update_server(server, server)
Downloader.do.update_server(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)
return
config.save_config()
downloader.update_server(server, server)
Downloader.do.update_server(server, server)
def system_shutdown():
@ -708,7 +708,7 @@ def keep_awake():
""" If we still have work to do, keep Windows system awake
"""
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():
# set ES_SYSTEM_REQUIRED
KERNEL32.SetThreadExecutionState(ctypes.c_int(0x00000001))
@ -717,11 +717,11 @@ def keep_awake():
def CheckFreeSpace():
""" 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:
logging.warning(Ta('Too little diskspace forcing PAUSE'))
# Pause downloader, but don't save, since the disk is almost full!
downloader.pause_downloader(save=False)
Downloader.do.pause(save=False)
emailer.diskfull()
@ -927,7 +927,7 @@ def check_all_tasks():
if not sabnzbd.PostProcessor.do.isAlive():
logging.info('Restarting because of crashed postprocessor')
return False
if not sabnzbd.downloader.alive():
if not Downloader.do.isAlive():
logging.info('Restarting because of crashed downloader')
return False
if not Assembler.do.isAlive():
@ -935,10 +935,10 @@ def check_all_tasks():
return False
# Kick the downloader, in case it missed the semaphore
sabnzbd.downloader.wakeup()
Downloader.do.wakeup()
# Make sure the right servers are active
sabnzbd.downloader.check()
Downloader.do.check_timers()
# Restartable threads
if not DirScanner.do.isAlive():
@ -953,7 +953,7 @@ def check_all_tasks():
if not sabnzbd.scheduler.sched_check():
logging.info('Restarting crashed scheduler')
sabnzbd.scheduler.init()
sabnzbd.downloader.unblock_all()
sabnzbd.downloader.Downloader.do.unblock_all()
# Check one-shot pause
sabnzbd.scheduler.pause_check()
@ -963,7 +963,7 @@ def check_all_tasks():
# Required wrapper because nzbstuff.py cannot import downloader.py
def active_primaries():
return sabnzbd.downloader.active_primaries()
return sabnzbd.downloader.Downloader.do.active_primaries()
def proxy_postproc(nzo):

26
sabnzbd/api.py

@ -31,7 +31,7 @@ import sabnzbd
from sabnzbd.constants import *
import sabnzbd.config as config
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
import sabnzbd.nzbstuff as nzbstuff
import sabnzbd.scheduler as scheduler
@ -439,7 +439,7 @@ def _api_addid(name, output, kwargs):
def _api_pause(name, output, kwargs):
""" API: accepts output """
scheduler.plan_resume(0)
downloader.pause_downloader()
Downloader.do.pause()
return report(output)
@ -519,7 +519,7 @@ def _api_restart_repair(name, output, kwargs):
def _api_disconnect(name, output, kwargs):
""" API: accepts output """
downloader.disconnect()
Downloader.do.disconnect()
return report(output)
@ -557,7 +557,7 @@ def _api_config_speedlimit(output, kwargs):
value = int(value)
except:
return report(output, _MSG_NO_VALUE)
downloader.limit_speed(value)
Downloader.do.limit_speed(value)
return report(output)
else:
return report(output, _MSG_NO_VALUE)
@ -565,7 +565,7 @@ def _api_config_speedlimit(output, kwargs):
def _api_config_get_speedlimit(output, kwargs):
""" 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):
@ -805,7 +805,7 @@ def handle_server_api(output, kwargs):
else:
config.ConfigServer(name, kwargs)
old_name = None
downloader.update_server(old_name, name)
Downloader.do.update_server(old_name, 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['size'] = format_bytes(bytes)
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"
found_active = True
else:
@ -1057,14 +1057,14 @@ def qstatus_data():
"timeleft":calc_timeleft(bytesleftprogess, bpsnow) } )
state = "IDLE"
if downloader.paused():
if Downloader.do.paused:
state = "PAUSED"
elif qnfo[QNFO_BYTES_LEFT_FIELD] / MEBI > 0:
state = "DOWNLOADING"
status = {
"state" : state,
"paused" : downloader.paused(),
"paused" : Downloader.do.paused,
"pause_int" : scheduler.pause_int(),
"kbpersec" : BPSMeter.do.get_bps() / KIBI,
"speed" : to_units(BPSMeter.do.get_bps(), dec_limit=1),
@ -1310,10 +1310,10 @@ def build_header(prim):
else:
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,
'uptime':uptime, 'color_scheme':color }
speed_limit = downloader.get_limit()
speed_limit = Downloader.do.get_limit()
if speed_limit <= 0:
speed_limit = ''
@ -1354,7 +1354,7 @@ def build_header(prim):
header['size'] = format_bytes(bytes)
status = ''
if downloader.paused():
if Downloader.do.paused:
status = 'Paused'
elif bytespersec > 0:
status = 'Downloading'
@ -1676,7 +1676,7 @@ def del_from_section(kwargs):
del item
config.save_config()
if section == 'servers':
downloader.update_server(keyword, None)
Downloader.do.update_server(keyword, None)
return True
else:
return False

8
sabnzbd/decoder.py

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

208
sabnzbd/downloader.py

@ -50,151 +50,6 @@ _PENALTY_SHORT = 1 # Minimal penalty when no_penalties is set
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):
def __init__(self, id, host, port, timeout, threads, fillserver, ssl, username = None,
password = None, optional=False, retention=0):
@ -245,6 +100,10 @@ class Server(object):
#------------------------------------------------------------------------------
class Downloader(Thread):
""" Singleton Downloader Thread
"""
do = None
def __init__(self, paused=False):
Thread.__init__(self)
@ -280,7 +139,7 @@ class Downloader(Thread):
self.init_server(None, server)
self.decoder = Decoder(self.servers)
Downloader.do = self
def init_server(self, oldserver, newserver):
""" Setup or re-setup single server
@ -325,42 +184,54 @@ class Downloader(Thread):
return primary
def stop(self):
self.shutdown = True
osx.sendGrowlMsg("SABnzbd",T('Shutting down'),osx.NOTIFICATION['startup'])
@synchronized_CV
def set_paused(self, state):
self.paused = state
@synchronized_CV
def resume(self):
logging.info("Resuming")
self.paused = False
def pause(self):
@synchronized_CV
def pause(self, save=True):
logging.info("Pausing")
osx.sendGrowlMsg("SABnzbd",T('Paused'),osx.NOTIFICATION['download'])
self.paused = True
if self.is_paused():
BPSMeter.do.reset()
if cfg.autodisconnect():
self.disconnect()
if save:
sabnzbd.save_state()
@synchronized_CV
def delay(self):
logging.debug("Delaying")
self.delayed = True
@synchronized_CV
def undelay(self):
logging.debug("Undelaying")
self.delayed = False
def wait_postproc(self):
@synchronized_CV
def wait_for_postproc(self):
logging.info("Waiting for post-processing to finish")
self.postproc = True
def resume_postproc(self):
@synchronized_CV
def resume_from_postproc(self):
logging.info("Post-processing finished, resuming download")
self.postproc = False
def disconnect(self):
self.force_disconnect = True
@synchronized_CV
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):
return self.bandwidth_limit
@ -812,6 +683,7 @@ class Downloader(Thread):
del self._timers[server_id]
self.init_server(server_id, server_id)
@synchronized_CV
@synchronized(TIMER_LOCK)
def unblock(self, server_id):
# Remove timer
@ -826,10 +698,12 @@ class Downloader(Thread):
self.init_server(server_id, server_id)
break
def unblock_all(self):
for server_id in self._timers.keys():
self.unblock(server_id)
@synchronized_CV
@synchronized(TIMER_LOCK)
def check_timers(self):
""" 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)
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):
""" Check for any "failed login" clues in the response code

16
sabnzbd/interface.py

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

2
sabnzbd/newswrapper.py

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

2
sabnzbd/nzbqueue.py

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

6
sabnzbd/postproc.py

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

12
sabnzbd/scheduler.py

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

Loading…
Cancel
Save