cql-rb 2.0.0.pre0 → 2.0.0.pre1

data/lib/cql/protocol.rb

@@ -41,8 +41,7 @@ module Cql
   end
 end
 
-require 'cql/protocol/encoding'
-require 'cql/protocol/decoding'
+require 'cql/protocol/cql_byte_buffer'
 require 'cql/protocol/type_converter'
 require 'cql/protocol/response'
 require 'cql/protocol/responses/auth_challenge_response'

data/lib/cql/protocol/cql_byte_buffer.rb

@@ -0,0 +1,285 @@
+# encoding: utf-8
+
+require 'bigdecimal'
+
+
+module Cql
+  module Protocol
+    class CqlByteBuffer < Ione::ByteBuffer
+      def read_unsigned_byte
+        read_byte
+      rescue RangeError => e
+        raise DecodingError, e.message, e.backtrace
+      end
+      
+      def read_varint(len=bytesize, signed=true)
+        bytes = read(len)
+        n = 0
+        bytes.each_byte do |b|
+          n = (n << 8) | b
+        end
+        if signed && bytes.getbyte(0) & 0x80 == 0x80
+          n -= 2**(bytes.length * 8)
+        end
+        n
+      rescue RangeError => e
+        raise DecodingError, e.message, e.backtrace
+      end
+
+      def read_decimal(len=bytesize)
+        size = read_signed_int
+        number_string = read_varint(len - 4).to_s
+        if number_string.length < size
+          if number_string.start_with?(MINUS)
+            number_string = number_string[1, number_string.length - 1]
+            fraction_string = MINUS + ZERO << DECIMAL_POINT
+          else
+            fraction_string = ZERO + DECIMAL_POINT
+          end
+          (size - number_string.length).times { fraction_string << ZERO }
+          fraction_string << number_string
+        else
+          fraction_string = number_string[0, number_string.length - size]
+          fraction_string << DECIMAL_POINT
+          fraction_string << number_string[number_string.length - size, number_string.length]
+        end
+        BigDecimal.new(fraction_string)
+      rescue DecodingError => e
+        raise DecodingError, e.message, e.backtrace
+      end
+
+      def read_long
+        top, bottom = read(8).unpack(Formats::TWO_INTS_FORMAT)
+        return (top << 32) | bottom if top <= 0x7fffffff
+        top ^= 0xffffffff
+        bottom ^= 0xffffffff
+        -((top << 32) | bottom) - 1
+      rescue RangeError => e
+        raise DecodingError, e.message, e.backtrace
+      end
+
+      def read_double
+        read(8).unpack(Formats::DOUBLE_FORMAT).first
+      rescue RangeError => e
+        raise DecodingError, "Not enough bytes available to decode a double: #{e.message}", e.backtrace
+      end
+
+      def read_float
+        read(4).unpack(Formats::FLOAT_FORMAT).first
+      rescue RangeError => e
+        raise DecodingError, "Not enough bytes available to decode a float: #{e.message}", e.backtrace
+      end
+
+      def read_signed_int
+        n = read_int
+        return n if n <= 0x7fffffff
+        n - 0xffffffff - 1
+      rescue RangeError => e
+        raise DecodingError, "Not enough bytes available to decode an int: #{e.message}", e.backtrace
+      end
+      
+      def read_unsigned_short
+        read_short
+      rescue RangeError => e
+        raise DecodingError, "Not enough bytes available to decode a short: #{e.message}", e.backtrace
+      end
+
+      def read_string
+        length = read_unsigned_short
+        string = read(length)
+        string.force_encoding(::Encoding::UTF_8)
+        string
+      rescue RangeError => e
+        raise DecodingError, "Not enough bytes available to decode a string: #{e.message}", e.backtrace
+      end
+
+      def read_long_string
+        length = read_signed_int
+        string = read(length)
+        string.force_encoding(::Encoding::UTF_8)
+        string
+      rescue RangeError => e
+        raise DecodingError, "Not enough bytes available to decode a long string: #{e.message}", e.backtrace
+      end
+
+      def read_uuid(impl=Uuid)
+        impl.new(read_varint(16, false))
+      rescue DecodingError => e
+        raise DecodingError, "Not enough bytes available to decode a UUID: #{e.message}", e.backtrace
+      end
+
+      def read_string_list
+        size = read_unsigned_short
+        Array.new(size) { read_string }
+      end
+
+      def read_bytes
+        size = read_signed_int
+        return nil if size & 0x80000000 == 0x80000000
+        read(size)
+      rescue RangeError => e
+        raise DecodingError, "Not enough bytes available to decode a bytes: #{e.message}", e.backtrace
+      end
+
+      def read_short_bytes
+        size = read_unsigned_short
+        return nil if size & 0x8000 == 0x8000
+        read(size)
+      rescue RangeError => e
+        raise DecodingError, "Not enough bytes available to decode a short bytes: #{e.message}", e.backtrace
+      end
+
+      def read_option
+        id = read_unsigned_short
+        value = nil
+        if block_given?
+          value = yield id, self
+        end
+        [id, value]
+      end
+
+      def read_inet
+        size = read_byte
+        ip_addr = IPAddr.new_ntoh(read(size))
+        port = read_int
+        [ip_addr, port]
+      rescue RangeError => e
+        raise DecodingError, "Not enough bytes available to decode an INET: #{e.message}", e.backtrace
+      end
+
+      def read_consistency
+        index = read_unsigned_short
+        raise DecodingError, "Unknown consistency index #{index}" if index >= CONSISTENCIES.size || CONSISTENCIES[index].nil?
+        CONSISTENCIES[index]
+      end
+
+      def read_string_map
+        map = {}
+        map_size = read_unsigned_short
+        map_size.times do
+          key = read_string
+          map[key] = read_string
+        end
+        map
+      end
+
+      def read_string_multimap
+        map = {}
+        map_size = read_unsigned_short
+        map_size.times do
+          key = read_string
+          map[key] = read_string_list
+        end
+        map
+      end
+
+      def append_int(n)
+        append([n].pack(Formats::INT_FORMAT))
+      end
+
+      def append_short(n)
+        append([n].pack(Formats::SHORT_FORMAT))
+      end
+
+      def append_string(str)
+        str = str.to_s
+        append_short(str.bytesize)
+        append(str)
+      end
+
+      def append_long_string(str)
+        append_int(str.bytesize)
+        append(str)
+      end
+
+      def append_uuid(uuid)
+        v = uuid.value
+        append_int((v >> 96) & 0xffffffff)
+        append_int((v >> 64) & 0xffffffff)
+        append_int((v >> 32) & 0xffffffff)
+        append_int((v >>  0) & 0xffffffff)
+      end
+
+      def append_string_list(strs)
+        append_short(strs.size)
+        strs.each do |str|
+          append_string(str)
+        end
+        self
+      end
+
+      def append_bytes(bytes)
+        if bytes
+          append_int(bytes.bytesize)
+          append(bytes)
+        else
+          append_int(-1)
+        end
+      end
+
+      def append_short_bytes(bytes)
+        if bytes
+          append_short(bytes.bytesize)
+          append(bytes)
+        else
+          append_short(-1)
+        end
+      end
+
+      def append_consistency(consistency)
+        index = CONSISTENCIES.index(consistency)
+        raise EncodingError, %(Unknown consistency "#{consistency}") if index.nil? || CONSISTENCIES[index].nil?
+        append_short(index)
+      end
+
+      def append_string_map(map)
+        append_short(map.size)
+        map.each do |key, value|
+          append_string(key)
+          append_string(value)
+        end
+        self
+      end
+
+      def append_long(n)
+        top = n >> 32
+        bottom = n & 0xffffffff
+        append_int(top)
+        append_int(bottom)
+      end
+
+      def append_varint(n)
+        num = n
+        bytes = []
+        until num == 0
+          bytes << (num & 0xff)
+          num = num >> 8
+          break if num == -1
+        end
+        append(bytes.reverse.pack(Formats::BYTES_FORMAT))
+      end
+
+      def append_decimal(n)
+        sign, number_string, _, size = n.split
+        num = number_string.to_i
+        raw = self.class.new.append_varint(sign * num)
+        append_int(number_string.length - size)
+        append(raw)
+      end
+
+      def append_double(n)
+        append([n].pack(Formats::DOUBLE_FORMAT))
+      end
+
+      def append_float(n)
+        append([n].pack(Formats::FLOAT_FORMAT))
+      end
+
+      private
+
+      MINUS = '-'.freeze
+      ZERO = '0'.freeze
+      DECIMAL_POINT = '.'.freeze
+    end
+  end
+end

