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

data/lib/cassandra/address_resolution.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Cassandra
+  # Address Resolution policy allows translating a node ip address from what is
+  # recorded in Cassandra's system tables to an actual ip address for the driver
+  # to use. It is very useful in various multi-region scenarios (e.g. on EC2).
+  module AddressResolution
+    class Policy
+      # Resolves a node ip address.
+      #
+      # @param address [IPAddr] node ip address from Cassandra's system table
+      #
+      # @return [IPAddr] actual ip address of the node
+      def resolve(address)
+      end
+    end
+  end
+end
+
+require 'cassandra/address_resolution/policies'

data/lib/cassandra/address_resolution/policies.rb

@@ -0,0 +1,2 @@
+require 'cassandra/address_resolution/policies/none'
+require 'cassandra/address_resolution/policies/ec2_multi_region'

data/lib/cassandra/address_resolution/policies/ec2_multi_region.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Cassandra
+  module AddressResolution
+    module Policies
+      # This policy resolves private ips of the hosts in the same datacenter and
+      # public ips of hosts in other datacenters.
+      #
+      # @note Initializing this policy is not necessary, you should just pass
+      #   `:ec_multi_region` to the `:address_resolution` option of
+      #   {Cassandra.cluster}
+      class EC2MultiRegion
+        # @private
+        def initialize(resolver = Resolv)
+          @resolver = resolver
+        end
+
+        # Returns ip address after a double DNS lookup. First, it will get
+        # hostname from a given ip, then resolve the resulting hostname. This
+        # policy works because AWS public hostnames resolve to a private ip
+        # address within the same datacenter.
+        #
+        # @param address [IPAddr] node ip address from Cassandra's system table
+        #
+        # @return [IPAddr] private ip withing the same datacenter, public ip
+        #   otherwise. Returns original address if DNS lookups fail.
+        def resolve(address)
+          @resolver.each_name(Resolv::DNS::Name.create(address.reverse)) do |name|
+            @resolver.each_address(name) do |addr|
+              return ::IPAddr.new(addr)
+            end
+          end
+
+          # default to original address if reverse DNS lookup failed
+          address
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/address_resolution/policies/none.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Cassandra
+  module AddressResolution
+    module Policies
+      # The default address resolution policy. Always returns original address.
+      class None
+        # Returns original address.
+        #
+        # @param address [IPAddr] node ip address from Cassandra's system table
+        #
+        # @return [IPAddr] same as `address`
+        def resolve(address)
+          address
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/auth.rb

@@ -28,7 +28,7 @@ module Cassandra
     # @note Creating an authenticator must absolutely not block, or the whole
     #   connection process will block.
     #
-    # @abstract Auth providers given to {Cassandra.connect} don't need to be
+    # @abstract Auth providers given to {Cassandra.cluster} don't need to be
     #   subclasses of this class, but need to implement the same methods. This
     #   class exists only for documentation purposes.
     #

data/lib/cassandra/auth/providers/password.rb

@@ -22,7 +22,7 @@ module Cassandra
       # Auth provider used for Cassandra's built in authentication.
       #
       # @note No need to instantiate this class manually, use `:username` and
-      #   `:password` options when calling {Cassandra.connect} and one will be
+      #   `:password` options when calling {Cassandra.cluster} and one will be
       #   created automatically for you.
       class Password < Provider
         # Authenticator used for Cassandra's built in authentication,

data/lib/cassandra/cluster.rb

@@ -63,7 +63,7 @@ module Cassandra
     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, connector, futures_factory)
+    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)
       @logger                = logger
       @io_reactor            = io_reactor
       @control_connection    = control_connection
@@ -75,6 +75,7 @@ module Cassandra
       @load_balancing_policy = load_balancing_policy
       @reconnection_policy   = reconnection_policy
       @retry_policy          = retry_policy
+      @address_resolver      = address_resolution_policy
       @connector             = connector
       @futures               = futures_factory
     end
@@ -133,19 +134,22 @@ module Cassandra
     #
     # @return [Cassandra::Future<Cassandra::Session>] a future new session that
     #   can prepare and execute statements
