cassandra-driver 3.0.0 → 3.0.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YjE4OWU5NjliOWY2YjgwM2RkMzJlNmMyZWU0YzdlOWFlYzNkYjUxOQ==
+    MjRlMWI4NGUyYzNjNzMzZTQ1MTNiNDE4NTIxODk3NGIwOTIwZjVkZg==
   data.tar.gz: !binary |-
-    M2E5YTgyMTllNTg2ZGI2NjgyN2VjZTJmN2Q0MGI4ZDAwNGU1YjkxMw==
+    YWMwYmNlM2RmYzIzYWY5MGQ2MmIyNjU5NTU3NTkyNGMxYmY0NTAyNA==
 SHA512:
   metadata.gz: !binary |-
-    ZTBmMzYzMTQwMDEwYTQ4YjljNmNhMWQwMGI0ZWZjYTVlOTczMjkxNzUzNTMz
-    YzY5MzhjNjUyMjc2Mjc2NGVhODE4NDYwOTRiOTViZWY5MGE4YmQ1NTg1MGY0
-    MTYwZDgwZDg2MDQzNTViNmI0NDk2ZWRjMWRhMWMxZTQ5MTVkODQ=
+    NTdhMWZiODYzYTViZGJiNTY5NDYzMjQ2ZDZiMDE2MTY4MTI3NTY3NjM0Y2Rl
+    YmE0MjkxYmZhNDI0OTliMDcyZWUyMjM3M2E2OWIzNzg2MGJkODVlMjhmYmQ3
+    N2NhYzQ5NmY2MmQxYzdkY2U3NTJmZDAyMjI2MWE4MTM3YTZkMmY=
   data.tar.gz: !binary |-
-    ZmQ5MGM4ZTI1ZTFmN2QzNjE5OGNmNjg4MzVmZTJkYjM0NTM0MzI4MWIxNGJk
-    MDY3NTRmOWQ0YWM5NWUzY2Q2NTFmOWIwOGExZDI5MWQ0ODIyOWVmMjVkNjll
-    MGRhMWJkOGExZThlNWQzOWMzYTE1YzZmNTM5YWJjZmNhMTllNWE=
+    Y2IwOGMwOGQzYTlkZjUzYjQ1NzFlZjJhNTY3YWM2MmNjN2QxM2ExZmU0YWZh
+    ODBjYjQ4ODUwZDAzMTZjMzRhMDEwYzhkZDA4Zjk3NjIzOWI1OWM2ZGViYjQ0
+    ZjZkZjM0YTEzNTY0YTAxNzA0YWEwYjdlOWY2NjkyOWNkZDE4YjM=

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](https://github.com/datastax/ruby-driver/tree/v3.0.0).*
+*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.
 
@@ -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,14 +85,16 @@ 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:
 
@@ -162,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:
 
@@ -186,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
@@ -210,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
 
@@ -240,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,
@@ -293,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)
@@ -664,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
 
@@ -757,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
@@ -798,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'
@@ -831,6 +836,11 @@ 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/client.rb

@@ -1390,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

data/lib/cassandra/cluster/connector.rb

@@ -134,7 +134,8 @@ module Cassandra
                                            @connection_options.compressor,
                                            @connection_options.heartbeat_interval,
                                            @connection_options.idle_timeout,
-                                           @connection_options.requests_per_connection)
+                                           @connection_options.requests_per_connection,
+                                           @connection_options.custom_type_handlers)
         end.flat_map do |connection|
           # connection is a CqlProtocolHandler
           f = request_options(connection)
@@ -154,7 +155,7 @@ module Cassandra
                 supported_cql_versions.first :
                 '3.1.0'
 
-            startup_connection(connection, cql_version, compression)
+            startup_connection(host, connection, cql_version, compression)
           end
           f.fallback do |error|
             case error
@@ -200,7 +201,7 @@ module Cassandra
         end
       end
 
-      def startup_connection(connection, cql_version, compression)
+      def startup_connection(host, connection, cql_version, compression)
         connection.send_request(Protocol::StartupRequest.new(cql_version, compression),
                                 @execution_options.timeout).flat_map do |r|
           case r
