Merge pull request #131 from jdecuyper/error-code-registry

Add HTTP2 error code registry

Author: Lukasa

hyper/http20/connection.py

@@ -19,6 +19,7 @@
 from .response import HTTP20Response, HTTP20Push
 from .window import FlowControlManager
 from .exceptions import ConnectionError
+from . import errors
 
 import errno
 import logging
@@ -375,11 +376,20 @@ def receive_frame(self, frame):
             # shutdown and all is well. Otherwise, throw an exception.
             self.close()
 
+            # If an error occured, try to read the error description from
+            # code registry otherwise use the frame's additional data.
             if frame.error_code != 0:
-                raise ConnectionError(
-                    "Encountered error %d, extra data %s." %
-                    (frame.error_code, frame.additional_data)
-                )
+                try:
+                    name, number, description = errors.get_data(frame.error_code)
+                except ValueError:
+                    error_string = ("Encountered error code %d, extra data %s" %
+                                   (frame.error_code, frame.additional_data))
+                else:
+                    error_string = ("Encountered error %s %s: %s" %
+                                   (name, number, description))
+
+                raise ConnectionError(error_string)
+
         elif frame.type == BlockedFrame.type:
             increment = self.window_manager._blocked()
             if increment:

hyper/http20/errors.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+"""
+hyper/http20/errors
+~~~~~~~~~~~~~~~~~~~
+
+Global error code registry containing the established HTTP/2 error codes.
+The registry is based on a 32-bit space so we use the error code to index into
+the array.
+
+The current registry is available at:
+https://tools.ietf.org/html/draft-ietf-httpbis-http2-17#section-11.4
+"""
+
+NO_ERROR =            {'Name': 'NO_ERROR',
+                       'Code': '0x0',
+                       'Description': 'Graceful shutdown'}
+PROTOCOL_ERROR =      {'Name': 'PROTOCOL_ERROR',
+                       'Code': '0x1',
+                       'Description': 'Protocol error detected'}
+INTERNAL_ERROR =      {'Name': 'INTERNAL_ERROR',
+                       'Code': '0x2',
+                       'Description': 'Implementation fault'}
+FLOW_CONTROL_ERROR =  {'Name': 'FLOW_CONTROL_ERROR',
+                       'Code': '0x3',
+                       'Description': 'Flow control limits exceeded'}
+SETTINGS_TIMEOUT =    {'Name': 'SETTINGS_TIMEOUT',
+                       'Code': '0x4',
+                       'Description': 'Settings not acknowledged'}
+STREAM_CLOSED =       {'Name': 'STREAM_CLOSED',
+                       'Code': '0x5',
+                       'Description': 'Frame received for closed stream'}
+FRAME_SIZE_ERROR =    {'Name': 'FRAME_SIZE_ERROR',
+                       'Code': '0x6',
+                       'Description': 'Frame size incorrect'}
+REFUSED_STREAM =      {'Name': 'REFUSED_STREAM ',
+                       'Code': '0x7',
+                       'Description': 'Stream not processed'}
+CANCEL =              {'Name': 'CANCEL',
+                       'Code': '0x8',
+                       'Description': 'Stream cancelled'}
+COMPRESSION_ERROR =   {'Name': 'COMPRESSION_ERROR',
+                       'Code': '0x9',
+                       'Description': 'Compression state not updated'}
+CONNECT_ERROR =       {'Name': 'CONNECT_ERROR',
+                       'Code': '0xa',
+                       'Description': 
+                       'TCP connection error for CONNECT method'}
+ENHANCE_YOUR_CALM =   {'Name': 'ENHANCE_YOUR_CALM',
+                       'Code': '0xb',
+                       'Description': 'Processing capacity exceeded'}
+INADEQUATE_SECURITY = {'Name': 'INADEQUATE_SECURITY',
+                       'Code': '0xc',
+                       'Description': 
+                       'Negotiated TLS parameters not acceptable'}
+HTTP_1_1_REQUIRED =   {'Name': 'HTTP_1_1_REQUIRED', 
+                       'Code': '0xd',
+                       'Description': 'Use HTTP/1.1 for the request'}
+
+H2_ERRORS = [NO_ERROR, PROTOCOL_ERROR, INTERNAL_ERROR, FLOW_CONTROL_ERROR,
+             SETTINGS_TIMEOUT, STREAM_CLOSED, FRAME_SIZE_ERROR, REFUSED_STREAM,
+             CANCEL, COMPRESSION_ERROR, CONNECT_ERROR, ENHANCE_YOUR_CALM,
+             INADEQUATE_SECURITY, HTTP_1_1_REQUIRED]
+
+def get_data(error_code):
+    """
+    Lookup the error code description, if not available throw a value error
+    """
+    if error_code < 0 or error_code >= len(H2_ERRORS):
+        raise ValueError("Error code is invalid")
+
+    name = H2_ERRORS[error_code]['Name']
+    number = H2_ERRORS[error_code]['Code']
+    description = H2_ERRORS[error_code]['Description']
+
+    return name, number, description

