cql-rb 1.1.0.pre6 → 1.1.0.pre7

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    N2VjM2JjM2ZiNjU3MTkzOTk4MTU2MjUyMWViZWIwYTExMjc4MTQ0MA==
+  data.tar.gz: !binary |-
+    OWQ2NWYxY2UwN2YxNjM0NmYxZmRlMmViMmI3OGJlMDdmZTE2NDY3Zg==
+SHA512:
+  metadata.gz: !binary |-
+    OTZkNmMzNjk5MDRhODdjZmNkMzljZDMxMzA2ZWQ1MWFjM2EyNWI3NmZmMjI2
+    OWZlMzY3NTczOTZiYzY2YmQ2ZWFmZWQ0ZTM1M2NjODBkOTI0MzMwODc2YmEx
+    OTBhNzdiZWNjYWY0YzA4NTQyNzc2NThhNTY2ZWM1ZDFmYmRjMDg=
+  data.tar.gz: !binary |-
+    NGM4NmMyZDRhOTE3MTg4NmNjOGFmYmZhNmU5MWRiMTkzOWM4NzhlYzE2YTRk
+    ZGFmODJmMGNiMGRlNjFmZTNhMTZhYjdmYzhmOTMwNmQwOWFjMDc5NTk5Y2Jj
+    OTRiYWVkMWY2ZTYxMzUxMmRiODY4ZGQ5MzE3NWRkYzk5MTVlMGU=

data/lib/cql/client.rb

@@ -12,6 +12,7 @@ module Cql
   end
 
   NotConnectedError = Class.new(CqlError)
+  TimeoutError = Class.new(CqlError)
   ClientError = Class.new(CqlError)
   AuthenticationError = Class.new(ClientError)
 
@@ -171,6 +172,7 @@ require 'cql/client/null_logger'
 require 'cql/client/column_metadata'
 require 'cql/client/result_metadata'
 require 'cql/client/query_result'
+require 'cql/client/execute_options_decoder'
 require 'cql/client/keyspace_changer'
 require 'cql/client/asynchronous_client'
 require 'cql/client/asynchronous_prepared_statement'

data/lib/cql/client/asynchronous_client.rb

@@ -9,7 +9,6 @@ module Cql
         @io_reactor = options[:io_reactor] || Io::IoReactor.new(Protocol::CqlProtocolHandler)
         @hosts = extract_hosts(options)
         @initial_keyspace = options[:keyspace]
-        @default_consistency = options[:default_consistency] || DEFAULT_CONSISTENCY
         @lock = Mutex.new
         @connected = false
         @connecting = false
@@ -19,8 +18,11 @@ module Cql
         @connection_manager = ConnectionManager.new
         port = options[:port] || DEFAULT_PORT
         credentials = options[:credentials]
+        connections_per_node = options[:connections_per_node] || 1
         connection_timeout = options[:connection_timeout] || DEFAULT_CONNECTION_TIMEOUT
-        @connection_helper = ConnectionHelper.new(@io_reactor, port, credentials, connection_timeout, @logger)
+        default_consistency = options[:default_consistency] || DEFAULT_CONSISTENCY
+        @execute_options_decoder = ExecuteOptionsDecoder.new(default_consistency)
+        @connection_helper = ConnectionHelper.new(@io_reactor, port, credentials, connections_per_node, connection_timeout, @logger)
       end
 
       def connect
@@ -87,15 +89,16 @@ module Cql
         end
       end
 
-      def execute(cql, consistency=nil)
+      def execute(cql, options_or_consistency=nil)
         with_failure_handler do
-          execute_request(Protocol::QueryRequest.new(cql, consistency || @default_consistency))
+          consistency, timeout = @execute_options_decoder.decode_options(options_or_consistency)
+          execute_request(Protocol::QueryRequest.new(cql, consistency), timeout)
         end
       end
 
       def prepare(cql)
         with_failure_handler do
-          AsynchronousPreparedStatement.prepare(cql, @default_consistency, @connection_manager, @logger)
+          AsynchronousPreparedStatement.prepare(cql, @execute_options_decoder, @connection_manager, @logger)
         end
       end
 
