cassandra-driver 1.0.0 → 1.1.0

data/lib/cassandra/cluster/options.rb

@@ -23,24 +23,31 @@ module Cassandra
       attr_reader :credentials, :auth_provider, :compressor, :port,
                   :connect_timeout, :ssl, :connections_per_local_node,
                   :connections_per_remote_node, :heartbeat_interval,
-                  :idle_timeout
+                  :idle_timeout, :schema_refresh_delay, :schema_refresh_timeout
       attr_accessor :protocol_version
 
-      def initialize(protocol_version, credentials, auth_provider, compressor, port, connect_timeout, ssl, connections_per_local_node, connections_per_remote_node, heartbeat_interval, idle_timeout)
-        @protocol_version   = protocol_version
-        @credentials        = credentials
-        @auth_provider      = auth_provider
-        @compressor         = compressor
-        @port               = port
-        @connect_timeout    = connect_timeout
-        @ssl                = ssl
-        @heartbeat_interval = heartbeat_interval
-        @idle_timeout       = idle_timeout
+      def initialize(protocol_version, credentials, auth_provider, compressor, port, connect_timeout, ssl, connections_per_local_node, connections_per_remote_node, heartbeat_interval, idle_timeout, synchronize_schema, schema_refresh_delay, schema_refresh_timeout)
+        @protocol_version       = protocol_version
+        @credentials            = credentials
+        @auth_provider          = auth_provider
+        @compressor             = compressor
+        @port                   = port
+        @connect_timeout        = connect_timeout
+        @ssl                    = ssl
+        @heartbeat_interval     = heartbeat_interval
+        @idle_timeout           = idle_timeout
+        @synchronize_schema     = synchronize_schema
+        @schema_refresh_delay   = schema_refresh_delay
+        @schema_refresh_timeout = schema_refresh_timeout
 
         @connections_per_local_node  = connections_per_local_node
         @connections_per_remote_node = connections_per_remote_node
       end
 
+      def synchronize_schema?
+        @synchronize_schema
+      end
+
       def compression
         @compressor && @compressor.algorithm
       end

data/lib/cassandra/cluster/schema.rb

@@ -130,6 +130,9 @@ module Cassandra
 
         return self unless keyspace
 
+        columns  = columns.each_with_object(::Hash.new) do |row, index|
+          index[row['column_name']] = row
+        end
         table    = create_table(table, columns, host.release_version)
         keyspace = keyspace.update_table(table)
 
@@ -139,7 +142,25 @@ module Cassandra
           @keyspaces = keyspaces
         end
 
-        keyspace_updated(keyspace)
+        keyspace_changed(keyspace)
+
+        self
+      end
+
+      def delete_table(keyspace_name, table_name)
+        keyspace = @keyspaces[keyspace_name]
+
+        return self unless keyspace
+
+        keyspace = keyspace.delete_table(table_name)
+
+        synchronize do
+          keyspaces = @keyspaces.dup
+          keyspaces[keyspace_name] = keyspace
+          @keyspaces = keyspaces
+        end
+
+        keyspace_changed(keyspace)
 
         self
       end

data/lib/cassandra/driver.rb

@@ -20,7 +20,7 @@ module Cassandra
   # @private
   class Driver
     def self.let(name, &block)
-      define_method(name)        { @instances[name] ||= @defaults.fetch(name) { instance_eval(&block) } }
+      define_method(name)        { @instances.has_key?(name) ? @instances[name] : @instances[name] = instance_eval(&block) }
       define_method(:"#{name}=") { |object| @instances[name] = object }
     end
 
@@ -42,7 +42,9 @@ module Cassandra
                                no_replication_strategy
                               )
                            }
-    let(:futures_factory)  { Future }
+
+    let(:executor)         { Executors::ThreadPool.new(thread_pool_size) }
+    let(:futures_factory)  { Future::Factory.new(executor) }
 
     let(:schema_type_parser) { Cluster::Schema::TypeParser.new }
 
@@ -56,9 +58,9 @@ module Cassandra
 
     let(:connector) { Cluster::Connector.new(logger, io_reactor, cluster_registry, connection_options, execution_options) }
 
