tornado.http1connection – HTTP/1.x client/server implementation

Client and server implementations of HTTP/1.x.

New in version 4.0.

class tornado.http1connection.HTTP1ConnectionParameters(no_keep_alive: bool = False, chunk_size: Optional[int] = None, max_header_size: Optional[int] = None, header_timeout: Optional[float] = None, max_body_size: Optional[int] = None, body_timeout: Optional[float] = None, decompress: bool = False)[source]

Parameters for HTTP1Connection and HTTP1ServerConnection.

Parameters

  • no_keep_alive (bool) – If true, always close the connection after one request.

  • chunk_size (int) – how much data to read into memory at once

  • max_header_size (int) – maximum amount of data for HTTP headers

  • header_timeout (float) – how long to wait for all headers (seconds)

  • max_body_size (int) – maximum amount of data for body

  • body_timeout (float) – how long to wait while reading body (seconds)

  • decompress (bool) – if true, decode incoming Content-Encoding: gzip

class tornado.http1connection.HTTP1Connection(stream: IOStream, is_client: bool, params: Optional[HTTP1ConnectionParameters] = None, context: Optional[object] = None)[source]

Implements the HTTP/1.x protocol.

This class can be on its own for clients, or via HTTP1ServerConnection for servers.

Parameters

  • stream – an IOStream

  • is_client (bool) – client or server

  • params – a HTTP1ConnectionParameters instance or None

  • context – an opaque application-defined object that can be accessed as connection.context.

read_response(delegate: HTTPMessageDelegate) → Awaitable[bool][source]

Read a single HTTP response.

Typical client-mode usage is to write a request using write_headers, write, and finish, and then call read_response.

Parameters

delegate – a HTTPMessageDelegate

Returns a Future that resolves to a bool after the full response has been read. The result is true if the stream is still open.

set_close_callback(callback: Optional[Callable[[], None]]) → None[source]

Sets a callback that will be run when the connection is closed.

Note that this callback is slightly different from HTTPMessageDelegate.on_connection_close: The HTTPMessageDelegate method is called when the connection is closed while receiving a message. This callback is used when there is not an active delegate (for example, on the server side this callback is used if the client closes the connection after sending its request but before receiving all the response.

detach() → IOStream[source]

Take control of the underlying stream.

Returns the underlying IOStream object and stops all further HTTP processing. May only be called during HTTPMessageDelegate.headers_received. Intended for implementing protocols like websockets that tunnel over an HTTP handshake.

set_body_timeout(timeout: float) → None[source]

Sets the body timeout for a single request.

Overrides the value from HTTP1ConnectionParameters.

set_max_body_size(max_body_size: int) → None[source]

Sets the body size limit for a single request.

Overrides the value from HTTP1ConnectionParameters.

write_headers(start_line: Union[RequestStartLine, ResponseStartLine], headers: HTTPHeaders, chunk: Optional[bytes] = None) → Future[None][source]

Implements HTTPConnection.write_headers.

write(chunk: bytes) → Future[None][source]

Implements HTTPConnection.write.

For backwards compatibility it is allowed but deprecated to skip write_headers and instead call write() with a pre-encoded header block.

finish() → None[source]

Implements HTTPConnection.finish.

class tornado.http1connection.HTTP1ServerConnection(stream: IOStream, params: Optional[HTTP1ConnectionParameters] = None, context: Optional[object] = None)[source]

An HTTP/1.x server.

Parameters
coroutine close() → None[source]

Closes the connection.

Returns a Future that resolves after the serving loop has exited.

start_serving(delegate: HTTPServerConnectionDelegate) → None[source]

Starts serving requests on this connection.

Parameters

delegate – a HTTPServerConnectionDelegate