@@ -161,7 +164,7 @@ module Cql
 
       def register_event_listener(connection)
         register_request = Protocol::RegisterRequest.new(Protocol::TopologyChangeEventResponse::TYPE, Protocol::StatusChangeEventResponse::TYPE)
-        execute_request(register_request, connection)
+        execute_request(register_request, nil, connection)
         connection.on_closed do
           if connected?
             begin
@@ -198,8 +201,8 @@ module Cql
         end
       end
 
-      def execute_request(request, connection=nil)
-        f = @request_runner.execute(connection || @connection_manager.random_connection, request)
+      def execute_request(request, timeout=nil, connection=nil)
+        f = @request_runner.execute(connection || @connection_manager.random_connection, request, timeout)
         f.map do |result|
           if result.is_a?(KeyspaceChanged)
             use(result.keyspace)

data/lib/cql/client/asynchronous_prepared_statement.rb

@@ -5,16 +5,16 @@ module Cql
     # @private
     class AsynchronousPreparedStatement < PreparedStatement
       # @private
-      def initialize(cql, default_consistency, connection_manager, logger)
+      def initialize(cql, execute_options_decoder, connection_manager, logger)
         @cql = cql
-        @default_consistency = default_consistency
+        @execute_options_decoder = execute_options_decoder
         @connection_manager = connection_manager
         @logger = logger
         @request_runner = RequestRunner.new
       end
 
-      def self.prepare(cql, default_consistency, connection_manager, logger)
-        statement = new(cql, default_consistency, connection_manager, logger)
+      def self.prepare(cql, execute_options_decoder, connection_manager, logger)
+        statement = new(cql, execute_options_decoder, connection_manager, logger)
         futures = connection_manager.map do |connection|
           statement.prepare(connection)
         end
@@ -57,10 +57,13 @@ module Cql
       def run(args, connection)
         statement_id = connection[self]
         bound_args = args.shift(@raw_metadata.size)
-        consistency = args.shift || @default_consistency
+        unless bound_args.size == @raw_metadata.size && args.size <= 1
+          raise ArgumentError, "Expected #{@raw_metadata.size} arguments, got #{bound_args.size}"
+        end
+        consistency, timeout = @execute_options_decoder.decode_options(args.last)
         statement_id = connection[self]
         request = Protocol::ExecuteRequest.new(statement_id, @raw_metadata, bound_args, consistency)
-        @request_runner.execute(connection, request)
+        @request_runner.execute(connection, request, timeout)
       end
     end
   end

data/lib/cql/client/connection_helper.rb

@@ -4,10 +4,11 @@ module Cql
   module Client
     # @private
     class ConnectionHelper
-      def initialize(io_reactor, port, credentials, connection_timeout, logger)
+      def initialize(io_reactor, port, credentials, connections_per_node, connection_timeout, logger)
         @io_reactor = io_reactor
         @port = port
         @credentials = credentials
+        @connections_per_node = connections_per_node
         @connection_timeout = connection_timeout
         @logger = logger
         @request_runner = RequestRunner.new
@@ -67,9 +68,11 @@ module Cql
       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)
+        connection_futures = hosts.flat_map do |host|
+          Array.new(@connections_per_node) do
+            connect_to_host(host, initial_keyspace).recover do |error|
+              FailedConnection.new(error, host, @port)
+            end
           end
         end
         connection_futures.each do |cf|

data/lib/cql/client/execute_options_decoder.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module Cql
+  module Client
+    class ExecuteOptionsDecoder
+      def initialize(default_consistency)
+        @default_consistency = default_consistency
+      end
+
+      def decode_options(options_or_consistency)
+        consistency = @default_consistency
+        timeout = nil
+        case options_or_consistency
+        when Symbol
+          consistency = options_or_consistency
+        when Hash
+          consistency = options_or_consistency[:consistency] || consistency
+          timeout = options_or_consistency[:timeout]
+        end
+        return consistency, timeout
+      end
+    end
+  end
+end

data/lib/cql/client/request_runner.rb

@@ -4,8 +4,8 @@ module Cql
   module Client
     # @private
     class RequestRunner
-      def execute(connection, request)
-        connection.send_request(request).map do |response|
+      def execute(connection, request, timeout=nil)
+        connection.send_request(request, timeout).map do |response|
           case response
           when Protocol::RowsResultResponse
             QueryResult.new(response.metadata, response.rows)

