cql-rb 1.1.0.pre0 → 1.1.0.pre1

data/lib/cql/io/connection.rb

@@ -8,6 +8,7 @@ module Cql
     # A wrapper around a socket. Handles connecting to the remote host, reading
     # from and writing to the socket.
     #
+    # @private
     class Connection
       attr_reader :host, :port, :connection_timeout
 

data/lib/cql/io/io_reactor.rb

@@ -78,6 +78,8 @@ module Cql
     # protocol is implemented, and there is an integration tests that implements
     # the Redis protocol that you can look at too.
     #
+    # @private
+    #
     class IoReactor
       # Initializes a new IO reactor.
       #

data/lib/cql/protocol/cql_protocol_handler.rb

@@ -10,7 +10,7 @@ module Cql
     #
     # Instances of this class are thread safe.
     #
-    # @examle Sending an OPTIONS request
+    # @example Sending an OPTIONS request
     #   future = protocol_handler.send_request(Cql::Protocol::OptionsRequest.new)
     #   response = future.get
     #   puts "These options are supported: #{response.options}"
@@ -29,11 +29,26 @@ module Cql
         @request_queue_in = []
         @request_queue_out = []
         @event_listeners = []
+        @data = {}
         @lock = Mutex.new
         @closed_future = Future.new
         @keyspace = nil
       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
+      # connection this protocol handler wraps.
+      def []=(key, value)
+        @lock.synchronize { @data[key] = value }
+      end
+
+      # @see {#[]=}
+      # @return the value associated with the key
+      def [](key)
+        @lock.synchronize { @data[key] }
+      end
+
       # @return [true, false] true if the underlying connection is connected
       def connected?
         @connection.connected?

data/lib/cql/version.rb

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

data/spec/cql/client/asynchronous_client_spec.rb

@@ -1,7 +1,6 @@
 # encoding: utf-8
 
 require 'spec_helper'
-require 'cql/client/client_shared'
 
 
 module Cql
@@ -11,7 +10,48 @@ module Cql
         described_class.new(connection_options)
       end
 
-      include_context 'client setup'
+      let :connection_options do
+        {:host => 'example.com', :port => 12321, :io_reactor => io_reactor}
+      end
+
+      let :io_reactor do
+        FakeIoReactor.new
+      end
+
+      def connections
+        io_reactor.connections
+      end
+
+      def last_connection
+        connections.last
+      end
+
+      def requests
+        last_connection.requests
+      end
+
+      def last_request
+        requests.last
+      end
+
+      def handle_request(&handler)
+        @request_handler = handler
+      end
+
+      before do
+        io_reactor.on_connection do |connection|
+          connection.handle_request do |request|
+            response = nil
+            if @request_handler
+              response = @request_handler.call(request, connection, proc { connection.default_request_handler(request) })
+            end
+            unless response
+              response = connection.default_request_handler(request)
+            end
+            response
+          end
+        end
+      end
 
       describe '#connect' do
         it 'connects' do
@@ -25,14 +65,45 @@ module Cql
           connections.should have(1).item
         end
 
-        it 'connects to all hosts' do
-          client.close.get
-          io_reactor.stop.get
-          io_reactor.start.get
+        context 'when connecting to multiple hosts' do
+          before do
+            client.close.get
+            io_reactor.stop.get
+          end
 
-          c = described_class.new(connection_options.merge(host: 'h1.example.com,h2.example.com,h3.example.com'))
-          c.connect.get
-          connections.should have(3).items
+          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
+            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
+            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
+            connections.should have(2).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')
+            c = described_class.new(connection_options.merge(hosts: %w[h1.example.com h2.example.com h2.example.com]))
+            c.connect.get
+            connections.should have(1).items
+          end
+
+          it 'fails when all nodes are down' do
+            io_reactor.node_down('h1.example.com')
+            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)
+          end
         end
 
         it 'returns itself' do
@@ -52,7 +123,7 @@ module Cql
 
         it 'sends a startup request' do
           client.connect.get
