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

data/lib/cassandra/{client/null_logger.rb → cluster/failed_connection.rb}

@@ -17,21 +17,19 @@
 #++
 
 module Cassandra
-  module Client
+  class Cluster
     # @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
+    class FailedConnection
+      attr_reader :error, :host
+
+      def initialize(error, host)
+        @error = error
+        @host  = host
+      end
+
+      def connected?
+        false
+      end
     end
   end
 end

data/lib/cassandra/cluster/options.rb

@@ -22,10 +22,11 @@ module Cassandra
     class Options
       attr_reader :credentials, :auth_provider, :compressor, :port,
                   :connect_timeout, :ssl, :connections_per_local_node,
-                  :connections_per_remote_node
+                  :connections_per_remote_node, :heartbeat_interval,
+                  :idle_timeout
       attr_accessor :protocol_version
 
-      def initialize(protocol_version, credentials, auth_provider, compressor, port, connect_timeout, ssl, connections_per_local_node, connections_per_remote_node)
+      def initialize(protocol_version, credentials, auth_provider, compressor, port, connect_timeout, ssl, connections_per_local_node, connections_per_remote_node, heartbeat_interval, idle_timeout)
         @protocol_version   = protocol_version
         @credentials        = credentials
         @auth_provider      = auth_provider
@@ -33,10 +34,20 @@ module Cassandra
         @port               = port
         @connect_timeout    = connect_timeout
         @ssl                = ssl
+        @heartbeat_interval = heartbeat_interval
+        @idle_timeout       = idle_timeout
 
         @connections_per_local_node  = connections_per_local_node
         @connections_per_remote_node = connections_per_remote_node
       end
+
+      def compression
+        @compressor && @compressor.algorithm
+      end
+
+      def create_authenticator(authentication_class)
+        @auth_provider && @auth_provider.create_authenticator(authentication_class)
+      end
     end
   end
 end

data/lib/cassandra/cluster/registry.rb

@@ -22,24 +22,30 @@ module Cassandra
     class Registry
       include MonitorMixin
 
-      LISTENER_METHODS = [:host_found, :host_lost, :host_up, :host_down].freeze
-
       def initialize(logger)
         @logger    = logger
         @hosts     = ::Hash.new
-        @listeners = ::Set.new
+        @listeners = ::Array.new
 
         mon_initialize
       end
 
       def add_listener(listener)
-        synchronize { @listeners = @listeners.dup.add(listener) }
+        synchronize do
+          listeners = @listeners.dup
+          listeners.push(listener)
+          @listeners = listeners
+        end
 
         self
       end
 
       def remove_listener(listener)
-        synchronize { @listeners = @listeners.dup.delete(listener) }
+        synchronize do
+          listeners = @listeners.dup
+          listeners.delete(listener)
+          @listeners = listeners
+        end
 
         self
       end
@@ -72,8 +78,12 @@ module Cassandra
              host.rack            == data['rack']            &&
              host.datacenter      == data['data_center']
 
-            return self
+            return self if host.up?
+
+            host = toggle_up(host)
           else
+            @logger.debug("Host #{host.ip} metadata has been updated, it will be considered lost and found")
+
             notify_lost(host)
 
             host = create_host(address, data)
@@ -164,7 +174,7 @@ module Cassandra
       def toggle_down(host)
         host = Host.new(host.ip, host.id, host.rack, host.datacenter, host.release_version, host.tokens, :down)
         @logger.debug("Host #{host.ip} is down")
-        @listeners.each do |listener|
+        @listeners.reverse_each do |listener|
           listener.host_down(host) rescue nil
         end
         host
@@ -174,13 +184,13 @@ module Cassandra
         if host.up?
           @logger.debug("Host #{host.ip} is down and lost")
           host = Host.new(host.ip, host.id, host.rack, host.datacenter, host.release_version, host.tokens, :down)
