Initial HTTP/1.1 work

Lukasa · Lukasa · commit e7852f309633 · 2015-03-07T18:01:33.000Z
diff --git a/.coveragerc b/.coveragerc
@@ -4,3 +4,4 @@ omit =
     hyper/httplib_compat.py
     hyper/ssl_compat.py
     hyper/http20/hpack_compat.py
+    hyper/http11/*
diff --git a/hyper/http11/__init__.py b/hyper/http11/__init__.py
@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+"""
+hyper/http11
+~~~~~~~~~~~~
+
+The HTTP/1.1 submodule that powers hyper.
+"""
diff --git a/hyper/http11/connection.py b/hyper/http11/connection.py
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+"""
+hyper/http11/connection
+~~~~~~~~~~~~~~~~~~~~~~~
+
+Objects that build hyper's connection-level HTTP/1.1 abstraction.
+"""
+import io
+import logging
+import socket
+
+from .response import HTTP11Response
+from ..http20.bufsocket import BufferedSocket
+
+log = logging.getLogger(__name__)
+
+
+class HTTP11Connection(object):
+    """
+    An object representing a single HTTP/1.1 connection to a server.
+
+    :param host: The host to connect to. This may be an IP address or a
+        hostname, and optionally may include a port: for example,
+        ``'twitter.com'``, ``'twitter.com:443'`` or ``'127.0.0.1'``.
+    :param port: (optional) The port to connect to. If not provided and one also
+        isn't provided in the ``host`` parameter, defaults to 443.
+    """
+    def __init__(self, host, port):
+        if port is None:
+            try:
+                self.host, self.port = host.split(':')
+                self.port = int(self.port)
+            except ValueError:
+                self.host, self.port = host, 443
+        else:
+            self.host, self.port = host, port
+
+        self._sock = None
+
+        #: The size of the in-memory buffer used to store data from the
+        #: network. This is used as a performance optimisation. Increase buffer
+        #: size to improve performance: decrease it to conserve memory.
+        #: Defaults to 64kB.
+        self.network_buffer_size = 65536
+
+    def connect(self):
+        """
+        Connect to the server specified when the object was created. This is a
+        no-op if we're already connected.
+
+        :returns: Nothing.
+        """
+        if self._sock is None:
+            sock = socket.create_connection((self.host, self.port), 5)
+            self._sock = BufferedSocket(sock, self.network_buffer_size)
+
+        return
+
+    def request(self, method, url, body=None, headers={}):
+        """
+        This will send a request to the server using the HTTP request method
+        ``method`` and the selector ``url``. If the ``body`` argument is
+        present, it should be string or bytes object of data to send after the
+        headers are finished. Strings are encoded as UTF-8. To use other
+        encodings, pass a bytes object. The Content-Length header is set to the
+        length of the body field.
+
+        :param method: The request method, e.g. ``'GET'``.
+        :param url: The URL to contact, e.g. ``'/path/segment'``.
+        :param body: (optional) The request body to send. Must be a bytestring
+            or a file-like object.
+        :param headers: (optional) The headers to send on the request.
+        :returns: Nothing.
+        """
+        if self._sock is None:
+            self.connect()
+
+        # In this initial implementation, let's just write straight to the
+        # socket. We'll fix this up as we go.
+        # TODO: Fix fix fix.
+        self._sock.send(b' '.join([method, url, b'HTTP/1.1\r\n']))
+
+        for name, value in headers.items():
+            self._sock.send(name)
+            self._sock.send(b': ')
+            self._sock.send(value)
+            self._sock.send(b'\r\n')
+
+        self._sock.send(b'\r\n')
+
+        if body:
+            # TODO: Come back here to support non-string bodies.
+            self._sock.send(body)
+
+        return
+
+    def get_response(self):
+        """
+        Returns a response object.
+
+        This is an early beta, so the response object is pretty stupid. That's
+        ok, we'll fix it later.
+        """
+        headers = {}
+
+        # First read the header line and drop it on the floor.
+        self._sock.readline()
+
+        while True:
+            line = self._sock.readline().tobytes()
+            if len(line) <= 2:
+                break
+
+            name, val = line.split(b':', 1)
+            val = val.lstrip().rstrip(b'\r\n')
+            headers[name] = val
+
+        return HTTP11Response(headers, self._sock)
diff --git a/hyper/http11/response.py b/hyper/http11/response.py
@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+"""
+hyper/http20/response
+~~~~~~~~~~~~~~~~~~~~~
+
+Contains the HTTP/2 equivalent of the HTTPResponse object defined in
+httplib/http.client.
+"""
+import logging
+
+log = logging.getLogger(__name__)
+
+
+class DeflateDecoder(object):
+    """
+    This is a decoding object that wraps ``zlib`` and is used for decoding
+    deflated content.
+
+    This rationale for the existence of this object is pretty unpleasant.
+    The HTTP RFC specifies that 'deflate' is a valid content encoding. However,
+    the spec _meant_ the zlib encoding form. Unfortunately, people who didn't
+    read the RFC very carefully actually implemented a different form of
+    'deflate'. Insanely, ``zlib`` handles them using two wbits values. This is
+    such a mess it's hard to adequately articulate.
+
+    This class was lovingly borrowed from the excellent urllib3 library under
+    license: see NOTICES. If you ever see @shazow, you should probably buy him
+    a drink or something.
+    """
+    def __init__(self):
+        self._first_try = True
+        self._data = b''
+        self._obj = zlib.decompressobj(zlib.MAX_WBITS)
+
+    def __getattr__(self, name):
+        return getattr(self._obj, name)
+
+    def decompress(self, data):
+        if not self._first_try:
+            return self._obj.decompress(data)
+
+        self._data += data
+        try:
+            return self._obj.decompress(data)
+        except zlib.error:
+            self._first_try = False
+            self._obj = zlib.decompressobj(-zlib.MAX_WBITS)
+            try:
+                return self.decompress(self._data)
+            finally:
+                self._data = None
+
+
+class HTTP11Response(object):
+    """
+    An ``HTTP11Response`` wraps the HTTP/1.1 response from the server. It
+    provides access to the response headers and the entity body. The response
+    is an iterable object and can be used in a with statement.
+    """
+    def __init__(self, headers, sock):
+        #: The reason phrase returned by the server.
+        self.reason = ''
+
+        #: The status code returned by the server.
+        self.status = 0
+
+        # The response headers. These are determined upon creation, assigned
+        # once, and never assigned again.
+        self._headers = headers
+
+        # The response trailers. These are always intially ``None``.
+        self._trailers = None
+
+        # The socket this response is being sent over.
+        self._sock = sock
+
+        # We always read in one-data-frame increments from the stream, so we
+        # may need to buffer some for incomplete reads.
+        self._data_buffer = b''
+
+    def read(self, amt=None, decode_content=True):
+        """
+        Reads the response body, or up to the next ``amt`` bytes.
+
+        :param amt: (optional) The amount of data to read. If not provided, all
+            the data will be read from the response.
+        :param decode_content: (optional) If ``True``, will transparently
+            decode the response data.
+        :returns: The read data. Note that if ``decode_content`` is set to
+            ``True``, the actual amount of data returned may be different to
+            the amount requested.
+        """
+        # For now, just read what we're asked, unless we're not asked:
+        # then, read content-length. This obviously doesn't work longer term,
+        # we need to do some content-length processing there.
+        if amt is None:
+            amt = self.headers.get(b'content-length', 0)
+
+        # Return early if we've lost our connection.
+        if self._sock is None:
+            return b''
+
+        data = self._sock.read(amt)
+
+        # We may need to decode the body.
+        if decode_content and self._decompressobj and data:
+            data = self._decompressobj.decompress(data)
+
+        # If we're at the end of the request, we have some cleaning up to do.
+        # Close the stream, and if necessary flush the buffer.
+        if decode_content and self._decompressobj:
+            data += self._decompressobj.flush()
+
+        # We're at the end. Close the connection.
+        if not data:
+            self.close()
+
+        return data
+
+    def fileno(self):
+        """
+        Return the ``fileno`` of the underlying socket. This function is
+        currently not implemented.
+        """
+        raise NotImplementedError("Not currently implemented.")
+
+    def close(self):
+        """
+        Close the response. In effect this closes the backing HTTP/2 stream.
+
+        :returns: Nothing.
+        """
+        self._sock = None
+
+    # The following methods implement the context manager protocol.
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+        return False  # Never swallow exceptions.