@@ -213,12 +214,9 @@ module Cassandra
                 Ione::Future.failed(cannot_authenticate_error)
               end
             else
-              authenticator = @connection_options.create_authenticator(
-                r.authentication_class)
+              authenticator = @connection_options.create_authenticator(r.authentication_class, host)
               if authenticator
-                challenge_response_cycle(connection,
-                                         authenticator,
-                                         authenticator.initial_response)
+                challenge_response_cycle(connection, authenticator, authenticator.initial_response)
               else
                 Ione::Future.failed(cannot_authenticate_error)
               end
@@ -283,7 +281,7 @@ module Cassandra
           case r
           when Protocol::AuthChallengeResponse
             token = authenticator.challenge_response(r.token)
-            challenge_response_cycle(pending_connection, authenticator, token)
+            challenge_response_cycle(connection, authenticator, token)
           when Protocol::AuthSuccessResponse
             begin
               authenticator.authentication_successful(r.token)

data/lib/cassandra/cluster/options.rb

@@ -24,7 +24,7 @@ module Cassandra
 
       attr_reader :auth_provider, :compressor, :connect_timeout, :credentials,
                   :heartbeat_interval, :idle_timeout, :port, :schema_refresh_delay,
-                  :schema_refresh_timeout, :ssl
+                  :schema_refresh_timeout, :ssl, :custom_type_handlers
       attr_boolean :protocol_negotiable, :synchronize_schema, :nodelay
 
       attr_accessor :protocol_version
@@ -45,7 +45,8 @@ module Cassandra
                      schema_refresh_delay,
                      schema_refresh_timeout,
                      nodelay,
-                     requests_per_connection)
+                     requests_per_connection,
+                     custom_types)
         @logger                 = logger
         @protocol_version       = protocol_version
         @credentials            = credentials
@@ -60,6 +61,10 @@ module Cassandra
         @schema_refresh_delay   = schema_refresh_delay
         @schema_refresh_timeout = schema_refresh_timeout
         @nodelay                = nodelay
+        @custom_type_handlers   = {}
+        custom_types.each do |type_klass|
+          @custom_type_handlers[type_klass.type] = type_klass
+        end
 
         @connections_per_local_node  = connections_per_local_node
         @connections_per_remote_node = connections_per_remote_node
@@ -78,8 +83,17 @@ module Cassandra
         @compressor && @compressor.algorithm
       end
 
-      def create_authenticator(authentication_class)
-        @auth_provider && @auth_provider.create_authenticator(authentication_class)
+      def create_authenticator(authentication_class, host)
+        if @auth_provider
+          # Auth providers should take an auth-class and host, but they used to not, so for backward compatibility
+          # we figure out if this provider does, and if so send both args, otherwise just send the auth-class.
+
+          if @auth_provider.method(:create_authenticator).arity == 1
+            @auth_provider.create_authenticator(authentication_class)
+          else
+            @auth_provider.create_authenticator(authentication_class, host)
+          end
+        end
       end
 
       def connections_per_local_node

data/lib/cassandra/cluster/schema/cql_type_parser.rb

@@ -72,6 +72,9 @@ module Cassandra
             Cassandra::Types.tuple(*node.children.map { |t| lookup_type(t, types)})
           when 'empty'             then
             Cassandra::Types.custom('org.apache.cassandra.db.marshal.EmptyType')
+          when /\A'/ then
+            # Custom type.
+            Cassandra::Types.custom(node.name[1..-2])
           else
             types.fetch(node.name) do
               raise IncompleteTypeError, "unable to lookup type #{node.name.inspect}"

data/lib/cassandra/cluster/schema/fetchers.rb

