Use HTTPHeaderMap in H2 as well as H1.

Author: Lukasa

hyper/contrib.py

@@ -80,7 +80,7 @@ def build_response(self, request, resp):
         response = Response()
 
         response.status_code = resp.status
-        response.headers = CaseInsensitiveDict(resp.getheaders())
+        response.headers = CaseInsensitiveDict(resp.headers.iter_raw())
         response.raw = resp
         response.reason = resp.reason
         response.encoding = get_encoding_from_headers(response.headers)
@@ -136,6 +136,6 @@ def getheaders(self, name):
         orig.version = 20
         orig.status = resp.status
         orig.reason = resp.reason
-        orig.msg = FakeOriginalResponse(resp.getheaders())
+        orig.msg = FakeOriginalResponse(resp.headers.iter_raw())
 
         return response

hyper/http20/connection.py

@@ -8,6 +8,7 @@
 from ..tls import wrap_socket, H2_NPN_PROTOCOLS
 from ..common.exceptions import ConnectionResetError
 from ..common.bufsocket import BufferedSocket
+from ..common.headers import HTTPHeaderMap
 from .hpack_compat import Encoder, Decoder
 from .stream import Stream
 from .frame import (
@@ -191,7 +192,9 @@ def getpushes(self, stream_id=None, capture_all=False):
         """
         stream = self._get_stream(stream_id)
         for promised_stream_id, headers in stream.getpushes(capture_all):
-            yield HTTP20Push(headers, self.streams[promised_stream_id])
+            yield HTTP20Push(
+                HTTPHeaderMap(headers), self.streams[promised_stream_id]
+            )
 
     def connect(self):
         """

hyper/http20/response.py

@@ -10,44 +10,22 @@
 import zlib
 
 from ..common.decoder import DeflateDecoder
-from .util import pop_from_key_value_set
+from ..common.headers import HTTPHeaderMap
 
 log = logging.getLogger(__name__)
 
 
-class Headers(object):
-    def __init__(self, pairs):
-        # This conversion to dictionary is unwise, as there may be repeated
-        # keys, but it's acceptable for an early alpha.
-        self._headers = dict(pairs)
-        self._strip_headers()
-
-    def getheader(self, name, default=None):
-        return self._headers.get(name, default)
-
-    def getheaders(self):
-        return list(self._headers.items())
-
-    def items(self):
-        return self._headers.items()
-
-    def merge(self, headers):
-        for n, v in headers:
-            self._headers[n] = v
-        self._strip_headers()
-
-    def _strip_headers(self):
-        """
-        Strips the headers attached to the instance of any header beginning
-        with a colon that ``hyper`` doesn't understand. This method logs at
-        warning level about the deleted headers, for discoverability.
-        """
-        # Convert to list to ensure that we don't mutate the headers while
-        # we iterate over them.
-        for name in list(self._headers.keys()):
-            if name.startswith(':'):
-                val = self._headers.pop(name)
-                log.warning("Unknown reserved header: %s: %s", name, val)
+def strip_headers(headers):
+    """
+    Strips the headers attached to the instance of any header beginning
+    with a colon that ``hyper`` doesn't understand. This method logs at
+    warning level about the deleted headers, for discoverability.
+    """
+    # Convert to list to ensure that we don't mutate the headers while
+    # we iterate over them.
+    for name in list(headers.keys()):
+        if name.startswith(b':'):
+            del headers[name]
 
 
 class HTTP20Response(object):
@@ -63,14 +41,15 @@ def __init__(self, headers, stream):
         #: HTTP/2, and so is always the empty string.
         self.reason = ''
 
-        status = pop_from_key_value_set(headers, ':status')[0]
+        status = headers[b':status'][0]
+        strip_headers(headers)
 
         #: The status code returned by the server.
         self.status = int(status)
 
-        # The response headers. These are determined upon creation, assigned
-        # once, and never assigned again.
-        self._headers = Headers(headers)
+        #: 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
@@ -88,13 +67,29 @@ def __init__(self, headers, stream):
         # This 16 + MAX_WBITS nonsense is to force gzip. See this
         # Stack Overflow answer for more:
         # http://stackoverflow.com/a/2695466/1401686
-        if self._headers.getheader('content-encoding') == 'gzip':
+        if b'gzip' in self.headers.get(b'content-encoding', []):
             self._decompressobj = zlib.decompressobj(16 + zlib.MAX_WBITS)
-        elif self._headers.getheader('content-encoding') == 'deflate':
+        elif b'deflate' in self.headers.get(b'content-encoding', []):
             self._decompressobj = DeflateDecoder()
         else:
             self._decompressobj = None
 
+    @property
+    def trailers(self):
+        """
+        Trailers on the HTTP message, if any.
+
+        .. warning:: Note that this property requires that the stream is
+                     totally exhausted. This means that, if you have not
+                     completely read from the stream, all stream data will be
+                     read into memory.
+        """
+        if self._trailers is None:
+            self._trailers = self._stream.gettrailers() or HTTPHeaderMap()
+            strip_headers(self._trailers)
+
+        return self._trailers
+
     def read(self, amt=None, decode_content=True):
         """
         Reads the response body, or up to the next ``amt`` bytes.
@@ -132,78 +127,14 @@ def read(self, amt=None, decode_content=True):
                 data += self._decompressobj.flush()
 
             if self._stream.response_headers:
-                self._headers.merge(self._stream.response_headers)
+                self.headers.merge(self._stream.response_headers)
 
         # We're at the end. Close the connection.
         if not data:
             self.close()
 
         return data
 
-    def getheader(self, name, default=None):
-        """
-        Return the value of the header ``name``, or ``default`` if there is no
-        header matching ``name``. If there is more than one header with the
-        value ``name``, return all of the values joined by ', '. If ``default``
-        is any iterable other than a single string, its elements are similarly
-        returned joined by commas.
-
-        :param name: The name of the header to get the value of.
-        :param default: (optional) The return value if the header wasn't sent.
-        :returns: The value of the header.
-        """
-        return self._headers.getheader(name, default)
-
-    def getheaders(self):
-        """
-        Get all the headers sent on the response.
-
-        :returns: A list of ``(header, value)`` tuples.
-        """
-        return list(self._headers.items())
-
-    def gettrailer(self, name, default=None):
-        """
-        Return the value of the trailer ``name``, or ``default`` if there is no
-        trailer matching ``name``. If there is more than one trailer with the
-        value ``name``, return all of the values joined by ', '. If ``default``
-        is any iterable other than a single string, its elements are similarly
-        returned joined by commas.
-
-        .. warning:: Note that this method requires that the stream is
-                     totally exhausted. This means that, if you have not
-                     completely read from the stream, all stream data will be
-                     read into memory.
-
-        :param name: The name of the trailer to get the value of.
-        :param default: (optional) The return value if the trailer wasn't sent.
-        :returns: The value of the trailer.
-        """
-        # We need to get the trailers.
-        if self._trailers is None:
-            trailers = self._stream.gettrailers() or []
-            self._trailers = Headers(trailers)
-
-        return self._trailers.getheader(name, default)
-
-    def gettrailers(self):
-        """
-        Get all the trailers sent on the response.
-
-        .. warning:: Note that this method requires that the stream is
-                     totally exhausted. This means that, if you have not
-                     completely read from the stream, all stream data will be
-                     read into memory.
-
-        :returns: A list of ``(header, value)`` tuples.
-        """
-        # We need to get the trailers.
-        if self._trailers is None:
-            trailers = self._stream.gettrailers() or []
-            self._trailers = Headers(trailers)
-
-        return list(self._trailers.items())
-
     def fileno(self):
         """
         Return the ``fileno`` of the underlying socket. This function is
@@ -234,43 +165,21 @@ class HTTP20Push(object):
     push mechanism.
     """
     def __init__(self, request_headers, stream):
-        scheme, method, authority, path = (
-            pop_from_key_value_set(request_headers,
-                                   ':scheme', ':method', ':authority', ':path')
-        )
         #: The scheme of the simulated request
-        self.scheme = scheme
+        self.scheme = request_headers[b':scheme'][0]
         #: The method of the simulated request (must be safe and cacheable, e.g. GET)
-        self.method = method
+        self.method = request_headers[b':method'][0]
         #: The authority of the simulated request (usually host:port)
-        self.authority = authority
+        self.authority = request_headers[b':authority'][0]
         #: The path of the simulated request
-        self.path = path
+        self.path = request_headers[b':path'][0]
 
-        self._request_headers = Headers(request_headers)
-        self._stream = stream
+        strip_headers(request_headers)
 
-    def getrequestheader(self, name, default=None):
-        """
-        Return the value of the simulated request header ``name``, or ``default``
-        if there is no header matching ``name``. If there is more than one header
-        with the value ``name``, return all of the values joined by ``', '``.
-        If ``default`` is any iterable other than a single string, its elements
-        are similarly returned joined by commas.
-
-        :param name: The name of the header to get the value of.
-        :param default: (optional) The return value if the header wasn't sent.
-        :returns: The value of the header.
-        """
-        return self._request_headers.getheader(name, default)
-
-    def getrequestheaders(self):
-        """
-        Get all the simulated request headers.
+        #: The headers the server attached to the simulated request.
+        self.request_headers = request_headers
 
-        :returns: A list of ``(header, value)`` tuples.
-        """
-        return self._request_headers.getheaders()
+        self._stream = stream
 
     def getresponse(self):
         """

hyper/http20/stream.py

@@ -13,12 +13,13 @@
 Each stream is identified by a monotonically increasing integer, assigned to
 the stream by the endpoint that initiated the stream.
 """
+from ..common.headers import HTTPHeaderMap
 from .exceptions import ProtocolError
 from .frame import (
     FRAME_MAX_LEN, FRAMES, HeadersFrame, DataFrame, PushPromiseFrame,
     WindowUpdateFrame, ContinuationFrame, BlockedFrame
 )
-from .util import get_from_key_value_set, h2_safe_headers
+from .util import h2_safe_headers
 import collections
 import logging
 import zlib
@@ -296,7 +297,7 @@ def getheaders(self):
 
         # Find the Content-Length header if present.
         self._in_window_manager.document_size = (
-            int(get_from_key_value_set(self.response_headers, 'content-length', 0))
+            int(self.response_headers.get(b'content-length', [0])[0])
         )
 
         return self.response_headers
@@ -379,9 +380,9 @@ def _handle_header_block(self, headers):
         # The header block may be for trailers or headers. If we've already
         # received headers these _must_ be for trailers.
         if self.response_headers is None:
-            self.response_headers = headers
+            self.response_headers = HTTPHeaderMap(headers)
         elif self.response_trailers is None:
-            self.response_trailers = headers
+            self.response_trailers = HTTPHeaderMap(headers)
         else:
             # Received too many headers blocks.
             raise ProtocolError("Too many header blocks.")

hyper/http20/util.py

@@ -8,40 +8,6 @@
 from collections import defaultdict
 
 
-def get_from_key_value_set(kvset, key, default=None):
-    """
-    Returns a value from a key-value set, or the default if the value isn't
-    present.
-    """
-    value = pop_from_key_value_set(kvset[:], key)[0]
-    return value if value is not None else default
-
-def pop_from_key_value_set(kvset, *keys):
-    """
-    Pops the values of ``keys`` from ``kvset`` and returns them as a tuple. If a
-    key is not found in ``kvset``, ``None`` is used instead.
-
-    >>> kvset = [('a',0), ('b',1), ('c',2)]
-    >>> pop_from_key_value_set(kvset, 'a', 'foo', 'c')
-    (0, None, 2)
-    >>> kvset
-    [('b', 1)]
-    """
-    extracted = [None] * len(keys)
-    indices_to_remove = []
-    for index, elem in enumerate(kvset):
-        key, value = elem
-        try:
-            extracted[keys.index(key)] = value
-            indices_to_remove.append(index)
-        except ValueError:
-            pass
-
-    for index in indices_to_remove[::-1]:
-        kvset.pop(index)
-
-    return tuple(extracted)
-
 def combine_repeated_headers(kvset):
     """
     Given a list of key-value pairs (like for HTTP headers!), combines pairs