cql-rb 1.1.0.pre0 → 1.1.0.pre1

data/lib/cql/byte_buffer.rb

@@ -1,6 +1,7 @@
 # encoding: utf-8
 
 module Cql
+  # @private
   class ByteBuffer
     def initialize(initial_bytes='')
       @read_buffer = ''

data/lib/cql/client.rb

@@ -46,11 +46,25 @@ module Cql
   module Client
     InvalidKeyspaceNameError = Class.new(ClientError)
 
-    # Create a new client and connects to Cassandra.
+    # Create a new client and connect to Cassandra.
     #
+    # By default the client will connect to localhost port 9042, which can be
+    # overridden with the `:hosts` and `:port` options, respectively. Once
+    # connected to the hosts given in `:hosts` the rest of the nodes in the
+    # cluster will automatically be discovered and connected to.
+    #
+    # The connection will succeed if at least one node is up. Nodes that don't
+    # respond within the specified timeout, or where the connection initialization
+    # fails for some reason, are ignored.
+    #
+    # @raise Cql::Io::ConnectionError when a connection couldn't be established
+    #   to any node
     # @param [Hash] options
-    # @option options [String] :host ('localhost') One or more (comma separated)
-    #   hostnames for the Cassandra nodes you want to connect to.
+    # @option options [Array<String>] :hosts (['localhost']) One or more
+    #   hostnames used as seed nodes when connecting. Duplicates will be removed.
+    # @option options [String] :host ('localhost') A comma separated list of 
+    #   hostnames to use as seed nodes. This is a backwards-compatible version
+    #   of the :hosts option, and is deprecated.
     # @option options [String] :port (9042) The port to connect to
     # @option options [Integer] :connection_timeout (5) Max time to wait for a
     #   connection, in seconds
@@ -70,9 +84,7 @@ module Cql
       # You must call this method before you call any of the other methods of a
       # client. Calling it again will have no effect.
       #
-      # If `:keyspace` was specified when the client was created the current
-      # keyspace will also be changed (otherwise the current keyspace will not
-      # be set).
+      # @see Cql::Client.connect
       #
       # @return [Cql::Client]
 
@@ -156,8 +168,8 @@ end
 require 'cql/client/column_metadata'
 require 'cql/client/result_metadata'
 require 'cql/client/query_result'
+require 'cql/client/asynchronous_client'
 require 'cql/client/asynchronous_prepared_statement'
-require 'cql/client/synchronous_prepared_statement'
 require 'cql/client/synchronous_client'
-require 'cql/client/asynchronous_client'
+require 'cql/client/synchronous_prepared_statement'
 require 'cql/client/request_runner'

data/lib/cql/client/asynchronous_client.rb

@@ -6,7 +6,7 @@ module Cql
     class AsynchronousClient < Client
       def initialize(options={})
         @connection_timeout = options[:connection_timeout] || 10
-        @host = options[:host] || 'localhost'
+        @hosts = extract_hosts(options)
         @port = options[:port] || 9042
         @io_reactor = options[:io_reactor] || Io::IoReactor.new(Protocol::CqlProtocolHandler)
         @lock = Mutex.new
@@ -23,6 +23,7 @@ module Cql
           return @connected_future if can_execute?
           @connecting = true
           @connected_future = Future.new
+          @connections = []
         end
         when_not_closing do
           setup_connections
@@ -79,35 +80,30 @@ module Cql
       end
 
       def use(keyspace)
-        return Future.failed(NotConnectedError.new) unless can_execute?
-        return Future.failed(InvalidKeyspaceNameError.new(%("#{keyspace}" is not a valid keyspace name))) unless valid_keyspace_name?(keyspace)
-        connections = @lock.synchronize do
-          @connections.select { |c| c.keyspace != keyspace }
-        end
-        if connections.any?
-          futures = connections.map do |connection|
-            execute_request(Protocol::QueryRequest.new("USE #{keyspace}", :one), connection)
+        with_failure_handler do
+          connections = @lock.synchronize do
+            @connections.select { |c| c.keyspace != keyspace }
+          end
+          if connections.any?
+            futures = connections.map { |connection| use_keyspace(keyspace, connection) }
+            Future.combine(*futures).map { nil }
+          else
+            Future.completed(nil)
           end
