cql-rb 1.0.6 → 1.1.0.pre0

data/lib/cql/future.rb

@@ -62,7 +62,7 @@ module Cql
         raise FutureError, 'Future already completed' if complete? || failed?
         @value = v
         @complete_listeners.each do |listener|
-          listener.call(@value)
+          listener.call(@value) rescue nil
         end
       end
     ensure
@@ -84,7 +84,7 @@ module Cql
     def on_complete(&listener)
       @state_lock.synchronize do
         if complete?
-          listener.call(value)
+          listener.call(value) rescue nil
         else
           @complete_listeners << listener
         end
@@ -101,7 +101,6 @@ module Cql
       raise @error if @error
       return @value if defined? @value
       @value_barrier.pop
-      @value_barrier << :ping
       raise @error if @error
       return @value
     end
@@ -118,7 +117,7 @@ module Cql
         raise FutureError, 'Future already completed' if failed? || complete?
         @error = error
         @failure_listeners.each do |listener|
-          listener.call(error)
+          listener.call(error) rescue nil
         end
       end
     ensure
@@ -140,7 +139,7 @@ module Cql
     def on_failure(&listener)
       @state_lock.synchronize do
         if failed?
-          listener.call(@error)
+          listener.call(@error) rescue nil
         else
           @failure_listeners << listener
         end

data/lib/cql/io.rb

@@ -5,13 +5,10 @@ module Cql
 
   module Io
     ConnectionError = Class.new(IoError)
-    ConnectionClosedError = Class.new(IoError)
+    ConnectionClosedError = Class.new(ConnectionError)
     ConnectionTimeoutError = Class.new(ConnectionError)
-    NotRunningError = Class.new(CqlError)
-    ConnectionNotFoundError = Class.new(CqlError)
-    ConnectionBusyError = Class.new(CqlError)
   end
 end
 
 require 'cql/io/io_reactor'
-require 'cql/io/node_connection'
+require 'cql/io/connection'

data/lib/cql/io/connection.rb

