def test_nntp_server(host,
port,
server=None,
username=None,
password=None,
ssl=None,
ssl_verify=1):
""" Will connect (blocking) to the nttp server and report back any errors """
timeout = 4.0
if '*' in password and not password.strip('*'):
# If the password is masked, try retrieving it from the config
if not server:
servers = get_servers()
got_pass = False
for server in servers:
if host in servers[server].host():
srv = servers[server]
password = srv.password()
got_pass = True
else:
srv = get_servers().get(server)
if srv:
password = srv.password()
got_pass = True
if not got_pass:
return False, T('Password masked in ******, please re-enter')
try:
s = Server(-1, '', host, port, timeout, 0, 0, ssl, ssl_verify, None,
False, username, password)
except:
return False, T('Invalid server details')
try:
nw = NewsWrapper(s, -1, block=True)
nw.init_connect(None)
while not nw.connected:
nw.clear_data()
nw.recv_chunk(block=True)
#more ssl related: handle 1/n-1 splitting to prevent Rizzo/Duong-Beast
read_sockets, _, _ = select.select([nw.nntp.sock], [], [], 0.1)
if read_sockets:
nw.recv_chunk(block=True)
nw.finish_connect(nw.status_code)
except socket.timeout:
if port != 119 and not ssl:
return False, T(
'Timed out: Try enabling SSL or connecting on a different port.'
)
else:
return False, T('Timed out')
except socket.error, e:
# Trying SSL on non-SSL port?
if 'unknown protocol' in str(e).lower():
return False, T(
'Unknown SSL protocol: Try disabling SSL or connecting on a different port.'
)
return False, unicode(e)
def test_nntp_server(host, port, server=None, username=None, password=None, ssl=None, ssl_verify=1):
""" Will connect (blocking) to the nttp server and report back any errors """
timeout = 4.0
if '*' in password and not password.strip('*'):
# If the password is masked, try retrieving it from the config
if not server:
servers = get_servers()
got_pass = False
for server in servers:
if host in servers[server].host():
srv = servers[server]
password = srv.password()
got_pass = True
else:
srv = get_servers().get(server)
if srv:
password = srv.password()
got_pass = True
if not got_pass:
return False, T('Password masked in ******, please re-enter')
try:
s = Server(-1, '', host, port, timeout, 0, 0, ssl, ssl_verify, None, False, username, password)
except:
return False, T('Invalid server details')
try:
nw = NewsWrapper(s, -1, block=True)
nw.init_connect(None)
while not nw.connected:
nw.clear_data()
nw.recv_chunk(block=True)
#more ssl related: handle 1/n-1 splitting to prevent Rizzo/Duong-Beast
read_sockets, _, _ = select.select([nw.nntp.sock], [], [], 0.1)
if read_sockets:
nw.recv_chunk(block=True)
nw.finish_connect(nw.status_code)
except socket.timeout:
if port != 119 and not ssl:
return False, T('Timed out: Try enabling SSL or connecting on a different port.')
else:
return False, T('Timed out')
except socket.error, e:
# Trying SSL on non-SSL port?
if 'unknown protocol' in str(e).lower():
return False, T('Unknown SSL protocol: Try disabling SSL or connecting on a different port.')
return False, unicode(e)
def init_server(self, oldserver, newserver):
""" Setup or re-setup single server
When oldserver is defined and in use, delay startup.
Note that the server names are "host:port" strings!
"""
create = False
servers = config.get_servers()
if newserver in servers:
srv = servers[newserver]
enabled = srv.enable()
displayname = srv.displayname()
host = srv.host()
port = srv.port()
timeout = srv.timeout()
threads = srv.connections()
priority = srv.priority()
ssl = srv.ssl() and sabnzbd.newswrapper.HAVE_SSL
ssl_type = srv.ssl_type()
username = srv.username()
password = srv.password()
optional = srv.optional()
categories = srv.categories()
retention = float(srv.retention() * 24 * 3600) # days ==> seconds
send_group = srv.send_group()
create = True
if oldserver:
for n in xrange(len(self.servers)):
if self.servers[n].id == oldserver:
# Server exists, do re-init later
create = False
self.servers[n].newid = newserver
self.servers[n].restart = True
self.__restart += 1
break
if create and enabled and host and port and threads:
self.servers.append(
Server(
newserver,
displayname,
host,
port,
timeout,
threads,
priority,
ssl,
ssl_type,
send_group,
username,
password,
optional,
retention,
categories=categories,
)
)
return
def test_nntp_server(host,
port,
server=None,
username=None,
password=None,
ssl=None,
ssl_type='t1'):
""" Will connect (blocking) to the nttp server and report back any errors """
timeout = 4.0
if '*' in password and not password.strip('*'):
# If the password is masked, try retrieving it from the config
if not server:
servers = get_servers()
got_pass = False
for server in servers:
if host in server:
srv = servers[server]
password = srv.password()
got_pass = True
else:
srv = get_servers().get(server)
if srv:
password = srv.password()
got_pass = True
if not got_pass:
return False, T('Password masked in ******, please re-enter')
try:
s = Server(-1, '', host, port, timeout, 0, 0, ssl, ssl_type, False,
username, password)
except:
return False, T('Invalid server details')
try:
nw = NewsWrapper(s, -1, block=True)
nw.init_connect(None)
while not nw.connected:
nw.lines = []
nw.recv_chunk(block=True)
nw.finish_connect(nw.lines[0][:3])
except socket.timeout, e:
if port != 119 and not ssl:
return False, T(
'Timed out: Try enabling SSL or connecting on a different port.'
)
else:
return False, T('Timed out')
def check_server_quota():
"""Check quota on servers"""
for srv, server in config.get_servers().items():
if server.quota():
if server.quota.get_int() + server.usage_at_start() < sabnzbd.BPSMeter.grand_total.get(srv, 0):
logging.warning(T("Server %s has used the specified quota"), server.displayname())
server.quota.set("")
config.save_config()
def init_server(self, oldserver, newserver):
""" Setup or re-setup single server
When oldserver is defined and in use, delay startup.
Note that the server names are "host:port" strings!
"""
create = False
servers = config.get_servers()
if newserver in servers:
srv = servers[newserver]
enabled = srv.enable()
displayname = srv.displayname()
host = srv.host()
port = srv.port()
timeout = srv.timeout()
threads = srv.connections()
priority = srv.priority()
ssl = srv.ssl() and sabnzbd.newswrapper.HAVE_SSL
ssl_type = srv.ssl_type()
username = srv.username()
password = srv.password()
optional = srv.optional()
categories = srv.categories()
retention = float(srv.retention() * 24 * 3600) # days ==> seconds
send_group = srv.send_group()
create = True
if oldserver:
for n in xrange(len(self.servers)):
if self.servers[n].id == oldserver:
# Server exists, do re-init later
create = False
self.servers[n].newid = newserver
self.servers[n].restart = True
self.__restart += 1
break
if create and enabled and host and port and threads:
self.servers.append(
Server(newserver,
displayname,
host,
port,
timeout,
threads,
priority,
ssl,
ssl_type,
send_group,
username,
password,
optional,
retention,
categories=categories))
return
def one(self, **kwargs):
""" Accept language and show server page """
if cfg.configlock() or not sabnzbd.interface.check_access():
return sabnzbd.interface.Protected()
if not sabnzbd.interface.check_login():
raise sabnzbd.interface.NeedLogin()
language = kwargs.get('lang') if kwargs.get('lang') else cfg.language()
cfg.language.set(language)
set_language(language)
sabnzbd.api.clear_trans_cache()
# Always setup Glitter
sabnzbd.interface.change_web_dir('Glitter - Default')
info = self.info.copy()
info['session'] = cfg.api_key()
info['language'] = cfg.language()
info['active_lang'] = info['language']
info['T'] = Ttemplate
info['have_ssl_context'] = sabnzbd.HAVE_SSL_CONTEXT
servers = config.get_servers()
if not servers:
info['host'] = ''
info['port'] = ''
info['username'] = ''
info['password'] = ''
info['connections'] = ''
info['ssl'] = 0
info['ssl_verify'] = 2
else:
# Sort servers to get the first enabled one
server_names = sorted(
servers.keys(),
key=lambda svr: '%d%02d%s' %
(int(not servers[svr].enable()), servers[svr].priority(),
servers[svr].displayname().lower()))
for server in server_names:
# If there are multiple servers, just use the first enabled one
s = servers[server]
info['host'] = s.host()
info['port'] = s.port()
info['username'] = s.username()
info['password'] = s.password.get_stars()
info['connections'] = s.connections()
info['ssl'] = s.ssl()
info['ssl_verify'] = s.ssl_verify()
if s.enable():
break
template = Template(file=os.path.join(self.__web_dir, 'one.html'),
searchList=[info],
compilerSettings=sabnzbd.interface.DIRECTIVES)
return template.respond()
def __init__(self, paused=False):
Thread.__init__(self)
logging.debug("Initializing downloader/decoder")
# Used for scheduled pausing
self.paused = paused
# used for throttling bandwidth and scheduling bandwidth changes
cfg.bandwidth_perc.callback(self.speed_set)
cfg.bandwidth_max.callback(self.speed_set)
self.speed_set()
# Used for reducing speed
self.delayed = False
# Used to see if we can add a slowdown to the Downloader-loop
self.can_be_slowed = None
self.can_be_slowed_timer = 0
self.postproc = False
self.shutdown = False
# A user might change server parms again before server restart is ready.
# Keep a counter to prevent multiple restarts
self.__restart = 0
self.force_disconnect = False
self.read_fds = {}
self.write_fds = {}
self.servers = []
self.server_dict = {} # For faster lookups, but is not updated later!
self.server_nr = 0
self._timers = {}
for server in config.get_servers():
self.init_server(None, server)
self.decoder_queue = Queue.Queue()
# Initialize decoders, only 1 for non-SABYenc
self.decoder_workers = []
nr_decoders = 2 if sabnzbd.decoder.SABYENC_ENABLED else 1
for i in range(nr_decoders):
self.decoder_workers.append(
Decoder(self.servers, self.decoder_queue))
Downloader.do = self
def test_nntp_server(host, port, server=None, username=None, password=None, ssl=None):
''' Will connect (blocking) to the nttp server and report back any errors '''
timeout = 4.0
if '*' in password and not password.strip('*'):
# If the password is masked, try retrieving it from the config
if not server:
servers = get_servers()
got_pass = False
for server in servers:
if host in server:
srv = servers[server]
password = srv.password()
got_pass = True
else:
srv = get_servers().get(server)
if srv:
password = srv.password()
got_pass = True
if not got_pass:
return False, T('Password masked in ******, please re-enter')
try:
s = Server(-1, host, port, timeout, 0, 0, ssl, username, password)
except:
return False, T('Invalid server details')
try:
nw = NewsWrapper(s, -1, block=True)
nw.init_connect(None)
while not nw.connected:
nw.lines = []
nw.recv_chunk(block=True)
nw.finish_connect(nw.lines[0][:3])
except socket.timeout, e:
if port != 119 and not ssl:
return False, T('Timed out: Try enabling SSL or connecting on a different port.')
else:
return False, T('Timed out')
def check_server_expiration():
"""Check if user should get warning about server date expiration"""
for server in config.get_servers().values():
if server.expire_date():
days_to_expire = ceil(
(time.mktime(time.strptime(server.expire_date(), "%Y-%m-%d")) - time.time()) / (60 * 60 * 24)
)
# Notify from 5 days in advance
if days_to_expire < 6:
logging.warning(T("Server %s is expiring in %s day(s)"), server.displayname(), days_to_expire)
# Reset on the day of expiration
if days_to_expire <= 0:
server.expire_date.set("")
config.save_config()
def __init__(self, paused=False):
Thread.__init__(self)
logging.debug("Initializing downloader/decoder")
# Used for scheduled pausing
self.paused = paused
# used for throttling bandwidth and scheduling bandwidth changes
cfg.bandwidth_perc.callback(self.speed_set)
cfg.bandwidth_max.callback(self.speed_set)
self.speed_set()
# Used for reducing speed
self.delayed = False
# Used to see if we can add a slowdown to the Downloader-loop
self.can_be_slowed = None
self.can_be_slowed_timer = 0
self.postproc = False
self.shutdown = False
# A user might change server parms again before server restart is ready.
# Keep a counter to prevent multiple restarts
self.__restart = 0
self.force_disconnect = False
self.read_fds = {}
self.write_fds = {}
self.servers = []
self.server_dict = {} # For faster lookups, but is not updated later!
self.server_nr = 0
self._timers = {}
for server in config.get_servers():
self.init_server(None, server)
self.decoder_queue = Queue.Queue()
# Initialize decoders, only 1 for non-SABYenc
self.decoder_workers = []
nr_decoders = 2 if sabnzbd.decoder.SABYENC_ENABLED else 1
for i in range(nr_decoders):
self.decoder_workers.append(Decoder(self.servers, self.decoder_queue))
Downloader.do = self
def serverUpdate(self):
try:
if not config.get_servers():
self.state_menu_item.setTitle_(T('Go to wizard'))
hide = YES
alternate = NO
value = 0
else:
hide = NO
alternate = YES
value = 1
if self.isLeopard:
self.speed_menu_item.setHidden_(hide)
self.resume_menu_item.setHidden_(hide)
self.pause_menu_item.setHidden_(hide)
self.watched_menu_item.setHidden_(hide)
self.rss_menu_item.setHidden_(hide)
self.purgequeue_menu_item.setAlternate_(alternate)
self.purgequeue_menu_item.setHidden_(hide)
self.queue_menu_item.setHidden_(hide)
self.purgehistory_menu_item.setAlternate_(alternate)
self.purgehistory_menu_item.setHidden_(hide)
self.history_menu_item.setHidden_(hide)
self.separator_menu_item.setHidden_(hide)
self.separator2_menu_item.setHidden_(hide)
self.completefolder_menu_item.setHidden_(hide)
self.incompletefolder_menu_item.setHidden_(hide)
else:
self.speed_menu_item.setEnabled_(alternate)
self.resume_menu_item.setEnabled_(alternate)
self.pause_menu_item.setEnabled_(alternate)
self.watched_menu_item.setEnabled_(alternate)
self.rss_menu_item.setEnabled_(alternate)
self.purgequeue_menu_item.setAlternate_(alternate)
self.purgequeue_menu_item.setEnabled_(alternate)
self.queue_menu_item.setEnabled_(alternate)
self.purgehistory_menu_item.setAlternate_(alternate)
self.purgehistory_menu_item.setEnabled_(alternate)
self.history_menu_item.setEnabled_(alternate)
self.separator_menu_item.setEnabled_(alternate)
self.separator2_menu_item.setEnabled_(alternate)
self.completefolder_menu_item.setEnabled_(alternate)
self.incompletefolder_menu_item.setEnabled_(alternate)
return value
except:
logging.info("[osx] configUpdate Exception %s" %
(sys.exc_info()[0]))
return 0
def serverUpdate(self):
try:
if not config.get_servers():
self.state_menu_item.setTitle_(T('Go to wizard'))
hide=YES
alternate=NO
value=0
else:
hide=NO
alternate=YES
value=1
if self.isLeopard:
self.speed_menu_item.setHidden_(hide)
self.resume_menu_item.setHidden_(hide)
self.pause_menu_item.setHidden_(hide)
self.newzbin_menu_item.setHidden_(hide)
self.watched_menu_item.setHidden_(hide)
self.purgequeue_menu_item.setAlternate_(alternate)
self.purgequeue_menu_item.setHidden_(hide)
self.queue_menu_item.setHidden_(hide)
self.purgehistory_menu_item.setAlternate_(alternate)
self.purgehistory_menu_item.setHidden_(hide)
self.history_menu_item.setHidden_(hide)
self.separator_menu_item.setHidden_(hide)
self.separator2_menu_item.setHidden_(hide)
self.completefolder_menu_item.setHidden_(hide)
self.incompletefolder_menu_item.setHidden_(hide)
else:
self.speed_menu_item.setEnabled_(alternate)
self.resume_menu_item.setEnabled_(alternate)
self.pause_menu_item.setEnabled_(alternate)
self.newzbin_menu_item.setEnabled_(alternate)
self.watched_menu_item.setEnabled_(alternate)
self.purgequeue_menu_item.setAlternate_(alternate)
self.purgequeue_menu_item.setEnabled_(alternate)
self.queue_menu_item.setEnabled_(alternate)
self.purgehistory_menu_item.setAlternate_(alternate)
self.purgehistory_menu_item.setEnabled_(alternate)
self.history_menu_item.setEnabled_(alternate)
self.separator_menu_item.setEnabled_(alternate)
self.separator2_menu_item.setEnabled_(alternate)
self.completefolder_menu_item.setEnabled_(alternate)
self.incompletefolder_menu_item.setEnabled_(alternate)
return value
except :
logging.info("[osx] configUpdate Exception %s" % (sys.exc_info()[0]))
return 0
def __init__(self, paused=False):
Thread.__init__(self)
logging.debug("Initializing downloader/decoder")
# Used for scheduled pausing
self.paused = paused
#used for throttling bandwidth and scheduling bandwidth changes
self.bandwidth_limit = cfg.bandwidth_limit()
cfg.bandwidth_limit.callback(self.speed_set)
t = time.time()
self.log_time = t
self.end_of_day = tomorrow(t) # Time that current day will end
self.end_of_week = next_week(t) # Time that current day will end
self.end_of_month = next_month(t) # Time that current month will end
self.ext_ip = ""
# Used for reducing speed
self.delayed = False
self.postproc = False
self.shutdown = False
# A user might change server parms again before server restart is ready.
# Keep a counter to prevent multiple restarts
self.__restart = 0
self.force_disconnect = False
self.read_fds = {}
self.write_fds = {}
self.servers = []
self._timers = {}
for server in config.get_servers():
self.init_server(None, server)
self.decoder = Decoder(self.servers)
Downloader.do = self
def one(self, **kwargs):
""" Accept language and show server page """
language = kwargs.get('lang') if kwargs.get('lang') else cfg.language()
cfg.language.set(language)
set_language(language)
sabnzbd.api.clear_trans_cache()
# Always setup Glitter
sabnzbd.interface.change_web_dir('Glitter - Default')
info = self.info.copy()
info['session'] = cfg.api_key()
info['language'] = cfg.language()
info['active_lang'] = info['language']
info['T'] = Ttemplate
info['have_ssl_context'] = sabnzbd.HAVE_SSL_CONTEXT
servers = config.get_servers()
if not servers:
info['host'] = ''
info['port'] = ''
info['username'] = ''
info['password'] = ''
info['connections'] = ''
info['ssl'] = 0
info['ssl_verify'] = 2
else:
for server in servers:
# If there are multiple servers, just use the first enabled one
s = servers[server]
info['host'] = s.host()
info['port'] = s.port()
info['username'] = s.username()
info['password'] = s.password.get_stars()
info['connections'] = s.connections()
info['ssl'] = s.ssl()
info['ssl_verify'] = s.ssl_verify()
if s.enable():
break
template = Template(file=os.path.join(self.__web_dir, 'one.html'),
searchList=[info],
compilerSettings=sabnzbd.interface.DIRECTIVES)
return template.respond()
def one(self, **kwargs):
""" Accept language and show server page """
language = kwargs.get('lang')
cfg.language.set(language)
set_language(language)
sabnzbd.api.clear_trans_cache()
# Always setup Plush
sabnzbd.interface.change_web_dir('Plush - Gold')
info = self.info.copy()
info['num'] = '» %s' % T('Step One')
info['number'] = 1
info['session'] = cfg.api_key()
info['language'] = cfg.language()
info['T'] = Ttemplate
info['have_ssl'] = bool(sabnzbd.newswrapper.HAVE_SSL)
servers = config.get_servers()
if not servers:
info['host'] = ''
info['port'] = ''
info['username'] = ''
info['password'] = ''
info['connections'] = ''
info['ssl'] = 0
else:
for server in servers:
# If there are multiple servers, just use the first enabled one
s = servers[server]
info['host'] = s.host()
info['port'] = s.port()
info['username'] = s.username()
info['password'] = s.password.get_stars()
info['connections'] = s.connections()
info['ssl'] = s.ssl()
if s.enable():
break
template = Template(file=os.path.join(self.__web_dir, 'one.html'),
searchList=[info],
compilerSettings=sabnzbd.interface.DIRECTIVES)
return template.respond()
def init_server(self, oldserver, newserver):
""" Setup or re-setup single server
When oldserver is defined and in use, delay startup.
Return True when newserver is primary
Note that the server names are "host:port" strings!
"""
primary = False
create = False
servers = config.get_servers()
if newserver in servers:
srv = servers[newserver]
enabled = srv.enable()
host = srv.host()
port = srv.port()
timeout = srv.timeout()
threads = srv.connections()
fillserver = srv.fillserver()
primary = enabled and (not fillserver) and (threads > 0)
ssl = srv.ssl() and sabnzbd.newswrapper.HAVE_SSL
username = srv.username()
password = srv.password()
optional = srv.optional()
retention = float(srv.retention() * 24 * 3600) # days ==> seconds
create = True
if oldserver:
for n in xrange(len(self.servers)):
if self.servers[n].id == oldserver:
# Server exists, do re-init later
create = False
self.servers[n].newid = newserver
self.servers[n].restart = True
self.__restart += 1
break
if create and enabled and host and port and threads:
self.servers.append(
Server(newserver, host, port, timeout, threads, fillserver,
ssl, username, password, optional, retention))
return primary
def one(self, **kwargs):
""" Accept language and show server page """
language = kwargs.get('lang')
cfg.language.set(language)
set_language(language)
sabnzbd.api.clear_trans_cache()
# Always setup Plush
sabnzbd.interface.change_web_dir('Plush - Gold')
info = self.info.copy()
info['num'] = '» %s' % T('Step One')
info['number'] = 1
info['session'] = cfg.api_key()
info['language'] = cfg.language()
info['T'] = Ttemplate
info['have_ssl'] = bool(sabnzbd.newswrapper.HAVE_SSL)
servers = config.get_servers()
if not servers:
info['host'] = ''
info['port'] = ''
info['username'] = ''
info['password'] = ''
info['connections'] = ''
info['ssl'] = 0
else:
for server in servers:
# If there are multiple servers, just use the first enabled one
s = servers[server]
info['host'] = s.host()
info['port'] = s.port()
info['username'] = s.username()
info['password'] = s.password.get_stars()
info['connections'] = s.connections()
info['ssl'] = s.ssl()
if s.enable():
break
template = Template(file=os.path.join(self.__web_dir, 'one.html'),
searchList=[info], compilerSettings=sabnzbd.interface.DIRECTIVES)
return template.respond()
def one(self, **kwargs):
""" Accept language and show server page """
language = kwargs.get('lang') if kwargs.get('lang') else cfg.language()
cfg.language.set(language)
set_language(language)
sabnzbd.api.clear_trans_cache()
# Always setup Glitter
sabnzbd.interface.change_web_dir('Glitter - Default')
info = self.info.copy()
info['session'] = cfg.api_key()
info['language'] = cfg.language()
info['active_lang'] = info['language']
info['T'] = Ttemplate
info['have_ssl_context'] = sabnzbd.HAVE_SSL_CONTEXT
servers = config.get_servers()
if not servers:
info['host'] = ''
info['port'] = ''
info['username'] = ''
info['password'] = ''
info['connections'] = ''
info['ssl'] = 0
info['ssl_verify'] = 2
else:
for server in servers:
# If there are multiple servers, just use the first enabled one
s = servers[server]
info['host'] = s.host()
info['port'] = s.port()
info['username'] = s.username()
info['password'] = s.password.get_stars()
info['connections'] = s.connections()
info['ssl'] = s.ssl()
info['ssl_verify'] = s.ssl_verify()
if s.enable():
break
template = Template(file=os.path.join(self.__web_dir, 'one.html'),
searchList=[info], compilerSettings=sabnzbd.interface.DIRECTIVES)
return template.respond()
def stateUpdate(self):
try:
paused, bytes_left, bpsnow, time_left = fast_queue()
if paused:
self.state = T("Paused")
if sabnzbd.Scheduler.pause_int() != "0":
self.setMenuTitle_("\n%s\n%s\n" % (T("Paused"), sabnzbd.Scheduler.pause_int()))
else:
self.setMenuTitle_("")
elif bytes_left > 0:
self.state = ""
speed = to_units(bpsnow)
# "10.1 MB/s" doesn't fit, remove space char
if "M" in speed and len(speed) > 5:
speed = speed.replace(" ", "")
time_left = (bpsnow > 10 and time_left) or "------"
statusbarText = "\n\n%s\n%sB/s\n" % (time_left, speed)
if sabnzbd.SABSTOP:
statusbarText = "..."
if not sabnzbd.cfg.osx_speed():
statusbarText = ""
self.setMenuTitle_(statusbarText)
else:
self.state = T("Idle")
self.setMenuTitle_("")
if self.state != "" and self.info != "":
self.state_menu_item.setTitle_("%s - %s" % (self.state, self.info))
if self.info == "":
self.state_menu_item.setTitle_("%s" % self.state)
else:
self.state_menu_item.setTitle_("%s" % self.info)
if not config.get_servers():
self.state_menu_item.setTitle_(T("Go to wizard"))
except:
logging.info("[osx] stateUpdate Exception", exc_info=True)
def init_server(self, oldserver, newserver):
""" Setup or re-setup single server
When oldserver is defined and in use, delay startup.
Return True when newserver is primary
Note that the server names are "host:port" strings!
"""
primary = False
create = False
servers = config.get_servers()
if newserver in servers:
srv = servers[newserver]
enabled = srv.enable()
host = srv.host()
port = srv.port()
timeout = srv.timeout()
threads = srv.connections()
fillserver = srv.fillserver()
primary = enabled and (not fillserver) and (threads > 0)
ssl = srv.ssl() and sabnzbd.newswrapper.HAVE_SSL
username = srv.username()
password = srv.password()
optional = srv.optional()
retention = float(srv.retention() * 24 * 3600) # days ==> seconds
create = True
if oldserver:
for n in xrange(len(self.servers)):
if self.servers[n].id == oldserver:
# Server exists, do re-init later
create = False
self.servers[n].newid = newserver
self.servers[n].restart = True
self.__restart += 1
break
if create and enabled and host and port and threads:
self.servers.append(Server(newserver, host, port, timeout, threads, fillserver, ssl,
username, password, optional, retention))
return primary
def __init__(self, paused=False):
Thread.__init__(self)
logging.debug("Initializing downloader")
# Used for scheduled pausing
self.paused = paused
# Used for reducing speed
self.bandwidth_limit = 0
self.bandwidth_perc = 0
cfg.bandwidth_perc.callback(self.speed_set)
cfg.bandwidth_max.callback(self.speed_set)
self.speed_set()
# Used to see if we can add a slowdown to the Downloader-loop
self.can_be_slowed = None
self.can_be_slowed_timer = 0
self.postproc = False
self.shutdown = False
# A user might change server parms again before server restart is ready.
# Keep a counter to prevent multiple restarts
self.__restart = 0
self.force_disconnect = False
self.read_fds = {}
self.write_fds = {}
self.servers = []
self.server_dict = {} # For faster lookups, but is not updated later!
self.server_nr = 0
self._timers = {}
for server in config.get_servers():
self.init_server(None, server)
Downloader.do = self
def __init__(self, paused=False):
Thread.__init__(self)
logging.debug("Initializing downloader/decoder")
# Used for scheduled pausing
self.paused = paused
# used for throttling bandwidth and scheduling bandwidth changes
cfg.bandwidth_perc.callback(self.speed_set)
cfg.bandwidth_max.callback(self.speed_set)
self.speed_set()
# Used for reducing speed
self.delayed = False
# Used to see if we can add a slowdown to the Downloader-loop
self.can_be_slowed = None
self.can_be_slowed_timer = 0
self.postproc = False
self.shutdown = False
# A user might change server parms again before server restart is ready.
# Keep a counter to prevent multiple restarts
self.__restart = 0
self.force_disconnect = False
self.read_fds = {}
self.write_fds = {}
self.servers = []
self._timers = {}
for server in config.get_servers():
self.init_server(None, server)
self.decoder = Decoder(self.servers)
Downloader.do = self
def __init__(self, paused=False):
super().__init__()
logging.debug("Initializing downloader")
# Used for scheduled pausing
self.paused: bool = paused
# Used for reducing speed
self.bandwidth_limit: int = 0
self.bandwidth_perc: int = 0
cfg.bandwidth_perc.callback(self.speed_set)
cfg.bandwidth_max.callback(self.speed_set)
self.speed_set()
# Used to see if we can add a slowdown to the Downloader-loop
self.can_be_slowed: Optional[bool] = None
self.can_be_slowed_timer: int = 0
self.sleep_time: float = 0.0
self.sleep_time_set()
cfg.downloader_sleep_time.callback(self.sleep_time_set)
self.paused_for_postproc: bool = False
self.shutdown: bool = False
# A user might change server parms again before server restart is ready.
# Keep a counter to prevent multiple restarts
self.server_restarts: int = 0
self.force_disconnect: bool = False
self.read_fds: Dict[int, NewsWrapper] = {}
self.servers: List[Server] = []
self.server_dict: Dict[str, Server] = {} # For faster lookups, but is not updated later!
self.server_nr: int = 0
self.timers: Dict[str, List[float]] = {}
for server in config.get_servers():
self.init_server(None, server)
def __init__(self, paused=False):
Thread.__init__(self)
logging.debug("Initializing downloader/decoder")
# Used for scheduled pausing
self.paused = paused
# used for throttling bandwidth and scheduling bandwidth changes
cfg.bandwidth_perc.callback(self.speed_set)
cfg.bandwidth_max.callback(self.speed_set)
self.speed_set()
# Used for reducing speed
self.delayed = False
self.postproc = False
self.shutdown = False
# A user might change server parms again before server restart is ready.
# Keep a counter to prevent multiple restarts
self.__restart = 0
self.force_disconnect = False
self.read_fds = {}
self.write_fds = {}
self.servers = []
self._timers = {}
for server in config.get_servers():
self.init_server(None, server)
self.decoder = Decoder(self.servers)
Downloader.do = self
d.setBackgroundTitle("Docker Usenet Pack - First Run")
try:
# Load config
sab_read_config(SAB_CONFIG)
section_defaults = dict(DIALOG_DEFAULTS.items() +
[('title', 'General Configuration')])
sab_config_question("UI Username", sab_config.username, "admin", True,
**section_defaults)
sab_config_question("UI Password",
sab_config.password,
required=True,
**section_defaults)
usenet_servers = sab_config_utils.get_servers()
if usenet_servers:
done = False
next_val = ("S", "Skip")
while not done:
big_section_defaults = dict(section_defaults.items() +
[('height', 10)])
cancelled, value = d.menu("Servers already configured",
choices=(("E", "Edit"), ("D", "Delete"),
next_val),
**big_section_defaults)
if value == 'E':
cancelled, server = sab_server_menu(usenet_servers, "Edit")
elif value == 'D':
cancelled, server = sab_server_menu(usenet_servers, "Delete")
def test_nntp_server(host,
port,
server=None,
username=None,
password=None,
ssl=None,
ssl_verify=1,
ssl_ciphers=None):
""" Will connect (blocking) to the nttp server and report back any errors """
timeout = 4.0
if "*" in password and not password.strip("*"):
# If the password is masked, try retrieving it from the config
if not server:
servers = get_servers()
got_pass = False
for server in servers:
if host in servers[server].host():
srv = servers[server]
password = srv.password()
got_pass = True
else:
srv = get_servers().get(server)
if srv:
password = srv.password()
got_pass = True
if not got_pass:
return False, T("Password masked in ******, please re-enter")
try:
s = Server(-1, "", host, port, timeout, 0, 0, ssl, ssl_verify,
ssl_ciphers, False, username, password)
except:
return False, T("Invalid server details")
try:
nw = NewsWrapper(s, -1, block=True)
nw.init_connect(None)
while not nw.connected:
nw.clear_data()
nw.recv_chunk(block=True)
# Handle 1/n-1 splitting to prevent Rizzo/Duong-Beast
read_sockets, _, _ = select.select([nw.nntp.sock], [], [], 0.1)
if read_sockets:
nw.recv_chunk(block=True)
nw.finish_connect(nw.status_code)
except socket.timeout:
if port != 119 and not ssl:
return False, T(
"Timed out: Try enabling SSL or connecting on a different port."
)
else:
return False, T("Timed out")
except socket.error as e:
# Trying SSL on non-SSL port?
if "unknown protocol" in str(e).lower():
return False, T(
"Unknown SSL protocol: Try disabling SSL or connecting on a different port."
)
return False, str(e)
except TypeError:
return False, T("Invalid server address.")
except IndexError:
# No data was received in recv_chunk() call
return False, T("Server quit during login sequence.")
except:
return False, str(sys.exc_info()[1])
if not username or not password:
nw.nntp.sock.sendall(b"ARTICLE <test@home>\r\n")
try:
nw.clear_data()
nw.recv_chunk(block=True)
except:
# Some internal error, not always safe to close connection
return False, str(sys.exc_info()[1])
# Close the connection
nw.terminate(quit=True)
if nw.status_code == 480:
return False, T("Server requires username and password.")
elif nw.status_code == 100 or str(nw.status_code).startswith(("2", "4")):
return True, T("Connection Successful!")
elif nw.status_code == 502 or clues_login(nntp_to_msg(nw.data)):
return False, T("Authentication failed, check username/password.")
elif clues_too_many(nntp_to_msg(nw.data)):
return False, T(
"Too many connections, please pause downloading or try again later"
)
else:
return False, T("Could not determine connection result (%s)"
) % nntp_to_msg(nw.data)
def init_server(self, oldserver: Optional[str], newserver: str):
"""Setup or re-setup single server
When oldserver is defined and in use, delay startup.
Note that the server names are "host:port" strings!
"""
create = False
servers = config.get_servers()
if newserver in servers:
srv = servers[newserver]
enabled = srv.enable()
displayname = srv.displayname()
host = srv.host()
port = srv.port()
timeout = srv.timeout()
threads = srv.connections()
priority = srv.priority()
ssl = srv.ssl()
ssl_verify = srv.ssl_verify()
ssl_ciphers = srv.ssl_ciphers()
username = srv.username()
password = srv.password()
optional = srv.optional()
retention = int(srv.retention() * 24 * 3600) # days ==> seconds
send_group = srv.send_group()
create = True
if oldserver:
for server in self.servers:
if server.id == oldserver:
# Server exists, do re-init later
create = False
server.newid = newserver
server.restart = True
self.server_restarts += 1
break
if create and enabled and host and port and threads:
server = Server(
newserver,
displayname,
host,
port,
timeout,
threads,
priority,
ssl,
ssl_verify,
ssl_ciphers,
send_group,
username,
password,
optional,
retention,
)
self.servers.append(server)
self.server_dict[newserver] = server
# Update server-count
self.server_nr = len(self.servers)