-          futures.compact!
-          Future.combine(*futures).map { nil }
-        else
-          Future.completed(nil)
         end
       end
 
       def execute(cql, consistency=nil)
-        consistency ||= DEFAULT_CONSISTENCY_LEVEL
-        return Future.failed(NotConnectedError.new) unless can_execute?
-        execute_request(Protocol::QueryRequest.new(cql, consistency))
-      rescue => e
-        Future.failed(e)
+        with_failure_handler do
+          consistency ||= DEFAULT_CONSISTENCY_LEVEL
+          execute_request(Protocol::QueryRequest.new(cql, consistency))
+        end
       end
 
       def prepare(cql)
-        return Future.failed(NotConnectedError.new) unless can_execute?
-        execute_request(Protocol::PrepareRequest.new(cql))
-      rescue => e
-        Future.failed(e)
+        with_failure_handler do
+          execute_request(Protocol::PrepareRequest.new(cql))
+        end
       end
 
       private
@@ -115,6 +111,28 @@ module Cql
       KEYSPACE_NAME_PATTERN = /^\w[\w\d_]*$/
       DEFAULT_CONSISTENCY_LEVEL = :quorum
 
+      class FailedConnection
+        attr_reader :error
+
+        def initialize(error)
+          @error = error
+        end
+
+        def connected?
+          false
+        end
+      end
+
+      def extract_hosts(options)
+        if options[:hosts]
+          options[:hosts].uniq
+        elsif options[:host]
+          options[:host].split(',').uniq
+        else
+          %w[localhost]
+        end
+      end
+
       def can_execute?
         @connected || @connecting
       end
@@ -123,6 +141,13 @@ module Cql
         name =~ KEYSPACE_NAME_PATTERN
       end
 
+      def with_failure_handler
+        return Future.failed(NotConnectedError.new) unless can_execute?
+        yield
+      rescue => e
+        Future.failed(e)
+      end
+
       def when_not_connecting(&callback)
         if @connecting
           @connected_future.on_complete(&callback)
@@ -141,43 +166,103 @@ module Cql
         end
       end
 
+      def discover_peers(seed_connections, initial_keyspace)
+        connected_seeds = seed_connections.select(&:connected?)
+        connection = connected_seeds.sample
+        return Future.completed([]) unless connection
+        request = Protocol::QueryRequest.new('SELECT data_center, host_id, rpc_address FROM system.peers', :one)
+        peer_info = execute_request(request, connection)
+        peer_info.flat_map do |result|
+          seed_dcs = connected_seeds.map { |c| c[:data_center] }.uniq
+          unconnected_peers = result.select do |row|
+            seed_dcs.include?(row['data_center']) && connected_seeds.none? { |c| c[:host_id] == row['host_id'] }
+          end
+          node_addresses = unconnected_peers.map { |row| row['rpc_address'].to_s }
+          if node_addresses.any?
+            connect_to_hosts(node_addresses, initial_keyspace, false)
+          else
+            Future.completed([])
+          end
+        end
+      end
+
       def setup_connections
-        hosts_connected_future = @io_reactor.start.flat_map do
-          hosts = @host.split(',')
-          connection_futures = hosts.map { |host| connect_to_host(host) }
-          Future.combine(*connection_futures)
+        f = @io_reactor.start.flat_map do
+          connect_to_hosts(@hosts, @initial_keyspace, true)
         end
-        hosts_connected_future.on_complete do |connections|
-          @connections = connections
+        f.on_failure do |e|
+          fail_connecting(e)
         end
-        if @initial_keyspace
-          initialized_future = hosts_connected_future.flat_map do |*args|
-            use(@initial_keyspace)
+        f.on_complete do |connections|
+          connected_connections = connections.select(&:connected?)
+          if connected_connections.any?
+            @connections = connected_connections
+            @connected_future.complete!(self)
+          else
+            fail_connecting(connections.first.error)
           end
+        end
+      end
+
+      def fail_connecting(e)
+        close
+        if e.is_a?(Cql::QueryError) && e.code == 0x100
+          @connected_future.fail!(AuthenticationError.new(e.message))
         else
