cassandra-driver 1.0.0 → 1.1.0

data/lib/cassandra/cluster/client.rb

@@ -140,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)
@@ -149,11 +149,11 @@ 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
@@ -171,8 +171,8 @@ module Cassandra
       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 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
 
@@ -198,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
@@ -345,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] ||= ConnectionPool.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
@@ -370,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)
@@ -444,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)
@@ -543,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)

data/lib/cassandra/cluster/connection_pool.rb

@@ -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/control_connection.rb

@@ -22,7 +22,7 @@ module Cassandra
     class ControlConnection
       include MonitorMixin
 
-      def initialize(logger, io_reactor, cluster_registry, cluster_schema, cluster_metadata, load_balancing_policy, reconnection_policy, address_resolution_policy, connector)
+      def initialize(logger, io_reactor, cluster_registry, cluster_schema, cluster_metadata, load_balancing_policy, reconnection_policy, address_resolution_policy, connector, connection_options)
         @logger                = logger
         @io_reactor            = io_reactor
         @registry              = cluster_registry
@@ -32,17 +32,24 @@ module Cassandra
         @reconnection_policy   = reconnection_policy
         @address_resolver      = address_resolution_policy
         @connector             = connector
-        @refreshing_statuses   = Hash.new(false)
+        @connection_options    = connection_options
+        @refreshing_statuses   = ::Hash.new(false)
         @status                = :closed
-        @refreshing_schema     = false
-        @refreshing_keyspaces  = Hash.new(false)
-        @refreshing_tables     = Hash.new
         @refreshing_hosts      = false
-        @refreshing_host       = Hash.new(false)
+        @refreshing_host       = ::Hash.new(false)
+        @closed_promise        = Ione::Promise.new
+        @schema_changes        = ::Array.new
+        @schema_refresh_timer  = nil
+        @schema_refresh_window = nil
 
         mon_initialize
       end
 
+      def on_close(&block)
+        @closed_promise.future.on_value(&block)
+        @closed_promise.future.on_failure(&block)
+      end
+
       def connect_async
         synchronize do
           return Ione::Future.resolved if @status == :connecting || @status == :connected
@@ -110,10 +117,33 @@ module Cassandra
 
       def close_async
         synchronize do
-          return Ione::Future.resolved if @status == :closing || @status == :closed
+          return @closed_promise.future if @status == :closing || @status == :closed
           @status = :closing
         end
-        @io_reactor.stop
+        f = @io_reactor.stop
+
+        f.on_value(&method(:connection_closed))
+        f.on_failure(&method(:connection_closed))
+
+        @closed_promise.future
+      end
+
+      def connection_closed(cause)
+        @closed_promise.fulfill
+      end
+
+      def refresh_schema_async_maybe_retry
+        refresh_schema_async.fallback do |e|
+          case e
+          when Errors::HostError
+            refresh_schema_async_retry(e, @reconnection_policy.schedule)
+          else
+            connection = @connection
+            connection && connection.close(e)
+
+            Ione::Future.failed(e)
+          end
+        end
       end
 
       def inspect
@@ -127,11 +157,6 @@ module Cassandra
       SELECT_KEYSPACES = Protocol::QueryRequest.new('SELECT * FROM system.schema_keyspaces', nil, nil, :one)
       SELECT_TABLES    = Protocol::QueryRequest.new('SELECT * FROM system.schema_columnfamilies', nil, nil, :one)
       SELECT_COLUMNS   = Protocol::QueryRequest.new('SELECT * FROM system.schema_columns', nil, nil, :one)
-      REGISTER         = Protocol::RegisterRequest.new(
-                           Protocol::TopologyChangeEventResponse::TYPE,
-                           Protocol::StatusChangeEventResponse::TYPE,
-                           Protocol::SchemaChangeEventResponse::TYPE
-                         )
 
       def reconnect_async(schedule)
         timeout = schedule.next
@@ -163,7 +188,14 @@ module Cassandra
 
         return Ione::Future.failed(Errors::ClientError.new('Not connected')) if connection.nil?
 
-        f = connection.send_request(REGISTER)
+        request = Protocol::RegisterRequest.new(
+          Protocol::TopologyChangeEventResponse::TYPE,
+          Protocol::StatusChangeEventResponse::TYPE
+        )
+
+        request.events << Protocol::SchemaChangeEventResponse::TYPE if @connection_options.synchronize_schema?
+
+        f = connection.send_request(request)
         f = f.map do |r|
           case r
           when Protocol::ReadyResponse
