cassandra-driver 1.0.0.rc.1-java → 1.1.0-java

data/lib/cassandra/auth.rb

@@ -18,9 +18,9 @@
 
 module Cassandra
   module Auth
-    # An auth provider is a factory for {Cassandra::Auth::Authenticator} instances
-    # (or objects matching that interface). Its {#create_authenticator} will be
-    # called once for each connection that requires authentication.
+    # An auth provider is a factory for {Cassandra::Auth::Authenticator authenticator} instances (or objects matching that interface). Its
+    # {#create_authenticator} will be called once for each connection that
+    # requires authentication.
     #
     # If the authentication requires keeping state, keep that in the
     # authenticator instances, not in the auth provider.

data/lib/cassandra/cluster.rb

@@ -17,8 +17,7 @@
 #++
 
 module Cassandra
-  # Cluster represents a cassandra cluster. It serves as a {Cassandra::Session}
-  # factory and a collection of metadata.
+  # Cluster represents a cassandra cluster. It serves as a {Cassandra::Session session factory} factory and a collection of metadata.
   #
   # @see Cassandra::Cluster#connect Creating a new session
   # @see Cassandra::Cluster#each_host Getting all peers in the cluster
@@ -26,46 +25,11 @@ module Cassandra
   class Cluster
     extend Forwardable
 
-    # @!method host(address)
-    #   Find a host by its address
-    #   @param address [IPAddr, String] ip address
-    #   @return [Cassandra::Host, nil] host or nil
-    #
-    # @!method has_host?(address)
-    #   Determine if a host by a given address exists
-    #   @param address [IPAddr, String] ip address
-    #   @return [Boolean] true or false
-    def_delegators :@registry, :host, :has_host?
-
-    # @!method keyspace(name)
-    #   Find a keyspace by name
-    #   @param name [String] keyspace name
-    #   @return [Cassandra::Keyspace, nil] keyspace or nil
-    #
-    # @!method has_keyspace?(name)
-    #   Determine if a keyspace by a given name exists
-    #   @param name [String] keyspace name
-    #   @return [Boolean] true or false
-    def_delegators :@schema, :keyspace, :has_keyspace?
-
-    # @!method name
-    #   Return cluster's name
-    #   @return [String] cluster's name
-    #
-    # @!method find_replicas(keyspace, statement)
-    #   Return replicas for a given statement and keyspace
-    #   @note an empty list is returned when statement/keyspace information is
-    #     not enough to determine replica list.
-    #   @param keyspace [String] keyspace name
-    #   @param statement [Cassandra::Statement] statement for which to find
-    #     replicas
-    #   @return [Array<Cassandra::Host>] a list of replicas
-    def_delegators :@metadata, :name, :find_replicas
-
     # @private
-    def initialize(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)
+    def initialize(logger, io_reactor, executor, 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)
       @logger                = logger
       @io_reactor            = io_reactor
+      @executor              = executor
       @control_connection    = control_connection
       @registry              = cluster_registry
       @schema                = cluster_schema
@@ -78,8 +42,26 @@ module Cassandra
       @address_resolver      = address_resolution_policy
       @connector             = connector
       @futures               = futures_factory
+
+      @control_connection.on_close do |cause|
+        @load_balancing_policy.teardown(self) rescue nil
+      end
     end
 
+    # @!method name
+    #   Return cluster's name
+    #   @return [String] cluster's name
+    #
+    # @!method find_replicas(keyspace, statement)
+    #   Return replicas for a given statement and keyspace
+    #   @note an empty list is returned when statement/keyspace information is
+    #     not enough to determine replica list.
+    #   @param keyspace [String] keyspace name
+    #   @param statement [Cassandra::Statement] statement for which to find
+    #     replicas
+    #   @return [Array<Cassandra::Host>] a list of replicas
+    def_delegators :@metadata, :name, :find_replicas
+
     # Register a cluster state listener. State listener will start receiving
     # notifications about topology and schema changes
     #
@@ -115,6 +97,17 @@ module Cassandra
     end
     alias :hosts :each_host
 
+    # @!method host(address)
+    #   Find a host by its address
+    #   @param address [IPAddr, String] ip address
+    #   @return [Cassandra::Host, nil] host or nil
+    #
+    # @!method has_host?(address)
+    #   Determine if a host by a given address exists
+    #   @param address [IPAddr, String] ip address
+    #   @return [Boolean] true or false
+    def_delegators :@registry, :host, :has_host?
+
     # Yield or enumerate each keyspace defined in this cluster
     # @overload each_keyspace
     #   @yieldparam keyspace [Cassandra::Keyspace] current keyspace
@@ -128,6 +121,35 @@ module Cassandra
     end
     alias :keyspaces :each_keyspace
 
+    # @!method keyspace(name)
+    #   Find a keyspace by name
+    #   @param name [String] keyspace name
+    #   @return [Cassandra::Keyspace, nil] keyspace or nil
+    #
+    # @!method has_keyspace?(name)
+    #   Determine if a keyspace by a given name exists
+    #   @param name [String] keyspace name
+    #   @return [Boolean] true or false
+    def_delegators :@schema, :keyspace, :has_keyspace?
+
+    # @!method refresh_schema_async
+    #   Trigger an asynchronous schema metadata refresh
+    #   @return [Cassandra::Future<nil>] a future that will be fulfilled when
+    #     schema metadata has been refreshed
+    def_delegator :@control_connection, :refresh_schema_async_maybe_retry, \
+                                        :refresh_schema_async
+
+    # Synchronously refresh schema metadata
+    #
+    # @return [nil] nothing
+    # @raise [Cassandra::Errors::ClientError] when cluster is disconnected
+    # @raise [Cassandra::Error] other unexpected errors
+    #
+    # @see Cassandra::Cluster#refresh_schema_async
+    def refresh_schema
+      refresh_schema_async.get
+    end
+
     # Asynchronously create a new session, optionally scoped to a keyspace
     #
     # @param keyspace [String] optional keyspace to scope session to