-          last_request.should be_a(Protocol::StartupRequest)
+          requests.first.should be_a(Protocol::StartupRequest)
         end
 
         it 'sends a startup request to each connection' do
@@ -60,10 +131,10 @@ module Cql
           io_reactor.stop.get
           io_reactor.start.get
 
-          c = described_class.new(connection_options.merge(host: 'h1.example.com,h2.example.com,h3.example.com'))
+          c = described_class.new(connection_options.merge(hosts: %w[h1.example.com h2.example.com h3.example.com]))
           c.connect.get
           connections.each do |cc|
-            cc.requests.last.should be_a(Protocol::StartupRequest)
+            cc.requests.first.should be_a(Protocol::StartupRequest)
           end
         end
 
@@ -75,7 +146,8 @@ module Cql
         it 'changes to the keyspace given as an option' do
           c = described_class.new(connection_options.merge(:keyspace => 'hello_world'))
           c.connect.get
-          last_request.should == Protocol::QueryRequest.new('USE hello_world', :one)
+          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
@@ -84,6 +156,107 @@ module Cql
           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
+
+          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
+                      {'host_id' => host_id, 'data_center' => data_centers[ip], 'rpc_address' => ip}
+                    end
+                    Protocol::RowsResultResponse.new(rows, peer_metadata)
+                  end
+                end
+              end
+            end
+          end
+
+          it 'connects to the other nodes in the cluster' do
+            client.connect.get
+            connections.should have(3).items
+          end
+
+          it 'connects to the other nodes in the same data center' do
+            data_centers[additional_nodes[1]] = 'dc2'
+            client.connect.get
+            connections.should have(2).items
+          end
+
+          it 'connects to the other nodes in same data centers as the seed nodes' do
+            data_centers['host2'] = 'dc2'
+            data_centers[additional_nodes[1]] = 'dc2'
+            c = described_class.new(connection_options.merge(hosts: %w[host1 host2]))
+            c.connect.get
+            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
+            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
+            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
+            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)
@@ -102,24 +275,45 @@ module Cql
         end
 
         it 'is not connected while connecting' do
+          go = false
           io_reactor.stop.get
-          f = client.connect
-          client.should_not be_connected
-          io_reactor.start.get
-          f.get
+          io_reactor.before_startup { sleep 0.01 until go }
+          client.connect
+          begin
+            client.should_not be_connected
+          ensure
+            go = true
+          end
         end
 
         context 'when the server requests authentication' do
-          before do
-            io_reactor.on_connection do |connection|
-              connection.queue_response(Protocol::AuthenticateResponse.new('com.example.Auth'))
+          def accepting_request_handler(request, *)
+            case request
+            when Protocol::StartupRequest
+              Protocol::AuthenticateResponse.new('com.example.Auth')
+            when Protocol::CredentialsRequest
+              Protocol::ReadyResponse.new
             end
           end
 
+          def denying_request_handler(request, *)
+            case request
+            when Protocol::StartupRequest
+              Protocol::AuthenticateResponse.new('com.example.Auth')
+            when Protocol::CredentialsRequest
+              Protocol::ErrorResponse.new(256, 'No way, José')
+            end
+          end
+
+          before do
+            handle_request(&method(:accepting_request_handler))
+          end
+
           it 'sends credentials' do
             client = described_class.new(connection_options.merge(credentials: {'username' => 'foo', 'password' => 'bar'}))
             client.connect.get
-            last_request.should == Protocol::CredentialsRequest.new('username' => 'foo', 'password' => 'bar')
+            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
@@ -128,17 +322,13 @@ module Cql
           end
 
           it 'raises an error when the server responds with an error to the credentials request' do
-            io_reactor.on_connection do |connection|
-              connection.queue_response(Protocol::ErrorResponse.new(256, 'No way, José'))
-            end
+            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)
           end
 
           it 'shuts down the client when there is an authentication error' do
