cassandra-driver 1.0.0.beta.3-java → 1.0.0-java

data/lib/cassandra/execution/options.rb

@@ -39,14 +39,21 @@ module Cassandra
         timeout            = options[:timeout]
         serial_consistency = options[:serial_consistency]
 
-        raise ::ArgumentError, ":consistency must be one of #{CONSISTENCIES.inspect}, #{consistency.inspect} given" unless CONSISTENCIES.include?(consistency)
-        raise ::ArgumentError, ":serial_consistency must be one of #{SERIAL_CONSISTENCIES.inspect}, #{serial_consistency.inspect} given" if serial_consistency && !SERIAL_CONSISTENCIES.include?(serial_consistency)
+        Util.assert_one_of(CONSISTENCIES, consistency) { ":consistency must be one of #{CONSISTENCIES.inspect}, #{consistency.inspect} given" }
 
-        page_size = page_size && Integer(page_size)
-        timeout   = timeout   && Integer(timeout)
+        unless serial_consistency.nil?
+          Util.assert_one_of(SERIAL_CONSISTENCIES, serial_consistency) { ":serial_consistency must be one of #{SERIAL_CONSISTENCIES.inspect}, #{serial_consistency.inspect} given" }
+        end
 
-        raise ::ArgumentError, ":page_size must be greater than 0, #{page_size.inspect} given" if page_size && page_size <= 0
-        raise ::ArgumentError, ":timeout must be greater than 0, #{timeout.inspect} given" if timeout && timeout <= 0
+        unless page_size.nil?
+          page_size = options[:page_size] = Integer(page_size)
+          Util.assert(page_size > 0) { ":page_size must be a positive integer, #{page_size.inspect} given" }
+        end
+
+        unless timeout.nil?
+          Util.assert_instance_of(::Numeric, timeout) { ":timeout must be a number of seconds, #{timeout} given" }
+          Util.assert(timeout > 0) { ":timeout must be greater than 0, #{timeout} given" }
+        end
 
         @consistency        = consistency
         @page_size          = page_size

data/lib/cassandra/execution/trace.rb

@@ -108,16 +108,16 @@ module Cassandra
       private
 
       # @private
-      SELECT_SESSION = "SELECT * FROM system_traces.sessions WHERE session_id = ?"
+      SELECT_SESSION = "SELECT * FROM system_traces.sessions WHERE session_id = %s"
       # @private
-      SELECT_EVENTS  = "SELECT * FROM system_traces.events WHERE session_id = ?"
+      SELECT_EVENTS  = "SELECT * FROM system_traces.events WHERE session_id = %s"
 
       # @private
       def load
         synchronize do
           return if @loaded
 
-          data = @client.query(Statements::Simple.new(SELECT_SESSION, @id), VOID_OPTIONS).get.first
+          data = @client.query(Statements::Simple.new(SELECT_SESSION % @id), VOID_OPTIONS).get.first
           raise ::RuntimeError, "unable to load trace #{@id}" if data.nil?
 
           @coordinator = data['coordinator']
@@ -138,7 +138,7 @@ module Cassandra
 
           @events = []
 
-          @client.query(Statements::Simple.new(SELECT_EVENTS, @id), VOID_OPTIONS).get.each do |row|
+          @client.query(Statements::Simple.new(SELECT_EVENTS % @id), VOID_OPTIONS).get.each do |row|
             @events << Event.new(row['event_id'], row['activity'], row['source'], row['source_elapsed'], row['thread'])
           end
 

data/lib/cassandra/future.rb

@@ -48,6 +48,8 @@ module Cassandra
       def initialize(error)
         raise ::ArgumentError, "error must be an exception, #{error.inspect} given" unless error.is_a?(::Exception)
 
+        error.set_backtrace(caller) unless error.backtrace
+
         @error = error
       end
 
@@ -188,7 +190,7 @@ module Cassandra
       monitor   = Monitor.new
       promise   = Promise.new
       remaining = futures.length
-      values    = Array.new(length)
+      values    = Array.new(remaining)
 
       futures.each_with_index do |future, i|
         future.on_complete do |v, e|
@@ -390,11 +392,11 @@ module Cassandra
           end
 
           def success(value)
-            @block.call(nil, value)
+            @block.call(value, nil)
           end
 
           def failure(error)
-            @block.call(error, nil)
+            @block.call(nil, error)
           end
         end
 
@@ -471,6 +473,8 @@ module Cassandra
           raise ::ArgumentError, "error must be an exception, #{error.inspect} given"
         end
 
+        error.set_backtrace(caller) unless error.backtrace
+
         return unless @state == :pending
 
         listeners = nil

