cql-rb 1.0.0.pre4 → 1.0.0.pre5

data/README.md

@@ -20,15 +20,14 @@ The native transport protocol (sometimes called binary protocol, or CQL protocol
 
     require 'cql'
 
-    client = Cql::Client.new(host: 'cassandra.example.com')
-    client.start!
+    client = Cql::Client.connect(host: 'cassandra.example.com')
     client.use('system')
     rows = client.execute('SELECT keyspace_name, columnfamily_name FROM schema_columnfamilies')
     rows.each do |row|
       puts "The keyspace #{row['keyspace_name']} has a table called #{row['columnfamily_name']}""
     end
 
-when you're done you can call `#shutdown!` to disconnect from Cassandra. You can connect to multiple Cassandra nodes by passing multiple comma separated host names to the `:host` option.
+when you're done you can call `#close` to disconnect from Cassandra. You can connect to multiple Cassandra nodes by passing multiple comma separated host names to the `:host` option.
 
 ## Changing keyspaces
 

data/lib/cql/client.rb

@@ -11,15 +11,14 @@ module Cql
   end
 
   ClientError = Class.new(CqlError)
+  AuthenticationError = Class.new(ClientError)
 
   # A CQL client manages connections to one or more Cassandra nodes and you use
   # it run queries, insert and update data.
   #
   # @example Connecting and changing to a keyspace
-  #   # create a client that will connect to two Cassandra nodes
-  #   client = Cql::Client.new(host: 'node01.cassandra.local,node02.cassandra.local')
-  #   # establish node connections
-  #   client.start!
+  #   # create a client and connect to two Cassandra nodes
+  #   client = Cql::Client.connect(host: 'node01.cassandra.local,node02.cassandra.local')
   #   # change to a keyspace
   #   client.use('stuff')
   #
@@ -47,8 +46,8 @@ module Cql
     # Create a new client.
     #
     # Creating a client does not automatically connect to Cassandra, you need to
-    # call {#start!} to connect. `#start!` returns `self` so you can chain that
-    # call after `new`.
+    # call {#connect} to connect, or use {Client.connect}. `#connect` returns
+    # `self` so you can chain that call after `new`.
     #
     # @param [Hash] options
     # @option options [String] :host ('localhost') One or more (comma separated)
@@ -67,9 +66,14 @@ module Cql
       @started = false
       @shut_down = false
       @initial_keyspace = options[:keyspace]
+      @credentials = options[:credentials]
       @connection_keyspaces = {}
     end
 
+    def self.connect(options={})
+      new(options).connect
+    end
+
     # Connect to all nodes.
     #
     # You must call this method before you call any of the other methods of a
@@ -81,29 +85,37 @@ module Cql
     #
     # @return self
     #
-    def start!
+    def connect
       @lock.synchronize do
         return if @started
+        @started = true
         @io_reactor.start
         hosts = @host.split(',')
-        start_request = Protocol::StartupRequest.new
-        connection_futures = hosts.map do |host|
-          @io_reactor.add_connection(host, @port).flat_map do |connection_id|
-            execute_request(start_request, connection_id).map { connection_id }
-          end
-        end
+        connection_futures = hosts.map { |host| connect_to_host(host) }
         @connection_ids = Future.combine(*connection_futures).get
-        @started = true
       end
       use(@initial_keyspace) if @initial_keyspace
       self
+    rescue => e
+      close
+      if e.is_a?(Cql::QueryError) && e.code == 0x100
+        raise AuthenticationError, e.message, e.backtrace
+      else
+        raise
+      end
+    end
+
+    # @deprecated Use {#connect} or {.connect}
+    def start!
+      $stderr.puts('Client#start! is deprecated, use Client#connect, or Client.connect')
+      connect
     end
 
     # Disconnect from all nodes.
     #
     # @return self
     #
-    def shutdown!
+    def close
       @lock.synchronize do
         return if @shut_down || !@started
         @shut_down = true
@@ -113,6 +125,12 @@ module Cql
       self
     end
 
+    # @deprecated Use {#close}
+    def shutdown!
+      $stderr.puts('Client#shutdown! is deprecated, use Client#close')
+      close
+    end
+
     # Returns whether or not the client is connected.
     #
     def connected?
@@ -196,6 +214,28 @@ module Cql
       true
     end
 
+    def connect_to_host(host)
+      connected = @io_reactor.add_connection(host, @port)
+      connected.flat_map do |connection_id|
+        started = execute_request(Protocol::StartupRequest.new, connection_id)
+        started.flat_map { |response| maybe_authenticate(response, connection_id) }
+      end
+    end
+
+    def maybe_authenticate(response, connection_id)
+      case response
+      when AuthenticationRequired
+        if @credentials
+          credentials_request = Protocol::CredentialsRequest.new(@credentials)
+          execute_request(credentials_request, connection_id).map { connection_id }
+        else
+          Future.failed(AuthenticationError.new('Server requested authentication, but no credentials given'))
+        end
+      else
+        Future.completed(connection_id)
+      end
+    end
+
     def execute_request(request, connection_id=nil)
       @io_reactor.queue_request(request, connection_id).map do |response, connection_id|
         interpret_response!(response, connection_id)
@@ -215,6 +255,8 @@ module Cql
           @last_keyspace_change = @connection_keyspaces[connection_id] = response.keyspace
         end
         nil
+      when Protocol::AuthenticateResponse
+        AuthenticationRequired.new(response.authentication_class)
       else
         nil
       end
@@ -264,6 +306,14 @@ module Cql
       end
     end
 
+    class AuthenticationRequired
+      attr_reader :authentication_class
+
+      def initialize(authentication_class)
+        @authentication_class = authentication_class
+      end
+    end
+
     class QueryResult
       include Enumerable
 

data/lib/cql/io.rb

@@ -5,6 +5,7 @@ module Cql
 
   module Io
     ConnectionError = Class.new(IoError)
+    ConnectionTimeoutError = Class.new(ConnectionError)
     NotRunningError = Class.new(CqlError)
     ConnectionNotFoundError = Class.new(CqlError)
     ConnectionBusyError = Class.new(CqlError)
@@ -12,3 +13,4 @@ module Cql
 end
 
 require 'cql/io/io_reactor'
+require 'cql/io/node_connection'

data/lib/cql/io/io_reactor.rb

@@ -1,9 +1,5 @@
 # encoding: utf-8
 
-require 'socket'
-require 'resolv-replace'
-
-
 module Cql
   module Io
     # An instance of IO reactor manages the connections used by a client.
@@ -20,9 +16,9 @@ module Cql
       def initialize(options={})
         @connection_timeout = options[:connection_timeout] || 5
         @lock = Mutex.new
-        @streams = []
         @command_queue = []
-        @queue_signal_receiver, @queue_signal_sender = IO.pipe
+        @unblocker = UnblockerConnection.new(*IO.pipe)
+        @connections = [@unblocker]
         @started_future = Future.new
         @stopped_future = Future.new
         @running = false
@@ -45,7 +41,6 @@ module Cql
         @lock.synchronize do
           unless @running
             @running = true
-            @streams << CommandDispatcher.new(@queue_signal_receiver, @command_queue, @lock, @streams)
             @reactor_thread = Thread.start do
               begin
                 @started_future.complete!
@@ -70,6 +65,7 @@ module Cql
       #
       def stop
         @running = false
+        command_queue_push(nil)
         @stopped_future
       end
 
@@ -82,20 +78,17 @@ module Cql
       #
       def add_connection(host, port)
         connection = NodeConnection.new(host, port, @connection_timeout)
-        future = connection.open
-        future.on_failure do
+        connection.on_close do
           @lock.synchronize do
-            @streams.delete(connection)
+            @connections.delete(connection)
           end
         end
-        future.on_complete do
-          command_queue_push(:connection_established, connection)
-        end
+        f = connection.open
         @lock.synchronize do
-          @streams << connection
+          @connections << connection
         end
-        command_queue_push(:connection_added, connection)
-        future
+        command_queue_push(nil)
+        f
       end
 
       # Sends a request over a random, or specific connection.
@@ -106,9 +99,9 @@ module Cql
       # @return [Future<ResultResponse>] a future representing the result of the request
       #
       def queue_request(request, connection_id=nil)
-        future = Future.new
-        command_queue_push(:request, request, future, connection_id)
-        future
+        command = connection_id ? TargetedRequestCommand.new(request, connection_id) : RequestCommand.new(request)
+        command_queue_push(command)
+        command.future
       end
 
       # Registers a listener to receive server sent events.
@@ -116,258 +109,133 @@ module Cql
       # @yieldparam [Cql::Protocol::EventResponse] event the event sent by the server
       #
       def add_event_listener(&listener)
-        command_queue_push(:event_listener, listener)
+        command_queue_push(EventListenerCommand.new(listener))
       end
 
       private
 
-      PING_BYTE = "\0".freeze
-
       def io_loop
         while running?
-          read_ready_streams = @streams.select(&:connected?)
-          write_ready_streams = @streams.select(&:can_write?)
+          read_ready_streams = @connections.select(&:connected?)
+          write_ready_streams = @connections.select(&:can_write?)
           readables, writables, _ = IO.select(read_ready_streams, write_ready_streams, nil, 1)
           readables && readables.each(&:handle_read)
           writables && writables.each(&:handle_write)
-          @streams.each(&:ping)
-          @streams.reject!(&:closed?)
+          @connections.each do |connection|
+            if connection.connecting?
+              connection.handle_connecting
+            end
+          end
+          if running?
+            perform_queued_commands
+          end
         end
       ensure
         stop
-        @streams.each do |stream|
+        @connections.dup.each do |connection|
           begin
-            stream.close
-          rescue IOError
+            connection.close
+          rescue IOError => e
           end
         end
       end
 
-      def command_queue_push(*item)
-        if item && item.any?
+      def command_queue_push(command)
+        if command
           @lock.synchronize do
-            @command_queue << item
+            @command_queue << command
           end
         end
-        @queue_signal_sender.write(PING_BYTE)
-      end
-    end
-
-    # @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] = [] }
+        @unblocker.unblock!
       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)
