cql-rb 1.1.0.pre3 → 1.1.0.pre6

data/lib/cql/io/connection.rb

@@ -23,7 +23,7 @@ module Cql
         @lock = Mutex.new
         @connected = false
         @write_buffer = ByteBuffer.new
-        @connected_future = Future.new
+        @connected_promise = Promise.new
       end
 
       # @private
@@ -41,11 +41,11 @@ module Cql
           unless connected?
             @io.connect_nonblock(@sockaddr)
             @connected = true
-            @connected_future.complete!(self)
+            @connected_promise.fulfill(self)
           end
         rescue Errno::EISCONN
           @connected = true
-          @connected_future.complete!(self)
+          @connected_promise.fulfill(self)
         rescue Errno::EINPROGRESS, Errno::EALREADY
           if @clock.now - @connection_started_at > @connection_timeout
             close(ConnectionTimeoutError.new("Could not connect to #{@host}:#{@port} within #{@connection_timeout}s"))
@@ -62,7 +62,7 @@ module Cql
         rescue SocketError => e
           close(e) || closed!(e)
         end
-        @connected_future
+        @connected_promise.future
       end
 
       # Closes the connection
@@ -209,7 +209,7 @@ module Cql
           cause = ConnectionError.new(cause.message)
         end
         unless connected?
-          @connected_future.fail!(cause)
+          @connected_promise.fail(cause)
         end
         @connected = false
         if @closed_listener

data/lib/cql/io/io_reactor.rb

@@ -95,8 +95,8 @@ module Cql
         @io_loop.add_socket(@unblocker)
         @running = false
         @stopped = false
-        @started_future = Future.new
-        @stopped_future = Future.new
+        @started_promise = Promise.new
+        @stopped_promise = Promise.new
         @lock = Mutex.new
       end
 
@@ -109,7 +109,7 @@ module Cql
       # @yield [error] the error that cause the reactor to stop
       #
       def on_error(&listener)
-        @stopped_future.on_failure(&listener)
+        @stopped_promise.future.on_failure(&listener)
       end
 
       # Returns true as long as the reactor is running. It will be true even
@@ -130,11 +130,11 @@ module Cql
       def start
         @lock.synchronize do
           raise ReactorError, 'Cannot start a stopped IO reactor' if @stopped
-          return @started_future if @running
+          return @started_promise.future if @running
           @running = true
         end
         Thread.start do
-          @started_future.complete!(self)
+          @started_promise.fulfill(self)
           begin
             @io_loop.tick until @stopped
           ensure
@@ -142,13 +142,13 @@ module Cql
             @io_loop.cancel_timers
             @running = false
             if $!
-              @stopped_future.fail!($!)
+              @stopped_promise.fail($!)
             else
-              @stopped_future.complete!(self)
+              @stopped_promise.fulfill(self)
             end
           end
         end
-        @started_future
+        @started_promise.future
       end
 
       # Stops the reactor.
@@ -161,7 +161,7 @@ module Cql
       #
       def stop
         @stopped = true
-        @stopped_future
+        @stopped_promise.future
       end
 
       # Opens a connection to the specified host and port.
@@ -197,9 +197,7 @@ module Cql
       # @return [Cql::Future] a future that completes when the timer expires
       #
       def schedule_timer(timeout)
-        f = Future.new
-        @io_loop.schedule_timer(timeout, f)
-        f
+        @io_loop.schedule_timer(timeout)
       end
 
       def to_s
@@ -272,19 +270,19 @@ module Cql
 
       def add_socket(socket)
         @lock.synchronize do
-          sockets = @sockets.dup
+          sockets = @sockets.reject { |s| s.closed? }
           sockets << socket
           @sockets = sockets
         end
       end
 
-      def schedule_timer(timeout, future)
+      def schedule_timer(timeout, promise=Promise.new)
         @lock.synchronize do
-          timers = @timers.dup
-          timers << [@clock.now + timeout, future]
-          timers.sort_by(&:first)
+          timers = @timers.reject { |pair| pair[1].nil? }
+          timers << [@clock.now + timeout, promise]
           @timers = timers
         end
+        promise.future
       end
 
       def close_sockets
@@ -300,7 +298,7 @@ module Cql
       def cancel_timers
         @timers.each do |pair|
           if pair[1]
-            pair[1].fail!(CancelledError.new)
+            pair[1].fail(CancelledError.new)
             pair[1] = nil
           end
         end
@@ -320,8 +318,8 @@ module Cql
       def check_sockets!(timeout)
         readables, writables, connecting = [], [], []
         sockets = @sockets
-        sockets.reject! { |s| s.closed? }
         sockets.each do |s|
+          next if s.closed?
           readables << s if s.connected?
           writables << s if s.connecting? || s.writable?
           connecting << s if s.connecting?
@@ -335,11 +333,11 @@ module Cql
       def check_timers!
         timers = @timers
         timers.each do |pair|
-          break unless pair[0] <= @clock.now && pair[1]
-          pair[1].complete!
-          pair[1] = nil
+          if pair[1] && pair[0] <= @clock.now
+            pair[1].fulfill
+            pair[1] = nil
+          end
         end
-        timers.reject! { |pair| pair[1].nil? }
       end
     end
   end

data/lib/cql/protocol/cql_protocol_handler.rb

@@ -23,7 +23,7 @@ module Cql
         @connection = connection
         @connection.on_data(&method(:receive_data))
         @connection.on_closed(&method(:socket_closed))
-        @responses = Array.new(128) { nil }
+        @promises = Array.new(128) { nil }
         @read_buffer = ByteBuffer.new
         @current_frame = Protocol::ResponseFrame.new(@read_buffer)
         @request_queue_in = []