data/lib/cassandra/keyspace.rb

@@ -106,6 +106,11 @@ module Cassandra
     end
     alias :== :eql?
 
+    # @return [String] a CLI-friendly keyspace representation
+    def inspect
+      "#<#{self.class.name}:0x#{self.object_id.to_s(16)} @name=#{@name}>"
+    end
+
     # @private
     def update_table(table)
       tables = @tables.dup

data/lib/cassandra/load_balancing/policies/dc_aware_round_robin.rb

@@ -56,12 +56,17 @@ module Cassandra
 
         include MonitorMixin
 
-        def initialize(datacenter, max_remote_hosts_to_use = nil, use_remote_hosts_for_local_consistency = false)
-          datacenter              = String(datacenter)
+        def initialize(datacenter = nil, max_remote_hosts_to_use = nil, use_remote_hosts_for_local_consistency = false)
+          datacenter              = datacenter && String(datacenter)
           max_remote_hosts_to_use = max_remote_hosts_to_use && Integer(max_remote_hosts_to_use)
 
-          raise ::ArgumentError, "datacenter cannot be nil" if datacenter.nil?
-          raise ::ArgumentError, "max_remote_hosts_to_use must be nil or >= 0" if max_remote_hosts_to_use && max_remote_hosts_to_use < 0
+          unless datacenter.nil?
+            Util.assert_not_empty(datacenter) { "datacenter cannot be empty" }
+          end
+
+          unless max_remote_hosts_to_use.nil?
+            Util.assert(max_remote_hosts_to_use >= 0) { "max_remote_hosts_to_use must be nil or >= 0" }
+          end
 
           @datacenter = datacenter
           @max_remote = max_remote_hosts_to_use
@@ -75,6 +80,10 @@ module Cassandra
         end
 
         def host_up(host)
+          if !@datacenter && host.datacenter
+            @datacenter = host.datacenter
+          end
+
           if host.datacenter.nil? || host.datacenter == @datacenter
             synchronize { @local = @local.dup.push(host) }
           else

data/lib/cassandra/load_balancing/policies/token_aware.rb

@@ -92,9 +92,7 @@ module Cassandra
         def initialize(wrapped_policy)
           methods = [:host_up, :host_down, :host_found, :host_lost, :distance, :plan]
 
-          unless methods.all? {|method| wrapped_policy.respond_to?(method)}
-            raise ::ArgumentError, "supplied policy must be a Cassandra::LoadBalancing::Policy, #{wrapped_policy.inspect} given"
-          end
+          Util.assert_responds_to_all(methods, wrapped_policy) { "supplied policy must respond to #{methods.inspect}, but doesn't" }
 
           @policy = wrapped_policy
         end
@@ -111,7 +109,7 @@ module Cassandra
           replicas = @cluster.find_replicas(keyspace, statement)
           return @policy.plan(keyspace, statement, options) if replicas.empty?
 
-          Plan.new(replicas.dup, @policy, keyspace, statement, options)
+          Plan.new(replicas.shuffle, @policy, keyspace, statement, options)
         end
       end
     end

data/lib/cassandra/load_balancing/policies/white_list.rb

@@ -35,12 +35,9 @@ module Cassandra
         # @param wrapped_policy [Cassandra::LoadBalancing::Policy] actual policy to filter
         # @raise [ArgumentError] if arguments are of unexpected types
         def initialize(ips, wrapped_policy)
-          raise ::ArgumentError, "ips must be enumerable" unless ips.respond_to?(:each)
+          Util.assert_instance_of(::Enumerable, ips) { "ips must be an Enumerable, #{ips.inspect} given" }
           methods = [:host_up, :host_down, :host_found, :host_lost, :distance, :plan]
-
-          unless methods.all? {|method| wrapped_policy.respond_to?(method)}
-            raise ::ArgumentError, "supplied policy must be a Cassandra::LoadBalancing::Policy, #{wrapped_policy.inspect} given"
-          end
+          Util.assert_responds_to_all(methods, wrapped_policy) { "supplied policy must respond to #{methods.inspect}, but doesn't" }
 
           @ips    = ::Set.new
           @policy = wrapped_policy
@@ -52,7 +49,7 @@ module Cassandra
             when ::String
               @ips << ::IPAddr.new(ip)
             else
-              raise ::ArgumentError, "ips must contain only instance of String or IPAddr, #{ip.inspect} given"
+              raise ::ArgumentError, "each ip must be a String or IPAddr, #{ip.inspect} given"
             end
           end
         end

