cassandra-driver 3.0.0.beta.1-java → 3.0.0-java

data/lib/cassandra/protocol/cql_byte_buffer.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -19,8 +19,19 @@
 module Cassandra
   module Protocol
     class CqlByteBuffer < Ione::ByteBuffer
+      # @private
+      MINUS = '-'.freeze
+      # @private
+      ZERO = '0'.freeze
+      # @private
+      DECIMAL_POINT = '.'.freeze
+      # @private
+      FLOAT_STRING_FORMAT = 'F'.freeze
+      # @private
+      NO_CHAR = ''.freeze
+
       def inspect
-        "#<#{self.class.name}:0x#{self.object_id.to_s(16)} #{to_str.inspect}>"
+        "#<#{self.class.name}:0x#{object_id.to_s(16)} #{to_str.inspect}>"
       end
 
       def read_unsigned_byte
@@ -28,22 +39,20 @@ module Cassandra
       rescue RangeError => e
         raise Errors::DecodingError, e.message, e.backtrace
       end
-      
-      def read_varint(len=bytesize, signed=true)
+
+      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 -= 2**(bytes.length * 8) if signed && bytes.getbyte(0) & 0x80 == 0x80
         n
       rescue RangeError => e
         raise Errors::DecodingError, e.message, e.backtrace
       end
 
-      def read_decimal(len=bytesize)
+      def read_decimal(len = bytesize)
         size = read_signed_int
         number_string = read_varint(len - 4).to_s
         if number_string.length <= size
@@ -58,7 +67,8 @@ module Cassandra
         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]
+          fraction_string <<
+            number_string[number_string.length - size, number_string.length]
         end
         BigDecimal.new(fraction_string)
       rescue Errors::DecodingError => e
@@ -78,13 +88,15 @@ module Cassandra
       def read_double
         read(8).unpack(Formats::DOUBLE_FORMAT).first
       rescue RangeError => e
-        raise Errors::DecodingError, "Not enough bytes available to decode a double: #{e.message}", e.backtrace
+        raise Errors::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 Errors::DecodingError, "Not enough bytes available to decode a float: #{e.message}", e.backtrace
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a float: #{e.message}", e.backtrace
       end
 
       def read_signed_int
@@ -92,13 +104,15 @@ module Cassandra
         return n if n <= 0x7fffffff
         n - 0xffffffff - 1
       rescue RangeError => e
-        raise Errors::DecodingError, "Not enough bytes available to decode an int: #{e.message}", e.backtrace
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode an int: #{e.message}", e.backtrace
       end
-      
+
       def read_unsigned_short
         read_short
       rescue RangeError => e
-        raise Errors::DecodingError, "Not enough bytes available to decode a short: #{e.message}", e.backtrace
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a short: #{e.message}", e.backtrace
       end
 
       def read_string
@@ -107,7 +121,8 @@ module Cassandra
         string.force_encoding(::Encoding::UTF_8)
         string
       rescue RangeError => e
-        raise Errors::DecodingError, "Not enough bytes available to decode a string: #{e.message}", e.backtrace
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a string: #{e.message}", e.backtrace
       end
 
       def read_long_string
@@ -116,13 +131,16 @@ module Cassandra
         string.force_encoding(::Encoding::UTF_8)
         string
       rescue RangeError => e
-        raise Errors::DecodingError, "Not enough bytes available to decode a long string: #{e.message}", e.backtrace
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a long string: #{e.message}",
+              e.backtrace
       end
 
-      def read_uuid(impl=Uuid)
+      def read_uuid(impl = Uuid)
         impl.new(read_varint(16, false))
       rescue Errors::DecodingError => e
-        raise Errors::DecodingError, "Not enough bytes available to decode a UUID: #{e.message}", e.backtrace
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a UUID: #{e.message}", e.backtrace
       end
 
       def read_string_list
@@ -135,21 +153,22 @@ module Cassandra
         return nil if size & 0x80000000 == 0x80000000
         read(size)
       rescue RangeError => e
-        raise Errors::DecodingError, "Not enough bytes available to decode a bytes: #{e.message}", e.backtrace
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a bytes: #{e.message}", e.backtrace
       end
 
       def read_short_bytes
         read(read_unsigned_short)
       rescue RangeError => e
-        raise Errors::DecodingError, "Not enough bytes available to decode a short bytes: #{e.message}", e.backtrace
+        raise Errors::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
+        value = yield id, self if block_given?
         [id, value]
       end
 
@@ -159,12 +178,16 @@ module Cassandra
         port = read_int
         [ip_addr, port]
       rescue RangeError => e
