http-2 0.12.0 → 1.0.2

data/lib/http/2/flow_buffer.rb

@@ -5,16 +5,28 @@ module HTTP2
   # be split and / or may be buffered based on current flow control window.
   #
   module FlowBuffer
+    include Error
+
+    MAX_WINDOW_SIZE = (2 << 30) - 1
+
     # Amount of buffered data. Only DATA payloads are subject to flow stream
     # and connection flow control.
     #
     # @return [Integer]
     def buffered_amount
-      @send_buffer.map { |f| f[:length] }.reduce(:+) || 0
+      send_buffer.bytesize
+    end
+
+    def flush
+      send_data
     end
 
     private
 
+    def send_buffer
+      @send_buffer ||= FrameBuffer.new
+    end
+
     def update_local_window(frame)
       frame_size = frame[:payload].bytesize
       frame_size += frame[:padding] || 0
@@ -26,7 +38,7 @@ module HTTP2
       # current received window size + delta length is strictly larger than
       # local window size, it throws a flow control error.
       #
-      error(:flow_control_error) if @local_window.negative?
+      error(:flow_control_error) if @local_window < 0
 
       # Send WINDOW_UPDATE if the received window size goes over
       # the local window size / 2.
@@ -55,51 +67,92 @@ module HTTP2
     # Buffered DATA frames are emitted in FIFO order.
     #
     # @param frame [Hash]
-    # @param encode [Boolean] set to true by co
+    # @param encode [Boolean] set to true by connection
     def send_data(frame = nil, encode = false)
-      @send_buffer.push frame unless frame.nil?
-
-      # FIXME: Frames with zero length with the END_STREAM flag set (that
-      # is, an empty DATA frame) MAY be sent if there is no available space
-      # in either flow control window.
-      while @remote_window.positive? && !@send_buffer.empty?
-        frame = @send_buffer.shift
+      send_buffer << frame unless frame.nil?
 
-        sent = 0
-        frame_size = frame[:payload].bytesize
+      while (frame = send_buffer.retrieve(@remote_window))
 
-        if frame_size > @remote_window
-          payload = frame.delete(:payload)
-          chunk   = frame.dup
-
-          # Split frame so that it fits in the window
-          # TODO: consider padding!
-          frame[:payload] = payload.slice!(0, @remote_window)
-          chunk[:length]  = payload.bytesize
-          chunk[:payload] = payload
-
-          # if no longer last frame in sequence...
-          frame[:flags] -= [:end_stream] if frame[:flags].include? :end_stream
-
-          @send_buffer.unshift chunk
-          sent = @remote_window
-        else
-          sent = frame_size
-        end
+        # puts "#{self.class} -> #{@remote_window}"
+        sent = frame[:payload].bytesize
 
         manage_state(frame) do
-          frames = encode ? encode(frame) : [frame]
-          frames.each { |f| emit(:frame, f) }
+          if encode
+            encode(frame).each { |f| emit(:frame, f) }
+          else
+            emit(:frame, frame)
+          end
           @remote_window -= sent
         end
       end
     end
 
-    def process_window_update(frame)
+    def process_window_update(frame:, encode: false)
       return if frame[:ignore]
 
-      @remote_window += frame[:increment]
-      send_data
+      if frame[:increment]
+        raise ProtocolError, "increment MUST be higher than zero" if frame[:increment].zero?
+
+        @remote_window += frame[:increment]
+        error(:flow_control_error, msg: "window size too large") if @remote_window > MAX_WINDOW_SIZE
+      end
+      send_data(nil, encode)
+    end
+  end
+
+  class FrameBuffer
+    attr_reader :bytesize
+
+    def initialize
+      @buffer = []
+      @bytesize = 0
+    end
+
+    def <<(frame)
+      @buffer << frame
+      @bytesize += frame[:payload].bytesize
+    end
+
+    def empty?
+      @bytesize.zero?
+    end
+
+    def retrieve(window_size)
+      frame = @buffer.first or return
+
+      frame_size = frame[:payload].bytesize
+      end_stream = frame[:flags].include? :end_stream
+
+      # Frames with zero length with the END_STREAM flag set (that
+      # is, an empty DATA frame) MAY be sent if there is no available space
+      # in either flow control window.
+      return if window_size <= 0 && !(frame_size == 0 && end_stream)
+
+      @buffer.shift
+
+      if frame_size > window_size
+        payload = frame[:payload]
+        chunk   = frame.dup
+
+        # Split frame so that it fits in the window
+        # TODO: consider padding!
+        frame_bytes = payload.byteslice(0, window_size)
+        payload = payload.byteslice(window_size..-1)
+
+        frame[:payload] = frame_bytes
+        frame[:length] = frame_bytes.bytesize
+        chunk[:payload] = payload
+        chunk[:length]  = payload.bytesize
+
+        # if no longer last frame in sequence...
+        frame[:flags] -= [:end_stream] if end_stream
+
+        @buffer.unshift(chunk)
+        @bytesize -= window_size
+      else
+        @bytesize -= frame_size
+      end
+      frame
     end
   end
 end

