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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 30507d23df35b3b683d9064dd63d4af9e2682ec2
-  data.tar.gz: b135c04a1633f21c3120b2b6c9dcbd669742ed1e
+  metadata.gz: 8fb7875e0edf290caf3226ac04b20a6b55702ce0
+  data.tar.gz: 188e96a446ecaf5565f851cf76ea5f0ffa7a5229
 SHA512:
-  metadata.gz: 83d9554f95da481f110427cade444772b7ee73cce03808dd220d92115110a3b7b50bab5880f34f65dab8201b0e03779a9b8583b0cbc67ab66bea83d559f61ca4
-  data.tar.gz: c77a60ed7222a1a10a4e1c87b7c0e002b607ba4b09bfcd0208251ec50ac7bb38a8b431ea125090194a5b29df656d9dd048afd7e181f2e2dd54a5722253e4f742
+  metadata.gz: b4c5895f4a5e774cf62b2caf9e199538467124ffcf522a42e2118f77fa09b9490c4f0db0a66922e1dee168e5cc2afddbe71830033ad3c30a2f8fa6f14b4dca84
+  data.tar.gz: 04f3589e992f19720ddcf877499b485a2a819338889e6fba94acba2f66fd7102558dfa519eff76c28ed51497e5cb3bd6c25819e6c3ba3347823579ee59c5c4b2

data/README.md

@@ -1,5 +1,7 @@
 # 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).*