@@ -836,7 +836,7 @@ module Cassandra
             initial_state  = Util.encode_object(
               Protocol::Coder.read_value_v4(
                 Protocol::CqlByteBuffer.new.append_bytes(aggregate_data['initcond']),
-                state_type))
+                state_type, nil))
 
             # The state-function takes arguments: first the stype, then the args of the aggregate.
             state_function = functions.get(aggregate_data['state_func'],

data/lib/cassandra/custom_data.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+#--
+# 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
+#
+# 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.
+#++
+
+# Use this module to mark domain object classes as custom type implementations for custom-type
+# columns in C*. This module has no logic of its own, but indicates that the marked class has
+# certain methods.
+# @private
+module Cassandra::CustomData
+  def self.included base
+    base.send :include, InstanceMethods
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    # @return [Cassandra::Types::Custom] the custom type that this class represents.
+    def type
+      raise NotImplementedError, "#{self.class} must implement the :type class method"
+    end
+
+    # Deserialize the given data into an instance of this domain object class.
+    # @param data [String] byte-array representation of a column value of this custom type.
+    # @return An instance of the domain object class.
+    # @raise [Cassandra::Errors::DecodingError] upon failure.
+    def deserialize(data)
+      raise NotImplementedError, "#{self.class} must implement the :deserialize class method"
+    end
+  end
+
+  module InstanceMethods
+    # Serialize this domain object into a byte array to send to C*.
+    # @return [String] byte-array representation of this domain object.
+    def serialize
+      raise NotImplementedError, "#{self.class} must implement the :serialize instance method"
+    end
+  end
+end

data/lib/cassandra/driver.rb

@@ -92,23 +92,25 @@ module Cassandra
                                      schema_fetcher)
     end
 
+    let(:cluster_klass) { Cluster }
+
     let(:cluster) do
-      Cluster.new(logger,
-                  io_reactor,
-                  executor,
-                  control_connection,
-                  cluster_registry,
-                  cluster_schema,
-                  cluster_metadata,
-                  execution_options,
-                  connection_options,
-                  load_balancing_policy,
-                  reconnection_policy,
-                  retry_policy,
-                  address_resolution_policy,
-                  connector,
-                  futures_factory,
-                  timestamp_generator)
+      cluster_klass.new(logger,
+                        io_reactor,
+                        executor,
+                        control_connection,
+                        cluster_registry,
+                        cluster_schema,
+                        cluster_metadata,
+                        execution_options,
+                        connection_options,
+                        load_balancing_policy,
+                        reconnection_policy,
+                        retry_policy,
+                        address_resolution_policy,
+                        connector,
+                        futures_factory,
+			timestamp_generator)
     end
 
     let(:execution_options) do
@@ -137,10 +139,12 @@ module Cassandra
         schema_refresh_delay,
         schema_refresh_timeout,
         nodelay,
-        requests_per_connection
+        requests_per_connection,
+        custom_types
       )
     end
 
+    let(:custom_types)      { [] }
     let(:port)                      { 9042 }
     let(:protocol_version)          { nil }
     let(:connect_timeout)           { 10 }

data/lib/cassandra/execution/options.rb

@@ -177,7 +177,7 @@ module Cassandra
           @consistency = consistency || trusted_options.consistency
           @page_size = page_size || trusted_options.page_size
           @trace = trace.nil? ? trusted_options.trace? : !!trace
-          @timeout = timeout || trusted_options.timeout
+          @timeout = options.key?(:timeout) ? timeout : trusted_options.timeout
           @serial_consistency = serial_consistency || trusted_options.serial_consistency
           @arguments = arguments || trusted_options.arguments
           @type_hints = type_hints || trusted_options.type_hints

data/lib/cassandra/protocol.rb

@@ -28,6 +28,13 @@ module Cassandra
 
       BYTES_FORMAT = 'C*'.freeze
       TWO_INTS_FORMAT = 'NN'.freeze
+
+      # All of the formats above are big-endian (e.g. network-byte-order). Some payloads (custom types) may have
+      # little-endian components.
+
+      DOUBLE_FORMAT_LE = 'E'.freeze
+      INT_FORMAT_LE = 'V'.freeze
+      SHORT_FORMAT_LE = 'v'.freeze
     end
 
     module Constants

data/lib/cassandra/protocol/coder.rb