-            io_reactor.on_connection do |connection|
-              connection.queue_response(Protocol::ErrorResponse.new(256, 'No way, José'))
-            end
+            handle_request(&method(:denying_request_handler))
             client = described_class.new(connection_options.merge(credentials: {'username' => 'foo', 'password' => 'bar'}))
             client.connect.get rescue nil
             client.should_not be_connected
@@ -175,14 +365,13 @@ module Cql
       end
 
       describe '#use' do
-        before do
-          client.connect.get
-        end
-
         it 'executes a USE query' do
-          io_reactor.on_connection do |connection|
-            connection.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
+          handle_request do |request|
+            if request.is_a?(Protocol::QueryRequest) && request.cql == 'USE system'
+              Protocol::SetKeyspaceResultResponse.new('system')
+            end
           end
+          client.connect.get
           client.use('system').get
           last_request.should == Protocol::QueryRequest.new('USE system', :one)
         end
@@ -192,7 +381,7 @@ module Cql
           io_reactor.stop.get
           io_reactor.start.get
 
-          c = described_class.new(connection_options.merge(host: 'h1.example.com,h2.example.com,h3.example.com'))
+          c = described_class.new(connection_options.merge(hosts: %w[h1.example.com h2.example.com h3.example.com]))
           c.connect.get
 
           c.use('system').get
@@ -205,12 +394,18 @@ module Cql
         end
 
         it 'knows which keyspace it changed to' do
-          last_connection.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
+          handle_request do |request|
+            if request.is_a?(Protocol::QueryRequest) && request.cql == 'USE system'
+              Protocol::SetKeyspaceResultResponse.new('system')
+            end
+          end
+          client.connect.get
           client.use('system').get
           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)
         end
       end
@@ -232,7 +427,11 @@ module Cql
 
         context 'with a void CQL query' do
           it 'returns nil' do
-            last_connection.queue_response(Protocol::VoidResultResponse.new)
+            handle_request do |request|
+              if request.is_a?(Protocol::QueryRequest) && request.cql =~ /UPDATE/
+                Protocol::VoidResultResponse.new
+              end
+            end
             result = client.execute('UPDATE stuff SET thing = 1 WHERE id = 3').get
             result.should be_nil
           end
@@ -240,13 +439,21 @@ module Cql
 
         context 'with a USE query' do
           it 'returns nil' do
-            last_connection.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
+            handle_request do |request|
+              if request.is_a?(Protocol::QueryRequest) && request.cql == 'USE system'
+                Protocol::SetKeyspaceResultResponse.new('system')
+              end
+            end
             result = client.execute('USE system').get
             result.should be_nil
           end
 
           it 'knows which keyspace it changed to' do
-            last_connection.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
+            handle_request do |request|
+              if request.is_a?(Protocol::QueryRequest) && request.cql == 'USE system'
+                Protocol::SetKeyspaceResultResponse.new('system')
+              end
+            end
             client.execute('USE system').get
             client.keyspace.should == 'system'
           end
@@ -256,12 +463,14 @@ module Cql
             io_reactor.stop.get
             io_reactor.start.get
 
-            c = described_class.new(connection_options.merge(host: 'h1.example.com,h2.example.com,h3.example.com'))
-            c.connect.get
+            handle_request do |request, connection|
+              if request.is_a?(Protocol::QueryRequest) && request.cql == 'USE system'
+                Protocol::SetKeyspaceResultResponse.new('system')
+              end
+            end
 
-            connections.find { |c| c.host == 'h1.example.com' }.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
-            connections.find { |c| c.host == 'h2.example.com' }.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
-            connections.find { |c| c.host == 'h3.example.com' }.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
+            c = described_class.new(connection_options.merge(hosts: %w[h1.example.com h2.example.com h3.example.com]))
+            c.connect.get
 
             c.execute('USE system', :one).get
             c.keyspace.should == 'system'
@@ -285,10 +494,17 @@ module Cql
           end
 
           let :result do
-            last_connection.queue_response(Protocol::RowsResultResponse.new(rows, metadata))
             client.execute('SELECT * FROM things').get
           end
 
