cassandra-driver 1.0.0.beta.2-java

data/lib/cassandra/reconnection.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 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 Reconnection
+    # Reconnection schedule
+    # @abstract Actual reconnection schedules returned from
+    #   {Cassandra::Reconnection::Policy} implementation don't need to inherit
+    #   this class. This class exists for documentation purposes only.
+    class Schedule
+      # @return [Numeric] the next reconnection interval in seconds
+      def next
+      end
+    end
+
+    # A reconnection policy
+    # @abstract Actual reconnection policies supplied as `:reconnection_policy`
+    #   option to {Cassandra.connect} don't need to inherit this class, only
+    #   implement its methods. This class exists for documentation purposes
+    #   only.
+    class Policy
+      # Returns a reconnection schedule
+      #
+      # @note Reconnection schedule returned from this method doesn't need to
+      #   extend {Cassandra::Reconnection::Schedule}, only conform to its
+      #   interface.
+      # @return [Cassandra::Reconnection::Schedule] reconnection schedule
+      def schedule
+      end
+    end
+  end
+end
+
+require 'cassandra/reconnection/policies'

data/lib/cassandra/result.rb

@@ -0,0 +1,215 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 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
+  class Result
+    include Enumerable
+
+    # Query execution information, such as number of retries and all tried hosts, etc.
+    # @return [Cassandra::Execution::Info]
+    def execution_info
+      @info ||= Execution::Info.new(@keyspace, @statement, @options, @hosts, @consistency, @retries, @trace_id ? Execution::Trace.new(@trace_id, @client) : nil)
+    end
+
+    # @return [Boolean] whether it has any rows
+    def empty?
+    end
+
+    # @return [Integer] rows count
+    def size
+    end
+    alias :length :size
+
+    # @yieldparam row [Hash] current row
+    # @return [Enumerator, self] returns Enumerator if no block given
+    def each
+    end
+    alias :rows :each
+    alias :each_row :each
+
+    # @return [Boolean] whether no more pages are available
+    def last_page?
+    end
+
+    # Loads next page synchronously
+    #
+    # @param options [Hash] additional options, just like the ones for
+    #   {Cassandra::Session#execute}
+    #
+    # @return [Cassandra::Result, nil] returns `nil` if last page
+    #
+    # @see Cassandra::Session#execute
+    def next_page(options = nil)
+    end
+
+    # Loads next page asynchronously
+    #
+    # @param options [Hash] additional options, just like the ones for
+    #   {Cassandra::Session#execute_async}
+    #
+    # @return [Cassandra::Future<Cassandra::Result, nil>] `nil` if last
+    #   page
+    #
+    # @see Cassandra::Session#execute
+    def next_page_async(options = nil)
+    end
+  end
+
+  # @private
+  module Results
+    class Paged < Result
+      def initialize(rows, paging_state, trace_id, keyspace, statement, options, hosts, consistency, retries, client, futures_factory)
+        @rows           = rows
+        @paging_state   = paging_state
+        @trace_id       = trace_id
+        @keyspace       = keyspace
+        @statement      = statement
+        @options        = options
+        @hosts          = hosts
+        @consistency    = consistency
+        @retries        = retries
+        @client         = client
+        @futures        = futures_factory
+      end
+
+      # Returns whether or not there are any rows in this result set
+      def empty?
+        @rows.empty?
+      end
+
+      # Returns count of underlying rows
+      def size
+        @rows.size
+      end
+      alias :length :size
+
+      def each(&block)
+        if block_given?
+          @rows.each(&block)
+          self
+        else
+          @rows.each
+        end
+      end
+      alias :rows :each
+      alias :each_row :each
+
+      # Returns true when there are no more pages to load.
+      def last_page?
+        @paging_state.nil?
+      end
+
+      # Returns the next page or nil when there is no next page.
+      #
+      # @return [Cassandra::Result]
+      def next_page(options = nil)
+        next_page_async(options).get
+      end
+
+      def next_page_async(options = nil)
+        return @futures.value(nil) if @paging_state.nil?
+
+        options = options ? @options.override(options) : @options
+
+        if @statement.is_a?(Statements::Simple)
+          @client.query(@statement, options, @paging_state)
+        else
+          @client.execute(@statement, options, @paging_state)
+        end
+      end
+
+      def inspect
+        "#<Cassandra::Result:0x#{self.object_id.to_s(16)} @rows=#{@rows.inspect} @last_page=#{@paging_state.nil?}>"
+      end
+    end
+
+    class Void < Result
+      def initialize(trace_id, keyspace, statement, options, hosts, consistency, retries, client, futures_factory)
+        @trace_id    = trace_id
+        @keyspace    = keyspace
+        @statement   = statement
+        @options     = options
+        @hosts       = hosts
+        @consistency = consistency
+        @retries     = retries
+        @client      = client
+        @futures     = futures_factory
+      end
+
+      # Returns whether or not there are any rows in this result set
+      def empty?
+        true
+      end
+
+      # Returns count of underlying rows
+      def size
+        0
+      end
+      alias :length :size
+
+      # Iterates over each row in the result set.
+      #
+      # @yieldparam row [Hash] each row in the result set as a hash
+      # @return [Cassandra::Result]
+      def each(&block)
+        if block_given?
+          NO_ROWS.each(&block)
+          self
+        else
+          NO_ROWS.each
+        end
+      end
+      alias :rows :each
+      alias :each_row :each
+
+      # Returns true when there are no more pages to load.
+      #
+      # This is only relevant when you have requested paging of the results with
+      # the `:page_size` option to {Cassandra::Client::Client#execute} or
+      # {Cassandra::Client::PreparedStatement#execute}.
+      #
+      # @see Cassandra::Client::Client#execute
+      def last_page?
+        true
+      end
+
+      # Returns the next page or nil when there is no next page.
+      #
+      # This is only relevant when you have requested paging of the results with
+      # the `:page_size` option to {Cassandra::Client::Client#execute} or
+      # {Cassandra::Client::PreparedStatement#execute}.
+      #
+      # @see Cassandra::Client::Client#execute
+      def next_page_async(options = nil)
+        @futures.value(nil)
+      end
+
+      def next_page(options = nil)
+        nil
+      end
+
+      def inspect
+        "#<Cassandra::Result:0x#{self.object_id.to_s(16)} @rows=[] @last_page=true>"
+      end
+
+      private
+
+      NO_ROWS = [].freeze
+    end
+  end
+end