@@ -97,6 +97,7 @@ module Cassandra
         when :bigint, :counter then write_bigint(buffer, value)
         when :blob             then write_blob(buffer, value)
         when :boolean          then write_boolean(buffer, value)
+        when :custom           then write_custom(buffer, value, type)
         when :decimal          then write_decimal(buffer, value)
         when :double           then write_double(buffer, value)
         when :float            then write_float(buffer, value)
@@ -221,19 +222,19 @@ module Cassandra
         end
       end
 
-      def read_values_v4(buffer, column_metadata)
+      def read_values_v4(buffer, column_metadata, custom_type_handlers)
         ::Array.new(buffer.read_int) do |_i|
           row = ::Hash.new
 
           column_metadata.each do |(_, _, column, type)|
-            row[column] = read_value_v4(buffer, type)
+            row[column] = read_value_v4(buffer, type, custom_type_handlers)
           end
 
           row
         end
       end
 
-      def read_value_v4(buffer, type)
+      def read_value_v4(buffer, type, custom_type_handlers)
         case type.kind
         when :ascii            then read_ascii(buffer)
         when :bigint, :counter then read_bigint(buffer)
@@ -253,11 +254,12 @@ module Cassandra
         when :smallint         then read_smallint(buffer)
         when :time             then read_time(buffer)
         when :date             then read_date(buffer)
+        when :custom           then read_custom(buffer, type, custom_type_handlers)
         when :list
           return nil unless read_size(buffer)
 
           value_type = type.value_type
-          ::Array.new(buffer.read_signed_int) { read_value_v4(buffer, value_type) }
+          ::Array.new(buffer.read_signed_int) { read_value_v4(buffer, value_type, custom_type_handlers) }
         when :map
           return nil unless read_size(buffer)
 
@@ -266,7 +268,7 @@ module Cassandra
           value      = ::Hash.new
 
           buffer.read_signed_int.times do
-            value[read_value_v4(buffer, key_type)] = read_value_v4(buffer, value_type)
+            value[read_value_v4(buffer, key_type, custom_type_handlers)] = read_value_v4(buffer, value_type, custom_type_handlers)
           end
 
           value
@@ -277,7 +279,7 @@ module Cassandra
           value      = ::Set.new
 
           buffer.read_signed_int.times do
-            value << read_value_v4(buffer, value_type)
+            value << read_value_v4(buffer, value_type, custom_type_handlers)
           end
 
           value
@@ -295,7 +297,7 @@ module Cassandra
             values[field.name] = if length - buffer.length >= size
                                    nil
                                  else
-                                   read_value_v4(buffer, field.type)
+                                   read_value_v4(buffer, field.type, custom_type_handlers)
                                  end
           end
 
@@ -308,7 +310,7 @@ module Cassandra
 
           members.each do |member_type|
             break if buffer.empty?
-            values << read_value_v4(buffer, member_type)
+            values << read_value_v4(buffer, member_type, custom_type_handlers)
           end
 
           values.fill(nil, values.length, (members.length - values.length))
@@ -774,6 +776,15 @@ module Cassandra
         read_size(buffer) && buffer.read(1) == Constants::TRUE_BYTE
       end
 
