cassandra-driver 1.0.0.beta.1 → 1.0.0.beta.2

data/lib/cassandra/auth.rb

@@ -46,7 +46,7 @@ module Cassandra
       # @param authentication_class [String] the authentication class used by
       #   the server.
       # @return [Cassandra::Auth::Authenticator, nil] an object with an
-      #   interface matching {Cassandra::Auth::Authenticator} or nil if the
+      #   interface matching {Cassandra::Auth::Authenticator} or `nil` if the
       #   authentication class is not supported.
     end
 
@@ -55,12 +55,12 @@ module Cassandra
     # block. If any of the method calls block, the whole connection process
     # will be blocked.
     #
-    # @note Authenticators created by auth providers don't need to be subclasses
-    #   of this class, but need to implement the same methods. This class exists
-    #   only for documentation purposes.
+    # @abstract Authenticators created by auth providers don't need to be
+    #   subclasses of this class, but need to implement the same methods. This
+    #   class exists only for documentation purposes.
     #
     # @see https://github.com/apache/cassandra/blob/trunk/doc/native_protocol_v2.spec#L257-L273 Cassandra native protocol v2 SASL authentication
-    # @see Cassandra::Auth::Provider
+    # @see Cassandra::Auth::Provider#create_authenticator
     class Authenticator
       # @!method initial_response
       #

data/lib/cassandra/client/connector.rb

@@ -88,16 +88,16 @@ module Cassandra
 
     # @private
     class ConnectStep
-      def initialize(io_reactor, protocol_handler_factory, port, connection_timeout, logger)
+      def initialize(io_reactor, protocol_handler_factory, port, connection_options, logger)
         @io_reactor = io_reactor
         @protocol_handler_factory = protocol_handler_factory
         @port = port
-        @connection_timeout = connection_timeout
+        @connection_options = connection_options
         @logger = logger
       end
 
       def run(pending_connection)
-        @io_reactor.connect(pending_connection.host, @port, @connection_timeout, &@protocol_handler_factory).map do |connection|
+        @io_reactor.connect(pending_connection.host, @port, @connection_options, &@protocol_handler_factory).map do |connection|
           pending_connection.with_connection(connection)
         end
       end
@@ -105,12 +105,17 @@ module Cassandra
 
     # @private
     class CacheOptionsStep
+      def initialize(timeout = nil)
+        @timeout = timeout
+      end
+
       def run(pending_connection)
-        f = pending_connection.execute(Protocol::OptionsRequest.new)
+        f = pending_connection.execute(Protocol::OptionsRequest.new, @timeout)
         f.on_value do |supported_options|
           pending_connection[:cql_version] = supported_options['CQL_VERSION']
           pending_connection[:compression] = supported_options['COMPRESSION']
         end
+
         f.map(pending_connection)
       end
     end
@@ -250,8 +255,8 @@ module Cassandra
         @connection[key] = value
       end
 
-      def execute(request, &block)
-        @request_runner.execute(@connection, request, nil, nil, &block)
+      def execute(request, timeout = nil, &block)
+        @request_runner.execute(@connection, request, timeout, nil, &block)
       end
     end
 

data/lib/cassandra/cluster.rb

@@ -26,15 +26,6 @@ module Cassandra
   class Cluster
     extend Forwardable
 
-    # @!method each_host
-    #   Yield or enumerate each member of this cluster
-    #   @overload each_host
-    #     @yieldparam host [Cassandra::Host] current host
-    #     @return [Array<Cassandra::Host>] a list of hosts
-    #   @overload each_host
-    #     @return [Enumerator<Cassandra::Host>] an enumerator
-    # @!parse alias :hosts :each_host
-    #
     # @!method host(address)
     #   Find a host by its address
     #   @param address [IPAddr, String] ip address
@@ -44,17 +35,8 @@ module Cassandra
     #   Determine if a host by a given address exists
     #   @param address [IPAddr, String] ip address
     #   @return [Boolean] true or false
-    def_delegators :@registry, :hosts, :each_host, :host, :has_host?
-
-    # @!method each_keyspace
-    #   Yield or enumerate each keyspace defined in this cluster
-    #   @overload each_keyspace
-    #     @yieldparam keyspace [Cassandra::Keyspace] current keyspace
-    #     @return [Array<Cassandra::Keyspace>] a list of keyspaces
-    #   @overload each_keyspace
-    #     @return [Enumerator<Cassandra::Keyspace>] an enumerator
-    # @!parse alias :keyspaces :each_keyspace
-    #
+    def_delegators :@registry, :host, :has_host?
+
     # @!method keyspace(name)
     #   Find a keyspace by name
     #   @param name [String] keyspace name