-          initialized_future = hosts_connected_future
+          @connected_future.fail!(e)
         end
-        initialized_future.on_failure do |e|
-          close
-          if e.is_a?(Cql::QueryError) && e.code == 0x100
-            @connected_future.fail!(AuthenticationError.new(e.message))
-          else
-            @connected_future.fail!(e)
+      end
+
+      def connect_to_hosts(hosts, initial_keyspace, peer_discovery)
+        connection_futures = hosts.map do |host|
+          connect_to_host(host, initial_keyspace).recover do |error|
+            FailedConnection.new(error)
           end
         end
-        initialized_future.on_complete do
-          @connected_future.complete!(self)
+        hosts_connected_future = Future.combine(*connection_futures)
+        if peer_discovery
+          hosts_connected_future.flat_map do |connections|
+            discover_peers(connections, initial_keyspace).map do |peer_connections|
+              connections + peer_connections
+            end
+          end
+        else
+          hosts_connected_future
         end
       end
 
-      def connect_to_host(host)
+      def connect_to_host(host, keyspace)
         connected = @io_reactor.connect(host, @port, @connection_timeout)
         connected.flat_map do |connection|
-          started = execute_request(Protocol::StartupRequest.new, connection)
-          started.flat_map { |response| maybe_authenticate(response, connection) }
+          initialize_connection(connection, keyspace)
         end
       end
 
+      def initialize_connection(connection, keyspace)
+        started = execute_request(Protocol::StartupRequest.new, connection)
+        authenticated = started.flat_map { |response| maybe_authenticate(response, connection) }
+        identified = authenticated.flat_map { identify_node(connection) }
+        identified.flat_map { use_keyspace(keyspace, connection) }
+      end
+
+      def identify_node(connection)
+        request = Protocol::QueryRequest.new('SELECT data_center, host_id FROM system.local', :one)
+        f = execute_request(request, connection)
+        f.on_complete do |result|
+          unless result.empty?
+            connection[:host_id] = result.first['host_id']
+            connection[:data_center] = result.first['data_center']
+          end
+        end
+        f
+      end
+
+      def use_keyspace(keyspace, connection)
+        return Future.completed(connection) unless keyspace
+        return Future.failed(InvalidKeyspaceNameError.new(%("#{keyspace}" is not a valid keyspace name))) unless valid_keyspace_name?(keyspace)
+        execute_request(Protocol::QueryRequest.new("USE #{keyspace}", :one), connection).map { connection }
+      end
+
       def maybe_authenticate(response, connection)
         case response
         when AuthenticationRequired

data/lib/cql/client/synchronous_client.rb

@@ -2,19 +2,39 @@
 
 module Cql
   module Client
+    # @private
+    module SynchronousBacktrace
+      def synchronous_backtrace
+        yield
+      rescue CqlError => e
+        new_backtrace = caller
+        if new_backtrace.first.include?(SYNCHRONOUS_BACKTRACE_METHOD_NAME)
+          new_backtrace = new_backtrace.drop(1)
+        end
+        e.set_backtrace(new_backtrace)
+        raise
+      end
+
+      private
+
+      SYNCHRONOUS_BACKTRACE_METHOD_NAME = 'synchronous_backtrace'
+    end
+
     # @private
     class SynchronousClient < Client
+      include SynchronousBacktrace
+
       def initialize(async_client)
         @async_client = async_client
       end
 
       def connect
-        @async_client.connect.get
+        synchronous_backtrace { @async_client.connect.get }
         self
       end
 
       def close
-        @async_client.close.get
+        synchronous_backtrace { @async_client.close.get }
         self
       end
 
@@ -27,15 +47,15 @@ module Cql
       end
 
       def use(keyspace)
-        @async_client.use(keyspace).get
+        synchronous_backtrace { @async_client.use(keyspace).get }
       end
 
       def execute(cql, consistency=nil)
-        @async_client.execute(cql, consistency).get
+        synchronous_backtrace { @async_client.execute(cql, consistency).get }
       end
 
       def prepare(cql)