data/lib/cassandra/null_logger.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Cassandra
+  # @private
+  class NullLogger
+    def close(*); end
+    def debug(*); end
+    def debug?; false end
+    def error(*); end
+    def error?; false end
+    def fatal(*); end
+    def fatal?; false end
+    def info(*); end
+    def info?; false end
+    def unknown(*); end
+    def warn(*); end
+    def warn?; false end
+  end
+end

data/lib/cassandra/protocol.rb

@@ -17,24 +17,8 @@
 #++
 
 module Cassandra
-  # @private
-  ProtocolError = Class.new(Error)
-
   # @private
   module Protocol
-    DecodingError = Class.new(ProtocolError)
-    EncodingError = Class.new(ProtocolError)
-    InvalidStreamIdError = Class.new(ProtocolError)
-    InvalidValueError = Class.new(ProtocolError)
-    UnsupportedOperationError = Class.new(ProtocolError)
-    UnsupportedFrameTypeError = Class.new(ProtocolError)
-    UnsupportedResultKindError = Class.new(ProtocolError)
-    UnsupportedColumnTypeError = Class.new(ProtocolError)
-    UnsupportedEventTypeError = Class.new(ProtocolError)
-    UnsupportedFeatureError = Class.new(ProtocolError)
-    UnexpectedCompressionError = Class.new(ProtocolError)
-    UnmaterializedRowsError = Class.new(ProtocolError)
-
     module Formats
       CHAR_FORMAT = 'c'.freeze
       DOUBLE_FORMAT = 'G'.freeze

data/lib/cassandra/protocol/cql_byte_buffer.rb

@@ -22,7 +22,7 @@ module Cassandra
       def read_unsigned_byte
         read_byte
       rescue RangeError => e
-        raise DecodingError, e.message, e.backtrace
+        raise Errors::DecodingError, e.message, e.backtrace
       end
       
       def read_varint(len=bytesize, signed=true)
@@ -36,7 +36,7 @@ module Cassandra
         end
         n
       rescue RangeError => e
-        raise DecodingError, e.message, e.backtrace
+        raise Errors::DecodingError, e.message, e.backtrace
       end
 
       def read_decimal(len=bytesize)
@@ -57,8 +57,8 @@ module Cassandra
           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
+      rescue Errors::DecodingError => e
+        raise Errors::DecodingError, e.message, e.backtrace
       end
 
       def read_long
@@ -68,19 +68,19 @@ module Cassandra
         bottom ^= 0xffffffff
         -((top << 32) | bottom) - 1
       rescue RangeError => e
-        raise DecodingError, e.message, e.backtrace
+        raise Errors::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
+        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 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
@@ -88,13 +88,13 @@ module Cassandra
         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
+        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 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
@@ -103,7 +103,7 @@ module Cassandra
         string.force_encoding(::Encoding::UTF_8)
         string
       rescue RangeError => e
-        raise 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
@@ -112,13 +112,13 @@ module Cassandra
         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
+        raise Errors::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
+      rescue Errors::DecodingError => e
+        raise Errors::DecodingError, "Not enough bytes available to decode a UUID: #{e.message}", e.backtrace
       end
 
       def read_string_list
@@ -131,7 +131,7 @@ module Cassandra
         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
+        raise Errors::DecodingError, "Not enough bytes available to decode a bytes: #{e.message}", e.backtrace
       end
 
       def read_short_bytes
@@ -139,7 +139,7 @@ module Cassandra
         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
+        raise Errors::DecodingError, "Not enough bytes available to decode a short bytes: #{e.message}", e.backtrace
       end
 
       def read_option
@@ -157,12 +157,12 @@ module Cassandra
         port = read_int
         [ip_addr, port]
       rescue RangeError => e
-        raise 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 DecodingError, "Unknown consistency index #{index}" if index >= CONSISTENCIES.size || CONSISTENCIES[index].nil?
+        raise Errors::DecodingError, "Unknown consistency index #{index}" if index >= CONSISTENCIES.size || CONSISTENCIES[index].nil?
         CONSISTENCIES[index]
       end
 
@@ -241,7 +241,7 @@ module Cassandra
 
       def append_consistency(consistency)
         index = CONSISTENCIES.index(consistency)
-        raise EncodingError, %(Unknown consistency "#{consistency}") if index.nil? || CONSISTENCIES[index].nil?
+        raise Errors::EncodingError, %(Unknown consistency "#{consistency}") if index.nil? || CONSISTENCIES[index].nil?
         append_short(index)
       end
 

data/lib/cassandra/protocol/cql_protocol_handler.rb

@@ -35,7 +35,7 @@ module Cassandra
       # @return [String] the current keyspace for the underlying connection
       attr_reader :keyspace
 
