cassandra-driver 3.0.3-java → 3.1.0-java

data/lib/cassandra/column_container.rb

@@ -60,8 +60,10 @@ module Cassandra
       # @return [ColumnContainer::Compaction] the compaction strategy of this column-container.
       attr_reader :compaction_strategy
 
+      # @return whether or not change data capture is enabled on this table.
+      attr_reader :cdc
+
       # @private
-      # rubocop:disable Metrics/ParameterLists
       def initialize(comment,
                      read_repair_chance,
                      local_read_repair_chance,
@@ -80,7 +82,8 @@ module Cassandra
                      compression,
                      compact_storage,
                      crc_check_chance,
-                     extensions)
+                     extensions,
+                     cdc)
         @comment                     = comment
         @read_repair_chance          = read_repair_chance
         @local_read_repair_chance    = local_read_repair_chance
@@ -100,6 +103,7 @@ module Cassandra
         @compact_storage             = compact_storage
         @crc_check_chance            = crc_check_chance
         @extensions                  = extensions
+        @cdc                         = cdc
       end
 
       # Return whether to replicate counter updates to other replicas. It is *strongly* recommended
@@ -130,6 +134,7 @@ module Cassandra
           options << "bloom_filter_fp_chance = #{Util.encode_object(@bloom_filter_fp_chance)}"
         end
         options << "caching = #{Util.encode_object(@caching)}" unless @caching.nil?
+        options << 'cdc = true' if @cdc
         options << "comment = #{Util.encode_object(@comment)}" unless @comment.nil?
         options << "compaction = #{@compaction_strategy.to_cql}" unless @compaction_strategy.nil?
         options << "compression = #{Util.encode_object(@compression)}" unless @compression.nil?
@@ -153,7 +158,6 @@ module Cassandra
         options << "read_repair_chance = #{Util.encode_object(@read_repair_chance)}" unless @read_repair_chance.nil?
         options << "replicate_on_write = '#{@replicate_on_write}'" unless @replicate_on_write.nil?
         options << "speculative_retry = #{Util.encode_object(@speculative_retry)}" unless @speculative_retry.nil?
-
         options.join("\nAND ")
       end
 
@@ -176,7 +180,8 @@ module Cassandra
           @compression == other.compression &&
           @compact_storage == other.compact_storage? &&
           @crc_check_chance == other.crc_check_chance &&
-          @extensions == other.extensions
+          @extensions == other.extensions &&
+          @cdc == other.cdc
       end
       alias == eql?
     end

data/lib/cassandra/custom_data.rb

@@ -20,32 +20,34 @@
 # 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"
+module Cassandra
+  module CustomData
+    def self.included(base)
+      base.send :include, InstanceMethods
+      base.extend ClassMethods
     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"
+    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
-  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"
+    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
 end

data/lib/cassandra/driver.rb

@@ -84,7 +84,7 @@ module Cassandra
                                      cluster_registry,
                                      cluster_schema,
                                      cluster_metadata,
-                                     load_balancing_policy,
+                                     profile_manager.default_profile.load_balancing_policy,
                                      reconnection_policy,
                                      address_resolution_policy,
                                      connector,
@@ -104,21 +104,22 @@ module Cassandra
                         cluster_metadata,
                         execution_options,
                         connection_options,
-                        load_balancing_policy,
+                        profile_manager,
                         reconnection_policy,
-                        retry_policy,
                         address_resolution_policy,
                         connector,
                         futures_factory,
-			timestamp_generator)
+                        timestamp_generator)
     end
 
     let(:execution_options) do
-      Execution::Options.new(consistency: consistency,
+      Execution::Options.new(consistency: profile_manager.default_profile.consistency,
                              trace: trace,
                              page_size: page_size,
-                             timeout: timeout,
-                             idempotent: false)
+                             timeout: profile_manager.default_profile.timeout,
+                             idempotent: false,
+                             load_balancing_policy: profile_manager.default_profile.load_balancing_policy,
+                             retry_policy: profile_manager.default_profile.retry_policy)
     end
 
     let(:connection_options) do
@@ -140,13 +141,15 @@ module Cassandra
         schema_refresh_timeout,
         nodelay,
         requests_per_connection,
-        custom_types
+        custom_types,
+        allow_beta_protocol
       )
     end
 
-    let(:custom_types)      { [] }
+    let(:custom_types)              { [] }
     let(:port)                      { 9042 }
     let(:protocol_version)          { nil }
+    let(:allow_beta_protocol)       { false }
     let(:connect_timeout)           { 10 }
     let(:ssl)                       { false }
     let(:logger)                    { NullLogger.new }