+      def perform_queued_commands
+        @lock.synchronize do
+          unexecuted_commands = []
+          while (command = @command_queue.shift)
+            case command
+            when EventListenerCommand
+              @connections.each do |connection|
+                connection.on_event(&command.listener)
+              end
+            when TargetedRequestCommand
+              connection = @connections.find { |c| c.connection_id == command.connection_id }
+              if connection && connection.connected? && connection.has_capacity?
+                connection.perform_request(command.request, command.future)
+              elsif connection && connection.connected?
+                command.future.fail!(ConnectionBusyError.new("Connection ##{command.connection_id} is busy"))
+              else
+                command.future.fail!(ConnectionNotFoundError.new("Connection ##{command.connection_id} does not exist"))
+              end
+            when RequestCommand
+              connection = @connections.select(&:has_capacity?).sample
+              if connection
+                connection.perform_request(command.request, command.future)
+              else
+                unexecuted_commands << command
+              end
+            end
+          end
+          @command_queue.unshift(*unexecuted_commands) if unexecuted_commands.any?
         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
+    end
 
-      def ping
-        if @io && connecting? && (Time.now - @connection_started_at > @connection_timeout)
-          fail_connection!
-        end
-      end
+    class EventListenerCommand
+      attr_reader :listener
 
-      def connected?
-        @io && !connecting?
+      def initialize(listener)
+        @listener = listener
       end