@@ -179,26 +211,7 @@ module Cassandra
             @logger.debug("Event received #{event}")
 
             if event.type == 'SCHEMA_CHANGE'
-              case event.change
-              when 'CREATED'
-                if event.table.empty?
-                  refresh_schema_async_maybe_retry
-                else
-                  refresh_keyspace_async_maybe_retry(event.keyspace)
-                end
-              when 'DROPPED'
-                if event.table.empty?
-                  refresh_schema_async_maybe_retry
-                else
-                  refresh_keyspace_async_maybe_retry(event.keyspace)
-                end
-              when 'UPDATED'
-                if event.table.empty?
-                  refresh_keyspace_async_maybe_retry(event.keyspace)
-                else
-                  refresh_table_async_maybe_retry(event.keyspace, event.table)
-                end
-              end
+              handle_schema_change(event)
             else
               case event.change
               when 'UP'
@@ -242,29 +255,6 @@ module Cassandra
         end
       end
 
-      def refresh_schema_async_maybe_retry
-        synchronize do
-          return Ione::Future.resolved if @refreshing_schema
-          @refreshing_schema = true
-        end
-
-        refresh_schema_async.fallback do |e|
-          case e
-          when Errors::HostError
-            refresh_schema_async_retry(e, @reconnection_policy.schedule)
-          else
-            connection = @connection
-            connection && connection.close(e)
-
-            Ione::Future.resolved
-          end
-        end.map do
-          synchronize do
-            @refreshing_schema = false
-          end
-        end
-      end
-
       def refresh_schema_async_retry(error, schedule)
         timeout = schedule.next
         @logger.info("Failed to refresh schema (#{error.class.name}: #{error.message}), retrying in #{timeout}")
@@ -279,18 +269,13 @@ module Cassandra
               connection = @connection
               connection && connection.close(e)
 
-              Ione::Future.resolved
+              Ione::Future.failed(e)
             end
           end
         end
       end
 
       def refresh_keyspace_async_maybe_retry(keyspace)
-        synchronize do
-          return Ione::Future.resolved if @refreshing_schema || @refreshing_keyspaces[keyspace]
-          @refreshing_keyspaces[keyspace] = true
-        end
-
         refresh_keyspace_async(keyspace).fallback do |e|
           case e
           when Errors::HostError
@@ -299,11 +284,7 @@ module Cassandra
             connection = @connection
             connection && connection.close(e)
 
-            Ione::Future.resolved
-          end
-        end.map do
-          synchronize do
-            @refreshing_keyspaces.delete(host)
+            Ione::Future.failed(e)
           end
         end
       end
@@ -322,7 +303,7 @@ module Cassandra
               connection = @connection
               connection && connection.close(e)
 
-              Ione::Future.resolved
+              Ione::Future.failed(e)
             end
           end
         end
@@ -340,17 +321,15 @@ module Cassandra
         Ione::Future.all(keyspaces, tables, columns).map do |(keyspaces, tables, columns)|
           host = @registry.host(connection.host)
 
-          @schema.update_keyspace(host, keyspaces.first, tables, columns) unless keyspaces.empty?
+          if keyspaces.empty?
+            @schema.delete_keyspace(keyspace)
+          else
+            @schema.update_keyspace(host, keyspaces.first, tables, columns)
+          end
         end
       end
 
       def refresh_table_async_maybe_retry(keyspace, table)
-        synchronize do
-          return Ione::Future.resolved if @refreshing_schema || @refreshing_keyspaces[keyspace] || @refreshing_tables[keyspace][table]
-          @refreshing_tables[keyspace] ||= ::Hash.new(false)
-          @refreshing_tables[keyspace][table] = true
-        end
-
         refresh_table_async(keyspace, table).fallback do |e|
           case e
           when Errors::HostError
@@ -359,12 +338,7 @@ module Cassandra
             connection = @connection
             connection && connection.close(e)
 
-            Ione::Future.resolved
-          end
-        end.map do
-          synchronize do
-            @refreshing_tables[keyspace].delete(table)
-            @refreshing_tables.delete(keyspace) if @refreshing_tables[keyspace].empty?
+            Ione::Future.failed(e)
           end
         end
       end