@@ -0,0 +1,220 @@
+# encoding: utf-8
+
+require 'socket'
+
+
+module Cql
+  module Io
+    # A wrapper around a socket. Handles connecting to the remote host, reading
+    # from and writing to the socket.
+    #
+    class Connection
+      attr_reader :host, :port, :connection_timeout
+
+      # @private
+      def initialize(host, port, connection_timeout, unblocker, socket_impl=Socket, clock=Time)
+        @host = host
+        @port = port
+        @connection_timeout = connection_timeout
+        @unblocker = unblocker
+        @socket_impl = socket_impl
+        @clock = clock
+        @lock = Mutex.new
+        @connected = false
+        @write_buffer = ByteBuffer.new
+        @connected_future = Future.new
+      end
+
+      # @private
+      def connect
+        begin
+          unless @addrinfos
+            @connection_started_at = @clock.now
+            @addrinfos = @socket_impl.getaddrinfo(@host, @port, nil, Socket::SOCK_STREAM)
+          end
+          unless @io
+            _, port, _, ip, address_family, socket_type = @addrinfos.shift
+            @sockaddr = @socket_impl.sockaddr_in(port, ip)
+            @io = @socket_impl.new(address_family, socket_type, 0)
+          end
+          unless connected?
+            @io.connect_nonblock(@sockaddr)
+            @connected = true
+            @connected_future.complete!(self)
+          end
+        rescue Errno::EISCONN
+          @connected = true
+          @connected_future.complete!(self)
+        rescue Errno::EINPROGRESS, Errno::EALREADY
+          if @clock.now - @connection_started_at > @connection_timeout
+            close(ConnectionTimeoutError.new("Could not connect to #{@host}:#{@port} within #{@connection_timeout}s"))
+          end
+        rescue Errno::EINVAL => e
+          if @addrinfos.empty?
+            close(e)
+          else
+            @io = nil
+            retry
+          end
+        rescue SystemCallError => e
+          close(e)
+        rescue SocketError => e
+          close(e) || closed!(e)
+        end
+        @connected_future
+      end
+
+      # Closes the connection
+      def close(cause=nil)
+        return false unless @io
+        begin
+          @io.close
+        rescue SystemCallError, IOError
+          # nothing to do, the socket was most likely already closed
+        end
+        closed!(cause)
+        true
+      end
+
+      # @private
+      def connecting?
+        !(closed? || connected?)
+      end
+
+      # Returns true if the connection is connected
+      def connected?
+        @connected
+      end
+
+      # Returns true if the connection is closed
+      def closed?
+        @io.nil?
+      end
+
+      # @private
+      def writable?
+        empty_buffer = @lock.synchronize do
+          @write_buffer.empty?
+        end
+        !(closed? || empty_buffer)
+      end
+
+      # Register to receive notifications when new data is read from the socket.
+      #
+      # You should only call this method in your protocol handler constructor.
+      #
+      # Only one callback can be registered, if you register multiple times only
+      # the last one will receive notifications. This is not meant as a general
+      # event system, it's just for protocol handlers to receive data from their
+      # connection. If you want multiple listeners you need to implement that
+      # yourself in your protocol handler.
+      #
+      # It is very important that you don't do any heavy lifting in the callback
+      # since it is called from the IO reactor thread, and as long as the
+      # callback is working the reactor can't handle any IO and no other
+      # callbacks can be called.
+      #
+      # Errors raised by the callback will be ignored.
+      #
+      # @yield [String] the new data
+      #
+      def on_data(&listener)
+        @data_listener = listener
+      end
+
+      # Register to receive a notification when the socket is closed, both for
+      # expected and unexpected reasons.
+      #
+      # You shoud only call this method in your protocol handler constructor.
+      #
+      # Only one callback can be registered, if you register multiple times only
+      # the last one will receive notifications. This is not meant as a general
+      # event system, it's just for protocol handlers to be notified of the
+      # connection closing. If you want multiple listeners you need to implement
+      # that yourself in your protocol handler.
+      #
+      # Errors raised by the callback will be ignored.
+      #
+      # @yield [error, nil] the error that caused the socket to close, or nil if
+      #   the socket closed with #close
+      #
+      def on_closed(&listener)
+        @closed_listener = listener
+      end
+
+      # Write bytes to the socket.
+      #
+      # You can either pass in bytes (as a string or as a `ByteBuffer`), or you
+      # can use the block form of this method to get access to the connection's
+      # internal buffer.
+      # 
+      # @yieldparam buffer [Cql::ByteBuffer] the connection's internal buffer
+      # @param bytes [String, Cql::ByteBuffer] the data to write to the socket
+      #
+      def write(bytes=nil)
+        @lock.synchronize do
+          if block_given?
+            yield @write_buffer
+          elsif bytes
+            @write_buffer.append(bytes)
+          end
+        end
+        @unblocker.unblock!
+      end
+
+      # @private
+      def flush
+        if writable?
+          @lock.synchronize do
+            s = @write_buffer.cheap_peek.dup
+            bytes_written = @io.write_nonblock(@write_buffer.cheap_peek)
+            @write_buffer.discard(bytes_written)
+          end
+        end
+      rescue => e
+        close(e)
+      end
+
+      # @private
+      def read
+        new_data = @io.read_nonblock(2**16)
+        @data_listener.call(new_data) if @data_listener
+      rescue => e
+        close(e)
+      end
+
+      # @private
+      def to_io
+        @io
+      end
+
+      def to_s
+        state = 'inconsistent'
+        if connected?
+          state = 'connected'
+        elsif connecting?
+          state = 'connecting'
+        elsif closed?
+          state = 'closed'
+        end
+        %(#<#{self.class.name} #{state} #{@host}:#{@port}>)
+      end
+
+      private
+
+      def closed!(cause)
+        @io = nil
+        if cause && !cause.is_a?(IoError)
+          cause = ConnectionError.new(cause.message)
+        end
+        unless connected?
+          @connected_future.fail!(cause)
+        end
+        @connected = false
+        if @closed_listener
+          @closed_listener.call(cause)
+        end
+      end
+    end
+  end
+end

data/lib/cql/io/io_reactor.rb

@@ -2,54 +2,145 @@
 
 module Cql
   module Io
-    # An instance of IO reactor manages the connections used by a client.
+    ReactorError = Class.new(IoError)
+
+    # An IO reactor takes care of all the IO for a client. It handles opening
+    # new connections, and making sure that connections that have data to send
+    # flush to the network, and connections that have data coming in read that
+    # data and delegate it to their protocol handlers.
+    #
+    # All IO is done in a single background thread, regardless of how many
+    # connections you open. There shouldn't be any problems handling hundreds of
+    # connections if needed. All operations are thread safe, but you should take
+    # great care when in your protocol handlers to make sure that they don't
+    # do too much work in their data handling callbacks, since those will be
+    # run in the reactor thread, and every cycle you use there is a cycle which
+    # can't be used to handle IO.
+    #
+    # The IO reactor is completely protocol agnostic, and it's up to the
+    # specified protocol handler factory to create objects that can interpret
+    # the bytes received from remote hosts, and to send the correct commands
+    # back. The way this works is that when you create an IO reactor you provide
+    # a factory that can create protocol handler objects (this factory is most
+    # of the time just class, but it could potentially be any object that
+    # responds to #new). When you #connect a new protocol handler instance is
+    # created and passed a connection. The protocol handler can then register to
+    # receive data that arrives over the socket, and it can write data to the
+    # socket. It can also register to be notified when the socket is closed, or
+    # it can itself close the socket.
+    #
+    # @example A protocol handler that processes whole lines
+    #
+    #   class LineProtocolHandler
+    #     def initialize(connection)
+    #       @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
+    #       @connection.on_data(&method(:process_data))
+    #       @buffer = ''
+    #     end
+    #
+    #     def process_data(new_data)
+    #       # in this fictional protocol we want to process whole lines, so we
+    #       # append new data to our buffer and then loop as long as there is
+    #       # a newline in the buffer, everything up until a newline is a
+    #       # complete line
+    #       @buffer << new_data
+    #       while newline_index = @buffer.index("\n")
+    #         line = @buffer.slice!(0, newline_index + 1)
+    #         line.chomp!
+    #         # Now do something interesting with the line, but remember that
+    #         # while you're in the data listener method you're executing in the
+    #         # IO reactor thread so you're blocking the reactor from doing
+    #         # other IO work. You should not do any heavy lifting here, but
+    #         # instead hand off the data to your application's other threads.
+    #         # One way of doing that is to create a Cql::Future in the method
+    #         # that sends the request, and then complete the future in this
+    #         # method. How you keep track of which future belongs to which
+    #         # reply is very protocol dependent so you'll have to figure that
+    #         # out yourself.
+    #       end
+    #     end
     #
-    # The reactor starts a thread in which all IO is performed. The IO reactor
-    # instances are thread safe.
+    #     def send_request(command_string)
+    #       # This example primarily shows how to implement a data listener
+    #       # method, but this is how you write data to the connection. The
+    #       # method can be called anything, it doesn't have to be #send_request
+    #       @connection.write(command_string)
+    #       # The connection object itself is threadsafe, but to create any
+    #       # interesting protocol you probably need to set up some state for
+    #       # each request so that you know which request to complete when you
+    #       # get data back.
+    #     end
+    #   end
+    #
+    # See {Cql::Protocol::CqlProtocolHandler} for an example of how the CQL
+    # protocol is implemented, and there is an integration tests that implements
+    # the Redis protocol that you can look at too.
     #
     class IoReactor
+      # Initializes a new IO reactor.
       #
-      # @param [Hash] options
-      # @option options [Integer] :connection_timeout (5) Max time to wait for a
-      #   connection, in seconds
+      # @param protocol_handler_factory [Object] a class that will be used
+      #   create the protocol handler objects returned by {#connect}
+      # @param options [Hash] only used to inject behaviour during tests
       #
-      def initialize(options={})
-        @connection_timeout = options[:connection_timeout] || 5
-        @lock = Mutex.new
-        @command_queue = []
-        @unblocker = UnblockerConnection.new(*IO.pipe)
-        @connections = [@unblocker]
+      def initialize(protocol_handler_factory, options={})
+        @protocol_handler_factory = protocol_handler_factory
+        @unblocker = Unblocker.new
+        @io_loop = IoLoopBody.new(options)
+        @io_loop.add_socket(@unblocker)
+        @running = false
+        @stopped = false
         @started_future = Future.new
         @stopped_future = Future.new
-        @running = false
+        @lock = Mutex.new
       end
 
-      # Returns whether or not the reactor is running
+      # Register to receive notifications when the reactor shuts down because
+      # on an irrecoverable error.
+      #
+      # The listener block will be called in the reactor thread. Any errors that
+      # it raises will be ignored.
+      #
+      # @yield [error] the error that cause the reactor to stop
+      #
+      def on_error(&listener)
+        @stopped_future.on_failure(&listener)
+      end
+
+      # Returns true as long as the reactor is running. It will be true even
+      # after #stop has been called, but false when the future returned by
+      # #stop completes.
       #
       def running?
         @running
       end
 
-      # Starts the reactor.
-      #
-      # Calling this method when the reactor is connecting or is connected has
-      # no effect.
+      # Starts the reactor. This will spawn a background thread that will manage
+      # all connections.
       #
-      # @return [Future<nil>] a future which completes when the reactor has started
+      # This method is asynchronous and returns a future which completes when
+      # the reactor has started.
       #
+      # @return [Cql::Future] a future that will resolve to the reactor itself
       def start
         @lock.synchronize do
-          unless @running
-            @running = true
-            @reactor_thread = Thread.start do
-              begin
-                @started_future.complete!
-                io_loop
-                @stopped_future.complete!
-              rescue => e
-                @stopped_future.fail!(e)
-                raise
-              end
+          raise ReactorError, 'Cannot start a stopped IO reactor' if @stopped
+          return @started_future if @running
+          @running = true
+        end
+        Thread.start do
+          @started_future.complete!(self)
+          begin
+            @io_loop.tick until @stopped
+          ensure
+            @io_loop.close_sockets
+            @running = false
+            if $!
+              @stopped_future.fail!($!)
+            else
+              @stopped_future.complete!(self)
             end
           end
         end
@@ -58,208 +149,145 @@ module Cql
 
       # Stops the reactor.
       #
-      # Calling this method when the reactor is stopping or has stopped has
-      # no effect.
+      # This method is asynchronous and returns a future which completes when
+      # the reactor has completely stopped, or fails with an error if the reactor
+      # stops or has already stopped because of a failure.
       #
-      # @return [Future<nil>] a future which completes when the reactor has stopped
+      # @return [Cql::Future] a future that will resolve to the reactor itself
       #
       def stop
-        @running = false
-        command_queue_push(nil)
+        @stopped = true
         @stopped_future
       end
 
-      # Establish a new connection.
+      # Opens a connection to the specified host and port.
       #
-      # @param [String] host The hostname to connect to
-      # @param [Integer] port The port to connect to
-      # @return [Future<Object>] a future representing the ID of the newly
-      #   established connection, or connection error if the connection fails.
+      # This method is asynchronous and returns a future which completes when
+      # the connection has been established, or fails if the connection cannot
+      # be established for some reason (the connection takes longer than the
+      # specified timeout, the remote host cannot be found, etc.).
       #
-      def add_connection(host, port)
-        connection = NodeConnection.new(host, port, @connection_timeout)
-        connection.on_close do
-          @lock.synchronize do
-            @connections.delete(connection)
-            connection_commands, @command_queue = @command_queue.partition do |command|
-              command.is_a?(TargetedRequestCommand) && command.connection_id == connection.connection_id
-            end
-            connection_commands.each do |command|
-              command.future.fail!(ConnectionClosedError.new)
-            end
-          end
-        end
-        f = connection.open
-        @lock.synchronize do
-          @connections << connection
-        end
-        command_queue_push(nil)
-        f
-      end
-
-      # Sends a request over a random, or specific connection.
+      # The object returned in the future will be an instance of the protocol
+      # handler class you passed to {#initialize}.
       #
-      # @param [Cql::Protocol::Request] request the request to send
-      # @param [Object] connection_id the ID of the connection which should be
-      #   used to send the request
-      # @return [Future<ResultResponse>] a future representing the result of the request
+      # @param host [String] the host to connect to
+      # @param port [Integer] the port to connect to
+      # @param timeout [Numeric] the number of seconds to wait for a connection
+      #   before failing
+      # @return [Cql::Future] a future that will resolve to a protocol handler
+      #   object that will be your interface to interact with the connection
       #
-      def queue_request(request, connection_id=nil)
-        command = connection_id ? TargetedRequestCommand.new(request, connection_id) : RequestCommand.new(request)
-        command_queue_push(command)
-        command.future
+      def connect(host, port, timeout)
+        connection = Connection.new(host, port, timeout, @unblocker)
+        f = connection.connect
+        protocol_handler = @protocol_handler_factory.new(connection)
+        @io_loop.add_socket(connection)
+        @unblocker.unblock!
+        f.map { protocol_handler }
       end
 
-      # Registers a listener to receive server sent events.
-      #
-      # @yieldparam [Cql::Protocol::EventResponse] event the event sent by the server
-      #
-      def add_event_listener(&listener)
-        command_queue_push(EventListenerCommand.new(listener))
+      def to_s
+        @io_loop.to_s
       end
+    end
 
-      private
-
-      def io_loop
-        while running?
-          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)
-          @connections.each do |connection|
-            if connection.connecting?
-              connection.handle_connecting
-            end
-          end
-          if running?
-            perform_queued_commands
-          end
-        end
-      ensure
-        stop
-        @connections.dup.each do |connection|
-          begin
-            connection.close
-          rescue IOError => e
-          end
-        end
+    # @private
+    class Unblocker
+      def initialize
+        @out, @in = IO.pipe
+        @lock = Mutex.new
       end
 