+    end
 
-      def closed?
-        @io.nil? && !connecting?
-      end
+    class RequestCommand
+      attr_reader :future, :request
 
-      def has_capacity?
-        !!next_stream_id && connected?
+      def initialize(request)
+        @request = request
+        @future = Future.new
       end
+    end
 
-      def can_write?
-        @io && (!@write_buffer.empty? || connecting?)
-      end
+    class TargetedRequestCommand < RequestCommand
+      attr_reader :connection_id
 
-      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)
+      def initialize(request, connection_id)
+        super(request)
+        @connection_id = connection_id
       end
+    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)
+    class UnblockerConnection
+      def initialize(*args)
+        @out, @in = args
       end
 
-      def handle_write
-        if connecting?
-          handle_connected
-        elsif connected?
-          bytes_written = @io.write_nonblock(@write_buffer)
-          @write_buffer.slice!(0, bytes_written)
-        end
-      rescue => e
-        force_close(e)
+      def unblock!
+        @in.write(PING_BYTE)
       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
+      def to_io
+        @out
       end
 
       def close
-        if @io
-          begin
-            @io.close
-          rescue SystemCallError
-            # nothing to do, it wasn't open
-          end
-          @io = nil
-          if connecting?
-            succeed_connection!
-          end
-          @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?
-        !(@connected_future.complete? || @connected_future.failed?)
-      end
-
-      def handle_connected
-        @io.connect_nonblock(@sockaddr)
-        succeed_connection!
-      rescue Errno::EISCONN
-        # ok
-        succeed_connection!
-      rescue SystemCallError, SocketError => e
-        fail_connection!(e)
-      end
-
-      def succeed_connection!
-        @connected_future.complete!(connection_id)
-      end
-
-      def fail_connection!(e=nil)
-        message = "Could not connect to #{@host}:#{@port}"
-        message << ": #{e.message} (#{e.class.name})" if e
-        error = ConnectionError.new(message)
-        error.set_backtrace(e.backtrace) if e
-        @connected_future.fail!(error)
-        close
-      end
-
-      def next_stream_id
-        @response_tasks.each_with_index do |task, index|
-          return index if task.nil?
-        end
-        nil
-      end
-    end
+      def on_event; end
 