-        raise Errors::DecodingError, "Not enough bytes available to decode an INET: #{e.message}", e.backtrace
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode an INET: #{e.message}",
+              e.backtrace
       end
 
       def read_consistency
         index = read_unsigned_short
-        raise Errors::DecodingError, "Unknown consistency index #{index}" if index >= CONSISTENCIES.size || CONSISTENCIES[index].nil?
+        if index >= CONSISTENCIES.size || CONSISTENCIES[index].nil?
+          raise Errors::DecodingError, "Unknown consistency index #{index}"
+        end
         CONSISTENCIES[index]
       end
 
@@ -203,7 +226,8 @@ module Cassandra
         return n if n <= 0x7fff
         n - 0xffff - 1
       rescue RangeError => e
-        raise Errors::DecodingError, "Not enough bytes available to decode a smallint: #{e.message}", e.backtrace
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a smallint: #{e.message}", e.backtrace
       end
 
       def read_tinyint
@@ -211,7 +235,8 @@ module Cassandra
         return n if n <= 0x7f
         n - 0xff - 1
       rescue RangeError => e
-        raise Errors::DecodingError, "Not enough bytes available to decode a tinyint: #{e.message}", e.backtrace
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a tinyint: #{e.message}", e.backtrace
       end
 
       def append_tinyint(n)
@@ -246,7 +271,7 @@ module Cassandra
         append_int((v >> 96) & 0xffffffff)
         append_int((v >> 64) & 0xffffffff)
         append_int((v >> 32) & 0xffffffff)
-        append_int((v >>  0) & 0xffffffff)
+        append_int((v >> 0) & 0xffffffff)
       end
 
       def append_string_list(strs)
@@ -299,10 +324,6 @@ module Cassandra
         self
       end
 
-      def append_timestamp(timestamp)
-        append_long(timestamp.tv_sec * 1000000 + timestamp.tv_usec)
-      end
-
       def append_long(n)
         top = n >> 32
         bottom = n & 0xffffffff
@@ -313,10 +334,11 @@ module Cassandra
       def append_varint(n)
         num = n
         bytes = []
-        begin
+        loop do
           bytes << (num & 0xff)
           num >>= 8
-        end until (num == 0 || num == -1) && (bytes.last[7] == num[7])
+          break if (num == 0 || num == -1) && (bytes.last[7] == num[7])
+        end
         append(bytes.reverse.pack(Formats::BYTES_FORMAT))
       end
 
@@ -342,15 +364,7 @@ module Cassandra
       def eql?(other)
         other.eql?(to_str)
       end
-      alias_method :==, :eql?
-
-      private
-
-      MINUS = '-'.freeze
-      ZERO = '0'.freeze
-      DECIMAL_POINT = '.'.freeze
-      FLOAT_STRING_FORMAT = 'F'.freeze
-      NO_CHAR = ''.freeze
+      alias == eql?
     end
   end
-end
+end

data/lib/cassandra/protocol/cql_protocol_handler.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -32,22 +32,31 @@ module Cassandra
     #   puts "These options are supported: #{response.options}"
     class CqlProtocolHandler
       # @return [String] the current keyspace for the underlying connection
-      attr_reader :keyspace, :error
-
-      def initialize(connection, scheduler, protocol_version, compressor=nil, heartbeat_interval = 30, idle_timeout = 60)
+      attr_reader :keyspace
+
+      # @return [Exception] outstanding error, from a failed connection.
+      attr_reader :error
+
+      # @return [Integer] the version of the protocol to use in communicating with C*.
+      attr_reader :protocol_version
+
+      def initialize(connection,
+                     scheduler,
+                     protocol_version,
+                     compressor = nil,
+                     heartbeat_interval = 30,
+                     idle_timeout = 60,
+                     requests_per_connection = 128)
+        @protocol_version = protocol_version
         @connection = connection
         @scheduler = scheduler
         @compressor = compressor
         @connection.on_data(&method(:receive_data))
         @connection.on_closed(&method(:socket_closed))
 
-        if protocol_version > 2
-          @streams = Array.new(1024) {|i| i}
-        else
-          @streams = Array.new(128) {|i| i}
-        end
+        @streams = Array.new(requests_per_connection) {|i| i}
 
-        @promises = Hash.new
+        @promises = {}
 
         if protocol_version > 3
           @frame_encoder = V4::Encoder.new(@compressor, protocol_version)
@@ -147,20 +156,20 @@ module Cassandra
       # closes the futures of all active requests will be failed with the error
       # that caused the connection to close, or nil.
       #