-      def initialize(connection, scheduler, protocol_version, compressor=nil)
+      def initialize(connection, scheduler, protocol_version, compressor=nil, heartbeat_interval = 30, idle_timeout = 60)
         @connection = connection
         @scheduler = scheduler
         @compressor = compressor
@@ -53,6 +53,10 @@ module Cassandra
         @lock = Mutex.new
         @closed_promise = Ione::Promise.new
         @keyspace = nil
+        @heartbeat = nil
+        @terminate = nil
+        @heartbeat_interval = heartbeat_interval
+        @idle_timeout = idle_timeout
       end
 
       # Returns the hostname of the underlying connection
@@ -128,7 +132,7 @@ 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::TimeoutError}
+      # 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.
@@ -138,8 +142,9 @@ module Cassandra
       #   failing the request
       # @return [Ione::Future<Cassandra::Protocol::Response>] a future that resolves to
       #   the response
-      def send_request(request, timeout=nil)
-        return Ione::Future.failed(Errors::NotConnectedError.new) if closed?
+      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, @frame_encoder)
         id = nil
         @lock.lock
@@ -174,8 +179,18 @@ module Cassandra
       # Closes the underlying connection.
       #
       # @return [Ione::Future] a future that completes when the connection has closed
-      def close
-        @connection.close
+      def close(cause = nil)
+        if @heartbeat
+          @scheduler.cancel_timer(@heartbeat)
+          @heartbeat = nil
+        end
+
+        if @terminate
+          @scheduler.cancel_timer(@terminate)
+          @terminate = nil
+        end
+
+        @connection.close(cause)
         @closed_promise.future
       end
 
@@ -199,7 +214,7 @@ module Cassandra
         def time_out!
           unless future.completed?
             @timed_out = true
-            fail(TimeoutError.new)
+            fail(Errors::TimeoutError.new('Timed out'))
           end
         end
 
@@ -209,6 +224,7 @@ module Cassandra
       end
 
       def receive_data(data)
+        reschedule_termination
         @read_buffer << data
         @current_frame = @frame_decoder.decode_frame(@read_buffer, @current_frame)
         while @current_frame.complete?
@@ -248,6 +264,9 @@ module Cassandra
         if response.is_a?(Protocol::SetKeyspaceResultResponse)
           @keyspace = response.keyspace
         end
+        if response.is_a?(Protocol::SchemaChangeResultResponse) && response.change == 'DROPPED' && response.keyspace == @keyspace && response.table.empty?
+          @keyspace = nil
+        end
         flush_request_queue
         unless promise.timed_out?
           promise.fulfill(response)
@@ -291,9 +310,22 @@ module Cassandra
       end
 
       def socket_closed(cause)
-        request_failure_cause = cause || Io::ConnectionClosedError.new
+        if cause
+          e = Errors::IOError.new(cause.message)
+          e.set_backtrace(cause.backtrace)
+
+          cause = e
+        end
+
+        request_failure_cause = cause || Errors::IOError.new('Connection closed')
         promises_to_fail = nil
         @lock.synchronize do
+          @scheduler.cancel_timer(@heartbeat) if @heartbeat
+          @scheduler.cancel_timer(@terminate) if @terminate
+
+          @heartbeat = nil
+          @terminate = nil
+
           promises_to_fail = @promises.compact
           promises_to_fail.concat(@request_queue_in)
           promises_to_fail.concat(@request_queue_out)
@@ -311,6 +343,41 @@ module Cassandra
         end
       end
 
+      def schedule_heartbeat
+        return unless @heartbeat_interval
+
+        timer = nil
+
+        @lock.synchronize do
+          @scheduler.cancel_timer(@heartbeat) if @heartbeat && !@heartbeat.resolved?
+
+          @heartbeat = timer = @scheduler.schedule_timer(@heartbeat_interval)
+        end
+
+        timer.on_value do
+          send_request(HEARTBEAT, nil, false).on_value do
+            schedule_heartbeat
+          end
+        end
+      end
+
+      def reschedule_termination
+        return unless @idle_timeout
+
+        timer = nil
+
+        @lock.synchronize do
+          @scheduler.cancel_timer(@terminate) if @terminate
+
+          @terminate = timer = @scheduler.schedule_timer(@idle_timeout)
+        end
+
+        timer.on_value do
+          @terminate = nil
+          @connection.close(TERMINATED)
+        end
+      end
+
       def next_stream_id
         if (stream_id = @promises.index(nil))
           stream_id
@@ -318,6 +385,9 @@ module Cassandra
           nil
         end
       end
+
+      HEARTBEAT  = OptionsRequest.new
+      TERMINATED = Errors::TimeoutError.new('Terminated due to inactivity')
     end
   end
 end