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
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()