data/lib/cassandra/retry/policies/default.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 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 Retry
+    module Policies
+      class Default
+        include Policy
+
+        def read_timeout(statement, consistency, required, received, retrieved, retries)
+          return reraise if retries > 0
+
+          if received >= required && !retrieved
+            try_again(consistency)
+          else
+            reraise
+          end
+        end
+
+        def write_timeout(statement, consistency, type, required, received, retries)
+          return reraise if retries > 0
+
+          type == :batch_log ? try_again(consistency) : reraise
+        end
+
+        def unavailable(statement, consistency, required, alive, retries)
+          reraise
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/retry/policies/downgrading_consistency.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 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 Retry
+    module Policies
+      class DowngradingConsistency
+        include Policy
+
+        def read_timeout(statement, consistency, required, received, retrieved, retries)
+          return reraise if retries > 0 || SERIAL_CONSISTENCIES.include?(consistency)
+          return max_likely_to_work(consistency, required, received) if received < required
+
+          retrieved ? reraise : try_again(consistency)
+        end
+
+        def write_timeout(statement, consistency, type, required, received, retries)
+          return reraise if retries > 0
+
+          case type
+          when :simple, :batch
+            ignore
+          when :unlogged_batch
+            max_likely_to_work(consistency, required, received)
+          when :batch_log
+            try_again(consistency)
+          else
+            reraise
+          end
+        end
+
+        def unavailable(statement, consistency, required, alive, retries)
+          return reraise if retries > 0
+
+          max_likely_to_work(consistency, required, alive)
+        end
+
+        private
+
+        def max_likely_to_work(consistency, required, received)
+          if consistency == :all && required > 1 && received >= (required.to_f / 2).floor + 1
+            try_again(:quorum)
+          elsif received >= 3
+            try_again(:three)
+          elsif received >= 2
+            try_again(:two)
+          elsif received >= 1
+            try_again(:one)
+          else
+            reraise
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/retry/policies/fallthrough.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 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 Retry
+    module Policies
+      class Fallthrough
+        include Policy
+
+        def read_timeout(statement, consistency, required, received, retrieved, retries)
+          reraise
+        end
+
+        def write_timeout(statement, consistency, type, required, received, retries)
+          reraise
+        end
+
+        def unavailable(statement, consistency, required, alive, retries)
+          reraise
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/retry/policies.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 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.
+#++
+
+require 'cassandra/retry/policies/default'
+require 'cassandra/retry/policies/downgrading_consistency'
+require 'cassandra/retry/policies/fallthrough'