@@ -157,7 +160,8 @@ module Cassandra
     let(:load_balancing_policy)     do
       LoadBalancing::Policies::TokenAware.new(
         LoadBalancing::Policies::DCAwareRoundRobin.new(datacenter, 0),
-        shuffle_replicas)
+        shuffle_replicas
+      )
     end
     let(:reconnection_policy) do
       Reconnection::Policies::Exponential.new(0.5, 30, 2)
@@ -180,7 +184,14 @@ module Cassandra
     let(:connections_per_local_node)  { nil }
     let(:connections_per_remote_node) { nil }
     let(:requests_per_connection) { nil }
-
+    let(:default_execution_profile) {
+      Cassandra::Execution::Profile.new(load_balancing_policy: load_balancing_policy,
+                                        retry_policy: retry_policy,
+                                        consistency: consistency,
+                                        timeout: timeout)
+    }
+    let(:execution_profiles) { {} }
+    let(:profile_manager) { Cassandra::Execution::ProfileManager.new(default_execution_profile, execution_profiles) }
     let(:listeners) { [] }
 
     def initialize(defaults = {})
@@ -188,8 +199,11 @@ module Cassandra
     end
 
     def connect(addresses)
-      load_balancing_policy.setup(cluster)
-      cluster_registry.add_listener(load_balancing_policy)
+      profile_manager.load_balancing_policies.each do |lbp|
+        lbp.setup(cluster)
+        cluster_registry.add_listener(lbp)
+      end
+
       cluster_registry.add_listener(control_connection)
       listeners.each do |listener|
         cluster.register(listener)
@@ -236,6 +250,9 @@ module Cassandra
       picker.when('3.') do
         Cluster::Schema::Fetchers::V3_0_x.new(schema_cql_type_parser, cluster_schema)
       end
+      picker.when('4.') do
+        Cluster::Schema::Fetchers::V3_0_x.new(schema_cql_type_parser, cluster_schema)
+      end
 
       picker
     end

data/lib/cassandra/errors.rb

@@ -348,6 +348,9 @@ module Cassandra
       attr_reader :received
       # @return [Integer] the number of writes failed
       attr_reader :failed