@@ -64,15 +46,30 @@ module Cassandra
     #   Determine if a keyspace by a given name exists
     #   @param name [String] keyspace name
     #   @return [Boolean] true or false
-    def_delegators :@schema, :keyspaces, :each_keyspace, :keyspace, :has_keyspace?
+    def_delegators :@schema, :keyspace, :has_keyspace?
+
+    # @!method name
+    #   Return cluster's name
+    #   @return [String] cluster's name
+    #
+    # @!method find_replicas(keyspace, statement)
+    #   Return replicas for a given statement and keyspace
+    #   @note an empty list is returned when statement/keyspace information is
+    #     not enough to determine replica list.
+    #   @param keyspace [String] keyspace name
+    #   @param statement [Cassandra::Statement] statement for which to find
+    #     replicas
+    #   @return [Array<Cassandra::Host>] a list of replicas
+    def_delegators :@metadata, :name, :find_replicas
 
     # @private
-    def initialize(logger, io_reactor, control_connection, cluster_registry, cluster_schema, execution_options, connection_options, load_balancing_policy, reconnection_policy, retry_policy, connector, futures_factory)
+    def initialize(logger, io_reactor, control_connection, cluster_registry, cluster_schema, cluster_metadata, execution_options, connection_options, load_balancing_policy, reconnection_policy, retry_policy, connector, futures_factory)
       @logger                = logger
       @io_reactor            = io_reactor
       @control_connection    = control_connection
       @registry              = cluster_registry
       @schema                = cluster_schema
+      @metadata              = cluster_metadata
       @execution_options     = execution_options
       @connection_options    = connection_options
       @load_balancing_policy = load_balancing_policy
@@ -104,6 +101,32 @@ module Cassandra
       self
     end
 
+    # Yield or enumerate each member of this cluster
+    # @overload each_host
+    #   @yieldparam host [Cassandra::Host] current host
+    #   @return [Cassandra::Cluster] self
+    # @overload each_host
+    #   @return [Array<Cassandra::Host>] a list of hosts
+    def each_host(&block)
+      r = @registry.each_host(&block)
+      return self if r == @registry
+      r
+    end
+    alias :hosts :each_host
+
+    # Yield or enumerate each keyspace defined in this cluster
+    # @overload each_keyspace
+    #   @yieldparam keyspace [Cassandra::Keyspace] current keyspace
+    #   @return [Cassandra::Cluster] self
+    # @overload each_keyspace
+    #   @return [Array<Cassandra::Keyspace>] a list of keyspaces
+    def each_keyspace(&block)
+      r = @schema.each_keyspace(&block)
+      return self if r == @schema
+      r
+    end
+    alias :keyspaces :each_keyspace
+
     # Asynchronously create a new session, optionally scoped to a keyspace
     #
     # @param keyspace [String] optional keyspace to scope session to
@@ -115,7 +138,7 @@ module Cassandra
         return @futures.error(::ArgumentError.new("keyspace must be a string, #{keyspace.inspect} given"))
       end
 
-      client  = Client.new(@logger, @registry, @io_reactor, @connector, @load_balancing_policy, @reconnection_policy, @retry_policy, @connection_options, @futures)
+      client  = Client.new(@logger, @registry, @schema, @io_reactor, @connector, @load_balancing_policy, @reconnection_policy, @retry_policy, @connection_options, @futures)
       session = Session.new(client, @execution_options, @futures)
       promise = @futures.promise
 
@@ -186,6 +209,7 @@ end
 require 'cassandra/cluster/client'
 require 'cassandra/cluster/connector'
 require 'cassandra/cluster/control_connection'
+require 'cassandra/cluster/metadata'
 require 'cassandra/cluster/options'
 require 'cassandra/cluster/registry'
 require 'cassandra/cluster/schema'

data/lib/cassandra/cluster/client.rb

@@ -22,9 +22,12 @@ module Cassandra
     class Client
       include MonitorMixin
 
-      def initialize(logger, cluster_registry, io_reactor, connector, load_balancing_policy, reconnection_policy, retry_policy, connection_options, futures_factory)
+      attr_reader :keyspace
+
+      def initialize(logger, cluster_registry, cluster_schema, io_reactor, connector, load_balancing_policy, reconnection_policy, retry_policy, connection_options, futures_factory)
         @logger                      = logger
         @registry                    = cluster_registry
+        @schema                      = cluster_schema
         @reactor                     = io_reactor
         @connector                   = connector
         @load_balancing_policy       = load_balancing_policy
@@ -597,9 +600,7 @@ module Cassandra
                 @preparing_statements[host].delete(cql)
               end
 