data/lib/cql/protocol/cql_protocol_handler.rb

@@ -26,7 +26,7 @@ module Cql
         @connection.on_data(&method(:receive_data))
         @connection.on_closed(&method(:socket_closed))
         @promises = Array.new(128) { nil }
-        @read_buffer = ByteBuffer.new
+        @read_buffer = CqlByteBuffer.new
         @frame_encoder = FrameEncoder.new(protocol_version, @compressor)
         @frame_decoder = FrameDecoder.new(@compressor)
         @current_frame = FrameDecoder::NULL_FRAME
@@ -129,7 +129,7 @@ module Cql
           end
         else
           @lock.synchronize do
-            promise.encode_frame!
+            promise.encode_frame
             @request_queue_in << promise
           end
         end
@@ -173,7 +173,7 @@ module Cql
           end
         end
 
-        def encode_frame!
+        def encode_frame
           @frame = @frame_encoder.encode_frame(@request)
         end
       end

data/lib/cql/protocol/frame_decoder.rb

@@ -44,8 +44,8 @@ module Cql
           size = buffer.size
         end
         extra_length = buffer.length - size 
-        trace_id = tracing == 2 ? Decoding.read_uuid!(buffer) : nil
-        response = Response.decode!(opcode, protocol_version, buffer, size, trace_id)
+        trace_id = tracing == 2 ? buffer.read_uuid : nil
+        response = Response.decode(opcode, protocol_version, buffer, size, trace_id)
         if buffer.length > extra_length
           buffer.discard(buffer.length - extra_length)
         end
