cql-rb 1.1.0.pre3 → 1.1.0.pre6

data/lib/cql/client/connection_helper.rb

@@ -0,0 +1,155 @@
+# encoding: utf-8
+
+module Cql
+  module Client
+    # @private
+    class ConnectionHelper
+      def initialize(io_reactor, port, credentials, connection_timeout, logger)
+        @io_reactor = io_reactor
+        @port = port
+        @credentials = credentials
+        @connection_timeout = connection_timeout
+        @logger = logger
+        @request_runner = RequestRunner.new
+        @keyspace_changer = KeyspaceChanger.new
+      end
+
+      def connect(hosts, initial_keyspace)
+        f = @io_reactor.start.flat_map do
+          connect_to_hosts(hosts, initial_keyspace, true)
+        end
+        f = f.map do |connections|
+          connected_connections = connections.select(&:connected?)
+          if connected_connections.empty?
+            e = connections.first.error
+            if e.is_a?(Cql::QueryError) && e.code == 0x100
+              e = AuthenticationError.new(e.message)
+            end
+            raise e
+          end
+          connected_connections
+        end
+        f
+      end
+
+      def discover_peers(seed_connections, initial_keyspace)
+        @logger.debug('Looking for additional nodes')
+        connection = seed_connections.sample
+        return Future.resolved([]) unless connection
+        request = Protocol::QueryRequest.new('SELECT peer, data_center, host_id, rpc_address FROM system.peers', :one)
+        peer_info = @request_runner.execute(connection, request)
+        peer_info.flat_map do |result|
+          seed_dcs = seed_connections.map { |c| c[:data_center] }.uniq
+          unconnected_peers = result.select do |row|
+            seed_dcs.include?(row['data_center']) && seed_connections.none? { |c| c[:host_id] == row['host_id'] }
+          end
+          if unconnected_peers.empty?
+            @logger.debug('No additional nodes found')
+          else
+            @logger.debug('%d additional nodes found' % unconnected_peers.size)
+          end
+          node_addresses = unconnected_peers.map do |row|
+            rpc_address = row['rpc_address'].to_s
+            if rpc_address == '0.0.0.0'
+              row['peer'].to_s
+            else
+              rpc_address
+            end
+          end
+          if node_addresses.any?
+            connect_to_hosts(node_addresses, initial_keyspace, false)
+          else
+            Future.resolved([])
+          end
+        end
+      end
+
+      private
+
+      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, host, @port)
+          end
+        end
+        connection_futures.each do |cf|
+          cf.on_value do |c|
+            if c.is_a?(FailedConnection)
+              @logger.warn('Failed connecting to node at %s:%d: %s' % [c.host, c.port, c.error.message])
+            else
+              @logger.info('Connected to node %s at %s:%d in data center %s' % [c[:host_id], c.host, c.port, c[:data_center]])
+            end
+            c.on_closed do
+              @logger.warn('Connection to node %s at %s:%d in data center %s unexpectedly closed' % [c[:host_id], c.host, c.port, c[:data_center]])
+            end
+          end
+        end
+        hosts_connected_future = Future.all(*connection_futures)
+        if peer_discovery
+          hosts_connected_future.flat_map do |connections|
+            discover_peers(connections.select(&:connected?), initial_keyspace).map do |peer_connections|
+              connections + peer_connections
+            end
+          end
+        else
+          hosts_connected_future
+        end
+      end
+
+      def connect_to_host(host, keyspace)
+        @logger.debug('Connecting to node at %s:%d' % [host, @port])
+        connected = @io_reactor.connect(host, @port, @connection_timeout)
+        connected.flat_map do |connection|
+          initialize_connection(connection, keyspace)
+        end
+      end
+
+      def initialize_connection(connection, keyspace)
+        started = @request_runner.execute(connection, Protocol::StartupRequest.new)
+        authenticated = started.flat_map { |response| maybe_authenticate(response, connection) }
+        identified = authenticated.flat_map { identify_node(connection) }
+        identified.flat_map { @keyspace_changer.use_keyspace(keyspace, connection) }
+      end
+
+      def identify_node(connection)
+        request = Protocol::QueryRequest.new('SELECT data_center, host_id FROM system.local', :one)
+        f = @request_runner.execute(connection, request)
+        f.on_value do |result|
+          unless result.empty?
+            connection[:host_id] = result.first['host_id']
+            connection[:data_center] = result.first['data_center']
+          end
+        end
+        f
+      end
+
+      def maybe_authenticate(response, connection)
+        case response
+        when AuthenticationRequired
+          if @credentials
+            credentials_request = Protocol::CredentialsRequest.new(@credentials)
+            @request_runner.execute(connection, credentials_request).map { connection }
+          else
+            Future.failed(AuthenticationError.new('Server requested authentication, but no credentials given'))
+          end
+        else
+          Future.resolved(connection)
+        end
+      end
+
+      class FailedConnection
+        attr_reader :error, :host, :port
+
+        def initialize(error, host, port)
+          @error = error
+          @host = host
+          @port = port
+        end
+
+        def connected?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/cql/client/connection_manager.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+module Cql
+  module Client
+    # @private
+    class ConnectionManager
+      include Enumerable
+
+      def initialize
+        @connections = []
+        @lock = Mutex.new
+      end
+
+      def add_connections(connections)
+        @lock.synchronize do
+          @connections.concat(connections)
+          connections.each do |connection|
+            connection.on_closed do
+              @lock.synchronize do
+                @connections.delete(connection)
+              end
+            end
+          end
+        end
+      end
+
+      def connected?
+        @lock.synchronize do
+          @connections.any?
+        end
+      end
+
+      def snapshot
+        @lock.synchronize do
+          @connections.dup
+        end
+      end
+
+      def random_connection
+        raise NotConnectedError unless connected?
+        @lock.synchronize do
+          @connections.sample
+        end
+      end
+
+      def each_connection(&callback)
+        return self unless block_given?
+        raise NotConnectedError unless connected?
+        @lock.synchronize do
+          @connections.each(&callback)
+        end
+      end
+      alias_method :each, :each_connection
+    end
+  end
+end