-      # When `timeout` is specified the future will fail with {Cassandra::Errors::TimeoutError}
-      # after that many seconds have passed. If a response arrives after that
-      # time it will be lost. If a response never arrives for the request the
-      # channel occupied by the request will _not_ be reused.
+      # When `timeout` is specified the future will fail with
+      # {Cassandra::Errors::TimeoutError} after that many seconds have passed. If a
+      # response arrives after that time it will be lost. If a response never arrives
+      # for the request the channel occupied by the request will _not_ be reused.
       #
       # @param [Cassandra::Protocol::Request] request
       # @param [Float] timeout an optional number of seconds to wait until
       #   failing the request
       # @return [Ione::Future<Cassandra::Protocol::Response>] a future that resolves to
       #   the response
-      def send_request(request, timeout=nil, with_heartbeat = true)
+      def send_request(request, timeout = nil, with_heartbeat = true)
         return Ione::Future.failed(Errors::IOError.new('Connection closed')) if closed?
         schedule_heartbeat if with_heartbeat
-        promise = RequestPromise.new(request)
+        promise = RequestPromise.new(request, timeout)
         id = nil
         @lock.lock
         begin
@@ -171,9 +180,7 @@ module Cassandra
           @lock.unlock
         end
         if id
-          @connection.write do |buffer|
-            @frame_encoder.encode(buffer, request, id)
-          end
+          write_request(id, promise)
         else
           @lock.lock
           begin
@@ -182,11 +189,6 @@ module Cassandra
             @lock.unlock
           end
         end
-        if timeout
-          @scheduler.schedule_timer(timeout).on_value do
-            promise.time_out!
-          end
-        end
         promise.future
       end
 
@@ -234,38 +236,39 @@ module Cassandra
         ensure
           @lock.unlock
         end
-        if response.is_a?(Protocol::SetKeyspaceResultResponse)
-          @keyspace = response.keyspace
-        end
-        if response.is_a?(Protocol::SchemaChangeResultResponse) && response.change == 'DROPPED' && response.keyspace == @keyspace && response.target == Protocol::Constants::SCHEMA_CHANGE_TARGET_KEYSPACE
+        @keyspace = response.keyspace if response.is_a?(Protocol::SetKeyspaceResultResponse)
+        if response.is_a?(Protocol::SchemaChangeResultResponse) &&
+           response.change == 'DROPPED' &&
+           response.keyspace == @keyspace &&
+           response.target == Protocol::Constants::SCHEMA_CHANGE_TARGET_KEYSPACE
           @keyspace = nil
         end
         flush_request_queue
-        unless promise.timed_out?
-          promise.fulfill(response)
-        end
+        promise.fulfill(response) unless promise.timed_out?
       end
 
       private
 
       # @private
       class RequestPromise < Ione::Promise
-        attr_reader :request
+        extend AttrBoolean
 
-        def initialize(request)
+        attr_reader :request, :timeout
+        attr_boolean :timed_out
+
+        def initialize(request, timeout)
           @request = request
+          @timeout = timeout
           @timed_out = false
           super()
         end
 
-        def timed_out?
-          @timed_out
-        end
-
         def time_out!
           unless future.completed?
             @timed_out = true
+            # rubocop:disable Style/SignalException
             fail(Errors::TimeoutError.new('Timed out'))
+            # rubocop:enable Style/SignalException
           end
         end
       end
@@ -285,28 +288,32 @@ module Cassandra
         ensure
           @lock.unlock
         end
-        while true
+        loop do
           id = nil
           promise = nil
           @lock.lock
           begin
             if @request_queue_out.any? && (id = next_stream_id)
               promise = @request_queue_out.shift
-              if promise.timed_out?
-                next
-              else
-                @promises[id] = promise
-              end
+              next if promise.timed_out?
+              @promises[id] = promise
             end
           ensure
             @lock.unlock
           end
-          if id
-            @connection.write do |buffer|
-              @frame_encoder.encode(buffer, promise.request, id)
-            end
-          else
-            break
+
+          break unless id
+          write_request(id, promise)
+        end
+      end
+
+      def write_request(id, request_promise)
+        @connection.write do |buffer|
+          @frame_encoder.encode(buffer, request_promise.request, id)
+        end
+        if request_promise.timeout
+          @scheduler.schedule_timer(request_promise.timeout).on_value do
+            request_promise.time_out!
           end
         end
       end
@@ -382,11 +389,7 @@ module Cassandra
       end
 
       def next_stream_id
-        if (stream_id = @streams.shift)
-          stream_id
-        else
-          nil
-        end
+        @streams.shift
       end
 
       HEARTBEAT  = OptionsRequest.new