def test_read_pty_output(self):
proto = MyReadPipeProto(loop=self.loop)
master, slave = os.openpty()
master_read_obj = io.open(master, "rb", 0)
@asyncio.coroutine
def connect():
t, p = yield from self.loop.connect_read_pipe(lambda: proto, master_read_obj)
self.assertIs(p, proto)
self.assertIs(t, proto.transport)
self.assertEqual(["INITIAL", "CONNECTED"], proto.state)
self.assertEqual(0, proto.nbytes)
self.loop.run_until_complete(connect())
os.write(slave, b"1")
test_utils.run_until(self.loop, lambda: proto.nbytes)
self.assertEqual(1, proto.nbytes)
os.write(slave, b"2345")
test_utils.run_until(self.loop, lambda: proto.nbytes >= 5)
self.assertEqual(["INITIAL", "CONNECTED"], proto.state)
self.assertEqual(5, proto.nbytes)
# On Linux, transport raises EIO when slave is closed --
# ignore it.
self.loop.set_exception_handler(lambda loop, ctx: None)
os.close(slave)
self.loop.run_until_complete(proto.done)
self.assertEqual(["INITIAL", "CONNECTED", "EOF", "CLOSED"], proto.state)
# extra info is available
self.assertIsNotNone(proto.transport.get_extra_info("pipe"))
def test_read_pipe(self):
proto = MyReadPipeProto(loop=self.loop)
rpipe, wpipe = os.pipe()
pipeobj = io.open(rpipe, 'rb', 1024)
@asyncio.coroutine
def connect():
t, p = yield from self.loop.connect_read_pipe(
lambda: proto, pipeobj)
self.assertIs(p, proto)
self.assertIs(t, proto.transport)
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(0, proto.nbytes)
self.loop.run_until_complete(connect())
os.write(wpipe, b'1')
test_utils.run_until(self.loop, lambda: proto.nbytes >= 1)
self.assertEqual(1, proto.nbytes)
os.write(wpipe, b'2345')
test_utils.run_until(self.loop, lambda: proto.nbytes >= 5)
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(5, proto.nbytes)
os.close(wpipe)
self.loop.run_until_complete(proto.done)
self.assertEqual(
['INITIAL', 'CONNECTED', 'EOF', 'CLOSED'], proto.state)
# extra info is available
self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
def test_read_pipe(loop):
proto = MyReadPipeProto(loop=loop)
rpipe, wpipe = os.pipe()
pipeobj = io.open(rpipe, 'rb', 1024)
@asyncio.coroutine
def connect():
t, p = yield from loop.connect_read_pipe(lambda: proto, pipeobj)
assert p is proto
assert t is proto.transport
assert ['INITIAL', 'CONNECTED'] == proto.state
assert 0 == proto.nbytes
loop.run_until_complete(connect())
os.write(wpipe, b'1')
test_utils.run_until(loop, lambda: proto.nbytes >= 1)
assert 1 == proto.nbytes
os.write(wpipe, b'2345')
test_utils.run_until(loop, lambda: proto.nbytes >= 5)
assert ['INITIAL', 'CONNECTED'] == proto.state
assert 5 == proto.nbytes
os.close(wpipe)
loop.run_until_complete(proto.done)
assert ['INITIAL', 'CONNECTED', 'EOF', 'CLOSED'] == proto.state
# extra info is available
assert proto.transport.get_extra_info('pipe') is not None
def test_read_pipe(self):
proto = MyReadPipeProto(loop=self.loop)
rpipe, wpipe = os.pipe()
pipeobj = io.open(rpipe, 'rb', 1024)
@asyncio.coroutine
def connect():
t, p = yield from self.loop.connect_read_pipe(
lambda: proto, pipeobj)
self.assertIs(p, proto)
self.assertIs(t, proto.transport)
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(0, proto.nbytes)
self.loop.run_until_complete(connect())
os.write(wpipe, b'1')
test_utils.run_until(self.loop, lambda: proto.nbytes >= 1)
self.assertEqual(1, proto.nbytes)
os.write(wpipe, b'2345')
test_utils.run_until(self.loop, lambda: proto.nbytes >= 5)
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(5, proto.nbytes)
os.close(wpipe)
self.loop.run_until_complete(proto.done)
self.assertEqual(
['INITIAL', 'CONNECTED', 'EOF', 'CLOSED'], proto.state)
# extra info is available
self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
def test_create_datagram_endpoint_addrs(self):
class TestMyDatagramProto(MyDatagramProto):
def __init__(inner_self):
super().__init__(loop=self.loop)
def datagram_received(self, data, addr):
super().datagram_received(data, addr)
self.transport.sendto(b'resp:' + data, addr)
for lc in (('127.0.0.1', 0), None):
if lc is None and not isinstance(self.loop, uvloop.Loop):
# TODO This looks like a bug in asyncio -- if no local_addr
# and no remote_addr are specified, the connection
# that asyncio creates is not bound anywhere.
return
with self.subTest(local_addr=lc):
coro = self.loop.create_datagram_endpoint(
TestMyDatagramProto, local_addr=lc, family=socket.AF_INET)
s_transport, server = self.loop.run_until_complete(coro)
host, port = s_transport.get_extra_info('sockname')
self.assertIsInstance(server, TestMyDatagramProto)
self.assertEqual('INITIALIZED', server.state)
self.assertIs(server.transport, s_transport)
extra = {}
if hasattr(socket, 'SO_REUSEPORT') and \
sys.version_info[:3] >= (3, 5, 1):
extra['reuse_port'] = True
coro = self.loop.create_datagram_endpoint(
lambda: MyDatagramProto(loop=self.loop),
family=socket.AF_INET,
remote_addr=None if lc is None else (host, port),
**extra)
transport, client = self.loop.run_until_complete(coro)
self.assertIsInstance(client, MyDatagramProto)
self.assertEqual('INITIALIZED', client.state)
self.assertIs(client.transport, transport)
transport.sendto(b'xxx', (host, port) if lc is None else None)
test_utils.run_until(self.loop, lambda: server.nbytes)
self.assertEqual(3, server.nbytes)
test_utils.run_until(self.loop, lambda: client.nbytes)
# received
self.assertEqual(8, client.nbytes)
# extra info is available
self.assertIsNotNone(transport.get_extra_info('sockname'))
# close connection
transport.close()
self.loop.run_until_complete(client.done)
self.assertEqual('CLOSED', client.state)
server.transport.close()
self.loop.run_until_complete(server.done)
def test_create_datagram_endpoint_addrs(self):
class TestMyDatagramProto(MyDatagramProto):
def __init__(inner_self):
super().__init__(loop=self.loop)
def datagram_received(self, data, addr):
super().datagram_received(data, addr)
self.transport.sendto(b'resp:' + data, addr)
for lc in (('127.0.0.1', 0), None):
if lc is None and not isinstance(self.loop, uvloop.Loop):
# TODO This looks like a bug in asyncio -- if no local_addr
# and no remote_addr are specified, the connection
# that asyncio creates is not bound anywhere.
return
with self.subTest(local_addr=lc):
coro = self.loop.create_datagram_endpoint(
TestMyDatagramProto, local_addr=lc, family=socket.AF_INET)
s_transport, server = self.loop.run_until_complete(coro)
host, port = s_transport.get_extra_info('sockname')
self.assertIsInstance(server, TestMyDatagramProto)
self.assertEqual('INITIALIZED', server.state)
self.assertIs(server.transport, s_transport)
extra = {}
if hasattr(socket, 'SO_REUSEPORT') and \
sys.version_info[:3] >= (3, 5, 1):
extra['reuse_port'] = True
coro = self.loop.create_datagram_endpoint(
lambda: MyDatagramProto(loop=self.loop),
family=socket.AF_INET,
remote_addr=None if lc is None else (host, port),
**extra)
transport, client = self.loop.run_until_complete(coro)
self.assertIsInstance(client, MyDatagramProto)
self.assertEqual('INITIALIZED', client.state)
self.assertIs(client.transport, transport)
transport.sendto(b'xxx', (host, port) if lc is None else None)
test_utils.run_until(self.loop, lambda: server.nbytes)
self.assertEqual(3, server.nbytes)
test_utils.run_until(self.loop, lambda: client.nbytes)
# received
self.assertEqual(8, client.nbytes)
# extra info is available
self.assertIsNotNone(transport.get_extra_info('sockname'))
# close connection
transport.close()
self.loop.run_until_complete(client.done)
self.assertEqual('CLOSED', client.state)
server.transport.close()
self.loop.run_until_complete(server.done)
def _test_create_datagram_endpoint_addrs(self, family, lc_addr):
class TestMyDatagramProto(MyDatagramProto):
def __init__(inner_self):
super().__init__(loop=self.loop)
def datagram_received(self, data, addr):
super().datagram_received(data, addr)
self.transport.sendto(b'resp:' + data, addr)
coro = self.loop.create_datagram_endpoint(TestMyDatagramProto,
local_addr=lc_addr,
family=family)
s_transport, server = self.loop.run_until_complete(coro)
host, port, *_ = s_transport.get_extra_info('sockname')
self.assertIsInstance(server, TestMyDatagramProto)
self.assertEqual('INITIALIZED', server.state)
self.assertIs(server.transport, s_transport)
extra = {}
if hasattr(socket, 'SO_REUSEPORT') and \
sys.version_info[:3] >= (3, 5, 1):
extra['reuse_port'] = True
coro = self.loop.create_datagram_endpoint(
lambda: MyDatagramProto(loop=self.loop),
family=family,
remote_addr=(host, port),
**extra)
transport, client = self.loop.run_until_complete(coro)
self.assertIsInstance(client, MyDatagramProto)
self.assertEqual('INITIALIZED', client.state)
self.assertIs(client.transport, transport)
transport.sendto(b'xxx')
test_utils.run_until(self.loop, lambda: server.nbytes)
self.assertEqual(3, server.nbytes)
test_utils.run_until(self.loop, lambda: client.nbytes)
# received
self.assertEqual(8, client.nbytes)
# extra info is available
self.assertIsNotNone(transport.get_extra_info('sockname'))
# close connection
transport.close()
self.loop.run_until_complete(client.done)
self.assertEqual('CLOSED', client.state)
server.transport.close()
self.loop.run_until_complete(server.done)
def test_write_pty(self):
master, slave = os.openpty()
os.set_blocking(master, False)
slave_write_obj = io.open(slave, 'wb', 0)
proto = MyWritePipeProto(loop=self.loop)
connect = self.loop.connect_write_pipe(lambda: proto, slave_write_obj)
transport, p = self.loop.run_until_complete(connect)
self.assertIs(p, proto)
self.assertIs(transport, proto.transport)
self.assertEqual('CONNECTED', proto.state)
transport.write(b'1')
data = bytearray()
def reader(data):
try:
chunk = os.read(master, 1024)
except BlockingIOError:
return len(data)
data += chunk
return len(data)
test_utils.run_until(self.loop, lambda: reader(data) >= 1,
timeout=10)
self.assertEqual(b'1', data)
transport.write(b'2345')
test_utils.run_until(self.loop, lambda: reader(data) >= 5,
timeout=10)
self.assertEqual(b'12345', data)
self.assertEqual('CONNECTED', proto.state)
os.close(master)
# extra info is available
self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
# close connection
proto.transport.close()
self.loop.run_until_complete(proto.done)
self.assertEqual('CLOSED', proto.state)
def test_write_pty(self):
master, slave = os.openpty()
os.set_blocking(master, False)
slave_write_obj = io.open(slave, "wb", 0)
proto = MyWritePipeProto(loop=self.loop)
connect = self.loop.connect_write_pipe(lambda: proto, slave_write_obj)
transport, p = self.loop.run_until_complete(connect)
self.assertIs(p, proto)
self.assertIs(transport, proto.transport)
self.assertEqual("CONNECTED", proto.state)
transport.write(b"1")
data = bytearray()
def reader(data):
try:
chunk = os.read(master, 1024)
except BlockingIOError:
return len(data)
data += chunk
return len(data)
test_utils.run_until(self.loop, lambda: reader(data) >= 1, timeout=10)
self.assertEqual(b"1", data)
transport.write(b"2345")
test_utils.run_until(self.loop, lambda: reader(data) >= 5, timeout=10)
self.assertEqual(b"12345", data)
self.assertEqual("CONNECTED", proto.state)
os.close(master)
# extra info is available
self.assertIsNotNone(proto.transport.get_extra_info("pipe"))
# close connection
proto.transport.close()
self.loop.run_until_complete(proto.done)
self.assertEqual("CLOSED", proto.state)
def test_write_pty(loop):
master, slave = os.openpty()
os.set_blocking(master, False)
slave_write_obj = io.open(slave, 'wb', 0)
proto = MyWritePipeProto(loop=loop)
connect = loop.connect_write_pipe(lambda: proto, slave_write_obj)
transport, p = loop.run_until_complete(connect)
assert p is proto
assert transport is proto.transport
assert 'CONNECTED' == proto.state
transport.write(b'1')
data = bytearray()
def reader(data):
try:
chunk = os.read(master, 1024)
except BlockingIOError:
return len(data)
data += chunk
return len(data)
test_utils.run_until(loop, lambda: reader(data) >= 1, timeout=10)
assert b'1' == data
transport.write(b'2345')
test_utils.run_until(loop, lambda: reader(data) >= 5, timeout=10)
assert b'12345' == data
assert 'CONNECTED' == proto.state
os.close(master)
# extra info is available
assert proto.transport.get_extra_info('pipe') is not None
# close connection
proto.transport.close()
loop.run_until_complete(proto.done)
assert 'CLOSED' == proto.state
def test_write_pty(self):
master, slave = os.openpty()
slave_write_obj = io.open(slave, 'wb', 0)
proto = MyWritePipeProto(loop=self.loop)
connect = self.loop.connect_write_pipe(lambda: proto, slave_write_obj)
transport, p = self.loop.run_until_complete(connect)
self.assertIs(p, proto)
self.assertIs(transport, proto.transport)
self.assertEqual('CONNECTED', proto.state)
transport.write(b'1')
data = bytearray()
def reader(data):
chunk = os.read(master, 1024)
data += chunk
return len(data)
test_utils.run_until(self.loop, lambda: reader(data) >= 1,
timeout=10)
self.assertEqual(b'1', data)
transport.write(b'2345')
test_utils.run_until(self.loop, lambda: reader(data) >= 5,
timeout=10)
self.assertEqual(b'12345', data)
self.assertEqual('CONNECTED', proto.state)
os.close(master)
# extra info is available
self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
# close connection
proto.transport.close()
self.loop.run_until_complete(proto.done)
self.assertEqual('CLOSED', proto.state)
def test_read_pty_output(loop):
proto = MyReadPipeProto(loop=loop)
master, slave = os.openpty()
master_read_obj = io.open(master, 'rb', 0)
@asyncio.coroutine
def connect():
t, p = yield from loop.connect_read_pipe(lambda: proto,
master_read_obj)
assert p is proto
assert t is proto.transport
assert ['INITIAL', 'CONNECTED'] == proto.state
assert 0 == proto.nbytes
loop.run_until_complete(connect())
os.write(slave, b'1')
test_utils.run_until(loop, lambda: proto.nbytes)
assert 1 == proto.nbytes
os.write(slave, b'2345')
test_utils.run_until(loop, lambda: proto.nbytes >= 5)
assert ['INITIAL', 'CONNECTED'] == proto.state
assert 5 == proto.nbytes
# On Linux, transport raises EIO when slave is closed --
# ignore it.
loop.set_exception_handler(lambda loop, ctx: None)
os.close(slave)
loop.run_until_complete(proto.done)
assert ['INITIAL', 'CONNECTED', 'EOF', 'CLOSED'] == proto.state
# extra info is available
assert proto.transport.get_extra_info('pipe') is not None
def test_read_pty_output(self):
proto = MyReadPipeProto(loop=self.loop)
master, slave = os.openpty()
master_read_obj = io.open(master, 'rb', 0)
@asyncio.coroutine
def connect():
t, p = yield from self.loop.connect_read_pipe(lambda: proto,
master_read_obj)
self.assertIs(p, proto)
self.assertIs(t, proto.transport)
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(0, proto.nbytes)
self.loop.run_until_complete(connect())
os.write(slave, b'1')
test_utils.run_until(self.loop, lambda: proto.nbytes)
self.assertEqual(1, proto.nbytes)
os.write(slave, b'2345')
test_utils.run_until(self.loop, lambda: proto.nbytes >= 5)
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(5, proto.nbytes)
# On Linux, transport raises EIO when slave is closed --
# ignore it.
self.loop.set_exception_handler(lambda loop, ctx: None)
os.close(slave)
self.loop.run_until_complete(proto.done)
self.assertEqual(
['INITIAL', 'CONNECTED', 'EOF', 'CLOSED'], proto.state)
# extra info is available
self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
