ione 1.3.0.pre0 → 1.3.0.pre3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6374a6945473a540ef416dec0eaef9f2c5a23913
-  data.tar.gz: c4b5defcacf2770af407842ee88edc7f9e172a6b
+SHA256:
+  metadata.gz: 78ca22da674434afcf1293e1b7d70bb3f13a0080b7c492f5016fb6f4f2428702
+  data.tar.gz: a50ef526b8a0163a3c2dd116a75d83b48cb6bbb79f80a4cdb0ba9e66c5c2e4b3
 SHA512:
-  metadata.gz: 72ee4392985a601b028b4e6aa170accff6e8e50c27fc2cb7674cb9b3dd5b29091e8f92b3b5e26a515f372036fcaf1727bb866e1e8165a0f9567fd1749be91bac
-  data.tar.gz: 231ee2abbb3d771d56d0fdab4c26b42f0684254b13056bf898dbce22d3ea2031e34aacc096a04dae6ee08a394ca880f03a362d7bbf9a96598becdbaaeec7e84c
+  metadata.gz: 8eb9100fc86fb57bff7a048f2d97411764df9e00fd5ec5afa921470283161a282686b9fdeea6cccd750b3dce5ea7efce666c9f6b98ef65ec3df2a3076e39c73d
+  data.tar.gz: be2df17439ad63370e7b980ab99e526080e995d65a25c3547fdfbeca34db25548ff6ba9c7b665cb1f7e4d6603d3a33398a16f9628fc5e9ad53f57f3fe9a8c455

data/lib/ione/byte_buffer.rb

@@ -174,6 +174,18 @@ module Ione
       b
     end
 
+    # Return the nt:h byte of the buffer, without removing it, and decode it as a signed or unsigned integer.
+    #
+    # @param [Integer] index the zero-based positive position of the byte to read
+    # @return [Integer, nil] the integer interpretation of the byte at the specified position, or nil when beyond buffer size.
+    def getbyte(index, signed=false)
+      if @offset+index >= @read_buffer.bytesize
+        swap_buffers
+      end
+      b = @read_buffer.getbyte(@offset+index)
+      (signed && b >= 0x80) ? b - 0x100 : b
+    end
+
     def index(substring, start_index=0)
       if @offset >= @read_buffer.bytesize
         swap_buffers
@@ -241,22 +253,35 @@ module Ione
     # in situations where a loop wants to offer some bytes but can't be sure
     # how many will be accepted — for example when writing to a socket.
     #
+    # By providing the readonly argument, the peek is even cheaper in that it
+    # only considers the read buffer. In this mode, the method returns nil
+    # to signify that the read buffer is empty. With just a single reader,
+    # like the IO reactor, where reads only happen in one thread, this means
+    # that `cheap_peek(true)` can be called without holding a lock to protect
+    # against concurrent writes
+    #
     # @example feeding bytes to a socket
     #   while true
     #     _, writables, _ = IO.select(nil, sockets)
     #     if writables
     #       writables.each do |io|
-    #         n = io.write_nonblock(buffer.cheap_peek)
+    #         bytes = buffer.cheap_peek(true)
+    #         unless bytes
+    #           bytes = buffer_lock.synchronize { buffer.cheap_peak }
+    #         end
+    #         n = io.write_nonblock(bytes)
     #         buffer.discard(n)
     #       end
     #     end
     #
-    # @return [String] some bytes from the start of the buffer
-    def cheap_peek
-      if @offset >= @read_buffer.bytesize
-        swap_buffers
+    # @param [Boolean] readonly to specify to only look at the read buffer
+    # @return [String, nil] some bytes from the start of the buffer, or nil when read buffer empty in readonly mode
+    def cheap_peek(readonly = false)
+      has_read_buffer = @offset < @read_buffer.bytesize
+      if has_read_buffer || !readonly
+        swap_buffers unless has_read_buffer
+        @read_buffer[@offset, @read_buffer.bytesize - @offset]
       end
-      @read_buffer[@offset, @read_buffer.bytesize - @offset]
     end
 
     def eql?(other)

data/lib/ione/future.rb

@@ -590,7 +590,33 @@ module Ione
       end
     end
 
+    # @since v1.3.0
+    module Blockers
+      # Awaits the completion of a future and either returns the value or raises
+      # an error.
+      #
+      # @note
+      #   This is a blocking operation and should be used with caution. You should
+      #   never call this method in a block given to any of the other methods
+      #   on {Future}. Prefer using combinator methods like {#map} and {#flat_map}
+      #   to compose operations asynchronously, or use {#on_value}, {#on_failure}
+      #   or {#on_complete} to listen for values and/or failures.
+      #
+      # @raise [Error] the error that failed this future
+      # @return [Object] the value of this future
+      def await(f)
+        semaphore = Queue.new
+        f.on_complete do |value, error|
+          semaphore << [value, error]
+        end
+        value, error = semaphore.pop
+        raise error if error
+        value
+      end
+    end
+
     extend Factories
+    extend Blockers
     include Combinators
     include Callbacks
 
@@ -599,6 +625,8 @@ module Ione
       @lock = Mutex.new
       @state = PENDING_STATE
       @listeners = []