-    let(:control_connection) { Cluster::ControlConnection.new(logger, io_reactor, cluster_registry, cluster_schema, cluster_metadata, load_balancing_policy, reconnection_policy, address_resolution_policy, connector) }
+    let(:control_connection) { Cluster::ControlConnection.new(logger, io_reactor, cluster_registry, cluster_schema, cluster_metadata, load_balancing_policy, reconnection_policy, address_resolution_policy, connector, connection_options) }
 
-    let(:cluster) { Cluster.new(logger, io_reactor, 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) }
+    let(:cluster) { 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) }
 
     let(:execution_options) do
       Execution::Options.new({
@@ -69,7 +71,24 @@ module Cassandra
       })
     end
 
-    let(:connection_options) { Cluster::Options.new(protocol_version, credentials, auth_provider, compressor, port, connect_timeout, ssl, connections_per_local_node, connections_per_remote_node, heartbeat_interval, idle_timeout) }
+    let(:connection_options) do
+      Cluster::Options.new(
+        protocol_version,
+        credentials,
+        auth_provider,
+        compressor,
+        port,
+        connect_timeout,
+        ssl,
+        connections_per_local_node,
+        connections_per_remote_node,
+        heartbeat_interval,
+        idle_timeout,
+        synchronize_schema,
+        schema_refresh_delay,
+        schema_refresh_timeout
+      )
+    end
 
     let(:port)                      { 9042 }
     let(:protocol_version)          { 2 }
@@ -80,7 +99,7 @@ module Cassandra
     let(:credentials)               { nil }
     let(:auth_provider)             { nil }
     let(:datacenter)                { nil }
-    let(:load_balancing_policy)     { LoadBalancing::Policies::TokenAware.new(LoadBalancing::Policies::DCAwareRoundRobin.new(datacenter, 0)) }
+    let(:load_balancing_policy)     { LoadBalancing::Policies::TokenAware.new(LoadBalancing::Policies::DCAwareRoundRobin.new(datacenter, 0), shuffle_replicas) }
     let(:reconnection_policy)       { Reconnection::Policies::Exponential.new(0.5, 30, 2) }
     let(:retry_policy)              { Retry::Policies::Default.new }
     let(:address_resolution_policy) { AddressResolution::Policies::None.new }
@@ -90,6 +109,11 @@ module Cassandra
     let(:heartbeat_interval)        { 30 }
     let(:idle_timeout)              { 60 }
     let(:timeout)                   { 10 }
+    let(:synchronize_schema)        { true }
+    let(:schema_refresh_delay)      { 1 }
+    let(:schema_refresh_timeout)    { 10 }
+    let(:thread_pool_size)          { 4 }
+    let(:shuffle_replicas)          { true }
 
     let(:connections_per_local_node)  { 2 }
     let(:connections_per_remote_node) { 1 }
@@ -97,8 +121,7 @@ module Cassandra
     let(:listeners) { [] }
 
     def initialize(defaults = {})
-      @defaults  = defaults
-      @instances = {}
+      @instances = defaults
     end
 
     def connect(addresses)
@@ -113,7 +136,18 @@ module Cassandra
       addresses.each {|address| cluster_registry.host_found(address)}
 
       logger.info('Establishing control connection')
-      control_connection.connect_async.map(cluster)
+
+      promise = futures_factory.promise
+
+      control_connection.connect_async.on_complete do |f|
+        if f.resolved?
+          promise.fulfill(cluster)
+        else
+          f.on_failure {|e| promise.break(e)}
+        end
+      end
+
+      promise.future
     end
   end
 end

data/lib/cassandra/execution/options.rb

@@ -31,6 +31,20 @@ module Cassandra
       # @return [Numeric] request timeout interval
       attr_reader :timeout
 
+      # @return [String] paging state
+      #
+      # @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 Cassandra::Result#paging_state
+      attr_reader :paging_state
+
       # @private
       def initialize(options)
         consistency        = options[:consistency]
@@ -38,6 +52,7 @@ module Cassandra
         trace              = options[:trace]
         timeout            = options[:timeout]
         serial_consistency = options[:serial_consistency]