data/lib/http/2/framer.rb

@@ -5,12 +5,14 @@ module HTTP2
   #
   class Framer
     include Error
+    include PackingExtensions
+    include BufferUtils
 
     # Default value of max frame size (16384 bytes)
-    DEFAULT_MAX_FRAME_SIZE = 2**14
+    DEFAULT_MAX_FRAME_SIZE = 2 << 13
 
-    # Current maximum frame size
-    attr_accessor :max_frame_size
+    # maximum frame size
+    attr_accessor :local_max_frame_size, :remote_max_frame_size
 
     # Maximum stream ID (2^31)
     MAX_STREAM_ID = 0x7fffffff
@@ -30,7 +32,8 @@ module HTTP2
       goaway: 0x7,
       window_update: 0x8,
       continuation: 0x9,
-      altsvc: 0xa
+      altsvc: 0xa,
+      origin: 0xc
     }.freeze
 
     FRAME_TYPES_WITH_PADDING = %i[data headers push_promise].freeze
@@ -59,7 +62,13 @@ module HTTP2
       goaway: {},
       window_update: {},
       continuation: { end_headers: 2 },
-      altsvc: {}
+      altsvc: {},
+      origin: {
+        reserved: 1,
+        reserved2: 2,
+        reserved3: 4,
+        reserved4: 8
+      }
     }.each_value(&:freeze).freeze
 
     # Default settings as defined by the spec
@@ -93,9 +102,9 @@ module HTTP2
     RBIT  = 0x7fffffff
     RBYTE = 0x0fffffff
     EBIT  = 0x80000000
-    UINT32 = 'N'
-    UINT16 = 'n'
-    UINT8  = 'C'
+    UINT32 = "N"
+    UINT16 = "n"
+    UINT8  = "C"
     HEADERPACK = (UINT8 + UINT16 + UINT8 + UINT8 + UINT32).freeze
     FRAME_LENGTH_HISHIFT = 16
     FRAME_LENGTH_LOMASK  = 0xFFFF
@@ -104,23 +113,24 @@ module HTTP2
 
     # Initializes new framer object.
     #
-    def initialize
-      @max_frame_size = DEFAULT_MAX_FRAME_SIZE
+    def initialize(local_max_frame_size = DEFAULT_MAX_FRAME_SIZE,
+                   remote_max_frame_size = DEFAULT_MAX_FRAME_SIZE)
+      @local_max_frame_size = local_max_frame_size
+      @remote_max_frame_size = remote_max_frame_size
     end
 
     # Generates common 9-byte frame header.
     # - http://tools.ietf.org/html/draft-ietf-httpbis-http2-16#section-4.1
     #
     # @param frame [Hash]
+    # @param buffer [String] buffer to pack bytes into
     # @return [String]
-    def common_header(frame)
-      header = []
-
+    def common_header(frame, buffer:)
       raise CompressionError, "Invalid frame type (#{frame[:type]})" unless FRAME_TYPES[frame[:type]]
 
-      raise CompressionError, "Frame size is too large: #{frame[:length]}" if frame[:length] > @max_frame_size
+      raise CompressionError, "Frame size is too large: #{frame[:length]}" if frame[:length] > @remote_max_frame_size
 
-      raise CompressionError, "Frame size is invalid: #{frame[:length]}" if (frame[:length]).negative?
+      raise CompressionError, "Frame size is invalid: #{frame[:length]}" if frame[:length] < 0
 
       raise CompressionError, "Stream ID (#{frame[:stream]}) is too large" if frame[:stream] > MAX_STREAM_ID
 