-              execution_info = create_execution_info(keyspace, statement, options, request, r, hosts)
-
-              promise.fulfill(Statements::Prepared.new(cql, r.metadata, r.result_metadata, execution_info))
+              promise.fulfill(Statements::Prepared.new(cql, r.metadata, r.result_metadata, r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures, @schema))
             when Protocol::RawRowsResultResponse
               r.materialize(statement.result_metadata)
               promise.fulfill(Results::Paged.new(r.rows, r.paging_state, r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))

data/lib/cassandra/cluster/connector.rb

@@ -69,7 +69,11 @@ module Cassandra
       end
 
       def refresh_status(host)
-        return Future.resolved if synchronize { @connections[host] }
+        if synchronize { @connections[host] }
+          @registry.host_up(host.ip)
+
+          return Future.resolved
+        end
 
         @logger.info("Refreshing host status ip=#{host.ip}")
         f = do_connect(host)
@@ -130,11 +134,20 @@ module Cassandra
 
       def create_connector
         authentication_step = @options.protocol_version == 1 ? Cassandra::Client::CredentialsAuthenticationStep.new(@options.credentials) : Cassandra::Client::SaslAuthenticationStep.new(@options.auth_provider)
-        protocol_handler_factory = lambda { |connection| Protocol::CqlProtocolHandler.new(connection, @reactor, @options.protocol_version, @options.compressor) }
+        protocol_handler_factory = lambda do |connection|
+          raise "no connection given" unless connection
+          Protocol::CqlProtocolHandler.new(connection, @reactor, @options.protocol_version, @options.compressor)
+        end
 
         Cassandra::Client::Connector.new([
-          Cassandra::Client::ConnectStep.new(@reactor, protocol_handler_factory, @options.port, @options.connection_timeout, @logger),
-          Cassandra::Client::CacheOptionsStep.new,
+          Cassandra::Client::ConnectStep.new(
+            @reactor,
+            protocol_handler_factory,
+            @options.port,
+            {:timeout => @options.connect_timeout, :ssl => @options.ssl},
+            @logger
+          ),
+          Cassandra::Client::CacheOptionsStep.new(@options.connect_timeout),
           Cassandra::Client::InitializeStep.new(@options.compressor, @logger),
           authentication_step,
           Cassandra::Client::CachePropertiesStep.new,

data/lib/cassandra/cluster/control_connection.rb

@@ -22,11 +22,12 @@ module Cassandra
     class ControlConnection
       include MonitorMixin
 
-      def initialize(logger, io_reactor, cluster_registry, cluster_schema, load_balancing_policy, reconnection_policy, connector)
+      def initialize(logger, io_reactor, cluster_registry, cluster_schema, cluster_metadata, load_balancing_policy, reconnection_policy, connector)
         @logger                = logger
         @io_reactor            = io_reactor
         @registry              = cluster_registry
         @schema                = cluster_schema
+        @metadata              = cluster_metadata
         @load_balancing_policy = load_balancing_policy
         @reconnection_policy   = reconnection_policy
         @connector             = connector
@@ -96,8 +97,8 @@ module Cassandra
 
       private
 
-      SELECT_LOCAL     = Protocol::QueryRequest.new('SELECT rack, data_center, host_id, release_version FROM system.local', nil, nil, :one)
-      SELECT_PEERS     = Protocol::QueryRequest.new('SELECT peer, rack, data_center, host_id, rpc_address, release_version FROM system.peers', nil, nil, :one)
+      SELECT_LOCAL     = Protocol::QueryRequest.new('SELECT rack, data_center, host_id, release_version, tokens, partitioner FROM system.local', nil, nil, :one)
+      SELECT_PEERS     = Protocol::QueryRequest.new('SELECT peer, rack, data_center, host_id, rpc_address, release_version, tokens FROM system.peers', nil, nil, :one)
       SELECT_KEYSPACES = Protocol::QueryRequest.new('SELECT * FROM system.schema_keyspaces', nil, nil, :one)
       SELECT_TABLES    = Protocol::QueryRequest.new('SELECT * FROM system.schema_columnfamilies', nil, nil, :one)
       SELECT_COLUMNS   = Protocol::QueryRequest.new('SELECT * FROM system.schema_columns', nil, nil, :one)
@@ -178,9 +179,13 @@ module Cassandra
               when 'NEW_NODE'
                 address = event.address
 
-                refresh_host_async(address) unless @registry.has_host?(address)
+                unless @registry.has_host?(address)
+                  refresh_host_async(address)
+                  refresh_schema_async
+                end
               when 'REMOVED_NODE'
                 @registry.host_lost(event.address)
+                refresh_schema_async
               end
             end
           end
@@ -206,6 +211,7 @@ module Cassandra
           host = @registry.host(connection.host)
 
           @schema.update_keyspaces(host, keyspaces.rows, tables.rows, columns.rows)
+          @metadata.rebuild_token_map
         end
       end
 
@@ -268,32 +274,31 @@ module Cassandra
 
           raise NO_HOSTS if local.empty? && peers.empty?
 
-          local_ip = connection.host
-          ips      = ::Set.new
-
-          unless local.empty?
-            ips << local_ip
-            @registry.host_found(IPAddr.new(local_ip), local.first)
-          end
+          ips = ::Set.new
 
           peers.each do |data|
-            ip = peer_ip(data)
-            ips << ip.to_s
+            ips << ip = peer_ip(data)
             @registry.host_found(ip, data)
           end
 
+          ips << ip = IPAddr.new(connection.host)
+          data = local.first
+          @registry.host_found(ip, data)
+
           futures = []
 
           @registry.each_host do |host|
-            if ips.include?(host.ip.to_s)
+            if ips.include?(host.ip)
               futures << refresh_host_status(host) if host.down?
             else
               @registry.host_lost(host.ip)
             end
           end
 
+          @metadata.update(data)
+
           if futures.empty?
-            Ione::Future.resolved(self)
+            Ione::Future.resolved
           else
             Ione::Future.all(*futures)
           end
@@ -332,7 +337,7 @@ module Cassandra
         if ip == connection.host
           request = SELECT_LOCAL
         else
-          request = Protocol::QueryRequest.new('SELECT rack, data_center, host_id, rpc_address, release_version FROM system.peers WHERE peer = ?', [address], nil, :one)
+          request = Protocol::QueryRequest.new('SELECT rack, data_center, host_id, rpc_address, release_version, tokens FROM system.peers WHERE peer = ?', [address], nil, :one)
         end
 
         connection.send_request(request).map do |response|

data/lib/cassandra/cluster/metadata.rb

@@ -0,0 +1,124 @@
+# 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 Cluster
+    # @private
+    class Metadata
+      include MonitorMixin
+
+      attr_reader :name
+
+      def initialize(cluster_registry, cluster_schema, schema_partitioners, replication_strategies, default_replication_strategy)
+        @registry         = cluster_registry
+        @schema           = cluster_schema
+        @partitioners     = schema_partitioners
+        @strategies       = replication_strategies
+        @default_strategy = default_replication_strategy
+      end
+
+      def find_replicas(keyspace, statement)
+        unless statement.respond_to?(:partition_key) && statement.respond_to?(:keyspace)
+          return EMPTY_LIST
+        end
+
+        keyspace      = String(statement.keyspace || keyspace)
+        partition_key = statement.partition_key
+        return EMPTY_LIST unless keyspace && partition_key
+
+        partitioner = @partitioner
+        return EMPTY_LIST unless partitioner
+
+        keyspace_hosts = @token_replicas[keyspace]
+        return EMPTY_LIST if keyspace_hosts.nil? || keyspace_hosts.empty?
+
+        token = partitioner.create_token(partition_key)
+        index = insertion_point(@token_ring, token)
+        index = 0 if index >= @token_ring.size
+        hosts = keyspace_hosts[@token_ring[index]]
+        return EMPTY_LIST unless hosts
+
+        hosts
+      end
+
+      def update(data)
+        @name        = data['name']
+        @partitioner = @partitioners[data['partitioner']]
+
+        self
+      end
+
+      def rebuild_token_map
+        partitioner = @partitioner
+        return self unless partitioner
+
+        tokens        = ::SortedSet.new
+        token_to_host = ::Hash.new
+
+        @registry.each_host do |host|
+          host.tokens.each do |token|
+            token = partitioner.parse_token(token) rescue next
+            tokens.add(token)
+            token_to_host[token] = host
+          end
+        end
+
+        token_ring     = tokens.to_a
+        token_replicas = ::Hash.new
+
+        @schema.each_keyspace do |keyspace|
+          replication = keyspace.replication
+          strategy    = @strategies[replication.klass] || @default_strategy
+
+          token_replicas[keyspace.name] = strategy.replication_map(
+            token_to_host,
+            token_ring,
+            replication.options
+          )
+        end
+
+        @token_replicas = token_replicas
+        @token_ring     = token_ring
+
+        self
+      end
+
+      private
+
+      def insertion_point(list, item)
+        min = 0
+        max = list.size - 1
+
+        while min <= max do
+          idx = (min + max) / 2
+          val = list[idx]
+
+          if val < item
+            min = idx + 1
+          elsif val > item
+            max = idx - 1
+          else
+            return idx # item found
+          end
+        end
+
+        min # item not found.
+      end
+    end
+  end
+end