@@ -195,6 +217,8 @@ module Cassandra
         else
           f.on_failure {|e| promise.break(e)}
         end
+
+        @executor.shutdown
       end
 
       promise.future
@@ -217,8 +241,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 }
@@ -138,7 +140,7 @@ module Cassandra
       end
 
       def host_down(host)
-        manager = nil
+        pool = nil
 
         synchronize do
           return Ione::Future.resolved if !@connections.has_key?(host) && !@connecting_hosts.include?(host)
@@ -147,18 +149,30 @@ module Cassandra
           @prepared_statements.delete(host)
           @preparing_statements.delete(host)
 
-          manager = @connections.delete(host)
+          pool = @connections.delete(host)
         end
 
-        if manager
-          Ione::Future.all(*manager.snapshot.map! {|c| c.close}).map(nil)
+        if pool
+          Ione::Future.all(*pool.snapshot.map! {|c| c.close}).map(nil)
         else
           Ione::Future.resolved
         end
       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?)
+      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)
+        request = Protocol::QueryRequest.new(statement.cql, statement.params, nil, options.consistency, options.serial_consistency, options.page_size, options.paging_state, options.trace?)
         timeout = options.timeout
         promise = @futures.promise
 
@@ -184,10 +198,10 @@ module Cassandra
         promise.future
       end
 
-      def execute(statement, options, paging_state = nil)
+      def execute(statement, options)
         timeout         = options.timeout
         result_metadata = statement.result_metadata
-        request         = Protocol::ExecuteRequest.new(nil, statement.params_metadata, statement.params, result_metadata.nil?, options.consistency, options.serial_consistency, options.page_size, paging_state, options.trace?)
+        request         = Protocol::ExecuteRequest.new(nil, statement.params_metadata, statement.params, result_metadata.nil?, options.consistency, options.serial_consistency, options.page_size, options.paging_state, options.trace?)
         promise         = @futures.promise
 
         keyspace = @keyspace
@@ -331,19 +345,46 @@ module Cassandra
           return NO_CONNECTIONS
         end
 
-        f = @connector.connect_many(host, pool_size)
+        pool = nil
+        existing_connections = 0
+
+        synchronize do
+          pool = @connections[host]
+        end
+
+        existing_connections = pool.size if pool
+        pool = nil
+        missing_connections  = (pool_size - existing_connections)
+        return Ione::Future.resolved if missing_connections <= 0
+
+        f = @connector.connect_many(host, missing_connections)
 
         f.on_value do |connections|
-          manager = nil
+          pool = nil
 
           synchronize do
             @connecting_hosts.delete(host)
             @prepared_statements[host] = {}
             @preparing_statements[host] = {}
-            manager = @connections[host] ||= Cassandra::Client::ConnectionManager.new
+            pool = @connections[host] ||= ConnectionPool.new
           end
 
-          manager.add_connections(connections)
+          pool.add_connections(connections)
+
+          connections.each do |connection|
+            connection.on_closed do
+              distance = nil
+
+              synchronize do
+                if !(@state == :closed || @state == :closing) && !@connecting_hosts.include?(host) && @connections.include?(host)
+                  distance = @load_balancing_policy.distance(host)
+                  @connecting_hosts[host] = distance unless distance == :ignore
+                end
+              end
+
+              connect_to_host_maybe_retry(host, distance).map(nil) if distance
+            end
+          end
         end
 
         f
@@ -356,16 +397,16 @@ module Cassandra
         end
 
         hosts << host = plan.next
-        manager = nil
-        synchronize { manager = @connections[host] }
+        pool = nil
+        synchronize { pool = @connections[host] }
 
-        unless manager
+        unless pool
           errors ||= {}
           errors[host] = NOT_CONNECTED
           return execute_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
         end
 
-        connection = manager.random_connection
+        connection = pool.random_connection
 
         if keyspace && connection.keyspace != keyspace
           switch = switch_keyspace(connection, keyspace, timeout)
@@ -430,16 +471,16 @@ module Cassandra
         end
 
         hosts << host = plan.next
-        manager = nil
-        synchronize { manager = @connections[host] }
+        pool = nil
+        synchronize { pool = @connections[host] }
 
-        unless manager
+        unless pool
           errors ||= {}
           errors[host] = NOT_CONNECTED
           return batch_by_plan(promise, keyspace, statement, options, plan, timeout, errors, hosts)
         end
 
-        connection = manager.random_connection
+        connection = pool.random_connection
 
         if keyspace && connection.keyspace != keyspace
           switch = switch_keyspace(connection, keyspace, timeout)
@@ -529,16 +570,16 @@ module Cassandra
         end
 
         hosts << host = plan.next
-        manager = nil
-        synchronize { manager = @connections[host] }
+        pool = nil
+        synchronize { pool = @connections[host] }
 
-        unless manager
+        unless pool
           errors ||= {}
           errors[host] = NOT_CONNECTED
           return send_request_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
         end
 
-        connection = manager.random_connection
+        connection = pool.random_connection
 
         if keyspace && connection.keyspace != keyspace
           switch = switch_keyspace(connection, keyspace, timeout)
@@ -671,9 +712,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)
@@ -59,6 +59,12 @@ module Cassandra
         end
       end
 
+      def size
+        @lock.synchronize do
+          @connections.size
+        end
+      end
+
       def each_connection(&callback)
         return self unless block_given?
         raise Errors::IOError, 'Not connected' unless connected?

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