@@ -55,7 +55,7 @@ module Cql
       def decompress(buffer, size)
         if @compressor
           compressed_body = buffer.read(size)
-          ByteBuffer.new(@compressor.decompress(compressed_body))
+          CqlByteBuffer.new(@compressor.decompress(compressed_body))
         else
           raise UnexpectedCompressionError, 'Compressed frame received, but no compressor configured'
         end

data/lib/cql/protocol/frame_encoder.rb

@@ -11,9 +11,9 @@ module Cql
 
       def encode_frame(request, stream_id=0, buffer=nil)
         raise InvalidStreamIdError, 'The stream ID must be between 0 and 127' unless 0 <= stream_id && stream_id < 128
-        buffer ||= ByteBuffer.new
+        buffer ||= CqlByteBuffer.new
         flags = request.trace? ? 2 : 0
-        body = request.write(@protocol_version, ByteBuffer.new)
+        body = request.write(@protocol_version, CqlByteBuffer.new)
         if @compressor && request.compressable? && @compressor.compress?(body)
           flags |= 1
           body = @compressor.compress(body)

data/lib/cql/protocol/request.rb

@@ -3,8 +3,6 @@
 module Cql
   module Protocol
     class Request
-      include Encoding
-
       attr_reader :opcode, :trace
 
       def initialize(opcode, trace=false)

data/lib/cql/protocol/requests/auth_response_request.rb

@@ -10,8 +10,8 @@ module Cql
         @token = token
       end
 
-      def write(protocol_version, io)
-        write_bytes(io, @token)
+      def write(protocol_version, buffer)
+        buffer.append_bytes(@token)
       end
 
       def to_s