-      def command_queue_push(command)
-        if command
-          @lock.synchronize do
-            @command_queue << command
-          end
-        end
-        @unblocker.unblock!
+      def connected?
+        true
       end
 
-      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?
-                unexecuted_commands << command
-              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 = unexecuted_commands
-        end
+      def connecting?
+        false
       end
-    end
-
-    class EventListenerCommand
-      attr_reader :listener
 
-      def initialize(listener)
-        @listener = listener
+      def writable?
+        false
       end
-    end
-
-    class RequestCommand
-      attr_reader :future, :request
 
-      def initialize(request)
-        @request = request
-        @future = Future.new
+      def closed?
+        @in.nil?
       end
-    end
-
-    class TargetedRequestCommand < RequestCommand
-      attr_reader :connection_id
 
-      def initialize(request, connection_id)
-        super(request)
-        @connection_id = connection_id
+      def unblock!
+        @lock.synchronize do
+          @in.write(PING_BYTE)
+        end
       end
-    end
 
-    class UnblockerConnection
-      def initialize(*args)
-        @out, @in = args
+      def read
+        @out.read_nonblock(2**16)
       end
 
-      def unblock!
-        @in.write(PING_BYTE)
+      def close
+        @in.close
+        @out.close
+        @in = nil
+        @out = nil
       end
 
       def to_io
         @out
       end
 