-        async_statement = @async_client.prepare(cql).get
+        async_statement = synchronous_backtrace { @async_client.prepare(cql).get }
         SynchronousPreparedStatement.new(async_statement)
       end
 

data/lib/cql/client/synchronous_prepared_statement.rb

@@ -4,19 +4,21 @@ module Cql
   module Client
     # @private
     class SynchronousPreparedStatement < PreparedStatement
+      include SynchronousBacktrace
+
       def initialize(async_statement)
         @async_statement = async_statement
         @metadata = async_statement.metadata
       end
 
       def execute(*args)
-        @async_statement.execute(*args).get
+        synchronous_backtrace { @async_statement.execute(*args).get }
       end
 
       def pipeline
         pl = Pipeline.new(@async_statement)
         yield pl
-        pl.get
+        synchronous_backtrace { pl.get }
       end
 
       def async

data/lib/cql/future.rb

@@ -8,6 +8,8 @@ module Cql
 
   # A future represents the value of a process that may not yet have completed.
   #
+  # @private
+  #
   class Future
     def initialize
       @complete_listeners = []
@@ -33,6 +35,26 @@ module Cql
       end
     end
 
+    # Returns a future which will complete with the value of the first
+    # (successful) of the specified futures. If all of the futures fail, the
+    # returned future will also fail (with the error of the last failed future).
+    #
+    # @param [Array<Future>] futures the futures to monitor
+    # @return [Future] a future which represents the first completing future
+    #
+    def self.first(*futures)
+      ff = Future.new
+      futures.each do |f|
+        f.on_complete do |value|
+          ff.complete!(value) unless ff.complete?
+        end
+        f.on_failure do |e|
+          ff.fail!(e) if futures.all?(&:failed?)
+        end
+      end
+      ff
+    end
+
     # Creates a new future which is completed.
     #
     # @param [Object, nil] value the value of the created future
@@ -197,6 +219,81 @@ module Cql
       end
       fp
     end
+
+    # Returns a new future which represents either the value of the original
+    # future, or the result of the given block, if the original future fails.
+    #
+    # This method is similar to{#map}, but is triggered by a failure. You can
+    # also think of it as a `rescue` block for asynchronous operations.
+    #
+    # If the block raises an error a failed future with that error will be
+    # returned (this can be used to transform an error into another error,
+    # instead of tranforming an error into a value).
+    #
+    # @example
+    #   future2 = future1.recover { |error| 'foo' }
+    #   future1.fail!(error)
+    #   future2.get # => 'foo'
+    #
+    # @yieldparam [Object] error the error from the original future
+    # @yieldreturn [Object] the value of the new future
+    # @return [Future] a new future representing a value recovered from the error
+    #
+    def recover(&block)
+      fp = Future.new
+      on_failure do |e|
+        begin
+          vv = block.call(e)
+          fp.complete!(vv)
+        rescue => e
+          fp.fail!(e)
+        end
+      end
+      on_complete do |v|
+        fp.complete!(v)
+      end
+      fp
+    end
+
+    # Returns a new future which represents either the value of the original
+    # future, or the value of the future returned by the given block.
+    #
+    # This is like {#recover} but for cases when the handling of an error is
+    # itself asynchronous.
+    #
+    # If the block raises an error a failed future with that error will be
+    # returned (this can be used to transform an error into another error,
+    # instead of tranforming an error into a value).
+    #
+    # @example
+    #   future2 = future1.fallback { |error| perform_async_operation }
+    #   future1.fail!(error)
+    #   future2.get # => whatever the async operation resolved to
+    #
+    # @yieldparam [Object] error the error from the original future
+    # @yieldreturn [Object] the value of the new future
+    # @return [Future] a new future representing a value recovered from the error
+    #
+    def fallback(&block)
+      fp = Future.new
+      on_failure do |e|
+        begin
+          fpp = block.call(e)
+          fpp.on_failure do |e|
+            fp.fail!(e)
+          end
+          fpp.on_complete do |vv|
+            fp.complete!(vv)
+          end
+        rescue => e
+          fp.fail!(e)
+        end
+      end
+      on_complete do |v|
+        fp.complete!(v)
+      end
+      fp
+    end
   end
 
   # @private