change ProtocolError to ProtocolException

Author: Junchao Wu

tchannel/event.py

@@ -46,8 +46,8 @@ class EventType(IntEnum):
     before_receive_response = 0x30
     after_receive_response = 0x31
 
-    after_receive_protocol_error = 0x40
-    after_send_protocol_error = 0x41
+    after_receive_error = 0x40
+    after_send_error = 0x41
 
 
 class EventHook(object):
@@ -95,11 +95,11 @@ def after_receive_response(self, response):
         """Called after a ``CALL_RESP`` message is read."""
         pass
 
-    def after_receive_protocol_error(self, error):
+    def after_receive_error(self, err):
         """Called after a ``error`` message is read."""
         pass
 
-    def after_send_protocol_error(self, error):
+    def after_send_error(self, err):
         """Called after a ``error`` message is sent."""
         pass
 

tchannel/exceptions.py

@@ -28,7 +28,27 @@ class TChannelException(Exception):
 
 class ProtocolException(TChannelException):
     """Represent a protocol-level exception"""
-    pass
+    __slots__ = (
+        'code',
+        'description',
+        'id',
+        'tracing',
+    )
+
+    def __init__(
+        self,
+        code,
+        description,
+        id=None,
+        tracing=None,
+    ):
+        super(TChannelException, self).__init__(
+            'TChannel protocol error (%s)' % description
+        )
+        self.code = code
+        self.tracing = tracing
+        self.id = id
+        self.description = description
 
 
 class InvalidMessageException(ProtocolException):

tchannel/tornado/connection.py

@@ -36,13 +36,12 @@
 from ..event import EventType
 from ..exceptions import ConnectionClosedException
 from ..exceptions import InvalidErrorCodeException
-from ..exceptions import TChannelException
 from ..io import BytesIO
 from ..messages.common import PROTOCOL_VERSION
 from ..messages.common import FlagsType
 from ..messages.error import ErrorMessage
 from ..messages.types import Types
-from .message_factory import build_protocol_error
+from .message_factory import build_protocol_exception
 from .message_factory import MessageFactory
 
 try:
@@ -227,11 +226,11 @@ def _loop(self):
                     future = self._outstanding.pop(context.message_id)
 
                 if context.message.message_type == Types.ERROR:
-                    protocol_error = build_protocol_error(
+                    protocol_exception = build_protocol_exception(
                         context.message,
                         context.message_id,
                     )
-                    future.set_exception(protocol_error)
+                    future.set_exception(protocol_exception)
                     continue
 
                 if response and future.running():
@@ -609,15 +608,13 @@ def send_request(self, request):
 
     def adapt_result(self, f, request, response_future):
         if f.exception():
-            protocol_error = f.exception()
-            protocol_error.tracing = request.tracing
-            response_future.set_exception(
-                TChannelException(protocol_error.description)
-            )
+            protocol_exception = f.exception()
+            protocol_exception.tracing = request.tracing
+            response_future.set_exception(protocol_exception)
             # event: after_receive_protocol_error
             self.tchannel.event_emitter.fire(
-                EventType.after_receive_protocol_error,
-                protocol_error,
+                EventType.after_receive_error,
+                protocol_exception,
             )
         else:
             response = f.result()

tchannel/tornado/data.py

@@ -42,16 +42,16 @@ class Request(object):
 
     # TODO decide which elements inside "message" object to expose to user.
     def __init__(
-            self,
-            id=None,
-            flags=FlagsType.none,
-            ttl=10,
-            tracing=None,
-            service=None,
-            headers=None,
-            checksum=None,
-            argstreams=None,
-            scheme=None,
+        self,
+        id=None,
+        flags=FlagsType.none,
+        ttl=10,
+        tracing=None,
+        service=None,
+        headers=None,
+        checksum=None,
+        argstreams=None,
+        scheme=None,
     ):
         self.flags = flags
         self.ttl = ttl
@@ -133,16 +133,16 @@ class Response(object):
 
     # TODO decide which elements inside "message" object to expose to user.
     def __init__(
-            self,
-            connection=None,
-            id=None,
-            flags=FlagsType.none,
-            code=0,
-            tracing=None,
-            headers=None,
-            checksum=None,
-            argstreams=None,
-            scheme=None,
+        self,
+        connection=None,
+        id=None,
+        flags=FlagsType.none,
+        code=0,
+        tracing=None,
+        headers=None,
+        checksum=None,
+        argstreams=None,
+        scheme=None,
     ):
 
         self.flags = flags or StatusCode.ok
@@ -316,19 +316,3 @@ def close_argstreams(self, force=False):
         for stream in self.argstreams:
             if stream.auto_close or force:
                 stream.close()
-
-
-class ProtocolError(Exception):
-    """Object to represent protocol error message"""
-
-    def __init__(
-        self,
-        code,
-        description,
-        id=None,
-        tracing=None,
-    ):
-        self.code = code
-        self.tracing = tracing
-        self.id = id
-        self.description = description

tchannel/tornado/message_factory.py

@@ -37,31 +37,31 @@
 from ..messages.error import ErrorMessage
 from ..zipkin.annotation import Endpoint
 from ..zipkin.trace import Trace
-from .data import ProtocolError
+from ..exceptions import ProtocolException
 from .data import Request
 from .data import Response
 from .stream import InMemStream
 
 
-def build_raw_error_message(protocol_error):
+def build_raw_error_message(protocol_exception):
     """build protocol level error message based on Error object"""
     message = ErrorMessage(
-        code=protocol_error.code,
+        code=protocol_exception.code,
         tracing=Tracing(
-            protocol_error.tracing.span_id,
-            protocol_error.tracing.parent_span_id,
-            protocol_error.tracing.trace_id,
-            protocol_error.tracing.traceflags),
-        description=protocol_error.description,
+            protocol_exception.tracing.span_id,
+            protocol_exception.tracing.parent_span_id,
+            protocol_exception.tracing.trace_id,
+            protocol_exception.tracing.traceflags),
+        description=protocol_exception.description,
     )
 
     return message
 
 
-def build_protocol_error(message, message_id=None):
+def build_protocol_exception(message, message_id=None):
     """build protocol level error message based on Error object"""
 
-    error = ProtocolError(
+    error = ProtocolException(
         code=message.code,
         description=message.description,
         id=message_id,

tchannel/zipkin/zipkin_trace.py

@@ -71,15 +71,15 @@ def after_receive_response(self, response):
         response.tracing.annotations.append(ann)
         self.tracer.record([(response.tracing, response.tracing.annotations)])
 
-    def after_receive_protocol_error(self, error):
+    def after_receive_error(self, error):
         if not error.tracing.traceflags:
             return
 
         ann = annotation.client_recv()
         error.tracing.annotations.append(ann)
         self.tracer.record([(error.tracing, error.tracing.annotations)])
 
-    def after_send_protocol_error(self, error):
+    def after_send_error(self, error):
         if not error.tracing.traceflags:
             return