+      # @return [Hash<IPAddr, Integer>] map of <ip, error-code>. This is new in v5 and is nil in previous versions
+      #    of the Casssandra protocol.
+      attr_reader :failures_by_node
 
       # @private
       def initialize(message,
@@ -363,7 +366,8 @@ module Cassandra
                      consistency,
                      required,
                      failed,
-                     received)
+                     received,
+                     failures_by_node)
         super(message,
               payload,
               warnings,
@@ -378,6 +382,7 @@ module Cassandra
         @required    = required
         @failed      = failed
         @received    = received
+        @failures_by_node = failures_by_node
       end
     end
 
@@ -400,6 +405,9 @@ module Cassandra
       attr_reader :received
       # @return [Integer] the number of reads failed
       attr_reader :failed
+      # @return [Hash<IPaddr, Integer>] map of <ip, error-code>. This is new in v5 and is nil in previous versions
+      #    of the Casssandra protocol.
+      attr_reader :failures_by_node
 
       # @private
       def initialize(message,
@@ -415,7 +423,8 @@ module Cassandra
                      consistency,
                      required,
                      failed,
-                     received)
+                     received,
+                     failures_by_node)
         super(message,
               payload,
               warnings,
@@ -430,6 +439,7 @@ module Cassandra
         @required    = required
         @failed      = failed
         @received    = received
+        @failures_by_node = failures_by_node
       end
 
       def retrieved?

data/lib/cassandra/execution/options.rb

@@ -50,11 +50,11 @@ module Cassandra
       attr_reader :paging_state
 
       # @return [nil, Hash<String, String>] custom outgoing payload, a map of
-      # string and byte buffers.
+      #   string and byte buffers.
       #
       # @see https://github.com/apache/cassandra/blob/cassandra-3.4/doc/native_protocol_v4.spec#L125-L131 Description
       #   of custom payload in Cassandra native protocol v4.
-      # @see http://docs.datastax.com/en/developer/java-driver/3.0/supplemental/manual/custom_payloads/?local=true&nav=toc#enabling-custom-payloads-on-c-nodes
+      # @see http://dsdocs30_java/manual/custom_payloads/#enabling-custom-payloads-on-c-nodes
       #   Enabling custom payloads on Cassandra nodes.
       #
       # @example Sending a custom payload
@@ -64,21 +64,31 @@ module Cassandra
       #            })
       attr_reader :payload
 
+      # @return [Cassandra::LoadBalancing::Policy] load-balancing policy that determines which node will run the
+      #   next statement.
+      attr_reader :load_balancing_policy
+
+      # @return [Cassandra::Retry::Policy] retry policy that determines how request retries should be handled for
+      #   different failure modes.
+      attr_reader :retry_policy
+
       # @private
       # @param options [Hash] execution options to validate and encapsulate
       # @param trusted_options [Options] (optional) base Execution::Options from which
       #        to create this new Options object.
       def initialize(options, trusted_options = nil)
-        consistency        = options[:consistency]
-        page_size          = options[:page_size]
-        trace              = options[:trace]
-        timeout            = options[:timeout]
-        serial_consistency = options[:serial_consistency]
-        paging_state       = options[:paging_state]
-        arguments          = options[:arguments]
-        type_hints         = options[:type_hints]
-        idempotent         = options[:idempotent]
-        payload            = options[:payload]
+        consistency           = options[:consistency]
+        page_size             = options[:page_size]
+        trace                 = options[:trace]
+        timeout               = options[:timeout]
+        serial_consistency    = options[:serial_consistency]
+        paging_state          = options[:paging_state]
+        arguments             = options[:arguments]
+        type_hints            = options[:type_hints]
+        idempotent            = options[:idempotent]
+        payload               = options[:payload]
+        load_balancing_policy = options[:load_balancing_policy]
+        retry_policy          = options[:retry_policy]
 
         # consistency is a required attribute of an Options object. If we are creating
         # an Options object from scratch (e.g. no trusted_options as base) validate the
@@ -91,6 +101,22 @@ module Cassandra
           end
         end
 
+        # load_balancing_policy and retry_policy are required, but can fallback to trusted_options, just like
+        # consistency.
+        if trusted_options.nil? || !load_balancing_policy.nil?
+          methods = [:host_up, :host_down, :host_found, :host_lost, :setup, :teardown,
+                     :distance, :plan]
+          Util.assert_responds_to_all(methods, load_balancing_policy,
+                                      ":load_balancing_policy #{load_balancing_policy.inspect} must respond " \
+                                      "to #{methods.inspect}, but doesn't")
+        end
+        if trusted_options.nil? || !retry_policy.nil?
+          methods = [:read_timeout, :write_timeout, :unavailable]
+          Util.assert_responds_to_all(methods, retry_policy,
+                                      ":retry_policy #{retry_policy.inspect} must respond to #{methods.inspect}, " \
+                                      "but doesn't")
+        end
+
         unless serial_consistency.nil?
           Util.assert_one_of(SERIAL_CONSISTENCIES, serial_consistency) do
             ":serial_consistency must be one of #{SERIAL_CONSISTENCIES.inspect}, " \
@@ -173,6 +199,8 @@ module Cassandra
           @serial_consistency = serial_consistency
           @arguments = arguments
           @type_hints = type_hints
+          @load_balancing_policy = load_balancing_policy
+          @retry_policy = retry_policy
         else
           @consistency = consistency || trusted_options.consistency
           @page_size = page_size || trusted_options.page_size
@@ -181,6 +209,8 @@ module Cassandra
           @serial_consistency = serial_consistency || trusted_options.serial_consistency
           @arguments = arguments || trusted_options.arguments
           @type_hints = type_hints || trusted_options.type_hints
+          @load_balancing_policy = load_balancing_policy || trusted_options.load_balancing_policy
+          @retry_policy = retry_policy || trusted_options.retry_policy
         end
 
         # The following fields are *not* inherited from trusted_options, so we always
@@ -210,18 +240,24 @@ module Cassandra
           other.serial_consistency == @serial_consistency &&
           other.paging_state == @paging_state &&
           other.arguments == @arguments &&
-          other.type_hints == @type_hints
+          other.type_hints == @type_hints &&
+          other.load_balancing_policy == @load_balancing_policy &&
+          other.retry_policy == @retry_policy
       end
       alias == eql?
 
       # @private
       def override(*options)
         merged = options.unshift({}).inject do |base, opts|
+          # Skip nil args
           next base unless opts
-          Util.assert_instance_of(::Hash, opts) do
-            "options must be a Hash, #{options.inspect} given"
+
+          if opts.is_a?(Cassandra::Execution::Profile)
+            base.merge!(opts.to_h)
+          else
+            Util.assert_instance_of(::Hash, opts, "options must be a Hash, #{opts.inspect} given")
+            base.merge!(opts)
           end
-          base.merge!(opts)
         end
 
         Options.new(merged, self)

data/lib/cassandra/execution/profile.rb

@@ -0,0 +1,150 @@
+# 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.
+#++
+
+module Cassandra
+  module Execution
+    # A profile is a collection of settings to use when executing and preparing statements. Register different
+    # profiles when creating the {Cassandra::Cluster} and execute/prepare statements with a particular profile
+    # by providing its name to the relevant method in {Session}.
+    #
+    # @see Cassandra.cluster
+    # @see Session#execute_async
+    # @see Session#execute
+    # @see Session#prepare_async
+    # @see Session#prepare
+    class Profile
+      # @return [Cassandra::LoadBalancing::Policy] load-balancing policy that determines which node will run the
+      #   next statement.
+      attr_reader :load_balancing_policy
+
+      # @return [Cassandra::Retry::Policy] retry policy that determines how request retries should be handled for
+      #   different failure modes.
+      attr_reader :retry_policy
+
+      # @return [Symbol] consistency level with which to run statements.
+      attr_reader :consistency
+
+      # @return [Numeric] request execution timeout in seconds. `nil` means there is no timeout.
+      attr_reader :timeout
+
+      # @private
+      DEFAULT_OPTIONS = { consistency: :local_one, timeout: 12 }.freeze
+
+      # @param options [Hash] hash of attributes. Unspecified attributes fall back to system defaults.
+      # @option options [Numeric] :timeout (12) Request execution timeout in
+      #   seconds. Setting value to `nil` will remove request timeout.
+      # @option options [Cassandra::LoadBalancing::Policy] :load_balancing_policy (
+      #   LoadBalancing::Policies::TokenAware(LoadBalancing::Policies::DCAwareRoundRobin)) Load-balancing policy
+      #   that determines which node will run the next statement.
+      # @option options [Cassandra::Retry::Policy] :retry_policy (Retry::Policies::Default) Retry policy that
+      #   determines how request retries should be handled for different failure modes.
+      # @option options [Symbol] :consistency (:local_one) Consistency level with which to run statements. Must be one
+      #   of {Cassandra::CONSISTENCIES}.
+      def initialize(options = {})
+        validate(options)
+        options = DEFAULT_OPTIONS.merge(options)
+        @load_balancing_policy = options[:load_balancing_policy] ||
+            LoadBalancing::Policies::TokenAware.new(
+                LoadBalancing::Policies::DCAwareRoundRobin.new,
+                true)
+        @retry_policy = options[:retry_policy] || Retry::Policies::Default.new
+        @consistency = options[:consistency]
+        @timeout = options[:timeout]
+      end
+
+      # @private
+      def to_h
+        {
+            load_balancing_policy: @load_balancing_policy,
+            retry_policy: @retry_policy,
+            consistency: @consistency,
+            timeout: @timeout
+        }
+      end
+
+      # @private
+      def eql?(other)
+        other.is_a?(Profile) && \
+          @load_balancing_policy == other.load_balancing_policy && \
+          @retry_policy == other.retry_policy && \
+          @consistency == other.consistency && \
+          @timeout == other.timeout
+      end
+      alias == eql?
+
+      # @private
+      def hash
+        @hash ||= begin
+          h = 17
+          h = 31 * h + @load_balancing_policy.hash
+          h = 31 * h + @retry_policy.hash
+          h = 31 * h + @consistency.hash
+          h = 31 * h + @timeout.hash
+          h
+        end
+      end
+
+      # @private
+      def inspect
+        "#<#{self.class.name}:0x#{object_id.to_s(16)} " \
+      "load_balancing_policy=#{@load_balancing_policy.inspect}, " \
+      "retry_policy=#{@retry_policy.inspect}, " \
+      "consistency=#{@consistency.inspect}, " \
+      "timeout=#{@timeout.inspect}>"
+      end
+
+      # @private
+      def validate(options)
+        if options.key?(:timeout)
+          timeout = options[:timeout]
+
+          unless timeout.nil?
+            Util.assert_instance_of(::Numeric, timeout, ":timeout must be a number of seconds, #{timeout.inspect} given")
+            Util.assert(timeout > 0, ":timeout must be greater than 0, #{timeout} given")
+          end
+        end
+
+        if options.key?(:load_balancing_policy)
+          load_balancing_policy = options[:load_balancing_policy]
+          methods = [:host_up, :host_down, :host_found, :host_lost, :setup, :teardown,
+                     :distance, :plan]
+          Util.assert_responds_to_all(methods, load_balancing_policy) do
+            ":load_balancing_policy #{load_balancing_policy.inspect} must respond " \
+            "to #{methods.inspect}, but doesn't"
+          end
+        end
+
+        if options.key?(:retry_policy)
+          retry_policy = options[:retry_policy]
+          methods = [:read_timeout, :write_timeout, :unavailable]
+          Util.assert_responds_to_all(methods, retry_policy) do
+            ":retry_policy #{retry_policy.inspect} must respond to #{methods.inspect}, " \
+            "but doesn't"
+          end
+        end
+
+        if options.key?(:consistency)
+          consistency = options[:consistency]
+          Util.assert_one_of(CONSISTENCIES, consistency,
+                             ":consistency must be one of #{CONSISTENCIES.inspect}, " \
+                             "#{consistency.inspect} given")
+        end
+      end
+    end
+  end
+end