cassandra-driver 1.0.0 → 1.1.0

data/lib/cassandra/keyspace.rb

@@ -118,6 +118,13 @@ module Cassandra
       Keyspace.new(@name, @durable_writes, @replication, tables)
     end
 
+    # @private
+    def delete_table(table_name)
+      tables = @tables.dup
+      tables.delete(table_name)
+      Keyspace.new(@name, @durable_writes, @replication, tables)
+    end
+
     # @private
     def create_partition_key(table, values)
       table = @tables[table]

data/lib/cassandra/load_balancing.rb

@@ -28,11 +28,21 @@ module Cassandra
     class Policy
       # Allows policy to initialize with the cluster instance. This method is
       # called once before connecting to the cluster.
+      #
       # @param cluster [Cassandra::Cluster] current cluster instance
       # @return [void]
       def setup(cluster)
       end
 
+      # Allows policy to release any external resources it might be holding.
+      # This method is called once the cluster has been terminated after calling
+      # {Cassandra::Cluster#close}
+      #
+      # @param cluster [Cassandra::Cluster] current cluster instance
+      # @return [void]
+      def teardown(cluster)
+      end
+
       # @see Cassandra::Listener#host_up
       def host_up(host)
       end

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

@@ -136,12 +136,12 @@ module Cassandra
             remote = @remote
           end
 
-          position = @position
-          total    = local.size + remote.size
+          total = local.size + remote.size
 
           return EMPTY_PLAN if total == 0
 
-          @position = (@position + 1) % total
+          position  = @position % total
+          @position = position + 1
 
           Plan.new(local, remote, position)
         end

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

@@ -37,7 +37,8 @@ module Cassandra
             return if @remaining == 0
 
             @remaining -= 1
-            index, @index = @index, (@index + 1) % @total
+            index  = @index
+            @index = (index + 1) % @total
 
             @hosts[index]
           end
@@ -117,12 +118,13 @@ module Cassandra
         # @return [Cassandra::LoadBalancing::Plan] a rotated load balancing plan
         # @see Cassandra::LoadBalancing::Policy#plan
         def plan(keyspace, statement, options)
-          hosts    = @hosts
-          position = @position
-          total    = hosts.size
+          hosts = @hosts
+          total = hosts.size
+
           return EMPTY_PLAN if total == 0
 
-          @position = (position + 1) % total
+          position  = @position % total
+          @position = position + 1
 
           Plan.new(hosts, position)
         end

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

@@ -88,13 +88,24 @@ module Cassandra
         #   @see Cassandra::LoadBalancing::Policy#host_lost
         def_delegators :@policy, :distance, :host_found, :host_up, :host_down, :host_lost
 
-        # @param wrapped_policy [Cassandra::LoadBalancing::Policy] actual policy to filter
-        def initialize(wrapped_policy)
-          methods = [:host_up, :host_down, :host_found, :host_lost, :distance, :plan]
+        # @param wrapped_policy [Cassandra::LoadBalancing::Policy] actual
+        #   policy to filter
+        # @param shuffle [Boolean] (true) whether or not to shuffle the replicas
+        #
+        # @note If replicas are not shuffled (`shuffle = false`), then it is
+        #   possibile to create hotspots in a write-heavy scenario, where most
+        #   of the write requests will be handled by the same node(s). The
+        #   default behavior of shuffling replicas helps mitigate this by
+        #   universally distributing write load between replicas. However, it
+        #   under-utilizes read caching and forces multiple replicas to cache
+        #   the same read statements.
+        def initialize(wrapped_policy, shuffle = true)
+          methods = [:host_up, :host_down, :host_found, :host_lost, :setup, :teardown, :distance, :plan]
 
           Util.assert_responds_to_all(methods, wrapped_policy) { "supplied policy must respond to #{methods.inspect}, but doesn't" }
 
-          @policy = wrapped_policy
+          @policy  = wrapped_policy
+          @shuffle = !!shuffle
         end
 
         def setup(cluster)
@@ -103,13 +114,25 @@ module Cassandra
           nil
         end
 
+        def teardown(cluster)
+          @cluster = nil
+          @policy.teardown(cluster)
+          nil
+        end
+
         def plan(keyspace, statement, options)
           return @policy.plan(keyspace, statement, options) unless @cluster
 
           replicas = @cluster.find_replicas(keyspace, statement)
           return @policy.plan(keyspace, statement, options) if replicas.empty?
 
-          Plan.new(replicas.shuffle, @policy, keyspace, statement, options)
+          if @shuffle
+            replicas = replicas.shuffle
+          else
+            replicas = replicas.dup
+          end
+
+          Plan.new(replicas, @policy, keyspace, statement, options)
         end
       end
     end

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

