ione 1.2.0 → 1.2.1

data/lib/ione/io/connection.rb

@@ -4,6 +4,7 @@ module Ione
   module Io
     # A wrapper around a socket. Handles connecting to the remote host, reading
     # from and writing to the socket.
+    # @since v1.0.0
     class Connection < BaseConnection
       attr_reader :connection_timeout
 
@@ -31,11 +32,11 @@ module Ione
           end
           unless connected?
             @io.connect_nonblock(@sockaddr)
-            @state = :connected
+            @state = CONNECTED_STATE
             @connected_promise.fulfill(self)
           end
         rescue Errno::EISCONN
-          @state = :connected
+          @state = CONNECTED_STATE
           @connected_promise.fulfill(self)
         rescue Errno::EINPROGRESS, Errno::EALREADY
           if @clock.now - @connection_started_at > @connection_timeout

data/lib/ione/io/io_reactor.rb

@@ -78,20 +78,25 @@ module Ione
     #       # get data back.
     #     end
     #   end
+    #
+    # @since v1.0.0
     class IoReactor
+      PENDING_STATE = 0
+      RUNNING_STATE = 1
+      CRASHED_STATE = 2
+      STOPPING_STATE = 3
+      STOPPED_STATE = 4
+
       # Initializes a new IO reactor.
       #
       # @param options [Hash] only used to inject behaviour during tests
       def initialize(options={})
+        @options = options
         @clock = options[:clock] || Time
-        @unblocker = Unblocker.new
-        @io_loop = IoLoopBody.new(options)
-        @io_loop.add_socket(@unblocker)
+        @state = PENDING_STATE
+        @error_listeners = []
+        @io_loop = IoLoopBody.new(@options)
         @scheduler = Scheduler.new
-        @running = false
-        @stopped = false
-        @started_promise = Promise.new
-        @stopped_promise = Promise.new
         @lock = Mutex.new
       end
 
@@ -103,14 +108,23 @@ module Ione
       #
       # @yield [error] the error that cause the reactor to stop
       def on_error(&listener)
-        @stopped_promise.future.on_failure(&listener)
+        @lock.lock
+        begin
+          @error_listeners = @error_listeners.dup
+          @error_listeners << listener
+        ensure
+          @lock.unlock
+        end
+        if @state == RUNNING_STATE || @state == CRASHED_STATE
+          @stopped_promise.future.on_failure(&listener)
+        end
       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
+        @state == RUNNING_STATE
       end
 
       # Starts the reactor. This will spawn a background thread that will manage
@@ -122,25 +136,41 @@ module Ione
       # @return [Ione::Future] a future that will resolve to the reactor itself
       def start
         @lock.synchronize do
-          raise ReactorError, 'Cannot start a stopped IO reactor' if @stopped
-          return @started_promise.future if @running
-          @running = true
+          if @state == RUNNING_STATE
+            return @started_promise.future
+          elsif @state == STOPPING_STATE
+            return @stopped_promise.future.flat_map { start }.fallback { start }
+          else
+            @state = RUNNING_STATE
+          end
+        end
+        @unblocker = Unblocker.new
+        @io_loop.add_socket(@unblocker)
+        @started_promise = Promise.new
+        @stopped_promise = Promise.new
+        @error_listeners.each do |listener|
+          @stopped_promise.future.on_failure(&listener)
         end
         Thread.start do
           @started_promise.fulfill(self)
           begin
-            until @stopped
+            while @state == RUNNING_STATE
               @io_loop.tick
               @scheduler.tick
             end
           ensure
-            @io_loop.close_sockets
-            @scheduler.cancel_timers
-            @running = false
-            if $!
-              @stopped_promise.fail($!)
-            else
-              @stopped_promise.fulfill(self)
+            begin
+              @io_loop.close_sockets
+              @scheduler.cancel_timers
+              @unblocker = nil
+            ensure
+              if $!
+                @state = CRASHED_STATE
+                @stopped_promise.fail($!)
+              else
+                @state = STOPPED_STATE
+                @stopped_promise.fulfill(self)
+              end
             end
           end
         end
@@ -155,12 +185,29 @@ module Ione
       #
       # @return [Ione::Future] a future that will resolve to the reactor itself
       def stop
-        @stopped = true
-        @stopped_promise.future
+        @lock.synchronize do
+          if @state == PENDING_STATE
+            Future.resolved(self)
+          elsif @state != STOPPED_STATE && @state != CRASHED_STATE
+            @state = STOPPING_STATE
+            @stopped_promise.future
+          else
+            @stopped_promise.future
+          end
+        end
       end
 
       # Opens a connection to the specified host and port.
       #