@@ -128,32 +138,33 @@ module HTTP2
         raise CompressionError, "Window increment (#{frame[:increment]}) is too large"
       end
 
-      header << (frame[:length] >> FRAME_LENGTH_HISHIFT)
-      header << (frame[:length] & FRAME_LENGTH_LOMASK)
-      header << FRAME_TYPES[frame[:type]]
-      header << frame[:flags].reduce(0) do |acc, f|
-        position = FRAME_FLAGS[frame[:type]][f]
-        raise CompressionError, "Invalid frame flag (#{f}) for #{frame[:type]}" unless position
-
-        acc | (1 << position)
-      end
-
-      header << frame[:stream]
-      header.pack(HEADERPACK) # 8+16,8,8,32
+      pack([
+             (frame[:length] >> FRAME_LENGTH_HISHIFT),
+             (frame[:length] & FRAME_LENGTH_LOMASK),
+             FRAME_TYPES[frame[:type]],
+             frame[:flags].reduce(0) do |acc, f|
+               position = FRAME_FLAGS[frame[:type]][f]
+               raise CompressionError, "Invalid frame flag (#{f}) for #{frame[:type]}" unless position
+
+               acc | (1 << position)
+             end,
+             frame[:stream]
+           ], HEADERPACK, buffer: buffer, offset: 0) # 8+16,8,8,32
     end
 
     # Decodes common 9-byte header.
     #
     # @param buf [Buffer]
+    # @return [Hash] the corresponding frame
     def read_common_header(buf)
       frame = {}
-      len_hi, len_lo, type, flags, stream = buf.slice(0, 9).unpack(HEADERPACK)
+      len_hi, len_lo, type, flags, stream = buf.byteslice(0, 9).unpack(HEADERPACK)
 
       frame[:length] = (len_hi << FRAME_LENGTH_HISHIFT) | len_lo
       frame[:type], = FRAME_TYPES.find { |_t, pos| type == pos }
       if frame[:type]
         frame[:flags] = FRAME_FLAGS[frame[:type]].each_with_object([]) do |(name, pos), acc|
-          acc << name if (flags & (1 << pos)).positive?
+          acc << name if flags.anybits?((1 << pos))
         end
       end
 
@@ -166,7 +177,7 @@ module HTTP2
     #
     # @param frame [Hash]
     def generate(frame)
-      bytes  = Buffer.new
+      bytes  = "".b
       length = 0
 
       frame[:flags] ||= []
@@ -175,11 +186,12 @@ module HTTP2
       case frame[:type]
       when :data
         bytes << frame[:payload]
+        bytes.force_encoding(Encoding::BINARY)
         length += frame[:payload].bytesize
 
       when :headers
-        if frame[:weight] || frame[:stream_dependency] || !frame[:exclusive].nil?
-          unless frame[:weight] && frame[:stream_dependency] && !frame[:exclusive].nil?
+        if frame[:weight] || frame[:dependency] || !frame[:exclusive].nil?
+          unless frame[:weight] && frame[:dependency] && !frame[:exclusive].nil?
             raise CompressionError, "Must specify all of priority parameters for #{frame[:type]}"
           end
 
@@ -187,8 +199,8 @@ module HTTP2
         end
 
         if frame[:flags].include? :priority
-          bytes << [(frame[:exclusive] ? EBIT : 0) | (frame[:stream_dependency] & RBIT)].pack(UINT32)
-          bytes << [frame[:weight] - 1].pack(UINT8)
+          pack([(frame[:exclusive] ? EBIT : 0) | (frame[:dependency] & RBIT)], UINT32, buffer: bytes)
+          pack([frame[:weight] - 1], UINT8, buffer: bytes)
           length += 5
         end
 
@@ -196,23 +208,23 @@ module HTTP2
         length += frame[:payload].bytesize
 
       when :priority
-        unless frame[:weight] && frame[:stream_dependency] && !frame[:exclusive].nil?
+        unless frame[:weight] && frame[:dependency] && !frame[:exclusive].nil?
           raise CompressionError, "Must specify all of priority parameters for #{frame[:type]}"
         end
 