+    #
+    # @see Cassandra::Cluster#connect A list of possible exceptions that this
+    #   future can be resolved with
     def connect_async(keyspace = nil)
       if !keyspace.nil? && !keyspace.is_a?(::String)
         return @futures.error(::ArgumentError.new("keyspace must be a string, #{keyspace.inspect} given"))
       end
 
-      client  = Client.new(@logger, @registry, @schema, @io_reactor, @connector, @load_balancing_policy, @reconnection_policy, @retry_policy, @connection_options, @futures)
+      client  = Client.new(@logger, @registry, @schema, @io_reactor, @connector, @load_balancing_policy, @reconnection_policy, @retry_policy, @address_resolver, @connection_options, @futures)
       session = Session.new(client, @execution_options, @futures)
       promise = @futures.promise
 
       client.connect.on_complete do |f|
         if f.resolved?
           if keyspace
-            f = session.execute_async("USE #{keyspace}")
+            f = session.execute_async("USE #{Util.escape_name(keyspace)}")
 
             f.on_success {promise.fulfill(session)}
             f.on_failure {|e| promise.break(e)}
@@ -162,8 +166,14 @@ module Cassandra
 
     # Synchronously create a new session, optionally scoped to a keyspace
     #
-    # @param keyspace [String] optional keyspace to scope session to
-    # @raise  [ArgumentError] if keyspace is not a String
+    # @param keyspace [String] optional keyspace to scope the session to
+    #
+    # @raise [ArgumentError] if keyspace is not a String
+    # @raise [Cassandra::Errors::NoHostsAvailable] when all hosts failed
+    # @raise [Cassandra::Errors::AuthenticationError] when authentication fails
+    # @raise [Cassandra::Errors::ProtocolError] when protocol negotiation fails
+    # @raise [Cassandra::Error] other unexpected errors
+    #
     # @return [Cassandra::Session] a new session that can prepare and execute
     #   statements
     #
@@ -181,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)}
@@ -207,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

@@ -24,7 +24,7 @@ module Cassandra
 
       attr_reader :keyspace
 
-      def initialize(logger, cluster_registry, cluster_schema, io_reactor, connector, load_balancing_policy, reconnection_policy, retry_policy, connection_options, futures_factory)
+      def initialize(logger, cluster_registry, cluster_schema, io_reactor, connector, load_balancing_policy, reconnection_policy, retry_policy, address_resolution_policy, connection_options, futures_factory)
         @logger                      = logger
         @registry                    = cluster_registry
         @schema                      = cluster_schema
@@ -33,9 +33,10 @@ module Cassandra
         @load_balancing_policy       = load_balancing_policy
         @reconnection_policy         = reconnection_policy
         @retry_policy                = retry_policy
+        @address_resolver            = address_resolution_policy
         @connection_options          = connection_options
         @futures                     = futures_factory
-        @connecting_hosts            = ::Set.new
+        @connecting_hosts            = ::Hash.new
         @connections                 = ::Hash.new
         @prepared_statements         = ::Hash.new
         @preparing_statements        = ::Hash.new
@@ -51,16 +52,23 @@ module Cassandra
           return @connected_future if @state == :connecting || @state == :connected
 
           @state = :connecting
-          @connecting_hosts.merge(@registry.hosts)
+          @registry.each_host do |host|
+            distance = @load_balancing_policy.distance(host)
+            next if distance == :ignore
+
+            @connecting_hosts[host] = distance
+          end
         end
 
         @connected_future = begin
+          @logger.info('Creating session')
           @registry.add_listener(self)
+          @schema.add_listener(self)
 
-          futures = @connecting_hosts.map do |host|
-            f = connect_to_host_maybe_retry(host, @load_balancing_policy.distance(host))
+          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
 
@@ -93,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 }
@@ -116,12 +125,18 @@ module Cassandra
       end
 
       def host_up(host)
+        distance = nil
+
         synchronize do
           return Ione::Future.resolved if @connecting_hosts.include?(host)
-          @connecting_hosts << host
+
+          distance = @load_balancing_policy.distance(host)
+          return Ione::Future.resolved if distance == :ignore
+
+          @connecting_hosts[host] = distance
         end
 
-        connect_to_host_maybe_retry(host, @load_balancing_policy.distance(host)).map(nil)
+        connect_to_host_maybe_retry(host, distance).map(nil)
       end
 
       def host_down(host)
