cassandra-driver 3.0.0.rc.2-java → 3.0.2-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 31c4aade473cf9c4faf5c905819d7e70346fb287
-  data.tar.gz: 640e1bba76cc474ddea22ec12f61d14390bc1dc2
+  metadata.gz: 78dc265751584f3c23a824f4f8f8cfebd5f98d32
+  data.tar.gz: 303da68ffd2ec37685f54a22e7c26f0f3568b51d
 SHA512:
-  metadata.gz: 5de161197b459eb8b5362c3594bd556fd87f25e5eb1038352e218be5ef170bdb20e2757d33e16430ba569564eed6f88fabe98dc4a1f1a84facff5c80e24310fb
-  data.tar.gz: cf8dee7303a54788a68786b89142873056172cc28381c744af30fb55e6972af4db0297da551011d49725c297777e0dca80fd8e7d102fe957e006b5d21ccb9685
+  metadata.gz: 7ecd09602150990d62b56ba5b0c75e1131f54b7c598171f0ca17927dfaf2fc3a2b1bc66c2ffb7b1b61f0164daa6fcbd359c3c6d6528230b05d4e5ba34482665b
+  data.tar.gz: 64d64fadf8a713b97079096af4aafd966689f9b8e9e0a6e1acae8442229de407599e3d4318eed80614fb30af5fb53db4a98e340c9a8c3490b03ae07e3a363023

data/README.md

@@ -1,6 +1,6 @@
 # Datastax Ruby Driver for Apache Cassandra
 
