cql-rb 1.0.6 → 1.1.0.pre0

data/lib/cql/protocol.rb

@@ -66,3 +66,4 @@ require 'cql/protocol/requests/query_request'
 require 'cql/protocol/requests/prepare_request'
 require 'cql/protocol/requests/execute_request'
 require 'cql/protocol/response_frame'
+require 'cql/protocol/cql_protocol_handler'

data/lib/cql/protocol/cql_protocol_handler.rb

@@ -0,0 +1,201 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    # This class wraps a single connection and translates between request/
+    # response frames and raw bytes.
+    #
+    # You send requests with #send_request, and receive responses through the
+    # returned future.
+    #
+    # Instances of this class are thread safe.
+    #
+    # @examle Sending an OPTIONS request
+    #   future = protocol_handler.send_request(Cql::Protocol::OptionsRequest.new)
+    #   response = future.get
+    #   puts "These options are supported: #{response.options}"
+    #
+    class CqlProtocolHandler
+      # @return [String] the current keyspace for the underlying connection
+      attr_reader :keyspace
+
+      def initialize(connection)
+        @connection = connection
+        @connection.on_data(&method(:receive_data))
+        @connection.on_closed(&method(:socket_closed))
+        @responses = Array.new(128) { nil }
+        @read_buffer = ByteBuffer.new
+        @current_frame = Protocol::ResponseFrame.new(@read_buffer)
+        @request_queue_in = []
+        @request_queue_out = []
+        @event_listeners = []
+        @lock = Mutex.new
+        @closed_future = Future.new
+        @keyspace = nil
+      end
+
+      # @return [true, false] true if the underlying connection is connected
+      def connected?
+        @connection.connected?
+      end
+
+      # @return [true, false] true if the underlying connection is closed
+      def closed?
+        @connection.closed?
+      end
+
+      # Register to receive notification when the underlying connection has
+      # closed. If the connection closed abruptly the error will be passed
+      # to the listener, otherwise it will not receive any parameters.
+      #
+      # @yieldparam error [nil, Error] the error that caused the connection to
+      #   close, if any
+      def on_closed(&listener)
+        @closed_future.on_complete(&listener)
+        @closed_future.on_failure(&listener)
+      end
+
+      # Register to receive server sent events, like schema changes, nodes going
+      # up or down, etc. To actually receive events you also need to send a
+      # REGISTER request for the events you wish to receive.
+      #
+      # @yieldparam event [Cql::Protocol::EventResponse] an event sent by the server
+      def on_event(&listener)
+        @lock.synchronize do
+          @event_listeners << listener
+        end
+      end
+
+      # Serializes and send a request over the underlying connection.
+      #
+      # Returns a future that will resolve to the response. When the connection
+      # closes the futures of all active requests will be failed with the error
+      # that caused the connection to close, or nil
+      #
+      # @return [Cql::Future<Cql::Protocol::Response>] a future that resolves to
+      #   the response
+      def send_request(request)
+        return Future.failed(NotConnectedError.new) if closed?
+        future = Future.new
+        id = nil
+        @lock.synchronize do
+          if (id = next_stream_id)
+            @responses[id] = future
+          end
+        end
+        if id
+          @connection.write do |buffer|
+            request.encode_frame(id, buffer)
+          end
+        else
+          @lock.synchronize do
+            @request_queue_in << [request.encode_frame(0), future]
+          end
+        end
+        future
+      end
+
+      # Closes the underlying connection.
+      #
+      # @return [Cql::Future] a future that completes when the connection has closed
+      def close
+        @connection.close
+        @closed_future
+      end
+
+      private
+
+      def receive_data(data)
+        @current_frame << data
+        while @current_frame.complete?
+          id = @current_frame.stream_id
+          if id == -1
+            notify_event_listeners(@current_frame.body)
+          else
+            complete_request(id, @current_frame.body)
+          end
+          @current_frame = Protocol::ResponseFrame.new(@read_buffer)
+          flush_request_queue
+        end
+      end
+
+      def notify_event_listeners(event_response)
+        return if @event_listeners.empty?
+        @lock.synchronize do
+          @event_listeners.each do |listener|
+            listener.call(@current_frame.body) rescue nil
+          end
+        end
+      end
+
+      def complete_request(id, response)
+        future = @lock.synchronize do
+          future = @responses[id]
+          @responses[id] = nil
+          future
+        end
+        if response.is_a?(Protocol::SetKeyspaceResultResponse)
+          @keyspace = response.keyspace
+        end
+        future.complete!(response)
+      end
+
+      def flush_request_queue
+        @lock.synchronize do
+          if @request_queue_out.empty? && !@request_queue_in.empty?
+            @request_queue_out = @request_queue_in
+            @request_queue_in = []
+          end
+        end
+        while true
+          id = nil
+          request_buffer = nil
+          @lock.synchronize do
+            if @request_queue_out.any? && (id = next_stream_id)
+              request_buffer, future = @request_queue_out.shift
+              @responses[id] = future
+            end
+          end
+          if id
+            Protocol::Request.change_stream_id(id, request_buffer)
+            @connection.write(request_buffer)
+          else
+            break
+          end
+        end
+      end
+
+      def socket_closed(cause)
+        request_failure_cause = cause || Io::ConnectionClosedError.new
+        @lock.synchronize do
+          @responses.each_with_index do |future, i|
+            if future
+              @responses[i].fail!(request_failure_cause)
+              @responses[i] = nil
+            end
+          end
+          @request_queue_in.each do |_, future|
+            future.fail!(request_failure_cause)
+          end
+          @request_queue_in.clear
+          @request_queue_out.each do |_, future|
+            future.fail!(request_failure_cause)
+          end
+          @request_queue_out.clear
+          if cause
+            @closed_future.fail!(cause)
+          else
+            @closed_future.complete!
+          end
+        end
+      end
+
+      def next_stream_id
+        @responses.each_with_index do |task, index|
+          return index if task.nil?
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/cql/protocol/decoding.rb