data/lib/cql/client/keyspace_changer.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+module Cql
+  module Client
+    # @private
+    class KeyspaceChanger
+      KEYSPACE_NAME_PATTERN = /^\w[\w\d_]*$|^"\w[\w\d_]*"$/
+      
+      def initialize
+        @request_runner = RequestRunner.new
+      end
+
+      def use_keyspace(keyspace, connection)
+        return Future.resolved(connection) unless keyspace
+        return Future.failed(InvalidKeyspaceNameError.new(%("#{keyspace}" is not a valid keyspace name))) unless valid_keyspace_name?(keyspace)
+        request = Protocol::QueryRequest.new("USE #{keyspace}", :one)
+        @request_runner.execute(connection, request).map { connection }
+      end
+
+      private
+
+      def valid_keyspace_name?(name)
+        name =~ KEYSPACE_NAME_PATTERN
+      end
+    end
+  end
+end

data/lib/cql/client/null_logger.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Cql
+  module Client
+    # @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
+end

data/lib/cql/client/request_runner.rb

@@ -9,8 +9,6 @@ module Cql
           case response
           when Protocol::RowsResultResponse
             QueryResult.new(response.metadata, response.rows)
-          when Protocol::PreparedResultResponse
-            AsynchronousPreparedStatement.new(connection, response.id, response.metadata)
           when Protocol::ErrorResponse
             cql = request.is_a?(Protocol::QueryRequest) ? request.cql : nil
             raise QueryError.new(response.code, response.message, cql)
@@ -19,7 +17,11 @@ module Cql
           when Protocol::AuthenticateResponse
             AuthenticationRequired.new(response.authentication_class)
           else
-            nil
+            if block_given?
+              yield response
+            else
+              nil
+            end
           end
         end
       end

data/lib/cql/client/synchronous_client.rb

@@ -29,12 +29,12 @@ module Cql
       end
 
       def connect
-        synchronous_backtrace { @async_client.connect.get }
+        synchronous_backtrace { @async_client.connect.value }
         self
       end
 
       def close
-        synchronous_backtrace { @async_client.close.get }
+        synchronous_backtrace { @async_client.close.value }
         self
       end
 
@@ -47,15 +47,15 @@ module Cql
       end
 
       def use(keyspace)
-        synchronous_backtrace { @async_client.use(keyspace).get }
+        synchronous_backtrace { @async_client.use(keyspace).value }
       end
 
       def execute(cql, consistency=nil)
-        synchronous_backtrace { @async_client.execute(cql, consistency).get }
+        synchronous_backtrace { @async_client.execute(cql, consistency).value }
       end
 
       def prepare(cql)