+      @value = nil
+      @error = nil
     end
 
     # Registers a listener that will be called when this future completes,
@@ -674,35 +702,19 @@ module Ione
     #   to compose operations asynchronously, or use {#on_value}, {#on_failure}
     #   or {#on_complete} to listen for values and/or failures.
     #
+    # @deprecated
+    #   This method will be removed in the next major release.
+    #   Use {Future.await}. Synchronously waiting for the result of a future is
+    #   very rarely the right thing to do, and as the only blocking method on
+    #   {Future}, {#value} doesn't belong.
+    #
     # @raise [Error] the error that failed this future
     # @return [Object] the value of this future
     # @see Callbacks#on_value
     # @see Callbacks#on_failure
     # @see Callbacks#on_complete
     def value
-      raise @error if @state == FAILED_STATE
-      return @value if @state == RESOLVED_STATE
-      semaphore = nil
-      @lock.lock
-      begin
-        raise @error if @state == FAILED_STATE
-        return @value if @state == RESOLVED_STATE
-        semaphore = Queue.new
-        u = proc { semaphore << :unblock }
-        @listeners << u
-      ensure
-        @lock.unlock
-      end
-      while true
-        @lock.lock
-        begin
-          raise @error if @state == FAILED_STATE
-          return @value if @state == RESOLVED_STATE
-        ensure
-          @lock.unlock
-        end
-        semaphore.pop
-      end
+      Future.await(self)
     end
     alias_method :get, :value
 
@@ -859,9 +871,9 @@ module Ione
         looping = more = true
         while more
           more = false
-          @futures.pop.on_complete do |v, e|
-            if e || @futures.empty? || !looping || !Thread.current.equal?(outer)
-              await_next(v, e)
+          @futures.pop.on_complete do |value, error|
+            if error || @futures.empty? || !looping || !Thread.current.equal?(outer)
+              await_next(value, error)
             else
               more = true
             end

data/lib/ione/io/acceptor.rb

@@ -22,6 +22,7 @@ module Ione
         @backlog = backlog
         @unblocker = unblocker
         @reactor = reactor
+        @io = nil
         @socket_impl = socket_impl || ServerSocket
         @accept_listeners = []
         @lock = Mutex.new

data/lib/ione/io/base_connection.rb

@@ -15,10 +15,12 @@ module Ione
       def initialize(host, port, unblocker)
         @host = host
         @port = port
+        @io = nil
         @unblocker = unblocker
         @state = CONNECTING_STATE
         @writable = false
         @lock = Mutex.new
+        @data_listener = nil
         @write_buffer = ByteBuffer.new
         @closed_promise = Promise.new
       end
@@ -163,18 +165,29 @@ module Ione
       def flush
         should_close = false
         if @state == CONNECTED_STATE || @state == DRAINING_STATE
-          @lock.lock
-          begin
-            if @writable
-              bytes_written = @io.write_nonblock(@write_buffer.cheap_peek)
-              @write_buffer.discard(bytes_written)
+          bytes = @write_buffer.cheap_peek(true)
+          unless bytes
+            @lock.lock
+            begin
+              if @writable
+                bytes = @write_buffer.cheap_peek
+              end
+            ensure
+              @lock.unlock
             end
-            @writable = !@write_buffer.empty?
-            if @state == DRAINING_STATE && !@writable
-              should_close = true
+          end
+          if bytes
+            bytes_written = @io.write_nonblock(bytes)
+            @lock.lock
+            begin
+              @write_buffer.discard(bytes_written)
+              @writable = !@write_buffer.empty?
+              if @state == DRAINING_STATE && !@writable
+                should_close = true
+              end
+            ensure
+              @lock.unlock
             end
-          ensure
-            @lock.unlock
           end
           close if should_close
         end

data/lib/ione/io/connection.rb

@@ -14,6 +14,7 @@ module Ione
         @connection_timeout = connection_timeout
         @clock = clock
         @socket_impl = socket_impl
+        @addrinfos = nil
         @connected_promise = Promise.new
         on_closed(&method(:cleanup_on_close))
       end

data/lib/ione/io/io_reactor.rb

@@ -95,8 +95,9 @@ module Ione
         @clock = options[:clock] || Time
         @state = PENDING_STATE
         @error_listeners = []
-        @io_loop = IoLoopBody.new(@options)
-        @scheduler = Scheduler.new
+        @unblocker = Unblocker.new
+        @io_loop = IoLoopBody.new(@unblocker, @options)
+        @scheduler = Scheduler.new(@options)
         @lock = Mutex.new
       end
 
@@ -144,8 +145,6 @@ module Ione
             @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|
@@ -170,7 +169,6 @@ module Ione
               end
               @io_loop.close_sockets
               @scheduler.cancel_timers
-              @unblocker = nil
             ensure
               if error
                 @state = CRASHED_STATE
@@ -367,14 +365,13 @@ module Ione
 
     # @private
     class Unblocker
-      OPEN_STATE = 0
-      CLOSED_STATE = 1
+      BLOCKABLE_STATE = 0
+      UNBLOCKING_STATE = 1
+      CLOSED_STATE = 2
 
       def initialize
         @out, @in = IO.pipe