@@ -31,10 +31,24 @@ module Cql
         @event_listeners = []
         @data = {}
         @lock = Mutex.new
-        @closed_future = Future.new
+        @closed_promise = Promise.new
         @keyspace = nil
       end
 
+      # Returns the hostname of the underlying connection
+      #
+      # @return [String] the hostname
+      def host
+        @connection.host
+      end
+
+      # Returns the port of the underlying connection
+      #
+      # @return [Integer] the port
+      def port
+        @connection.port
+      end
+
       # Associate arbitrary data with this protocol handler object. This is
       # useful in situations where additional metadata can be loaded after the
       # connection has been set up, or to keep statistics specific to the
@@ -66,8 +80,7 @@ module Cql
       # @yieldparam error [nil, Error] the error that caused the connection to
       #   close, if any
       def on_closed(&listener)
-        @closed_future.on_complete(&listener)
-        @closed_future.on_failure(&listener)
+        @closed_promise.future.on_complete(&listener)
       end
 
       # Register to receive server sent events, like schema changes, nodes going
@@ -77,7 +90,7 @@ module Cql
       # @yieldparam event [Cql::Protocol::EventResponse] an event sent by the server
       def on_event(&listener)
         @lock.synchronize do
-          @event_listeners << listener
+          @event_listeners += [listener]
         end
       end
 
@@ -91,11 +104,11 @@ module Cql
       #   the response
       def send_request(request)
         return Future.failed(NotConnectedError.new) if closed?
-        future = Future.new
+        promise = RequestPromise.new(request)
         id = nil
         @lock.synchronize do
           if (id = next_stream_id)
-            @responses[id] = future
+            @promises[id] = promise
           end
         end
         if id
@@ -104,10 +117,11 @@ module Cql
           end
         else
           @lock.synchronize do
-            @request_queue_in << [request.encode_frame(0), future]
+            promise.encode_frame!
+            @request_queue_in << promise
           end
         end
-        future
+        promise.future
       end
 
       # Closes the underlying connection.
@@ -115,11 +129,25 @@ module Cql
       # @return [Cql::Future] a future that completes when the connection has closed
       def close
         @connection.close
-        @closed_future
+        @closed_promise.future
       end
 
       private
 
+      # @private
+      class RequestPromise < Promise
+        attr_reader :request, :frame
+
+        def initialize(request)
+          @request = request
+          super()
+        end
+
+        def encode_frame!
+          @frame = @request.encode_frame(0)
+        end
+      end
+
       def receive_data(data)
         @current_frame << data
         while @current_frame.complete?
@@ -135,24 +163,26 @@ module Cql
       end
 
       def notify_event_listeners(event_response)
-        return if @event_listeners.empty?
+        event_listeners = nil
         @lock.synchronize do
-          @event_listeners.each do |listener|
-            listener.call(@current_frame.body) rescue nil
-          end
+          event_listeners = @event_listeners
+          return if event_listeners.empty?
+        end
+        event_listeners.each do |listener|
+          listener.call(@current_frame.body) rescue nil
         end
       end
 
       def complete_request(id, response)
-        future = @lock.synchronize do
-          future = @responses[id]
-          @responses[id] = nil
-          future
+        promise = @lock.synchronize do
+          promise = @promises[id]
+          @promises[id] = nil
+          promise
         end
         if response.is_a?(Protocol::SetKeyspaceResultResponse)
           @keyspace = response.keyspace
         end
-        future.complete!(response)
+        promise.fulfill(response)
       end
 
       def flush_request_queue
@@ -164,16 +194,17 @@ module Cql
         end
         while true
           id = nil
-          request_buffer = nil
+          frame = nil
           @lock.synchronize do
             if @request_queue_out.any? && (id = next_stream_id)
-              request_buffer, future = @request_queue_out.shift
-              @responses[id] = future
+              promise = @request_queue_out.shift
+              frame = promise.frame
+              @promises[id] = promise
             end
           end
           if id
-            Protocol::Request.change_stream_id(id, request_buffer)
-            @connection.write(request_buffer)
+            Protocol::Request.change_stream_id(id, frame)
+            @connection.write(frame)
           else
             break
           end
@@ -183,30 +214,30 @@ module Cql
       def socket_closed(cause)
         request_failure_cause = cause || Io::ConnectionClosedError.new
         @lock.synchronize do
-          @responses.each_with_index do |future, i|
-            if future
-              @responses[i].fail!(request_failure_cause)
-              @responses[i] = nil
+          @promises.each_with_index do |promise, i|
+            if promise
+              @promises[i].fail(request_failure_cause)
+              @promises[i] = nil
             end
           end
-          @request_queue_in.each do |_, future|
-            future.fail!(request_failure_cause)
+          @request_queue_in.each do |promise|
+            promise.fail(request_failure_cause)
           end
           @request_queue_in.clear
-          @request_queue_out.each do |_, future|
-            future.fail!(request_failure_cause)
+          @request_queue_out.each do |promise|
+            promise.fail(request_failure_cause)
           end
           @request_queue_out.clear
-          if cause
-            @closed_future.fail!(cause)
-          else
-            @closed_future.complete!
-          end
+        end
+        if cause
+          @closed_promise.fail(cause)
+        else
+          @closed_promise.fulfill
         end
       end
 
       def next_stream_id
-        @responses.each_with_index do |task, index|
+        @promises.each_with_index do |task, index|
           return index if task.nil?
         end
         nil

data/lib/cql/protocol/encoding.rb

@@ -27,7 +27,11 @@ module Cql
       end
 
       def write_uuid(buffer, uuid)