+      # @example A naive HTTP client
+      #   connection_future = reactor.connect('example.com', 80)
+      #   connection_future.on_value do |connection|
+      #     connection.write("GET / HTTP/1.1\r\nHost: example.com\r\n\r\n")
+      #     connection.on_data do |data|
+      #       print(data)
+      #     end
+      #   end
+      #
       # @param host [String] the host to connect to
       # @param port [Integer] the port to connect to
       # @param options [Hash, Numeric] a hash of options (see below)
@@ -172,8 +219,8 @@ module Ione
       #   or true to upgrade the connection and create a new context.
       # @yieldparam [Ione::Io::Connection] connection the newly opened connection
       # @return [Ione::Future] a future that will resolve when the connection is
-      #   open. The value will be the connection, or when a block is given to
-      #   what the block returns
+      #   open. The value will be the connection, or when a block is given the
+      #   value returned by the block.
       def connect(host, port, options=nil, &block)
         if options.is_a?(Numeric) || options.nil?
           timeout = options || 5
@@ -185,7 +232,7 @@ module Ione
         connection = Connection.new(host, port, timeout, @unblocker, @clock)
         f = connection.connect
         @io_loop.add_socket(connection)
-        @unblocker.unblock
+        @unblocker.unblock if running?
         if ssl
           f = f.flat_map do
             ssl_context = ssl == true ? nil : ssl
@@ -201,6 +248,60 @@ module Ione
         f
       end
 
+      # Starts a server bound to the specified host and port.
+      #
+      # A server is represented by an {Acceptor}, which wraps the server socket
+      # and accepts client connections. By registering to be notified on new
+      # connections, via {Acceptor#on_accept}, you can attach your server
+      # handling code to a connection.
+      #
+      # @example An echo server
+      #   acceptor_future = reactor.bind('0.0.0.0', 11111)
+      #   acceptor_future.on_value do |acceptor|
+      #     acceptor.on_accept do |connection|
+      #       connection.on_data do |data|
+      #         connection.write(data)
+      #       end
+      #     end
+      #   end
+      #
+      # @example A more realistic server template
+      #   class EchoServer
+      #     def initialize(acceptor)
+      #       @acceptor = acceptor
+      #       @acceptor.on_accept do |connection|
+      #         handle_connection(connection)
+      #       end
+      #     end
+      #
+      #     def handle_connection(connection)
+      #       connection.on_data do |data|
+      #         connection.write(data)
+      #       end
+      #     end
+      #   end
+      #
+      #   server_future = reactor.bind('0.0.0.0', 11111) do |acceptor|
+      #     EchoServer.new(acceptor)
+      #   end
+      #
+      #   server_future.on_value do |echo_server|
+      #     # this is called when the server has started
+      #   end
+      #
+      # @param host [String] the host to bind to, for example 127.0.0.1,
+      #   'example.com' – or '0.0.0.0' to bind to all interfaces
+      # @param port [Integer] the port to bind to
+      # @param options [Hash]
+      # @option options [Integer] :backlog (5) the maximum number of pending
+      #   (unaccepted) connections, i.e. Socket::SOMAXCONN
+      # @option options [OpenSSL::SSL::SSLContext] :ssl (nil) when specified the
+      #   server will use this SSLContext to encrypt connections
+      # @yieldparam [Ione::Io::Acceptor] the acceptor instance for this server
+      # @return [Ione::Future] a future that will resolve when the server is
+      #   bound. The value will be the acceptor, or when a block is given, the
+      #   value returned by the block.
+      # @since v1.1.0
       def bind(host, port, options=nil, &block)
         if options.is_a?(Integer) || options.nil?
           backlog = options || 5
@@ -216,7 +317,7 @@ module Ione
         end
         f = server.bind
         @io_loop.add_socket(server)
-        @unblocker.unblock
+        @unblocker.unblock if running?
         f = f.map(&block) if block_given?
         f
       end
@@ -241,21 +342,31 @@ module Ione
       # The timer will fail with a {Ione::CancelledError}.
       #
       # @param timer_future [Ione::Future] the future returned by {#schedule_timer}
+      # @since v1.1.3
       def cancel_timer(timer_future)
         @scheduler.cancel_timer(timer_future)
       end
 
       def to_s