-        async_statement = synchronous_backtrace { @async_client.prepare(cql).get }
+        async_statement = synchronous_backtrace { @async_client.prepare(cql).value }
         SynchronousPreparedStatement.new(async_statement)
       end
 

data/lib/cql/client/synchronous_prepared_statement.rb

@@ -12,13 +12,13 @@ module Cql
       end
 
       def execute(*args)
-        synchronous_backtrace { @async_statement.execute(*args).get }
+        synchronous_backtrace { @async_statement.execute(*args).value }
       end
 
       def pipeline
         pl = Pipeline.new(@async_statement)
         yield pl
-        synchronous_backtrace { pl.get }
+        synchronous_backtrace { pl.value }
       end
 
       def async
@@ -37,12 +37,8 @@ module Cql
         @futures << @async_statement.execute(*args)
       end
 
-      def get
-        if @futures.any?
-          Future.combine(*@futures).get
-        else
-          []
-        end
+      def value
+        Future.all(*@futures).value
       end
     end
   end

data/lib/cql/future.rb

@@ -6,168 +6,128 @@ require 'thread'
 module Cql
   FutureError = Class.new(CqlError)
 
-  # A future represents the value of a process that may not yet have completed.
+  # A promise of delivering a value some time in the future.
   #
-  # @private
+  # A promise is the write end of a Promise/Future pair. It can be fulfilled
+  # with a value or failed with an error. The value can be read through the
+  # future returned by {#future}.
   #
-  class Future
+  # @private
+  class Promise
+    attr_reader :future
+
     def initialize
-      @complete_listeners = []
-      @failure_listeners = []
-      @value_barrier = Queue.new
-      @state_lock = Mutex.new
+      @future = CompletableFuture.new
     end
 
-    # Combine multiple futures into a new future which completes when all
-    # constituent futures complete, or fail when one or more of them fails.
+    # Fulfills the promise.
     #
-    # The value of the combined future is an array of the values of the
-    # constituent futures.
+    # This will resolve this promise's future, and trigger all listeners of that
+    # future. The value of the future will be the specified value, or nil if
+    # no value is specified.
     #
-    # @param [Array<Future>] futures the futures to combine
-    # @return [Future<Array>] an array of the values of the constituent futures
-    #
-    def self.combine(*futures)
-      if futures.any?
-        CombinedFuture.new(*futures)
-      else
-        completed([])
-      end
+    # @param [Object] value the value of the future
+    def fulfill(value=nil)
+      @future.resolve(value)
     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).
+    # Fails the promise.
     #
-    # @param [Array<Future>] futures the futures to monitor
-    # @return [Future] a future which represents the first completing future
+    # This will fail this promise's future, and trigger all listeners of that
+    # 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
+    # @param [Error] error the error which prevented the promise to be fulfilled
+    def fail(error)
+      @future.fail(error)
     end
 
-    # Creates a new future which is completed.
-    #
-    # @param [Object, nil] value the value of the created future
-    # @return [Future] a completed future
+    # Observe a future and fulfill the promise with the future's value when the
+    # future resolves, or fail with the future's error when the future fails.
     #
-    def self.completed(value=nil)
-      CompletedFuture.new(value)
+    # @param [Cql::Future] future the future to observe
+    def observe(future)
+      future.on_value { |v| fulfill(v) }
+      future.on_failure { |e| fail(e) }
     end
 
-    # Creates a new future which is failed.
+    # Run the given block and fulfill this promise with its result. If the block
+    # raises an error, fail this promise with the error.
     #
-    # @param [Error] error the error of the created future
-    # @return [Future] a failed future
-    #
-    def self.failed(error)
-      FailedFuture.new(error)
-    end
-
-    # Completes the future.
+    # All arguments given will be passed onto the block.
     #
-    # This will trigger all completion listeners in the calling thread.
+    # @example
+    #   promise.try { 3 + 4 }
+    #   promise.future.value # => 7
     #
-    # @param [Object] v the value of the future
+    # @example
+    #   promise.try do
+    #     do_something_that_will_raise_an_error
+    #   end
+    #   promise.future.value # => (raises error)
     #