-        bytes << [(frame[:exclusive] ? EBIT : 0) | (frame[:stream_dependency] & RBIT)].pack(UINT32)
-        bytes << [frame[:weight] - 1].pack(UINT8)
+        pack([(frame[:exclusive] ? EBIT : 0) | (frame[:dependency] & RBIT)], UINT32, buffer: bytes)
+        pack([frame[:weight] - 1], UINT8, buffer: bytes)
         length += 5
 
       when :rst_stream
-        bytes << pack_error(frame[:error])
+        pack_error(frame[:error], buffer: bytes)
         length += 4
 
       when :settings
         raise CompressionError, "Invalid stream ID (#{frame[:stream]})" if (frame[:stream]).nonzero?
 
         frame[:payload].each do |(k, v)|
-          if k.is_a? Integer
+          if k.is_a? Integer # rubocop:disable Style/GuardClause
             DEFINED_SETTINGS.value?(k) || next
           else
             k = DEFINED_SETTINGS[k]
@@ -220,27 +232,25 @@ module HTTP2
             raise CompressionError, "Unknown settings ID for #{k}" if k.nil?
           end
 
-          bytes << [k].pack(UINT16)
-          bytes << [v].pack(UINT32)
+          pack([k], UINT16, buffer: bytes)
+          pack([v], UINT32, buffer: bytes)
           length += 6
         end
 
       when :push_promise
-        bytes << [frame[:promise_stream] & RBIT].pack(UINT32)
+        pack([frame[:promise_stream] & RBIT], UINT32, buffer: bytes)
         bytes << frame[:payload]
         length += 4 + frame[:payload].bytesize
 
       when :ping
-        if frame[:payload].bytesize != 8
-          raise CompressionError, "Invalid payload size (#{frame[:payload].size} != 8 bytes)"
-        end
+        raise CompressionError, "Invalid payload size (#{frame[:payload].size} != 8 bytes)" if frame[:payload].bytesize != 8
 
         bytes << frame[:payload]
         length += 8
 
       when :goaway
-        bytes << [frame[:last_stream] & RBIT].pack(UINT32)
-        bytes << pack_error(frame[:error])
+        pack([frame[:last_stream] & RBIT], UINT32, buffer: bytes)
+        pack_error(frame[:error], buffer: bytes)
         length += 8
 
         if frame[:payload]
@@ -249,7 +259,7 @@ module HTTP2
         end
 
       when :window_update
-        bytes << [frame[:increment] & RBIT].pack(UINT32)
+        pack([frame[:increment] & RBIT], UINT32, buffer: bytes)
         length += 4
 
       when :continuation
@@ -257,32 +267,40 @@ module HTTP2
         length += frame[:payload].bytesize
 
       when :altsvc
-        bytes << [frame[:max_age], frame[:port]].pack(UINT32 + UINT16)
+        pack([frame[:max_age], frame[:port]], UINT32 + UINT16, buffer: bytes)
         length += 6
         if frame[:proto]
-          raise CompressionError, 'Proto too long' if frame[:proto].bytesize > 255
+          raise CompressionError, "Proto too long" if frame[:proto].bytesize > 255
 
-          bytes << [frame[:proto].bytesize].pack(UINT8)
-          bytes << frame[:proto].force_encoding(Encoding::BINARY)
+          pack([frame[:proto].bytesize], UINT8, buffer: bytes)
+          bytes << frame[:proto]
           length += 1 + frame[:proto].bytesize
         else
-          bytes << [0].pack(UINT8)
+          pack([0], UINT8, buffer: bytes)
           length += 1
         end
         if frame[:host]
-          raise CompressionError, 'Host too long' if frame[:host].bytesize > 255
+          raise CompressionError, "Host too long" if frame[:host].bytesize > 255
 
-          bytes << [frame[:host].bytesize].pack(UINT8)
-          bytes << frame[:host].force_encoding(Encoding::BINARY)
+          pack([frame[:host].bytesize], UINT8, buffer: bytes)
+          bytes << frame[:host]
           length += 1 + frame[:host].bytesize
         else
-          bytes << [0].pack(UINT8)
+          pack([0], UINT8, buffer: bytes)
           length += 1
         end
         if frame[:origin]
           bytes << frame[:origin]
           length += frame[:origin].bytesize
         end
+
+      when :origin
+        frame[:payload].each do |origin|
+          pack([origin.bytesize], UINT16, buffer: bytes)
+          bytes << origin
+          length += 2 + origin.bytesize
+        end
+
       end
 
       # Process padding.
