cassandra-driver 1.0.0.rc.1-java → 1.1.0-java

data/lib/cassandra/future.rb

@@ -161,18 +161,64 @@ module Cassandra
       end
     end
 
+    # @private
+    class Factory
+      def initialize(executor)
+        @executor = executor
+      end
+
+      def value(value)
+        Value.new(value)
+      end
+
+      def error(error)
+        Error.new(error)
+      end
+
+      def promise
+        Promise.new(@executor)
+      end
+
+      def all(*futures)
+        futures   = Array(futures.first) if futures.one?
+        monitor   = Monitor.new
+        promise   = Promise.new(@executor)
+        remaining = futures.length
+        values    = Array.new(remaining)
+
+        futures.each_with_index do |future, i|
+          future.on_complete do |v, e|
+            if e
+              promise.break(e)
+            else
+              done = false
+              monitor.synchronize do
+                remaining -= 1
+                done = (remaining == 0)
+                values[i] = v
+              end
+              promise.fulfill(values) if done
+            end
+          end
+        end
+      end
+    end
+
+    # @private
+    @@factory = Factory.new(Executors::SameThread.new)
+
     # Returns a future resolved to a given value
     # @param value [Object] value for the future
     # @return [Cassandra::Future<Object>] a future value
     def self.value(value)
-      Value.new(value)
+      @@factory.value(value)
     end
 
     # Returns a future resolved to a given error
     # @param error [Exception] error for the future
     # @return [Cassandra::Future<Exception>] a future error
     def self.error(error)
-      Error.new(error)
+      @@factory.error(error)
     end
 
     # Returns a future that resolves with values of all futures
@@ -184,35 +230,7 @@ module Cassandra
     #     combine
     #   @return [Cassandra::Future<Array<Object>>] a combined future
     def self.all(*futures)
-      futures   = Array(futures.first) if futures.one?
-      monitor   = Monitor.new
-      promise   = Promise.new
-      remaining = futures.length
-      values    = Array.new(remaining)
-
-      futures.each_with_index do |future, i|
-        future.on_complete do |v, e|
-          if e
-            promise.break(e)
-          else
-            done = false
-            monitor.synchronize do
-              remaining -= 1
-              done = (remaining == 0)
-              values[i] = v
-            end
-            promise.fulfill(values) if done
-          end
-        end
-      end
-
-      promise.future
-    end
-
-    # @private
-    # Returns a new promise instance
-    def self.promise
-      Promise.new
+      @@factory.all(*futures)
     end
 
     # @private
@@ -220,24 +238,6 @@ module Cassandra
       @signal = signal
     end
 
-    # Returns future value or raises future error
-    # @note This method blocks until a future is resolved
-    # @raise [Exception] error used to resolve this future if any
-    # @return [Object] value used to resolve this future if any
-    def get
-      @signal.get
-    end
-
-    # Block until the future has been resolved
-    # @note This method blocks until a future is resolved
-    # @note This method won't raise any errors or return anything but the
-    #   future itself
-    # @return [self]
-    def join
-      @signal.join
-      self
-    end
-
     # Run block when future resolves to a value
     # @note The block can be called synchronously from current thread if the
     #   future has already been resolved, or, asynchronously, from background
@@ -348,6 +348,25 @@ module Cassandra
       raise ::ArgumentError, "no block given" unless block_given?
       @signal.fallback(&block)
     end
+
+    # Returns future value or raises future error
+    # @note This method blocks until a future is resolved
+    # @raise [Exception] error used to resolve this future if any
+    # @return [Object] value used to resolve this future if any
+    def get
+      @signal.get
+      
+    end
+
+    # Block until the future has been resolved
+    # @note This method blocks until a future is resolved
+    # @note This method won't raise any errors or return anything but the
+    #   future itself
+    # @return [self]
+    def join
+      @signal.join
+      self
+    end
   end
 
   # @private
@@ -455,10 +474,11 @@ module Cassandra
 
       include MonitorMixin
 
-      def initialize
+      def initialize(executor)
         mon_initialize
 
         @cond      = new_cond
+        @executor  = executor
         @state     = :pending
         @waiting   = 0
         @error     = nil
@@ -484,12 +504,14 @@ module Cassandra
           listeners, @listeners = @listeners, nil
         end
 
-        listeners.each do |listener|
-          listener.failure(error) rescue nil
-        end
+        @executor.execute do
+          listeners.each do |listener|
+            listener.failure(error) rescue nil
+          end
 
-        synchronize do
-          @cond.broadcast if @waiting > 0
+          synchronize do
+            @cond.broadcast if @waiting > 0
+          end
         end
 
         self