-    def complete!(v=nil)
-      @state_lock.synchronize do
-        raise FutureError, 'Future already completed' if complete? || failed?
-        @value = v
-        @complete_listeners.each do |listener|
-          listener.call(@value) rescue nil
-        end
-      end
-    ensure
-      @state_lock.synchronize do
-        @value_barrier << :ping
-      end
-    end
-
-    # Returns whether or not the future is complete
+    # @example
+    #   promise.try('foo', 'bar', &proc_taking_two_arguments)
     #
-    def complete?
-      defined? @value
+    # @yieldparam [Array] ctx the arguments passed to {#try}
+    def try(*ctx)
+      fulfill(yield(*ctx))
+    rescue => e
+      fail(e)
     end
+  end
 
-    # Registers a listener for when this future completes
+  # @private
+  module FutureFactories
+    # Combines multiple futures into a new future which resolves when all
+    # constituent futures complete, or fails when one or more of them fails.
     #
-    # @yieldparam [Object] value the value of the completed future
+    # The value of the combined future is an array of the values of the
+    # constituent futures.
     #
-    def on_complete(&listener)
-      @state_lock.synchronize do
-        if complete?
-          listener.call(value) rescue nil
-        else
-          @complete_listeners << listener
-        end
+    # @param [Array<Cql::Future>] futures the futures to combine
+    # @return [Cql::Future<Array>] an array of the values of the constituent
+    #   futures
+    def all(*futures)
+      if futures.any?
+        CombinedFuture.new(futures)
+      else
+        resolved([])
       end
     end
 
-    # Returns the value of this future, blocking until it is available, if necessary.
-    #
-    # If the future fails this method will raise the error that failed the future.
-    #
-    # @return [Object] the value of this future
-    #
-    def value
-      raise @error if @error
-      return @value if defined? @value
-      @value_barrier.pop
-      raise @error if @error
-      return @value
-    end
-    alias_method :get, :value
-
-    # Fails the future.
-    #
-    # This will trigger all failure listeners in the calling thread.
-    #
-    # @param [Error] error the error which prevented the value from being determined
+    # Returns a future which will be resolved with the value of the first
+    # (resolved) of the specified futures. If all of the futures fail, the
+    # returned future will also fail (with the error of the last failed future).
     #
-    def fail!(error)
-      @state_lock.synchronize do
-        raise FutureError, 'Future already completed' if failed? || complete?
-        @error = error
-        @failure_listeners.each do |listener|
-          listener.call(error) rescue nil
-        end
-      end
-    ensure
-      @state_lock.synchronize do
-        @value_barrier << :ping
+    # @param [Array<Cql::Future>] futures the futures to monitor
+    # @return [Cql::Future] a future which represents the first completing future
+    def first(*futures)
+      if futures.any?
+        FirstFuture.new(futures)
+      else
+        resolved
       end
     end
 
-    # Returns whether or not the future is failed.
+    # Creates a new pre-resolved future.
     #
-    def failed?
-      !!@error
+    # @param [Object, nil] value the value of the created future
+    # @return [Cql::Future] a resolved future
+    def resolved(value=nil)
+      ResolvedFuture.new(value)
     end
 
-    # Registers a listener for when this future fails
-    #
-    # @yieldparam [Error] error the error that failed the future
+    # Creates a new pre-failed future.
     #
-    def on_failure(&listener)
-      @state_lock.synchronize do
-        if failed?
-          listener.call(@error) rescue nil
-        else
-          @failure_listeners << listener
-        end
-      end
+    # @param [Error] error the error of the created future
+    # @return [Cql::Future] a failed future
+    def failed(error)
+      FailedFuture.new(error)
     end
+  end
 
+  # @private
+  module FutureCombinators
     # Returns a new future representing a transformation of this future's value.
     #
     # @example
@@ -175,20 +135,14 @@ module Cql
     #
     # @yieldparam [Object] value the value of this future
     # @yieldreturn [Object] the transformed value
-    # @return [Future] a new future representing the transformed value
-    #
+    # @return [Cql::Future] a new future representing the transformed value
     def map(&block)
-      fp = Future.new
-      on_failure { |e| fp.fail!(e) }
-      on_complete do |v|
-        begin
-          vv = block.call(v)
-          fp.complete!(vv)
-        rescue => e
-          fp.fail!(e)
-        end
+      p = Promise.new
+      on_failure { |e| p.fail(e) }
+      on_value do |v|
+        p.try(v, &block)
       end
-      fp
+      p.future
     end
 
     # Returns a new future representing a transformation of this future's value,
