cql-rb 1.0.0.pre4 → 1.0.0.pre5

data/lib/cql/io/node_connection.rb

@@ -0,0 +1,206 @@
+# encoding: utf-8
+
+require 'socket'
+require 'resolv-replace'
+
+
+module Cql
+  module Io
+    # @private
+    class NodeConnection
+      def initialize(*args)
+        @host, @port, @connection_timeout = args
+        @connected_future = Future.new
+        @io = nil
+        @addrinfo = nil
+        @write_buffer = ''
+        @read_buffer = ''
+        @current_frame = Protocol::ResponseFrame.new(@read_buffer)
+        @response_tasks = [nil] * 128
+        @event_listeners = Hash.new { |h, k| h[k] = [] }
+      end
+
+      def open
+        @connection_started_at = Time.now
+        begin
+          addrinfo = Socket.getaddrinfo(@host, @port, Socket::AF_INET, Socket::SOCK_STREAM)
+          _, port, _, ip, address_family, socket_type = addrinfo.first
+          @sockaddr = Socket.sockaddr_in(port, ip)
+          @io = Socket.new(address_family, socket_type, 0)
+          @io.connect_nonblock(@sockaddr)
+        rescue Errno::EINPROGRESS
+          # ok
+        rescue SystemCallError, SocketError => e
+          fail_connection!(e)
+        end
+        @connected_future
+      end
+
+      def connection_id
+        self.object_id
+      end
+
+      def to_io
+        @io
+      end
+
+      def on_event(&listener)
+        @event_listeners[:event] << listener
+      end
+
+      def on_close(&listener)
+        @event_listeners[:close] << listener
+      end
+
+      def connected?
+        @io && !connecting?
+      end
+
+      def connecting?
+        @io && !(@connected_future.complete? || @connected_future.failed?)
+      end
+
+      def closed?
+        @io.nil? && !connecting?
+      end
+
+      def has_capacity?
+        !!next_stream_id && connected?
+      end
+
+      def can_write?
+        @io && (!@write_buffer.empty? || connecting?)
+      end
+
+      def perform_request(request, future)
+        stream_id = next_stream_id
+        Protocol::RequestFrame.new(request, stream_id).write(@write_buffer)
+        @response_tasks[stream_id] = future
+      rescue => e
+        case e
+        when CqlError
+          error = e
+        else
+          error = IoError.new(e.message)
+          error.set_backtrace(e.backtrace)
+        end
+        @response_tasks.delete(stream_id)
+        future.fail!(error)
+      end
+
+      def handle_read
+        new_bytes = @io.read_nonblock(2**16)
+        @current_frame << new_bytes
+        while @current_frame.complete?
+          stream_id = @current_frame.stream_id
+          if stream_id == EVENT_STREAM_ID
+            @event_listeners[:event].each { |listener| listener.call(@current_frame.body) }
+          elsif @response_tasks[stream_id]
+            @response_tasks[stream_id].complete!([@current_frame.body, connection_id])
+            @response_tasks[stream_id] = nil
+          else
+            # TODO dropping the request on the floor here, but we didn't send it
+          end
+          @current_frame = Protocol::ResponseFrame.new(@read_buffer)
+        end
+      rescue => e
+        force_close(e)
+      end
+
+      def handle_write
+        succeed_connection! if connecting?
+        if !@write_buffer.empty?
+          bytes_written = @io.write_nonblock(@write_buffer)
+          @write_buffer.slice!(0, bytes_written)
+        end
+      rescue => e
+        force_close(e)
+      end
+
+      def handle_connecting
+        if connecting_timed_out?
+          fail_connection!(ConnectionTimeoutError.new("Could not connect to #{@host}:#{@port} within #{@connection_timeout}s"))
+        else
+          @io.connect_nonblock(@sockaddr)
+          succeed_connection!
+        end
+      rescue Errno::EISCONN
+        # ok
+        succeed_connection!
+      rescue SystemCallError, SocketError => e
+        fail_connection!(e)
+      end
+
+      def close
+        if @io
+          begin
+            @io.close
+          rescue SystemCallError
+            # nothing to do, it wasn't open
+          end
+          if connecting?
+            succeed_connection!
+          end
+          @io = nil
+          @event_listeners[:close].each { |listener| listener.call(self) }
+        end
+      end
+
+      def to_s
+        state = begin
+          if connected? then 'connected'
+          elsif connecting? then 'connecting'
+          else 'not connected'
+          end
+        end
+        %<NodeConnection(#{@host}:#{@port}, #{state})>
+      end
+
+      private
+
+      EVENT_STREAM_ID = -1
+
+      def connecting_timed_out?
+        (Time.now - @connection_started_at) > @connection_timeout
+      end
+
+      def succeed_connection!
+        @connected_future.complete!(connection_id)
+      end
+
+      def fail_connection!(e)
+        case e
+        when ConnectionError
+          error = e
+        else
+          message = "Could not connect to #{@host}:#{@port}: #{e.message} (#{e.class.name})"
+          error = ConnectionError.new(message)
+          error.set_backtrace(e.backtrace)
+        end
+        @connected_future.fail!(error)
+        force_close(error)
+      end
+
+      def force_close(e)
+        case e
+        when CqlError
+          error = e
+        else
+          error = IoError.new(e.message)
+          error.set_backtrace(e.backtrace)
+        end
+        @response_tasks.each do |listener|
+          listener.fail!(error) if listener
+        end
+        close
+      end
+
+      def next_stream_id
+        @response_tasks.each_with_index do |task, index|
+          return index if task.nil?
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/cql/protocol/encoding.rb

@@ -14,6 +14,7 @@ module Cql
       end
 
       def write_string(buffer, str)
+        str = str.to_s
         buffer << [str.bytesize].pack(Formats::SHORT_FORMAT)
         buffer << binary_cast(str)
         buffer.force_encoding(::Encoding::BINARY)

data/lib/cql/protocol/request_frame.rb

@@ -49,6 +49,32 @@ module Cql
       COMPRESSION = 'COMPRESSION'.freeze
     end
 
+    class CredentialsRequest < RequestBody
+      attr_reader :credentials
+
+      def initialize(credentials)
+        super(4)
+        @credentials = credentials.dup.freeze
+      end
+
+      def write(io)
+        write_string_map(io, @credentials)
+      end
+
+      def to_s
+        %(CREDENTIALS #{@credentials})
+      end
+
+      def eql?(rq)
+        self.class === rq && rq.credentials.eql?(@credentials)
+      end
+      alias_method :==, :eql?
+
+      def hash
+        @h ||= @credentials.hash
+      end
+    end
+
     class OptionsRequest < RequestBody
       def initialize
         super(5)

data/lib/cql/protocol/response_frame.rb

@@ -55,6 +55,7 @@ module Cql
           case @headers.opcode
           when 0x00 then ErrorResponse
           when 0x02 then ReadyResponse
+          when 0x03 then AuthenticateResponse
           when 0x06 then SupportedResponse
           when 0x08 then ResultResponse
           when 0x0c then EventResponse
@@ -214,6 +215,22 @@ module Cql
       end
     end
 
+    class AuthenticateResponse < ResponseBody
+      attr_reader :authentication_class
+
+      def self.decode!(buffer)
+        new(read_string!(buffer))
+      end
+
+      def initialize(authentication_class)
+        @authentication_class = authentication_class
+      end
+
+      def to_s
+        %(AUTHENTICATE #{authentication_class})
+      end
+    end
+
     class SupportedResponse < ResponseBody
       attr_reader :options
 

data/lib/cql/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Cql
-  VERSION = '1.0.0.pre4'.freeze
+  VERSION = '1.0.0.pre5'.freeze
 end

data/spec/cql/client_spec.rb

@@ -33,114 +33,153 @@ module Cql
       requests.last
     end
 
-    describe '#start!' do
+    describe '.connect' do
+      it 'connects and returns the client' do
+        client = described_class.connect(connection_options)
+        client.should be_connected
+      end
+    end
+
+    describe '#connect' do
       it 'connects' do
-        client.start!
+        client.connect
         connections.should have(1).item
       end
 
       it 'connects only once' do
-        client.start!
-        client.start!
+        client.connect
+        client.connect
         connections.should have(1).item
       end
 
       it 'connects to all hosts' do
-        client.shutdown!
+        client.close
         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.start!
+        c.connect
         connections.should have(3).items
       end
 
       it 'returns itself' do
-        client.start!.should equal(client)
+        client.connect.should equal(client)
       end
 
       it 'forwards the host and port' do
-        client.start!
+        client.connect
         connection[:host].should == 'example.com'
         connection[:port].should == 12321
       end
 
       it 'sends a startup request' do
-        client.start!
+        client.connect
         last_request.should be_a(Protocol::StartupRequest)
       end
 
       it 'sends a startup request to each connection' do
-        client.shutdown!
+        client.close
         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.start!
+        c.connect
         connections.each do |cc|
           cc[:requests].last.should be_a(Protocol::StartupRequest)
         end
       end
 
       it 'is not in a keyspace' do
-        client.start!
+        client.connect
         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.start!
+        c.connect
         last_request.should == Protocol::QueryRequest.new('USE hello_world', :one)
       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.start! }.to raise_error(Client::InvalidKeyspaceNameError)
+        expect { c.connect }.to raise_error(Client::InvalidKeyspaceNameError)
         requests.should_not include(Protocol::QueryRequest.new('USE system; DROP KEYSPACE system', :one))
       end
 
       it 're-raises any errors raised' do
         io_reactor.stub(:add_connection).and_raise(ArgumentError)
-        expect { client.start! }.to raise_error(ArgumentError)
+        expect { client.connect }.to raise_error(ArgumentError)
       end
 
       it 'is not connected if an error is raised' do
         io_reactor.stub(:add_connection).and_raise(ArgumentError)
-        client.start! rescue nil
+        client.connect rescue nil
         client.should_not be_connected
+        io_reactor.should_not be_running
       end
 
-      it 'is connected after #start! returns' do
-        client.start!
+      it 'is connected after #connect returns' do
+        client.connect
         client.should be_connected
       end
+
+      context 'when the server requests authentication' do
+        before do
+          io_reactor.queue_response(Protocol::AuthenticateResponse.new('com.example.Auth'))
+        end
+
+        it 'sends credentials' do
+          client = described_class.new(connection_options.merge(credentials: {'username' => 'foo', 'password' => 'bar'}))
+          client.connect
+          last_request.should == Protocol::CredentialsRequest.new('username' => 'foo', 'password' => 'bar')
+        end
+
+        it 'raises an error when no credentials have been given' do
+          client = described_class.new(connection_options)
+          expect { client.connect }.to raise_error(AuthenticationError)
+        end
+
+        it 'raises an error when the server responds with an error to the credentials request' do
+          io_reactor.queue_response(Protocol::ErrorResponse.new(256, 'No way, José'))
+          client = described_class.new(connection_options.merge(credentials: {'username' => 'foo', 'password' => 'bar'}))
+          expect { client.connect }.to raise_error(AuthenticationError)
+        end
+
+        it 'shuts down the client when there is an authentication error' do
+          io_reactor.queue_response(Protocol::ErrorResponse.new(256, 'No way, José'))
+          client = described_class.new(connection_options.merge(credentials: {'username' => 'foo', 'password' => 'bar'}))
+          client.connect rescue nil
+          client.should_not be_connected
+          io_reactor.should_not be_running
+        end
+      end
     end
 
-    describe '#shutdown!' do
+    describe '#close' do
       it 'closes the connection' do
-        client.start!
-        client.shutdown!
+        client.connect
+        client.close
         io_reactor.should_not be_running
       end
 
-      it 'does nothing when called before #start!' do
-        client.shutdown!
+      it 'does nothing when called before #connect' do
+        client.close
       end
 
-      it 'accepts multiple calls to #shutdown!' do
-        client.start!
-        client.shutdown!
-        client.shutdown!
+      it 'accepts multiple calls to #close' do
+        client.connect
+        client.close
+        client.close
       end
 
       it 'returns itself' do
-        client.start!.shutdown!.should equal(client)
+        client.connect.close.should equal(client)
       end
     end
 
     describe '#use' do
       before do
-        client.start!
+        client.connect
       end
 
       it 'executes a USE query' do
@@ -150,12 +189,12 @@ module Cql
       end
 
       it 'executes a USE query for each connection' do
-        client.shutdown!
+        client.close
         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.start!
+        c.connect
 
         c.use('system')
         last_requests = connections.select { |c| c[:host] =~ /^h\d\.example\.com$/ }.sort_by { |c| c[:host] }.map { |c| c[:requests].last }
@@ -179,7 +218,7 @@ module Cql
 
     describe '#execute' do
       before do
-        client.start!
+        client.connect
       end
 
       it 'asks the connection to execute the query' do
@@ -214,12 +253,12 @@ module Cql
         end
 
         it 'detects that one connection changed to a keyspace and changes the others too' do
-          client.shutdown!
+          client.close
           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.start!
+          c.connect
 
           io_reactor.queue_response(Protocol::SetKeyspaceResultResponse.new('system'), connections.find { |c| c[:host] == 'h1.example.com' }[:host])
           io_reactor.queue_response(Protocol::SetKeyspaceResultResponse.new('system'), connections.find { |c| c[:host] == 'h2.example.com' }[:host])
@@ -299,7 +338,7 @@ module Cql
       end
 
       before do
-        client.start!
+        client.connect
       end
 
       it 'sends a prepare request' do
@@ -334,12 +373,12 @@ module Cql
       end
 
       it 'executes a prepared statement using the right connection' do
-        client.shutdown!
+        client.close
         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.start!
+        c.connect
 
         io_reactor.queue_response(Protocol::PreparedResultResponse.new('A' * 32, metadata))
         io_reactor.queue_response(Protocol::PreparedResultResponse.new('B' * 32, metadata))
@@ -363,51 +402,51 @@ module Cql
     end
 
     context 'when not connected' do
-      it 'is not connected before #start! has been called' do
+      it 'is not connected before #connect has been called' do
         client.should_not be_connected
       end
 
-      it 'is not connected after #shutdown! has been called' do
-        client.start!
-        client.shutdown!
+      it 'is not connected after #close has been called' do
+        client.connect
+        client.close
         client.should_not be_connected
       end
 
-      it 'complains when #use is called before #start!' do
+      it 'complains when #use is called before #connect' do
         expect { client.use('system') }.to raise_error(Client::NotConnectedError)
       end
 
-      it 'complains when #use is called after #shutdown!' do
-        client.start!
-        client.shutdown!
+      it 'complains when #use is called after #close' do
+        client.connect
+        client.close
         expect { client.use('system') }.to raise_error(Client::NotConnectedError)
       end
 
-      it 'complains when #execute is called before #start!' do
+      it 'complains when #execute is called before #connect' do
         expect { client.execute('DELETE FROM stuff WHERE id = 3') }.to raise_error(Client::NotConnectedError)
       end
 
-      it 'complains when #execute is called after #shutdown!' do
-        client.start!
-        client.shutdown!
+      it 'complains when #execute is called after #close' do
+        client.connect
+        client.close
         expect { client.execute('DELETE FROM stuff WHERE id = 3') }.to raise_error(Client::NotConnectedError)
       end
 
-      it 'complains when #prepare is called before #start!' do
+      it 'complains when #prepare is called before #connect' do
         expect { client.prepare('DELETE FROM stuff WHERE id = 3') }.to raise_error(Client::NotConnectedError)
       end
 
-      it 'complains when #prepare is called after #shutdown!' do
-        client.start!
-        client.shutdown!
+      it 'complains when #prepare is called after #close' do
+        client.connect
+        client.close
         expect { client.prepare('DELETE FROM stuff WHERE id = 3') }.to raise_error(Client::NotConnectedError)
       end
 
-      it 'complains when #execute of a prepared statement is called after #shutdown!' do
-        client.start!
+      it 'complains when #execute of a prepared statement is called after #close' do
+        client.connect
         io_reactor.queue_response(Protocol::PreparedResultResponse.new('A' * 32, []))
         statement = client.prepare('DELETE FROM stuff WHERE id = 3')
-        client.shutdown!
+        client.close
         expect { statement.execute }.to raise_error(Client::NotConnectedError)
       end
     end