+        paging_state       = options[:paging_state]
 
         Util.assert_one_of(CONSISTENCIES, consistency) { ":consistency must be one of #{CONSISTENCIES.inspect}, #{consistency.inspect} given" }
 
@@ -46,7 +61,7 @@ module Cassandra
         end
 
         unless page_size.nil?
-          page_size = options[:page_size] = Integer(page_size)
+          page_size = Integer(page_size)
           Util.assert(page_size > 0) { ":page_size must be a positive integer, #{page_size.inspect} given" }
         end
 
@@ -55,11 +70,17 @@ module Cassandra
           Util.assert(timeout > 0) { ":timeout must be greater than 0, #{timeout} given" }
         end
 
+        unless paging_state.nil?
+          paging_state = String(paging_state)
+          Util.assert_not_empty(paging_state) { ":paging_state must not be empty" }
+        end
+
         @consistency        = consistency
         @page_size          = page_size
         @trace              = !!trace
         @timeout            = timeout
         @serial_consistency = serial_consistency
+        @paging_state       = paging_state
       end
 
       # @return [Boolean] whether request tracing was enabled
@@ -68,8 +89,14 @@ module Cassandra
       end
 
       # @private
-      def override(options)
-        Options.new(to_h.merge!(options))
+      def override(*options)
+        merged = options.unshift(to_h).inject do |base, opts|
+          next base unless opts
+          Util.assert_instance_of(::Hash, opts) { "options must be a Hash, #{options.inspect} given" }
+          base.merge!(opts)
+        end
+
+        Options.new(merged)
       end
 
       # @private

data/lib/cassandra/executors.rb

@@ -0,0 +1,111 @@
+# 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
+  module Executors
+    class ThreadPool
+      # @private
+      class Task
+        def initialize(*args, &block)
+          @args    = args
+          @block   = block
+        end
+
+        def run
+          @block.call(*@args)
+        rescue ::Exception
+        ensure
+          @args = @block = nil
+        end
+      end
+
+      include MonitorMixin
+
+      def initialize(size)
+        mon_initialize
+
+        @cond    = new_cond
+        @tasks   = ::Array.new
+        @waiting = 0
+        @pool    = ::Array.new(size, &method(:spawn_thread))
+        @term    = false
+      end
+
+      def execute(*args, &block)
+        synchronize do
+          @tasks << Task.new(*args, &block)
+          @cond.signal if @waiting > 0
+        end
+
+        nil
+      end
+
+      def shutdown
+        execute do
+          synchronize do
+            @term = true
+            @cond.broadcast if @waiting > 0
+          end
+        end
+
+        nil
+      end
+
+      private
+
+      def spawn_thread(i)
+        Thread.new(&method(:run))
+      end
+
+      def run
+        Thread.current.abort_on_exception = true
+
+        loop do
+          tasks = nil
+
+          synchronize do
+            @waiting += 1
+            @cond.wait while !@term && @tasks.empty?
+            @waiting -= 1
+
+            return if @tasks.empty?
+
+            tasks  = @tasks
+            @tasks = ::Array.new
+          end
+
+          tasks.each(&:run).clear
+        end
+      end
+    end
+
+    class SameThread
+      def execute(*args, &block)
+        yield(*args)
+        nil
+      rescue ::Exception
+        nil
+      end
+
+      def shutdown
+        nil
+      end
+    end
+  end
+end

data/lib/cassandra/future.rb

@@ -48,8 +48,6 @@ module Cassandra
       def initialize(error)
         raise ::ArgumentError, "error must be an exception, #{error.inspect} given" unless error.is_a?(::Exception)
 
-        error.set_backtrace(caller) unless error.backtrace
-
         @error = error
       end
 
@@ -163,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
@@ -186,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
@@ -222,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
@@ -350,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
@@ -457,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
@@ -473,8 +491,6 @@ module Cassandra
           raise ::ArgumentError, "error must be an exception, #{error.inspect} given"
         end
 
-        error.set_backtrace(caller) unless error.backtrace
-
         return unless @state == :pending
 
         listeners = nil
@@ -488,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
@@ -513,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
@@ -612,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
@@ -635,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
@@ -657,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