-          @listeners.each do |listener|
+          @listeners.reverse_each do |listener|
             listener.host_down(host) rescue nil
             listener.host_lost(host) rescue nil
           end
         else
           @logger.debug("Host #{host.ip} is lost")
-          @listeners.each do |listener|
+          @listeners.reverse_each do |listener|
             listener.host_lost(host) rescue nil
           end
         end

data/lib/cassandra/column.rb

@@ -78,6 +78,11 @@ module Cassandra
       cql
     end
 
+    # @return [String] a CLI-friendly column representation
+    def inspect
+      "#<#{self.class.name}:0x#{self.object_id.to_s(16)} @name=#{@name}>"
+    end
+
     # @return [Boolean] whether this column is equal to the other
     def eql?(other)
       other.is_a?(Column) &&

data/lib/cassandra/compression.rb

@@ -18,7 +18,7 @@
 
 module Cassandra
   module Compression
-    # @abstract Compressors given to {Cassandra.connect} as the `:compressor`
+    # @abstract Compressors given to {Cassandra.cluster} as the `:compressor`
     #   option don't need to be subclasses of this class, but need to implement
     #   the same methods. This class exists only for documentation purposes.
     class Compressor

data/lib/cassandra/compression/compressors/lz4.rb

@@ -31,7 +31,7 @@ module Cassandra
       #   [lz4-ruby](http://rubygems.org/gems/lz4-ruby) gem (v0.3.2 or later
       #   required).
       # @note No need to instantiate this class manually, use `compression:
-      #   :lz4` option when calling {Cassandra.connect} and one will be created
+      #   :lz4` option when calling {Cassandra.cluster} and one will be created
       #   automatically for you.
       class Lz4 < Compressor
         # @return [String] `'lz4'`

data/lib/cassandra/compression/compressors/snappy.rb

@@ -31,7 +31,7 @@ module Cassandra
       #   [snappy](http://rubygems.org/gems/snappy) gem (v0.0.10 or later for
       #   JRuby support).
       # @note No need to instantiate this class manually, use `compression:
-      #   :snappy` option when calling {Cassandra.connect} and one will be
+      #   :snappy` option when calling {Cassandra.cluster} and one will be
       #   created automatically for you.
       class Snappy < Compressor
         # @return [String] `'snappy'`

data/lib/cassandra/driver.rb

@@ -24,7 +24,7 @@ module Cassandra
       define_method(:"#{name}=") { |object| @instances[name] = object }
     end
 