data/lib/cassandra/retry.rb

@@ -0,0 +1,142 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 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 Retry
+    # @abstract Actual retry policies supplied as `:retry_policy` option to
+    #   {Cassandra.connect} don't need to inherit this class, only implement
+    #   its methods. This class exists for documentation purposes only.
+    module Policy
+      # Decides wether to retry a read and at what consistency level.
+      # 
+      # @note this method may be called even if required_responses >= received
+      #   responses if data_present is false.
+      # 
+      # @param statement [Cassandra::Statement] the original statement that timed out
+      # @param consistency [Symbol] the original consistency level for the
+      #   request, one of {Cassandra::CONSISTENCIES}
+      # @param required [Integer] the number of responses required to achieve
+      #   requested consistency level
+      # @param received [Integer] the number of responses received by the time
+      #   the query timed out
+      # @param retrieved [Boolean] whether actual data (as opposed to data
+      #   checksum) was present in the received responses.
+      # @param retries [Integer] the number of retries already performed
+      # 
+      # @return [Cassandra::Policies::Retry::Decision] a retry decision
+      #
+      # @see Cassandra::Retry::Policy#try_again
+      # @see Cassandra::Retry::Policy#reraise
+      # @see Cassandra::Retry::Policy#ignore
+      def read_timeout(statement, consistency, required, received, retrieved, retries)
+      end
+
+      # Decides wether to retry a write and at what consistency level.
+      # 
+      # @param statement [Cassandra::Statement] the original statement that timed out
+      # @param consistency [Symbol] the original consistency level for the
+      #   request, one of {Cassandra::CONSISTENCIES}
+      # @param type [Symbol] One of `:simple`, `:batch`, `:unlogged_batch`,
+      #   `:counter` or `:batch_log`
+      # @param required [Integer] the number of acks required to achieve
+      #   requested consistency level
+      # @param received [Integer] the number of acks received by the time the
+      #   query timed out
+      # @param retries [Integer] the number of retries already performed
+      # 
+      # @return [Cassandra::Policies::Retry::Decision] a retry decision
+      #
+      # @see Cassandra::Retry::Policy#try_again
+      # @see Cassandra::Retry::Policy#reraise
+      # @see Cassandra::Retry::Policy#ignore
+      def write_timeout(statement, consistency, type, required, received, retries)
+      end
+
+      # Decides wether to retry and at what consistency level on an Unavailable
+      # exception.
+      # 
+      # @param statement [Cassandra::Statement] the original Statement that timed out
+      # @param consistency [Symbol] the original consistency level for the
+      #   request, one of {Cassandra::CONSISTENCIES}
+      # @param required [Integer] the number of replicas required to achieve
+      #   requested consistency level
+      # @param alive [Integer] the number of replicas received by the time the
+      #   query timed out
+      # @param retries [Integer] the number of retries already performed
+      # 
+      # @return [Cassandra::Policies::Retry::Decision] a retry decision
+      #
+      # @see Cassandra::Retry::Policy#try_again
+      # @see Cassandra::Retry::Policy#reraise
+      # @see Cassandra::Retry::Policy#ignore
+      def unavailable(statement, consistency, required, alive, retries)
+      end
+
+      private
+
+      # Returns a decision that signals retry at a given consistency
+      #
+      # @param consistency [Symbol] consistency level for the retry, one of
+      #   {Cassandra::CONSISTENCIES}
+      # @return [Cassandra::Policies::Retry::Decision] tell driver to retry
+      def try_again(consistency)
+        Decisions::Retry.new(consistency)
+      end
+
+      # Returns a decision that signals to driver to reraise original error to
+      # the application
+      #
+      # @return [Cassandra::Policies::Retry::Decision] tell driver to reraise
+      def reraise
+        DECISION_RERAISE
+      end
+
+      # Returns a decision that signals to driver to ignore the error
+      #
+      # @return [Cassandra::Policies::Retry::Decision] tell driver to ignore the error
+      #   and return an empty result to the application
+      def ignore
+        DECISION_IGNORE
+      end
+    end
+
+    # @private
+    module Decisions
+      class Retry
+        attr_reader :consistency
+
+        def initialize(consistency)
+          @consistency = consistency
+        end
+      end
+
+      class Reraise
+      end
+
+      class Ignore
+      end
+    end
+
+    # @private
+    DECISION_RERAISE = Decisions::Reraise.new
+    # @private
+    DECISION_IGNORE  = Decisions::Ignore.new
+  end
+end
+
+require 'cassandra/retry/policies'