@@ -383,7 +357,7 @@ module Cassandra
               connection = @connection
               connection && connection.close(e)
 
-              Ione::Future.resolved
+              Ione::Future.failed(e)
             end
           end
         end
@@ -395,13 +369,17 @@ 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 = '%s' AND columnfamily_name = '%s'" % params, nil, nil, :one))
+        tables   = 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)|
+        Ione::Future.all(tables, columns).map do |(tables, columns)|
           host = @registry.host(connection.host)
 
-          @schema.udpate_table(host, keyspace, table, columns)
+          if tables.empty?
+            @schema.delete_table(keyspace, table)
+          else
+            @schema.udpate_table(host, keyspace, tables.first, columns)
+          end
         end
       end
 
@@ -419,7 +397,7 @@ module Cassandra
             connection = @connection
             connection && connection.close(e)
 
-            Ione::Future.resolved
+            Ione::Future.failed(e)
           end
         end.map do
           synchronize do
@@ -442,7 +420,7 @@ module Cassandra
               connection = @connection
               connection && connection.close(e)
 
-              Ione::Future.resolved
+              Ione::Future.failed(e)
             end
           end
         end
@@ -468,6 +446,7 @@ module Cassandra
             @metadata.update(data)
           end
 
+          peers.shuffle!
           peers.each do |data|
             ip = peer_ip(data)
             next unless ip
@@ -524,7 +503,7 @@ module Cassandra
             connection = @connection
             connection && connection.close(e)
 
-            Ione::Future.resolved
+            Ione::Future.failed(e)
           end
         end.map do
           synchronize do
@@ -547,7 +526,7 @@ module Cassandra
               connection = @connection
               connection && connection.close(e)
 
-              Ione::Future.resolved
+              Ione::Future.failed(e)
             end
           end
         end
@@ -661,6 +640,92 @@ Control connection failed and is unlikely to recover.
         @address_resolver.resolve(ip)
       end
 
+      def process_schema_changes(schema_changes)
+        refresh_keyspaces = ::Hash.new
+        refresh_tables    = ::Hash.new
+
+        schema_changes.each do |change|
+          keyspace = change.keyspace
+          table    = change.table
+
+          next if refresh_keyspaces.has_key?(keyspace)
+
+          if table.empty?
+            refresh_tables.delete(keyspace)
+            refresh_keyspaces[keyspace] = true
+          else
+            tables = refresh_tables[keyspace] ||= ::Hash.new
+            tables[table] = true
+          end
+        end
+
+        futures = ::Array.new
+
+        refresh_keyspaces.each do |(keyspace, _)|
+          futures << refresh_keyspace_async_maybe_retry(keyspace)
+        end
+
+        refresh_tables.each do |(keyspace, tables)|
+          tables.each do |(table, _)|
+            futures << refresh_table_async_maybe_retry(keyspace, table)
+          end
+        end
+
+        Ione::Future.all(*futures)
+      end
+
+      def handle_schema_change(change)
+        timer = nil
+        expiration_timer = nil
+
+        synchronize do
+          @schema_changes << change
+
+          @io_reactor.cancel_timer(@schema_refresh_timer) if @schema_refresh_timer
+          timer = @schema_refresh_timer = @io_reactor.schedule_timer(@connection_options.schema_refresh_delay)
+
+          unless @schema_refresh_window
+            expiration_timer = @schema_refresh_window = @io_reactor.schedule_timer(@connection_options.schema_refresh_timeout)
+          end
+        end
+
+        if expiration_timer
+          expiration_timer.on_value do
+            schema_changes = nil
+
+            synchronize do
+              @io_reactor.cancel_timer(@schema_refresh_timer)
+
+              @schema_refresh_window = nil
+              @schema_refresh_timer  = nil
+
+              schema_changes  = @schema_changes
+              @schema_changes = ::Array.new
+            end
+
+            process_schema_changes(schema_changes)
+          end
+        end
+
+        timer.on_value do
+          schema_changes = nil
+
+          synchronize do
+            @io_reactor.cancel_timer(@schema_refresh_window)
+
+            @schema_refresh_window = nil
+            @schema_refresh_timer  = nil
+
+            schema_changes  = @schema_changes
+            @schema_changes = ::Array.new
+          end
+
+          process_schema_changes(schema_changes)
+        end
+
+        nil
+      end
+
       def send_select_request(connection, request)
         connection.send_request(request).map do |r|
           case r