data/lib/cql/io/io_reactor.rb

@@ -32,7 +32,7 @@ module Cql
     # @example A protocol handler that processes whole lines
     #
     #   class LineProtocolHandler
-    #     def initialize(connection)
+    #     def initialize(connection, scheduler)
     #       @connection = connection
     #       # register a listener method for new data, this must be done in the
     #       # in the constructor, and only one listener can be registered
@@ -184,7 +184,7 @@ module Cql
       def connect(host, port, timeout)
         connection = Connection.new(host, port, timeout, @unblocker, @clock)
         f = connection.connect
-        protocol_handler = @protocol_handler_factory.new(connection)
+        protocol_handler = @protocol_handler_factory.new(connection, self)
         @io_loop.add_socket(connection)
         @unblocker.unblock!
         f.map { protocol_handler }

data/lib/cql/protocol/cql_protocol_handler.rb

@@ -19,8 +19,9 @@ module Cql
       # @return [String] the current keyspace for the underlying connection
       attr_reader :keyspace
 
-      def initialize(connection)
+      def initialize(connection, scheduler)
         @connection = connection
+        @scheduler = scheduler
         @connection.on_data(&method(:receive_data))
         @connection.on_closed(&method(:socket_closed))
         @promises = Array.new(128) { nil }
@@ -98,11 +99,19 @@ module Cql
       #
       # Returns a future that will resolve to the response. When the connection
       # closes the futures of all active requests will be failed with the error
-      # that caused the connection to close, or nil
+      # that caused the connection to close, or nil.
       #
+      # When `timeout` is specified the future will fail with {Cql::TimeoutError}
+      # after that many seconds have passed. If a response arrives after that
+      # time it will be lost. If a response never arrives for the request the
+      # channel occupied by the request will _not_ be reused.
+      #
+      # @param [Cql::Protocol::Request] request
+      # @param [Float] timeout an optional number of seconds to wait until
+      #   failing the request
       # @return [Cql::Future<Cql::Protocol::Response>] a future that resolves to
       #   the response
-      def send_request(request)
+      def send_request(request, timeout=nil)
         return Future.failed(NotConnectedError.new) if closed?
         promise = RequestPromise.new(request)
         id = nil
@@ -121,6 +130,11 @@ module Cql
             @request_queue_in << promise
           end
         end
+        if timeout
+          @scheduler.schedule_timer(timeout).on_value do
+            promise.time_out!
+          end
+        end
         promise.future
       end
 
@@ -140,9 +154,21 @@ module Cql
 
         def initialize(request)
           @request = request
+          @timed_out = false
           super()
         end
 
+        def timed_out?
+          @timed_out
+        end
+
+        def time_out!
+          unless future.completed?
+            @timed_out = true
+            fail(TimeoutError.new)
+          end
+        end
+
         def encode_frame!
           @frame = @request.encode_frame(0)
         end
@@ -182,7 +208,9 @@ module Cql
         if response.is_a?(Protocol::SetKeyspaceResultResponse)
           @keyspace = response.keyspace
         end
-        promise.fulfill(response)
+        unless promise.timed_out?
+          promise.fulfill(response)
+        end
       end
 
       def flush_request_queue
@@ -198,8 +226,12 @@ module Cql
           @lock.synchronize do
             if @request_queue_out.any? && (id = next_stream_id)
               promise = @request_queue_out.shift
-              frame = promise.frame
-              @promises[id] = promise
+              if promise.timed_out?
+                id = nil
+              else
+                frame = promise.frame
+                @promises[id] = promise
+              end
             end
           end
           if id

data/lib/cql/version.rb

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

data/spec/cql/client/asynchronous_client_spec.rb

@@ -44,10 +44,10 @@ module Cql
 
       before do
         io_reactor.on_connection do |connection|
-          connection.handle_request do |request|
+          connection.handle_request do |request, timeout|
             response = nil
             if @request_handler
-              response = @request_handler.call(request, connection, proc { connection.default_request_handler(request) })
+              response = @request_handler.call(request, connection, proc { connection.default_request_handler(request) }, timeout)
             end
             unless response
               response = connection.default_request_handler(request)
@@ -170,6 +170,12 @@ module Cql
             connections.should have(2).items
           end
 