-        @io_loop.to_s
+        state_constant_name = self.class.constants.find do |name|
+          name.to_s.end_with?('_STATE') && self.class.const_get(name) == @state
+        end
+        state = state_constant_name.to_s.rpartition('_').first
+        %(#<#{self.class.name} #{state}>)
       end
     end
 
     # @private
     class Unblocker
+      OPEN_STATE = 0
+      CLOSED_STATE = 1
+
       def initialize
         @out, @in = IO.pipe
         @lock = Mutex.new
-        @state = :open
+        @state = OPEN_STATE
+        @unblocked = false
+        @writables = [@in]
       end
 
       def connected?
@@ -271,14 +382,16 @@ module Ione
       end
 
       def closed?
-        @state == :closed
+        @state == CLOSED_STATE
       end
 
       def unblock
-        unless closed?
+        if @state != CLOSED_STATE
           @lock.lock
           begin
-            @in.write(PING_BYTE)
+            if @state != CLOSED_STATE && IO.select(nil, @writables, nil, 0)
+              @in.write_nonblock(PING_BYTE)
+            end
           ensure
             @lock.unlock
           end
@@ -286,15 +399,19 @@ module Ione
       end
 
       def read
-        unless closed?
-          @out.read_nonblock(2**16)
+        @lock.lock
+        if @state != CLOSED_STATE
+          @out.read_nonblock(65536)
+          @unblocked = false
         end
+      ensure
+        @lock.unlock
       end
 
       def close
         @lock.synchronize do
-          return if @state == :closed
-          @state = :closed
+          return if @state == CLOSED_STATE
+          @state = CLOSED_STATE
         end
         @in.close
         @out.close
@@ -374,6 +491,7 @@ module Ione
             # the socket had most likely already closed due to an error
           end
         end
+        @sockets = []
       end
 
       def tick
@@ -452,25 +570,28 @@ module Ione
         timers.each do |timer|
           timer.fail(CancelledError.new)
         end
+        nil
       end
 
       def tick
-        now = @clock.now
-        first_timer = @timer_queue.peek
-        if first_timer && first_timer.time <= now
-          expired_timers = []
-          @lock.lock
-          begin
-            while (timer = @timer_queue.peek) && timer.time <= now
-              @timer_queue.pop
-              @pending_timers.delete(timer.future)
-              expired_timers << timer
+        unless @timer_queue.empty?
+          now = @clock.now
+          first_timer = @timer_queue.peek
+          if first_timer && first_timer.time <= now
+            expired_timers = []
+            @lock.lock
+            begin
+              while (timer = @timer_queue.peek) && timer.time <= now
+                @timer_queue.pop
+                @pending_timers.delete(timer.future)
+                expired_timers << timer
+              end
+            ensure
+              @lock.unlock
+            end
+            expired_timers.each do |timer|
+              timer.fulfill
             end
-          ensure
-            @lock.unlock
-          end
-          expired_timers.each do |timer|
-            timer.fulfill
           end
         end
       end

data/lib/ione/io/server_connection.rb

@@ -2,12 +2,13 @@
 
 module Ione
   module Io
+    # @since v1.1.0
     class ServerConnection < BaseConnection
       # @private
       def initialize(socket, host, port, unblocker)
         super(host, port, unblocker)
         @io = socket
-        @state = :connected
+        @state = CONNECTED_STATE
       end
     end
   end

data/lib/ione/io/ssl_connection.rb

@@ -23,7 +23,7 @@ module Ione
           @io = @socket_impl.new(@raw_io)
         end
         @io.connect_nonblock
-        @state = :connected
+        @state = CONNECTED_STATE
         @connected_promise.fulfill(self)
         @connected_promise.future
       rescue IO::WaitReadable, IO::WaitWritable

data/lib/ione/io/ssl_server_connection.rb

@@ -4,17 +4,20 @@ module Ione
   module Io
     # @private
     class SslServerConnection < ServerConnection
+      ACCEPTING_STATE = 0
+      ESTABLISHED_STATE = 1
+
       def initialize(socket, host, port, unblocker, ssl_context, accept_callback, ssl_socket_impl=nil)
         super(socket, host, port, unblocker)
         @ssl_context = ssl_context
         @accept_callback = accept_callback
         @ssl_socket_impl = ssl_socket_impl || OpenSSL::SSL::SSLSocket
-        @ssl_state = :accepting
+        @ssl_state = ACCEPTING_STATE
       end
 
       # @private
       def to_io
-        if @ssl_state == :established
+        if @ssl_state == ESTABLISHED_STATE
           @io.to_io
         else
           @io
@@ -22,12 +25,12 @@ module Ione
       end
 
       def read
-        if @ssl_state == :accepting
+        if @ssl_state == ACCEPTING_STATE
           begin
             @ssl_io ||= @ssl_socket_impl.new(@io, @ssl_context)
             @ssl_io.accept_nonblock
             @io = @ssl_io
-            @ssl_state = :established
+            @ssl_state = ESTABLISHED_STATE
             @accept_callback.call(self)
           rescue IO::WaitReadable
             # connection not ready yet

data/lib/ione/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Ione
-  VERSION = '1.2.0'.freeze
+  VERSION = '1.2.1'.freeze
 end