@@ -130,7 +145,6 @@ module Cassandra
         synchronize do
           return Ione::Future.resolved if !@connections.has_key?(host) && !@connecting_hosts.include?(host)
 
-          @logger.info("Session disconnecting from ip=#{host.ip}")
           @connecting_hosts.delete(host)
           @prepared_statements.delete(host)
           @preparing_statements.delete(host)
@@ -145,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
@@ -209,13 +235,17 @@ module Cassandra
         :unlogged => Protocol::BatchRequest::UNLOGGED_TYPE,
         :counter  => Protocol::BatchRequest::COUNTER_TYPE,
       }.freeze
-      CLIENT_CLOSED        = Ione::Future.failed(Errors::ClientError.new('Cannot connect a closed client'))
-      CLIENT_NOT_CONNECTED = Ione::Future.failed(Errors::ClientError.new('Cannot close a not connected client'))
-      NOT_CONNECTED        = Errors::NotConnectedError.new
+      CLIENT_CLOSED        = Ione::Future.failed(Errors::ClientError.new('Client closed'))
+      NOT_CONNECTED        = Errors::ClientError.new('Client not connected')
+      CLIENT_NOT_CONNECTED = Ione::Future.failed(NOT_CONNECTED)
 
       UNAVAILABLE_ERROR_CODE   = 0x1000
       WRITE_TIMEOUT_ERROR_CODE = 0x1100
       READ_TIMEOUT_ERROR_CODE  = 0x1200
+      OVERLOADED_ERROR_CODE    = 0x1001
+      SERVER_ERROR_CODE        = 0x0000
+      BOOTSTRAPPING_ERROR_CODE = 0x1002
+      UNPREPARED_ERROR_CODE    = 0x2500
 
       SELECT_SCHEMA_PEERS = Protocol::QueryRequest.new("SELECT peer, rpc_address, schema_version FROM system.peers", nil, nil, :one)
       SELECT_SCHEMA_LOCAL = Protocol::QueryRequest.new("SELECT schema_version FROM system.local WHERE key='local'", nil, nil, :one)
@@ -226,14 +256,14 @@ module Cassandra
             @state = :connected
           end
 
-          @logger.info('Session connected')
+          @logger.info('Session created')
         else
           synchronize do
             @state = :defunct
           end
 
           f.on_failure do |e|
-            @logger.error('Session connect failed: %s' % e.message)
+            @logger.error("Session failed to connect (#{e.class.name}: #{e.message})")
           end
 
           close
@@ -248,20 +278,17 @@ module Cassandra
             @logger.info('Session closed')
           else
             f.on_failure do |e|
-              @logger.error('Session close failed: %s' % e.message)
+              @logger.error("Session failed to close (#{e.class.name}: #{e.message})")
             end
           end
         end
       end
 
       def close_connections
-        @logger.info('Session closing')
-
         futures = []
         synchronize do
           @connections.each do |host, connections|
             connections.snapshot.each do |c|
-              @logger.info("Disconnecting ip=#{c.host}")
               futures << c.close
             end
           end.clear
@@ -274,7 +301,7 @@ module Cassandra
         f = connect_to_host(host, distance)
 
         f.on_failure do |e|
-          connect_to_host_with_retry(host, @reconnection_policy.schedule) if e.is_a?(Io::ConnectionError) || e.is_a?(::SystemCallError) || e.is_a?(::SocketError)
+          connect_to_host_with_retry(host, @reconnection_policy.schedule)
         end
 
         f
@@ -283,21 +310,23 @@ module Cassandra
       def connect_to_host_with_retry(host, schedule)
         interval = schedule.next
 
-        @logger.info("Session started reconnecting to ip=#{host.ip} delay=#{interval}")
+        @logger.debug("Reconnecting to #{host.ip} in #{interval} seconds")
 
         f = @reactor.schedule_timer(interval)
         f.flat_map do
-          if synchronize { @connecting_hosts.include?(host) }
-            connect_to_host(host, @load_balancing_policy.distance(host)).fallback do |e|
-              if e.is_a?(Io::ConnectionError) || e.is_a?(::SystemCallError) || e.is_a?(::SocketError)
-                connect_to_host_with_retry(host, schedule)
-              else
-                Ione::Future.failed(e)
-              end
+          distance = nil
+
+          synchronize do
+            if @connecting_hosts.include?(host)
+              distance = @load_balancing_policy.distance(host)
             end