+          it 'connects to each host the specifie number of times' do
+            c = described_class.new(connection_options.merge(hosts: %w[h1.example.com h2.example.com], connections_per_node: 3))
+            c.connect.value
+            connections.should have(6).items
+          end
+
           it 'succeeds even if only one of the connections succeeded' do
             io_reactor.node_down('h1.example.com')
             io_reactor.node_down('h3.example.com')
@@ -474,11 +480,16 @@ module Cql
           last_request.should == Protocol::QueryRequest.new(cql, :all)
         end
 
-        it 'uses the specified consistency' do
+        it 'uses the consistency given as last argument' do
           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
 
+        it 'uses the consistency given as an option' do
+          client.execute('UPDATE stuff SET thing = 1 WHERE id = 3', consistency: :local_quorum).value
+          last_request.should == Protocol::QueryRequest.new('UPDATE stuff SET thing = 1 WHERE id = 3', :local_quorum)
+        end
+
         context 'with a void CQL query' do
           it 'returns nil' do
             handle_request do |request|
@@ -619,6 +630,18 @@ module Cql
             end
           end
         end
+
+        context 'with a timeout' do
+          it 'passes the timeout along with the request' do
+            sent_timeout = nil
+            handle_request do |request, _, _, timeout|
+              sent_timeout = timeout
+              nil
+            end
+            client.execute(cql, timeout: 3).value
+            sent_timeout.should == 3
+          end
+        end
       end
 
       describe '#prepare' do

data/spec/cql/client/asynchronous_prepared_statement_spec.rb

@@ -41,7 +41,7 @@ module Cql
         ]
       end
 
-      def handle_request(connection, request)
+      def handle_request(connection, request, timeout)
         case request
         when Protocol::PrepareRequest
           statement_id = [rand(2**31)].pack('c*')
@@ -56,14 +56,14 @@ module Cql
 
       before do
         connections.each do |c|
-          c.handle_request { |r| handle_request(c, r) }
+          c.handle_request { |r, t| handle_request(c, r, t) }
         end
         connection_manager.add_connections(connections)
       end
 
       describe '.prepare' do
         it 'prepares a statement on all connections' do
-          f = described_class.prepare(cql, :one, connection_manager, logger)
+          f = described_class.prepare(cql, ExecuteOptionsDecoder.new(:one), connection_manager, logger)
           f.value
           connections.each do |c|
             c.requests.should include(Protocol::PrepareRequest.new(cql))
@@ -71,13 +71,13 @@ module Cql
         end
 
         it 'returns a prepared statement object' do
-          f = described_class.prepare(cql, :two, connection_manager, logger)
+          f = described_class.prepare(cql, ExecuteOptionsDecoder.new(:two), connection_manager, logger)
           f.value.should be_a(PreparedStatement)
         end
 
         it 'returns a failed future when something goes wrong in the preparation' do
           connections.each(&:close)
-          f = described_class.prepare(cql, :three, connection_manager, logger)
+          f = described_class.prepare(cql, ExecuteOptionsDecoder.new(:three), connection_manager, logger)
           expect { f.value }.to raise_error(NotConnectedError)
         end
 
@@ -92,7 +92,7 @@ module Cql
 
       describe '#metadata' do
         let :statement do
-          described_class.prepare(cql, :all, connection_manager, logger).value
+          described_class.prepare(cql, ExecuteOptionsDecoder.new(:all), connection_manager, logger).value
         end
 
         it 'returns the interpreted metadata' do
@@ -103,7 +103,7 @@ module Cql
 
       describe '#execute' do
         let :statement do
-          described_class.prepare(cql, :local_quorum, connection_manager, logger).value
+          described_class.prepare(cql, ExecuteOptionsDecoder.new(:local_quorum), connection_manager, logger).value
         end
 
         it 'executes itself on one of the connections' do
@@ -132,6 +132,24 @@ module Cql
           request.consistency.should == :two
         end
 