@@ -295,12 +313,12 @@ module HTTP2
 
         padlen = frame[:padding]
 
-        if padlen <= 0 || padlen > 256 || padlen + length > @max_frame_size
+        if padlen <= 0 || padlen > 256 || padlen + length > @remote_max_frame_size
           raise CompressionError, "Invalid padding #{padlen}"
         end
 
         length += padlen
-        bytes.prepend([padlen -= 1].pack(UINT8))
+        pack([padlen -= 1], UINT8, buffer: bytes, offset: 0)
         frame[:flags] << :padded
 
         # Padding:  Padding octets that contain no application semantic value.
@@ -310,7 +328,7 @@ module HTTP2
       end
 
       frame[:length] = length
-      bytes.prepend(common_header(frame))
+      common_header(frame, buffer: bytes)
     end
 
     # Decodes complete HTTP/2 frame from provided buffer. If the buffer
@@ -318,66 +336,74 @@ module HTTP2
     #
     # @param buf [Buffer]
     def parse(buf)
-      return nil if buf.size < 9
+      return if buf.size < 9
 
       frame = read_common_header(buf)
-      return nil if buf.size < 9 + frame[:length]
+      return if buf.size < 9 + frame[:length]
 
-      raise ProtocolError, 'payload too large' if frame[:length] > DEFAULT_MAX_FRAME_SIZE
+      raise ProtocolError, "payload too large" if frame[:length] > @local_max_frame_size
 
-      buf.read(9)
-      payload = buf.read(frame[:length])
+      read_str(buf, 9)
+      payload = read_str(buf, frame[:length])
 
       # Implementations MUST discard frames
       # that have unknown or unsupported types.
       # - http://tools.ietf.org/html/draft-ietf-httpbis-http2-16#section-5.5
-      return nil if frame[:type].nil?
+      return frame if frame[:type].nil?
 
       # Process padding
       padlen = 0
       if FRAME_TYPES_WITH_PADDING.include?(frame[:type])
         padded = frame[:flags].include?(:padded)
         if padded
-          padlen = payload.read(1).unpack1(UINT8)
+          padlen = read_str(payload, 1).unpack1(UINT8)
           frame[:padding] = padlen + 1
-          raise ProtocolError, 'padding too long' if padlen > payload.bytesize
+          raise ProtocolError, "padding too long" if padlen > payload.bytesize
 
-          payload.slice!(-padlen, padlen) if padlen.positive?
+          payload = payload.byteslice(0, payload.bytesize - padlen) if padlen > 0
           frame[:length] -= frame[:padding]
           frame[:flags].delete(:padded)
         end
       end
 
       case frame[:type]
-      when :data
-        frame[:payload] = payload.read(frame[:length])
+      when :data, :ping, :continuation
+        frame[:payload] = read_str(payload, frame[:length])
       when :headers
         if frame[:flags].include? :priority
-          e_sd = payload.read_uint32
-          frame[:stream_dependency] = e_sd & RBIT
-          frame[:exclusive] = (e_sd & EBIT) != 0
-          frame[:weight] = payload.getbyte + 1
+          e_sd = read_uint32(payload)
+          frame[:dependency] = e_sd & RBIT
+          frame[:exclusive] = e_sd.anybits?(EBIT)
+          weight = payload.byteslice(0, 1).ord + 1
+          frame[:weight] = weight
+          payload = payload.byteslice(1..-1)
         end
-        frame[:payload] = payload.read(frame[:length])
+        frame[:payload] = read_str(payload, frame[:length])
       when :priority
-        e_sd = payload.read_uint32
-        frame[:stream_dependency] = e_sd & RBIT
-        frame[:exclusive] = (e_sd & EBIT) != 0
-        frame[:weight] = payload.getbyte + 1
+        raise FrameSizeError, "Invalid length for PRIORITY_STREAM (#{frame[:length]} != 5)" if frame[:length] != 5
+
+        e_sd = read_uint32(payload)
+        frame[:dependency] = e_sd & RBIT
+        frame[:exclusive] = e_sd.anybits?(EBIT)
+        weight = payload.byteslice(0, 1).ord + 1
+        frame[:weight] = weight
+        payload = payload.byteslice(1..-1)
       when :rst_stream