@@ -509,12 +531,14 @@ module Cassandra
           listeners, @listeners = @listeners, nil
         end
 
-        listeners.each do |listener|
-          listener.success(value) rescue nil
-        end
+        @executor.execute do
+          listeners.each do |listener|
+            listener.success(value) rescue nil
+          end
 
-        synchronize do
-          @cond.broadcast if @waiting > 0
+          synchronize do
+            @cond.broadcast if @waiting > 0
+          end
         end
 
         self
@@ -608,7 +632,7 @@ module Cassandra
         if @state == :pending
           synchronize do
             if @state == :pending
-              promise  = Promise.new
+              promise  = Promise.new(@executor)
               listener = Listeners::Then.new(promise, &block)
               @listeners << listener
               return promise.future
@@ -631,7 +655,7 @@ module Cassandra
         if @state == :pending
           synchronize do
             if @state == :pending
-              promise  = Promise.new
+              promise  = Promise.new(@executor)
               listener = Listeners::Fallback.new(promise, &block)
               @listeners << listener
               return promise.future
@@ -653,8 +677,8 @@ module Cassandra
 
     attr_reader :future
 
-    def initialize
-      @signal = Signal.new
+    def initialize(executor)
+      @signal = Signal.new(executor)
       @future = Future.new(@signal)
     end
 

data/lib/cassandra/keyspace.rb

@@ -106,6 +106,11 @@ module Cassandra
     end
     alias :== :eql?
 
+    # @return [String] a CLI-friendly keyspace representation
+    def inspect
+      "#<#{self.class.name}:0x#{self.object_id.to_s(16)} @name=#{@name}>"
+    end
+
     # @private
     def update_table(table)
       tables = @tables.dup
@@ -113,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

@@ -60,8 +60,13 @@ module Cassandra
           datacenter              = datacenter && String(datacenter)
           max_remote_hosts_to_use = max_remote_hosts_to_use && Integer(max_remote_hosts_to_use)
 
-          raise ::ArgumentError, "datacenter cannot be empty" if datacenter && datacenter.empty?
-          raise ::ArgumentError, "max_remote_hosts_to_use must be nil or >= 0" if max_remote_hosts_to_use && max_remote_hosts_to_use < 0
+          unless datacenter.nil?
+            Util.assert_not_empty(datacenter) { "datacenter cannot be empty" }
+          end
+
+          unless max_remote_hosts_to_use.nil?
+            Util.assert(max_remote_hosts_to_use >= 0) { "max_remote_hosts_to_use must be nil or >= 0" }
+          end
 
           @datacenter = datacenter
           @max_remote = max_remote_hosts_to_use
@@ -131,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,15 +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]
-
-          unless methods.all? {|method| wrapped_policy.respond_to?(method)}
-            raise ::ArgumentError, "supplied policy must be a Cassandra::LoadBalancing::Policy, #{wrapped_policy.inspect} given"
-          end
-
-          @policy = wrapped_policy
+        # @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
+          @shuffle = !!shuffle
         end
 
         def setup(cluster)
@@ -105,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

@@ -35,12 +35,9 @@ module Cassandra
         # @param wrapped_policy [Cassandra::LoadBalancing::Policy] actual policy to filter
         # @raise [ArgumentError] if arguments are of unexpected types
         def initialize(ips, wrapped_policy)
-          raise ::ArgumentError, "ips must be enumerable" unless ips.respond_to?(:each)
-          methods = [:host_up, :host_down, :host_found, :host_lost, :distance, :plan]
-
-          unless methods.all? {|method| wrapped_policy.respond_to?(method)}
-            raise ::ArgumentError, "supplied policy must be a Cassandra::LoadBalancing::Policy, #{wrapped_policy.inspect} given"
-          end
+          Util.assert_instance_of(::Enumerable, ips) { "ips must be an Enumerable, #{ips.inspect} given" }
+          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
           @policy = wrapped_policy
@@ -52,7 +49,7 @@ module Cassandra
             when ::String
               @ips << ::IPAddr.new(ip)
             else
-              raise ::ArgumentError, "ips must contain only instance of String or IPAddr, #{ip.inspect} given"
+              raise ::ArgumentError, "each ip must be a String or IPAddr, #{ip.inspect} given"
             end
           end
         end

data/lib/cassandra/null_logger.rb

@@ -0,0 +1,35 @@
+# 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
+  # @private
+  class NullLogger
+    def close(*); end
+    def debug(*); end
+    def debug?; false end
+    def error(*); end
+    def error?; false end
+    def fatal(*); end
+    def fatal?; false end
+    def info(*); end
+    def info?; false end
+    def unknown(*); end
+    def warn(*); end
+    def warn?; false end
+  end
+end