+      def read_custom(buffer, type, custom_type_handlers)
+        # Lookup the type-name to get the Class that can deserialize buffer data into a custom domain object.
+        unless custom_type_handlers && custom_type_handlers.key?(type)
+          raise Errors::DecodingError, %(Unsupported custom column type: #{type.name})
+        end
+        num_bytes = read_size(buffer)
+        custom_type_handlers[type].deserialize(buffer.read(num_bytes)) if num_bytes && num_bytes > 0
+      end
+
       def read_decimal(buffer)
         size = read_size(buffer)
         size && buffer.read_decimal(size)
@@ -860,6 +871,15 @@ module Cassandra
         buffer.append(value ? Constants::TRUE_BYTE : Constants::FALSE_BYTE)
       end
 
+      def write_custom(buffer, value, type)
+        # Verify that the given type-name matches the value's cql type name.
+        if value.class.type != type
+          raise Errors::EncodingError, "type mismatch: value is a #{value.type} and column is a #{type}"
+        end
+
+        buffer.append_bytes(value.serialize)
+      end
+
       def write_decimal(buffer, value)
         buffer.append_bytes(CqlByteBuffer.new.append_decimal(value))
       end

data/lib/cassandra/protocol/cql_byte_buffer.rb

@@ -92,6 +92,13 @@ module Cassandra
               "Not enough bytes available to decode a double: #{e.message}", e.backtrace
       end
 
+      def read_double_le
+        read(8).unpack(Formats::DOUBLE_FORMAT_LE).first
+      rescue RangeError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a double: #{e.message}", e.backtrace
+      end
+
       def read_float
         read(4).unpack(Formats::FLOAT_FORMAT).first
       rescue RangeError => e
@@ -108,6 +115,13 @@ module Cassandra
               "Not enough bytes available to decode an int: #{e.message}", e.backtrace
       end
 
+      def read_unsigned_int_le
+        read(4).unpack(Formats::INT_FORMAT_LE).first
+      rescue RangeError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode an int: #{e.message}", e.backtrace
+      end
+
       def read_unsigned_short
         read_short
       rescue RangeError => e
@@ -115,6 +129,13 @@ module Cassandra
               "Not enough bytes available to decode a short: #{e.message}", e.backtrace
       end
 
+      def read_unsigned_short_le
+        read(2).unpack(Formats::SHORT_FORMAT_LE).first
+      rescue RangeError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a short: #{e.message}", e.backtrace
+      end
+
       def read_string
         length = read_unsigned_short
         string = read(length)

data/lib/cassandra/protocol/cql_protocol_handler.rb

@@ -46,7 +46,8 @@ module Cassandra
                      compressor = nil,
                      heartbeat_interval = 30,
                      idle_timeout = 60,
-                     requests_per_connection = 128)
+                     requests_per_connection = 128,
+                     custom_type_handlers = {})
         @protocol_version = protocol_version
         @connection = connection
         @scheduler = scheduler
@@ -60,7 +61,7 @@ module Cassandra
 
         if protocol_version > 3
           @frame_encoder = V4::Encoder.new(@compressor, protocol_version)
-          @frame_decoder = V4::Decoder.new(self, @compressor)
+          @frame_decoder = V4::Decoder.new(self, @compressor, custom_type_handlers)
         elsif protocol_version > 2
           @frame_encoder = V3::Encoder.new(@compressor, protocol_version)
           @frame_decoder = V3::Decoder.new(self, @compressor)

data/lib/cassandra/protocol/responses/raw_rows_result_response.rb

@@ -24,17 +24,19 @@ module Cassandra
                      protocol_version,
                      raw_rows,
                      paging_state,
-                     trace_id)
+                     trace_id,
+                     custom_type_handlers = nil)
         super(custom_payload, warnings, nil, nil, paging_state, trace_id)
         @protocol_version = protocol_version
         @raw_rows = raw_rows
+        @custom_type_handlers = custom_type_handlers
       end
 
       def materialize(metadata)
         @metadata = metadata
 
         @rows = if @protocol_version == 4
-                  Coder.read_values_v4(@raw_rows, @metadata)
+                  Coder.read_values_v4(@raw_rows, @metadata, @custom_type_handlers)
                 elsif @protocol_version == 3
                   Coder.read_values_v3(@raw_rows, @metadata)
                 else

data/lib/cassandra/protocol/v1.rb

@@ -241,7 +241,8 @@ module Cassandra
                                           protocol_version,
                                           remaining_bytes,
                                           paging_state,
