cassandra-driver 1.0.0.rc.1 → 1.0.0

data/lib/cassandra/cluster.rb

@@ -191,6 +191,7 @@ module Cassandra
 
       @control_connection.close_async.on_complete do |f|
         if f.resolved?
+          @load_balancing_policy.teardown(self) rescue nil
           promise.fulfill(self)
         else
           f.on_failure {|e| promise.break(e)}
@@ -217,8 +218,10 @@ module Cassandra
 end
 
 require 'cassandra/cluster/client'
+require 'cassandra/cluster/connection_pool'
 require 'cassandra/cluster/connector'
 require 'cassandra/cluster/control_connection'
+require 'cassandra/cluster/failed_connection'
 require 'cassandra/cluster/metadata'
 require 'cassandra/cluster/options'
 require 'cassandra/cluster/registry'

data/lib/cassandra/cluster/client.rb

@@ -63,11 +63,12 @@ module Cassandra
         @connected_future = begin
           @logger.info('Creating session')
           @registry.add_listener(self)
+          @schema.add_listener(self)
 
           futures = @connecting_hosts.map do |(host, distance)|
             f = connect_to_host(host, distance)
             f.recover do |error|
-              Cassandra::Client::FailedConnection.new(error, host)
+              FailedConnection.new(error, host)
             end
           end
 
@@ -100,6 +101,7 @@ module Cassandra
 
         @closed_future = begin
           @registry.remove_listener(self)
+          @schema.remove_listener(self)
 
           if state == :connecting
             f = @connected_future.recover.flat_map { close_connections }
@@ -157,6 +159,18 @@ module Cassandra
         end
       end
 
+      def keyspace_created(keyspace)
+      end
+
+      def keyspace_changed(keyspace)
+      end
+
+      def keyspace_dropped(keyspace)
+        @keyspace = nil if @keyspace == keyspace.name
+        nil
+      end
+
+
       def query(statement, options, paging_state = nil)
         request = Protocol::QueryRequest.new(statement.cql, statement.params, nil, options.consistency, options.serial_consistency, options.page_size, paging_state, options.trace?)
         timeout = options.timeout
@@ -340,7 +354,7 @@ module Cassandra
             @connecting_hosts.delete(host)
             @prepared_statements[host] = {}
             @preparing_statements[host] = {}
-            manager = @connections[host] ||= Cassandra::Client::ConnectionManager.new
+            manager = @connections[host] ||= ConnectionPool.new
           end
 
           manager.add_connections(connections)