-        write_varint(buffer, uuid.value)
+        v = uuid.value
+        write_int(buffer, (v >> 96) & 0xffffffff)
+        write_int(buffer, (v >> 64) & 0xffffffff)
+        write_int(buffer, (v >> 32) & 0xffffffff)
+        write_int(buffer, v & 0xffffffff)
       end
 
       def write_string_list(buffer, strs)

data/lib/cql/protocol/requests/register_request.rb

@@ -3,6 +3,8 @@
 module Cql
   module Protocol
     class RegisterRequest < Request
+      attr_reader :events
+
       def initialize(*events)
         super(11)
         @events = events

data/lib/cql/protocol/type_converter.rb

@@ -108,6 +108,7 @@ module Cql
           :bigint => method(:bigint_to_bytes),
           :blob => method(:blob_to_bytes),
           :boolean => method(:boolean_to_bytes),
+          :counter => method(:bigint_to_bytes),
           :decimal => method(:decimal_to_bytes),
           :double => method(:double_to_bytes),
           :float => method(:float_to_bytes),

data/lib/cql/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Cql
-  VERSION = '1.1.0.pre3'.freeze
+  VERSION = '1.1.0.pre6'.freeze
 end

data/spec/cql/client/asynchronous_client_spec.rb

@@ -11,13 +11,17 @@ module Cql
       end
 
       let :connection_options do
-        {:host => 'example.com', :port => 12321, :io_reactor => io_reactor}
+        {:host => 'example.com', :port => 12321, :io_reactor => io_reactor, :logger => logger}
       end
 
       let :io_reactor do
         FakeIoReactor.new
       end
 
+      let :logger do
+        NullLogger.new
+      end
+
       def connections
         io_reactor.connections
       end
@@ -53,39 +57,116 @@ module Cql
         end
       end
 
+      shared_context 'peer discovery setup' do
+        let :local_info do
+          {
+            'data_center' => 'dc1',
+            'host_id' => nil,
+          }
+        end
+
+        let :local_metadata do
+          [
+            ['system', 'local', 'data_center', :text],
+            ['system', 'local', 'host_id', :uuid],
+          ]
+        end
+
+        let :peer_metadata do
+          [
+            ['system', 'peers', 'peer', :inet],
+            ['system', 'peers', 'data_center', :varchar],
+            ['system', 'peers', 'host_id', :uuid],
+            ['system', 'peers', 'rpc_address', :inet],
+          ]
+        end
+
+        let :data_centers do
+          Hash.new('dc1')
+        end
+
+        let :additional_nodes do
+          Array.new(5) { IPAddr.new("127.0.#{rand(255)}.#{rand(255)}") }
+        end
+
+        let :bind_all_rpc_addresses do
+          false
+        end
+
+        let :min_peers do
+          [2]
+        end
+
+        before do
+          uuid_generator = TimeUuid::Generator.new
+          additional_rpc_addresses = additional_nodes.dup
+          io_reactor.on_connection do |connection|
+            connection[:spec_host_id] = uuid_generator.next
+            connection[:spec_data_center] = data_centers[connection.host]
+            connection.handle_request do |request|
+              case request
+              when Protocol::StartupRequest
+                Protocol::ReadyResponse.new
+              when Protocol::QueryRequest
+                case request.cql
+                when /FROM system\.local/
+                  row = {'host_id' => connection[:spec_host_id], 'data_center' => connection[:spec_data_center]}
+                  Protocol::RowsResultResponse.new([row], local_metadata)
+                when /FROM system\.peers/
+                  other_host_ids = connections.reject { |c| c[:spec_host_id] == connection[:spec_host_id] }.map { |c| c[:spec_host_id] }
+                  until other_host_ids.size >= min_peers[0]
+                    other_host_ids << uuid_generator.next
+                  end
+                  rows = other_host_ids.map do |host_id|
+                    ip = additional_rpc_addresses.shift
+                    {
+                      'peer' => ip,
+                      'host_id' => host_id,
+                      'data_center' => data_centers[ip],
+                      'rpc_address' => bind_all_rpc_addresses ? IPAddr.new('0.0.0.0') : ip
+                    }
+                  end
+                  Protocol::RowsResultResponse.new(rows, peer_metadata)
+                end
+              end
+            end
+          end
+        end
+      end
+
       describe '#connect' do
         it 'connects' do
-          client.connect.get
+          client.connect.value
           connections.should have(1).item
         end
 
         it 'connects only once' do
-          client.connect.get
-          client.connect.get
+          client.connect.value
+          client.connect.value
           connections.should have(1).item
         end
 
         context 'when connecting to multiple hosts' do
           before do
-            client.close.get
-            io_reactor.stop.get
+            client.close.value
+            io_reactor.stop.value
           end
 
           it 'connects to all hosts' do
             c = described_class.new(connection_options.merge(hosts: %w[h1.example.com h2.example.com h3.example.com]))
-            c.connect.get
+            c.connect.value
             connections.should have(3).items
           end
 
           it 'connects to all hosts, when given as a comma-sepatated string' do
             c = described_class.new(connection_options.merge(host: 'h1.example.com,h2.example.com,h3.example.com'))
-            c.connect.get
+            c.connect.value
             connections.should have(3).items
           end
 
           it 'only connects to each host once' do
             c = described_class.new(connection_options.merge(hosts: %w[h1.example.com h2.example.com h2.example.com]))
-            c.connect.get
+            c.connect.value
             connections.should have(2).items
           end
 
