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()
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)
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)
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
except GeneratorExit:
rawserver.shutdown()
session_done_flag.set()
break
callback.register(watchdog)
callback.register(start)
rawserver.listen_forever(None)
callback.stop()
if callback.exception:
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()
