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, 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["torrent_collecting_dir"] = 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, time.asctime(), "-", "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 __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['torrent_collecting_dir'] = 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()
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)
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,time.asctime(),'-', "i2is: RawServer fatal error func called",e
print_exc()
def rawserver_nonfatalerrorfunc(self,e):
""" Called by network thread """
if DEBUG:
print >>sys.stderr,time.asctime(),'-', "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,time.asctime(),'-', "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,time.asctime(),'-', "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 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, time.asctime(), "-", "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)
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 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()
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)