-                                          trace_id)
+                                          trace_id,
+                                          nil)
               else
                 RowsResultResponse.new(nil,
                                        nil,

data/lib/cassandra/protocol/v3.rb

@@ -275,7 +275,8 @@ module Cassandra
                                           protocol_version,
                                           remaining_bytes,
                                           paging_state,
-                                          trace_id)
+                                          trace_id,
+                                          nil)
               else
                 RowsResultResponse.new(nil,
                                        nil,

data/lib/cassandra/protocol/v4.rb

@@ -59,7 +59,7 @@ module Cassandra
       end
 
       class Decoder
-        def initialize(handler, compressor = nil)
+        def initialize(handler, compressor = nil, custom_type_handlers = {})
           @handler    = handler
           @compressor = compressor
           @state      = :initial
@@ -68,6 +68,7 @@ module Cassandra
           @code       = nil
           @length     = nil
           @buffer     = CqlByteBuffer.new
+          @custom_type_handlers = custom_type_handlers
         end
 
         def <<(data)
@@ -325,11 +326,12 @@ module Cassandra
                                           protocol_version,
                                           remaining_bytes,
                                           paging_state,
-                                          trace_id)
+                                          trace_id,
+                                          @custom_type_handlers)
               else
                 RowsResultResponse.new(custom_payload,
                                        warnings,
-                                       Coder.read_values_v4(buffer, column_specs),
+                                       Coder.read_values_v4(buffer, column_specs, @custom_type_handlers),
                                        column_specs,
                                        paging_state,
                                        trace_id)

data/lib/cassandra/result.rb

@@ -76,8 +76,8 @@ module Cassandra
     #
     # @note `:paging_state` option will be ignored.
     #
-    # @return [Cassandra::Future<Cassandra::Result, nil>] `nil` if last
-    #   page
+    # @return [Cassandra::Future<Cassandra::Result>] a future that resolves to a new Result if there is a new page,
+    #   `nil` otherwise.
     #
     # @see Cassandra::Session#execute
     def next_page_async(options = nil)

data/lib/cassandra/session.rb

@@ -89,20 +89,13 @@ module Cassandra
 
       case statement
       when ::String
-        @client.query(Statements::Simple.new(statement,
-                                             options.arguments,
-                                             options.type_hints,
-                                             options.idempotent?),
-                      options)
-      when Statements::Simple
-        @client.query(statement, options)
-      when Statements::Prepared
-        @client.execute(statement.bind(options.arguments), options)
-      when Statements::Bound
-        @client.execute(statement, options)
-      when Statements::Batch
-        Util.assert_not_empty(statement.statements) { 'batch cannot be empty' }
-        @client.batch(statement, options)
+        Statements::Simple.new(statement,
+                               options.arguments,
+                               options.type_hints,
+                               options.idempotent?).accept(@client,
+                                                           options)
+      when Statement
+        statement.accept(@client, options)
       else
         @futures.error(::ArgumentError.new("unsupported statement #{statement.inspect}"))
       end

data/lib/cassandra/statement.rb

@@ -23,5 +23,10 @@ module Cassandra
     def idempotent?
       !!@idempotent
     end
+
+    # @private
+    def accept(client, options)
+      raise NotImplementedError, "#{self.class} must implement :accept method"
+    end
   end
 end

data/lib/cassandra/statements/batch.rb

@@ -113,6 +113,12 @@ module Cassandra
         self
       end
 
+      # @private
+      def accept(client, options)
+        Util.assert_not_empty(statements) { 'batch cannot be empty' }
+        client.batch(self, options)
+      end
+
       # Determines whether or not the statement is safe to retry on timeout
       # Batches are idempotent only when all statements in a batch are.
       # @return [Boolean] whether the statement is safe to retry on timeout

data/lib/cassandra/statements/bound.rb

@@ -46,6 +46,11 @@ module Cassandra
         @idempotent      = idempotent
       end
 
+      # @private
+      def accept(client, options)
+        client.execute(self, options)
+      end
+
       # @return [String] a CLI-friendly bound statement representation
       def inspect
         "#<#{self.class.name}:0x#{object_id.to_s(16)} @cql=#{@cql.inspect} " \

data/lib/cassandra/statements/prepared.rb

@@ -155,6 +155,11 @@ module Cassandra
                                           nil)
       end
 
+      # @private
+      def accept(client, options)
+        client.execute(bind(options.arguments), options)
+      end
+
       # @return [String] a CLI-friendly prepared statement representation
       def inspect
         "#<#{self.class.name}:0x#{object_id.to_s(16)} @cql=#{@cql.inspect}>"
