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

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
@@ -333,25 +314,22 @@ 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)
 
-          @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
@@ -360,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
@@ -384,7 +357,7 @@ module Cassandra
               connection = @connection
               connection && connection.close(e)
 
-              Ione::Future.resolved
+              Ione::Future.failed(e)
             end
           end
         end
@@ -396,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 = ? 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))
+        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
 
@@ -420,7 +397,7 @@ module Cassandra
             connection = @connection
             connection && connection.close(e)
 
-            Ione::Future.resolved
+            Ione::Future.failed(e)
           end
         end.map do
           synchronize do
@@ -443,7 +420,7 @@ module Cassandra
               connection = @connection
               connection && connection.close(e)
 
-              Ione::Future.resolved
+              Ione::Future.failed(e)
             end
           end
         end
@@ -469,6 +446,7 @@ module Cassandra
             @metadata.update(data)
           end
 
+          peers.shuffle!
           peers.each do |data|
             ip = peer_ip(data)
             next unless ip
@@ -525,7 +503,7 @@ module Cassandra
             connection = @connection
             connection && connection.close(e)
 
-            Ione::Future.resolved
+            Ione::Future.failed(e)
           end
         end.map do
           synchronize do
@@ -548,7 +526,7 @@ module Cassandra
               connection = @connection
               connection && connection.close(e)
 
-              Ione::Future.resolved
+              Ione::Future.failed(e)
             end
           end
         end
@@ -563,7 +541,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|
@@ -662,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

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