-      def close
+      def to_s
+        %(#<#{self.class.name}>)
       end
 
-      def on_event; end
-
-      def on_close; end
+      private
 
-      def connection_id
-        -1
-      end
+      PING_BYTE = "\0".freeze
+    end
 
-      def connected?
-        true
+    # @private
+    class IoLoopBody
+      def initialize(options={})
+        @selector = options[:selector] || IO
+        @lock = Mutex.new
+        @sockets = []
       end
 
-      def connecting?
-        false
+      def add_socket(socket)
+        @lock.synchronize do
+          sockets = @sockets.dup
+          sockets << socket
+          @sockets = sockets
+        end
       end
 
-      def can_write?
-        false
+      def close_sockets
+        @sockets.each do |s|
+          begin
+            s.close unless s.closed?
+          rescue
+            # the socket had most likely already closed due to an error
+          end
+        end
       end
 
-      def has_capacity?
-        false
+      def tick(timeout=1)
+        readables, writables, connecting = [], [], []
+        sockets = @sockets
+        sockets.reject! { |s| s.closed? }
+        sockets.each do |s|
+          readables << s if s.connected?
+          writables << s if s.connecting? || s.writable?
+          connecting << s if s.connecting?
+        end
+        r, w, _ = @selector.select(readables, writables, nil, timeout)
+        connecting.each(&:connect)
+        r && r.each(&:read)
+        w && w.each(&:flush)
       end
 
-      def handle_read
-        @out.read_nonblock(2**16)
+      def to_s
+        %(#<#{IoReactor.name} @connections=[#{@sockets.map(&:to_s).join(', ')}]>)
       end
-
-      private
-
-      PING_BYTE = "\0".freeze
     end
   end
 end