cassandra-driver 1.0.0.beta.3 → 1.0.0.rc.1

data/lib/cassandra/future.rb

@@ -188,7 +188,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 +390,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
 

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

@@ -56,11 +56,11 @@ 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, "datacenter cannot be empty" if datacenter && datacenter.empty?
           raise ::ArgumentError, "max_remote_hosts_to_use must be nil or >= 0" if max_remote_hosts_to_use && max_remote_hosts_to_use < 0
 
           @datacenter = datacenter
@@ -75,6 +75,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

@@ -111,7 +111,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/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,37 @@ module Cassandra
         end
       end
 
+      def schedule_heartbeat
+        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
+        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 +381,9 @@ module Cassandra
           nil
         end
       end
+
+      HEARTBEAT  = OptionsRequest.new
+      TERMINATED = Errors::TimeoutError.new('Terminated due to inactivity')
     end
   end
 end

data/lib/cassandra/protocol/frame_decoder.rb

@@ -47,7 +47,7 @@ module Cassandra
 
       def actual_decode(buffer, fields, size)
         if (fields >> 24) & 0x80 == 0
-          raise UnsupportedFrameTypeError, 'Request frames are not supported'
+          raise Errors::DecodingError, 'Request frames are not supported'
         end
         protocol_version = (fields >> 24) & 0x7f
         compression = (fields >> 16) & 0x01
@@ -78,7 +78,7 @@ module Cassandra
           compressed_body = buffer.read(size)
           CqlByteBuffer.new(@compressor.decompress(compressed_body))
         else
-          raise UnexpectedCompressionError, 'Compressed frame received, but no compressor configured'
+          raise Errors::DecodingError, 'Compressed frame received, but no compressor configured'
         end
       end
 

data/lib/cassandra/protocol/frame_encoder.rb

@@ -26,7 +26,7 @@ module Cassandra
       end
 
       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
+        raise EncodingError, 'The stream ID must be between 0 and 127' unless 0 <= stream_id && stream_id < 128
         buffer ||= CqlByteBuffer.new
         flags = request.trace? ? 2 : 0
         body = request.write(@protocol_version, CqlByteBuffer.new)

data/lib/cassandra/protocol/response.rb

@@ -24,7 +24,7 @@ module Cassandra
         if response_class
           response_class.decode(protocol_version, buffer, length, trace_id)
         else
-          raise UnsupportedOperationError, "The operation #{opcode} is not supported"
+          raise Errors::DecodingError, "Unsupported opcode #{opcode.inspect}"
         end
       end
 

data/lib/cassandra/protocol/responses/detailed_error_response.rb

@@ -37,7 +37,10 @@ module Cassandra
           details[:cl] = buffer.read_consistency
           details[:received] = buffer.read_int
           details[:blockfor] = buffer.read_int
-          details[:write_type] = buffer.read_string
+          write_type = buffer.read_string
+          write_type.downcase!
+
+          details[:write_type] = write_type.to_sym
         when 0x1200 # read_timeout
           details[:cl] = buffer.read_consistency
           details[:received] = buffer.read_int
@@ -52,6 +55,18 @@ module Cassandra
         new(code, message, details)
       end
 
+      def to_error(statement = nil)
+        case code
+        when 0x1000 then Errors::UnavailableError.new(@message, statement, @details[:cl], @details[:required], @details[:alive])
+        when 0x1100 then Errors::WriteTimeoutError.new(@message, statement, @details[:write_type], @details[:cl], @details[:blockfor], @details[:received])
+        when 0x1200 then Errors::ReadTimeoutError.new(@message, statement, @details[:data_present], @details[:cl], @details[:blockfor], @details[:received])
+        when 0x2400 then Errors::AlreadyExistsError.new(@message, statement, @details[:ks], @details[:table])
+        when 0x2500 then Errors::UnpreparedError.new(@message, statement, @details[:id])
+        else
+          super
+        end
+      end
+
       def to_s
         "#{super} #{@details}"
       end

data/lib/cassandra/protocol/responses/error_response.rb

@@ -42,6 +42,23 @@ module Cassandra
         %(ERROR 0x#{hex_code} "#@message")
       end
 
+      def to_error(statement = nil)
+        case @code
+        when 0x0000 then Errors::ServerError.new(@message)
+        when 0x000A then Errors::ProtocolError.new(@message)
+        when 0x0100 then Errors::AuthenticationError.new(@message)
+        when 0x1001 then Errors::OverloadedError.new(@message, statement)
+        when 0x1002 then Errors::IsBootstrappingError.new(@message, statement)
+        when 0x1003 then Errors::TruncateError.new(@message, statement)
+        when 0x2000 then Errors::SyntaxError.new(@message, statement)
+        when 0x2100 then Errors::UnauthorizedError.new(@message, statement)
+        when 0x2200 then Errors::InvalidError.new(@message, statement)
+        when 0x2300 then Errors::ConfigurationError.new(@message, statement)
+        else
+          Errors::ServerError.new(@message)
+        end
+      end
+
       private
 
       RESPONSE_TYPES[0x00] = self