Review markups for @Lukasa

Author: alexwlchan

h2/config.py

@@ -32,19 +32,19 @@ class H2Configuration(object):
         ``False`` or the empty string.
     :type header_encoding: ``str``, ``False``, or ``None``
 
-    :param validate_sent_headers: Controls whether the headers emitted
+    :param validate_outbound_headers: Controls whether the headers emitted
         by this object are validated against the rules in RFC 7540.
         Disabling this setting will cause outbound header validation to
         be skipped, and allow the object to emit headers that may be illegal
         according to RFC 7540. Defaults to ``True``.
-    :type validate_sent_headers: ``bool``
+    :type validate_outbound_headers: ``bool``
 
-    :param normalize_sent_headers: Controls whether the headers emitted
+    :param normalize_outbound_headers: Controls whether the headers emitted
         by this object are normalized before sending.  Disabling this setting
         will cause outbound header normalization to be skipped, and allow
         the object to emit headers that may be illegal according to
         RFC 7540. Defaults to ``True``.
-    :type normalize_sent_headers: ``bool``
+    :type normalize_outbound_headers: ``bool``
 
     :param validate_inbound_headers: Controls whether the headers received
         by this object are validated against the rules in RFC 7540.
@@ -56,13 +56,13 @@ class H2Configuration(object):
     def __init__(self,
                  client_side=True,
                  header_encoding='utf-8',
-                 validate_sent_headers=True,
-                 normalize_sent_headers=True,
+                 validate_outbound_headers=True,
+                 normalize_outbound_headers=True,
                  validate_inbound_headers=True):
         self._client_side = client_side
         self._header_encoding = header_encoding
-        self._validate_sent_headers = validate_sent_headers
-        self._normalize_sent_headers = normalize_sent_headers
+        self._validate_outbound_headers = validate_outbound_headers
+        self._normalize_outbound_headers = normalize_outbound_headers
         self._validate_inbound_headers = validate_inbound_headers
 
     @property
@@ -108,42 +108,42 @@ def header_encoding(self, value):
         self._header_encoding = value
 
     @property
-    def validate_sent_headers(self):
+    def validate_outbound_headers(self):
         """
         Whether the headers emitted by this object are validated against
         the rules in RFC 7540. Disabling this setting will cause outbound
         header validation to be skipped, and allow the object to emit headers
         that may be illegal according to RFC 7540. Defaults to ``True``.
         """
-        return self._validate_sent_headers
+        return self._validate_outbound_headers
 
-    @validate_sent_headers.setter
-    def validate_sent_headers(self, value):
+    @validate_outbound_headers.setter
+    def validate_outbound_headers(self, value):
         """
         Enforces validation of outbound headers.
         """
         if not isinstance(value, bool):
-            raise ValueError("validate_sent_headers must be a bool")
-        self._validate_sent_headers = value
+            raise ValueError("validate_outbound_headers must be a bool")
+        self._validate_outbound_headers = value
 
     @property
-    def normalize_sent_headers(self):
+    def normalize_outbound_headers(self):
         """
         Whether the headers emitted by this object are normalized before
         sending.  Disabling this setting will cause outbound header
         normalization to be skipped, and allow the object to emit headers
         that may be illegal according to RFC 7540. Defaults to ``True``.
         """
-        return self._normalize_sent_headers
+        return self._normalize_outbound_headers
 
-    @normalize_sent_headers.setter
-    def normalize_sent_headers(self, value):
+    @normalize_outbound_headers.setter
+    def normalize_outbound_headers(self, value):
         """
         Enforces normalization of outbound headers.
         """
         if not isinstance(value, bool):
-            raise ValueError("normalize_sent_headers must be a bool")
-        self._normalize_sent_headers = value
+            raise ValueError("normalize_outbound_headers must be a bool")
+        self._normalize_outbound_headers = value
 
     @property
     def validate_inbound_headers(self):

h2/connection.py

@@ -505,14 +505,13 @@ def _begin_new_stream(self, stream_id, allowed_ids):
                 "Invalid stream ID for peer."
             )
 
-        s = H2Stream(stream_id)
+        s = H2Stream(stream_id, config=self.config)
         s.max_inbound_frame_size = self.max_inbound_frame_size
         s.max_outbound_frame_size = self.max_outbound_frame_size
         s.outbound_flow_control_window = (
             self.remote_settings.initial_window_size
         )
         s.inbound_flow_control_window = self.local_settings.initial_window_size
-        s.config = self.config
 
         self.streams[stream_id] = s
 

h2/stream.py

@@ -14,7 +14,6 @@
     RstStreamFrame, PushPromiseFrame, AltSvcFrame
 )
 
-from .config import H2Configuration
 from .errors import STREAM_CLOSED
 from .events import (
     RequestReceived, ResponseReceived, DataReceived, WindowUpdated,
@@ -27,7 +26,7 @@
 )
 from .utilities import (
     guard_increment_window, is_informational_response, authority_from_headers,
-    validate_headers, validate_sent_headers, normalize_sent_headers,
+    validate_headers, validate_outbound_headers, normalize_outbound_headers,
     HeaderValidationFlags, extract_method_header
 )
 
