18.5.5. Streams (coroutine based API)

注解

The top-level functions in this module are meant as convenience wrappers only; there’s really nothing special there, and if they don’t do exactly what you want, feel free to copy their code.

coroutine (host=None, port=None, , loop=None, limit=None, kwds*)

A wrapper for create_connection() returning a (reader, writer) pair.

The reader returned is a instance; the writer is a StreamWriter instance.

The arguments are all the usual arguments to except protocol_factory; most common are positional host and port, with various optional keyword arguments following.

Additional optional keyword arguments are loop (to set the event loop instance to use) and limit (to set the buffer limit passed to the StreamReader).

This function is a .

coroutine asyncio.start_server(client_connected_cb, host=None, port=None, , loop=None, limit=None, kwds*)

Start a socket server, with a callback for each client connected. The return value is the same as create_server().

The client_connected_cb parameter is called with two parameters: client_reader, client_writer. client_reader is a object, while client_writer is a StreamWriter object. The client_connected_cb parameter can either be a plain callback function or a ; if it is a coroutine function, it will be automatically converted into a Task.

The rest of the arguments are all the usual arguments to except protocol_factory; most common are positional host and port, with various optional keyword arguments following.

Additional optional keyword arguments are loop (to set the event loop instance to use) and limit (to set the buffer limit passed to the StreamReader).

This function is a .

coroutine asyncio.open_unix_connection(path=None, , loop=None, limit=None, kwds*)

A wrapper for create_unix_connection() returning a (reader, writer) pair.

See for information about return value and other details.

This function is a coroutine.

Availability: UNIX.

coroutine asyncio.start_unix_server(client_connected_cb, path=None, , loop=None, limit=None, kwds*)

Start a UNIX Domain Socket server, with a callback for each client connected.

See for information about return value and other details.

This function is a coroutine.

Availability: UNIX.

18.5.5.2. StreamReader

class asyncio.StreamReader(limit=_DEFAULT_LIMIT, loop=None)

This class is not thread safe.

The limit argument’s default value is set to _DEFAULT_LIMIT which is 2**16 (64 KiB)

• exception()

  Get the exception.

• feed_eof()

  Acknowledge the EOF.

• feed_data(data)

  Feed data bytes in the internal buffer. Any operations waiting for the data will be resumed.

• set_exception(exc)

  Set the exception.

• Set the transport.

• coroutine read(n=-1)

  读取 n 个byte. 如果没有设置 n , 则自动置为 -1 ，读至 EOF 并返回所有读取的byte。

  If the EOF was received and the internal buffer is empty, return an empty bytes object.

  This method is a .

• coroutine readline()

  读取一行，其中“行”指的是以 \n 结尾的字节序列。

  If EOF is received, and \n was not found, the method will return the partial read bytes.

  If the EOF was received and the internal buffer is empty, return an empty bytes object.

  This method is a coroutine.

• coroutine readexactly(n)

  Read exactly n bytes. Raise an if the end of the stream is reached before n can be read, the IncompleteReadError.partial attribute of the exception contains the partial read bytes.

  This method is a .

• coroutine readuntil(separator=b’\n’)

  Read data from the stream until separator is found.

  成功后，数据和指定的separator将从内部缓冲区中删除(或者说被消费掉)。返回的数据将包括在末尾的指定separator。

  Configured stream limit is used to check result. Limit sets the maximal length of data that can be returned, not counting the separator.

  If an EOF occurs and the complete separator is still not found, an IncompleteReadError exception will be raised, and the internal buffer will be reset. The attribute may contain the separator partially.

  If the data cannot be read because of over limit, a LimitOverrunError exception will be raised, and the data will be left in the internal buffer, so it can be read again.

  3.5.2 新版功能.

• at_eof()

  如果缓冲区为空并且 被调用，则返回 True 。

class asyncio.StreamWriter(transport, protocol, reader, loop)

Wraps a Transport.

This exposes write(), , can_write_eof(), , get_extra_info() and . It adds drain() which returns an optional on which you can wait for flow control. It also adds a transport attribute which references the Transport directly.

This class is not thread safe.

• transport

  Transport.

• can_write_eof()

  Return if the transport supports write_eof(), if not. See WriteTransport.can_write_eof().

• close()

  Close the transport: see .

• coroutine drain()

  Let the write buffer of the underlying transport a chance to be flushed.

  The intended use is to write:

  Yielding from drain() gives the opportunity for the loop to schedule the write operation and flush the buffer. It should especially be used when a possibly large amount of data is written to the transport, and the coroutine does not yield-from between calls to .

  This method is a coroutine.

• get_extra_info(name, default=None)

  Return optional transport information: see .

• write(data)

  Write some data bytes to the transport: see WriteTransport.write().

• write_eof()

  Close the write end of the transport after flushing buffered data: see .

18.5.5.4. StreamReaderProtocol

class asyncio.StreamReaderProtocol(stream_reader, client_connected_cb=None, loop=None)

Trivial helper class to adapt between and StreamReader. Subclass of .

stream_reader is a StreamReader instance, client_connected_cb is an optional function called with (stream_reader, stream_writer) when a connection is made, loop is the event loop instance to use.

(This is a helper class instead of making itself a Protocol subclass, because the has other potential uses, and to prevent the user of the StreamReader from accidentally calling inappropriate methods of the protocol.)

exception asyncio.IncompleteReadError

• expected

  Total number of expected bytes ().

• partial

  Read bytes string before the end of stream was reached (bytes).

18.5.5.6. LimitOverrunError

exception asyncio.LimitOverrunError

Reached the buffer limit while looking for a separator.

• consumed

  Total number of to be consumed bytes.

使用 asyncio.open_connection() 函数的 TCP 回显客户端:

import asyncio
@asyncio.coroutine
def tcp_echo_client(message, loop):
    reader, writer = yield from asyncio.open_connection('127.0.0.1', 8888,
                                                        loop=loop)
    print('Send: %r' % message)
    writer.write(message.encode())
    data = yield from reader.read(100)
    print('Received: %r' % data.decode())
    print('Close the socket')
    writer.close()
message = 'Hello World!'
loop = asyncio.get_event_loop()
loop.run_until_complete(tcp_echo_client(message, loop))
loop.close()

参见

The example uses the AbstractEventLoop.create_connection() method.

TCP 回显服务器使用 函数:

参见

The TCP echo server protocol example uses the method.

查询命令行传入 URL 的 HTTP 标头的简单示例:

import asyncio
import urllib.parse
@asyncio.coroutine
def print_http_headers(url):
    url = urllib.parse.urlsplit(url)
    if url.scheme == 'https':
        connect = asyncio.open_connection(url.hostname, 443, ssl=True)
    else:
        connect = asyncio.open_connection(url.hostname, 80)
    reader, writer = yield from connect
    query = ('HEAD {path} HTTP/1.0\r\n'
             'Host: {hostname}\r\n'
             '\r\n').format(path=url.path or '/', hostname=url.hostname)
    writer.write(query.encode('latin-1'))
    while True:
        line = yield from reader.readline()
        if not line:
            break
        line = line.decode('latin1').rstrip()
        if line:
            print('HTTP header> %s' % line)
    # Ignore the body, close the socket
    writer.close()
url = sys.argv[1]
loop = asyncio.get_event_loop()
task = asyncio.ensure_future(print_http_headers(url))
loop.run_until_complete(task)

用法:

或使用 HTTPS:

使用 open_connection() 函数实现等待直到套接字接收到数据的协程:

参见

The example uses the low-level AbstractEventLoop.add_reader() method to register the file descriptor of a socket.