@@ -93,7 +174,7 @@ module Cql
             io_reactor.node_down('h1.example.com')
             io_reactor.node_down('h3.example.com')
             c = described_class.new(connection_options.merge(hosts: %w[h1.example.com h2.example.com h2.example.com]))
-            c.connect.get
+            c.connect.value
             connections.should have(1).items
           end
 
@@ -102,134 +183,65 @@ module Cql
             io_reactor.node_down('h2.example.com')
             io_reactor.node_down('h3.example.com')
             c = described_class.new(connection_options.merge(hosts: %w[h1.example.com h2.example.com h2.example.com]))
-            expect { c.connect.get }.to raise_error(Io::ConnectionError)
+            expect { c.connect.value }.to raise_error(Io::ConnectionError)
           end
         end
 
         it 'returns itself' do
-          client.connect.get.should equal(client)
+          client.connect.value.should equal(client)
         end
 
         it 'connects to the right host and port' do
-          client.connect.get
+          client.connect.value
           last_connection.host.should == 'example.com'
           last_connection.port.should == 12321
         end
 
         it 'connects with the default connection timeout' do
-          client.connect.get
+          client.connect.value
           last_connection.timeout.should == 10
         end
 
         it 'sends a startup request' do
-          client.connect.get
+          client.connect.value
           requests.first.should be_a(Protocol::StartupRequest)
         end
 
         it 'sends a startup request to each connection' do
-          client.close.get
-          io_reactor.stop.get
-          io_reactor.start.get
+          client.close.value
+          io_reactor.stop.value
+          io_reactor.start.value
 
           c = described_class.new(connection_options.merge(hosts: %w[h1.example.com h2.example.com h3.example.com]))
-          c.connect.get
+          c.connect.value
           connections.each do |cc|
             cc.requests.first.should be_a(Protocol::StartupRequest)
           end
         end
 
         it 'is not in a keyspace' do
-          client.connect.get
+          client.connect.value
           client.keyspace.should be_nil
         end
 
         it 'changes to the keyspace given as an option' do
           c = described_class.new(connection_options.merge(:keyspace => 'hello_world'))
-          c.connect.get
+          c.connect.value
           request = requests.find { |rq| rq == Protocol::QueryRequest.new('USE hello_world', :one) }
           request.should_not be_nil, 'expected a USE request to have been sent'
         end
 
         it 'validates the keyspace name before sending the USE command' do
           c = described_class.new(connection_options.merge(:keyspace => 'system; DROP KEYSPACE system'))
-          expect { c.connect.get }.to raise_error(InvalidKeyspaceNameError)
+          expect { c.connect.value }.to raise_error(InvalidKeyspaceNameError)
           requests.should_not include(Protocol::QueryRequest.new('USE system; DROP KEYSPACE system', :one))
         end
 
         context 'with automatic peer discovery' do
-          let :local_info do
-            {
-              'data_center' => 'dc1',
-              'host_id' => nil,
-            }
-          end
-
-          let :local_metadata do
-            [
-              ['system', 'local', 'data_center', :text],
-              ['system', 'local', 'host_id', :uuid],
-            ]
-          end
-
-          let :peer_metadata do
-            [
-              ['system', 'peers', 'peer', :inet],
-              ['system', 'peers', 'data_center', :varchar],
-              ['system', 'peers', 'host_id', :uuid],
-              ['system', 'peers', 'rpc_address', :inet],
-            ]
-          end
-
-          let :data_centers do
-            Hash.new('dc1')
-          end
-
-          let :additional_nodes do
-            Array.new(5) { IPAddr.new("127.0.#{rand(255)}.#{rand(255)}") }
-          end
-
-          let :bind_all_rpc_addresses do
-            false
-          end
-
-          before do
-            uuid_generator = TimeUuid::Generator.new
-            additional_rpc_addresses = additional_nodes.dup
-            io_reactor.on_connection do |connection|
-              connection[:spec_host_id] = uuid_generator.next
-              connection[:spec_data_center] = data_centers[connection.host]
-              connection.handle_request do |request|
-                case request
-                when Protocol::StartupRequest
-                  Protocol::ReadyResponse.new
-                when Protocol::QueryRequest
-                  case request.cql
-                  when /FROM system\.local/
-                    row = {'host_id' => connection[:spec_host_id], 'data_center' => connection[:spec_data_center]}
-                    Protocol::RowsResultResponse.new([row], local_metadata)
-                  when /FROM system\.peers/
-                    other_host_ids = connections.reject { |c| c[:spec_host_id] == connection[:spec_host_id] }.map { |c| c[:spec_host_id] }
-                    until other_host_ids.size >= 2
-                      other_host_ids << uuid_generator.next
-                    end
-                    rows = other_host_ids.map do |host_id|
-                      ip = additional_rpc_addresses.shift
-                      {
-                        'peer' => ip,
-                        'host_id' => host_id,
-                        'data_center' => data_centers[ip],
-                        'rpc_address' => bind_all_rpc_addresses ? IPAddr.new('0.0.0.0') : ip
-                      }
-                    end
-                    Protocol::RowsResultResponse.new(rows, peer_metadata)
-                  end
-                end
-              end
-            end
-          end
+          include_context 'peer discovery setup'
 
           it 'connects to the other nodes in the cluster' do
-            client.connect.get
+            client.connect.value
             connections.should have(3).items
           end
 
@@ -239,14 +251,14 @@ module Cql
             end
 
             it 'falls back on using the peer column' do
-              client.connect.get
+              client.connect.value
               connections.should have(3).items
             end
           end
 
           it 'connects to the other nodes in the same data center' do
             data_centers[additional_nodes[1]] = 'dc2'
-            client.connect.get
+            client.connect.value
             connections.should have(2).items
           end
 