@@ -671,9 +685,7 @@ module Cassandra
             when Protocol::RowsResultResponse
               promise.fulfill(Results::Paged.new(r.rows, r.paging_state, r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
             when Protocol::SchemaChangeResultResponse
-              if r.change == 'DROPPED' && r.keyspace == @keyspace && r.table.empty?
-                @keyspace = nil
-              end
+              @schema.delete_keyspace(r.keyspace) if r.change == 'DROPPED' && r.table.empty?
 
               @logger.debug('Waiting for schema to propagate to all hosts after a change')
               wait_for_schema_agreement(connection, @reconnection_policy.schedule).on_complete do |f|

data/lib/cassandra/{client/connection_manager.rb → cluster/connection_pool.rb}

@@ -17,14 +17,14 @@
 #++
 
 module Cassandra
-  module Client
+  class Cluster
     # @private
-    class ConnectionManager
+    class ConnectionPool
       include Enumerable
 
       def initialize
         @connections = []
-        @lock = Mutex.new
+        @lock = ::Mutex.new
       end
 
       def add_connections(connections)

data/lib/cassandra/cluster/connector.rb

@@ -22,13 +22,14 @@ module Cassandra
     class Connector
       include MonitorMixin
 
-      def initialize(logger, io_reactor, cluster_registry, connection_options)
-        @logger           = logger
-        @reactor          = io_reactor
-        @registry         = cluster_registry
-        @options          = connection_options
-        @connections      = ::Hash.new
-        @open_connections = ::Hash.new
+      def initialize(logger, io_reactor, cluster_registry, connection_options, execution_options)
+        @logger             = logger
+        @reactor            = io_reactor
+        @registry           = cluster_registry
+        @connection_options = connection_options
+        @execution_options  = execution_options
+        @connections        = ::Hash.new
+        @open_connections   = ::Hash.new
 
         mon_initialize
       end
@@ -115,13 +116,33 @@ module Cassandra
       UNCLAIMED_TIMEOUT = 5 # close unclaimed connections in five seconds
 
       def do_connect(host)
-        create_connector.connect(host.ip.to_s).fallback do |error|
+        f = @reactor.connect(host.ip.to_s, @connection_options.port, {:timeout => @connection_options.connect_timeout, :ssl => @connection_options.ssl}) do |connection|
+          raise Errors::ClientError, 'Not connected, reactor stopped' unless connection
+          Protocol::CqlProtocolHandler.new(connection, @reactor, @connection_options.protocol_version, @connection_options.compressor, @connection_options.heartbeat_interval, @connection_options.idle_timeout)
+        end
+        f = f.flat_map do |connection|
+          request_options(connection).flat_map do |options|
+            compression = @connection_options.compression
+            supported_algorithms = options['COMPRESSION']
+
+            if compression && !supported_algorithms.include?(compression)
+              @logger.warn("Compression with #{compression.inspect} is not supported by host at #{host.ip}, supported algorithms are #{supported_algorithms.inspect}")
+              compression = nil
+            end
+
+            supported_cql_versions = options['CQL_VERSION']
+            cql_version = (supported_cql_versions && !supported_cql_versions.empty?) ? supported_cql_versions.first : '3.1.0'
+
+            startup_connection(connection, cql_version, compression)
+          end
+        end
+        f.fallback do |error|
           case error
           when Errors::ProtocolError
             synchronize do
-              if @options.protocol_version > 1
-                @logger.info("Host #{host.ip} doesn't support protocol version #{@options.protocol_version}, downgrading")
-                @options.protocol_version -= 1
+              if @connection_options.protocol_version > 1
+                @logger.info("Host #{host.ip} doesn't support protocol version #{@connection_options.protocol_version}, downgrading")
+                @connection_options.protocol_version -= 1
                 do_connect(host)
               else
                 Ione::Future.failed(error)
@@ -137,32 +158,82 @@ module Cassandra
         end
       end
 
-      def create_connector
-        authentication_step = @options.protocol_version == 1 ? Cassandra::Client::CredentialsAuthenticationStep.new(@options.credentials) : Cassandra::Client::SaslAuthenticationStep.new(@options.auth_provider)
-        protocol_handler_factory = lambda do |connection|
-          raise Errors::ClientError, 'Not connected, reactor stopped' unless connection
-          Protocol::CqlProtocolHandler.new(connection, @reactor, @options.protocol_version, @options.compressor, @options.heartbeat_interval, @options.idle_timeout)
+      def startup_connection(connection, cql_version, compression)
+        connection.send_request(Protocol::StartupRequest.new(cql_version, compression), @execution_options.timeout).flat_map do |r|
+          case r
+          when Protocol::AuthenticateResponse
+            if @connection_options.protocol_version == 1
+              credentials = @connection_options.credentials
+              if credentials
+                send_credentials(connection, credentials)
+              else
+                Ione::Future.failed(Errors::AuthenticationError.new('Server requested authentication, but client was not configured to authenticate'))
+              end
+            else
+              authenticator = @connection_options.create_authenticator(r.authentication_class)
+              if authenticator
+                challenge_response_cycle(connection, authenticator, authenticator.initial_response)
+              else
+                Ione::Future.failed(Errors::AuthenticationError.new('Server requested authentication, but client was not configured to authenticate'))
+              end
+            end
+          when Protocol::ReadyResponse
+            ::Ione::Future.resolved(connection)
+          when Protocol::ErrorResponse
+            ::Ione::Future.failed(r.to_error(VOID_STATEMENT))
+          else
+            ::Ione::Future.failed(Errors::InternalError.new("Unexpected response #{r.inspect}"))
+          end
+        end
+      end
+
+      def request_options(connection)
+        connection.send_request(Protocol::OptionsRequest.new, @execution_options.timeout).map do |r|
+          case r
+          when Protocol::SupportedResponse
+            r.options
+          when Protocol::ErrorResponse
+            raise r.to_error(VOID_STATEMENT)
+          else
+            raise Errors::InternalError, "Unexpected response #{r.inspect}"
+          end
         end
+      end
 
-        Cassandra::Client::Connector.new([
-          Cassandra::Client::ConnectStep.new(
-            @reactor,
-            protocol_handler_factory,
-            @options.port,
-            {:timeout => @options.connect_timeout, :ssl => @options.ssl},
-            @logger
-          ),
-          Cassandra::Client::CacheOptionsStep.new(@options.connect_timeout),
-          Cassandra::Client::InitializeStep.new(@options.compressor, @logger),
-          authentication_step,
-          Cassandra::Client::CachePropertiesStep.new,
-        ])
+      def send_credentials(connection, credentials)
+        connection.send_request(Protocol::CredentialsRequest.new(credentials), @execution_options.timeout).map do |r|
+          case r
+          when Protocol::ReadyResponse
+            connection
+          when Protocol::ErrorResponse
+            raise r.to_error(VOID_STATEMENT)
+          else
+            raise Errors::InternalError, "Unexpected response #{r.inspect}"
+          end
+        end
+      end
+
+      def challenge_response_cycle(connection, authenticator, token)
+        connection.send_request(Protocol::AuthResponseRequest.new(token), @execution_options.timeout).flat_map do |r|
+          case r
+          when Protocol::AuthChallengeResponse
+            token = authenticator.challenge_response(r.token)
+            challenge_response_cycle(pending_connection, authenticator, token)
+          when Protocol::AuthSuccessResponse
+            authenticator.authentication_successful(r.token) rescue nil
+            ::Ione::Future.resolved(connection)
+          when Protocol::ErrorResponse
+            ::Ione::Future.failed(r.to_error(VOID_STATEMENT))
+          else
+            ::Ione::Future.failed(Errors::InternalError.new("Unexpected response #{r.inspect}"))
+          end
+        end
       end
 
       def create_additional_connections(host, count, established_connections, error = nil)
         futures = count.times.map do
           connect(host).recover do |e|
-            Cassandra::Client::FailedConnection.new(e, host)
+            FailedConnection.new(e, host)
           end
         end
 

data/lib/cassandra/cluster/control_connection.rb

@@ -333,10 +333,9 @@ module Cassandra
 
         return Ione::Future.failed(Errors::ClientError.new('Not connected')) if connection.nil?
 
-        params    = [keyspace]
-        keyspaces = send_select_request(connection, Protocol::QueryRequest.new("SELECT * FROM system.schema_keyspaces WHERE keyspace_name = ?", params, nil, :one))
-        tables    = send_select_request(connection, Protocol::QueryRequest.new("SELECT * FROM system.schema_columnfamilies WHERE keyspace_name = ?", params, nil, :one))
-        columns   = send_select_request(connection, Protocol::QueryRequest.new("SELECT * FROM system.schema_columns WHERE keyspace_name = ?", params, nil, :one))
+        keyspaces = send_select_request(connection, Protocol::QueryRequest.new("SELECT * FROM system.schema_keyspaces WHERE keyspace_name = '%s'" % keyspace, nil, nil, :one))
+        tables    = send_select_request(connection, Protocol::QueryRequest.new("SELECT * FROM system.schema_columnfamilies WHERE keyspace_name = '%s'" % keyspace, nil, nil, :one))
+        columns   = send_select_request(connection, Protocol::QueryRequest.new("SELECT * FROM system.schema_columns WHERE keyspace_name = '%s'" % keyspace, nil, nil, :one))
 
         Ione::Future.all(keyspaces, tables, columns).map do |(keyspaces, tables, columns)|
           host = @registry.host(connection.host)
@@ -396,8 +395,8 @@ module Cassandra
         return Ione::Future.failed(Errors::ClientError.new('Not connected')) if connection.nil?
 
         params   = [keyspace, table]
-        table    = send_select_request(connection, Protocol::QueryRequest.new("SELECT * FROM system.schema_columnfamilies WHERE keyspace_name = ? AND columnfamily_name = ?", params, nil, :one))
-        columns  = send_select_request(connection, Protocol::QueryRequest.new("SELECT * FROM system.schema_columns WHERE keyspace_name = ? AND columnfamily_name = ?", params, nil, :one))
+        table    = send_select_request(connection, Protocol::QueryRequest.new("SELECT * FROM system.schema_columnfamilies WHERE keyspace_name = '%s' AND columnfamily_name = '%s'" % params, nil, nil, :one))
+        columns  = send_select_request(connection, Protocol::QueryRequest.new("SELECT * FROM system.schema_columns WHERE keyspace_name = '%s' AND columnfamily_name = '%s'" % params, nil, nil, :one))
 
         Ione::Future.all(table, columns).map do |(table, columns)|
           host = @registry.host(connection.host)
@@ -563,7 +562,7 @@ module Cassandra
         if ip == connection.host
           request = SELECT_LOCAL
         else
-          request = Protocol::QueryRequest.new('SELECT rack, data_center, host_id, rpc_address, release_version, tokens FROM system.peers WHERE peer = ?', [address], nil, :one)
+          request = Protocol::QueryRequest.new("SELECT rack, data_center, host_id, rpc_address, release_version, tokens FROM system.peers WHERE peer = '%s'" % address, nil, nil, :one)
         end
 
         send_select_request(connection, request).map do |rows|

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

@@ -40,6 +40,14 @@ module Cassandra
         @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/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/driver.rb

@@ -54,7 +54,7 @@ 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, address_resolution_policy, connector) }
 