-    let(:io_reactor)       { Io::IoReactor.new }
+    let(:io_reactor)       { Ione::Io::IoReactor.new }
     let(:cluster_registry) { Cluster::Registry.new(logger) }
     let(:cluster_schema)   { Cluster::Schema.new(schema_type_parser) }
     let(:cluster_metadata) { Cluster::Metadata.new(
@@ -54,36 +54,42 @@ module Cassandra
     let(:ordered_partitioner) { Cluster::Schema::Partitioners::Ordered.new }
     let(:random_partitioner)  { Cluster::Schema::Partitioners::Random.new }
 
-    let(:connector) { Cluster::Connector.new(logger, io_reactor, cluster_registry, connection_options) }
+    let(:connector) { Cluster::Connector.new(logger, io_reactor, cluster_registry, connection_options, execution_options) }
 
-    let(:control_connection) { Cluster::ControlConnection.new(logger, io_reactor, cluster_registry, cluster_schema, cluster_metadata, load_balancing_policy, reconnection_policy, connector) }
+    let(:control_connection) { Cluster::ControlConnection.new(logger, io_reactor, cluster_registry, cluster_schema, cluster_metadata, load_balancing_policy, reconnection_policy, address_resolution_policy, connector) }
 
-    let(:cluster) { Cluster.new(logger, io_reactor, control_connection, cluster_registry, cluster_schema, cluster_metadata, execution_options, connection_options, load_balancing_policy, reconnection_policy, retry_policy, connector, futures_factory) }
+    let(:cluster) { Cluster.new(logger, io_reactor, control_connection, cluster_registry, cluster_schema, cluster_metadata, execution_options, connection_options, load_balancing_policy, reconnection_policy, retry_policy, address_resolution_policy, connector, futures_factory) }
 
     let(:execution_options) do
       Execution::Options.new({
         :consistency => consistency,
         :trace       => trace,
-        :page_size   => page_size
+        :page_size   => page_size,
+        :timeout     => timeout
       })
     end
 
-    let(:connection_options) { Cluster::Options.new(protocol_version, credentials, auth_provider, compressor, port, connect_timeout, ssl, connections_per_local_node, connections_per_remote_node) }
-
-    let(:port)                  { 9042 }
-    let(:protocol_version)      { 2 }
-    let(:connect_timeout)       { 10 }
-    let(:ssl)                   { false }
-    let(:logger)                { Client::NullLogger.new  }
-    let(:compressor)            { nil }
-    let(:credentials)           { nil }
-    let(:auth_provider)         { nil }
-    let(:load_balancing_policy) { LoadBalancing::Policies::RoundRobin.new }
-    let(:reconnection_policy)   { Reconnection::Policies::Exponential.new(0.5, 30, 2) }
-    let(:retry_policy)          { Retry::Policies::Default.new }
-    let(:consistency)           { :quorum }
-    let(:trace)                 { false }
-    let(:page_size)             { nil }
+    let(:connection_options) { Cluster::Options.new(protocol_version, credentials, auth_provider, compressor, port, connect_timeout, ssl, connections_per_local_node, connections_per_remote_node, heartbeat_interval, idle_timeout) }
+
+    let(:port)                      { 9042 }
+    let(:protocol_version)          { 2 }
+    let(:connect_timeout)           { 10 }
+    let(:ssl)                       { false }
+    let(:logger)                    { NullLogger.new  }
+    let(:compressor)                { nil }
+    let(:credentials)               { nil }
+    let(:auth_provider)             { nil }
+    let(:datacenter)                { nil }
+    let(:load_balancing_policy)     { LoadBalancing::Policies::TokenAware.new(LoadBalancing::Policies::DCAwareRoundRobin.new(datacenter, 0)) }
+    let(:reconnection_policy)       { Reconnection::Policies::Exponential.new(0.5, 30, 2) }
+    let(:retry_policy)              { Retry::Policies::Default.new }
+    let(:address_resolution_policy) { AddressResolution::Policies::None.new }
+    let(:consistency)               { :one }
+    let(:trace)                     { false }
+    let(:page_size)                 { 10000 }
+    let(:heartbeat_interval)        { 30 }
+    let(:idle_timeout)              { 60 }
+    let(:timeout)                   { 10 }
 
     let(:connections_per_local_node)  { 2 }
     let(:connections_per_remote_node) { 1 }
@@ -103,8 +109,10 @@ module Cassandra
         cluster.register(listener)
       end
 
+      logger.debug('Populating policies and listeners with initial endpoints')
       addresses.each {|address| cluster_registry.host_found(address)}
 
+      logger.info('Establishing control connection')
       control_connection.connect_async.map(cluster)
     end
   end

data/lib/cassandra/errors.rb

@@ -17,63 +17,353 @@
 #++
 
 module Cassandra
-  # Base class for all Errors raised by the driver 
+  # Included in all Errors raised by the driver to allow rescuing from any
+  # driver-specific error.
+  # @example Catching all driver errors
+  #   begin
+  #     cluster = Cassandra.cluster
+  #     session = cluster.connect
+  #   rescue Cassandra::Error => e
+  #     puts "#{e.class.name}: #{e.message}"
+  #   end
   # @see Cassandra::Errors
-  class Error < StandardError
+  module Error
   end
 
   module Errors
-    # @!parse class IoError < StandardError; end
-    # @private
-    IoError = Ione::IoError
-
-    # This error type represents errors sent by the server, the `code` attribute
-    # can be used to find the exact type, and `cql` contains the request's CQL,
-    # if any. `message` contains the human readable error message sent by the
-    # server.
-    class QueryError < Error
-      # @return [Integer] error code
-      attr_reader :code
-      # @return [String] original CQL used
-      attr_reader :cql
-      # @return [Hash{Symbol => String, Integer}] various error details
-      attr_reader :details
+    # Mixed into any host-specific errors. Requests resulting in these errors
+    # are attempted on other hosts. Once all hosts failed with this type of
+    # error, a {Cassandra::Errors::NoHostsAvailable} error is raised with
+    # details of failures.
+    #
+    # @see Errors::NoHostsAvailable
+    module HostError
+    end
+
+    # Raised when something unexpected happened. This indicates a server-side
+    # bug.
+    #
+    # @see https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v1.spec#L554-L555 Description of Server Error in Apache Cassandra native protocol spec v1
+    class ServerError < ::StandardError
+      include Error, HostError
+    end
+
+    # Mixed into all internal driver errors.
+    class InternalError < ::RuntimeError
+      include Error, HostError
+    end
+
+    # Raised when data decoding fails.
+    class DecodingError < ::RuntimeError
+      include Error, HostError
+    end
+
+    # Raised when data encoding fails.
+    class EncodingError < ::RuntimeError
+      include Error, HostError
+    end
+
+    # Raised when a connection level error occured.
+    class IOError < ::IOError
+      include Error, HostError
+    end
+
+    # Raised when a timeout has occured.
+    class TimeoutError < ::Timeout::Error
+      include Error, HostError
+    end
+
+    # Mixed into all request execution errors.
+    module ExecutionError
+      include Error
+
+      # @return [Cassandra::Statement] statement that triggered the error.
+      attr_reader :statement
 
       # @private
-      def initialize(code, message, cql=nil, details=nil)
+      def initialize(message, statement)
         super(message)
-        @code = code
-        @cql = cql
-        @details = details
+
+        @statement = statement
       end
     end
 
-    # This error is thrown when not hosts could be reached during connection or query execution.
-    class NoHostsAvailable < Error
-      # @return [Hash{Cassandra::Host => Exception}] a map of hosts to underlying exceptions
-      attr_reader :errors
+    # Raised when coordinator determines that a request cannot be executed
+    # because there are not enough replicas. In this scenario, the request is
+    # not sent to the nodes at all.
+    #
+    # @note This error can be handled by a {Cassandra::Retry::Policy} to
+    #   determine the desired outcome.
+    #
+    # @see https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v1.spec#L562-L572 Description of Unavailable Error in Apache Cassandra native protocol spec v1
+    class UnavailableError < ::StandardError
+      include ExecutionError
+      # Consistency level that triggered the error.
+      #
+      # @return [Symbol] the original consistency level for the request, one of
+      #   {Cassandra::CONSISTENCIES}
+      attr_reader :consistency
+
+      # @return [Integer] the number of replicas required to achieve requested
+      #   consistency level
+      attr_reader :required
+
+      # @return [Integer] the number of replicas available for the request
+      attr_reader :alive
 
       # @private
-      def initialize(errors = {})
-        super("no hosts available, check #errors property for details")
+      def initialize(message, statement, consistency, required, alive)
+        super(message, statement)
 
-        @errors = errors
+        @consistency = consistency
+        @required    = required
+        @alive       = alive
       end
     end
 
-    # Client error represents bad driver state or configuration
+    # Raised when the request cannot be processed because the coordinator node
+    # is overloaded
+    #
+    # @see https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v1.spec#L573-L574 Description of Overloaded Error in Apache Cassandra native protocol spec v1
+    class OverloadedError < ::StandardError
+      include ExecutionError, HostError
+    end
+
+    # Raise when the request was a read request but the coordinator node is
+    # bootstrapping
+    #
+    # @see https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v1.spec#L575-L576 Description of Is Bootstrapping Error in Apache Cassandra native protocol spec v1
+    class IsBootstrappingError < ::StandardError
+      include ExecutionError, HostError
+    end
+
+    # Raised when truncation failed.
+    #
+    # @see https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v1.spec#L577 Description of Truncate Error in Apache Cassandra native protocol spec v1
+    class TruncateError < ::StandardError
+      include ExecutionError
+    end
+
+    # Raised when a write request timed out.
+    #
+    # @see https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v1.spec#L578-L603 Description of Write Timeout Error in Apache Cassandra native protocol spec v1
+    class WriteTimeoutError < ::StandardError
+      include ExecutionError
+
+      # @return [Symbol] the type of write request that timed out, one of
+      #   {Cassandra::WRITE_TYPES}
+      attr_reader :type
+      # @return [Symbol] the original consistency level for the request, one of
+      #   {Cassandra::CONSISTENCIES}
+      attr_reader :consistency
+      # @return [Integer] the number of acks required to achieve requested
+      #   consistency level
+      attr_reader :required
+      # @return [Integer] the number of acks received by the time the query
+      #   timed out
+      attr_reader :received
+
+      # @private
+      def initialize(message, statement, type, consistency, required, received)
+        super(message, statement)
+
+        @type        = type
+        @consistency = consistency
+        @required    = required
+        @received    = received
+      end
+    end
+
+    # Raised when a read request timed out.
+    #
+    # @see https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v1.spec#L604-L622 Description of Read Timeout Error in Apache Cassandra native protocol spec v1
+    class ReadTimeoutError < ::StandardError
+      include ExecutionError
+
+      # @return [Boolean] whether actual data (as opposed to data checksum) was
+      #   present in the received responses.
+      attr_reader :retrieved
+      # @return [Symbol] the original consistency level for the request, one of
+      #   {Cassandra::CONSISTENCIES}
+      attr_reader :consistency
+      # @return [Integer] the number of responses required to achieve requested
+      #   consistency level
+      attr_reader :required
+      # @return [Integer] the number of responses received by the time the
+      #   query timed out
+      attr_reader :received
+
+      # @private
+      def initialize(message, statement, retrieved, consistency, required, received)
+        super(message, statement)
+
+        @retrieved   = retrieved
+        @consistency = consistency
+        @required    = required
+        @received    = received
+      end
+
+      def retrieved?
+        @retrieved
+      end
+    end
+
+    # Client error represents bad driver state or mis-configuration
+    class ClientError < ::StandardError
+      include Error
+    end
+
+    # Raised when some client message triggered a protocol violation (for
+    # instance a QUERY message is sent before a STARTUP one has been sent)
     #
-    # @see Cassandra::Errors::AuthenticationError
-    class ClientError < Error
+    # @see https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v1.spec#L556-L558 Description of Protocol Error in Apache Cassandra native protocol spec v1
+    class ProtocolError < ClientError
     end
 
     # Raised when cannot authenticate to Cassandra
+    #
+    # @see https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v1.spec#L559-L561 Description of Bad Credentials Error in Apache Cassandra native protocol spec v1
     class AuthenticationError < ClientError
     end
 
-    # @private
-    NotConnectedError = Class.new(Error)
-    # @private
-    NotPreparedError = Class.new(Error)
+    # Mixed into all request validation errors.
+    module ValidationError
+      include Error
+
+      # @return [Cassandra::Statement] statement that triggered the error.
+      attr_reader :statement
+
+      # @private
+      def initialize(message, statement)
+        super(message)
+
+        @statement = statement
+      end
+    end
+
+    # Raised when a prepared statement tries to be executed and the provided
+    # prepared statement ID is not known by this host
+    #
+    # @note Seeing this error can be considered a Ruby Driver bug as it should
+    #   handle automatic re-preparing internally.
+    #
+    # @see https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v1.spec#L638-L641 Description of Unprepared Error in Apache Cassandra native protocol spec v1
+    class UnpreparedError < ::StandardError
+      include ValidationError
+      # @return [String] prepared statement id that triggered the error
+      attr_reader :id
+
+      # @private
+      def initialize(message, statement, id)
+        super(message, statement)
+
+        @id = id
+      end
+    end
+
+    # Raised when the submitted query has a syntax error.
+    #
+    # @see https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v1.spec#L623 Description of Syntax Error in Apache Cassandra native protocol spec v1
+    class SyntaxError < ::StandardError
+      include ValidationError
+    end
+
+    # Raised when the logged user doesn't have the right to perform the query.
+    #
+    # @see https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v1.spec#L624-L625 Description of Unauthorized Error in Apache Cassandra native protocol spec v1
+    class UnauthorizedError < ::StandardError
+      include ValidationError
+    end
+
+    # Raised when the query is syntactically correct but invalid.
+    #
+    # @example Creating a table without selecting a keyspace
+    #   begin
+    #     session.execute("CREATE TABLE users (user_id INT PRIMARY KEY)")
+    #   rescue Cassandra::Errors::InvalidError
+    #   end
+    #
+    # @see https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v1.spec#L626 Description of Invalid Error in Apache Cassandra native protocol spec v1
+    class InvalidError < ::StandardError
+      include ValidationError
+    end
+
+    # Raised when the query is invalid because of some configuration issue.
+    #
+    # @example Dropping non-existent keyspace
+    #   begin
+    #     client.execute("DROP KEYSPACE unknown_keyspace")
+    #   rescue Cassandra::Errors::ConfigurationError
+    #   end
+    #
+    # @see https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v1.spec#L627 Description of Config Error in Apache Cassandra native protocol spec v1
+    class ConfigurationError < ::StandardError
+      include ValidationError
+    end
+
+    # Raised when the query attempted to create a keyspace or a table that was
+    # already existing.
+    #
+    # @example Creating a table twice
+    #   session.execute("USE my_keyspace")
+    #   session.execute("CREATE TABLE users (user_id INT PRIMARY KEY)")
+    #   begin
+    #     session.execute("CREATE TABLE users (user_id INT PRIMARY KEY)")
+    #   rescue Cassandra::Errors::AlreadyExistsError => e
+    #     p ['already exists', e.keyspace, e.table]
+    #   end
+    #
+    # @see https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v1.spec#L628-L637 Description of Already Exists Error in Apache Cassandra native protocol spec v1
+    class AlreadyExistsError < ConfigurationError
+      # @return [String] keyspace
+      attr_reader :keyspace
+
+      # @return [String, nil] table or `nil`
+      attr_reader :table
+
+      # @private
+      def initialize(message, statement, keyspace, table)
+        super(message, statement)
+
+        @keyspace = keyspace
+        @table    = table
+      end
+    end
+
+    # This error is thrown when all attempted hosts raised a
+    # {Cassandra::Errors::HostError} during connection or query execution.
+    #
+    # @see Cassandra::Cluster#connect
+    # @see Cassandra::Session#execute
+    class NoHostsAvailable < ::StandardError
+      include Error
+
+      # @return [Hash{Cassandra::Host => Cassandra::Errors::HostError}] a map
+      #   of hosts to underlying exceptions
+      attr_reader :errors
+
+      # @private
+      def initialize(errors = nil)
+        if errors
+          first   = true
+          message = "All attempted hosts failed"
+          details = errors.each do |(host, error)|
+            if first
+              first = false
+              message << ': '
+            else
+              message << ', '
+            end
+            message << "#{host.ip} (#{error.class.name}: #{error.message})"
+          end
+        else
+          message = "All hosts down"
+        end
+
+        super(message)
+
+        @errors = errors || {}
+      end
+    end
   end
 end