cassandra-driver 3.0.0.beta.1-java → 3.0.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1e6a787e376fb3c3593c39dfda36008493460d81
-  data.tar.gz: a2a29ca90926d5bd17a77c3604b79a364acd7824
+  metadata.gz: e54478ae2983bea8fe87b5cdb7bb4109b64a0321
+  data.tar.gz: 60309ae2ddd6c3adb1b78f932e6985371e1dd1da
 SHA512:
-  metadata.gz: d0f391e939675d5f22d8e057c9e2a75324e07762c6fd669c5768df8cb118b3d0a38daec56e81871351d80f913b3fe03d5000e3f1f5627522388780acb7accd64
-  data.tar.gz: 01e6930ee06ca09812de451671c4598119ebb2982619c3e663522e35938f3e6d3c846859b0192e28e00604e2fc00dcbc3c0fcdf51a6736241aa96db48fce591b
+  metadata.gz: 6adf8e05498642fa68929c41e0def00dd35bda7ccdddb2caa56e4082a882ef2351fc48c1b33ee824a35f4cd9aa50a9391d40aaa73809311482bd0c352bda3d8c
+  data.tar.gz: 97bbc836f22e5ff90431a32ec9d0143b6c7c11d21b9610fa81018728991b55359395f095f55f826b79cd1248a73a8063173ee3541e263ead85e7460f80aa8812

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. v1.0.0-beta.3](https://github.com/datastax/ruby-driver/tree/v1.0.0-beta.3).*
+*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](https://github.com/datastax/ruby-driver/tree/v3.0.0).*
 
 [![Build Status](https://travis-ci.org/datastax/ruby-driver.svg?branch=master)](https://travis-ci.org/datastax/ruby-driver)
 
@@ -12,7 +12,7 @@ the Cassandra Query Language version 3 (CQL3) and Cassandra's native protocol.
 - 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>)
-- Twitter: Follow the latest news about DataStax Drivers - [@avalanche123](http://twitter.com/avalanche123), [@mfiguiere](http://twitter.com/mfiguiere), [@al3xandru](https://twitter.com/al3xandru)
+- Twitter: Follow the latest news about DataStax Drivers - [@avalanche123](http://twitter.com/avalanche123), [@stamhankar999](http://twitter.com/stamhankar999), [@al3xandru](https://twitter.com/al3xandru)
 
 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:
 
@@ -27,17 +27,18 @@ This driver is based on [the cql-rb gem](https://github.com/iconara/cql-rb) by [
 
 [Check out the slides from Ruby Driver Explained](https://speakerdeck.com/avalanche123/ruby-driver-explained) for a detailed overview of the Ruby Driver architecture.
 
-## Compability
+## Compatibility
 
 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 and 2.1
-* DataStax Enterprise 3.1, 3.2, 4.0 and 4.5
-* Ruby (MRI) 1.9.3, 2.0, 2.1 and 2.2
+* 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
-* Rubinius 2.2
 
-__Note__: JRuby 1.6 is not officially supported, although 1.6.8 should work.
+__Note__: JRuby 1.6 is not officially supported, although 1.6.8 should work. Similarly,
+MRI 2.0 and 2.1 are not officially supported, but they should work. 1.9.3 is deprecated
+and is likely to break in the release following 3.0.
 
 ## Quick start
 
@@ -53,10 +54,10 @@ end
 keyspace = 'system'
 session  = cluster.connect(keyspace) # create session, optionally scoped to a keyspace, to execute queries
 
-future = session.execute_async('SELECT keyspace_name, columnfamily_name FROM schema_columnfamilies') # fully asynchronous api
+future = session.execute_async('SELECT keyspace_name, table_name FROM system_schema.tables') # fully asynchronous api
 future.on_success do |rows|
   rows.each do |row|
-    puts "The keyspace #{row['keyspace_name']} has a table called #{row['columnfamily_name']}"
+    puts "The keyspace #{row['keyspace_name']} has a table called #{row['table_name']}"
   end
 end
 future.join
@@ -91,31 +92,77 @@ __Note__: if you want to use compression you should also install [snappy](http:/
 
 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.
 
-## What's new in v2.1.3
-
-Features:
+## What's new in v3.0.0
+
+### Features:
+
+* 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 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 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.
+* 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 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'])
+# becomes
+batch.add(query, arguments: ['val1', 'val2'])
 
-* Apache Cassandra native protocol v3
-* [User-defined types](http://datastax.github.io/ruby-driver/features/basics/user_defined_types/) and [tuples](http://datastax.github.io/ruby-driver/features/basics/datatypes/#using-tuples)
-* [Schema metadata includes user-defined types](http://datastax.github.io/ruby-driver/api/keyspace/#type-instance_method)
-* [Named arguments](http://datastax.github.io/ruby-driver/features/basics/prepared_statements/#an-insert-statement-is-prepared-with-named-parameters)
-* [Public types api for type definition and introspection](http://datastax.github.io/ruby-driver/api/types/)
+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.
 
-Breaking Changes:
+### Bug Fixes:
 
-* Splat style positional arguments support, deprecated in 2.0.0, has been dropped
+* [[RUBY-120](https://datastax-oss.atlassian.net/browse/RUBY-120)] Tuples and UDTs can be used in sets and hash keys.
+* [[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-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.
 
-Bug Fixes:
+## Feedback Requested
 
-* [[RUBY-93](https://datastax-oss.atlassian.net/browse/RUBY-93)] Reconnection can overflow the stack
+*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
 
-The DataStax Ruby Driver uses the awesome [Cucumber Framework](http://cukes.info/) for both end-to-end, or acceptance, testing and constructing documentation. All of the features supported by the driver have appropriate acceptance tests with easy-to-copy code examples in the `features/` directory.
+The DataStax Ruby Driver uses the awesome [Cucumber Framework](http://cukes.info/) for
+both end-to-end, or acceptance, testing and constructing documentation. All of the
+features supported by the driver have appropriate acceptance tests with easy-to-copy code
+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).
+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).
 
 * Check out the driver codebase and install test dependencies:
 
@@ -127,26 +174,39 @@ bundle install --without docs
 
 * [Install ccm](http://www.datastax.com/dev/blog/ccm-a-development-tool-for-creating-local-cassandra-clusters)
 
-* Run tests:
+* Run tests against different versions of Cassandra:
 
 ```bash
-bundle exec cucumber # runs end-to-end tests (or bundle exec rake cucumber)
-bundle exec rspec # runs unit tests (or bundle exec rake rspec)
-bundle exec rake integration # run integration tests
-bundle exec rake test # run both as well as integration tests
+CASSANDRA_VERSION=3.1.1 bundle exec cucumber # runs end-to-end tests (or bundle exec rake cucumber)
+CASSANDRA_VERSION=3.0.0 bundle exec rspec # runs unit tests (or bundle exec rake rspec)
+CASSANDRA_VERSION=2.1.12 bundle exec rake integration # run integration tests
+CASSANDRA_VERSION=2.0.17 bundle exec rake test # run both as well as integration tests
 ```
 
 ## 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 numbering follows the [semantic versioning](http://semver.org/) scheme.
+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
+numbering follows the [semantic versioning](http://semver.org/) scheme.
 
-Private and experimental APIs, defined as whatever is not in the [public API documentation][1], i.e. classes and methods marked as `@private`, will change without warning. If you've been recommended to try an experimental API by the maintainers, please let them know if you depend on that API. Experimental APIs will eventually become public, and knowing how they are used helps in determining their maturity.
+Private and experimental APIs, defined as whatever is not in the
+[public API documentation][1], i.e. classes and methods marked as `@private`, will change
+without warning. If you've been recommended to try an experimental API by the maintainers,
+please let them know if you depend on that API. Experimental APIs will eventually become
+public, and knowing how they are used helps in determining their maturity.
 
-Prereleases will be stable, in the sense that they will have finished and properly tested features only, but may introduce APIs that will change before the final release. Please use the prereleases and report bugs, but don't deploy them to production without consulting the maintainers, or doing extensive testing yourself. If you do deploy to production please let the maintainers know as this helps determining the maturity of the release.
+Prereleases will be stable, in the sense that they will have finished and properly tested
+features only, but may introduce APIs that will change before the final release. Please
+use the prereleases and report bugs, but don't deploy them to production without
+consulting the maintainers, or doing extensive testing yourself. If you do deploy to
+production please let the maintainers know as this helps in determining the maturity of
+the release.
 
 ## Known bugs & limitations
 
-* JRuby 1.6 is not officially supported, although 1.6.8 should work, if you're stuck in JRuby 1.6.8 try and see if it works for you.
+* Specifying a `protocol_version` option of 1 or 2 in cluster options will fail with a
+  `NoHostsAvailable` error rather than a `ProtocolError` against Cassandra node versions 3.0-3.4.
+* JRuby 1.6 is not officially supported, although 1.6.8 should work.
 * 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.
 
@@ -158,19 +218,26 @@ For contributing read [CONTRIBUTING.md](https://github.com/datastax/ruby-driver/
 
 ## Credits
 
-This driver is based on the original work of [Theo Hultberg](https://github.com/iconara) on [cql-rb](https://github.com/iconara/cql-rb/) and adds a series of advanced features that are common across all other DataStax drivers for Apache Cassandra.
-
-The development effort to provide an up to date, high performance, fully featured Ruby Driver for Apache Cassandra will continue on this project, while [cql-rb](https://github.com/iconara/cql-rb/) will be discontinued.
+This driver is based on the original work of [Theo Hultberg](https://github.com/iconara)
+on [cql-rb](https://github.com/iconara/cql-rb/) and adds a series of advanced features
+that are common across all other DataStax drivers for Apache Cassandra.
 
+The development effort to provide an up to date, high performance, fully featured Ruby
+Driver for Apache Cassandra will continue on this project, while
+[cql-rb](https://github.com/iconara/cql-rb/) will be discontinued.
 
 ## Copyright
 
-Copyright 2013-2015 DataStax, Inc.
+Copyright 2013-2016 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
+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](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.
+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.
 
   [1]: http://datastax.github.io/ruby-driver/api

data/lib/cassandra.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -16,7 +16,6 @@
 # limitations under the License.
 #++
 
-
 require 'ione'
 require 'json'
 
@@ -35,11 +34,13 @@ require 'date'
 
 module Cassandra
   # A list of all supported request consistencies
-  # @see http://www.datastax.com/documentation/cassandra/2.0/cassandra/dml/dml_config_consistency_c.html Consistency levels in Apache Cassandra 2.0
-  # @see http://www.datastax.com/documentation/cassandra/1.2/cassandra/dml/dml_config_consistency_c.html Consistency levels in Apache Cassandra 1.2
+  # @see http://www.datastax.com/documentation/cassandra/2.0/cassandra/dml/dml_config_consistency_c.html Consistency
+  #   levels in Apache Cassandra 2.0
+  # @see http://www.datastax.com/documentation/cassandra/1.2/cassandra/dml/dml_config_consistency_c.html Consistency
+  #   levels in Apache Cassandra 1.2
   # @see Cassandra::Session#execute_async
-  CONSISTENCIES = [ :any, :one, :two, :three, :quorum, :all, :local_quorum,
-                    :each_quorum, :serial, :local_serial, :local_one ].freeze
+  CONSISTENCIES = [:any, :one, :two, :three, :quorum, :all, :local_quorum,
+                   :each_quorum, :serial, :local_serial, :local_one].freeze
 
   # A list of all supported serial consistencies
   # @see Cassandra::Session#execute_async
@@ -48,9 +49,52 @@ module Cassandra
   # A list of all possible write types that a
   # {Cassandra::Errors::WriteTimeoutError} can have.
   #
-  # @see https://github.com/apache/cassandra/blob/cassandra-2.0.16/doc/native_protocol_v2.spec#L872-L887 Description of possible types of writes in Apache Cassandra native protocol spec v1
+  # @see https://github.com/apache/cassandra/blob/cassandra-2.0.16/doc/native_protocol_v2.spec#L872-L887 Description of
+  #   possible types of writes in Apache Cassandra native protocol spec v1
   WRITE_TYPES = [:simple, :batch, :unlogged_batch, :counter, :batch_log].freeze
 
+  CLUSTER_OPTIONS = [
+    :address_resolution,
+    :address_resolution_policy,
+    :auth_provider,
+    :client_cert,
+    :client_timestamps,
+    :compression,
+    :compressor,
+    :connect_timeout,
+    :connections_per_local_node,
+    :connections_per_remote_node,
+    :consistency,
+    :credentials,
+    :datacenter,
+    :futures_factory,
+    :heartbeat_interval,
+    :hosts,
+    :idle_timeout,
+    :listeners,
+    :load_balancing_policy,
+    :logger,
+    :nodelay,
+    :reconnection_policy,
+    :retry_policy,
+    :page_size,
+    :passphrase,
+    :password,
+    :port,
+    :private_key,
+    :protocol_version,
+    :requests_per_connection,
+    :schema_refresh_delay,
+    :schema_refresh_timeout,
+    :server_cert,
+    :shuffle_replicas,
+    :ssl,
+    :synchronize_schema,
+    :timeout,
+    :trace,
+    :username
+  ].freeze
+
   # Creates a {Cassandra::Cluster Cluster instance}.
   #
   # @option options [Array<String, IPAddr>] :hosts (['127.0.0.1']) a list of
@@ -126,11 +170,34 @@ module Cassandra
   #   address resolver to use. Must be one of `:none` or
   #   `:ec2_multi_region`.
   #
-  # @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 [Integer] :connections_per_local_node (nil) Number of connections to
+  #   open to each local node; the value of this option directly correlates to the number
+  #   of requests the client can make to the local node concurrently. When `nil`, the
+  #   setting is `1` for nodes that use the v3 or later protocol, and `2` for nodes that
+  #   use the v2 or earlier protocol.
+  #
+  # @option options [Integer] :connections_per_remote_node (1) Number of connections to
+  #   open to each remote node; the value of this option directly correlates to the
+  #   number of requests the client can make to the remote node concurrently.
+  #
+  # @option options [Integer] :requests_per_connection (nil) Number of outstanding
+  #   requests to support on one connection. Depending on the types of requests, some may
+  #   get processed in parallel in the Cassandra node. When `nil`, the setting is `1024`
+  #   for nodes that use the v3 or later protocol, and `128` for nodes that use the
+  #   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 highest common protocol version
+  #   that all nodes in `:hosts` speak.
+  #
+  # @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
@@ -139,7 +206,8 @@ module Cassandra
   #   automatic schema updates. Schema metadata is used by the driver to
   #   determine cluster partitioners as well as to find partition keys and
   #   replicas of prepared statements, this information makes token aware load
-  #   balancing possible. One can still {Cassandra::Cluster#refresh_schema refresh schema manually}.
+  #   balancing possible. One can still
+  #   {Cassandra::Cluster#refresh_schema refresh schema manually}.
   #
   # @option options [Numeric] :schema_refresh_delay (1) the driver will wait
   #   for `:schema_refresh_delay` before fetching metadata after receiving a
@@ -177,9 +245,15 @@ module Cassandra
   # @option options [Integer] :page_size (10000) default page size for all
   #   select queries. Set this value to `nil` to disable paging.
   #
-  # @option options [Hash{String => String}] :credentials (none) a hash of credentials - to be used with [credentials authentication in cassandra 1.2](https://github.com/apache/cassandra/blob/cassandra-2.0.16/doc/native_protocol_v1.spec#L238-L250). Note that if you specified `:username` and `:password` options, those credentials are configured automatically.
+  # @option options [Hash{String => String}] :credentials (none) a hash of credentials -
+  #   to be used with [credentials authentication in cassandra 1.2](https://github.com/apache/cassandra/blob/cassandra-2.0.16/doc/native_protocol_v1.spec#L238-L250).
+  #   Note that if you specified `:username` and `:password` options, those credentials
+  #   are configured automatically.
   #
-  # @option options [Cassandra::Auth::Provider] :auth_provider (none) a custom auth provider to be used with [SASL authentication in cassandra 2.0](https://github.com/apache/cassandra/blob/cassandra-2.0.16/doc/native_protocol_v2.spec#L257-L273). Note that if you have specified `:username` and `:password`, then a {Cassandra::Auth::Providers::Password Password Provider} will be used automatically.
+  # @option options [Cassandra::Auth::Provider] :auth_provider (none) a custom auth
+  #   provider to be used with [SASL authentication in cassandra 2.0](https://github.com/apache/cassandra/blob/cassandra-2.0.16/doc/native_protocol_v2.spec#L257-L273).
+  #   Note that if you have specified `:username` and `:password`, then a
+  #   {Cassandra::Auth::Providers::Password Password Provider} will be used automatically.
   #
   # @option options [Cassandra::Compression::Compressor] :compressor (none) a
   #   custom compressor. Note that if you have specified `:compression`, an
@@ -187,8 +261,8 @@ module Cassandra
   #
   # @option options [Cassandra::AddressResolution::Policy]
   #   :address_resolution_policy default:
-  #   {Cassandra::AddressResolution::Policies::None No Resolution Policy} a custom address resolution
-  #   policy. Note that if you have specified `:address_resolution`, an
+  #   {Cassandra::AddressResolution::Policies::None No Resolution Policy} a custom address
+  #   resolution policy. Note that if you have specified `:address_resolution`, an
   #   appropriate address resolution policy will be provided automatically.
   #
   # @option options [Object<#all, #error, #value, #promise>] :futures_factory
@@ -219,78 +293,140 @@ module Cassandra
   # @return [Cassandra::Future<Cassandra::Cluster>] a future resolving to the
   #   cluster instance.
   def self.cluster_async(options = {})
-    options = options.select do |key, value|
-      [ :credentials, :auth_provider, :compression, :hosts, :logger, :port,
-        :load_balancing_policy, :reconnection_policy, :retry_policy, :listeners,
-        :consistency, :trace, :page_size, :compressor, :username, :password,
-        :ssl, :server_cert, :client_cert, :private_key, :passphrase,
-        :connect_timeout, :futures_factory, :datacenter, :address_resolution,
-        :address_resolution_policy, :idle_timeout, :heartbeat_interval, :timeout,
-        :synchronize_schema, :schema_refresh_delay, :schema_refresh_timeout,
-        :shuffle_replicas, :client_timestamps
-      ].include?(key)
-    end
-
-    has_username = options.has_key?(:username)
-    has_password = options.has_key?(:password)
+    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!
+  rescue => e
+    futures = options.fetch(:futures_factory) { return Future::Error.new(e) }
+    futures.error(e)
+  else
+    driver = Driver.new(options)
+    driver.connect(hosts)
+  end
+
+  # @private
+  SSL_CLASSES = [::TrueClass, ::FalseClass, ::OpenSSL::SSL::SSLContext].freeze
+
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/CyclomaticComplexity
+  # rubocop:disable Metrics/PerceivedComplexity
+  # @private
+  def self.validate_and_massage_options(options)
+    options = options.select do |key, _|
+      CLUSTER_OPTIONS.include?(key)
+    end
+
+    has_username = options.key?(:username)
+    has_password = options.key?(:password)
     if has_username || has_password
       if has_username && !has_password
-        raise ::ArgumentError, "both :username and :password options must be specified, but only :username given"
+        raise ::ArgumentError,
+              'both :username and :password options must be specified, ' \
+                  'but only :username given'
       end
 
       if !has_username && has_password
-        raise ::ArgumentError, "both :username and :password options must be specified, but only :password given"
+        raise ::ArgumentError,
+              'both :username and :password options must be specified, ' \
+                  'but only :password given'
       end
 
       username = options.delete(:username)
       password = options.delete(:password)
 
-      Util.assert_instance_of(::String, username) { ":username must be a String, #{username.inspect} given" }
-      Util.assert_instance_of(::String, password) { ":password must be a String, #{password.inspect} given" }
-      Util.assert_not_empty(username) { ":username cannot be empty" }
-      Util.assert_not_empty(password) { ":password cannot be empty" }
+      Util.assert_instance_of(::String, username) do
+        ":username must be a String, #{username.inspect} given"
+      end
+      Util.assert_instance_of(::String, password) do
+        ":password must be a String, #{password.inspect} given"
+      end
+      Util.assert_not_empty(username) { ':username cannot be empty' }
+      Util.assert_not_empty(password) { ':password cannot be empty' }
 
-      options[:credentials]   = {:username => username, :password => password}
+      options[:credentials]   = {username: username, password: password}
       options[:auth_provider] = Auth::Providers::Password.new(username, password)
     end
 
-    if options.has_key?(:credentials)
+    if options.key?(:credentials)
       credentials = options[:credentials]
 
-      Util.assert_instance_of(::Hash, credentials) { ":credentials must be a hash, #{credentials.inspect} given" }
+      Util.assert_instance_of(::Hash, credentials) do
+        ":credentials must be a hash, #{credentials.inspect} given"
+      end
     end
 
-    if options.has_key?(:auth_provider)
+    if options.key?(:auth_provider)
       auth_provider = options[:auth_provider]
 
-      Util.assert_responds_to(:create_authenticator, auth_provider) { ":auth_provider #{auth_provider.inspect} must respond to :create_authenticator, but doesn't" }
+      Util.assert_responds_to(:create_authenticator, auth_provider) do
+        ":auth_provider #{auth_provider.inspect} must respond to " \
+            ":create_authenticator, but doesn't"
+      end
     end
 
-    has_client_cert = options.has_key?(:client_cert)
-    has_private_key = options.has_key?(:private_key)
+    has_client_cert = options.key?(:client_cert)
+    has_private_key = options.key?(:private_key)
 
     if has_client_cert || has_private_key
       if has_client_cert && !has_private_key
-        raise ::ArgumentError, "both :client_cert and :private_key options must be specified, but only :client_cert given"
+        raise ::ArgumentError,
+              'both :client_cert and :private_key options must be specified, ' \
+                  'but only :client_cert given'
       end
 
       if !has_client_cert && has_private_key
-        raise ::ArgumentError, "both :client_cert and :private_key options must be specified, but only :private_key given"
+        raise ::ArgumentError,
+              'both :client_cert and :private_key options must be specified, ' \
+                  'but only :private_key given'
       end
 
+      Util.assert_instance_of(::String, options[:client_cert]) do
+        ":client_cert must be a string, #{options[:client_cert].inspect} given"
+      end
+      Util.assert_instance_of(::String, options[:private_key]) do
+        ":client_cert must be a string, #{options[:private_key].inspect} given"
+      end
       client_cert = ::File.expand_path(options[:client_cert])
       private_key = ::File.expand_path(options[:private_key])
 
-      Util.assert_file_exists(client_cert) { ":client_cert #{client_cert.inspect} doesn't exist" }
-      Util.assert_file_exists(private_key) { ":private_key #{private_key.inspect} doesn't exist" }
+      Util.assert_file_exists(client_cert) do
+        ":client_cert #{client_cert.inspect} doesn't exist"
+      end
+      Util.assert_file_exists(private_key) do
+        ":private_key #{private_key.inspect} doesn't exist"
+      end
     end
 
-    has_server_cert = options.has_key?(:server_cert)
+    has_server_cert = options.key?(:server_cert)
 
     if has_server_cert
+      Util.assert_instance_of(::String, options[:server_cert]) do
+        ":server_cert must be a string, #{options[:server_cert].inspect} given"
+      end
       server_cert = ::File.expand_path(options[:server_cert])
 
-      Util.assert_file_exists(server_cert) { ":server_cert #{server_cert.inspect} doesn't exist" }
+      Util.assert_file_exists(server_cert) do
+        ":server_cert #{server_cert.inspect} doesn't exist"
+      end
     end
 
     if has_client_cert || has_server_cert
@@ -304,23 +440,26 @@ module Cassandra
       if has_client_cert
         context.cert = ::OpenSSL::X509::Certificate.new(File.read(client_cert))
 
-        if options.has_key?(:passphrase)
-          context.key = ::OpenSSL::PKey::RSA.new(File.read(private_key), options[:passphrase])
-        else
-          context.key = ::OpenSSL::PKey::RSA.new(File.read(private_key))
-        end
+        context.key = if options.key?(:passphrase)
+                        ::OpenSSL::PKey::RSA.new(File.read(private_key),
+                                                 options[:passphrase])
+                      else
+                        ::OpenSSL::PKey::RSA.new(File.read(private_key))
+                      end
       end
 
       options[:ssl] = context
     end
 
-    if options.has_key?(:ssl)
+    if options.key?(:ssl)
       ssl = options[:ssl]
 
-      Util.assert_instance_of_one_of([::TrueClass, ::FalseClass, ::OpenSSL::SSL::SSLContext], ssl) { ":ssl must be a boolean or an OpenSSL::SSL::SSLContext, #{ssl.inspect} given" }
+      Util.assert_instance_of_one_of(SSL_CLASSES, ssl) do
+        ":ssl must be a boolean or an OpenSSL::SSL::SSLContext, #{ssl.inspect} given"
+      end
     end
 
-    if options.has_key?(:compression)
+    if options.key?(:compression)
       compression = options.delete(:compression)
 
       case compression
@@ -329,195 +468,296 @@ module Cassandra
       when :lz4
         options[:compressor] = Compression::Compressors::Lz4.new
       else
-        raise ::ArgumentError, ":compression must be either :snappy or :lz4, #{compression.inspect} given"
+        raise ::ArgumentError,
+              ":compression must be either :snappy or :lz4, #{compression.inspect} given"
       end
     end
 
-    if options.has_key?(:compressor)
+    if options.key?(:compressor)
       compressor = options[:compressor]
       methods    = [:algorithm, :compress?, :compress, :decompress]
 
-      Util.assert_responds_to_all(methods, compressor) { ":compressor #{compressor.inspect} must respond to #{methods.inspect}, but doesn't" }
+      Util.assert_responds_to_all(methods, compressor) do
+        ":compressor #{compressor.inspect} must respond to #{methods.inspect}, " \
+            "but doesn't"
+      end
     end
 
-    if options.has_key?(:logger)
-      logger  = options[:logger]
-      methods = [:debug, :info, :warn, :error, :fatal]
+    if options.key?(:logger)
+      if options[:logger].nil?
+        # Delete the key because we want to fallback to the default logger in Driver.
+        options.delete(:logger)
+      else
+        # Validate
+        logger = options[:logger]
+        methods = [:debug, :info, :warn, :error, :fatal]
 
-      Util.assert_responds_to_all(methods, logger) { ":logger #{logger.inspect} must respond to #{methods.inspect}, but doesn't" }
+        Util.assert_responds_to_all(methods, logger) do
+          ":logger #{logger.inspect} must respond to #{methods.inspect}, but doesn't"
+        end
+      end
     end
 
-    if options.has_key?(:port)
-      port = options[:port] = Integer(options[:port])
-
-      Util.assert_one_of(0..65536, port) { ":port must be a valid ip port, #{port} given" }
+    if options.key?(:port)
+      unless options[:port].nil?
+        port = options[:port]
+        Util.assert_instance_of(::Integer, port)
+        Util.assert_one_of(1...2**16, port) do
+          ":port must be a valid ip port, #{port} given"
+        end
+      end
     end
 
-    if options.has_key?(:datacenter)
-      options[:datacenter] = String(options[:datacenter])
-    end
+    options[:datacenter] = String(options[:datacenter]) if options.key?(:datacenter)
 
-    if options.has_key?(:connect_timeout)
+    if options.key?(:connect_timeout)
       timeout = options[:connect_timeout]
 
       unless timeout.nil?
-        Util.assert_instance_of(::Numeric, timeout) { ":connect_timeout must be a number of seconds, #{timeout} given" }
-        Util.assert(timeout > 0) { ":connect_timeout must be greater than 0, #{timeout} given" }
+        Util.assert_instance_of(::Numeric, timeout) do
+          ":connect_timeout must be a number of seconds, #{timeout.inspect} given"
+        end
+        Util.assert(timeout > 0) do
+          ":connect_timeout must be greater than 0, #{timeout} given"
+        end
       end
     end
 
-    if options.has_key?(:timeout)
+    if options.key?(:timeout)
       timeout = options[:timeout]
 
       unless timeout.nil?
-        Util.assert_instance_of(::Numeric, timeout) { ":timeout must be a number of seconds, #{timeout} given" }
+        Util.assert_instance_of(::Numeric, timeout) do
+          ":timeout must be a number of seconds, #{timeout.inspect} given"
+        end
         Util.assert(timeout > 0) { ":timeout must be greater than 0, #{timeout} given" }
       end
     end
 
-    if options.has_key?(:heartbeat_interval)
+    if options.key?(:heartbeat_interval)
       timeout = options[:heartbeat_interval]
 
       unless timeout.nil?
-        Util.assert_instance_of(::Numeric, timeout) { ":heartbeat_interval must be a number of seconds, #{timeout} given" }
-        Util.assert(timeout > 0) { ":heartbeat_interval must be greater than 0, #{timeout} given" }
+        Util.assert_instance_of(::Numeric, timeout) do
+          ":heartbeat_interval must be a number of seconds, #{timeout.inspect} given"
+        end
+        Util.assert(timeout > 0) do
+          ":heartbeat_interval must be greater than 0, #{timeout} given"
+        end
       end
     end
 
-    if options.has_key?(:idle_timeout)
+    if options.key?(:idle_timeout)
       timeout = options[:idle_timeout]
 
       unless timeout.nil?
-        Util.assert_instance_of(::Numeric, timeout) { ":idle_timeout must be a number of seconds, #{timeout} given" }
-        Util.assert(timeout > 0) { ":idle_timeout must be greater than 0, #{timeout} given" }
+        Util.assert_instance_of(::Numeric, timeout) do
+          ":idle_timeout must be a number of seconds, #{timeout.inspect} given"
+        end
+        Util.assert(timeout > 0) do
+          ":idle_timeout must be greater than 0, #{timeout} given"
+        end
       end
     end
 
-    if options.has_key?(:schema_refresh_delay)
+    if options.key?(:schema_refresh_delay)
       timeout = options[:schema_refresh_delay]
 
-      Util.assert_instance_of(::Numeric, timeout) { ":schema_refresh_delay must be a number of seconds, #{timeout} given" }
-      Util.assert(timeout > 0) { ":schema_refresh_delay must be greater than 0, #{timeout} given" }
+      Util.assert_instance_of(::Numeric, timeout) do
+        ":schema_refresh_delay must be a number of seconds, #{timeout.inspect} given"
+      end
+      Util.assert(timeout > 0) do
+        ":schema_refresh_delay must be greater than 0, #{timeout} given"
+      end
     end
 
-    if options.has_key?(:schema_refresh_timeout)
+    if options.key?(:schema_refresh_timeout)
       timeout = options[:schema_refresh_timeout]
 
-      Util.assert_instance_of(::Numeric, timeout) { ":schema_refresh_timeout must be a number of seconds, #{timeout} given" }
-      Util.assert(timeout > 0) { ":schema_refresh_timeout must be greater than 0, #{timeout} given" }
+      Util.assert_instance_of(::Numeric, timeout) do
+        ":schema_refresh_timeout must be a number of seconds, #{timeout.inspect} given"
+      end
+      Util.assert(timeout > 0) do
+        ":schema_refresh_timeout must be greater than 0, #{timeout} given"
+      end
     end
 
-    if options.has_key?(:load_balancing_policy)
+    if options.key?(:load_balancing_policy)
       load_balancing_policy = options[:load_balancing_policy]
-      methods = [:host_up, :host_down, :host_found, :host_lost, :setup, :teardown, :distance, :plan]
+      methods = [:host_up, :host_down, :host_found, :host_lost, :setup, :teardown,
+                 :distance, :plan]
 
-      Util.assert_responds_to_all(methods, load_balancing_policy) { ":load_balancing_policy #{load_balancing_policy.inspect} must respond to #{methods.inspect}, but doesn't" }
+      Util.assert_responds_to_all(methods, load_balancing_policy) do
+        ":load_balancing_policy #{load_balancing_policy.inspect} must respond " \
+            "to #{methods.inspect}, but doesn't"
+      end
     end
 
-    if options.has_key?(:reconnection_policy)
+    if options.key?(:reconnection_policy)
       reconnection_policy = options[:reconnection_policy]
 
-      Util.assert_responds_to(:schedule, reconnection_policy) { ":reconnection_policy #{reconnection_policy.inspect} must respond to :schedule, but doesn't" }
+      Util.assert_responds_to(:schedule, reconnection_policy) do
+        ":reconnection_policy #{reconnection_policy.inspect} must respond to " \
+            ":schedule, but doesn't"
+      end
     end
 
-    if options.has_key?(:retry_policy)
+    if options.key?(:retry_policy)
       retry_policy = options[:retry_policy]
       methods = [:read_timeout, :write_timeout, :unavailable]
 
-      Util.assert_responds_to_all(methods, retry_policy) { ":retry_policy #{retry_policy.inspect} must respond to #{methods.inspect}, but doesn't" }
+      Util.assert_responds_to_all(methods, retry_policy) do
+        ":retry_policy #{retry_policy.inspect} must respond to #{methods.inspect}, " \
+            "but doesn't"
+      end
     end
 
-    if options.has_key?(:listeners)
-      options[:listeners] = Array(options[:listeners])
-    end
+    options[:listeners] = Array(options[:listeners]) if options.key?(:listeners)
 
-    if options.has_key?(:consistency)
+    if options.key?(:consistency)
       consistency = options[:consistency]
 
-      Util.assert_one_of(CONSISTENCIES, consistency) { ":consistency must be one of #{CONSISTENCIES.inspect}, #{consistency.inspect} given" }
-    end
-
-    if options.has_key?(:nodelay)
-      options[:nodelay] = !!options[:nodelay]
+      Util.assert_one_of(CONSISTENCIES, consistency) do
+        ":consistency must be one of #{CONSISTENCIES.inspect}, " \
+            "#{consistency.inspect} given"
+      end
     end
 
-    if options.has_key?(:trace)
-      options[:trace] = !!options[:trace]
-    end
+    options[:nodelay] = !!options[:nodelay] if options.key?(:nodelay)
+    options[:trace] = !!options[:trace] if options.key?(:trace)
+    options[:shuffle_replicas] = !!options[:shuffle_replicas] if options.key?(:shuffle_replicas)
 
-    if options.has_key?(:shuffle_replicas)
-      options[:shuffle_replicas] = !!options[:shuffle_replicas]
-    end
-
-    if options.has_key?(:page_size)
+    if options.key?(:page_size)
       page_size = options[:page_size]
 
       unless page_size.nil?
-        page_size = options[:page_size] = Integer(page_size)
-        Util.assert(page_size > 0) { ":page_size must be a positive integer, #{page_size.inspect} given" }
+        page_size = options[:page_size]
+        Util.assert_instance_of(::Integer, page_size)
+        Util.assert_one_of(1...2**32, page_size) do
+          ":page_size must be a positive integer, #{page_size.inspect} given"
+        end
+      end
+    end
+
+    if options.key?(:protocol_version)
+      protocol_version = options[:protocol_version]
+      unless protocol_version.nil?
+        Util.assert_instance_of(::Integer, protocol_version)
+        Util.assert_one_of(1..4, protocol_version) do
+          ":protocol_version must be a positive integer, #{protocol_version.inspect} given"
+        end
       end
     end
 
-    if options.has_key?(:futures_factory)
+    if options.key?(:futures_factory)
       futures_factory = options[:futures_factory]
       methods = [:error, :value, :promise, :all]
 
-      Util.assert_responds_to_all(methods, futures_factory) { ":futures_factory #{futures_factory.inspect} must respond to #{methods.inspect}, but doesn't" }
+      Util.assert_responds_to_all(methods, futures_factory) do
+        ":futures_factory #{futures_factory.inspect} must respond to " \
+            "#{methods.inspect}, but doesn't"
+      end
     end
 
-    if options.has_key?(:address_resolution)
+    if options.key?(:address_resolution)
       address_resolution = options.delete(:address_resolution)
 
       case address_resolution
       when :none
         # do nothing
       when :ec2_multi_region
-        options[:address_resolution_policy] = AddressResolution::Policies::EC2MultiRegion.new
+        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"
+        raise ::ArgumentError,
+              ':address_resolution must be either :none or :ec2_multi_region, ' \
+                  "#{address_resolution.inspect} given"
       end
     end
 
-    if options.has_key?(:address_resolution_policy)
+    if options.key?(:address_resolution_policy)
       address_resolver = options[:address_resolution_policy]
 
-      Util.assert_responds_to(:resolve, address_resolver) { ":address_resolution_policy must respond to :resolve, #{address_resolver.inspect} but doesn't" }
+      Util.assert_responds_to(:resolve, address_resolver) do
+        ':address_resolution_policy must respond to :resolve, ' \
+            "#{address_resolver.inspect} but doesn't"
+      end
     end
 
-    if options.has_key?(:synchronize_schema)
-      options[:synchronize_schema] = !!options[:synchronize_schema]
+    options[:synchronize_schema] = !!options[:synchronize_schema] if options.key?(:synchronize_schema)
+
+    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.has_key?(:client_timestamps)
-      options[:client_timestamps] = !!options[:client_timestamps]
+    if options.key?(:connections_per_local_node)
+      connections_per_node = options[:connections_per_local_node]
+
+      unless connections_per_node.nil?
+        connections_per_node = options[:connections_per_local_node]
+        Util.assert_instance_of(::Integer, connections_per_node)
+        Util.assert_one_of(1...2**16, connections_per_node) do
+          ':connections_per_local_node must be a positive integer between ' \
+              "1 and 65535, #{connections_per_node.inspect} given"
+        end
+      end
     end
 
-    hosts = []
+    if options.key?(:connections_per_remote_node)
+      connections_per_node = options[:connections_per_remote_node]
 
-    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)
+      unless connections_per_node.nil?
+        connections_per_node = options[:connections_per_remote_node]
+        Util.assert_instance_of(::Integer, connections_per_node)
+        Util.assert_one_of(1...2**16, connections_per_node) do
+          ':connections_per_remote_node must be a positive integer between ' \
+              "1 and 65535, #{connections_per_node.inspect} given"
         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
+    if options.key?(:requests_per_connection)
+      requests_per_connection = options[:requests_per_connection]
 
-    hosts.shuffle!
-  rescue => e
-    futures = options.fetch(:futures_factory) { return Future::Error.new(e) }
-    futures.error(e)
-  else
-    driver = Driver.new(options)
-    driver.connect(hosts)
+      unless requests_per_connection.nil?
+        requests_per_connection = options[:requests_per_connection]
+        Util.assert_instance_of(::Integer, requests_per_connection)
+
+        # v3 protocol says that max stream-id is 32767 (2^15-1). This setting might be
+        # used to talk to a v2 (or less) node, but then we'll adjust it down.
+
+        Util.assert_one_of(1...2**15, requests_per_connection) do
+          ':requests_per_connection must be a positive integer, ' \
+              "#{requests_per_connection.inspect} given"
+        end
+      end
+    end
+    options
   end
 
   # @private
@@ -535,9 +775,11 @@ module Cassandra
   # => 1970-1-1
   # ::Date.jd(DATE_OFFSET + 2 ** 32, ::Date::GREGORIAN)
   # => 5881580-07-12
-  DATE_OFFSET = (::Time.utc(1970, 1, 1).to_date.jd - 2 ** 31)
+  DATE_OFFSET = (::Time.utc(1970, 1, 1).to_date.jd - 2**31)
 end
 
+require 'cassandra/attr_boolean'
+require 'cassandra/version'
 require 'cassandra/uuid'
 require 'cassandra/time_uuid'
 require 'cassandra/tuple'
@@ -550,6 +792,7 @@ require 'cassandra/errors'
 require 'cassandra/compression'
 require 'cassandra/protocol'
 require 'cassandra/auth'
+require 'cassandra/cassandra_logger'
 require 'cassandra/null_logger'
 
 require 'cassandra/executors'
@@ -565,9 +808,13 @@ require 'cassandra/statements'
 require 'cassandra/aggregate'
 require 'cassandra/argument'
 require 'cassandra/function'
+require 'cassandra/function_collection'
 require 'cassandra/column'
+require 'cassandra/column_container'
 require 'cassandra/table'
+require 'cassandra/materialized_view'
 require 'cassandra/keyspace'
+require 'cassandra/index'
 
 require 'cassandra/execution/info'
 require 'cassandra/execution/options'
@@ -577,6 +824,7 @@ require 'cassandra/load_balancing'
 require 'cassandra/reconnection'
 require 'cassandra/retry'
 require 'cassandra/address_resolution'
+require 'cassandra/timestamp_generator'
 
 require 'cassandra/util'
 
@@ -587,7 +835,7 @@ module Cassandra
   # @private
   VOID_STATEMENT = Statements::Void.new
   # @private
-  VOID_OPTIONS   = Execution::Options.new({:consistency => :one})
+  VOID_OPTIONS   = Execution::Options.new(consistency: :one)
   # @private
   NO_HOSTS       = Errors::NoHostsAvailable.new
 end