@@ -75,7 +75,7 @@ module Cassandra
     let(:protocol_version)          { 2 }
     let(:connect_timeout)           { 10 }
     let(:ssl)                       { false }
-    let(:logger)                    { Client::NullLogger.new  }
+    let(:logger)                    { NullLogger.new  }
     let(:compressor)                { nil }
     let(:credentials)               { nil }
     let(:auth_provider)             { nil }
@@ -86,7 +86,7 @@ module Cassandra
     let(:address_resolution_policy) { AddressResolution::Policies::None.new }
     let(:consistency)               { :one }
     let(:trace)                     { false }
-    let(:page_size)                 { nil }
+    let(:page_size)                 { 10000 }
     let(:heartbeat_interval)        { 30 }
     let(:idle_timeout)              { 60 }
     let(:timeout)                   { 10 }

data/lib/cassandra/errors.rb

@@ -49,28 +49,28 @@ module Cassandra
     end
 
     # Mixed into all internal driver errors.
-    module InternalError
+    class InternalError < ::RuntimeError
       include Error, HostError
     end
 
     # Raised when data decoding fails.
     class DecodingError < ::RuntimeError
-      include InternalError
+      include Error, HostError
     end
 
     # Raised when data encoding fails.
     class EncodingError < ::RuntimeError
-      include InternalError
+      include Error, HostError
     end
 
     # Raised when a connection level error occured.
     class IOError < ::IOError
-      include InternalError
+      include Error, HostError
     end
 
     # Raised when a timeout has occured.
     class TimeoutError < ::Timeout::Error
-      include InternalError
+      include Error, HostError
     end
 
     # Mixed into all request execution errors.

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