def __init__(self, o, accstr, acc2str, tester): self.o = o self.name = accstr self.io1 = None self.io2 = None self.waiter = gensio.waiter(o) gensios_enabled.check_iostr_gensios(accstr) self.acc = gensio.gensio_accepter(o, accstr, self) self.acc.startup() port = self.acc.control(gensio.GENSIO_CONTROL_DEPTH_FIRST, True, gensio.GENSIO_ACC_CONTROL_LPORT, "0") acc2str = acc2str + port self.acc2 = gensio.gensio_accepter(o, acc2str, self) print(" First connection") self.expect_connects = True self.acc2.startup() self.wait() tester(self.io1, self.io2) self.close() print(" Second connection") self.wait() tester(self.io1, self.io2) print(" Disable connections") self.expect_connects = False self.acc2.set_accept_callback_enable_cb(False, self) self.wait() self.close() # Make sure no connections come in if self.waiter.wait_timeout(1, 200) != 0: raise Exception("Got wakeup when nothing should happen") print(" Re-enable connections") self.expect_connects = True self.acc2.set_accept_callback_enable(True) self.wait() tester(self.io1, self.io2) print(" Disable connections synchronous") self.expect_connects = False self.acc2.set_accept_callback_enable_s(False) self.close() # Make sure no connections come in if self.waiter.wait_timeout(1, 200) != 0: raise Exception("Got wakeup when nothing should happen") print(" Re-enable connections") self.expect_connects = True self.acc2.set_accept_callback_enable(True) self.wait() tester(self.io1, self.io2) self.acc.shutdown_s() self.acc2.shutdown_s() self.close()
def __init__(self, o, iostr, io2str, io3str, tester, name=None, io1_dummy_write=None, CA=None, do_close=True, auth_begin_rv=gensio.GE_NOTSUP, expect_pw=None, expect_pw_rv=gensio.GE_NOTSUP, password=None): self.o = o if (name): self.name = name else: self.name = iostr self.waiter = gensio.waiter(o) self.acc = gensio.gensio_accepter(o, iostr, self) self.acc.startup() self.acc2 = gensio.gensio_accepter(o, io2str, self) self.acc2.startup() self.io1 = self.acc2.str_to_gensio(io3str, None) self.io2 = None self.CA = CA h = utils.HandleData(o, io3str, io=self.io1, password=password) self.auth_begin_rv = auth_begin_rv self.expect_pw = expect_pw self.expect_pw_rv = expect_pw_rv try: self.io1.open_s() except: self.io1 = None self.close() raise if (io1_dummy_write): # For UDP, kick start things. self.io1.write(io1_dummy_write, None) try: self.wait() except: self.close() raise if (io1_dummy_write): self.io2.handler.set_compare(io1_dummy_write) if (self.io2.handler.wait_timeout(1000) == 0): raise Exception( ("%s: %s: " % ("test_accept", self.io2.handler.name)) + ("Timed out waiting for dummy read at byte %d" % self.io2.handler.compared)) tester(self.io1, self.io2) if do_close: self.close()
def __init__(self, o, iostr, io2str, io3str, tester, name = None, io1_dummy_write = None, CA=None, do_close = True, auth_begin_rv = gensio.GE_NOTSUP, expect_pw = None, expect_pw_rv = gensio.GE_NOTSUP, password = None, expect_remclose = True, use_port = True): self.o = o if (name): self.name = name else: self.name = iostr self.waiter = gensio.waiter(o) gensios_enabled.check_iostr_gensios(iostr) gensios_enabled.check_iostr_gensios(io2str) self.acc = gensio.gensio_accepter(o, iostr, self); self.acc.startup() self.acc2 = gensio.gensio_accepter(o, io2str, self); self.acc2.startup() if (use_port): port = self.acc.control(gensio.GENSIO_CONTROL_DEPTH_FIRST, True, gensio.GENSIO_ACC_CONTROL_LPORT, "0") io3str = io3str + port self.io1 = self.acc2.str_to_gensio(io3str, None); self.io2 = None self.CA = CA h = HandleData(o, io3str, io = self.io1, password = password, expect_remclose = expect_remclose) self.auth_begin_rv = auth_begin_rv self.expect_pw = expect_pw self.expect_pw_rv = expect_pw_rv try: self.io1.open_s() except: self.io1 = None self.close() raise self.io1.read_cb_enable(True) if (io1_dummy_write): # For UDP, kick start things. self.io1.write(io1_dummy_write, None) try: self.wait() except: self.close() raise if (io1_dummy_write): self.io2.handler.set_compare(io1_dummy_write) if (self.io2.handler.wait_timeout(1000) == 0): raise Exception(("%s: %s: " % ("test_accept", self.io2.handler.name)) + ("Timed out waiting for dummy read at byte %d" % self.io2.handler.compared)) tester(self.io1, self.io2) if do_close: self.close()
def __init__(self, o, io1, iostr, tester, name=None, io1_dummy_write=None, do_close=True): self.o = o if (name): self.name = name else: self.name = iostr self.io1 = io1 self.io2 = None self.waiter = gensio.waiter(o) self.acc = gensio.gensio_accepter(o, iostr, self) self.acc.startup() io1.open_s() if (io1_dummy_write): # For UDP, kick start things. io1.write(io1_dummy_write, None) self.wait() if (io1_dummy_write): self.io2.handler.set_compare(io1_dummy_write) if (self.io2.handler.wait_timeout(1000) == 0): raise Exception( ("%s: %s: " % ("test_accept", self.io2.handler.name)) + ("Timed out waiting for dummy read at byte %d" % self.io2.handler.compared)) tester(self.io1, self.io2) if do_close: self.close()
def test_sync_gensio_accepter(o): print("Testing sync accept") gensios_enabled.check_iostr_gensios("tcp") a = gensio.gensio_accepter(o, "tcp,0", None) a.set_sync() a.startup() port = a.control(gensio.GENSIO_CONTROL_DEPTH_FIRST, True, gensio.GENSIO_ACC_CONTROL_LPORT, "0") sa = SyncEvent() (io, time) = a.accept_s_timeout(o, sa, 1) if io != None or time != 0: raise Exception("accept_s_timeout didn't time out") sg = SyncEvent() gensios_enabled.check_iostr_gensios("tcp") g = gensio.gensio(o, "tcp,localhost," + port, sg) g.open(sg) (io, time) = a.accept_s_timeout(o, sa, 1000) if io == None or time == 0: raise Exception("accept_s_timeout timed out") return
def __init__(self, o, io1str, accstr, tester, name=None, io1_dummy_write=None, do_close=True, expected_raddr=None, expected_acc_laddr=None, chunksize=10240, get_port=True, except_on_log=False): self.o = o self.except_on_log = except_on_log if (name): self.name = name else: self.name = accstr self.io2 = None self.waiter = gensio.waiter(o) gensios_enabled.check_iostr_gensios(accstr) self.acc = gensio.gensio_accepter(o, accstr, self) self.acc.startup() self.waiter.service(1) # Wait a bit for the accepter to start up. if get_port: port = self.acc.control(gensio.GENSIO_CONTROL_DEPTH_FIRST, True, gensio.GENSIO_ACC_CONTROL_LPORT, "0") else: port = "" io1str = io1str + port io1 = alloc_io(o, io1str, do_open=False, chunksize=chunksize) self.io1 = io1 if expected_acc_laddr: expected_acc_laddr = expected_acc_laddr + port if expected_raddr: expected_raddr = expected_raddr + port if expected_acc_laddr: check_laddr(self.acc, self.name, expected_acc_laddr) io1.open_s() if expected_raddr: check_raddr(io1, self.name, expected_raddr) if (io1_dummy_write): # For UDP, kick start things. io1.write(io1_dummy_write, None) self.wait() if (io1_dummy_write): self.io2.handler.set_compare(io1_dummy_write) if (self.io2.handler.wait_timeout(1000) == 0): raise Exception( ("%s: %s: " % ("test_accept", self.io2.handler.name)) + ("Timed out waiting for dummy read at byte %d" % self.io2.handler.compared)) tester(self.io1, self.io2) if do_close: self.close()
def __init__(self, o, iostr, name=None, chunksize=10240, io=None, io_is_accepter=False): """Start a gensio object with this handler""" if (name): self.name = name else: self.name = iostr self.waiter = gensio.waiter(o) self.to_write = None self.to_compare = None self.to_waitfor = None self.expecting_modemstate = False self.expecting_linestate = False self.expected_server_cb = None self.expected_server_value = 0 self.expected_server_return = 0 self.ignore_input = False self.expected_err = None self.io = None self.acc = None if io: if io_is_accepter: self.acc = io else: self.io = io io.set_cbs(self) else: if io_is_accepter: self.acc = gensio.gensio_accepter(o, iostr, self) else: self.io = gensio.gensio(o, iostr, self) if io_is_accepter: self.acc.handler = self else: self.io.handler = self self.chunksize = chunksize self.debug = 0 return
def test_sync_gensio_accepter(o): a = gensio.gensio_accepter(o, "tcp,3023", None) a.set_sync() a.startup() sa = SyncEvent() (io, time) = a.accept_s_timeout(o, sa, 1) if io != None or time != 0: raise Exception("accept_s_timeout didn't time out") sg = SyncEvent() g = gensio.gensio(o, "tcp,localhost,3023", sg) g.open(sg) (io, time) = a.accept_s_timeout(o, sa, 1000) if io == None or time == 0: raise Exception("accept_s_timeout timed out") return
def __init__(self, o, io1str, accstr, tester, name = None, io1_dummy_write = None, do_close = True, expected_raddr = None, expected_acc_laddr = None, chunksize = 10240, get_port = True, except_on_log = False, is_sergensio = False): self.o = o self.except_on_log = except_on_log if (name): self.name = name else: self.name = accstr if debug: print("TestAccept " + self.name); self.io2 = None self.waiter = gensio.waiter(o) gensios_enabled.check_iostr_gensios(accstr) self.acc = gensio.gensio_accepter(o, accstr, self); if is_sergensio: sga = self.acc.cast_to_sergensio_acc() if not sga: raise Exception("Cast to sergensio_accepter failed"); ga = sga.cast_to_gensio_acc() del sga del ga else: sga = None try: sga = self.acc.cast_to_sergensio_acc() except: pass if sga: raise Exception("Cast to sergensio_accepter succeeded"); if debug: print("acc startup"); self.acc.startup() self.waiter.service(1) # Wait a bit for the accepter to start up. if get_port: port = self.acc.control(gensio.GENSIO_CONTROL_DEPTH_FIRST, True, gensio.GENSIO_ACC_CONTROL_LPORT, "0") else: port = "" io1str = io1str + port io1 = alloc_io(o, io1str, do_open = False, chunksize = chunksize) self.io1 = io1 if expected_acc_laddr: expected_acc_laddr = expected_acc_laddr + port if expected_raddr: expected_raddr = expected_raddr + port if expected_acc_laddr: check_laddr(self.acc, self.name, expected_acc_laddr) if debug: print("io1 open " + self.name); io1.open_s() if expected_raddr: check_raddr(io1, self.name, expected_raddr) if (io1_dummy_write): # For UDP, kick start things. io1.write(io1_dummy_write, None) if debug: print("wait 1 " + self.name); # Wait for the accept to happen if (self.wait_timeout(1000) == 0): raise Exception(("%s: %s: " % ("test_accept", self.name)) + ("Timed out waiting for initial connection")) if (io1_dummy_write): self.io2.handler.set_compare(io1_dummy_write) if (self.io2.handler.wait_timeout(1000) == 0): raise Exception(("%s: %s: " % ("test_accept", self.io2.handler.name)) + ("Timed out waiting for dummy read at byte %d" % self.io2.handler.compared)) tester(self.io1, self.io2) if do_close: self.close()
self.check_finish() return def shutdown_done(self, acc): self.acc = None self.check_finish() return def shutdown(self, ioev): if self.in_shutdown: return self.in_shutdown = True self.acc.shutdown(self) for i in self.ios: if i != ioev: # The caller will close itself, let it finish its write i.io.close(i) def wait(self): self.waiter.wait(1) if len(sys.argv) < 2: print("No gensio supplied on commandline") sys.exit(1) accev = AccEvent() accev.acc = gensio.gensio_accepter(o, sys.argv[1], accev) accev.acc.startup() accev.wait()
def test_mux_limits(): print("Testing mux limits") handlemuxacc = MuxHandler(o, num_channels=10) muxacc = gensio.gensio_accepter(o, "mux(max_channels=10),tcp,3023", handlemuxacc) muxacc.startup() handlemuxcl = MuxHandler(o, num_channels=10) muxcl = gensio.gensio(o, "mux(service=0,max_channels=10),tcp,localhost,3023", handlemuxcl) handlemuxcl.channels[0] = muxcl handlemuxacc.set_op_count(1) handlemuxcl.set_op_count(1) muxcl.open(handlemuxcl) if (handlemuxcl.wait(timeout=1000) == 0): raise utils.HandlerException( "Timeout waiting for single client open finish") if (handlemuxacc.wait(timeout=1000) == 0): raise utils.HandlerException( "Timeout waiting for single client open finish") print("Opening all channels") handlemuxcl.set_op_count(9) handlemuxacc.set_op_count(9) for i in range(1, 10): handlemuxcl.channels[i] = muxcl.alloc_channel(["service=%d" % i], handlemuxcl) handlemuxcl.channels[i].open(handlemuxcl) print("Waiting for channels") if (handlemuxcl.wait(timeout=2000) == 0): raise utils.HandlerException("Timeout waiting for client open finish") if (handlemuxacc.wait(timeout=2000) == 0): raise utils.HandlerException("Timeout waiting for server open finish") print("Trying an open that should fail") try: muxcl.alloc_channel(["service=%d" % 10], handlemuxcl) except Exception as err: if str(err) != "gensio:alloc_channel: Object was already in use": raise utils.HandlerException("Got wrong error: %s" % str(err)) else: raise utils.HandlerException( "No exception when opening too many channels") print("Close one channel") handlemuxcl.set_expect_close(3) handlemuxacc.set_expect_close(3) handlemuxcl.set_op_count(1) handlemuxacc.set_op_count(1) handlemuxacc.channels[3].close(handlemuxacc) if (handlemuxcl.wait(timeout=1000) == 0): raise utils.HandlerException( "Timeout waiting for single client close finish") if (handlemuxacc.wait(timeout=1000) == 0): raise utils.HandlerException( "Timeout waiting for single server close finish") print("Open that channel again") handlemuxacc.set_op_count(1) handlemuxcl.set_op_count(1) handlemuxcl.channels[3] = muxcl.alloc_channel(["service=3"], handlemuxcl) handlemuxcl.channels[3].open(handlemuxcl) if (handlemuxcl.wait(timeout=1000) == 0): raise utils.HandlerException( "Timeout waiting for client singe close finish") if (handlemuxacc.wait(timeout=1000) == 0): raise utils.HandlerException( "Timeout waiting for server single close finish") print("Close all channels") handlemuxcl.set_expect_close(-1) handlemuxacc.set_expect_close(-1) handlemuxcl.set_op_count(10) handlemuxacc.set_op_count(10) for i in range(0, 10): if (i % 2 == 0): handlemuxcl.channels[i].close(handlemuxcl) else: handlemuxacc.channels[i].close(handlemuxacc) if (handlemuxcl.wait(timeout=2000) == 0): raise utils.HandlerException( "Timeout waiting for client all close finish") if (handlemuxacc.wait(timeout=2000) == 0): raise utils.HandlerException( "Timeout waiting for server all close finish") print("Re-open the mux") handlemuxacc.set_op_count(1) handlemuxcl.set_op_count(1) muxcl.open(handlemuxcl) if (handlemuxcl.wait(timeout=1000) == 0): raise utils.HandlerException( "Timeout waiting for single client open finish") if (handlemuxacc.wait(timeout=1000) == 0): raise utils.HandlerException( "Timeout waiting for single client open finish") print("Re-close the mux") handlemuxacc.set_op_count(1) handlemuxcl.set_op_count(1) handlemuxcl.channels[0] = muxcl muxcl.close(handlemuxcl) if (handlemuxcl.wait(timeout=1000) == 0): raise utils.HandlerException( "Timeout waiting for single client open finish") if (handlemuxacc.wait(timeout=1000) == 0): raise utils.HandlerException( "Timeout waiting for single client open finish") return
io.read_cb_enable(True) self.dec_op_count() return def wait(self, count=1, timeout=0): if (timeout > 0): return self.waiter.wait_timeout(count, timeout) else: return self.waiter.wait(count) return print("Testing mux limits") handlemuxacc = MuxHandler(o, num_channels=10) gensios_enabled.check_iostr_gensios("mux,tcp") muxacc = gensio.gensio_accepter(o, "mux(max_channels=10),tcp,0", handlemuxacc) muxacc.startup() port = muxacc.control(gensio.GENSIO_CONTROL_DEPTH_FIRST, True, gensio.GENSIO_ACC_CONTROL_LPORT, "0") handlemuxcl = MuxHandler(o, num_channels=10) muxcl = gensio.gensio(o, "mux(service=0,max_channels=10),tcp,localhost," + port, handlemuxcl) handlemuxcl.channels[0] = muxcl handlemuxacc.set_op_count(1) handlemuxcl.set_op_count(1) muxcl.open(handlemuxcl) if (handlemuxcl.wait(timeout=1000) == 0): raise HandlerException("Timeout waiting for single client open finish")