# `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=False, chunk_size=None, max_header_size=None, header_timeout=None, max_body_size=None, body_timeout=None, decompress=False)

  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, is_client, params=None, context=None)

  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)

    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 None after the full response has been read.

  `set_close_callback`(callback)

    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 recieving 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`()

    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)

    Sets the body timeout for a single request.

    Overrides the value from `HTTP1ConnectionParameters`.

  `set_max_body_size`(max_body_size)

    Sets the body size limit for a single request.

    Overrides the value from `HTTP1ConnectionParameters`.

  `write_headers`(start_line, headers, chunk=None, callback=None)

    Implements `HTTPConnection.write_headers`.

  `write`(chunk, callback=None)

    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`()

    Implements `HTTPConnection.finish`.

class `tornado.http1connection.``HTTP1ServerConnection`(stream, params=None, context=None)

  An HTTP/1.x server.

  Parameters:

  - stream – an `IOStream`
  - params – a `HTTP1ConnectionParameters` or None
  - context – an opaque application-defined object that is accessible as `connection.context`

  `close`()

    Closes the connection.

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

  `start_serving`(delegate)

    Starts serving requests on this connection.

    Parameters: | delegate – a `HTTPServerConnectionDelegate`