-          else
-            @logger.info("Session reconnection to ip=#{host.ip} cancelled")
+          end
 
+          if distance && distance != :ignore
+            connect_to_host(host, distance).fallback do |e|
+              connect_to_host_with_retry(host, schedule)
+            end
+          else
             NO_CONNECTIONS
           end
         end
@@ -312,22 +341,20 @@ module Cassandra
         when :remote
           pool_size = @connection_options.connections_per_remote_node
         else
-          raise ::ArgumentError, "distance must be one of :ignore, :local or :remote, #{distance.inspect} given"
+          @logger.error("Invalid load balancing distance, not connecting to #{host.ip}. Distance must be one of #{LoadBalancing::DISTANCES.inspect}, #{distance.inspect} given")
+          return NO_CONNECTIONS
         end
 
-        @logger.info("Session connecting to ip=#{host.ip}")
-
         f = @connector.connect_many(host, pool_size)
 
         f.on_value do |connections|
           manager = nil
 
           synchronize do
-            @logger.info("Session connected to ip=#{host.ip}")
             @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)
@@ -338,7 +365,7 @@ module Cassandra
 
       def execute_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors = nil, hosts = [])
         unless plan.has_next?
-          promise.break(Errors::NoHostsAvailable.new(errors || {}))
+          promise.break(Errors::NoHostsAvailable.new(errors))
           return
         end
 
@@ -361,12 +388,13 @@ module Cassandra
               prepare_and_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
             else
               s.on_failure do |e|
-                if e.is_a?(Errors::QueryError)
-                  promise.break(e)
-                else
+                case e
+                when Errors::HostError
                   errors ||= {}
                   errors[host] = e
                   execute_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                else
+                  promise.break(e)
                 end
               end
             end
@@ -395,12 +423,13 @@ module Cassandra
               do_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
             else
               prepare.on_failure do |e|
-                if e.is_a?(Errors::QueryError)
-                  promise.break(e)
-                else
+                case e
+                when Errors::HostError
                   errors ||= {}
                   errors[host] = e
                   execute_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                else
+                  promise.break(e)
                 end
               end
             end
@@ -410,7 +439,7 @@ module Cassandra
 
       def batch_by_plan(promise, keyspace, statement, options, plan, timeout, errors = nil, hosts = [])
         unless plan.has_next?
-          promise.break(Errors::NoHostsAvailable.new(errors || {}))
+          promise.break(Errors::NoHostsAvailable.new(errors))
           return
         end
 
@@ -433,12 +462,13 @@ module Cassandra
               batch_and_send_request_by_plan(host, connection, promise, keyspace, statement, options, plan, timeout, errors, hosts)
             else
               s.on_failure do |e|
-                if e.is_a?(Errors::QueryError)
-                  promise.break(e)
-                else
+                case e
+                when Errors::HostError
                   errors ||= {}
                   errors[host] = e
                   batch_by_plan(promise, keyspace, statement, options, plan, timeout, errors, hosts)
+                else
+                  promise.break(e)
                 end
               end
             end
@@ -492,12 +522,13 @@ module Cassandra
               do_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
             else
               f.on_failure do |e|
-                if e.is_a?(Errors::QueryError)
-                  promise.break(e)
-                else
+                case e
+                when Errors::HostError
                   errors ||= {}
                   errors[host] = e
                   batch_by_plan(promise, keyspace, statement, options, plan, timeout, errors, hosts)
+                else
+                  promise.break(e)
                 end
               end
             end
@@ -507,7 +538,7 @@ module Cassandra
 
       def send_request_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors = nil, hosts = [])
         unless plan.has_next?
-          promise.break(Errors::NoHostsAvailable.new(errors || {}))
+          promise.break(Errors::NoHostsAvailable.new(errors))
           return
         end
 
@@ -530,12 +561,13 @@ module Cassandra
               do_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
             else
               s.on_failure do |e|
-                if e.is_a?(Errors::QueryError)
-                  promise.break(e)
-                else
+                case e
+                when Errors::HostError
                   errors ||= {}
                   errors[host] = e
                   send_request_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                else
+                  promise.break(e)
                 end
               end
             end