@@ -180,7 +185,9 @@ module Cassandra
                                    'the partition key and must be present.'
           end
 
-          if @connection_options.protocol_version >= 3
+          if @connection_options.protocol_version >= 4
+            Protocol::Coder.write_value_v4(buffer, value, type)
+          elsif @connection_options.protocol_version >= 3
             Protocol::Coder.write_value_v3(buffer, value, type)
           else
             Protocol::Coder.write_value_v1(buffer, value, type)
@@ -200,7 +207,9 @@ module Cassandra
                                      'the partition key and must be present.'
             end
 
-            if @connection_options.protocol_version >= 3
+            if @connection_options.protocol_version >= 4
+              Protocol::Coder.write_value_v4(buf, value, type)
+            elsif @connection_options.protocol_version >= 3
               Protocol::Coder.write_value_v3(buf, value, type)
             else
               Protocol::Coder.write_value_v1(buf, value, type)

data/lib/cassandra/statements/simple.rb

@@ -93,6 +93,11 @@ module Cassandra
         @idempotent   = idempotent
       end
 
+      # @private
+      def accept(client, options)
+        client.query(self, options)
+      end
+
       # @return [String] a CLI-friendly simple statement representation
       def inspect
         "#<#{self.class.name}:0x#{object_id.to_s(16)} @cql=#{@cql.inspect} " \

data/lib/cassandra/statements/void.rb

@@ -23,6 +23,11 @@ module Cassandra
     class Void
       include Statement
 
+      # @private
+      def accept(client, options)
+        nil
+      end
+
       # Returns nothing
       # @return [nil] there is no cql for the void statement
       def cql

data/lib/cassandra/tuple.rb

@@ -55,7 +55,7 @@ module Cassandra
       end
 
       def inspect
-        "#<Cassandra::Tuple:0x#{object_id.to_s(16)} #{self}>"
+        "#<Cassandra::Tuple:0x#{object_id.to_s(16)} types=#{@types.inspect}, []=#{@values.inspect}>"
       end
     end
 
@@ -114,7 +114,7 @@ module Cassandra
 
     # @private
     def inspect
-      "#<Cassandra::Tuple:0x#{object_id.to_s(16)} #{self}>"
+      "#<Cassandra::Tuple:0x#{object_id.to_s(16)} []=#{@values.inspect}>"
     end
 
     # @private

data/lib/cassandra/types.rb

@@ -1389,8 +1389,8 @@ module Cassandra
       # @raise [ArgumentError] if the value is invalid
       # @return [void]
       def assert(value, message = nil, &block)
-        raise ::NotImplementedError,
-              "unable to assert a value for custom type: #{@name.inspect}"
+        Util.assert_instance_of(CustomData, value, message, &block)
+        Util.assert_equal(self, value.class.type, message, &block)
       end
 
       # @return [String] a cassandra representation of this type

data/lib/cassandra/util.rb

@@ -196,6 +196,7 @@ module Cassandra
         Types.udt(object.keyspace, object.name, object.types)
       when UDT
         Types.udt('unknown', 'unknown', object.map {|k, v| [k, guess_type(v)]})
+      when Cassandra::CustomData then object.class.type
       else
         raise ::ArgumentError,
               "Unable to guess the type of the argument: #{object.inspect}"

data/lib/cassandra/version.rb

@@ -17,5 +17,5 @@
 #++
 
 module Cassandra
-  VERSION = '3.0.0'.freeze
+  VERSION = '3.0.2'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cassandra-driver
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.0.2
 platform: ruby
 authors:
 - Theo Hultberg
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-23 00:00:00.000000000 Z
+date: 2016-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ione
@@ -107,6 +107,7 @@ files:
 - lib/cassandra/compression.rb
 - lib/cassandra/compression/compressors/lz4.rb
 - lib/cassandra/compression/compressors/snappy.rb
+- lib/cassandra/custom_data.rb
 - lib/cassandra/driver.rb
 - lib/cassandra/errors.rb
 - lib/cassandra/execution/info.rb