+        it 'sends the consistency given as an option' do
+          statement.execute(11, 'hello', consistency: :two)
+          request = connections.flat_map(&:requests).find { |r| r.is_a?(Protocol::ExecuteRequest) }
+          request.consistency.should == :two
+        end
+
+        it 'uses the specified timeout' do
+          sent_timeout = nil
+          connections.each do |c|
+            c.handle_request do |r, t|
+              sent_timeout = t
+              handle_request(c, r, t)
+            end
+          end
+          statement.execute(11, 'hello', timeout: 3)
+          sent_timeout.should == 3
+        end
+
         context 'when it receives a new connection from the connection manager' do
           let :new_connection do
             FakeConnection.new('h3.example.com', 1234, 5)
@@ -139,7 +157,7 @@ module Cql
 
           before do
             statement
-            new_connection.handle_request { |r| handle_request(new_connection, r) }
+            new_connection.handle_request { |r, t| handle_request(new_connection, r, t) }
             connections.each(&:close)
             connection_manager.add_connections([new_connection])
           end
@@ -169,8 +187,8 @@ module Cql
         it 'returns a failed future when the number of arguments is wrong' do
           f1 = statement.execute(11, :one)
           f2 = statement.execute(11, 'foo', 22, :one)
-          expect { f1.value }.to raise_error
-          expect { f2.value }.to raise_error
+          expect { f1.value }.to raise_error(NoMethodError)
+          expect { f2.value }.to raise_error(ArgumentError)
         end
       end
     end

data/spec/cql/client/connection_helper_spec.rb

@@ -7,7 +7,7 @@ module Cql
   module Client
     describe ConnectionHelper do
       let :connection_helper do
-        described_class.new(io_reactor, 9876, nil, 7, logger)
+        described_class.new(io_reactor, 9876, nil, 1, 7, logger)
       end
 
       let :io_reactor do
@@ -114,7 +114,7 @@ module Cql
 
         it 'authenticates when authentication is required and credentials were specified' do
           credentials = {'username' => 'foo', 'password' => 'bar'}
-          connection_helper = described_class.new(io_reactor, 9876, credentials, 7, logger)
+          connection_helper = described_class.new(io_reactor, 9876, credentials, 1, 7, logger)
           connection = FakeConnection.new('host0', 9876, 7)
           authentication_sent = false
           connection.handle_request do |request|
@@ -178,6 +178,13 @@ module Cql
           connection_helper.connect(hosts, 'some_keyspace')
           connection_helper.should have_received(:discover_peers).with([connection], 'some_keyspace')
         end
+
+        it 'connects to each node a configurable number of times' do
+          connection_helper = described_class.new(io_reactor, 9876, nil, connections_per_node = 3, 7, logger)
+          connection_helper.connect(hosts, nil)
+          io_reactor.should have_received(:connect).with('host0', 9876, 7).exactly(3).times
+          io_reactor.should have_received(:connect).with('host1', 9876, 7).exactly(3).times
+        end
       end
 
       describe '#discover_peers' do
@@ -329,6 +336,15 @@ module Cql
           f = connection_helper.discover_peers(seed_connections, nil)
           f.value
         end
+
+        it 'connects to each node a configurable number of times' do
+          connection_helper = described_class.new(io_reactor, 9876, nil, connections_per_node = 3, 7, logger)
+          connection = FakeConnection.new('host3', 9876, 7)
+          io_reactor.stub(:connect).with('1.0.0.3', 9876, 7).and_return(Future.resolved(connection))
+          peer_request_response { seed_connection_rows + extra_connection_rows.take(1) }
+          connection_helper.discover_peers(seed_connections, nil).value
+          io_reactor.should have_received(:connect).with('1.0.0.3', 9876, 7).exactly(3).times
+        end
       end
     end
   end

data/spec/cql/client/keyspace_changer_spec.rb

@@ -16,13 +16,13 @@ module Cql
 
       describe '#use_keyspace' do
         it 'sends a query request with a USE statement' do
-          connection.stub(:send_request).with(Protocol::QueryRequest.new('USE important_stuff', :one)).and_return(Future.resolved)
+          connection.stub(:send_request).with(Protocol::QueryRequest.new('USE important_stuff', :one), nil).and_return(Future.resolved)
           f = keyspace_changer.use_keyspace('important_stuff', connection)
           connection.should have_received(:send_request)
         end
 
         it 'accepts quoted keyspace names' do