@@ -31,34 +31,15 @@ module Cql
       def read_decimal!(buffer, length=buffer.length)
         size = read_int!(buffer)
         number_string = read_varint!(buffer, length - 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
+        fraction_string = number_string[0, number_string.length - size] << DECIMAL_POINT << number_string[number_string.length - size, number_string.length]
         BigDecimal.new(fraction_string)
       rescue RangeError => e
         raise DecodingError, e.message, e.backtrace
       end
 
       def read_long!(buffer)
-        hi, lo = buffer.read(8).unpack(Formats::TWO_INTS_FORMAT)
-        if (hi > 0x7fffffff)
-          hi ^= 0xffffffff
-          lo ^= 0xffffffff
-          0 - (hi << 32) - lo - 1
-        else
-          (hi << 32) + lo
-        end
+        top, bottom = buffer.read(8).unpack(Formats::TWO_INTS_FORMAT)
+        (top << 32) | bottom
       rescue RangeError => e
         raise DecodingError, e.message, e.backtrace
       end
@@ -76,11 +57,7 @@ module Cql
       end
 
       def read_int!(buffer)
-        val = buffer.read_int
-        if (val > 0x7fffffff)
-          val = 0 - ((val - 1) ^ 0xffffffff)
-        end
-        val
+        buffer.read_int
       rescue RangeError => e
         raise DecodingError, "Not enough bytes available to decode an int: #{e.message}", e.backtrace
       end
@@ -109,8 +86,8 @@ module Cql
         raise DecodingError, "Not enough bytes available to decode a long string: #{e.message}", e.backtrace
       end
 
-      def read_uuid!(buffer)
-        Uuid.new(read_varint!(buffer, 16, false))
+      def read_uuid!(buffer, impl=Uuid)
+        impl.new(read_varint!(buffer, 16, false))
       rescue RangeError => e
         raise DecodingError, "Not enough bytes available to decode a UUID: #{e.message}", e.backtrace
       end
@@ -184,8 +161,6 @@ module Cql
 
       private
 
-      MINUS = '-'.freeze
-      ZERO = '0'.freeze
       DECIMAL_POINT = '.'.freeze
     end
   end

data/lib/cql/protocol/encoding.rb

@@ -27,11 +27,7 @@ module Cql
       end
 
       def write_uuid(buffer, uuid)
-        v = uuid.value
-        write_int(buffer, (v >> 96) & 0xffffffff)
-        write_int(buffer, (v >> 64) & 0xffffffff)
-        write_int(buffer, (v >> 32) & 0xffffffff)
-        write_int(buffer, v & 0xffffffff)
+        write_varint(buffer, uuid.value)
       end
 
       def write_string_list(buffer, strs)

data/lib/cql/protocol/request.rb

@@ -19,6 +19,10 @@ module Cql
         buffer.update(offset + 4, [(buffer.bytesize - offset - 8)].pack(Formats::INT_FORMAT))
         buffer
       end
+
+      def self.change_stream_id(new_stream_id, buffer, offset=0)
+        buffer.update(offset + 2, new_stream_id.chr)
+      end
     end
   end
 end

data/lib/cql/protocol/responses/schema_change_result_response.rb

@@ -13,6 +13,21 @@ module Cql
         new(read_string!(buffer), read_string!(buffer), read_string!(buffer))
       end
 
+      def eql?(other)
+        self.change == other.change && self.keyspace == other.keyspace && self.table == other.table
+      end
+      alias_method :==, :eql?
+
+      def hash
+        @h ||= begin
+          h = 0
+          h = ((h & 0xffffffff) * 31) ^ @change.hash
+          h = ((h & 0xffffffff) * 31) ^ @keyspace.hash
+          h = ((h & 0xffffffff) * 31) ^ @table.hash
+          h
+        end
+      end
+
       def to_s
         %(RESULT SCHEMA_CHANGE #@change "#@keyspace" "#@table")
       end

data/lib/cql/protocol/type_converter.rb

@@ -36,35 +36,27 @@ module Cql
       def to_bytes(io, type, value, size_bytes=4)
         case type
         when Array
-          unless value.nil? || value.is_a?(Enumerable)
+          unless value.is_a?(Enumerable)
             raise InvalidValueError, 'Value for collection must be enumerable'
           end
           case type.first
           when :list, :set
             _, sub_type = type
-            if value
-              raw = ''
-              write_short(raw, value.size)
-              value.each do |element|
-                to_bytes(raw, sub_type, element, 2)
-              end
-              write_bytes(io, raw)
-            else
-              nil_to_bytes(io, size_bytes)
+            raw = ''
+            write_short(raw, value.size)
+            value.each do |element|
+              to_bytes(raw, sub_type, element, 2)
             end
+            write_bytes(io, raw)
           when :map
             _, key_type, value_type = type
-            if value
-              raw = ''
-              write_short(raw, value.size)
-              value.each do |key, value|
-                to_bytes(raw, key_type, key, 2)
-                to_bytes(raw, value_type, value, 2)
-              end
-              write_bytes(io, raw)
-            else
-              nil_to_bytes(io, size_bytes)
+            raw = ''
+            write_short(raw, value.size)
+            value.each do |key, value|
+              to_bytes(raw, key_type, key, 2)
+              to_bytes(raw, value_type, value, 2)
             end
+            write_bytes(io, raw)
           else
             raise UnsupportedColumnTypeError, %(Unsupported column collection type: #{type.first})
           end
@@ -96,7 +88,7 @@ module Cql
           :varchar => method(:bytes_to_varchar),
           :text => method(:bytes_to_varchar),
           :varint => method(:bytes_to_varint),
-          :timeuuid => method(:bytes_to_uuid),
+          :timeuuid => method(:bytes_to_timeuuid),
           :uuid => method(:bytes_to_uuid),
           :inet => method(:bytes_to_inet),
         }
@@ -108,7 +100,6 @@ module Cql
           :bigint => method(:bigint_to_bytes),
           :blob => method(:blob_to_bytes),
           :boolean => method(:boolean_to_bytes),
-          :counter => method(:bigint_to_bytes),
           :decimal => method(:decimal_to_bytes),
           :double => method(:double_to_bytes),
           :float => method(:float_to_bytes),
@@ -197,6 +188,11 @@ module Cql
         read_uuid!(buffer)
       end
 
+      def bytes_to_timeuuid(buffer, size_bytes)
+        return nil unless read_size(buffer, size_bytes)
+        read_uuid!(buffer, TimeUuid)
+      end
+
       def bytes_to_inet(buffer, size_bytes)
         size = read_size(buffer, size_bytes)
         return nil unless size
@@ -233,7 +229,7 @@ module Cql
       end
 
       def ascii_to_bytes(io, value, size_bytes)
-        v = value && value.encode(::Encoding::ASCII)
+        v = value.encode(::Encoding::ASCII)
         if size_bytes == 4
           write_bytes(io, v)
         else
@@ -242,16 +238,16 @@ module Cql
       end
 
       def bigint_to_bytes(io, value, size_bytes)
-        if value
-          size_to_bytes(io, 8, size_bytes)
-          write_long(io, value)
+        if size_bytes == 4
+          write_int(io, 8)
         else
-          nil_to_bytes(io, size_bytes)
+          write_short(io, 8)
         end
+        write_long(io, value)
       end
 
       def blob_to_bytes(io, value, size_bytes)
-        v = value && value.encode(::Encoding::BINARY)
+        v = value.encode(::Encoding::BINARY)
         if size_bytes == 4
           write_bytes(io, v)
         else
@@ -260,16 +256,16 @@ module Cql
       end
 
       def boolean_to_bytes(io, value, size_bytes)
-        if !value.nil?
-          size_to_bytes(io, 1, size_bytes)
-          io << (value ? Constants::TRUE_BYTE : Constants::FALSE_BYTE)
+        if size_bytes == 4
+          write_int(io, 1)
         else
-          nil_to_bytes(io, size_bytes)
+          write_short(io, 1)
         end
+        io << (value ? Constants::TRUE_BYTE : Constants::FALSE_BYTE)
       end
 
       def decimal_to_bytes(io, value, size_bytes)
-        raw = value && write_decimal('', value)
+        raw = write_decimal('', value)
         if size_bytes == 4
           write_bytes(io, raw)
         else
@@ -278,43 +274,43 @@ module Cql
       end
 
       def double_to_bytes(io, value, size_bytes)
-        if value
-          size_to_bytes(io, 8, size_bytes)
-          write_double(io, value)
+        if size_bytes == 4
+          write_int(io, 8)
         else
-          nil_to_bytes(io, size_bytes)
+          write_short(io, 8)
         end
+        write_double(io, value)
       end
 
       def float_to_bytes(io, value, size_bytes)
-        if value
-          size_to_bytes(io, 4, size_bytes)
-          write_float(io, value)
+        if size_bytes == 4
+          write_int(io, 4)
         else
-          nil_to_bytes(io, size_bytes)
+          write_short(io, 4)
         end
+        write_float(io, value)
       end
 
       def inet_to_bytes(io, value, size_bytes)
-        if value
-          size_to_bytes(io, value.ipv6? ? 16 : 4, size_bytes)
-          io << value.hton
+        if size_bytes == 4
+          write_int(io, value.ipv6? ? 16 : 4)
         else
-          nil_to_bytes(io, size_bytes)
+          write_short(io, value.ipv6? ? 16 : 4)
         end
+        io << value.hton
       end
 
       def int_to_bytes(io, value, size_bytes)
-        if value
-          size_to_bytes(io, 4, size_bytes)
-          write_int(io, value)
+        if size_bytes == 4
+          write_int(io, 4)
         else
-          nil_to_bytes(io, size_bytes)
+          write_short(io, 4)
         end
+        write_int(io, value)
       end
 
       def varchar_to_bytes(io, value, size_bytes)
-        v = value && value.encode(::Encoding::UTF_8)
+        v = value.encode(::Encoding::UTF_8)
         if size_bytes == 4
           write_bytes(io, v)
         else
@@ -323,48 +319,32 @@ module Cql
       end
 
       def timestamp_to_bytes(io, value, size_bytes)
-        if value
-          ms = (value.to_f * 1000).to_i
-          size_to_bytes(io, 8, size_bytes)
-          write_long(io, ms)
+        ms = (value.to_f * 1000).to_i
+        if size_bytes == 4
+          write_int(io, 8)
         else
-          nil_to_bytes(io, size_bytes)
+          write_short(io, 8)
         end
+        write_long(io, ms)
       end
 
       def uuid_to_bytes(io, value, size_bytes)
-        if value
-          size_to_bytes(io, 16, size_bytes)
-          write_uuid(io, value)
+        if size_bytes == 4
+          write_int(io, 16)
         else
-          nil_to_bytes(io, size_bytes)
+          write_short(io, 16)
         end
+        write_uuid(io, value)
       end
 
       def varint_to_bytes(io, value, size_bytes)
-        raw = value && write_varint('', value)
+        raw = write_varint('', value)
         if size_bytes == 4
           write_bytes(io, raw)
         else
           write_short_bytes(io, raw)
         end
       end
-
-      def size_to_bytes(io, size, size_bytes)
-        if size_bytes == 4
-          write_int(io, size)
-        else
-          write_short(io, size)
-        end
-      end
-
-      def nil_to_bytes(io, size_bytes)
-        if size_bytes == 4
-          write_int(io, -1)
-        else
-          write_short(io, -1)
-        end
-      end
     end
   end
 end