ione 1.3.0.pre1 → 1.3.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a30c2a01cc8a7803d8709c93735b4e860cbc2744
-  data.tar.gz: 4dbba5e04c9c8ae95d3588d377f645bcc8edef7c
+  metadata.gz: 21dcca9fc4413a5b2487e3773e276ef7b3ae0814
+  data.tar.gz: 641d648b3d338383fe12e724afcace063043c18a
 SHA512:
-  metadata.gz: cef52539a1cc94bf977a83f73417be683cb31c3685f34915176b25ae21fd95e8ed365f5aba48938b257bcf858368e17471a645b8b6dc0a6a08181da3d734fc0e
-  data.tar.gz: 374274bee30bf02895b893590e1a33fae294e1763ae959d7f2442519e42617dd65b57d715f7db891875b04e9ee612fef437a838dd40175cc0f4cff1e4d23dcb3
+  metadata.gz: 39f1108d6069ed37f168d68219ad6aebbe06fda839c7c238eea0cdf30bd27e4c15cf2aedd533e49b08abef170cfa2ef480a72471e9e44ca86b3e30dc491044be
+  data.tar.gz: 8faf34f893c4b913473734c66239145d41c0c1374c4db6571c03207c55d6bd8a5a38fe94724a2193541697f19cbf0c408cd19cacdd0382da87a4664b7be9ea91

data/lib/ione/byte_buffer.rb

@@ -176,7 +176,7 @@ module Ione
 
     # Return the nt:h byte of the buffer, without removing it, and decode it as a signed or unsigned integer.
     #
-    # @param [Integer] the zero-based positive position of the byte to read
+    # @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
@@ -253,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
 
@@ -674,35 +700,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
 

data/lib/ione/io/base_connection.rb

@@ -163,18 +163,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/io_reactor.rb

@@ -95,7 +95,8 @@ module Ione
         @clock = options[:clock] || Time
         @state = PENDING_STATE
         @error_listeners = []
-        @io_loop = IoLoopBody.new(@options)
+        @unblocker = Unblocker.new
+        @io_loop = IoLoopBody.new(@unblocker, @options)
         @scheduler = Scheduler.new
         @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)

data/lib/ione/version.rb

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

data/spec/ione/byte_buffer_spec.rb

@@ -330,6 +330,28 @@ module Ione
         x.bytesize.should be <= buffer.bytesize
         buffer.to_str.should start_with(x)
       end
+
+      it 'considers contents in the write when read buffer consumed' do
+        buffer.append('foo')
+        buffer.append('bar')
+        buffer.read_byte
+        buffer.discard(5)
+        buffer.append('hello')
+        x = buffer.cheap_peek
+        x.bytesize.should be > 0
+        x.bytesize.should be <= buffer.bytesize
+        buffer.to_str.should start_with(x)
+      end
+
+      it 'returns nil in readonly mode when read buffer is consumed' do
+        buffer.append('foo')
+        buffer.append('bar')
+        buffer.read_byte
+        buffer.discard(5)
+        buffer.append('hello')
+        x = buffer.cheap_peek(true)
+        x.should be_nil
+      end
     end
 
     describe '#getbyte' do

data/spec/ione/io/io_reactor_spec.rb

@@ -184,18 +184,17 @@ module Ione
         end
 
         it 'keeps running until stop completes' do
-          running_barrier = Queue.new
-          stop_barrier = Queue.new
+          barrier = Queue.new
           selector.handler do
-            running_barrier.push(nil)
-            stop_barrier.pop
+            barrier.pop
             [[], [], []]
           end
           reactor.start.value
           future = reactor.stop
-          running_barrier.pop
+          barrier.push(nil)
           reactor.should be_running
-          stop_barrier.push(nil) until future.completed?
+          barrier.push(nil) until future.completed?
+          reactor.should_not be_running
         end
 
         it 'unblocks the reactor' do
@@ -713,7 +712,11 @@ module Ione
 
     describe IoLoopBody do
       let :loop_body do
-        described_class.new(selector: selector, clock: clock)
+        described_class.new(unblocker, selector: selector, clock: clock)
+      end
+
+      let :unblocker do
+        double(:unblocker, connected?: true, connecting?: false, writable?: false, closed?: false)
       end
 
       let :selector do
@@ -728,14 +731,24 @@ module Ione
         double(:socket, connected?: false, connecting?: false, writable?: false, closed?: false)
       end
 
+      before do
+        unblocker.stub(:close) { unblocker.stub(:closed?).and_return(true) }
+      end
+
       describe '#tick' do
         before do
           loop_body.add_socket(socket)
         end
 
+        it 'passes the unblocker to the selector as the first readable' do
+          socket.stub(:connected?).and_return(true)
+          selector.should_receive(:select).with([unblocker, socket], anything, anything, anything).and_return([nil, nil, nil])
+          loop_body.tick
+        end
+
         it 'passes connected sockets as readables to the selector' do
           socket.stub(:connected?).and_return(true)
-          selector.should_receive(:select).with([socket], anything, anything, anything).and_return([nil, nil, nil])
+          selector.should_receive(:select).with([unblocker, socket], anything, anything, anything).and_return([nil, nil, nil])
           loop_body.tick
         end
 
@@ -748,7 +761,7 @@ module Ione
         it 'passes writable sockets as both readable and writable to the selector' do
           socket.stub(:connected?).and_return(true)
           socket.stub(:writable?).and_return(true)
-          selector.should_receive(:select).with([socket], [socket], anything, anything).and_return([nil, nil, nil])
+          selector.should_receive(:select).with([unblocker, socket], [socket], anything, anything).and_return([nil, nil, nil])
           loop_body.tick
         end
 
@@ -761,7 +774,7 @@ module Ione
 
         it 'filters out closed sockets' do
           socket.stub(:closed?).and_return(true)
-          selector.should_receive(:select).with([], [], anything, anything).and_return([nil, nil, nil])
+          selector.should_receive(:select).with([unblocker], [], anything, anything).and_return([nil, nil, nil])
           loop_body.tick
         end
 
@@ -805,7 +818,7 @@ module Ione
         end
 
         it 'allows the caller to specify a custom timeout' do
-          loop_body = described_class.new(selector: selector, clock: clock, tick_resolution: 99)
+          loop_body = described_class.new(unblocker, selector: selector, clock: clock, tick_resolution: 99)
           selector.should_receive(:select).with(anything, anything, anything, 99).and_return([[], [], []])
           loop_body.tick
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ione
 version: !ruby/object:Gem::Version
-  version: 1.3.0.pre1
+  version: 1.3.0.pre2
 platform: ruby
 authors:
 - Theo Hultberg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-17 00:00:00.000000000 Z
+date: 2016-05-17 00:00:00.000000000 Z
 dependencies: []
 description: Reactive programming framework for Ruby, painless evented IO, futures
   and an efficient byte buffer