ione 1.0.0 → 1.1.0.pre0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a27826f7fa9dee9d27d134b297bb4ce709e91c52
-  data.tar.gz: 151e10014cc157ce72e022491a2935b8cab92aa6
+  metadata.gz: 6454a46df7484d84b651eec23a73e5c0e04f3530
+  data.tar.gz: e3a48a9e32efc7a42f511b65f6ba248518df01e3
 SHA512:
-  metadata.gz: 3e254438d43b4e75ab39c435d49677f277ba6275905752f22ac69c14e90cd843981eeda525cc9385211ea2679b7aa95ae31c8e174a2ad448b5503304d6056fc2
-  data.tar.gz: 05e82e1103403c4ba0a6af5c99ab712f6f9d4da4d537b1f5327279e324e7d3b5d7baffabc8c59f287fbf30ca41ddc25245711df69b423f78127365f0c61e4e57
+  metadata.gz: bad31d689dea8e64182be056b877d7a4b4b12c4bbdebfe5b54c1b6eef1daaac9c9ff7e3705cc61bd68cbc6c1b6eeee7c6e228164de7b08a6cfd6a6bb0862ba7c
+  data.tar.gz: 75a8718bbbef223e86776b70e85e3ed4b382702c89f320bdfec5cb594dec95904d9913048283108834d2b7a5640256ee63ade40dfe269e16d6ac9b74ee0a33c4

data/lib/ione/io/acceptor.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+
+
+module Ione
+  module Io
+    class Acceptor
+      ServerSocket = RUBY_ENGINE == 'jruby' ? ::ServerSocket : Socket
+
+      def initialize(host, port, backlog, unblocker, reactor, socket_impl=nil)
+        @host = host
+        @port = port
+        @backlog = backlog
+        @unblocker = unblocker
+        @reactor = reactor
+        @socket_impl = socket_impl || ServerSocket
+        @accept_listeners = []
+        @lock = Mutex.new
+      end
+
+      def on_accept(&listener)
+        @lock.synchronize do
+          @accept_listeners << listener
+        end
+      end
+
+      def bind
+        addrinfos = @socket_impl.getaddrinfo(@host, @port, nil, Socket::SOCK_STREAM)
+        begin
+          _, port, _, ip, address_family, socket_type = addrinfos.shift
+          @socket = @socket_impl.new(address_family, socket_type, 0)
+          bind_socket(@socket, @socket_impl.sockaddr_in(port, ip), @backlog)
+        rescue Errno::EADDRNOTAVAIL => e
+          if addrinfos.empty?
+            raise
+          else
+            retry
+          end
+        end
+        Future.resolved(self)
+      rescue => e
+        Future.failed(e)
+      end
+
+      def close
+        return false unless @socket
+        begin
+          @socket.close
+        rescue SystemCallError, IOError
+          # nothing to do, the socket was most likely already closed
+        end
+        @socket = nil
+        true
+      end
+
+      def to_io
+        @socket
+      end
+
+      def closed?
+        @socket.nil?
+      end
+
+      def connected?
+        !closed?
+      end
+
+      def connecting?
+        false
+      end
+
+      def writable?
+        false
+      end
+
+      def read
+        client_socket, client_sockaddr = @socket.accept_nonblock
+        port, host = @socket_impl.unpack_sockaddr_in(client_sockaddr)
+        connection = ServerConnection.new(client_socket, host, port, @unblocker)
+        @reactor.accept(connection)
+        listeners = @lock.synchronize { @accept_listeners }
+        listeners.each { |l| l.call(connection) rescue nil }
+      end
+
+      if RUBY_ENGINE == 'jruby'
+        def bind_socket(socket, addr, backlog)
+          socket.bind(addr, backlog)
+        end
+      else
+        def bind_socket(socket, addr, backlog)
+          socket.bind(addr)
+          socket.listen(backlog)
+        end
+      end
+    end
+  end
+end

data/lib/ione/io/base_connection.rb