data/lib/cql/protocol/requests/batch_request.rb

@@ -13,31 +13,31 @@ module Cql
         super(0x0D, trace)
         @type = type
         @part_count = 0
-        @encoded_queries = ByteBuffer.new
+        @encoded_queries = CqlByteBuffer.new
         @consistency = consistency
       end
 
       def add_query(cql, values=nil, type_hints=nil)
-        @encoded_queries << QUERY_KIND
-        write_long_string(@encoded_queries, cql)
+        @encoded_queries.append(QUERY_KIND)
+        @encoded_queries.append_long_string(cql)
         QueryRequest.encode_values(@encoded_queries, values, type_hints)
         @part_count += 1
         nil
       end
 
       def add_prepared(id, metadata, values)
-        @encoded_queries << PREPARED_KIND
-        write_short_bytes(@encoded_queries, id)
+        @encoded_queries.append(PREPARED_KIND)
+        @encoded_queries.append_short_bytes(id)
         ExecuteRequest.encode_values(@encoded_queries, metadata, values)
         @part_count += 1
         nil
       end
 
-      def write(protocol_version, io)
-        io << @type.chr
-        write_short(io, @part_count)
-        io << @encoded_queries
-        write_consistency(io, @consistency)
+      def write(protocol_version, buffer)
+        buffer.append(@type.chr)
+        buffer.append_short(@part_count)
+        buffer.append(@encoded_queries)
+        buffer.append_consistency(@consistency)
       end
 
       def to_s

data/lib/cql/protocol/requests/credentials_request.rb

@@ -10,8 +10,8 @@ module Cql
         @credentials = credentials.dup.freeze
       end
 
-      def write(protocol_version, io)
-        write_string_map(io, @credentials)
+      def write(protocol_version, buffer)
+        buffer.append_string_map(@credentials)
       end
 
       def to_s

data/lib/cql/protocol/requests/execute_request.rb

@@ -19,31 +19,31 @@ module Cql
         @serial_consistency = serial_consistency
         @page_size = page_size
         @paging_state = paging_state
-        @encoded_values = self.class.encode_values('', @metadata, @values)
+        @encoded_values = self.class.encode_values(CqlByteBuffer.new, @metadata, @values)
       end
 
-      def write(protocol_version, io)
-        write_short_bytes(io, @id)
+      def write(protocol_version, buffer)
+        buffer.append_short_bytes(@id)
         if protocol_version > 1
-          write_consistency(io, @consistency)
+          buffer.append_consistency(@consistency)
           flags  = 0
           flags |= 0x01 if @values.size > 0
           flags |= 0x02 unless @request_metadata
           flags |= 0x04 if @page_size
           flags |= 0x08 if @paging_state
           flags |= 0x10 if @serial_consistency
-          io << flags.chr
+          buffer.append(flags.chr)
           if @values.size > 0
-            io << @encoded_values
+            buffer.append(@encoded_values)
           end
-          write_int(io, @page_size) if @page_size
-          write_bytes(io, @paging_state) if @paging_state
-          write_consistency(io, @serial_consistency) if @serial_consistency
-          io
+          buffer.append_int(@page_size) if @page_size
+          buffer.append_bytes(@paging_state) if @paging_state
+          buffer.append_consistency(@serial_consistency) if @serial_consistency
         else
-          io << @encoded_values
-          write_consistency(io, @consistency)
+          buffer.append(@encoded_values)
+          buffer.append_consistency(@consistency)
         end
+        buffer
       end
 
       def to_s
@@ -71,7 +71,7 @@ module Cql
       end
 
       def self.encode_values(buffer, metadata, values)
-        Encoding.write_short(buffer, metadata.size)
+        buffer.append_short(metadata.size)
         metadata.each_with_index do |(_, _, _, type), index|
           TYPE_CONVERTER.to_bytes(buffer, type, values[index])
         end