def test_tcp_bind(my_tcp_server):
server_addr = my_tcp_server
time.sleep(1)
io_engine = ioloop.get_ioloop("select")
server = connection.TCPConnection(io_engine=io_engine)
with pytest.raises(connection.BindException):
server.bind(server_addr)
def test_arecv_zero():
server = socketserver.TCPServer(
("127.0.0.1", random.randint(20000, 30000)), TcpEchoHandler)
server_addr = server.server_address
pcs = Process(target=server.serve_forever)
pcs.start()
io_engine = ioloop.get_ioloop("select")
client = connection.TCPConnection(io_engine=io_engine)
def on_recved(_, data, err):
client.close()
client.stop()
assert not data
def on_sent(conn, err):
assert err.errcode == connection.E_OK
os.kill(pcs.pid, signal.SIGTERM)
conn.arecv(2048, on_recved)
pcs.join()
def on_connected(conn, err):
assert err.errcode == connection.E_OK
conn.asend(b'x' * 2048, on_sent)
time.sleep(1)
client.aconnect(server_addr, on_connected)
client.run()
def init_forwarder(self):
io_engine = ioloop.get_ioloop(self.args.mode)
h = self.args.handler
upstreams = h.init(io_engine)
if not upstreams:
print("invalid upstreams")
sys.exit(1)
self.forwarder = forwarder.Forwarder(io_engine, upstreams,
self.args.listen,
self.args.timeout, h)
def test_aconnect_fail():
server_addr = ("127.0.0.1234", 2)
io_engine = ioloop.get_ioloop("select")
client = connection.TCPConnection(io_engine=io_engine)
def on_connected(_, err):
client.stop()
assert err.errcode == connection.E_FAIL
client.aconnect(server_addr, on_connected)
client.run()
def init_forwarder(self):
self.logger.info("GreenDNS %s", __version__)
io_engine = ioloop.get_ioloop(self.args.mode)
h = self.args.handler
upstreams = h.init(io_engine)
if not upstreams:
print("invalid upstreams")
sys.exit(1)
self.forwarder = forwarder.Forwarder(io_engine, upstreams,
self.args.listen,
self.args.timeout, h)
def test_forwarder_bind(forwarder):
io_engine = ioloop.get_ioloop("select")
addr1 = Addr("udp", "1.1.1.1", 53)
addr2 = Addr("tcp", "2.2.2.2", 53)
upstreams = [addr1, addr2]
listen = "%s:%d" % (forwarder.listen_addr[0], forwarder.listen_addr[1])
timeout = 1.0
handler = QuickestHandler()
handler.init(io_engine)
with pytest.raises(SystemExit):
f = Forwarder(io_engine, upstreams, listen, timeout, handler)
def forwarder(udp_server_process):
server_addr1, server_addr2 = udp_server_process
io_engine = ioloop.get_ioloop("select")
addr1 = Addr("udp", *server_addr1)
addr2 = Addr("tcp", *server_addr2)
upstreams = [addr1, addr2]
listen = "127.0.0.1:0"
timeout = 1.0
handler = QuickestHandler()
handler.init(io_engine)
f = Forwarder(io_engine, upstreams, listen, timeout, handler)
return f
def test_udp_client_sent_err(udp_server_process):
server_addr = udp_server_process
io_engine = ioloop.get_ioloop("select")
client = connection.UDPConnection(io_engine=io_engine)
client.set_recv_buffer_size(2048)
def on_sent_err(sock, _, err):
client.close()
client.stop()
assert err.errcode == connection.E_FAIL
length = 64 * 1024 + 1
client.asend(server_addr, b'x' * length, on_sent_err)
client.run()
def test_udp_client(udp_server_process):
server_addr = udp_server_process
io_engine = ioloop.get_ioloop("select")
client = connection.UDPConnection(io_engine=io_engine)
client.set_recv_buffer_size(2048)
def on_recved(sock, _, data, err):
client.close()
client.stop()
assert data == b'x' * 2048
assert err.errcode == connection.E_OK
def on_sent(sock, _, err):
client.arecv(on_recved)
assert err.errcode == connection.E_OK
client.asend(server_addr, b'x' * 2048, on_sent)
client.run()
def my_udp_server():
io_engine = ioloop.get_ioloop("select")
server = connection.UDPConnection(io_engine=io_engine)
server.bind(("127.0.0.1", 0))
server.set_recv_buffer_size(2048)
def on_sent(sock, _, err):
server.close()
server.stop()
assert err.errcode == connection.E_OK
def on_recved(sock, remote_addr, data, err):
assert err.errcode == connection.E_OK
server.asend(remote_addr, data, on_sent)
server.arecv(on_recved)
p = Process(target=server.run)
p.start()
yield server.bind_addr
os.kill(p.pid, signal.SIGINT)
p.join()
def test_tcp_client(tcp_server_process):
server_addr = tcp_server_process
io_engine = ioloop.get_ioloop("select")
client = connection.TCPConnection(io_engine=io_engine)
def on_recved(_, data, err):
client.close()
client.stop()
assert data == b'x' * 2048
assert err.errcode == connection.E_OK
def on_sent(conn, err):
assert err.errcode == connection.E_OK
conn.arecv(2048, on_recved)
def on_connected(conn, err):
assert err.errcode == connection.E_OK
conn.asend(b'x' * 2048, on_sent)
client.aconnect(server_addr, on_connected)
client.run()
def start_tcp_server():
io_engine = ioloop.get_ioloop("select")
server = connection.TCPConnection(io_engine=io_engine)
server.bind(("127.0.0.1", random.randint(20000, 30000)))
def on_sent(_, err):
server.close()
server.stop()
assert err.errcode == connection.E_OK
def on_recved(conn, data, err):
assert err.errcode == connection.E_OK
conn.asend(data, on_sent)
def on_connected(newconn, err):
assert err.errcode == connection.E_OK
newconn.arecv(2000, on_recved)
server.accept(on_connected)
pcs = Process(target=server.run)
pcs.start()
return (server.bind_addr, pcs)
def test_udp_bind(my_udp_server):
server_addr = my_udp_server
io_engine = ioloop.get_ioloop("select")
server = connection.UDPConnection(io_engine=io_engine)
with pytest.raises(connection.BindException):
server.bind(server_addr)
def iol(request):
return ioloop.get_ioloop(request.param)
