aws-eventstream 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f7aee8044bf87469f60f9a7fa8a7b28069a28a72
-  data.tar.gz: ab363b06b8d2e45da754e5dffc707dd68fdac1f9
+SHA256:
+  metadata.gz: fff3fdb08217556c55202a167109fc5bedf371ba7eabb7b23eb1e63df6b305b5
+  data.tar.gz: 9c47cccf76de702069df8692b74aefab41778374bc179db484c8835489708869
 SHA512:
-  metadata.gz: 8da3c6a510ab3355814264258350c8930847ddc0c1197ecfb59508eb9e37e97297572e0e7ea429953d3a1ac05cb5b070201c7054915986f1d630b4ec9da4dc3f
-  data.tar.gz: 2aff7fe4e8b4a0c07d7a2a35946066c376b5341a983a2da13059c8bdf8ba40add81f9c19a2e0b7b2441f375b43e3ee12a6e84681506b350befa2b0208a4e5486
+  metadata.gz: f82dd4b517d49fa88424cccb2d777a65b35e80ca47cd352f57c50d26e3073642d549f40d657d034c153df7a4863ad68ba8d163cf6ea422ee283ba27c8c0c3fe8
+  data.tar.gz: 20794804e55472b14614b5e0727ef807f9994a803328874a9fbb337777212c49d6798dc3136424c86de59d66d5ee7a121ccdd89b86572e5c84a7eeddd592513d

data/lib/aws-eventstream.rb

@@ -1,7 +1,6 @@
 require_relative 'aws-eventstream/decoder'
 require_relative 'aws-eventstream/encoder'
 
-require_relative 'aws-eventstream/bytes_buffer'
 require_relative 'aws-eventstream/message'
 require_relative 'aws-eventstream/header_value'
 require_relative 'aws-eventstream/types'

data/lib/aws-eventstream/decoder.rb

@@ -3,7 +3,7 @@ require 'tempfile'
 require 'zlib'
 
 module Aws
-  module EventStream 
+  module EventStream
 
     # This class provides method for decoding binary inputs into
     # single or multiple messages (Aws::EventStream::Message).
@@ -28,7 +28,7 @@ module Aws
     #   message_pool = decoder.decode(io)
     #   message_pool.next
     #   # => Aws::EventStream::Message
-    #   
+    #
     # * {#decode_chunk} - decodes a single message from a chunk of data,
     #   returning message object followed by boolean(indicating eof status
     #   of data) in an array object
@@ -63,27 +63,26 @@ module Aws
       include Enumerable
 
       ONE_MEGABYTE = 1024 * 1024
+      private_constant :ONE_MEGABYTE
 
       # bytes of prelude part, including 4 bytes of
       # total message length, headers length and crc checksum of prelude
       PRELUDE_LENGTH = 12
+      private_constant :PRELUDE_LENGTH
 
-      # bytes of total overhead in a message, including prelude
-      # and 4 bytes total message crc checksum
-      OVERHEAD_LENGTH = 16
+      # 4 bytes message crc checksum
+      CRC32_LENGTH = 4
+      private_constant :CRC32_LENGTH
 
-      # @options options [Boolean] format (true) When `false`
-      #   disable user-friendly formatting for message header values
+      # @param [Hash] options The initialization options.
+      # @option options [Boolean] :format (true) When `false` it
+      #   disables user-friendly formatting for message header values
       #   including timestamp and uuid etc.
-      #
       def initialize(options = {})
         @format = options.fetch(:format, true)
-        @message_buffer = BytesBuffer.new('')
+        @message_buffer = ''
       end
 
-      # @returns [BytesBuffer]
-      attr_reader :message_buffer
-
       # Decodes messages from a binary stream
       #
       # @param [IO#read] io An IO-like object
@@ -93,12 +92,12 @@ module Aws
       # @return [Enumerable<Message>, nil] Returns a new Enumerable
       #   containing decoded messages if no block is given
       def decode(io, &block)
-        io = BytesBuffer.new(io.read)
-        return decode_io(io) unless block_given?
-        until io.eof?
-          # fetch message only
-          yield(decode_message(io).first)
-        end
+        raw_message = io.read
+        decoded_message = decode_message(raw_message)
+        return wrap_as_enumerator(decoded_message) unless block_given?
+        # fetch message only
+        raw_event, _eof = decoded_message
+        block.call(raw_event)
       end
 
       # Decodes a single message from a chunk of string
@@ -111,95 +110,81 @@ module Aws
       #   and boolean pair, the boolean flag indicates whether this chunk
       #   has been fully consumed, unused data is tracked at #message_buffer
       def decode_chunk(chunk = nil)
