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)