-    # @private
-    class CommandDispatcher
-      def initialize(*args)
-        @io, @command_queue, @queue_lock, @node_connections = args
-      end
+      def on_close; end
 
       def connection_id
         -1
       end
 
-      def to_io
-        @io
-      end
-
       def connected?
         true
       end
 
-      def closed?
-        false
-      end
-
-      def has_capacity?
+      def connecting?
         false
       end
 
@@ -375,99 +243,17 @@ module Cql
         false
       end
 
-      def on_event; end
-
-      def on_close; end
-
-      def ping
-        if can_deliver_command?
-          deliver_commands
-        else
-          prune_directed_requests!
-        end
+      def has_capacity?
+        false
       end
 
       def handle_read
-        if @io.read_nonblock(1)
-          deliver_commands
-        end
-      end
-
-      def handle_write
-      end
-
-      def close
-        @io.close
-      end
-
-      def to_s
-        %(CommandDispatcher)
+        @out.read_nonblock(2**16)
       end
 
       private
 
-      def can_deliver_command?
-        @node_connections.any?(&:has_capacity?) && @command_queue.size > 0
-      end
-
-      def next_command
-        @queue_lock.synchronize do
-          if can_deliver_command?
-            return @command_queue.shift
-          end
-        end
-        nil
-      end
-
-      def deliver_commands
-        while (command = next_command)
-          case command.shift
-          when :connection_added
-          when :connection_established
-            connection = command.shift
-            connection.on_close(&method(:connection_closed))
-          when :event_listener
-            listener = command.shift
-            @node_connections.each { |c| c.on_event(&listener) }
-          when :request
-            request, future, connection_id = command
-            if connection_id
-              connection = @node_connections.find { |c| c.connection_id == connection_id }
-              if connection && connection.connected? && connection.has_capacity?
-                connection.perform_request(request, future)
-              elsif connection && connection.connected?
-                future.fail!(ConnectionBusyError.new("Connection ##{connection_id} is busy"))
-              else
-                future.fail!(ConnectionNotFoundError.new("Connection ##{connection_id} does not exist"))
-              end
-            else
-              @node_connections.select(&:has_capacity?).sample.perform_request(request, future)
-            end
-          end
-        end
-      end
-
-      def prune_directed_requests!
-        failing_commands = []
-        @queue_lock.synchronize do
-          @command_queue.reject! do |command|
-            if command.first == :request && command.last && @node_connections.none? { |c| c.connection_id == command.last }
-              failing_commands << command
-              true
-            else
-              false
-            end
-          end
-        end
-        failing_commands.each do |command|
-          _, _, future, id = command
-          future.fail!(ConnectionNotFoundError.new("Connection ##{id} no longer exists"))
-        end
-      end
-
-      def connection_closed(connection)
-        prune_directed_requests!
-      end
+      PING_BYTE = "\0".freeze
     end
   end
 end