@@ -36,7 +36,7 @@ module Cassandra
         # @raise [ArgumentError] if arguments are of unexpected types
         def initialize(ips, wrapped_policy)
           Util.assert_instance_of(::Enumerable, ips) { "ips must be an Enumerable, #{ips.inspect} given" }
-          methods = [:host_up, :host_down, :host_found, :host_lost, :distance, :plan]
+          methods = [:host_up, :host_down, :host_found, :host_lost, :setup, :teardown, :distance, :plan]
           Util.assert_responds_to_all(methods, wrapped_policy) { "supplied policy must respond to #{methods.inspect}, but doesn't" }
 
           @ips    = ::Set.new

data/lib/cassandra/protocol/cql_protocol_handler.rb

@@ -190,7 +190,10 @@ module Cassandra
           @terminate = nil
         end
 
-        @connection.close(cause)
+        @scheduler.schedule_timer(0).on_value do
+          @connection.close(cause)
+        end
+
         @closed_promise.future
       end
 

data/lib/cassandra/result.rb

@@ -51,6 +51,8 @@ module Cassandra
     # @param options [Hash] additional options, just like the ones for
     #   {Cassandra::Session#execute}
     #
+    # @note `:paging_state` option will be ignored.
+    #
     # @return [Cassandra::Result, nil] returns `nil` if last page
     #
     # @see Cassandra::Session#execute
@@ -62,17 +64,38 @@ module Cassandra
     # @param options [Hash] additional options, just like the ones for
     #   {Cassandra::Session#execute_async}
     #
+    # @note `:paging_state` option will be ignored.
+    #
     # @return [Cassandra::Future<Cassandra::Result, nil>] `nil` if last
     #   page
     #
     # @see Cassandra::Session#execute
     def next_page_async(options = nil)
     end
+
+    # Exposes current paging state for stateless pagination.
+    #
+    # @return [String, nil] current paging state as a `String` or `nil`.
+    #
+    # @note Although this feature exists to allow web applications to store
+    #   paging state in an [HTTP cookie](http://en.wikipedia.org/wiki/HTTP_cookie), **it is not safe to
+    #   expose without encrypting or otherwise securing it**. Paging state
+    #   contains information internal to the Apache Cassandra cluster, such as
+    #   partition key and data. Additionally, if a paging state is sent with CQL
+    #   statement, different from the original, the behavior of Cassandra is
+    #   undefined and will likely cause a server process of the coordinator of
+    #   such request to abort.
+    #
+    # @see https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v2.spec#L482-L487 Paging State description in Cassandra Native Protocol v2 specification
+    def paging_state
+    end
   end
 
   # @private
   module Results
     class Paged < Result
+      attr_reader :paging_state
+
       def initialize(rows, paging_state, trace_id, keyspace, statement, options, hosts, consistency, retries, client, futures_factory)
         @rows           = rows
         @paging_state   = paging_state
@@ -124,12 +147,12 @@ module Cassandra
       def next_page_async(options = nil)
         return @futures.value(nil) if @paging_state.nil?
 
-        options = options ? @options.override(options) : @options
+        options = @options.override(options, paging_state: @paging_state)
 
         if @statement.is_a?(Statements::Simple)
-          @client.query(@statement, options, @paging_state)
+          @client.query(@statement, options)
         else
-          @client.execute(@statement, options, @paging_state)
+          @client.execute(@statement, options)
         end
       end
 
@@ -201,6 +224,10 @@ module Cassandra
         nil
       end
 
+      def paging_state
+        nil
+      end
+
       def inspect
         "#<Cassandra::Result:0x#{self.object_id.to_s(16)} @rows=[] @last_page=true>"
       end

data/lib/cassandra/session.rb

@@ -53,6 +53,9 @@ module Cassandra
     # @option options [Symbol] :serial_consistency (nil) this option is only
     #   relevant for conditional updates and specifies a serial consistency to
     #   be used, one of {Cassandra::SERIAL_CONSISTENCIES}
+    # @option options [String] :paging_state (nil) this option is used for
+    #   stateless paging, where result paging is resumed some time after the
+    #   initial request.
     #
     # @see Cassandra.cluster Options that can be specified on the cluster-level
     #   and their default values.

data/lib/cassandra/version.rb

@@ -17,5 +17,5 @@
 #++
 
 module Cassandra
-  VERSION = '1.0.0'.freeze
+  VERSION = '1.1.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cassandra-driver
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Theo Hultberg
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-19 00:00:00.000000000 Z
+date: 2014-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ione
@@ -103,6 +103,7 @@ files:
 - lib/cassandra/execution/info.rb
 - lib/cassandra/execution/options.rb
 - lib/cassandra/execution/trace.rb
+- lib/cassandra/executors.rb
 - lib/cassandra/future.rb
 - lib/cassandra/host.rb
 - lib/cassandra/keyspace.rb