test/test_hyper.py

@@ -2,7 +2,7 @@
 from hyper.packages.hyperframe.frame import (
     Frame, DataFrame, RstStreamFrame, SettingsFrame,
     PushPromiseFrame, PingFrame, WindowUpdateFrame, HeadersFrame,
-    ContinuationFrame, BlockedFrame,
+    ContinuationFrame, BlockedFrame, GoAwayFrame,
 )
 from hyper.packages.hpack.hpack_compat import Encoder, Decoder
 from hyper.http20.connection import HTTP20Connection
@@ -11,7 +11,7 @@
 )
 from hyper.http20.response import HTTP20Response, HTTP20Push
 from hyper.http20.exceptions import (
-    HPACKDecodingError, HPACKEncodingError, ProtocolError
+    HPACKDecodingError, HPACKEncodingError, ProtocolError, ConnectionError,
 )
 from hyper.http20.window import FlowControlManager
 from hyper.http20.util import (
@@ -20,6 +20,7 @@
 from hyper.common.headers import HTTPHeaderMap
 from hyper.compat import zlib_compressobj
 from hyper.contrib import HTTP20Adapter
+import hyper.http20.errors as errors
 import errno
 import os
 import pytest
@@ -1183,6 +1184,82 @@ def test_stripping_multiple_connection_headers(self):
 
         assert h2_safe_headers(headers) == stripped
 
+    def test_goaway_frame_PROTOCOL_ERROR(self):
+        f = GoAwayFrame(0)
+        # Set error code to PROTOCOL_ERROR
+        f.error_code = 1;
+
+        c = HTTP20Connection('www.google.com')
+        c._sock = DummySocket()
+
+        # 'Receive' the GOAWAY frame.
+        # Validate that the spec error name and description are used to throw
+        # the connection exception.
+        with pytest.raises(ConnectionError) as conn_err:
+            c.receive_frame(f)
+
+        err_msg = str(conn_err)
+        name, number, description = errors.get_data(1)
+
+        assert name in err_msg
+        assert number in err_msg
+        assert description in err_msg
+
+    def test_goaway_frame_HTTP_1_1_REQUIRED(self):
+        f = GoAwayFrame(0)
+        # Set error code to HTTP_1_1_REQUIRED
+        f.error_code = 13;
+
+        c = HTTP20Connection('www.google.com')
+        c._sock = DummySocket()
+
+        # 'Receive' the GOAWAY frame.
+        # Validate that the spec error name and description are used to throw
+        # the connection exception.
+        with pytest.raises(ConnectionError) as conn_err:
+            c.receive_frame(f)
+
+        err_msg = str(conn_err)
+        name, number, description = errors.get_data(13)
+
+        assert name in err_msg
+        assert number in err_msg
+        assert description in err_msg
+
+    def test_goaway_frame_NO_ERROR(self):
+        f = GoAwayFrame(0)
+        # Set error code to NO_ERROR
+        f.error_code = 0;
+
+        c = HTTP20Connection('www.google.com')
+        c._sock = DummySocket()
+
+        # 'Receive' the GOAWAY frame.
+        # Test makes sure no exception is raised; error code 0 means we are
+        # dealing with a standard and graceful shutdown.
+        c.receive_frame(f)
+
+    def test_goaway_frame_invalid_error_code(self):
+        f = GoAwayFrame(0)
+        # Set error code to non existing error
+        f.error_code = 100;
+        f.additional_data = 'data about non existing error code';
+
+        c = HTTP20Connection('www.google.com')
+        c._sock = DummySocket()
+
+        # 'Receive' the GOAWAY frame.
+        # If the error code does not exist in the spec then the additional
+        # data is used instead.
+        with pytest.raises(ConnectionError) as conn_err:
+            c.receive_frame(f)
+
+        err_msg = str(conn_err)
+        with pytest.raises(ValueError):
+            name, number, description = errors.get_data(100)
+
+        assert 'data about non existing error code' in err_msg
+        assert str(f.error_code) in err_msg
 
 # Some utility classes for the tests.
 class NullEncoder(object):