-        @message_buffer.write(chunk) if chunk
-        @message_buffer.rewind
+        @message_buffer = [@message_buffer, chunk].pack('a*a*') if chunk
         decode_message(@message_buffer)
       end
 
       private
 
-      def decode_io(io)
-        ::Enumerator.new {|e| e << decode_message(io) unless io.eof? }
+      # exposed via object.send for testing
+      attr_reader :message_buffer
+
+      def wrap_as_enumerator(decoded_message)
+        Enumerator.new do |yielder|
+          yielder << decoded_message
+        end
       end
 
-      def decode_message(io)
-        # incomplete message prelude received, leave it in the buffer
-        return [nil, true] if io.bytesize < PRELUDE_LENGTH
+      def decode_message(raw_message)
+        # incomplete message prelude received
+        return [nil, true] if raw_message.bytesize < PRELUDE_LENGTH
+
+        prelude, content = raw_message.unpack("a#{PRELUDE_LENGTH}a*")
 
         # decode prelude
-        total_len, headers_len, prelude_buffer = prelude(io)
+        total_length, header_length = decode_prelude(prelude)
 
         # incomplete message received, leave it in the buffer
-        return [nil, true] if io.bytesize < total_len
+        return [nil, true] if raw_message.bytesize < total_length
 
-        # decode headers and payload
-        headers, payload = context(io, total_len, headers_len, prelude_buffer)
-
-        # track extra message data in the buffer if exists
-        # for #decode_chunk, io is @message_buffer
-        if eof = io.eof?
-          @message_buffer.clear!
-        else
-          @message_buffer = BytesBuffer.new(@message_buffer.read)
+        content, checksum, remaining = content.unpack("a#{total_length - PRELUDE_LENGTH - CRC32_LENGTH}Na*")
+        unless Zlib.crc32([prelude, content].pack('a*a*')) == checksum
+          raise Errors::MessageChecksumError
         end
 
-        [Message.new(headers: headers, payload: payload), eof]
+        # decode headers and payload
+        headers, payload = decode_context(content, header_length)
+
+        @message_buffer = remaining
+
+        [Message.new(headers: headers, payload: payload), remaining.empty?]
       end
 
-      def prelude(io)
-        # buffer prelude into bytes buffer
+      def decode_prelude(prelude)
         # prelude contains length of message and headers,
         # followed with CRC checksum of itself
-        buffer = BytesBuffer.new(io.read(PRELUDE_LENGTH))
-
-        # prelude checksum takes last 4 bytes
-        checksum = Zlib.crc32(buffer.read(PRELUDE_LENGTH - 4))
-        unless checksum == unpack_uint32(buffer)
-          raise Errors::PreludeChecksumError
-        end
-
-        buffer.rewind
-        total_len, headers_len, _ = buffer.read.unpack('N*')
-        [total_len, headers_len, buffer]
+        content, checksum = prelude.unpack("a#{PRELUDE_LENGTH - CRC32_LENGTH}N")
+        raise Errors::PreludeChecksumError unless Zlib.crc32(content) == checksum
+        content.unpack('N*')
       end
 
-      def context(io, total_len, headers_len, prelude_buffer)
-        # buffer rest of the message except prelude length
-        # including context and total message checksum
-        buffer = BytesBuffer.new(io.read(total_len - PRELUDE_LENGTH))
-        context_len = total_len - OVERHEAD_LENGTH
-
-        prelude_buffer.rewind
-        checksum = Zlib.crc32(prelude_buffer.read << buffer.read(context_len))
-        unless checksum == unpack_uint32(buffer)
-          raise Errors::MessageChecksumError
-        end
-
-        buffer.rewind
+      def decode_context(content, header_length)
+        encoded_header, encoded_payload = content.unpack("a#{header_length}a*")
         [
-          extract_headers(BytesBuffer.new(buffer.read(headers_len))),
-          extract_payload(BytesBuffer.new(buffer.read(context_len - headers_len)))
+          extract_headers(encoded_header),
+          extract_payload(encoded_payload)
         ]
       end
 
       def extract_headers(buffer)
+        scanner = buffer
         headers = {}
-        until buffer.eof?
+        until scanner.bytesize == 0
           # header key
-          key_len = unpack_uint8(buffer)
-          key = buffer.read(key_len)
+          key_length, scanner = scanner.unpack('Ca*')
+          key, scanner = scanner.unpack("a#{key_length}a*")
 
           # header value