-        frame[:error] = unpack_error payload.read_uint32
+        raise FrameSizeError, "Invalid length for RST_STREAM (#{frame[:length]} != 4)" if frame[:length] != 4
+
+        frame[:error] = unpack_error read_uint32(payload)
 
       when :settings
         # NOTE: frame[:length] might not match the number of frame[:payload]
         # because unknown extensions are ignored.
         frame[:payload] = []
-        raise ProtocolError, 'Invalid settings payload length' unless (frame[:length] % 6).zero?
+        raise ProtocolError, "Invalid settings payload length" unless (frame[:length] % 6).zero?
 
         raise ProtocolError, "Invalid stream ID (#{frame[:stream]})" if (frame[:stream]).nonzero?
 
         (frame[:length] / 6).times do
-          id  = payload.read(2).unpack1(UINT16)
-          val = payload.read_uint32
+          id  = read_str(payload, 2).unpack1(UINT16)
+          val = read_uint32(payload)
 
           # Unsupported or unrecognized settings MUST be ignored.
           # Here we send it along.
@@ -385,30 +411,42 @@ module HTTP2
           frame[:payload] << [name, val] if name
         end
       when :push_promise
-        frame[:promise_stream] = payload.read_uint32 & RBIT
-        frame[:payload] = payload.read(frame[:length])
-      when :ping
-        frame[:payload] = payload.read(frame[:length])
+        frame[:promise_stream] = read_uint32(payload) & RBIT
+        frame[:payload] = read_str(payload, frame[:length])
       when :goaway
-        frame[:last_stream] = payload.read_uint32 & RBIT
-        frame[:error] = unpack_error payload.read_uint32
+        frame[:last_stream] = read_uint32(payload) & RBIT
+        frame[:error] = unpack_error read_uint32(payload)
 
         size = frame[:length] - 8 # for last_stream and error
-        frame[:payload] = payload.read(size) if size.positive?
+        frame[:payload] = read_str(payload, size) if size > 0
       when :window_update
-        frame[:increment] = payload.read_uint32 & RBIT
-      when :continuation
-        frame[:payload] = payload.read(frame[:length])
+        if frame[:length] % 4 != 0
+          raise FrameSizeError, "Invalid length for WINDOW_UPDATE (#{frame[:length]} not multiple of 4)"
+        end
+
+        frame[:increment] = read_uint32(payload) & RBIT
       when :altsvc
-        frame[:max_age], frame[:port] = payload.read(6).unpack(UINT32 + UINT16)
+        frame[:max_age], frame[:port] = read_str(payload, 6).unpack(UINT32 + UINT16)
 
-        len = payload.getbyte
-        frame[:proto] = payload.read(len) if len.positive?
+        len = payload.byteslice(0, 1).ord
+        payload = payload.byteslice(1..-1)
+        frame[:proto] = read_str(payload, len) if len > 0
 
-        len = payload.getbyte
-        frame[:host] = payload.read(len) if len.positive?
+        len = payload.byteslice(0, 1).ord
+        payload = payload.byteslice(1..-1)
+        frame[:host] = read_str(payload, len) if len > 0
+
+        frame[:origin] = read_str(payload, payload.size) unless payload.empty?
+
+      when :origin
+        origins = []
+
+        until payload.empty?
+          len = read_str(payload, 2).unpack1(UINT16)
+          origins << read_str(payload, len)
+        end
 
-        frame[:origin] = payload.read(payload.size) unless payload.empty?
+        frame[:payload] = origins
         # else # Unknown frame type is explicitly allowed
       end
 
@@ -417,19 +455,18 @@ module HTTP2
 
     private
 
-    def pack_error(e)
-      unless e.is_a? Integer
-        raise CompressionError, "Unknown error ID for #{e}" if DEFINED_ERRORS[e].nil?
+    def pack_error(error, buffer:)
+      unless error.is_a? Integer
+        error = DEFINED_ERRORS[error]
 
-        e = DEFINED_ERRORS[e]
+        raise CompressionError, "Unknown error ID for #{error}" unless error
       end
 
-      [e].pack(UINT32)
+      pack([error], UINT32, buffer: buffer)
     end
 
-    def unpack_error(e)
-      name, = DEFINED_ERRORS.find { |_name, v| v == e }
-      name || error
+    def unpack_error(error)
+      DEFINED_ERRORS.key(error) || error
     end
   end
 end