-          connection.stub(:send_request).with(Protocol::QueryRequest.new('USE "ImportantStuff"', :one)).and_return(Future.resolved)
+          connection.stub(:send_request).with(Protocol::QueryRequest.new('USE "ImportantStuff"', :one), nil).and_return(Future.resolved)
           f = keyspace_changer.use_keyspace('"ImportantStuff"', connection)
           connection.should have_received(:send_request)
         end
@@ -39,7 +39,7 @@ module Cql
           end
 
           it 'resolves to the given connection' do
-            connection.stub(:send_request).with(Protocol::QueryRequest.new('USE important_stuff', :one)).and_return(Future.resolved)
+            connection.stub(:send_request).with(Protocol::QueryRequest.new('USE important_stuff', :one), nil).and_return(Future.resolved)
             f = keyspace_changer.use_keyspace('important_stuff', connection)
             f.value.should equal(connection)
           end

data/spec/cql/client/request_runner_spec.rb

@@ -64,8 +64,15 @@ module Cql
         end
 
         it 'executes the request' do
-          connection.should_receive(:send_request).and_return(Future.resolved(rows_response))
+          connection.stub(:send_request).and_return(Future.resolved(rows_response))
           runner.execute(connection, request)
+          connection.should have_received(:send_request)
+        end
+
+        it 'executes the request with the specified timeout' do
+          connection.stub(:send_request).and_return(Future.resolved(rows_response))
+          runner.execute(connection, request, 7)
+          connection.should have_received(:send_request).with(request, 7)
         end
 
         it 'transforms a RowsResultResponse to a query result' do

data/spec/cql/io/io_reactor_spec.rb

@@ -79,7 +79,7 @@ module Cql
 
         it 'closes all sockets' do
           connection = nil
-          protocol_handler_factory.stub(:new) do |sh|
+          protocol_handler_factory.stub(:new) do |sh, _|
             connection = sh
             double(:protocol_handler)
           end
@@ -141,7 +141,7 @@ module Cql
         end
 
         before do
-          protocol_handler_factory.stub(:new) do |connection|
+          protocol_handler_factory.stub(:new) do |connection, _|
             connection.to_io.stub(:connect_nonblock)
             protocol_handler.stub(:connection).and_return(connection)
             protocol_handler
@@ -165,6 +165,12 @@ module Cql
           reactor.stop if reactor.running?
         end
 
+        it 'calls #new on the protocol handler factory with the connection and the reactor itself' do
+          reactor.start.value
+          reactor.connect('example.com', 9999, 5).value
+          protocol_handler_factory.should have_received(:new).with(an_instance_of(Connection), reactor)
+        end
+
         it 'returns a future that resolves to a new protocol handler' do
           reactor.start.value
           f = reactor.connect('example.com', 9999, 5)

data/spec/cql/protocol/cql_protocol_handler_spec.rb

@@ -7,13 +7,17 @@ module Cql
   module Protocol
     describe CqlProtocolHandler do
       let :protocol_handler do
-        described_class.new(connection)
+        described_class.new(connection, scheduler)
       end
 
       let :connection do
         double(:connection)
       end
 
+      let :scheduler do
+        double(:scheduler)
+      end
+
       let :request do
         Protocol::OptionsRequest.new
       end
@@ -32,6 +36,7 @@ module Cql
         connection.stub(:on_connected) do |&h|
           connection.stub(:connected_listener).and_return(h)
         end
+        scheduler.stub(:schedule_timer).and_return(Promise.new.future)
         protocol_handler
       end
 
@@ -66,7 +71,6 @@ module Cql
         before do
           connection.stub(:write).and_yield(buffer)
           connection.stub(:closed?).and_return(false)
-
           connection.stub(:connected?).and_return(true)
         end
 
@@ -151,6 +155,49 @@ module Cql
             expect { f.value }.to raise_error(NotConnectedError)
           end
         end