@@ -672,7 +671,7 @@ class H2Stream(object):
     Attempts to create frames that cannot be sent will raise a
     ``ProtocolError``.
     """
-    def __init__(self, stream_id):
+    def __init__(self, stream_id, config):
         self.state_machine = H2StreamStateMachine(stream_id)
         self.stream_id = stream_id
         self.max_outbound_frame_size = None
@@ -692,7 +691,7 @@ def __init__(self, stream_id):
         self._authority = None
 
         # The configuration for this stream.
-        self.config = H2Configuration()
+        self.config = config
 
     @property
     def open(self):
@@ -769,7 +768,8 @@ def send_headers(self, headers, encoder, end_stream=False):
         hf = HeadersFrame(self.stream_id)
         hdr_validation_flags = self._build_hdr_validation_flags(events)
         frames = self._build_headers_frames(
-            headers, encoder, hf, hdr_validation_flags)
+            headers, encoder, hf, hdr_validation_flags
+        )
 
         if end_stream:
             # Not a bug: the END_STREAM flag is valid on the initial HEADERS
@@ -807,7 +807,8 @@ def push_stream_in_band(self, related_stream_id, headers, encoder):
         ppf.promised_stream_id = related_stream_id
         hdr_validation_flags = self._build_hdr_validation_flags(events)
         frames = self._build_headers_frames(
-            headers, encoder, ppf, hdr_validation_flags)
+            headers, encoder, ppf, hdr_validation_flags
+        )
 
         return frames
 
@@ -931,10 +932,7 @@ def receive_headers(self, headers, end_stream, header_encoding):
                 raise ProtocolError("Trailers must have END_STREAM set")
 
         if self.config.validate_inbound_headers:
-            hdr_validation_flags = HeaderValidationFlags(
-                is_client=self.state_machine.client,
-                is_trailer=isinstance(events[0], TrailersReceived)
-            )
+            hdr_validation_flags = self._build_hdr_validation_flags(events)
             headers = validate_headers(headers, hdr_validation_flags)
 
         if header_encoding:
@@ -1039,7 +1037,9 @@ def _build_hdr_validation_flags(self, events):
         and validating header blocks.
         """
         try:
-            is_trailer = isinstance(events[0], _TrailersSent)
+            is_trailer = isinstance(
+                events[0], (_TrailersSent, TrailersReceived)
+            )
         except IndexError:
             is_trailer = False
 
@@ -1058,10 +1058,14 @@ def _build_headers_frames(self,
         """
         # We need to lowercase the header names, and to ensure that secure
         # header fields are kept out of compression contexts.
-        if self.config.normalize_sent_headers:
-            headers = normalize_sent_headers(headers, hdr_validation_flags)
-        if self.config.validate_sent_headers:
-            headers = validate_sent_headers(headers, hdr_validation_flags)
+        if self.config.normalize_outbound_headers:
+            headers = normalize_outbound_headers(
+                headers, hdr_validation_flags
+            )
+        if self.config.validate_outbound_headers:
+            headers = validate_outbound_headers(
+                headers, hdr_validation_flags
+            )
 
         encoded_headers = encoder.encode(headers)
 

h2/utilities.py

@@ -317,14 +317,14 @@ def _validate_host_authority_header(headers):
     # an :authority header nor a Host header.
     if not authority_present and not host_present:
         raise ProtocolError(
-            "Request header block must have an :authority or Host header."
+            "Request header block does not have an :authority or Host header."
         )
 
     # If we receive both headers, they should definitely match.
     if authority_present and host_present:
         if authority_header_val != host_header_val:
             raise ProtocolError(
-                "Request header block must have matching :authority and "
+                "Request header block has mismatched :authority and "
                 "Host headers: %r / %r"
                 % (authority_header_val, host_header_val)
             )
@@ -373,7 +373,7 @@ def _check_sent_host_authority_header(headers, hdr_validation_flags):
     return _validate_host_authority_header(headers)
 
 
-def normalize_sent_headers(headers, hdr_validation_flags):
+def normalize_outbound_headers(headers, hdr_validation_flags):
     """
     Normalizes a header sequence that we are about to send.
 
@@ -386,7 +386,7 @@ def normalize_sent_headers(headers, hdr_validation_flags):
     return headers
 
 
-def validate_sent_headers(headers, hdr_validation_flags):
+def validate_outbound_headers(headers, hdr_validation_flags):
     """
     Validates and normalizes a header sequence that we are about to send.
 

test/test_config.py

@@ -24,8 +24,8 @@ def test_defaults(self):
 
     boolean_config_options = [
         'client_side',
-        'validate_sent_headers',
-        'normalize_sent_headers',
+        'validate_outbound_headers',
+        'normalize_outbound_headers',
         'validate_inbound_headers'
     ]
 

test/test_invalid_headers.py

@@ -144,11 +144,11 @@ def test_headers_event(self, frame_factory, headers):
     @pytest.mark.parametrize('headers', invalid_header_blocks)
     def test_headers_event_skipping_validation(self, frame_factory, headers):
         """
-        If we have ``validate_sent_headers`` disabled, then all of these
+        If we have ``validate_outbound_headers`` disabled, then all of these
         invalid header blocks are allowed to pass.
         """
         config = h2.config.H2Configuration(
-            validate_sent_headers=False)
+            validate_outbound_headers=False)
 
         c = h2.connection.H2Connection(config=config)
         c.initiate_connection()
@@ -160,12 +160,12 @@ def test_headers_event_skipping_validation(self, frame_factory, headers):
     @pytest.mark.parametrize('headers', invalid_header_blocks)
     def test_headers_event_skip_normalization(self, frame_factory, headers):
         """
-        If we have ``normalize_sent_headers`` disabled, then all of these
+        If we have ``normalize_outbound_headers`` disabled, then all of these
         invalid header blocks are sent through unmodified.
         """
         config = h2.config.H2Configuration(
-            validate_sent_headers=False,
-            normalize_sent_headers=False)
+            validate_outbound_headers=False,
+            normalize_outbound_headers=False)
 
         c = h2.connection.H2Connection(config=config)
         c.initiate_connection()
@@ -192,7 +192,7 @@ class TestFilter(object):
     """
     validation_functions = [
         h2.utilities.validate_headers,
-        h2.utilities.validate_sent_headers
+        h2.utilities.validate_outbound_headers
     ]
 
     hdr_validation_combos = [