@@ -564,32 +596,78 @@ module Cassandra
                 when UNAVAILABLE_ERROR_CODE
                   @retry_policy.unavailable(statement, details[:cl], details[:required], details[:alive], retries)
                 when WRITE_TIMEOUT_ERROR_CODE
-                  details[:write_type] = write_type = details[:write_type].downcase!.to_sym
-                  @retry_policy.write_timeout(statement, details[:cl], write_type, details[:blockfor], details[:received], retries)
+                  @retry_policy.write_timeout(statement, details[:cl], details[:write_type], details[:blockfor], details[:received], retries)
                 when READ_TIMEOUT_ERROR_CODE
                   @retry_policy.read_timeout(statement, details[:cl], details[:blockfor], details[:received], details[:data_present], retries)
+                when UNPREPARED_ERROR_CODE
+                  cql = statement.cql
+
+                  synchronize do
+                    @preparing_statements[host].delete(cql)
+                    @prepared_statements[host].delete(cql)
+                  end
+
+                  prepare = prepare_statement(host, connection, cql, timeout)
+                  prepare.on_complete do |_|
+                    if prepare.resolved?
+                      request.id = prepare.value
+                      do_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                    else
+                      prepare.on_failure do |e|
+                        case e
+                        when Errors::HostError
+                          errors ||= {}
+                          errors[host] = e
+                          execute_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                        else
+                          promise.break(e)
+                        end
+                      end
+                    end
+                  end
+
+                  nil
                 else
-                  promise.break(Errors::QueryError.new(r.code, r.message, statement.cql, details))
-                  break
+                  promise.break(r.to_error(statement))
+
+                  nil
                 end
               rescue => e
                 promise.break(e)
-                break
+
+                nil
               end
 
