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

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/metadata.rb

@@ -61,7 +61,7 @@ module Cassandra
       end
 
       def update(data)
-        @name        = data['name']
+        @name        = data['cluster_name']
         @partitioner = @partitioners[data['partitioner']]
 
         self

data/lib/cassandra/cluster/options.rb

@@ -24,8 +24,8 @@ module Cassandra
 
       attr_reader :auth_provider, :compressor, :connect_timeout, :credentials,
                   :heartbeat_interval, :idle_timeout, :port, :schema_refresh_delay,
-                  :schema_refresh_timeout, :ssl
-      attr_boolean :protocol_negotiable, :synchronize_schema, :client_timestamps, :nodelay
+                  :schema_refresh_timeout, :ssl, :custom_type_handlers
+      attr_boolean :protocol_negotiable, :synchronize_schema, :nodelay
 
       attr_accessor :protocol_version
 
@@ -44,9 +44,9 @@ module Cassandra
                      synchronize_schema,
                      schema_refresh_delay,
                      schema_refresh_timeout,
-                     client_timestamps,
                      nodelay,
-                     requests_per_connection)
+                     requests_per_connection,
+                     custom_types)
         @logger                 = logger
         @protocol_version       = protocol_version
         @credentials            = credentials
@@ -60,8 +60,11 @@ module Cassandra
         @synchronize_schema     = synchronize_schema
         @schema_refresh_delay   = schema_refresh_delay
         @schema_refresh_timeout = schema_refresh_timeout
-        @client_timestamps      = client_timestamps
         @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
@@ -80,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,22 +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)
+      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
@@ -135,12 +138,13 @@ module Cassandra
         synchronize_schema,
         schema_refresh_delay,
         schema_refresh_timeout,
-        client_timestamps,
         nodelay,
-        requests_per_connection
+        requests_per_connection,
+        custom_types
       )
     end
 
+    let(:custom_types)      { [] }
     let(:port)                      { 9042 }
     let(:protocol_version)          { nil }
     let(:connect_timeout)           { 10 }
@@ -165,15 +169,14 @@ module Cassandra
     let(:page_size)                 { 10000 }
     let(:heartbeat_interval)        { 30 }
     let(:idle_timeout)              { 60 }
-    let(:timeout)                   { 10 }
+    let(:timeout)                   { 12 }
     let(:synchronize_schema)        { true }
     let(:schema_refresh_delay)      { 1 }
     let(:schema_refresh_timeout)    { 10 }
     let(:thread_pool_size)          { 4 }
     let(:shuffle_replicas)          { true }
-    let(:client_timestamps)         { false }
     let(:nodelay)                   { true }
-
+    let(:timestamp_generator)       { nil }
     let(:connections_per_local_node)  { nil }
     let(:connections_per_remote_node) { nil }
     let(:requests_per_connection) { nil }

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/index.rb

@@ -39,8 +39,17 @@ module Cassandra
       @table = table
       @name = name.freeze
       @kind = kind
-      @target = target.freeze
       @options = options.freeze
+
+      # Target is a bit tricky; it may be an escaped name or not
+      # depending on C* version. Unify to be unescaped since a user
+      # who wants to know the target would want the bare column name.
+
+      @target = if target[0] == '"'
+                  target[1..-2]
+                else
+                  target
+                end.freeze
     end
 
     # @return [Boolean] whether or not this index uses a custom class.
@@ -57,13 +66,18 @@ module Cassandra
     def to_cql
       keyspace_name = Util.escape_name(@table.keyspace.name)
       table_name = Util.escape_name(@table.name)
-      index_name = Util.escape_name(name)
+      index_name = Util.escape_name(@name)
+
+      # Target is interesting in that it's not necessarily a column name,
+      # so we can't simply escape it. If it contains a paren, we take it as is,
+      # otherwise assume it's a column name and escape accordingly.
+      escaped_target = @target.include?('(') ? @target : Util.escape_name(@target)
 
       if custom_index?
-        "CREATE CUSTOM INDEX #{index_name} ON #{keyspace_name}.#{table_name} (#{target}) " \
-        "USING '#{@options['class_name']}' #{options_cql};"
+        "CREATE CUSTOM INDEX #{index_name} ON #{keyspace_name}.#{table_name} (#{escaped_target}) " \
+        "USING '#{@options['class_name']}'#{options_cql};"
       else