@@ -254,49 +266,49 @@ module Cql
             data_centers['host2'] = 'dc2'
             data_centers[additional_nodes[1]] = 'dc2'
             c = described_class.new(connection_options.merge(hosts: %w[host1 host2]))
-            c.connect.get
+            c.connect.value
             connections.should have(3).items
           end
 
           it 'only connects to the other nodes in the cluster it is not already connected do' do
             c = described_class.new(connection_options.merge(hosts: %w[host1 host2]))
-            c.connect.get
+            c.connect.value
             connections.should have(3).items
           end
 
           it 'handles the case when it is already connected to all nodes' do
             c = described_class.new(connection_options.merge(hosts: %w[host1 host2 host3 host4]))
-            c.connect.get
+            c.connect.value
             connections.should have(4).items
           end
 
           it 'accepts that some nodes are down' do
             io_reactor.node_down(additional_nodes.first.to_s)
-            client.connect.get
+            client.connect.value
             connections.should have(2).items
           end
         end
 
         it 're-raises any errors raised' do
           io_reactor.stub(:connect).and_raise(ArgumentError)
-          expect { client.connect.get }.to raise_error(ArgumentError)
+          expect { client.connect.value }.to raise_error(ArgumentError)
         end
 
         it 'is not connected if an error is raised' do
           io_reactor.stub(:connect).and_raise(ArgumentError)
-          client.connect.get rescue nil
+          client.connect.value rescue nil
           client.should_not be_connected
           io_reactor.should_not be_running
         end
 
         it 'is connected after #connect returns' do
-          client.connect.get
+          client.connect.value
           client.should be_connected
         end
 
         it 'is not connected while connecting' do
           go = false
-          io_reactor.stop.get
+          io_reactor.stop.value
           io_reactor.before_startup { sleep 0.01 until go }
           client.connect
           begin
@@ -331,26 +343,26 @@ module Cql
 
           it 'sends credentials' do
             client = described_class.new(connection_options.merge(credentials: {'username' => 'foo', 'password' => 'bar'}))
-            client.connect.get
+            client.connect.value
             request = requests.find { |rq| rq == Protocol::CredentialsRequest.new('username' => 'foo', 'password' => 'bar') }
             request.should_not be_nil, 'expected a credentials request to have been sent'
           end
 
           it 'raises an error when no credentials have been given' do
             client = described_class.new(connection_options)
-            expect { client.connect.get }.to raise_error(AuthenticationError)
+            expect { client.connect.value }.to raise_error(AuthenticationError)
           end
 
           it 'raises an error when the server responds with an error to the credentials request' do
             handle_request(&method(:denying_request_handler))
             client = described_class.new(connection_options.merge(credentials: {'username' => 'foo', 'password' => 'bar'}))
-            expect { client.connect.get }.to raise_error(AuthenticationError)
+            expect { client.connect.value }.to raise_error(AuthenticationError)
           end
 
           it 'shuts down the client when there is an authentication error' do
             handle_request(&method(:denying_request_handler))
             client = described_class.new(connection_options.merge(credentials: {'username' => 'foo', 'password' => 'bar'}))
-            client.connect.get rescue nil
+            client.connect.value rescue nil
             client.should_not be_connected
             io_reactor.should_not be_running
           end
@@ -359,28 +371,28 @@ module Cql
 
       describe '#close' do
         it 'closes the connection' do
-          client.connect.get
-          client.close.get
+          client.connect.value
+          client.close.value
           io_reactor.should_not be_running
         end
 
         it 'does nothing when called before #connect' do
-          client.close.get
+          client.close.value
         end
 
         it 'accepts multiple calls to #close' do
-          client.connect.get
-          client.close.get
-          client.close.get
+          client.connect.value
+          client.close.value
+          client.close.value
         end
 
         it 'returns itself' do
-          client.connect.get.close.get.should equal(client)
+          client.connect.value.close.value.should equal(client)
         end
 
         it 'fails when the IO reactor stop fails' do
           io_reactor.stub(:stop).and_return(Future.failed(StandardError.new('Bork!')))
-          expect { client.close.get }.to raise_error('Bork!')
+          expect { client.close.value }.to raise_error('Bork!')
         end
       end
 
@@ -391,20 +403,20 @@ module Cql
               Protocol::SetKeyspaceResultResponse.new('system')
             end
           end
-          client.connect.get
-          client.use('system').get
+          client.connect.value
+          client.use('system').value
           last_request.should == Protocol::QueryRequest.new('USE system', :one)
         end
 
         it 'executes a USE query for each connection' do
-          client.close.get
-          io_reactor.stop.get
-          io_reactor.start.get
+          client.close.value
+          io_reactor.stop.value
+          io_reactor.start.value
 
           c = described_class.new(connection_options.merge(hosts: %w[h1.example.com h2.example.com h3.example.com]))
-          c.connect.get
+          c.connect.value
 