+          before do
+            handle_request do |request|
+              if request.is_a?(Protocol::QueryRequest) && request.cql =~ /FROM things/
+                Protocol::RowsResultResponse.new(rows, metadata)
+              end
+            end
+          end
+
           it 'returns an Enumerable of rows' do
             row_count = 0
             result.each do |row|
@@ -327,13 +543,19 @@ module Cql
         end
 
         context 'when the response is an error' do
+          before do
+            handle_request do |request|
+              if request.is_a?(Protocol::QueryRequest) && request.cql =~ /FROM things/
+                Protocol::ErrorResponse.new(0xabcd, 'Blurgh')
+              end
+            end
+          end
+
           it 'raises an error' do
-            last_connection.queue_response(Protocol::ErrorResponse.new(0xabcd, 'Blurgh'))
             expect { client.execute('SELECT * FROM things').get }.to raise_error(QueryError, 'Blurgh')
           end
 
           it 'decorates the error with the CQL that caused it' do
-            last_connection.queue_response(Protocol::ErrorResponse.new(0xabcd, 'Blurgh'))
             begin
               client.execute('SELECT * FROM things').get
             rescue QueryError => e
@@ -354,6 +576,14 @@ module Cql
           [['stuff', 'things', 'item', :varchar]]
         end
 
+        before do
+          handle_request do |request|
+            if request.is_a?(Protocol::PrepareRequest)
+              Protocol::PreparedResultResponse.new(id, metadata)
+            end
+          end
+        end
+
         before do
           client.connect.get
         end
@@ -364,26 +594,22 @@ module Cql
         end
 
         it 'returns a prepared statement' do
-          last_connection.queue_response(Protocol::PreparedResultResponse.new('A' * 32, [['stuff', 'things', 'item', :varchar]]))
           statement = client.prepare('SELECT * FROM stuff.things WHERE item = ?').get
           statement.should_not be_nil
         end
 
         it 'executes a prepared statement' do
-          last_connection.queue_response(Protocol::PreparedResultResponse.new(id, metadata))
           statement = client.prepare('SELECT * FROM stuff.things WHERE item = ?').get
           statement.execute('foo').get
           last_request.should == Protocol::ExecuteRequest.new(id, metadata, ['foo'], :quorum)
         end
 
         it 'returns a prepared statement that knows the metadata' do
-          last_connection.queue_response(Protocol::PreparedResultResponse.new(id, metadata))
           statement = client.prepare('SELECT * FROM stuff.things WHERE item = ?').get
           statement.metadata['item'].type == :varchar
         end
 
         it 'executes a prepared statement with a specific consistency level' do
-          last_connection.queue_response(Protocol::PreparedResultResponse.new(id, metadata))
           statement = client.prepare('SELECT * FROM stuff.things WHERE item = ?').get
           statement.execute('thing', :local_quorum).get
           last_request.should == Protocol::ExecuteRequest.new(id, metadata, ['thing'], :local_quorum)
@@ -398,7 +624,11 @@ module Cql
 
         context 'when there is an error preparing the request' do
           it 'returns a failed future' do
-            last_connection.queue_response(Protocol::PreparedResultResponse.new(id, metadata))
+            handle_request do |request|
+              if request.is_a?(Protocol::PrepareRequest)
+                Protocol::PreparedResultResponse.new(id, metadata)
+              end
+            end
             statement = client.prepare('SELECT * FROM stuff.things WHERE item = ?').get
             f = statement.execute
             expect { f.get }.to raise_error(ArgumentError)
@@ -448,8 +678,12 @@ module Cql
         end
 
         it 'complains when #execute of a prepared statement is called after #close' do
+          handle_request do |request|
+            if request.is_a?(Protocol::PrepareRequest)
+              Protocol::PreparedResultResponse.new('A' * 32, [])
+            end
+          end
           client.connect.get
-          last_connection.queue_response(Protocol::PreparedResultResponse.new('A' * 32, []))
           statement = client.prepare('DELETE FROM stuff WHERE id = 3').get
           client.close.get
           expect { statement.execute.get }.to raise_error(NotConnectedError)