@@ -200,24 +154,20 @@ module Cql
     # This method is useful when you want to chain asynchronous operations.
     #
     # @yieldparam [Object] value the value of this future
-    # @yieldreturn [Future] a future representing the transformed value
-    # @return [Future] a new future representing the transformed value
-    #
+    # @yieldreturn [Cql::Future] a future representing the transformed value
+    # @return [Cql::Future] a new future representing the transformed value
     def flat_map(&block)
-      fp = Future.new
-      on_failure { |e| fp.fail!(e) }
-      on_complete do |v|
+      p = Promise.new
+      on_failure { |e| p.fail(e) }
+      on_value do |v|
         begin
-          fpp = block.call(v)
-          fpp.on_failure { |e| fp.fail!(e) }
-          fpp.on_complete do |vv|
-            fp.complete!(vv)
-          end
+          f = block.call(v)
+          p.observe(f)
         rescue => e
-          fp.fail!(e)
+          p.fail(e)
         end
       end
-      fp
+      p.future
     end
 
     # Returns a new future which represents either the value of the original
@@ -232,124 +182,284 @@ module Cql
     #
     # @example
     #   future2 = future1.recover { |error| 'foo' }
-    #   future1.fail!(error)
-    #   future2.get # => 'foo'
+    #   future1.fail(error)
+    #   future2.value # => '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
-    #
+    # @return [Cql::Future] a new future representing a value recovered from the error
     def recover(&block)
-      fp = Future.new
+      p = Promise.new
       on_failure do |e|
-        begin
-          vv = block.call(e)
-          fp.complete!(vv)
-        rescue => e
-          fp.fail!(e)
-        end
+        p.try(e, &block)
       end
-      on_complete do |v|
-        fp.complete!(v)
+      on_value do |v|
+        p.fulfill(v)
       end
-      fp
+      p.future
     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.
+    # itself asynchronous. In other words, {#fallback} is to {#recover} what
+    # {#flat_map} is to {#map}.
     #
     # 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
+    #   result = http_get('/foo/bar').fallback do |error|
+    #     http_get('/baz')
+    #   end
+    #   result.value # either the response to /foo/bar, or if that failed
+    #                # the response to /baz
     #
     # @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
-    #
+    # @return [Cql::Future] a new future representing a value recovered from the
+    #   error
     def fallback(&block)
-      fp = Future.new
+      p = Promise.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
+          f = block.call(e)
+          p.observe(f)
         rescue => e
-          fp.fail!(e)
+          p.fail(e)
         end
       end
-      on_complete do |v|
-        fp.complete!(v)
+      on_value do |v|
+        p.fulfill(v)
       end
-      fp
+      p.future
     end
   end
 
   # @private
-  class CompletedFuture < Future
-    def initialize(value=nil)
-      super()
-      complete!(value)
+  module FutureCallbacks
+    # Registers a listener that will be called when this future completes,
+    # i.e. resolves or fails. The listener will be called with the future as
+    # solve argument
+    #
+    # @yieldparam [Cql::Future] future the future
+    def on_complete(&listener)
+      run_immediately = false
+      @lock.synchronize do
+        if @resolved || @failed
+          run_immediately = true
+        else
+          @complete_listeners << listener
+        end
+      end
+      if run_immediately
+        listener.call(self) rescue nil
+      end
+      nil
+    end
+
+    # Registers a listener that will be called when this future becomes
+    # resolved. The listener will be called with the value of the future as
+    # sole argument.
+    #
+    # @yieldparam [Object] value the value of the resolved future
+    def on_value(&listener)
+      run_immediately = false
+      @lock.synchronize do
+        if @resolved
+          run_immediately = true
+        elsif !@failed
+          @value_listeners << listener
+        end
+      end
+      if run_immediately
+        listener.call(value) rescue nil
+      end
+      nil
+    end
+
+    # Registers a listener that will be called when this future fails. The
+    # lisener will be called with the error that failed the future as sole
+    # argument.
+    #
+    # @yieldparam [Error] error the error that failed the future
+    def on_failure(&listener)
+      run_immediately = false
+      @lock.synchronize do
+        if @failed
+          run_immediately = true
+        elsif !@resolved
+          @failure_listeners << listener
+        end
+      end
+      if run_immediately
+        listener.call(@error) rescue nil
+      end
+      nil
     end
   end
 
+  # A future represents the value of a process that may not yet have completed.
+  #
+  # @see Cql::Promise
   # @private