-        @lock = Mutex.new
-        @state = OPEN_STATE
-        @unblocked = false
+        @state = BLOCKABLE_STATE
         @writables = [@in]
       end
 
@@ -395,33 +392,26 @@ module Ione
       end
 
       def unblock
-        if @state != CLOSED_STATE
-          @lock.lock
-          begin
-            if @state != CLOSED_STATE && IO.select(nil, @writables, nil, 0)
-              @in.write_nonblock(PING_BYTE)
-            end
-          ensure
-            @lock.unlock
-          end
+        if @state == BLOCKABLE_STATE
+          @state = UNBLOCKING_STATE
+          @in.write_nonblock(PING_BYTE)
         end
+      rescue IO::WaitWritable
+        $stderr.puts('Oh noes we got blocked while writing the unblocker')
+      rescue IOError
+        $stderr.puts('Oh noes we wrote to the unblocker after it got closed, probably')
       end
 
       def read
-        @lock.lock
-        if @state != CLOSED_STATE
-          @out.read_nonblock(65536)
-          @unblocked = false
-        end
-      ensure
-        @lock.unlock
+        @out.read_nonblock(65536)
+        @state = BLOCKABLE_STATE
+      rescue IOError
+        $stderr.puts('Oh noes we read from the unblocker after it got closed, probably')
       end
 
       def close
-        @lock.synchronize do
-          return if @state == CLOSED_STATE
-          @state = CLOSED_STATE
-        end
+        return if @state == CLOSED_STATE
+        @state = CLOSED_STATE
         @in.close
         @out.close
         @in = nil
@@ -472,13 +462,13 @@ module Ione
 
     # @private
     class IoLoopBody
-      def initialize(options={})
+      def initialize(unblocker, options={})
         @selector = options[:selector] || IO
         @clock = options[:clock] || Time
         @timeout = options[:tick_resolution] || 1
         @drain_timeout = options[:drain_timeout] || 5
         @lock = Mutex.new
-        @sockets = []
+        @sockets = [unblocker]
       end
 
       def add_socket(socket)
@@ -592,8 +582,8 @@ module Ione
         ensure
           @lock.unlock
         end
-        timers.each do |timer|
-          timer.fail(CancelledError.new)
+        timers.each do |t|
+          t.fail(CancelledError.new)
         end
         nil
       end
@@ -614,8 +604,8 @@ module Ione
             ensure
               @lock.unlock
             end
-            expired_timers.each do |timer|
-              timer.fulfill
+            expired_timers.each do |t|
+              t.fulfill
             end
           end
         end
@@ -626,4 +616,4 @@ module Ione
       end
     end
   end
-end
+end

data/lib/ione/io/ssl_connection.rb

@@ -12,6 +12,7 @@ module Ione
         @socket_impl = socket_impl
         @ssl_context = ssl_context
         @raw_io = io
+        @io = nil
         @connected_promise = Promise.new
         on_closed(&method(:cleanup_on_close))
       end

data/lib/ione/version.rb

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

data/spec/integration/io_spec.rb

@@ -37,7 +37,7 @@ describe 'An IO reactor' do
       fake_server.await_connects(1)
       fake_server.broadcast('hello world')
       await { protocol_handler.data.bytesize > 0 }
-      protocol_handler.data.should == 'hello world'
+      protocol_handler.data.should eq('hello world')
     end
 
     it 'receives data on multiple connections' do
@@ -45,7 +45,7 @@ describe 'An IO reactor' do
       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'
+      protocol_handlers.sample.data.should eq('hello world')
     end
   end
 
@@ -81,7 +81,7 @@ describe 'An IO reactor' do
       socket = TCPSocket.new(ENV['SERVER_HOST'], port)
       socket.puts('HELLO')
       result = socket.read(5)
-      result.should == 'HELLO'
+      result.should eq('HELLO')
       socket.close
     end
   end

data/spec/integration/ssl_spec.rb

@@ -49,6 +49,7 @@ describe 'SSL' do
     ssl_context = OpenSSL::SSL::SSLContext.new
     ssl_context.key = OpenSSL::PKey::RSA.new(ssl_key)
     ssl_context.cert = OpenSSL::X509::Certificate.new(ssl_cert)
+    ssl_context.tmp_dh_callback = proc { SslSpec::DH_PARAMS }
 
     f = io_reactor.start
     f = f.flat_map do
@@ -80,8 +81,8 @@ describe 'SSL' do
     end
     client.write('hello world')
     response_received.future.value
-    server_received_data.to_s.should == 'hello world'
-    client_received_data.to_s.should == 'dlrow olleh'
+    server_received_data.to_s.should eq('hello world')
+    client_received_data.to_s.should eq('dlrow olleh')
   end
 
   it 'fails to send a message when not using encryption' do
@@ -95,3 +96,7 @@ describe 'SSL' do
     client.should be_closed
   end
 end
+
+module SslSpec
+  DH_PARAMS = OpenSSL::PKey::DH.new(File.read(File.expand_path('../../resources/dh.pem', __FILE__)))
+end