-              case decision
-              when Retry::Decisions::Retry
-                request.consistency = decision.consistency
-                do_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts, retries + 1)
-              when Retry::Decisions::Ignore
-                promise.fulfill(Results::Void.new(r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
-              when Retry::Decisions::Reraise
-                promise.break(Errors::QueryError.new(r.code, r.message, statement.cql, r.details))
-              else
-                promise.break(Errors::QueryError.new(r.code, r.message, statement.cql, r.details))
+              if decision
+                case decision
+                when Retry::Decisions::Retry
+                  request.consistency = decision.consistency
+                  do_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts, retries + 1)
+                when Retry::Decisions::Ignore
+                  promise.fulfill(Results::Void.new(r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
+                when Retry::Decisions::Reraise
+                  promise.break(r.to_error(statement))
+                else
+                  promise.break(r.to_error(statement))
+                end
               end
             when Protocol::ErrorResponse
-              promise.break(Errors::QueryError.new(r.code, r.message, statement.cql, nil))
+              case r.code
+              when OVERLOADED_ERROR_CODE, SERVER_ERROR_CODE, BOOTSTRAPPING_ERROR_CODE
+                errors ||= {}
+                errors[host] = r.to_error(statement)
+
+                case request
+                when Protocol::QueryRequest, Protocol::PrepareRequest
+                  send_request_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                when Protocol::ExecuteRequest
+                  execute_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                when Protocol::BatchRequest
+                  batch_by_plan(promise, keyspace, statement, options, plan, timeout, errors, hosts)
+                end
+              else
+                promise.break(r.to_error(statement))
+              end
             when Protocol::SetKeyspaceResultResponse
               @keyspace = r.keyspace
               promise.fulfill(Results::Void.new(r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
@@ -607,14 +685,13 @@ 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|
                 unless f.resolved?
                   f.on_failure do |e|
-                    @logger.error("Schema agreement error: #{e.class.name}: #{e.message}\n#{e.backtrace.join("\n")}")
+                    @logger.error("Schema agreement failure (#{e.class.name}: #{e.message})")
                   end
                 end
                 promise.fulfill(Results::Void.new(r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
@@ -642,42 +719,35 @@ module Cassandra
       end
 
       def wait_for_schema_agreement(connection, schedule)
-        @logger.info('Fetching schema versions')
-
-        peers = connection.send_request(SELECT_SCHEMA_PEERS)
-        local = connection.send_request(SELECT_SCHEMA_LOCAL)
+        peers = send_select_request(connection, SELECT_SCHEMA_PEERS)
+        local = send_select_request(connection, SELECT_SCHEMA_LOCAL)
 
         Ione::Future.all(peers, local).flat_map do |(peers, local)|
-          @logger.info('Fetched schema versions')
-
-          peers = peers.rows
-          local = local.rows
-
           versions = ::Set.new
 
           unless local.empty?
             host = @registry.host(connection.host)
 
-            if host && host.up?
+            if host && @load_balancing_policy.distance(host) != :ignore
               versions << version = local.first['schema_version']
-              @logger.debug("Host #{host.ip} schema version: #{version}")
+              @logger.debug("Host #{host.ip} schema version is #{version}")
             end
           end
 
           peers.each do |row|
             host = @registry.host(peer_ip(row))
-            next unless host && host.up?
+            next unless host && @load_balancing_policy.distance(host) != :ignore
 
             versions << version = row['schema_version']
-            @logger.debug("Host #{host.ip} schema version: #{version}")
+            @logger.debug("Host #{host.ip} schema version is #{version}")
           end
 
           if versions.one?
-            @logger.info('All hosts have the same schema version')
+            @logger.debug('All hosts have the same schema')
             Ione::Future.resolved
           else
             interval = schedule.next
-            @logger.info("Hosts don't yet agree on schema: #{versions.to_a.inspect}, retrying in #{interval} seconds")
+            @logger.info("Hosts have different schema versions: #{versions.to_a.inspect}, retrying in #{interval} seconds")
             @reactor.schedule_timer(interval).flat_map do
               wait_for_schema_agreement(connection, schedule)
             end
@@ -688,7 +758,8 @@ module Cassandra
       def peer_ip(data)
         ip = data['rpc_address']
         ip = data['peer'] if ip == '0.0.0.0'
-        ip
+
+        @address_resolver.resolve(ip)
       end
 
       def switch_keyspace(connection, keyspace, timeout)
@@ -697,19 +768,17 @@ module Cassandra
 
         return pending_switch || Ione::Future.resolved if pending_keyspace == keyspace
 
-        request = Protocol::QueryRequest.new("USE #{keyspace}", nil, nil, :one)
+        request = Protocol::QueryRequest.new("USE #{Util.escape_name(keyspace)}", nil, nil, :one)
 
         f = connection.send_request(request, timeout).map do |r|
           case r
           when Protocol::SetKeyspaceResultResponse
             @keyspace = r.keyspace
             nil
-          when Protocol::DetailedErrorResponse
-            raise Errors::QueryError.new(r.code, r.message, request.cql, r.details)
           when Protocol::ErrorResponse
-            raise Errors::QueryError.new(r.code, r.message, request.cql, nil)
+            raise r.to_error(Statements::Simple.new("USE #{Util.escape_name(keyspace)}"))
           else
-            raise "unexpected response #{r.inspect}"
+            raise Errors::InternalError, "Unexpected response #{r.inspect}"
           end
         end
 
@@ -742,12 +811,10 @@ module Cassandra
               @preparing_statements[host].delete(cql)
             end
             id
-          when Protocol::DetailedErrorResponse
-            raise Errors::QueryError.new(r.code, r.message, cql, r.details)
           when Protocol::ErrorResponse
-            raise Errors::QueryError.new(r.code, r.message, cql, nil)
+            raise r.to_error(VOID_STATEMENT)
           else
-            raise "unexpected response #{r.inspect}"
+            raise Errors::InternalError, "Unexpected response #{r.inspect}"
           end
         end
 
@@ -758,10 +825,17 @@ module Cassandra
         f
       end
 
-      def create_execution_info(keyspace, statement, options, request, response, hosts)
-        trace_id = response.trace_id
-        trace    = trace_id ? Execution::Trace.new(trace_id, self) : nil
-        info     = Execution::Info.new(keyspace, statement, options, hosts, request.consistency, request.retries, trace)
+      def send_select_request(connection, request)
+        connection.send_request(request).map do |r|
+          case r
+          when Protocol::RowsResultResponse
+            r.rows
+          when Protocol::ErrorResponse
+            raise r.to_error(VOID_STATEMENT)
+          else
+            raise Errors::InternalError, "Unexpected response #{r.inspect}"
+          end
+        end
       end
     end
   end