-        "CREATE INDEX #{index_name} ON #{keyspace_name}.#{table_name} (#{target});"
+        "CREATE INDEX #{index_name} ON #{keyspace_name}.#{table_name} (#{escaped_target});"
       end
     end
 
@@ -81,7 +95,7 @@ module Cassandra
     # @private
     def inspect
       "#<#{self.class.name}:0x#{object_id.to_s(16)} " \
-          "@name=#{@name} table_name=#{@table.name} kind=#{@kind} target=#{@target}>"
+          "@name=#{@name.inspect} @table=#{@table.inspect} @kind=#{@kind.inspect} @target=#{@target.inspect}>"
     end
 
     private
@@ -93,9 +107,9 @@ module Cassandra
       end
       return '' if filtered_options.empty?
 
-      result = 'WITH OPTIONS = {'
+      result = ' WITH OPTIONS = {'
       result << filtered_options.map do |key, value|
-        "'#{key}':'#{value}'"
+        "'#{key}': '#{value}'"
       end.join(', ')
       result << '}'
       result

data/lib/cassandra/load_balancing/policies/dc_aware_round_robin.rb

@@ -62,7 +62,7 @@ module Cassandra
         include MonitorMixin
 
         def initialize(datacenter = nil,
-                       max_remote_hosts_to_use = nil,
+                       max_remote_hosts_to_use = 0,
                        use_remote_hosts_for_local_consistency = false)
           datacenter              &&= String(datacenter)
           max_remote_hosts_to_use &&= Integer(max_remote_hosts_to_use)
@@ -75,6 +75,13 @@ module Cassandra
             end
           end
 
+          # If use_remote* is true, max_remote* must be > 0
+          if use_remote_hosts_for_local_consistency
+            Util.assert(max_remote_hosts_to_use.nil? || max_remote_hosts_to_use > 0,
+                        'max_remote_hosts_to_use must be nil (meaning unlimited) or > 0 when ' \
+                        'use_remote_hosts_for_local_consistency is true')
+          end
+
           @datacenter = datacenter
           @max_remote = max_remote_hosts_to_use
           @local      = ::Array.new
@@ -148,6 +155,17 @@ module Cassandra
 
           Plan.new(local, remote, position)
         end
+
+        # @private
+        def inspect
+          "#<#{self.class.name}:0x#{object_id.to_s(16)} " \
+          "datacenter=#{@datacenter.inspect}, " \
+          "use_remote=#{@use_remote.inspect}, " \
+          "max_remote=#{@max_remote.inspect}, " \
+          "local=#{@local.inspect}, " \
+          "remote=#{@remote.inspect}, " \
+          "position=#{@position.inspect}>"
+        end
       end
     end
   end

data/lib/cassandra/load_balancing/policies/round_robin.rb

@@ -128,6 +128,13 @@ module Cassandra
 
           Plan.new(hosts, position)
         end
+
+        # @private
+        def inspect
+          "#<#{self.class.name}:0x#{object_id.to_s(16)} " \
+          "hosts=#{@hosts.inspect}, " \
+          "position=#{@position.inspect}>"
+        end
       end
     end
   end

data/lib/cassandra/load_balancing/policies/token_aware.rb

@@ -136,6 +136,13 @@ module Cassandra
 
           Plan.new(replicas, @policy, keyspace, statement, options)
         end
+
+        # @private
+        def inspect
+          "#<#{self.class.name}:0x#{object_id.to_s(16)} " \
+          "policy=#{@policy.inspect}, " \
+          "shuffle=#{@shuffle.inspect}>"
+        end
       end
     end
   end

data/lib/cassandra/load_balancing/policies/white_list.rb

@@ -87,6 +87,13 @@ module Cassandra
         def host_down(host)
           @policy.host_down(host) if @ips.include?(host.ip)
         end
+
+        # @private
+        def inspect
+          "#<#{self.class.name}:0x#{object_id.to_s(16)} " \
+          "policy=#{@policy.inspect}, " \
+          "ips=#{@ips.inspect}>"
+        end
       end
     end
   end

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