-  class FailedFuture < Future
-    def initialize(error)
-      super()
-      fail!(error)
+  class Future
+    extend FutureFactories
+    include FutureCombinators
+    include FutureCallbacks
+
+    def initialize
+      @lock = Mutex.new
+      @resolved = false
+      @failed = false
+      @failure_listeners = []
+      @value_listeners = []
+      @complete_listeners = []
+    end
+
+    # Returns the value of this future, blocking until it is available if
+    # necessary.
+    #
+    # If the future fails this method will raise the error that failed the
+    # future.
+    #
+    # @return [Object] the value of this future
+    def value
+      @lock.synchronize do
+        raise @error if @failed
+        return @value if @resolved
+        t = Thread.current
+        u = proc { t.run }
+        @value_listeners << u
+        @failure_listeners << u
+        while true
+          raise @error if @failed
+          return @value if @resolved
+          @lock.sleep
+        end
+      end
+    end
+
+    # Returns true if this future is resolved or failed
+    def completed?
+      resolved? || failed?
+    end
+
+    # Returns true if this future is resolved
+    def resolved?
+      @lock.synchronize { @resolved }
+    end
+
+    # Returns true if this future has failed
+    def failed?
+      @lock.synchronize { @failed }
     end
   end
 
   # @private
-  class CombinedFuture < Future
-    def initialize(*futures)
+  class CompletableFuture < Future
+    def resolve(v=nil)
+      value_listeners = nil
+      complete_listeners = nil
+      @lock.synchronize do
+        raise FutureError, 'Future already completed' if @resolved || @failed
+        @resolved = true
+        @value = v
+        value_listeners = @value_listeners
+        complete_listeners = @complete_listeners
+        @value_listeners = nil
+        @failure_listeners = nil
+        @complete_listeners = nil
+      end
+      value_listeners.each do |listener|
+        listener.call(v) rescue nil
+      end
+      complete_listeners.each do |listener|
+        listener.call(self) rescue nil
+      end
+      nil
+    end
+
+    def fail(error)
+      failure_listeners = nil
+      complete_listeners = nil
+      @lock.synchronize do
+        raise FutureError, 'Future already completed' if @failed || @resolved
+        @failed = true
+        @error = error
+        failure_listeners = @failure_listeners
+        complete_listeners = @complete_listeners
+        @value_listeners = nil
+        @failure_listeners = nil
+        @complete_listeners = nil
+      end
+      failure_listeners.each do |listener|
+        listener.call(error) rescue nil
+      end
+      complete_listeners.each do |listener|
+        listener.call(self) rescue nil
+      end
+      nil
+    end
+  end
+
+  # @private
+  class CombinedFuture < CompletableFuture
+    def initialize(futures)
       super()
-      values = [nil] * futures.size
-      completed = [false] * futures.size
+      values = Array.new(futures.size)
+      remaining = futures.size
       futures.each_with_index do |f, i|
-        f.on_complete do |v|
-          all_done = false
-          @state_lock.synchronize do
+        f.on_value do |v|
+          @lock.synchronize do
             values[i] = v
-            completed[i] = true
-            all_done = completed.all?
+            remaining -= 1
           end
-          if all_done
-            combined_complete!(values)
+          if remaining == 0
+            resolve(values)
           end
         end
         f.on_failure do |e|
           unless failed?
-            combined_fail!(e)
+            fail(e)
           end
         end
       end
     end
+  end
 
-    alias_method :combined_complete!, :complete!
-    private :combined_complete!
-
-    alias_method :combined_fail!, :fail!
-    private :combined_fail!
+  # @private
+  class FirstFuture < CompletableFuture
+    def initialize(futures)
+      super()
+      futures.each do |f|
+        f.on_value do |value|
+          resolve(value) unless completed?
+        end
+        f.on_failure do |e|
+          fail(e) if futures.all?(&:failed?)
+        end
+      end
+    end
+  end
 
-    def complete!(v=nil)
-      raise FutureError, 'Cannot complete a combined future'
+  # @private
+  class ResolvedFuture < Future
+    def initialize(value=nil)
+      super()
+      @value = value
+      @resolved = true
     end
+  end
 
-    def fail!(e)
-      raise FutureError, 'Cannot fail a combined future'
+  # @private
+  class FailedFuture < Future
+    def initialize(error)
+      super()
+      @error = error
+      @failed = true
     end
   end
 end