-          value_type = Types.types[unpack_uint8(buffer)]
-          unpack_pattern, value_len, _ = Types.pattern[value_type]
-          if !!unpack_pattern == unpack_pattern
+          type_index, scanner = scanner.unpack('Ca*')
+          value_type = Types.types[type_index]
+          unpack_pattern, value_length = Types.pattern[value_type]
+          value = if !!unpack_pattern == unpack_pattern
             # boolean types won't have value specified
-            value = unpack_pattern
+            unpack_pattern
           else
-            value_len = unpack_uint16(buffer) unless value_len
-            value = unpack_pattern ?
-              buffer.read(value_len).unpack(unpack_pattern)[0] :
-              buffer.read(value_len)
+            value_length, scanner = scanner.unpack('S>a*') unless value_length
+            unpacked_value, scanner = scanner.unpack("#{unpack_pattern || "a#{value_length}"}a*")
+            unpacked_value
           end
 
           headers[key] = HeaderValue.new(
@@ -211,40 +196,23 @@ module Aws
         headers
       end
 
-      def extract_payload(buffer)
-        buffer.bytesize <= ONE_MEGABYTE ?
-          payload_stringio(buffer) :
-          payload_tempfile(buffer)
+      def extract_payload(encoded)
+        encoded.bytesize <= ONE_MEGABYTE ?
+          payload_stringio(encoded) :
+          payload_tempfile(encoded)
       end
 
-      def payload_stringio(buffer)
-        StringIO.new(buffer.read)
+      def payload_stringio(encoded)
+        StringIO.new(encoded)
       end
 
-      def payload_tempfile(buffer)
+      def payload_tempfile(encoded)
         payload = Tempfile.new
         payload.binmode
-        until buffer.eof?
-          payload.write(buffer.read(ONE_MEGABYTE))
-        end
+        payload.write(encoded)
         payload.rewind
         payload
       end
-
-      # overhead decode helpers
-
-      def unpack_uint32(buffer)
-        buffer.read(4).unpack('N')[0]
-      end
-
-      def unpack_uint16(buffer)
-        buffer.read(2).unpack('S>')[0]
-      end
-
-      def unpack_uint8(buffer)
-        buffer.readbyte.unpack('C')[0]
-      end
     end
-
   end
 end

data/lib/aws-eventstream/encoder.rb

@@ -1,7 +1,7 @@
 require 'zlib'
 
 module Aws
-  module EventStream 
+  module EventStream
 
     # This class provides #encode method for encoding
     # Aws::EventStream::Message into binary.
@@ -59,7 +59,7 @@ module Aws
       #   will be returned. Else, encoded binary string is
       #   returned.
       def encode(message, io = nil)
-        encoded = encode_message(message).read
+        encoded = encode_message(message)
         if io
           io.write(encoded)
           io.close
@@ -69,92 +69,72 @@ module Aws
       end
 
       # Encodes an Aws::EventStream::Message
-      #   into Aws::EventStream::BytesBuffer
+      #   into String
       #
-      # @param [Aws::EventStream::Message] msg
+      # @param [Aws::EventStream::Message] message
       #
-      # @return [Aws::EventStream::BytesBuffer]
+      # @return [String]
       def encode_message(message)
         # create context buffer with encode headers
-        ctx_buffer = encode_headers(message)
-        headers_len = ctx_buffer.bytesize
+        encoded_header = encode_headers(message)
+        header_length = encoded_header.bytesize
         # encode payload
         if message.payload.length > MAX_PAYLOAD_LENGTH
           raise Aws::EventStream::Errors::EventPayloadLengthExceedError.new
         end
-        ctx_buffer << message.payload.read
-        total_len = ctx_buffer.bytesize + OVERHEAD_LENGTH
+        encoded_payload = message.payload.read
+        total_length = header_length + encoded_payload.bytesize + OVERHEAD_LENGTH
 
         # create message buffer with prelude section
-        buffer = prelude(total_len, headers_len)
+        encoded_prelude = encode_prelude(total_length, header_length)
 
         # append message context (headers, payload)
-        buffer << ctx_buffer.read
+        encoded_content = [
+          encoded_prelude,
+          encoded_header,
+          encoded_payload,
+        ].pack('a*a*a*')
         # append message checksum
-        buffer << pack_uint32(Zlib.crc32(buffer.read))
-
-        # write buffered message to io
-        buffer.rewind
-        buffer
+        message_checksum = Zlib.crc32(encoded_content)
+        [encoded_content, message_checksum].pack('a*N')
       end
 
       # Encodes headers part of an Aws::EventStream::Message
-      #   into Aws::EventStream::BytesBuffer
+      #   into String
       #
-      # @param [Aws::EventStream::Message] msg
+      # @param [Aws::EventStream::Message] message
       #
-      # @return [Aws::EventStream::BytesBuffer]
-      def encode_headers(msg)
-        buffer = BytesBuffer.new('')
-        msg.headers.each do |k, v|
-          # header key
-          buffer << pack_uint8(k.bytesize)
-          buffer << k
+      # @return [String]
+      def encode_headers(message)
+        header_entries = message.headers.map do |key, value|
+          encoded_key = [key.bytesize, key].pack('Ca*')
 
           # header value
-          pattern, val_len, idx = Types.pattern[v.type]
-          buffer << pack_uint8(idx)
+          pattern, value_length, type_index = Types.pattern[value.type]
+          encoded_value = [type_index].pack('C')
           # boolean types doesn't need to specify value
-          next if !!pattern == pattern
-          buffer << pack_uint16(v.value.bytesize) unless val_len
-          pattern ? buffer << [v.value].pack(pattern) :
-            buffer << v.value
+          next [encoded_key, encoded_value].pack('a*a*') if !!pattern == pattern
+          encoded_value = [encoded_value, value.value.bytesize].pack('a*S>') unless value_length
+
+          [
+            encoded_key,
+            encoded_value,
+            pattern ? [value.value].pack(pattern) : value.value,
+          ].pack('a*a*a*')
         end
-        if buffer.bytesize > MAX_HEADERS_LENGTH
+        header_entries.join.tap do |encoded_header|
+          break encoded_header if encoded_header.bytesize <= MAX_HEADERS_LENGTH
           raise Aws::EventStream::Errors::EventHeadersLengthExceedError.new
         end
-        buffer
       end
 
       private
 
-      def prelude(total_len, headers_len)
-        BytesBuffer.new(pack_uint32([
-          total_len,
-          headers_len,
-          Zlib.crc32(pack_uint32([total_len, headers_len]))
-        ]))
-      end
-
-      # overhead encode helpers
-
-      def pack_uint8(val)
-        [val].pack('C')
-      end
-
-      def pack_uint16(val)
-        [val].pack('S>')
+      def encode_prelude(total_length, headers_length)
+        prelude_body = [total_length, headers_length].pack('NN')
+        checksum = Zlib.crc32(prelude_body)
+        [prelude_body, checksum].pack('a*N')
       end
-
-      def pack_uint32(val)
-        if val.respond_to?(:each)
-          val.pack('N*')
-        else
-          [val].pack('N')
-        end
-      end
-
     end
-
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aws-eventstream
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Amazon Web Services
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-24 00:00:00.000000000 Z
+date: 2020-04-08 00:00:00.000000000 Z
 dependencies: []
 description: Amazon Web Services event stream library. Decodes and encodes binary
   stream under `vnd.amazon.event-stream` content-type
@@ -18,7 +18,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/aws-eventstream.rb
-- lib/aws-eventstream/bytes_buffer.rb
 - lib/aws-eventstream/decoder.rb
 - lib/aws-eventstream/encoder.rb
 - lib/aws-eventstream/errors.rb
@@ -47,7 +46,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2.3
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: AWS Event Stream Library

data/lib/aws-eventstream/bytes_buffer.rb

@@ -1,66 +0,0 @@
-module Aws
-  module EventStream 
-
-    # @api private
-    class BytesBuffer
-
-      # This Util class is for Decoder/Encoder usage only
-      # Not for public common bytes buffer usage
-      def initialize(data)
-        @data = data
-        @pos = 0
-      end
-
-      def read(len = nil, offset = 0)
-        return '' if len == 0 || bytesize == 0
-        unless eof?
-          start_byte = @pos + offset
-          end_byte = len ?
-            start_byte + len - 1 :
-            bytesize - 1
-
-          error = Errors::ReadBytesExceedLengthError.new(end_byte, bytesize)
-          raise error if end_byte >= bytesize
-
-          @pos = end_byte + 1
-          @data[start_byte..end_byte]
-        end
-      end
-
-      def readbyte
-        unless eof?
-          @pos += 1
-          @data[@pos - 1]
-        end
-      end
-
-      def write(bytes)
-        @data <<= bytes
-        bytes.bytesize
-      end
-      alias_method :<<, :write
-
-      def rewind
-        @pos = 0
-      end
-
-      def eof?
-        @pos == bytesize
-      end
-
-      def bytesize
-        @data.bytesize
-      end
-
-      def tell
-        @pos
-      end
-
-      def clear!
-        @data = ''
-        @pos = 0
-      end
-    end
-
-  end
-end