def run(params):
try:
import curses
curses.initscr()
cols = curses.COLS
curses.endwin()
except:
cols = 80
h = HeadlessDisplayer()
while 1:
configdir = ConfigDir('downloadheadless')
defaultsToIgnore = ['responsefile', 'url', 'priority']
configdir.setDefaults(defaults,defaultsToIgnore)
configdefaults = configdir.loadConfig()
defaults.append(('save_options',0,
"whether to save the current options as the new default configuration " +
"(only for btdownloadheadless.py)"))
try:
config = parse_params(params, configdefaults)
except ValueError, e:
print 'error: ' + str(e) + '\nrun with no args for parameter explanations'
break
if not config:
print get_usage(defaults, 80, configdefaults)
break
if config['save_options']:
configdir.saveConfig(config)
configdir.deleteOldCacheData(config['expire_cache_data'])
myid = createPeerID()
seed(myid)
config['overlay'] = 0
doneflag = Event()
def disp_exception(text):
print text
rawserver = RawServer(doneflag, config['timeout_check_interval'],
config['timeout'], ipv6_enable = config['ipv6_enabled'],
failfunc = h.failed, errorfunc = disp_exception)
upnp_type = UPnP_test(config['upnp_nat_access'])
while True:
try:
listen_port = rawserver.find_and_bind(config['minport'], config['minport'],
config['maxport'], config['bind'],
ipv6_socket_style = config['ipv6_binds_v4'],
upnp = upnp_type, randomizer = config['random_port'])
break
except socketerror, e:
if upnp_type and e == UPnP_ERROR:
print 'WARNING: COULD NOT FORWARD VIA UPnP'
upnp_type = 0
continue
print "error: Couldn't listen - " + str(e)
h.failed()
return
def main():
def on_fatal_error(error):
print >> sys.stderr, error
session_done_flag.set()
def on_non_fatal_error(error):
print >> sys.stderr, error
session_done_flag.set()
def start():
# start Dispersy
dispersy = TrackerDispersy.get_instance(callback, unicode(opt.statedir), opt.port)
dispersy.endpoint = RawserverEndpoint(rawserver, dispersy, opt.port, opt.ip)
dispersy.define_auto_load(TrackerCommunity)
command_line_parser = optparse.OptionParser()
command_line_parser.add_option("--statedir", action="store", type="string", help="Use an alternate statedir", default=".")
command_line_parser.add_option("--ip", action="store", type="string", default="0.0.0.0", help="Dispersy uses this ip")
command_line_parser.add_option("--port", action="store", type="int", help="Dispersy uses this UDL port", default=6421)
command_line_parser.add_option("--timeout-check-interval", action="store", type="float", default=60.0)
command_line_parser.add_option("--timeout", action="store", type="float", default=300.0)
# parse command-line arguments
opt, _ = command_line_parser.parse_args()
print "Press Ctrl-C to stop Dispersy"
# start threads
session_done_flag = threading.Event()
rawserver = RawServer(session_done_flag, opt.timeout_check_interval, opt.timeout, False, failfunc=on_fatal_error, errorfunc=on_non_fatal_error)
callback = Callback()
callback.start(name="Dispersy")
callback.register(start)
def rawserver_adrenaline():
"""
The rawserver tends to wait for a long time between handling tasks.
"""
rawserver.add_task(rawserver_adrenaline, 0.1)
rawserver.add_task(rawserver_adrenaline, 0.1)
def watchdog():
while True:
try:
yield 333.3
except GeneratorExit:
rawserver.shutdown()
session_done_flag.set()
break
callback.register(watchdog)
rawserver.listen_forever(None)
callback.stop()
def main():
def on_fatal_error(error):
print >> sys.stderr, error
session_done_flag.set()
def on_non_fatal_error(error):
print >> sys.stderr, error
session_done_flag.set()
def start():
# start Dispersy
dispersy = TrackerDispersy.get_instance(rawserver, unicode(opt.statedir))
dispersy.socket = DispersySocket(rawserver, dispersy, opt.port, opt.ip)
# load all HardKilledCommunity communities
print "Restored", len(HardKilledCommunity.load_communities()), "hard-killed communities"
# load the existing Tracker communities
print "Restored", len(TrackerCommunity.load_communities()), "tracker communities"
command_line_parser = optparse.OptionParser()
command_line_parser.add_option("--statedir", action="store", type="string", help="Use an alternate statedir", default=".")
command_line_parser.add_option("--ip", action="store", type="string", default="0.0.0.0", help="Dispersy uses this ip")
command_line_parser.add_option("--port", action="store", type="int", help="Dispersy uses this UDL port", default=6421)
command_line_parser.add_option("--timeout-check-interval", action="store", type="float", default=60.0)
command_line_parser.add_option("--timeout", action="store", type="float", default=300.0)
# parse command-line arguments
opt, args = command_line_parser.parse_args()
print "Press Ctrl-C to stop Dispersy"
# start threads
session_done_flag = threading.Event()
rawserver = RawServer(session_done_flag, opt.timeout_check_interval, opt.timeout, False, failfunc=on_fatal_error, errorfunc=on_non_fatal_error)
callback = Callback()
callback.start(name="Dispersy")
callback.register(start)
def watchdog():
while True:
try:
yield 333.3
except GeneratorExit:
rawserver.shutdown()
session_done_flag.set()
break
callback.register(watchdog)
rawserver.listen_forever(None)
callback.stop()
class Peer(Thread):
def __init__(self, testcase, port):
Thread.__init__(self)
self.setDaemon(True)
self.testcase = testcase
self.doneflag = Event()
config = {}
config['timeout_check_interval'] = 100000
config['timeout'] = 100000
config['ipv6_enabled'] = 0
config['minport'] = port
config['maxport'] = port + 5
config['random_port'] = 0
config['bind'] = ''
config['ipv6_binds_v4'] = 0
config['max_message_length'] = 2**23
self.rawserver = RawServer(self.doneflag,
config['timeout_check_interval'],
config['timeout'],
ipv6_enable=config['ipv6_enabled'],
failfunc=self.report_failure,
errorfunc=self.report_error)
while 1:
try:
self.listen_port = self.rawserver.find_and_bind(
0,
config['minport'],
config['maxport'],
config['bind'],
reuse=True,
ipv6_socket_style=config['ipv6_binds_v4'],
randomizer=config['random_port'])
print >> sys.stderr, "test: Got listen port", self.listen_port
break
except socketerror, e:
self.report_failure(str(e))
msg = "Couldn't not bind to listen port - " + str(e)
self.report_failure(msg)
return
self.multihandler = MultiHandler(self.rawserver, self.doneflag)
# Note: We don't want a singleton, we want
# two different instances for peer1 and peer2
self.dialback_connhand = ReturnConnHandler.getInstance()
self.dialback_connhand.resetSingleton()
self.dialback_connhand.register(self.rawserver, self.multihandler,
self.listen_port,
config['max_message_length'])
self.rawserver.sockethandler.set_handler(self.dialback_connhand)
self.dialback_connhand.start_listening()
# Stupid rawserver goes into very long wait if there are no short
# term tasks. Emulate this
self.rawserver.add_task(self.dummy_task, 0)
def __init__(self, i2iport, connhandler, timeout=300.0):
Thread.__init__(self)
self.setDaemon(True)
self.setName('Instance2Instance' + self.getName())
self.i2iport = i2iport
self.connhandler = connhandler
self.i2idoneflag = Event()
self.rawserver = RawServer(self.i2idoneflag,
timeout / 5.0,
timeout,
ipv6_enable=False,
failfunc=self.rawserver_fatalerrorfunc,
errorfunc=self.rawserver_nonfatalerrorfunc)
self.rawserver.add_task(self.rawserver_keepalive, 1)
# Only accept local connections
self.rawserver.bind(self.i2iport, bind=['127.0.0.1'], reuse=True)
def __init__(self, testcase, port, secover):
Thread.__init__(self)
self.setDaemon(True)
self.testcase = testcase
self.doneflag = Event()
config = {}
config['timeout_check_interval'] = 100000
config['timeout'] = 100000
config['ipv6_enabled'] = 0
config['minport'] = port
config['maxport'] = port + 5
config['random_port'] = 0
config['bind'] = ''
config['ipv6_binds_v4'] = 0
config['max_message_length'] = 2**23
config['state_dir'] = config['install_dir'] = tempfile.mkdtemp()
config['peer_icon_path'] = 'icons'
self.rawserver = RawServer(self.doneflag,
config['timeout_check_interval'],
config['timeout'],
ipv6_enable=config['ipv6_enabled'],
failfunc=self.report_failure,
errorfunc=self.report_error)
while 1:
try:
self.listen_port = self.rawserver.find_and_bind(
0,
config['minport'],
config['maxport'],
config['bind'],
reuse=True,
ipv6_socket_style=config['ipv6_binds_v4'],
randomizer=config['random_port'])
print >> sys.stderr, "test: Got listen port", self.listen_port
break
except socketerror, e:
self.report_failure(str(e))
msg = "Couldn't not bind to listen port - " + str(e)
self.report_failure(msg)
return
class Peer(Thread):
def __init__(self,testcase,port):
Thread.__init__(self)
self.setDaemon(True)
self.testcase = testcase
self.doneflag = Event()
config = {}
config['timeout_check_interval'] = 100000
config['timeout'] = 100000
config['ipv6_enabled'] = 0
config['minport'] = port
config['maxport'] = port+5
config['random_port'] = 0
config['bind'] = ''
config['ipv6_binds_v4'] = 0
config['max_message_length'] = 2 ** 23
self.rawserver = RawServer(self.doneflag,
config['timeout_check_interval'],
config['timeout'],
ipv6_enable = config['ipv6_enabled'],
failfunc = self.report_failure,
errorfunc = self.report_error)
while 1:
try:
self.listen_port = self.rawserver.find_and_bind(0,
config['minport'], config['maxport'], config['bind'],
reuse = True,
ipv6_socket_style = config['ipv6_binds_v4'],
randomizer = config['random_port'])
print >> sys.stderr,"test: Got listen port", self.listen_port
break
except socketerror, e:
self.report_failure(str(e))
msg = "Couldn't not bind to listen port - " + str(e)
self.report_failure(msg)
return
self.multihandler = MultiHandler(self.rawserver, self.doneflag)
# Note: We don't want a singleton, we want
# two different instances for peer1 and peer2
self.dialback_connhand = ReturnConnHandler.getInstance()
self.dialback_connhand.resetSingleton()
self.dialback_connhand.register(self.rawserver,self.multihandler,self.listen_port,config['max_message_length'])
self.rawserver.sockethandler.set_handler(self.dialback_connhand)
self.dialback_connhand.start_listening()
# Stupid rawserver goes into very long wait if there are no short
# term tasks. Emulate this
self.rawserver.add_task(self.dummy_task,0)
def __init__(self,i2iport,connhandler,timeout=300.0):
Thread.__init__(self)
self.setDaemon(True)
self.setName('Instance2Instance'+self.getName())
self.i2iport = i2iport
self.connhandler = connhandler
self.i2idoneflag = Event()
self.rawserver = RawServer(self.i2idoneflag,
timeout/5.0,
timeout,
ipv6_enable = False,
failfunc = self.rawserver_fatalerrorfunc,
errorfunc = self.rawserver_nonfatalerrorfunc)
self.rawserver.add_task(self.rawserver_keepalive,1)
# Only accept local connections
self.rawserver.bind(self.i2iport,bind=['127.0.0.1'],reuse=True)
def __init__(self,testcase,port,secover):
Thread.__init__(self)
self.setDaemon(True)
self.testcase = testcase
self.doneflag = Event()
config = {}
config['timeout_check_interval'] = 100000
config['timeout'] = 100000
config['ipv6_enabled'] = 0
config['minport'] = port
config['maxport'] = port+5
config['random_port'] = 0
config['bind'] = ''
config['ipv6_binds_v4'] = 0
config['max_message_length'] = 2 ** 23
config['state_dir'] = config['install_dir'] = tempfile.mkdtemp()
config['peer_icon_path'] = 'icons'
self.rawserver = RawServer(self.doneflag,
config['timeout_check_interval'],
config['timeout'],
ipv6_enable = config['ipv6_enabled'],
failfunc = self.report_failure,
errorfunc = self.report_error)
while 1:
try:
self.listen_port = self.rawserver.find_and_bind(0,
config['minport'], config['maxport'], config['bind'],
reuse = True,
ipv6_socket_style = config['ipv6_binds_v4'],
randomizer = config['random_port'])
print >> sys.stderr,"test: Got listen port", self.listen_port
break
except socketerror, e:
self.report_failure(str(e))
msg = "Couldn't not bind to listen port - " + str(e)
self.report_failure(msg)
return
class Peer(Thread):
def __init__(self,testcase,port,secover):
Thread.__init__(self)
self.setDaemon(True)
self.testcase = testcase
self.doneflag = Event()
config = {}
config['timeout_check_interval'] = 100000
config['timeout'] = 100000
config['ipv6_enabled'] = 0
config['minport'] = port
config['maxport'] = port+5
config['random_port'] = 0
config['bind'] = ''
config['ipv6_binds_v4'] = 0
config['max_message_length'] = 2 ** 23
config['state_dir'] = config['install_dir'] = tempfile.mkdtemp()
config['peer_icon_path'] = 'icons'
self.rawserver = RawServer(self.doneflag,
config['timeout_check_interval'],
config['timeout'],
ipv6_enable = config['ipv6_enabled'],
failfunc = self.report_failure,
errorfunc = self.report_error)
while 1:
try:
self.listen_port = self.rawserver.find_and_bind(0,
config['minport'], config['maxport'], config['bind'],
reuse = True,
ipv6_socket_style = config['ipv6_binds_v4'],
randomizer = config['random_port'])
print >> sys.stderr,"test: Got listen port", self.listen_port
break
except socketerror, e:
self.report_failure(str(e))
msg = "Couldn't not bind to listen port - " + str(e)
self.report_failure(msg)
return
self.multihandler = MultiHandler(self.rawserver, self.doneflag)
# Note: We don't want a singleton, we want
# two different instances for peer1 and peer2
self.secure_overlay = secover
self.my_keypair = EC.gen_params(EC.NID_sect233k1)
self.my_keypair.gen_key()
self.my_permid = str(self.my_keypair.pub().get_der())
self.session = FakeSession(self,self.my_keypair,self.my_permid,self.listen_port)
self.peer_db = PeerDBHandler.getInstance(config)
self.secure_overlay.register(self,config['max_message_length'])
print >>sys.stderr,"Peer: Setting",self.secure_overlay.get_handler(),"as handler at SocketHandler"
self.rawserver.sockethandler.set_handler(self.secure_overlay.get_handler())
self.secure_overlay.start_listening()
# Stupid rawserver goes into very long wait if there are no short
# term tasks. Emulate this
self.rawserver.add_task(self.dummy_task,0)
command_line_parser.add_option("--timeout-check-interval", action="store", type="float", default=1.0)
command_line_parser.add_option("--timeout", action="store", type="float", default=300.0)
# command_line_parser.add_option("--disable-allchannel-script", action="store_true", help="Include allchannel scripts", default=False)
# command_line_parser.add_option("--disable-barter-script", action="store_true", help="Include barter scripts", default=False)
command_line_parser.add_option("--disable-simple-dispersy-test-script", action="store_true", help="Include simple-dispersy-test scripts", default=False)
command_line_parser.add_option("--disable-dispersy-script", action="store_true", help="Include dispersy scripts", default=False)
command_line_parser.add_option("--script", action="store", type="string", help="Runs the Script python file with <SCRIPT> as an argument")
command_line_parser.add_option("--script-args", action="store", type="string", help="Executes --script with these arguments. Example 'startingtimestamp=1292333014,endingtimestamp=12923340000'")
# parse command-line arguments
opt, args = command_line_parser.parse_args()
print "Press Ctrl-C to stop Dispersy"
# start threads
session_done_flag = threading.Event()
rawserver = RawServer(session_done_flag, opt.timeout_check_interval, opt.timeout, False, failfunc=on_fatal_error, errorfunc=on_non_fatal_error)
callback = Callback()
callback.start(name="Dispersy")
callback.register(start)
def watchdog():
while True:
try:
yield 333.3
except GeneratorExit:
rawserver.shutdown()
session_done_flag.set()
break
callback.register(watchdog)
rawserver.listen_forever(None)
callback.stop()
class Instance2InstanceServer(Thread):
def __init__(self,i2iport,connhandler,timeout=300.0):
Thread.__init__(self)
self.setDaemon(True)
self.setName('Instance2Instance'+self.getName())
self.i2iport = i2iport
self.connhandler = connhandler
self.i2idoneflag = Event()
self.rawserver = RawServer(self.i2idoneflag,
timeout/5.0,
timeout,
ipv6_enable = False,
failfunc = self.rawserver_fatalerrorfunc,
errorfunc = self.rawserver_nonfatalerrorfunc)
self.rawserver.add_task(self.rawserver_keepalive,1)
# Only accept local connections
self.rawserver.bind(self.i2iport,bind=['127.0.0.1'],reuse=True)
def rawserver_keepalive(self):
""" Hack to prevent rawserver sleeping in select() for a long time, not
processing any tasks on its queue at startup time
Called by Instance2Instance thread """
self.rawserver.add_task(self.rawserver_keepalive,1)
def shutdown(self):
self.connhandler.shutdown()
self.i2idoneflag.set()
#
# Following methods are called by Instance2Instance thread
#
def rawserver_fatalerrorfunc(self,e):
""" Called by network thread """
if DEBUG:
print >>sys.stderr,"i2is: RawServer fatal error func called",e
print_exc()
def rawserver_nonfatalerrorfunc(self,e):
""" Called by network thread """
if DEBUG:
print >>sys.stderr,"i2is: RawServer non fatal error func called",e
print_exc()
# Could log this somewhere, or phase it out
def run(self):
try:
try:
if DEBUG:
print >>sys.stderr,"i2is: Ready to receive remote commands on",self.i2iport
self.rawserver.listen_forever(self)
except:
print_exc()
finally:
self.rawserver.shutdown()
def external_connection_made(self,s):
try:
self.connhandler.external_connection_made(s)
except:
print_exc()
s.close()
def connection_flushed(self,s):
self.connhandler.connection_flushed(s)
def connection_lost(self,s):
if DEBUG:
print >>sys.stderr,"i2is: connection_lost ------------------------------------------------"
self.connhandler.connection_lost(s)
def data_came_in(self, s, data):
try:
self.connhandler.data_came_in(s,data)
except:
print_exc()
s.close()
def add_task(self,func,t):
self.rawserver.add_task(func,t)
command_line_parser.add_option("--timeout-check-interval", action="store", type="float", default=1.0)
command_line_parser.add_option("--timeout", action="store", type="float", default=300.0)
command_line_parser.add_option("--disable-allchannel-script", action="store_true", help="Include allchannel scripts", default=False)
command_line_parser.add_option("--disable-barter-script", action="store_true", help="Include barter scripts", default=False)
command_line_parser.add_option("--disable-dispersy-script", action="store_true", help="Include dispersy scripts", default=False)
command_line_parser.add_option("--disable-walktest-script", action="store_true", help="Include walktest scripts", default=False)
command_line_parser.add_option("--script", action="store", type="string", help="Runs the Script python file with <SCRIPT> as an argument")
command_line_parser.add_option("--script-args", action="store", type="string", help="Executes --script with these arguments. Example 'startingtimestamp=1292333014,endingtimestamp=12923340000'")
# parse command-line arguments
opt, args = command_line_parser.parse_args()
print "Press Ctrl-C to stop Dispersy"
# start threads
session_done_flag = threading.Event()
rawserver = RawServer(session_done_flag, opt.timeout_check_interval, opt.timeout, False, failfunc=on_fatal_error, errorfunc=on_non_fatal_error)
callback = Callback()
callback.start(name="Dispersy")
def rawserver_adrenaline():
"""
The rawserver tends to wait for a long time between handling tasks. Our tests will fail if
they are delayed by the rawserver for too long.
"""
rawserver.add_task(rawserver_adrenaline, 0.1)
rawserver.add_task(rawserver_adrenaline, 0.1)
def watchdog():
while True:
try:
yield 333.3
class Instance2InstanceServer(Thread):
def __init__(self, i2iport, connhandler, timeout=300.0):
Thread.__init__(self)
self.setDaemon(True)
self.setName('Instance2Instance' + self.getName())
self.i2iport = i2iport
self.connhandler = connhandler
self.i2idoneflag = Event()
self.rawserver = RawServer(self.i2idoneflag,
timeout / 5.0,
timeout,
ipv6_enable=False,
failfunc=self.rawserver_fatalerrorfunc,
errorfunc=self.rawserver_nonfatalerrorfunc)
self.rawserver.add_task(self.rawserver_keepalive, 1)
# Only accept local connections
self.rawserver.bind(self.i2iport, bind=['127.0.0.1'], reuse=True)
def rawserver_keepalive(self):
""" Hack to prevent rawserver sleeping in select() for a long time, not
processing any tasks on its queue at startup time
Called by Instance2Instance thread """
self.rawserver.add_task(self.rawserver_keepalive, 1)
def shutdown(self):
self.connhandler.shutdown()
self.i2idoneflag.set()
#
# Following methods are called by Instance2Instance thread
#
def rawserver_fatalerrorfunc(self, e):
""" Called by network thread """
if DEBUG:
print >> sys.stderr, "i2is: RawServer fatal error func called", e
print_exc()
def rawserver_nonfatalerrorfunc(self, e):
""" Called by network thread """
if DEBUG:
print >> sys.stderr, "i2is: RawServer non fatal error func called", e
print_exc()
# Could log this somewhere, or phase it out
def run(self):
try:
try:
if DEBUG:
print >> sys.stderr, "i2is: Ready to receive remote commands on", self.i2iport
self.rawserver.listen_forever(self)
except:
print_exc()
finally:
self.rawserver.shutdown()
def external_connection_made(self, s):
try:
if DEBUG:
print >> sys.stderr, "i2is: external_connection_made"
self.connhandler.external_connection_made(s)
except:
print_exc()
s.close()
def connection_flushed(self, s):
self.connhandler.connection_flushed(s)
def connection_lost(self, s):
if DEBUG:
print >> sys.stderr, "i2is: connection_lost ------------------------------------------------"
self.connhandler.connection_lost(s)
def data_came_in(self, s, data):
try:
self.connhandler.data_came_in(s, data)
except:
print_exc()
s.close()
def add_task(self, func, t):
self.rawserver.add_task(func, t)
def start_connection(self, dns):
return self.rawserver.start_connection_raw(dns,
handler=self.connhandler)
class Peer(Thread):
def __init__(self, testcase, port, secover):
Thread.__init__(self)
self.setDaemon(True)
self.testcase = testcase
self.doneflag = Event()
config = {}
config['timeout_check_interval'] = 100000
config['timeout'] = 100000
config['ipv6_enabled'] = 0
config['minport'] = port
config['maxport'] = port + 5
config['random_port'] = 0
config['bind'] = ''
config['ipv6_binds_v4'] = 0
config['max_message_length'] = 2**23
config['state_dir'] = config['install_dir'] = tempfile.mkdtemp()
config['peer_icon_path'] = 'icons'
self.rawserver = RawServer(self.doneflag,
config['timeout_check_interval'],
config['timeout'],
ipv6_enable=config['ipv6_enabled'],
failfunc=self.report_failure,
errorfunc=self.report_error)
while 1:
try:
self.listen_port = self.rawserver.find_and_bind(
0,
config['minport'],
config['maxport'],
config['bind'],
reuse=True,
ipv6_socket_style=config['ipv6_binds_v4'],
randomizer=config['random_port'])
print >> sys.stderr, "test: Got listen port", self.listen_port
break
except socketerror, e:
self.report_failure(str(e))
msg = "Couldn't not bind to listen port - " + str(e)
self.report_failure(msg)
return
self.multihandler = MultiHandler(self.rawserver, self.doneflag)
# Note: We don't want a singleton, we want
# two different instances for peer1 and peer2
self.secure_overlay = secover
self.my_keypair = EC.gen_params(EC.NID_sect233k1)
self.my_keypair.gen_key()
self.my_permid = str(self.my_keypair.pub().get_der())
self.session = FakeSession(self, self.my_keypair, self.my_permid,
self.listen_port)
self.peer_db = PeerDBHandler.getInstance(config)
self.secure_overlay.register(self, config['max_message_length'])
print >> sys.stderr, "Peer: Setting", self.secure_overlay.get_handler(
), "as handler at SocketHandler"
self.rawserver.sockethandler.set_handler(
self.secure_overlay.get_handler())
self.secure_overlay.start_listening()
# Stupid rawserver goes into very long wait if there are no short
# term tasks. Emulate this
self.rawserver.add_task(self.dummy_task, 0)
def main():
def on_fatal_error(error):
print >> sys.stderr, error
session_done_flag.set()
def on_non_fatal_error(error):
print >> sys.stderr, error
session_done_flag.set()
def start():
# start Dispersy
dispersy = TrackerDispersy.get_instance(callback,
unicode(opt.statedir),
opt.port)
dispersy.endpoint = RawserverEndpoint(rawserver, dispersy, opt.port,
opt.ip)
dispersy.define_auto_load(TrackerCommunity)
command_line_parser = optparse.OptionParser()
command_line_parser.add_option("--statedir",
action="store",
type="string",
help="Use an alternate statedir",
default=".")
command_line_parser.add_option("--ip",
action="store",
type="string",
default="0.0.0.0",
help="Dispersy uses this ip")
command_line_parser.add_option("--port",
action="store",
type="int",
help="Dispersy uses this UDL port",
default=6421)
command_line_parser.add_option("--timeout-check-interval",
action="store",
type="float",
default=60.0)
command_line_parser.add_option("--timeout",
action="store",
type="float",
default=300.0)
# parse command-line arguments
opt, _ = command_line_parser.parse_args()
print "Press Ctrl-C to stop Dispersy"
# start threads
session_done_flag = threading.Event()
rawserver = RawServer(session_done_flag,
opt.timeout_check_interval,
opt.timeout,
False,
failfunc=on_fatal_error,
errorfunc=on_non_fatal_error)
callback = Callback()
callback.start(name="Dispersy")
callback.register(start)
def rawserver_adrenaline():
"""
The rawserver tends to wait for a long time between handling tasks.
"""
rawserver.add_task(rawserver_adrenaline, 0.1)
rawserver.add_task(rawserver_adrenaline, 0.1)
def watchdog():
while True:
try:
yield 333.3
except GeneratorExit:
rawserver.shutdown()
session_done_flag.set()
break
callback.register(watchdog)
rawserver.listen_forever(None)
callback.stop()