-*If you're reading this on GitHub, please note that this is the readme for the development version and that some features described here might not yet have been released. You can [find the documentation for latest version through ruby driver docs](http://datastax.github.io/ruby-driver/) or via the release tags, [e.g. v3.0.0-rc.2](https://github.com/datastax/ruby-driver/tree/v3.0.0-rc.2).*
+*If you're reading this on GitHub, please note that this is the readme for the development version and that some features described here might not yet have been released. You can [find the documentation for the latest version through ruby driver docs](http://docs.datastax.com/en/latest-ruby-driver/ruby-driver/whatsNew.html) or via the release tags, [e.g. v3.0.2](https://github.com/datastax/ruby-driver/tree/v3.0.2).*
 
 [![Build Status](https://travis-ci.org/datastax/ruby-driver.svg?branch=master)](https://travis-ci.org/datastax/ruby-driver)
 
@@ -8,7 +8,7 @@ A Ruby client driver for Apache Cassandra. This driver works exclusively with
 the Cassandra Query Language version 3 (CQL3) and Cassandra's native protocol.
 
 - Code: https://github.com/datastax/ruby-driver
-- Docs: http://datastax.github.io/ruby-driver/
+- Docs: http://docs.datastax.com/en/latest-ruby-driver/ruby-driver/whatsNew.html
 - Jira: https://datastax-oss.atlassian.net/browse/RUBY
 - Mailing List: https://groups.google.com/a/lists.datastax.com/forum/#!forum/ruby-driver-user
 - IRC: #datastax-drivers on [irc.freenode.net](http://freenode.net>)
@@ -16,14 +16,14 @@ the Cassandra Query Language version 3 (CQL3) and Cassandra's native protocol.
 
 This driver is based on [the cql-rb gem](https://github.com/iconara/cql-rb) by [Theo Hultberg](https://github.com/iconara) and we added support for:
 
-* [Asynchronous execution](http://datastax.github.io/ruby-driver/features/asynchronous_io/)
-* One-off, [prepared](http://datastax.github.io/ruby-driver/features/basics/prepared_statements/) and [batch statements](http://datastax.github.io/ruby-driver/features/basics/batch_statements/)
-* Automatic peer discovery and cluster metadata with [support for change notifications](http://datastax.github.io/ruby-driver/features/state_listeners/)
-* Various [load-balancing](http://datastax.github.io/ruby-driver/features/load_balancing/), [retry](http://datastax.github.io/ruby-driver/features/retry_policies/) and [reconnection](http://datastax.github.io/ruby-driver/features/reconnection/) policies with [ability to write your own](http://datastax.github.io/ruby-driver/features/load_balancing/implementing_a_policy/)
-* [SSL encryption](http://datastax.github.io/ruby-driver/features/security/ssl_encryption/)
-* [Flexible and robust error handling](http://datastax.github.io/ruby-driver/features/error_handling/)
-* [Per-request execution information and tracing](http://datastax.github.io/ruby-driver/features/debugging/)
-* [Configurable address resolution](http://datastax.github.io/ruby-driver/features/address_resolution/)
+* [Asynchronous execution](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/asynchronous_io/)
+* One-off, [prepared](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/basics/prepared_statements/) and [batch statements](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/basics/batch_statements/)
+* Automatic peer discovery and cluster metadata with [support for change notifications](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/state_listeners/)
+* Various [load-balancing](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/load_balancing/), [retry](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/retry_policies/) and [reconnection](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/reconnection/) policies with [ability to write your own](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/load_balancing/implementing_a_policy/)
+* [SSL encryption](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/security/ssl_encryption/)
+* [Flexible and robust error handling](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/error_handling/)
+* [Per-request execution information and tracing](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/debugging/)
+* [Configurable address resolution](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/address_resolution/)
 
 [Check out the slides from Ruby Driver Explained](https://speakerdeck.com/avalanche123/ruby-driver-explained) for a detailed overview of the Ruby Driver architecture.
 
@@ -31,8 +31,8 @@ This driver is based on [the cql-rb gem](https://github.com/iconara/cql-rb) by [
 
 This driver works exclusively with the Cassandra Query Language v3 (CQL3) and Cassandra's native protocol. The current version works with:
 
-* Apache Cassandra versions 1.2, 2.0, 2.1, and 3.x
-* DataStax Enterprise 4.0, 4.5, 4.6, 4.7, and 4.8
+* Apache Cassandra versions 1.2, 2.0, 2.1, 2.2, and 3.x
+* DataStax Enterprise 4.0 and above.
 * Ruby (MRI) 2.2, 2.3
 * JRuby 1.7
 
@@ -67,9 +67,9 @@ __Note__: The host you specify is just a seed node, the driver will automaticall
 
 Read more:
 
-* [`Cassandra.cluster` options](http://datastax.github.io/ruby-driver/api/#cluster-class_method)
-* [`Session#execute_async` options](http://datastax.github.io/ruby-driver/api/session/#execute_async-instance_method)
-* [Usage documentation](http://datastax.github.io/ruby-driver/features)
+* [`Cassandra.cluster` options](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/api/cassandra/#cluster-class_method)
+* [`Session#execute_async` options](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/api/cassandra/session/#execute_async-instance_method)
+* [Usage documentation](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features)
 
 ## Installation
 
@@ -85,39 +85,46 @@ Install via Gemfile
 gem 'cassandra-driver'
 ```
 
-__Note__: if you want to use compression you should also install [snappy](http://rubygems.org/gems/snappy) or [lz4-ruby](http://rubygems.org/gems/lz4-ruby). [Read more about compression.](http://datastax.github.io/ruby-driver/features/#compression)
+__Note__: if you want to use compression you should also install [snappy](http://rubygems.org/gems/snappy) or [lz4-ruby](http://rubygems.org/gems/lz4-ruby). [Read more about compression.](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/#compression)
 
 
 ## Upgrading from cql-rb
 
-Some of the new features added to the driver have unfortunately led to changes in the original cql-rb API. In the examples directory, you can find [an example of how to wrap the ruby driver to achieve almost complete interface parity with cql-rb](https://github.com/datastax/ruby-driver/blob/master/examples/cql-rb-wrapper.rb) to assist you with gradual upgrade.
+Some of the new features added to the driver have unfortunately led to changes in the original cql-rb API. In the examples directory, you can find [an example of how to wrap the ruby driver to achieve almost complete interface parity with cql-rb](https://github.com/datastax/ruby-driver/blob/v3.0.2/examples/cql-rb-wrapper.rb) to assist you with gradual upgrade.
 
-## What's new in v3.0.0
+## What's new in v3.0
+
+See the [changelog](https://github.com/datastax/ruby-driver/blob/v3.0.2/CHANGELOG.md) for details on patch versions.
 
 ### Features:
 
-* Apache Cassandra native protocol v4
-* Add support for smallint, tinyint, date (Cassandra::Date) and time (Cassandra::Time) data types.
+* Add support for Apache Cassandra native protocol v4
+* Add support for smallint, tinyint, date (`Cassandra::Date`) and time (`Cassandra::Time`) data types.
 * Include schema metadata for User Defined Functions and User Defined Aggregates.
+* Augment the `Cassandra::Table` object to expose many more attributes: `id`, `options`, `keyspace`, `partition_key`, `clustering_columns`, and `clustering_order`. This makes it significantly easier to write administration scripts that report various attributes of your schema, which may help to highlight areas for improvement.
 * Include client ip addresses in request traces, only on Cassandra 3.x.
-* Add new retry policy decision Cassandra::Retry::Policy#try_next_host.
-* Support specifying statement idempotence with the new :idempotent option when executing.
-* Support sending custom payloads when preparing or executing statements using the new :payload option.
-* Expose custom payloads received with responses on server exceptions and Cassandra::Execution::Info instances.
-* Expose server warnings on server exceptions and Cassandra::Execution::Info instances.
-* Add connections_per_local_node, connections_per_remote_node, requests_per_connection cluster configuration options to tune parallel query execution and resource usage.
-* Add Cassandra::Logger class to make it easy for users to enable debug logging in the client.
-* Add protocol_version configuration option to allow the user to force the protocol version to use for communication with nodes.
+* Add new retry policy decision `Cassandra::Retry::Policy#try_next_host`.
+* Support specifying statement idempotence with the new `idempotent` option when executing.
+* Support sending custom payloads when preparing or executing statements using the new `payload` option.
+* Expose custom payloads received with responses on server exceptions and `Cassandra::Execution::Info` instances.
+* Expose server warnings on server exceptions and `Cassandra::Execution::Info` instances.
+* Add `connections_per_local_node`, `connections_per_remote_node`, `requests_per_connection` cluster configuration options to tune parallel query execution and resource usage.
+* Add `Cassandra::Logger` class to make it easy for users to enable debug logging in the client.
+* Add `protocol_version` configuration option to allow the user to force the protocol version to use for communication with nodes.
 * Add support for materialized views and indexes in the schema metadata.
+* Support the `ReadError`, `WriteError`, and `FunctionCallError` Cassandra error responses introduced in Cassandra 2.2.
+* Add support for unset variables in bound statements.
+* Support DSE security (`DseAuthenticator`, configured for LDAP).
+* Add a timeout option to `Cassandra::Future#get`.
 
-### Breaking Changes:
+### Breaking Changes from 2.x:
 
-* Cassandra::Future#join is now an alias to Cassandra::Future#get and will raise an error if the future is resolved with one.
+* `Cassandra::Future#join` is now an alias to Cassandra::Future#get and will raise an error if the future is resolved with one.
 * Default consistency level is now LOCAL_ONE.
 * Enable tcp no-delay by default.
 * Unavailable errors are retried on the next host in the load balancing plan by default.
-* Statement execution no longer retried on timeouts, unless :idempotent => true has been specified when executing.
-* Cassandra::Statements::Batch#add signature has changed in how one specifies query parameters. Specify the query parameters array as the value of the arguments key:
+* Statement execution no longer retried on timeouts, unless the statement is marked as idempotent in the call to `Cassandra::Session#execute*` or when creating a `Cassandra::Statement` object. 
+* `Cassandra::Statements::Batch#add` and `Cassandra::Session#execute*` signatures have changed in how one specifies query parameters. Specify the query parameters array as the value of the arguments key:
  
 ```ruby
 batch.add(query, ['val1', 'val2'])
@@ -128,6 +135,10 @@ batch.add(query, {p1: 'val1'})
 # becomes
 batch.add(query, arguments: {p1: 'val1'})
 ```
+* The Datacenter-aware load balancing policy (`Cassandra::LoadBalancing::Policies::DCAwareRoundRobin`) defaults to using
+  nodes in the local DC only. In prior releases, the policy would fall back to remote nodes after exhausting local nodes.
+  Specify a positive value (or nil for unlimited) for `max_remote_hosts_to_use` when initializing the policy to allow remote node use.
+* Unspecified variables in statements previously resulted in an exception. Now they are essentially ignored or treated as null.
 
 ### Bug Fixes:
 
@@ -135,12 +146,13 @@ batch.add(query, arguments: {p1: 'val1'})
 * [[RUBY-143](https://datastax-oss.atlassian.net/browse/RUBY-143)] Retry querying system table for metadata of new hosts when prior attempts fail, ultimately enabling use of new hosts.
 * [[RUBY-150](https://datastax-oss.atlassian.net/browse/RUBY-150)] Fixed a protocol decoding error that occurred when multiple messages are available in a stream.
 * [[RUBY-151](https://datastax-oss.atlassian.net/browse/RUBY-151)] Decode incomplete UDTs properly.
-* [[RUBY-161](https://datastax-oss.atlassian.net/browse/RUBY-161)] Protocol version negotiation in mixed version clusters should not fall back to v1 unless it is truly warranted.    
+* [[RUBY-155](https://datastax-oss.atlassian.net/browse/RUBY-155)] Request timeout timer should not include request queuing time.
+* [[RUBY-161](https://datastax-oss.atlassian.net/browse/RUBY-161)] Protocol version negotiation in mixed version clusters should not fall back to v1 unless it is truly warranted.
+* [[RUBY-214](https://datastax-oss.atlassian.net/browse/RUBY-214)] Ensure client timestamps have microsecond precision in JRuby. Previously, some row updates would get lost in high transaction environments.
 
 ## Feedback Requested
 
-*Help us focus our efforts!* [Provide your input](http://goo.gl/forms/pCs8PTpHLf)
-on the Ruby Driver Platform and Runtime Survey (we kept it short).
+*Help us focus our efforts!* [Provide your input](http://goo.gl/forms/pCs8PTpHLf) on the Ruby Driver Platform and Runtime Survey (we kept it short).
 
 ## Code examples
 
@@ -152,7 +164,7 @@ examples in the `features/` directory.
 ## Running tests
 
 If you don't feel like reading through the following instructions on how to run
-ruby-driver tests, feel free to [check out .travis.yml for the entire build code](https://github.com/datastax/ruby-driver/blob/master/.travis.yml).
+ruby-driver tests, feel free to [check out .travis.yml for the entire build code](https://github.com/datastax/ruby-driver/blob/v3.0.2/.travis.yml).
 
 * Check out the driver codebase and install test dependencies:
 
@@ -176,7 +188,7 @@ CASSANDRA_VERSION=2.0.17 bundle exec rake test # run both as well as integration
 ## Changelog & versioning
 
 Check out the [releases on GitHub](https://github.com/datastax/ruby-driver/releases) and
-[changelog](https://github.com/datastax/ruby-driver/blob/master/CHANGELOG.md). Version
+[changelog](https://github.com/datastax/ruby-driver/blob/v3.0.2/CHANGELOG.md). Version
 numbering follows the [semantic versioning](http://semver.org/) scheme.
 
 Private and experimental APIs, defined as whatever is not in the
@@ -200,7 +212,7 @@ the release.
 * Because the driver reactor is using `IO.select`, the maximum number of tcp connections allowed is 1024.
 * Because the driver uses `IO#write_nonblock`, Windows is not supported.
 
-Please [refer to the usage documentation for more information on common pitfalls](http://datastax.github.io/ruby-driver/features/)
+Please [refer to the usage documentation for more information on common pitfalls](http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/features/)
 
 ## Contributing
 
@@ -230,4 +242,4 @@ License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
 either express or implied. See the License for the specific language governing permissions
 and limitations under the License.
 
-  [1]: http://datastax.github.io/ruby-driver/api
+  [1]: http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/api

data/lib/cassandra.rb

@@ -66,6 +66,7 @@ module Cassandra
     :connections_per_remote_node,
     :consistency,
     :credentials,
+    :custom_types,
     :datacenter,
     :futures_factory,
     :heartbeat_interval,
@@ -187,14 +188,17 @@ module Cassandra
   #   v2 or earlier protocol.
   #
   # @option options [Integer] :protocol_version (nil) Version of protocol to speak to
-  #   nodes. By default, this is auto-negotiated to the lowest common protocol version
+  #   nodes. By default, this is auto-negotiated to the highest common protocol version
   #   that all nodes in `:hosts` speak.
   #
-  # @option options [Boolean] :client_timestamps (false) whether the driver
-  #   should send timestamps for each executed statement. Enabling this setting
-  #   allows mitigating Cassandra cluster clock skew because the timestamp of
-  #   the client machine will be used. This does not help mitigate application
-  #   cluster clock skew.
+  # @option options [Boolean, Cassandra::TimestampGenerator] :client_timestamps (false) whether the driver
+  #   should send timestamps for each executed statement and possibly which timestamp generator to use. Enabling this
+  #   setting helps mitigate Cassandra cluster clock skew because the timestamp of the client machine will be used.
+  #   This does not help mitigate application cluster clock skew. Also accepts an initialized
+  #   {Cassandra::TimestampGenerator}, `:simple` (indicating an instance of {Cassandra::TimestampGenerator::Simple}),
+  #   or `:monotonic` (indicating an instance of {Cassandra::TimestampGenerator::TickingOnDuplicate}). If set to true,
+  #   it defaults to {Cassandra::TimestampGenerator::Simple} for all Ruby flavors except JRuby. On JRuby, it defaults to
+  #   {Cassandra::TimestampGenerator::TickingOnDuplicate}.
   #
   # @option options [Boolean] :synchronize_schema (true) whether the driver
   #   should automatically keep schema metadata synchronized. When enabled, the
@@ -290,28 +294,7 @@ module Cassandra
   # @return [Cassandra::Future<Cassandra::Cluster>] a future resolving to the
   #   cluster instance.
   def self.cluster_async(options = {})
-    options = validate_and_massage_options(options)
-    hosts = []
-
-    Array(options.fetch(:hosts, '127.0.0.1')).each do |host|
-      case host
-      when ::IPAddr
-        hosts << host
-      when ::String # ip address or hostname
-        Resolv.each_address(host) do |ip|
-          hosts << ::IPAddr.new(ip)
-        end
-      else
-        raise ::ArgumentError, ":hosts must be String or IPAddr, #{host.inspect} given"
-      end
-    end
-
-    if hosts.empty?
-      raise ::ArgumentError,
-            ":hosts #{options[:hosts].inspect} could not be resolved to any ip address"
-    end
-
-    hosts.shuffle!
+    options, hosts = validate_and_massage_options(options)
   rescue => e
     futures = options.fetch(:futures_factory) { return Future::Error.new(e) }
     futures.error(e)
@@ -661,14 +644,14 @@ module Cassandra
 
       case address_resolution
       when :none
-        # do nothing
+      # do nothing
       when :ec2_multi_region
         options[:address_resolution_policy] =
           AddressResolution::Policies::EC2MultiRegion.new
       else
         raise ::ArgumentError,
               ':address_resolution must be either :none or :ec2_multi_region, ' \
-                  "#{address_resolution.inspect} given"
+                "#{address_resolution.inspect} given"
       end
     end
 
@@ -682,7 +665,35 @@ module Cassandra
     end
 
     options[:synchronize_schema] = !!options[:synchronize_schema] if options.key?(:synchronize_schema)
-    options[:client_timestamps] = !!options[:client_timestamps] if options.key?(:client_timestamps)
+
+    if options.key?(:client_timestamps)
+      timestamp_generator = case options[:client_timestamps]
+                            when true
+                              if RUBY_ENGINE == 'jruby'
+                                Cassandra::TimestampGenerator::TickingOnDuplicate.new
+                              else
+                                Cassandra::TimestampGenerator::Simple.new
+                              end
+                            when false
+                              nil
+                            when :simple
+                              Cassandra::TimestampGenerator::Simple.new
+                            when :monotonic
+                              Cassandra::TimestampGenerator::TickingOnDuplicate.new
+                            else
+                              # The value must be a generator instance.
+                              options[:client_timestamps]
+                            end
+
+      if timestamp_generator
+        Util.assert_responds_to(:next, timestamp_generator) do
+          ":client_timestamps #{options[:client_timestamps].inspect} must be a boolean, :simple, :monotonic, or " \
+          'an object that responds to :next'
+        end
+      end
+      options.delete(:client_timestamps)
+      options[:timestamp_generator] = timestamp_generator
+    end
 
     if options.key?(:connections_per_local_node)
       connections_per_node = options[:connections_per_local_node]
@@ -726,7 +737,31 @@ module Cassandra
         end
       end
     end
-    options
+
+    # Get host addresses.
+    hosts = []
+
+    Array(options.fetch(:hosts, '127.0.0.1')).each do |host|
+      case host
+      when ::IPAddr
+        hosts << host
+      when ::String # ip address or hostname
+        Resolv.each_address(host) do |ip|
+          hosts << ::IPAddr.new(ip)
+        end
+      else
+        raise ::ArgumentError, ":hosts must be String or IPAddr, #{host.inspect} given"
+      end
+    end
+
+    if hosts.empty?
+      raise ::ArgumentError,
+            ":hosts #{options[:hosts].inspect} could not be resolved to any ip address"
+    end
+
+    hosts.shuffle!
+
+    [options, hosts]
   end
 
   # @private
@@ -767,6 +802,7 @@ require 'cassandra/null_logger'
 require 'cassandra/executors'
 require 'cassandra/future'
 require 'cassandra/cluster'
+require 'cassandra/custom_data'
 require 'cassandra/driver'
 require 'cassandra/host'
 require 'cassandra/session'
@@ -793,12 +829,18 @@ require 'cassandra/load_balancing'
 require 'cassandra/reconnection'
 require 'cassandra/retry'
 require 'cassandra/address_resolution'
+require 'cassandra/timestamp_generator'
 
 require 'cassandra/util'
 
 # murmur3 hash extension
 require 'cassandra_murmur3'
 
+# SortedSet has a race condition where it does some class/global initialization when the first instance is created.
+# If this is done in a multi-threaded environment, bad things can happen. So force the initialization here,
+# when loading the C* module.
+::SortedSet.new
+
 module Cassandra
   # @private
   VOID_STATEMENT = Statements::Void.new

data/lib/cassandra/auth.rb

@@ -34,7 +34,7 @@ module Cassandra
     #
     # @see Cassandra::Auth::Providers
     class Provider
-      # @!method create_authenticator(authentication_class, protocol_version)
+      # @!method create_authenticator(authentication_class, host)
       #
       # Create a new authenticator object. This method will be called once per
       # connection that requires authentication. The auth provider can create
@@ -45,6 +45,8 @@ module Cassandra
       #
       # @param authentication_class [String] the authentication class used by
       #   the server.
+      # @param host [Cassandra::Host] the node to whom we're authenticating.
+      #
       # @return [Cassandra::Auth::Authenticator, nil] an object with an
       #   interface matching {Cassandra::Auth::Authenticator} or `nil` if the
       #   authentication class is not supported.

data/lib/cassandra/cluster.rb

@@ -41,7 +41,8 @@ module Cassandra
                    retry_policy,
                    address_resolution_policy,
                    connector,
-                   futures_factory)
+                   futures_factory,
+                   timestamp_generator)
       @logger                = logger
       @io_reactor            = io_reactor
       @executor              = executor
@@ -57,6 +58,7 @@ module Cassandra
       @address_resolver      = address_resolution_policy
       @connector             = connector
       @futures               = futures_factory
+      @timestamp_generator   = timestamp_generator
 
       @control_connection.on_close do |_cause|
         begin
@@ -204,7 +206,8 @@ module Cassandra
                            @retry_policy,
                            @address_resolver,
                            @connection_options,
-                           @futures)
+                           @futures,
+                           @timestamp_generator)
       session = Session.new(client, @execution_options, @futures)
       promise = @futures.promise
 
@@ -275,7 +278,15 @@ module Cassandra
 
     # @private
     def inspect
-      "#<#{self.class.name}:0x#{object_id.to_s(16)}>"
+      "#<#{self.class.name}:0x#{object_id.to_s(16)} " \
+      "name=#{name.inspect}, " \
+      "port=#{@connection_options.port}, " \
+      "protocol_version=#{@connection_options.protocol_version}, " \
+      "load_balancing_policy=#{@load_balancing_policy.inspect}, " \
+      "consistency=#{@execution_options.consistency.inspect}, " \
+      "timeout=#{@execution_options.timeout.inspect}, " \
+      "hosts=#{hosts.inspect}, " \
+      "keyspaces=#{keyspaces.inspect}>"
     end
   end
 end

data/lib/cassandra/cluster/client.rb

@@ -34,7 +34,8 @@ module Cassandra
                      retry_policy,
                      address_resolution_policy,
                      connection_options,
-                     futures_factory)
+                     futures_factory,
+                     timestamp_generator)
         @logger                      = logger
         @registry                    = cluster_registry
         @schema                      = cluster_schema
@@ -52,6 +53,7 @@ module Cassandra
         @pending_connections         = ::Hash.new
         @keyspace                    = nil
         @state                       = :idle
+        @timestamp_generator         = timestamp_generator
 
         mon_initialize
       end
@@ -228,11 +230,7 @@ module Cassandra
               'Apache Cassandra'))
         end
 
-        timestamp = nil
-        if @connection_options.client_timestamps? &&
-           @connection_options.protocol_version > 2
-          timestamp = ::Time.now
-        end
+        timestamp = @timestamp_generator.next if @timestamp_generator && @connection_options.protocol_version > 2
         payload   = nil
         payload   = options.payload if @connection_options.protocol_version >= 4
         request   = Protocol::QueryRequest.new(statement.cql,
@@ -286,11 +284,7 @@ module Cassandra
       end
 
       def execute(statement, options)
-        timestamp = nil
-        if @connection_options.client_timestamps? &&
-           @connection_options.protocol_version > 2
-          timestamp = ::Time.now
-        end
+        timestamp = @timestamp_generator.next if @timestamp_generator && @connection_options.protocol_version > 2
         payload         = nil
         payload         = options.payload if @connection_options.protocol_version >= 4
         timeout         = options.timeout
@@ -324,11 +318,7 @@ module Cassandra
               'Apache Cassandra'))
         end
 
-        timestamp = nil
-        if @connection_options.client_timestamps? &&
-           @connection_options.protocol_version > 2
-          timestamp = ::Time.now
-        end
+        timestamp = @timestamp_generator.next if @timestamp_generator && @connection_options.protocol_version > 2
         payload   = nil
         payload   = options.payload if @connection_options.protocol_version >= 4
         timeout   = options.timeout
@@ -644,7 +634,15 @@ module Cassandra
                                            errors,
                                            hosts)
         cql = statement.cql
-        id  = synchronize { @prepared_statements[host][cql] }
+        id = nil
+        host_is_up = true
+        synchronize do
+          if @prepared_statements[host].nil?
+            host_is_up = false
+          else
+            id = @prepared_statements[host][cql]
+          end
+        end
 
         if id
           request.id = id
@@ -659,6 +657,19 @@ module Cassandra
                                   timeout,
                                   errors,
                                   hosts)
+        elsif !host_is_up
+          # We've hit a race condition where the plan says we can query this host, but the host has gone
+          # down in the mean time. Just execute the plan again on the next host.
+          @logger.debug("#{host} is down; executing plan on next host")
+          execute_by_plan(promise,
+                          keyspace,
+                          statement,
+                          options,
+                          request,
+                          plan,
+                          timeout,
+                          errors,
+                          hosts)
         else
           prepare = prepare_statement(host, connection, cql, timeout)
           prepare.on_complete do |_|
@@ -816,10 +827,29 @@ module Cassandra
           cql = statement.cql
 
           if statement.is_a?(Statements::Bound)
-            id = synchronize { @prepared_statements[host][cql] }
+            host_is_up = true
+            id = nil
+            synchronize do
+              if @prepared_statements[host].nil?
+                host_is_up = false
+              else
+                id = @prepared_statements[host][cql]
+              end
+            end
 
             if id
               request.add_prepared(id, statement.params, statement.params_types)
+            elsif !host_is_up
+              @logger.debug("#{host} is down; executing on next host in plan")
+              return batch_by_plan(promise,
+                                   keyspace,
+                                   batch_statement,
+                                   options,
+                                   request,
+                                   plan,
+                                   timeout,
+                                   errors,
+                                   hosts)
             else
               unprepared[cql] << statement
             end
@@ -1156,17 +1186,17 @@ module Cassandra
               end
             when Protocol::SetKeyspaceResultResponse
               @keyspace = r.keyspace
-              promise.fulfill(Results::Void.new(r.custom_payload,
-                                                r.warnings,
-                                                r.trace_id,
-                                                keyspace,
-                                                statement,
-                                                options,
-                                                hosts,
-                                                request.consistency,
-                                                retries,
-                                                self,
-                                                @futures))
+              promise.fulfill(Cassandra::Results::Void.new(r.custom_payload,
+                                                           r.warnings,
+                                                           r.trace_id,
+                                                           keyspace,
+                                                           statement,
+                                                           options,
+                                                           hosts,
+                                                           request.consistency,
+                                                           retries,
+                                                           self,
+                                                           @futures))
             when Protocol::PreparedResultResponse
               cql = request.cql
               synchronize do
@@ -1328,7 +1358,7 @@ module Cassandra
                 promise.fulfill(
                   Results::Void.new(r.custom_payload,
                                     r.warnings,
-                                    r.trace_id,
+                                    nil,
                                     keyspace,
                                     statement,
                                     options,
@@ -1360,38 +1390,44 @@ module Cassandra
           end
         else
           response_future.on_failure do |ex|
-            errors[host] = ex
-            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,
-                            request,
-                            plan,
-                            timeout,
-                            errors,
-                            hosts)
+            if ex.is_a?(Errors::HostError) ||
+                (ex.is_a?(Errors::TimeoutError) && statement.idempotent?)
+
+              errors[host] = ex
+              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,
+                                request,
+                                plan,
+                                timeout,
+                                errors,
+                                hosts)
+                else
+                  promise.break(ex)
+              end
             else
               promise.break(ex)
             end