@@ -0,0 +1,162 @@
+# encoding: utf-8
+
+module Ione
+  module Io
+    class BaseConnection
+      attr_reader :host, :port
+
+      def initialize(host, port)
+        @host = host
+        @port = port
+        @state = :connecting
+        @closed_promise = Promise.new
+      end
+
+      # Closes the connection
+      #
+      # @return [true, false] returns false if the connection was already closed
+      def close(cause=nil)
+        return false if @state == :closed
+        if @io
+          begin
+            @io.close
+            @io = nil
+          rescue SystemCallError, IOError
+            # nothing to do, the socket was most likely already closed
+          end
+        end
+        @state = :closed
+        if cause
+          @closed_promise.fail(cause)
+        else
+          @closed_promise.fulfill(self)
+        end
+        true
+      end
+
+      # Wait for the connection's buffers to empty and then close it.
+      #
+      # This method is almost always preferable to {#close}.
+      #
+      # @return [Ione::Future] a future that resolves to the connection when it
+      #   has closed
+      def drain
+        @state = :draining
+        close if @write_buffer.empty?
+        @closed_promise.future
+      end
+
+      # @private
+      def connecting?
+        @state == :connecting
+      end
+
+      # Returns true if the connection is connected
+      def connected?
+        @state == :connected
+      end
+
+      # Returns true if the connection is closed
+      def closed?
+        @state == :closed
+      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.
+      #
+      # 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_promise.future.on_value { listener.call(nil) }
+        @closed_promise.future.on_failure { |e| listener.call(e) }
+      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 [Ione::ByteBuffer] the connection's internal buffer
+      # @param bytes [String, Ione::ByteBuffer] the data to write to the socket
+      def write(bytes=nil)
+        if @state == :connected || @state == :connecting
+          @lock.synchronize do
+            if block_given?
+              yield @write_buffer
+            elsif bytes
+              @write_buffer.append(bytes)
+            end
+          end
+          @unblocker.unblock!
+        end
+      end
+
+      # @private
+      def flush
+        if @state == :connected || @state == :draining
+          @lock.synchronize do
+            unless @write_buffer.empty?
+              bytes_written = @io.write_nonblock(@write_buffer.cheap_peek)
+              @write_buffer.discard(bytes_written)
+            end
+            if @state == :draining && @write_buffer.empty?
+              close
+            end
+          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
+        %(#<#{self.class.name} #{@state} #{@host}:#{@port}>)
+      end
+    end
+  end
+end

data/lib/ione/io/connection.rb

@@ -1,27 +1,23 @@
 # encoding: utf-8
 
-require 'socket'
-
-
 module Ione
   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
+    class Connection < BaseConnection
+      attr_reader :connection_timeout
 
       # @private
       def initialize(host, port, connection_timeout, unblocker, clock, socket_impl=Socket)
-        @host = host
-        @port = port
+        super(host, port)
         @connection_timeout = connection_timeout
         @unblocker = unblocker
         @clock = clock
         @socket_impl = socket_impl
         @lock = Mutex.new
-        @connected = false
         @write_buffer = ByteBuffer.new
         @connected_promise = Promise.new
+        on_closed(&method(:cleanup_on_close))
       end
 
       # @private
@@ -38,11 +34,11 @@ module Ione
           end
           unless connected?
             @io.connect_nonblock(@sockaddr)
-            @connected = true
+            @state = :connected
             @connected_promise.fulfill(self)
           end
         rescue Errno::EISCONN
-          @connected = true
+          @state = :connected
           @connected_promise.fulfill(self)
         rescue Errno::EINPROGRESS, Errno::EALREADY
           if @clock.now - @connection_started_at > @connection_timeout
@@ -58,157 +54,20 @@ module Ione
         rescue SystemCallError => e
           close(e)
         rescue SocketError => e
-          close(e) || closed!(e)
+          close(e) || cleanup_on_close(e)
         end
         @connected_promise.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 [Ione::ByteBuffer] the connection's internal buffer
-      # @param bytes [String, Ione::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
-            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
+      def cleanup_on_close(cause)
         if cause && !cause.is_a?(IoError)
           cause = ConnectionError.new(cause.message)
         end
-        unless connected?
+        unless @connected_promise.future.completed?
           @connected_promise.fail(cause)
         end
-        @connected = false
-        if @closed_listener
-          @closed_listener.call(cause)
-        end
       end
     end
   end

data/lib/ione/io/io_reactor.rb

@@ -171,6 +171,21 @@ module Ione
         f
       end
 
+      def bind(host, port, backlog, &block)
+        server = Acceptor.new(host, port, backlog, @unblocker, self)
+        f = server.bind
+        @io_loop.add_socket(server)
+        @unblocker.unblock!
+        f = f.map(&block) if block_given?
+        f
+      end
+
+      # @private
+      def accept(socket)
+        @io_loop.add_socket(socket)
+        @unblocker.unblock!
+      end
+
       # Returns a future that completes after the specified number of seconds.
       #
       # @param timeout [Float] the number of seconds to wait until the returned

data/lib/ione/io/server_connection.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Ione
+  module Io
+    class ServerConnection < BaseConnection
+      # @private
+      def initialize(socket, host, port, unblocker)
+        super(host, port)
+        @io = socket
+        @unblocker = unblocker
+        @lock = Mutex.new
+        @write_buffer = ByteBuffer.new
+        @state = :connected
+      end
+    end
+  end
+end

data/lib/ione/io.rb

@@ -1,5 +1,8 @@
 # encoding: utf-8
 
+require 'socket'
+
+
 module Ione
   CancelledError = Class.new(StandardError)
   IoError = Class.new(StandardError)
@@ -12,4 +15,7 @@ module Ione
 end
 
 require 'ione/io/io_reactor'
+require 'ione/io/base_connection'
 require 'ione/io/connection'
+require 'ione/io/server_connection'
+require 'ione/io/acceptor'

data/lib/ione/version.rb

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

data/spec/integration/io_spec.rb

@@ -8,7 +8,7 @@ describe 'An IO reactor' do
     Ione::Io::IoReactor.new
   end
 
-  context 'with a generic server' do
+  context 'connecting to a generic server' do
     let :protocol_handler_factory do
       lambda { |c| IoSpec::TestConnection.new(c) }
     end
@@ -28,12 +28,12 @@ describe 'An IO reactor' do
     end
 
     it 'connects to the server' do
-      io_reactor.connect(ENV['SERVER_HOST'], fake_server.port, 1).map(&protocol_handler_factory)
+      io_reactor.connect(ENV['SERVER_HOST'], fake_server.port, 1, &protocol_handler_factory)
       fake_server.await_connects!(1)
     end
 
     it 'receives data' do
-      protocol_handler = io_reactor.connect(ENV['SERVER_HOST'], fake_server.port, 1).map(&protocol_handler_factory).value
+      protocol_handler = io_reactor.connect(ENV['SERVER_HOST'], fake_server.port, 1, &protocol_handler_factory).value
       fake_server.await_connects!(1)
       fake_server.broadcast!('hello world')
       await { protocol_handler.data.bytesize > 0 }
@@ -41,13 +41,50 @@ describe 'An IO reactor' do
     end
 
     it 'receives data on multiple connections' do
-      protocol_handlers = Array.new(10) { io_reactor.connect(ENV['SERVER_HOST'], fake_server.port, 1).map(&protocol_handler_factory).value }
+      protocol_handlers = Array.new(10) { io_reactor.connect(ENV['SERVER_HOST'], fake_server.port, 1, &protocol_handler_factory).value }
       fake_server.await_connects!(10)
       fake_server.broadcast!('hello world')
       await { protocol_handlers.all? { |c| c.data.bytesize > 0 } }
       protocol_handlers.sample.data.should == 'hello world'
     end
   end
+
+  context 'running an echo server' do
+    let :protocol_handler_factory do
+      lambda do |acceptor|
+        acceptor.on_accept do |connection|
+          connection.on_data do |data|
+            connection.write(data)
+          end
+        end
+      end
+    end
+
+    let :port do
+      2**15 + rand(2**15)
+    end
+
+    before do
+      io_reactor.start.value
+    end
+
+    after do
+      io_reactor.stop.value
+    end
+
+    it 'starts a server' do
+      io_reactor.bind(ENV['SERVER_HOST'], port, 1, &protocol_handler_factory).value
+    end
+
+    it 'starts a server that listens to the specified port' do
+      io_reactor.bind(ENV['SERVER_HOST'], port, 1, &protocol_handler_factory).value
+      socket = TCPSocket.new(ENV['SERVER_HOST'], port)
+      socket.puts('HELLO')
+      result = socket.read(5)
+      result.should == 'HELLO'
+      socket.close
+    end
+  end
 end
 
 module IoSpec