+
+        context 'when the request times out' do
+          let :timer_promise do
+            Promise.new
+          end
+
+          before do
+            scheduler.stub(:schedule_timer).with(3).and_return(timer_promise.future)
+          end
+
+          it 'raises a TimeoutError' do
+            f = protocol_handler.send_request(request, 3)
+            timer_promise.fulfill
+            expect { f.value }.to raise_error(TimeoutError)
+          end
+
+          it 'does not attempt to fulfill the promise when the request has already timed out' do
+            f = protocol_handler.send_request(request, 3)
+            timer_promise.fulfill
+            expect { connection.data_listener.call([0x81, 0, 0, 2, 0].pack('C4N')) }.to_not raise_error
+          end
+
+          it 'never sends a request when it has already timed out' do
+            write_count = 0
+            connection.stub(:write) do |s, &h|
+              write_count += 1
+              if h
+                h.call(buffer)
+              else
+                buffer << s
+              end
+            end
+            128.times do
+              scheduler.stub(:schedule_timer).with(5).and_return(Promise.new.future)
+              protocol_handler.send_request(request)
+            end
+            scheduler.stub(:schedule_timer).with(5).and_return(timer_promise.future)
+            f = protocol_handler.send_request(request, 5)
+            timer_promise.fulfill
+            128.times { |i| connection.data_listener.call([0x81, 0, i, 2, 0].pack('C4N')) }
+            write_count.should == 128
+          end
+        end
       end
 
       describe '#close' do

data/spec/integration/client_spec.rb

@@ -70,6 +70,7 @@ describe 'A CQL client' do
     let :multi_client do
       opts = connection_options.dup
       opts[:host] = ([opts[:host]] * 10).join(',')
+      opts[:connections_per_node] = 3
       Cql::Client.connect(opts)
     end
 

data/spec/integration/io_spec.rb

@@ -124,7 +124,7 @@ end
 
 module IoSpec
   class TestConnection
-    def initialize(connection)
+    def initialize(connection, scheduler)
       @connection = connection
       @connection.on_data(&method(:receive_data))
       @lock = Mutex.new
@@ -143,7 +143,7 @@ module IoSpec
   end
 
   class LineProtocolHandler
-    def initialize(connection)
+    def initialize(connection, scheduler)
       @connection = connection
       @connection.on_data(&method(:process_data))
       @lock = Mutex.new
@@ -176,8 +176,8 @@ module IoSpec
   end
 
   class RedisProtocolHandler
-    def initialize(connection)
-      @line_protocol = LineProtocolHandler.new(connection)
+    def initialize(connection, scheduler)
+      @line_protocol = LineProtocolHandler.new(connection, scheduler)
       @line_protocol.on_line(&method(:handle_line))
       @lock = Mutex.new
       @responses = []

data/spec/support/fake_io_reactor.rb

@@ -127,7 +127,7 @@ class FakeConnection
     @event_listeners.any? && @registered_event_types.any?
   end
 
-  def send_request(request)
+  def send_request(request, timeout=nil)
     if @closed
       Cql::Future.failed(Cql::NotConnectedError.new)
     else
@@ -136,7 +136,7 @@ class FakeConnection
       when Cql::Protocol::RegisterRequest
         @registered_event_types.concat(request.events)
       end
-      response = @request_handler.call(request)
+      response = @request_handler.call(request, timeout)
       if response.is_a?(Cql::Protocol::SetKeyspaceResultResponse)
         @keyspace = response.keyspace
       end
@@ -144,7 +144,7 @@ class FakeConnection
     end
   end
 
-  def default_request_handler(request)
+  def default_request_handler(request, timeout=nil)
     response = @responses.shift
     unless response
       case request

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cql-rb
 version: !ruby/object:Gem::Version
-  version: 1.1.0.pre6
-  prerelease: 6
+  version: 1.1.0.pre7
 platform: ruby
 authors:
 - Theo Hultberg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-01 00:00:00.000000000 Z
+date: 2013-10-07 00:00:00.000000000 Z
 dependencies: []
 description: A pure Ruby CQL3 driver for Cassandra
 email:
@@ -24,6 +23,7 @@ files:
 - lib/cql/client/column_metadata.rb
 - lib/cql/client/connection_helper.rb
 - lib/cql/client/connection_manager.rb
+- lib/cql/client/execute_options_decoder.rb
 - lib/cql/client/keyspace_changer.rb
 - lib/cql/client/null_logger.rb
 - lib/cql/client/query_result.rb
@@ -114,27 +114,26 @@ files:
 homepage: http://github.com/iconara/cql-rb
 licenses:
 - Apache License 2.0
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>'
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.1.5
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Cassandra CQL3 driver
 test_files:
 - spec/cql/byte_buffer_spec.rb