-          c.use('system').get
+          c.use('system').value
           last_requests = connections.select { |c| c.host =~ /^h\d\.example\.com$/ }.sort_by(&:host).map { |c| c.requests.last }
           last_requests.should == [
             Protocol::QueryRequest.new('USE system', :one),
@@ -419,14 +431,14 @@ module Cql
               Protocol::SetKeyspaceResultResponse.new('system')
             end
           end
-          client.connect.get
-          client.use('system').get
+          client.connect.value
+          client.use('system').value
           client.keyspace.should == 'system'
         end
 
         it 'raises an error if the keyspace name is not valid' do
-          client.connect.get
-          expect { client.use('system; DROP KEYSPACE system').get }.to raise_error(InvalidKeyspaceNameError)
+          client.connect.value
+          expect { client.use('system; DROP KEYSPACE system').value }.to raise_error(InvalidKeyspaceNameError)
         end
 
         it 'allows the keyspace name to be quoted' do
@@ -435,24 +447,35 @@ module Cql
               Protocol::SetKeyspaceResultResponse.new('system')
             end
           end
-          client.connect.get
-          client.use('"system"').get
+          client.connect.value
+          client.use('"system"').value
           client.keyspace.should == "system"
         end
       end
 
       describe '#execute' do
+        let :cql do
+          'UPDATE stuff SET thing = 1 WHERE id = 3'
+        end
+
         before do
-          client.connect.get
+          client.connect.value
         end
 
-        it 'asks the connection to execute the query' do
-          client.execute('UPDATE stuff SET thing = 1 WHERE id = 3').get
-          last_request.should == Protocol::QueryRequest.new('UPDATE stuff SET thing = 1 WHERE id = 3', :quorum)
+        it 'asks the connection to execute the query using the default consistency level' do
+          client.execute(cql).value
+          last_request.should == Protocol::QueryRequest.new(cql, :quorum)
+        end
+
+        it 'uses the consistency specified when the client was created' do
+          client = described_class.new(connection_options.merge(default_consistency: :all))
+          client.connect.value
+          client.execute(cql).value
+          last_request.should == Protocol::QueryRequest.new(cql, :all)
         end
 
         it 'uses the specified consistency' do
-          client.execute('UPDATE stuff SET thing = 1 WHERE id = 3', :three).get
+          client.execute('UPDATE stuff SET thing = 1 WHERE id = 3', :three).value
           last_request.should == Protocol::QueryRequest.new('UPDATE stuff SET thing = 1 WHERE id = 3', :three)
         end
 
@@ -463,7 +486,7 @@ module Cql
                 Protocol::VoidResultResponse.new
               end
             end
-            result = client.execute('UPDATE stuff SET thing = 1 WHERE id = 3').get
+            result = client.execute('UPDATE stuff SET thing = 1 WHERE id = 3').value
             result.should be_nil
           end
         end
@@ -475,7 +498,7 @@ module Cql
                 Protocol::SetKeyspaceResultResponse.new('system')
               end
             end
-            result = client.execute('USE system').get
+            result = client.execute('USE system').value
             result.should be_nil
           end
 
@@ -485,14 +508,14 @@ module Cql
                 Protocol::SetKeyspaceResultResponse.new('system')
               end
             end
-            client.execute('USE system').get
+            client.execute('USE system').value
             client.keyspace.should == 'system'
           end
 
           it 'detects that one connection changed to a keyspace and changes the others too' do
-            client.close.get
-            io_reactor.stop.get
-            io_reactor.start.get
+            client.close.value
+            io_reactor.stop.value
+            io_reactor.start.value
 
             handle_request do |request, connection|
               if request.is_a?(Protocol::QueryRequest) && request.cql == 'USE system'
@@ -501,9 +524,9 @@ module Cql
             end
 
             c = described_class.new(connection_options.merge(hosts: %w[h1.example.com h2.example.com h3.example.com]))
-            c.connect.get
+            c.connect.value
 
-            c.execute('USE system', :one).get
+            c.execute('USE system', :one).value
             c.keyspace.should == 'system'
 
             last_requests = connections.select { |c| c.host =~ /^h\d\.example\.com$/ }.sort_by(&:host).map { |c| c.requests.last }
@@ -525,7 +548,7 @@ module Cql
           end
 
           let :result do
-            client.execute('SELECT * FROM things').get
+            client.execute('SELECT * FROM things').value
           end
 
           before do
@@ -569,7 +592,7 @@ module Cql
         context 'when there is an error creating the request' do
           it 'returns a failed future' do
             f = client.execute('SELECT * FROM stuff', :foo)
-            expect { f.get }.to raise_error(ArgumentError)
+            expect { f.value }.to raise_error(ArgumentError)
           end
         end
 
@@ -583,12 +606,12 @@ module Cql
           end
 
           it 'raises an error' do
-            expect { client.execute('SELECT * FROM things').get }.to raise_error(QueryError, 'Blurgh')
+            expect { client.execute('SELECT * FROM things').value }.to raise_error(QueryError, 'Blurgh')
           end
 
           it 'decorates the error with the CQL that caused it' do
             begin
-              client.execute('SELECT * FROM things').get
+              client.execute('SELECT * FROM things').value
             rescue QueryError => e
               e.cql.should == 'SELECT * FROM things'
             else
@@ -607,6 +630,10 @@ module Cql
           [['stuff', 'things', 'item', :varchar]]
         end
 
+        let :cql do
+          'SELECT * FROM stuff.things WHERE item = ?'
+        end
+
         before do
           handle_request do |request|
             if request.is_a?(Protocol::PrepareRequest)
@@ -616,40 +643,48 @@ module Cql
         end
 
         before do
-          client.connect.get
+          client.connect.value
         end
 
         it 'sends a prepare request' do
-          client.prepare('SELECT * FROM system.peers').get
+          client.prepare('SELECT * FROM system.peers').value
           last_request.should == Protocol::PrepareRequest.new('SELECT * FROM system.peers')
         end
 
         it 'returns a prepared statement' do
-          statement = client.prepare('SELECT * FROM stuff.things WHERE item = ?').get
+          statement = client.prepare(cql).value
           statement.should_not be_nil
         end
 
-        it 'executes a prepared statement' do
-          statement = client.prepare('SELECT * FROM stuff.things WHERE item = ?').get
-          statement.execute('foo').get
+        it 'executes a prepared statement using the default consistency level' do
+          statement = client.prepare(cql).value
+          statement.execute('foo').value
           last_request.should == Protocol::ExecuteRequest.new(id, metadata, ['foo'], :quorum)
         end
 
+        it 'executes a prepared statement using the consistency specified when the client was created' do
+          client = described_class.new(connection_options.merge(default_consistency: :all))
+          client.connect.value
+          statement = client.prepare(cql).value
+          statement.execute('foo').value
+          last_request.should == Protocol::ExecuteRequest.new(id, metadata, ['foo'], :all)
+        end
+
         it 'returns a prepared statement that knows the metadata' do
-          statement = client.prepare('SELECT * FROM stuff.things WHERE item = ?').get
+          statement = client.prepare(cql).value
           statement.metadata['item'].type == :varchar
         end
 
         it 'executes a prepared statement with a specific consistency level' do
-          statement = client.prepare('SELECT * FROM stuff.things WHERE item = ?').get
-          statement.execute('thing', :local_quorum).get
+          statement = client.prepare(cql).value
+          statement.execute('thing', :local_quorum).value
           last_request.should == Protocol::ExecuteRequest.new(id, metadata, ['thing'], :local_quorum)
         end
 
         context 'when there is an error creating the request' do
           it 'returns a failed future' do
             f = client.prepare(nil)
-            expect { f.get }.to raise_error(ArgumentError)
+            expect { f.value }.to raise_error(ArgumentError)
           end
         end
 
@@ -660,9 +695,28 @@ module Cql
                 Protocol::PreparedResultResponse.new(id, metadata)
               end
             end
-            statement = client.prepare('SELECT * FROM stuff.things WHERE item = ?').get
+            statement = client.prepare(cql).value
             f = statement.execute
-            expect { f.get }.to raise_error(ArgumentError)
+            expect { f.value }.to raise_error(ArgumentError)
+          end
+        end
+
+        context 'with multiple connections' do
+          let :connection_options do
+            {:hosts => %w[host1 host2], :port => 12321, :io_reactor => io_reactor, :logger => logger}
+          end
+
+          it 'prepares the statement on all connections' do
+            statement = client.prepare('SELECT * FROM stuff WHERE item = ?').value
+            started_at = Time.now
+            until connections.map { |c| c.requests.last }.all? { |r| r.is_a?(Protocol::ExecuteRequest) }
+              statement.execute('hello').value
+              raise 'Did not receive EXECUTE requests on all connections within 5s' if (Time.now - started_at) > 5
+            end
+            connections.map { |c| c.requests.last }.should == [
+              Protocol::ExecuteRequest.new(id, metadata, ['hello'], :quorum),
+              Protocol::ExecuteRequest.new(id, metadata, ['hello'], :quorum),
+            ]
           end
         end
       end
@@ -673,39 +727,39 @@ module Cql
         end
 
         it 'is not connected after #close has been called' do
-          client.connect.get
-          client.close.get
+          client.connect.value
+          client.close.value
           client.should_not be_connected
         end
 
         it 'complains when #use is called before #connect' do
-          expect { client.use('system').get }.to raise_error(NotConnectedError)
+          expect { client.use('system').value }.to raise_error(NotConnectedError)
         end
 
         it 'complains when #use is called after #close' do
-          client.connect.get
-          client.close.get
-          expect { client.use('system').get }.to raise_error(NotConnectedError)
+          client.connect.value
+          client.close.value
+          expect { client.use('system').value }.to raise_error(NotConnectedError)
         end
 
         it 'complains when #execute is called before #connect' do
-          expect { client.execute('DELETE FROM stuff WHERE id = 3').get }.to raise_error(NotConnectedError)
+          expect { client.execute('DELETE FROM stuff WHERE id = 3').value }.to raise_error(NotConnectedError)
         end
 
         it 'complains when #execute is called after #close' do
-          client.connect.get
-          client.close.get
-          expect { client.execute('DELETE FROM stuff WHERE id = 3').get }.to raise_error(NotConnectedError)
+          client.connect.value
+          client.close.value
+          expect { client.execute('DELETE FROM stuff WHERE id = 3').value }.to raise_error(NotConnectedError)
         end
 
         it 'complains when #prepare is called before #connect' do
-          expect { client.prepare('DELETE FROM stuff WHERE id = 3').get }.to raise_error(NotConnectedError)
+          expect { client.prepare('DELETE FROM stuff WHERE id = 3').value }.to raise_error(NotConnectedError)
         end
 
         it 'complains when #prepare is called after #close' do
-          client.connect.get
-          client.close.get
-          expect { client.prepare('DELETE FROM stuff WHERE id = 3').get }.to raise_error(NotConnectedError)
+          client.connect.value
+          client.close.value
+          expect { client.prepare('DELETE FROM stuff WHERE id = 3').value }.to raise_error(NotConnectedError)
         end
 
         it 'complains when #execute of a prepared statement is called after #close' do
@@ -714,10 +768,149 @@ module Cql
               Protocol::PreparedResultResponse.new('A' * 32, [])
             end
           end
-          client.connect.get
-          statement = client.prepare('DELETE FROM stuff WHERE id = 3').get
-          client.close.get
-          expect { statement.execute.get }.to raise_error(NotConnectedError)
+          client.connect.value
+          statement = client.prepare('DELETE FROM stuff WHERE id = 3').value
+          client.close.value
+          expect { statement.execute.value }.to raise_error(NotConnectedError)
+        end
+      end
+
+      context 'when nodes go down' do
+        include_context 'peer discovery setup'
+
+        let :connection_options do
+          {:hosts => %w[host1 host2 host3], :port => 12321, :io_reactor => io_reactor}
+        end
+
+        before do
+          client.connect.value
+        end
+
+        it 'clears out old connections and don\'t reuse them for future requests' do
+          connections.first.close
+          expect { 10.times { client.execute('SELECT * FROM something').value } }.to_not raise_error
+        end
+
+        it 'raises NotConnectedError when all nodes are down' do
+          connections.each(&:close)
+          expect { client.execute('SELECT * FROM something').value }.to raise_error(NotConnectedError)
+        end
+
+        it 'reconnects when it receives a status change UP event' do
+          connections.first.close
+          event = Protocol::StatusChangeEventResponse.new('UP', IPAddr.new('1.1.1.1'), 9999)
+          connections.select(&:has_event_listener?).first.trigger_event(event)
+          connections.select(&:connected?).should have(3).items
+        end
+
+        it 'eventually reconnects even when the node doesn\'t respond at first' do
+          timer_promise = Promise.new
+          io_reactor.stub(:schedule_timer).and_return(timer_promise.future)
+          additional_nodes.each { |host| io_reactor.node_down(host.to_s) }
+          connections.first.close
+          event = Protocol::StatusChangeEventResponse.new('UP', IPAddr.new('1.1.1.1'), 9999)
+          connections.select(&:has_event_listener?).first.trigger_event(event)
+          connections.select(&:connected?).should have(2).items
+          additional_nodes.each { |host| io_reactor.node_up(host.to_s) }
+          timer_promise.fulfill
+          connections.select(&:connected?).should have(3).items
+        end
+
+        it 'connects when it receives a topology change UP event' do
+          min_peers[0] = 3
+          event = Protocol::TopologyChangeEventResponse.new('UP', IPAddr.new('1.1.1.1'), 9999)
+          connections.select(&:has_event_listener?).first.trigger_event(event)
+          connections.select(&:connected?).should have(4).items
+        end
+
+        it 'registers a new event listener when the current event listening connection closes' do
+          connections.select(&:has_event_listener?).should have(1).item
+          connections.select(&:has_event_listener?).first.close
+          connections.select(&:connected?).select(&:has_event_listener?).should have(1).item
+        end
+      end
+
+      context 'with logging' do
+        include_context 'peer discovery setup'
+
+        it 'logs when connecting to a node' do
+          logger.stub(:debug)
+          client.connect.value
+          logger.should have_received(:debug).with(/Connecting to node at example\.com:12321/)
+        end
+
+        it 'logs when a node is connected' do
+          logger.stub(:info)
+          client.connect.value
+          logger.should have_received(:info).with(/Connected to node .{36} at example\.com:12321 in data center dc1/)
+        end
+
+        it 'logs when all nodes are connected' do
+          logger.stub(:info)
+          client.connect.value
+          logger.should have_received(:info).with(/Cluster connection complete/)
+        end
+
+        it 'logs when the connection fails' do
+          logger.stub(:error)
+          io_reactor.stub(:connect).and_return(Future.failed(StandardError.new('Hurgh blurgh')))
+          client.connect.value rescue nil
+          logger.should have_received(:error).with(/Failed connecting to cluster: Hurgh blurgh/)
+        end
+
+        it 'logs when a single connection fails' do
+          logger.stub(:warn)
+          io_reactor.stub(:connect).and_return(Future.failed(StandardError.new('Hurgh blurgh')))
+          client.connect.value rescue nil
+          logger.should have_received(:warn).with(/Failed connecting to node at example\.com:12321: Hurgh blurgh/)
+        end
+
+        it 'logs when a connection fails' do
+          logger.stub(:warn)
+          client.connect.value
+          connections.sample.close
+          logger.should have_received(:warn).with(/Connection to node .{36} at .+:\d+ in data center .+ unexpectedly closed/)
+        end
+
+        it 'logs when it does a peer discovery' do
+          logger.stub(:debug)
+          client.connect.value
+          logger.should have_received(:debug).with(/Looking for additional nodes/)
+          logger.should have_received(:debug).with(/\d+ additional nodes found/)
+        end
+
+        it 'logs when it receives an UP event' do
+          logger.stub(:debug)
+          client.connect.value
+          event = Protocol::StatusChangeEventResponse.new('UP', IPAddr.new('1.1.1.1'), 9999)
+          connections.select(&:has_event_listener?).first.trigger_event(event)
+          logger.should have_received(:debug).with(/Received UP event/)
+        end
+
+        it 'logs when it fails with a connect after an UP event' do
+          logger.stub(:debug)
+          logger.stub(:warn)
+          additional_nodes.each { |host| io_reactor.node_down(host.to_s) }
+          client.connect.value
+          event = Protocol::StatusChangeEventResponse.new('UP', IPAddr.new('1.1.1.1'), 9999)
+          connections.select(&:has_event_listener?).first.trigger_event(event)
+          logger.should have_received(:warn).with(/Failed connecting to node/).at_least(1).times
+          logger.should have_received(:debug).with(/Scheduling new peer discovery in \d+s/)
+        end
+
+        it 'logs when it disconnects' do
+          logger.stub(:info)
+          client.connect.value
+          client.close.value
+          logger.should have_received(:info).with(/Cluster disconnect complete/)
+        end
+
+        it 'logs when it fails to disconnect' do
+          logger.stub(:error)
+          client.connect.value
+          io_reactor.stub(:stop).and_return(Future.failed(StandardError.new('Hurgh blurgh')))
+          client.close.value rescue nil
+          logger.should have_received(:error).with(/Cluster disconnect failed: Hurgh blurgh/)
         end
       end
     end