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

data/lib/cassandra/cluster/options.rb

@@ -23,23 +23,38 @@ 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
+
+      def create_authenticator(authentication_class)
+        @auth_provider && @auth_provider.create_authenticator(authentication_class)
+      end
     end
   end
 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/column.rb

@@ -78,6 +78,11 @@ module Cassandra
       cql
     end
 
+    # @return [String] a CLI-friendly column representation
+    def inspect
+      "#<#{self.class.name}:0x#{self.object_id.to_s(16)} @name=#{@name}>"
+    end
+
     # @return [Boolean] whether this column is equal to the other
     def eql?(other)
       other.is_a?(Column) &&

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 }
 
@@ -54,11 +56,11 @@ module Cassandra
     let(:ordered_partitioner) { Cluster::Schema::Partitioners::Ordered.new }
     let(:random_partitioner)  { Cluster::Schema::Partitioners::Random.new }
 
-    let(:connector) { Cluster::Connector.new(logger, io_reactor, cluster_registry, connection_options) }
+    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,27 +71,49 @@ 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 }
     let(:connect_timeout)           { 10 }
     let(:ssl)                       { false }
-    let(:logger)                    { Client::NullLogger.new  }
+    let(:logger)                    { NullLogger.new  }
     let(:compressor)                { nil }
     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 }
     let(:consistency)               { :one }
     let(:trace)                     { false }
-    let(:page_size)                 { nil }
+    let(:page_size)                 { 10000 }
     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/errors.rb

@@ -49,28 +49,28 @@ module Cassandra
     end
 
     # Mixed into all internal driver errors.
-    module InternalError
+    class InternalError < ::RuntimeError
       include Error, HostError
     end
 
     # Raised when data decoding fails.
     class DecodingError < ::RuntimeError
-      include InternalError
+      include Error, HostError
     end
 
     # Raised when data encoding fails.
     class EncodingError < ::RuntimeError
-      include InternalError
+      include Error, HostError
     end
 
     # Raised when a connection level error occured.
     class IOError < ::IOError
-      include InternalError
+      include Error, HostError
     end
 
     # Raised when a timeout has occured.
     class TimeoutError < ::Timeout::Error
-      include InternalError
+      include Error, HostError
     end
 
     # Mixed into all request execution errors.

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,21 +52,35 @@ 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" }
 
-        raise ::ArgumentError, ":consistency must be one of #{CONSISTENCIES.inspect}, #{consistency.inspect} given" unless CONSISTENCIES.include?(consistency)
-        raise ::ArgumentError, ":serial_consistency must be one of #{SERIAL_CONSISTENCIES.inspect}, #{serial_consistency.inspect} given" if serial_consistency && !SERIAL_CONSISTENCIES.include?(serial_consistency)
+        unless serial_consistency.nil?
+          Util.assert_one_of(SERIAL_CONSISTENCIES, serial_consistency) { ":serial_consistency must be one of #{SERIAL_CONSISTENCIES.inspect}, #{serial_consistency.inspect} given" }
+        end
 
-        page_size = page_size && Integer(page_size)
-        timeout   = timeout   && Integer(timeout)
+        unless page_size.nil?
+          page_size = Integer(page_size)
+          Util.assert(page_size > 0) { ":page_size must be a positive integer, #{page_size.inspect} given" }
+        end
 
-        raise ::ArgumentError, ":page_size must be greater than 0, #{page_size.inspect} given" if page_size && page_size <= 0
-        raise ::ArgumentError, ":timeout must be greater than 0, #{timeout.inspect} given" if timeout && timeout <= 0
+        unless timeout.nil?
+          Util.assert_instance_of(::Numeric, timeout) { ":timeout must be a number of seconds, #{timeout} given" }
+          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
@@ -61,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/execution/trace.rb

@@ -108,16 +108,16 @@ module Cassandra
       private
 
       # @private
-      SELECT_SESSION = "SELECT * FROM system_traces.sessions WHERE session_id = ?"
+      SELECT_SESSION = "SELECT * FROM system_traces.sessions WHERE session_id = %s"
       # @private
-      SELECT_EVENTS  = "SELECT * FROM system_traces.events WHERE session_id = ?"
+      SELECT_EVENTS  = "SELECT * FROM system_traces.events WHERE session_id = %s"
 
       # @private
       def load
         synchronize do
           return if @loaded
 
-          data = @client.query(Statements::Simple.new(SELECT_SESSION, @id), VOID_OPTIONS).get.first
+          data = @client.query(Statements::Simple.new(SELECT_SESSION % @id), VOID_OPTIONS).get.first
           raise ::RuntimeError, "unable to load trace #{@id}" if data.nil?
 
           @coordinator = data['coordinator']
@@ -138,7 +138,7 @@ module Cassandra
 
           @events = []
 
-          @client.query(Statements::Simple.new(SELECT_EVENTS, @id), VOID_OPTIONS).get.each do |row|
+          @client.query(Statements::Simple.new(SELECT_EVENTS % @id), VOID_OPTIONS).get.each do |row|
             @events << Event.new(row['event_id'], row['activity'], row['source'], row['source_elapsed'], row['thread'])
           end
 

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