+
 [![Build Status](https://travis-ci.org/datastax/ruby-driver.svg?branch=master)](https://travis-ci.org/datastax/ruby-driver)
 
 A Ruby client driver for Apache Cassandra. This driver works exclusively with
@@ -7,10 +9,10 @@ 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/
-- JIRA: https://datastax-oss.atlassian.net/browse/RUBY
-- MAILING LIST: https://groups.google.com/a/lists.datastax.com/forum/#!forum/ruby-driver-user
+- 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), [@mfiguiere](http://twitter.com/mfiguiere), [@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:
 
@@ -18,15 +20,17 @@ This driver is based on [the cql-rb gem](https://github.com/iconara/cql-rb) by [
 * 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
 * various [load-balancing](http://datastax.github.io/ruby-driver/features/load_balancing/), [retry](http://datastax.github.io/ruby-driver/features/retry_policies/) and 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/)
 
 ## Compability
 
 This driver works exclusively with the Cassandra Query Language v3 (CQL3) and Cassandra's native protocol. The current version works with:
 
-* Cassandra versions 1.2 and 2.0
-* Ruby 1.9.3 and 2.0
+* Apache Cassandra versions 1.2 and 2.0
+* DataStax Enterprise 3.1, 3.2, 4.0 and 4.5
+* Ruby (MRI) 1.9.3, 2.0 and 2.1
 * JRuby 1.7
-* Rubinius 2.1
+* Rubinius 2.2
 
 __Note__: JRuby 1.6 is not officially supported, although 1.6.8 should work.
 
@@ -35,7 +39,7 @@ __Note__: JRuby 1.6 is not officially supported, although 1.6.8 should work.
 ```ruby
 require 'cassandra'
 
-cluster = Cassandra.connect # connects to localhost by default
+cluster = Cassandra.cluster # connects to localhost by default
 
 cluster.each_host do |host| # automatically discovers all peers
   puts "Host #{host.ip}: id=#{host.id} datacenter=#{host.datacenter} rack=#{host.rack}"
@@ -57,7 +61,7 @@ The host you specify is just a seed node, the driver will automatically discover
 
 Read more:
 
-* [`Cassandra.connect` options](http://datastax.github.io/ruby-driver/api/#connect-class_method)
+* [`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)
 
@@ -72,7 +76,7 @@ gem install cassandra-driver --pre
 Install via Gemfile
 
 ```ruby
-gem 'cassandra-driver', '~> 1.0.0.beta'
+gem 'cassandra-driver', '~> 1.0.0.rc'
 ```
 
 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)
@@ -82,13 +86,45 @@ Note: if you want to use compression you should also install [snappy](http://rub
 
 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 v1.0.0.beta.2
+## What's new in v1.0.0
 
 Current release introduces the following new features:
 
-* [Token-aware load balancing policy](http://datastax.github.io/ruby-driver/features/load_balancing/token_aware/)
+* [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 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/)
-* Domain names
+* [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/)
+
+## 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.
+
+## 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).
+
+* Check out the driver codebase and install test dependencies:
+
+```bash
+git clone https://github.com/datastax/ruby-driver.git
+cd ruby-driver
+bundle install --without docs
+```
+
+* [Install ccm](http://www.datastax.com/dev/blog/ccm-a-development-tool-for-creating-local-cassandra-clusters)
+
+* Run tests:
+
+```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
+```
 
 ## Changelog & versioning
 
@@ -102,13 +138,15 @@ Prereleases will be stable, in the sense that they will have finished and proper
 
 * 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.
 * 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/)
 
 ## 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. 
+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
@@ -122,4 +160,3 @@ Licensed under the Apache License, Version 2.0 (the "License"); you may not use
 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

@@ -30,9 +30,13 @@ require 'digest'
 require 'stringio'
 require 'resolv'
 require 'openssl'
+require 'securerandom'
+require 'time'
 
 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 Cassandra::Session#execute_async
   CONSISTENCIES = [ :any, :one, :two, :three, :quorum, :all, :local_quorum,
                     :each_quorum, :serial, :local_serial, :local_one ].freeze
@@ -41,6 +45,12 @@ module Cassandra
   # @see Cassandra::Session#execute_async
   SERIAL_CONSISTENCIES = [:serial, :local_serial].freeze
 
+  # A list of all possible write types that a
+  # {Cassandra::Errors::WriteTimeoutError} can have.
+  #
+  # @see https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v1.spec#L591-L603 Description of possible types of writes in Apache Cassandra native protocol spec v1
+  WRITE_TYPES = [:simple, :batch, :unlogged_batch, :counter, :batch_log].freeze
+
   # Creates a {Cassandra::Cluster} instance
   #
   # @option options [Array<String, IPAddr>] :hosts (['127.0.0.1']) a list of
@@ -50,8 +60,28 @@ module Cassandra
   #
   # @option options [Integer] :port (9042) cassandra native protocol port.
   #
+  # @option options [String] :datacenter (nil) name of current datacenter.
+  #   First datacenter found will be assumed current by default. Note that you
+  #   can skip this option if you specify only hosts from the local datacenter
+  #   in `:hosts` option.
+  #
   # @option options [Numeric] :connect_timeout (10) connection timeout in
-  #   seconds.
+  #   seconds. Setting value to `nil` will reset it to 5 seconds.
+  #
+  # @option options [Numeric] :timeout (10) request execution timeout in
+  #   seconds. Setting value to `nil` will remove request timeout.
+  #
+  # @option options [Numeric] :heartbeat_interval (30) how often should a
+  #   heartbeat be sent to determine if a connection is alive. Several things to
+  #   note about this option. Only one heartbeat request will ever be
+  #   outstanding on a given connection. Each heatbeat will be sent in at least
+  #   `:heartbeat_interval` seconds after the last request has been sent on a
+  #   given connection. Setting value to `nil` will remove connection timeout.
+  #
+  # @option options [Numeric] :idle_timeout (60) period of inactivity after
+  #   which a connection is considered dead. Note that this value should be at
+  #   least a few times larger than `:heartbeat_interval`. Setting value to
+  #   `nil` will remove automatic connection termination.
   #
   # @option options [String] :username (none) username to use for
   #   authentication to cassandra. Note that you must also specify `:password`.
@@ -83,12 +113,15 @@ module Cassandra
   #   work, you must install 'snappy' or 'lz4-ruby' gems.
   #
   # @option options [Cassandra::LoadBalancing::Policy] :load_balancing_policy
-  #   default: {Cassandra::LoadBalancing::Policies::RoundRobin}.
+  #   default: token aware data center aware round robin.
+  #
+  # @option options [Symbol] :address_resolution (:none) a pre-configured
+  #   address resolver to use. Must be one of `:none` or
+  #   `:ec2_multi_region`.
   #
   # @option options [Cassandra::Reconnection::Policy] :reconnection_policy
   #   default: {Cassandra::Reconnection::Policies::Exponential}. Note that the
-  #   default policy is configured with
-  #   `Reconnection::Policies::Exponential.new(0.5, 30, 2)`.
+  #   default policy is configured with `(0.5, 30, 2)`.
   #
   # @option options [Cassandra::Retry::Policy] :retry_policy default:
   #   {Cassandra::Retry::Policies::Default}.
@@ -101,50 +134,69 @@ module Cassandra
   #   initial listeners. A list of initial cluster state listeners. Note that a
   #   `:load_balancing` policy is automatically registered with the cluster.
   #
-  # @option options [Symbol] :consistency (:quorum) default consistency to use
-  #   for all requests. Must be one of {Cassandra::CONSISTENCIES}.
+  # @option options [Symbol] :consistency (:one) default consistency to use for
+  #   all requests. Must be one of {Cassandra::CONSISTENCIES}.
   #
   # @option options [Boolean] :trace (false) whether or not to trace all
   #   requests by default.
   #
-  # @option options [Integer] :page_size (nil) default page size for all select
-  #   queries.
+  # @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/trunk/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/trunk/doc/native_protocol_v2.spec#L257-L273). Note that if you have specified `:username` and `:password`, then a {Cassandra::Auth::Providers::Password} will be used automatically.
   #
-  # @option options [Cassandra::Compressor] :compressor (none) a custom
-  #   compressor. Note that if you have specified `:compression`, an
+  # @option options [Cassandra::Compression::Compressor] :compressor (none) a
+  #   custom compressor. Note that if you have specified `:compression`, an
   #   appropriate compressor will be provided automatically.
   #
+  # @option options [Cassandra::AddressResolution::Policy]
+  #   :address_resolution_policy default:
+  #   {Cassandra::AddressResolution::Policies::None} 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
-  #   (none) a custom futures factory to assist with integration into existing
-  #   futures library. Note that promises returned by this object must conform
-  #   to {Cassandra::Promise} api, which is not yet public. Things may change,
-  #   use at your own risk.
+  #   default: {Cassandra::Future} a futures factory to assist with integration
+  #   into existing futures library. Note that promises returned by this object
+  #   must conform to {Cassandra::Promise} api, which is not yet public. Things
+  #   may change, use at your own risk.
   #
   # @example Connecting to localhost
-  #   cluster = Cassandra.connect
+  #   cluster = Cassandra.cluster
   #
   # @example Configuring {Cassandra::Cluster}
-  #   cluster = Cassandra.connect(
+  #   cluster = Cassandra.cluster(
   #               username: username,
   #               password: password,
   #               hosts: ['10.0.1.1', '10.0.1.2', '10.0.1.3']
   #             )
   #
   # @return [Cassandra::Cluster] a cluster instance
-  def self.connect(options = {})
-    options.select! do |key, value|
+  def self.cluster(options = {})
+    cluster_async(options).get
+  end
+
+  # Creates a {Cassandra::Cluster} instance
+  #
+  # @see Cassandra.cluster
+  #
+  # @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
+        :connect_timeout, :futures_factory, :datacenter, :address_resolution,
+        :address_resolution_policy, :idle_timeout, :heartbeat_interval, :timeout
       ].include?(key)
     end
 
+    futures = options.fetch(:futures_factory, Future)
+
     has_username = options.has_key?(:username)
     has_password = options.has_key?(:password)
     if has_username || has_password
@@ -156,11 +208,13 @@ module Cassandra
         raise ::ArgumentError, "both :username and :password options must be specified, but only :password given"
       end
 
-      username = String(options.delete(:username))
-      password = String(options.delete(:password))
+      username = options.delete(:username)
+      password = options.delete(:password)
 
-      raise ::ArgumentError, ":username cannot be empty" if username.empty?
-      raise ::ArgumentError, ":password cannot be empty" if password.empty?
+      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" }
 
       options[:credentials]   = {:username => username, :password => password}
       options[:auth_provider] = Auth::Providers::Password.new(username, password)
@@ -169,17 +223,13 @@ module Cassandra
     if options.has_key?(:credentials)
       credentials = options[:credentials]
 
-      unless credentials.is_a?(Hash)
-        raise ::ArgumentError, ":credentials must be a hash, #{credentials.inspect} given"
-      end
+      Util.assert_instance_of(::Hash, credentials) { ":credentials must be a hash, #{credentials.inspect} given" }
     end
 
     if options.has_key?(:auth_provider)
       auth_provider = options[:auth_provider]
 
-      unless auth_provider.respond_to?(:create_authenticator)
-        raise ::ArgumentError, ":auth_provider #{auth_provider.inspect} must respond to :create_authenticator, but doesn't"
-      end
+      Util.assert_responds_to(:create_authenticator, auth_provider) { ":auth_provider #{auth_provider.inspect} must respond to :create_authenticator, but doesn't" }
     end
 
     has_client_cert = options.has_key?(:client_cert)
@@ -197,13 +247,8 @@ module Cassandra
       client_cert = ::File.expand_path(options[:client_cert])
       private_key = ::File.expand_path(options[:private_key])
 
-      unless ::File.exists?(client_cert)
-        raise ::ArgumentError, ":client_cert #{client_cert.inspect} doesn't exist"
-      end
-
-      unless ::File.exists?(private_key)
-        raise ::ArgumentError, ":private_key #{private_key.inspect} doesn't exist"
-      end
+      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" }
     end
 
     has_server_cert = options.has_key?(:server_cert)
@@ -211,9 +256,7 @@ module Cassandra
     if has_server_cert
       server_cert = ::File.expand_path(options[:server_cert])
 
-      unless ::File.exists?(server_cert)
-        raise ::ArgumentError, ":server_cert #{server_cert.inspect} doesn't exist"
-      end
+      Util.assert_file_exists(server_cert) { ":server_cert #{server_cert.inspect} doesn't exist" }
     end
 
     if has_client_cert || has_server_cert
@@ -240,9 +283,7 @@ module Cassandra
     if options.has_key?(:ssl)
       ssl = options[:ssl]
 
-      unless ssl.is_a?(::TrueClass) || ssl.is_a?(::FalseClass) || ssl.is_a?(::OpenSSL::SSL::SSLContext)
-        raise ":ssl must be a boolean or an OpenSSL::SSL::SSLContext, #{ssl.inspect} given"
-      end
+      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" }
     end
 
     if options.has_key?(:compression)
@@ -264,33 +305,59 @@ module Cassandra
       compressor = options[:compressor]
       methods    = [:algorithm, :compress?, :compress, :decompress]
 
-      unless methods.all? {|method| compressor.respond_to?(method)}
-        raise ::ArgumentError, ":compressor #{compressor.inspect} must respond to #{methods.inspect}, but doesn't"
-      end
+      Util.assert_responds_to_all(methods, compressor) { ":compressor #{compressor.inspect} must respond to #{methods.inspect}, but doesn't" }
     end
 
     if options.has_key?(:logger)
       logger  = options[:logger]
       methods = [:debug, :info, :warn, :error, :fatal]
 
-      unless methods.all? {|method| logger.respond_to?(method)}
-        raise ::ArgumentError, ":logger #{logger.inspect} must respond to #{methods.inspect}, but doesn't"
-      end
+      Util.assert_responds_to_all(methods, logger) { ":logger #{logger.inspect} must respond to #{methods.inspect}, but doesn't" }
     end
 
     if options.has_key?(:port)
       port = options[:port] = Integer(options[:port])
 
-      if port < 0 || port > 65536
-        raise ::ArgumentError, ":port must be a valid ip port, #{port.given}"
-      end
+      Util.assert_one_of(0..65536, port) { ":port must be a valid ip port, #{port} given" }
+    end
+
+    if options.has_key?(:datacenter)
+      options[:datacenter] = String(options[:datacenter])
     end
 
     if options.has_key?(:connect_timeout)
-      timeout = options[:connect_timeout] = Integer(options[: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" }
+      end
+    end
+
+    if options.has_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(timeout > 0) { ":timeout must be greater than 0, #{timeout} given" }
+      end
+    end
+
+    if options.has_key?(:heartbeat_interval)
+      timeout = options[:heartbeat_interval]
 
-      if timeout < 0
-        raise ::ArgumentError, ":connect_timeout must be a positive value, #{timeout.given}"
+      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" }
+      end
+    end
+
+    if options.has_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" }
       end
     end
 
@@ -298,42 +365,32 @@ module Cassandra
       load_balancing_policy = options[:load_balancing_policy]
       methods = [:host_up, :host_down, :host_found, :host_lost, :setup, :distance, :plan]
 
-      unless methods.all? {|method| load_balancing_policy.respond_to?(method)}
-        raise ::ArgumentError, ":load_balancing_policy #{load_balancing_policy.inspect} must respond to #{methods.inspect}, but doesn't"
-      end
+      Util.assert_responds_to_all(methods, load_balancing_policy) { ":load_balancing_policy #{load_balancing_policy.inspect} must respond to #{methods.inspect}, but doesn't" }
     end
 
     if options.has_key?(:reconnection_policy)
       reconnection_policy = options[:reconnection_policy]
 
-      unless reconnection_policy.respond_to?(:schedule)
-        raise ::ArgumentError, ":reconnection_policy #{reconnection_policy.inspect} must respond to :schedule, but doesn't"
-      end
+      Util.assert_responds_to(:schedule, reconnection_policy) { ":reconnection_policy #{reconnection_policy.inspect} must respond to :schedule, but doesn't" }
     end
 
     if options.has_key?(:retry_policy)
       retry_policy = options[:retry_policy]
       methods = [:read_timeout, :write_timeout, :unavailable]
 
-      unless methods.all? {|method| retry_policy.respond_to?(method)}
-        raise ::ArgumentError, ":retry_policy #{retry_policy.inspect} must respond to #{methods.inspect}, but doesn't"
-      end
+      Util.assert_responds_to_all(methods, retry_policy) { ":retry_policy #{retry_policy.inspect} must respond to #{methods.inspect}, but doesn't" }
     end
 
     if options.has_key?(:listeners)
       listeners = options[:listeners]
 
-      unless listeners.respond_to?(:each)
-        raise ::ArgumentError, ":listeners must be an Enumerable, #{listeners.inspect} given"
-      end
+      Util.assert_instance_of(::Enumerable, listeners) { ":listeners must be an Enumerable, #{listeners.inspect} given" }
     end
 
     if options.has_key?(:consistency)
       consistency = options[:consistency]
 
-      unless CONSISTENCIES.include?(consistency)
-        raise ::ArgumentError, ":consistency must be one of #{CONSISTENCIES.inspect}, #{consistency.inspect} given"
-      end
+      Util.assert_one_of(CONSISTENCIES, consistency) { ":consistency must be one of #{CONSISTENCIES.inspect}, #{consistency.inspect} given" }
     end
 
     if options.has_key?(:trace)
@@ -341,10 +398,11 @@ module Cassandra
     end
 
     if options.has_key?(:page_size)
-      page_size = options[:page_size] = Integer(options[:page_size])
+      page_size = options[:page_size]
 
-      if page_size <= 0
-        raise ::ArgumentError, ":page_size must be a positive integer, #{page_size.inspect} given"
+      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" }
       end
     end
 
@@ -352,11 +410,28 @@ module Cassandra
       futures_factory = options[:futures_factory]
       methods = [:error, :value, :promise, :all]
 
-      unless methods.all? {|method| futures_factory.respond_to?(method)}
-        raise ::ArgumentError, ":futures_factory #{futures_factory.inspect} must respond to #{methods.inspect}, but doesn't"
+      Util.assert_responds_to_all(methods, futures_factory) { ":futures_factory #{futures_factory.inspect} must respond to #{methods.inspect}, but doesn't" }
+    end
+
+    if options.has_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
+      else
+        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)
+      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" }
+    end
+
     hosts = []
 
     Array(options.fetch(:hosts, '127.0.0.1')).each do |host|
@@ -375,8 +450,20 @@ module Cassandra
     if hosts.empty?
       raise ::ArgumentError, ":hosts #{options[:hosts].inspect} could not be resolved to any ip address"
     end
+  rescue => e
+    futures.error(e)
+  else
+    promise = futures.promise
+
+    Driver.new(options).connect(hosts).on_complete do |f|
+      if f.resolved?
+        promise.fulfill(f.value)
+      else
+        f.on_failure {|e| promise.break(e)}
+      end
+    end
 
-    Driver.new(options).connect(hosts).value
+    promise.future
   end
 end
 
@@ -386,7 +473,7 @@ require 'cassandra/time_uuid'
 require 'cassandra/compression'
 require 'cassandra/protocol'
 require 'cassandra/auth'
-require 'cassandra/client'
+require 'cassandra/null_logger'
 
 require 'cassandra/future'
 require 'cassandra/cluster'
@@ -408,6 +495,7 @@ require 'cassandra/execution/trace'
 require 'cassandra/load_balancing'
 require 'cassandra/reconnection'
 require 'cassandra/retry'
+require 'cassandra/address_resolution'
 
 require 'cassandra/util'
 
@@ -415,8 +503,6 @@ require 'cassandra/util'
 require 'cassandra_murmur3'
 
 module Cassandra
-  # @private
-  Io = Ione::Io
   # @private
   VOID_STATEMENT = Statements::Void.new
   # @private