async 1.7.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f19a934a9510bb56c88e54ac305707a0cd68d5a74f925e56a2f6ca69c5a0bab9
-  data.tar.gz: 8c68511531f459a2c067550f369e9253d7c93064f054a08780a11f357d68a942
+  metadata.gz: 8342091acbc6da153552ca269239949b27898eb7bff55ca9425687e86f314751
+  data.tar.gz: fa8fd142667ba572fd66554d25bf9490625811f91005c9c4b0ac76f9329dba69
 SHA512:
-  metadata.gz: e1387cc04e3d358d9b39dc5f2fb59e457b173f04b3381c603a11d495f987f29c41753c6addae55fcb203e6e1a3f96bf929e45cafddf624fd374fc85b6bc8e33f
-  data.tar.gz: e76e0e5dc3c67f6d77209f501a58ca1c97dbc8f96d40081ec55d082e0f0be63e7ecd344ba4adfcbaadcc910590d1abdf4a4eab0bd4a0ab8310f5afbe5a55db7d
+  metadata.gz: f8e9d025de96cee15d9967e344a81dd01e3c3f6e64895f1deba1f2fd77edbbff2d9d7d63294cdaca6492add2112e5b0742e326c70845c52b8041b10eba96fd17
+  data.tar.gz: 4f07e3153419bd128c53c86f63fca88dcde579d906689e9bbaff488b6f782f11d3950a1f6754894f20880aa8aa09fcde50b7608c0c47b97ef0fe9314b5d5343b

data/Rakefile

@@ -21,6 +21,7 @@ task :external do
 		clone_and_test("async-io")
 		clone_and_test("async-websocket")
 		clone_and_test("async-dns")
+		clone_and_test("async-http")
 		clone_and_test("falcon")
 	end
 end

data/lib/async/{debug.rb → debug/monitor.rb}

@@ -18,11 +18,9 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'nio'
-
 module Async
-	class DebugSelector
-		class MonitorProxy
+	module Debug
+		class Monitor
 			def initialize(monitor, selector)
 				@monitor = monitor
 				@selector = selector
@@ -40,47 +38,10 @@ module Async
 			def respond_to?(*args)
 				@monitor.respond_to?(*args)
 			end
-		end
-		
-		def initialize(selector)
-			@selector = selector
-			@monitors = {}
-		end
-		
-		def register(io, interests)
-			$stderr.puts "Registering #{io.inspect} for #{interests}."
 			
-			if monitor = @monitors[io.fileno]
-				raise RuntimeError, "Trying to register monitor for #{io.inspect} but it was already registered as #{monitor.io.inspect}!"
+			def inspect
+				"\#<#{self.class} io=#{@monitor.io.inspect} interests=#{@monitor.interests.inspect} readiness=#{@monitor.readiness.inspect}>"
 			end
-			
-			@monitors[io.fileno] = io
-			
-			MonitorProxy.new(@selector.register(io, interests), self)
-		end
-		
-		def deregister(io)
-			$stderr.puts "Deregistering #{io.inspect}."
-			
-			unless @monitors.delete(io.fileno)
-				raise RuntimeError, "Trying to remove monitor for #{io.inspect} but it was not registered!"
-			end
-		end
-		
-		def wakeup
-			@selector.wakeup
-		end
-		
-		def close
-			if @monitors.any?
-				$stderr.puts "Trying to close selector with active monitors: #{@monitors.values.inspect}!"
-			end
-			
-			@selector.close
-		end
-		
-		def select(*args)
-			@selector.select(*args)
 		end
 	end
 end

data/lib/async/debug/selector.rb

@@ -0,0 +1,81 @@
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require_relative 'monitor'
+require_relative '../logger'
+
+require 'nio'
+
+module Async
+	module Debug
+		class Selector
+			def initialize(selector = NIO::Selector.new)
+				@selector = selector
+				@monitors = {}
+			end
+			
+			def register(object, interests)
+				Async.logger.debug(self) {"Registering #{object.inspect} for #{interests}."}
+				
+				unless io = ::IO.try_convert(object)
+					raise RuntimeError, "Could not convert #{io} into IO!"
+				end
+				
+				if monitor = @monitors[io.fileno]
+					raise RuntimeError, "Trying to register monitor for #{object.inspect} but it was already registered: #{monitor.inspect}!"
+				end
+				
+				monitor = Monitor.new(@selector.register(object, interests), self)
+				
+				@monitors[io.fileno] = monitor
+				
+				return monitor
+			end
+			
+			def deregister(object)
+				Async.logger.debug(self) {"Deregistering #{object.inspect}."}
+				
+				unless io = ::IO.try_convert(object)
+					raise RuntimeError, "Could not convert #{io} into IO!"
+				end
+				
+				unless @monitors.delete(io.fileno)
+					raise RuntimeError, "Trying to remove monitor for #{io.inspect} but it was not registered!"
+				end
+			end
+			
+			def wakeup
+				@selector.wakeup
+			end
+			
+			def close
+				if @monitors.any?
+					raise RuntimeError, "Trying to close selector with active monitors: #{@monitors.values.inspect}!"
+				end
+			ensure
+				@selector.close
+			end
+			
+			def select(*args)
+				@selector.select(*args)
+			end
+		end
+	end
+end

data/lib/async/reactor.rb

@@ -31,16 +31,6 @@ module Async
 	class TimeoutError < RuntimeError
 	end
 	
-	class MonitorError < RuntimeError
-		def initialize(monitor)
-			super "Event detected on IO #{monitor.io.inspect} (#{monitor.interests} -> #{monitor.readiness}) without corresponding fiber!"
-			
-			@monitor = monitor
-		end
-		
-		attr :monitor
-	end
-	
 	# An asynchronous, cooperatively scheduled event reactor.
 	class Reactor < Node
 		extend Forwardable
@@ -68,10 +58,10 @@ module Async
 			end
 		end
 		
-		def initialize
-			super
+		def initialize(parent = nil, selector: NIO::Selector.new)
+			super(parent)
 			
-			@selector = NIO::Selector.new
+			@selector = selector
 			@timers = Timers::Group.new
 			
 			@ready = []
@@ -86,6 +76,10 @@ module Async
 		# @attr stopped [Boolean]
 		attr :stopped
 		
+		def stopped?
+			@stopped
+		end
+		
 		def_delegators :@timers, :every, :after
 		
 		# Start an asynchronous task within the specified reactor. The task will be
@@ -112,10 +106,9 @@ module Async
 			return task
 		end
 		
-		def register(*args)
-			monitor = @selector.register(*args)
-			
-			monitor.value = Fiber.current
+		def register(io, interest, value = Fiber.current)
+			monitor = @selector.register(io, interest)
+			monitor.value = value
 			
 			return monitor
 		end
@@ -186,11 +179,7 @@ module Async
 				# Async.logger.debug(self) {"Selecting with #{@children.count} fibers interval = #{interval.inspect}..."}
 				if monitors = @selector.select(interval)
 					monitors.each do |monitor|
-						if fiber = monitor.value
-							fiber.resume # if fiber.alive?
-						else
-							raise MonitorError.new(monitor)
-						end
+						monitor.value.resume
 					end
 				end
 			end until @stopped

data/lib/async/version.rb

@@ -19,5 +19,5 @@
 # THE SOFTWARE.
 
 module Async
-	VERSION = "1.7.0"
+	VERSION = "1.8.0"
 end

data/lib/async/wrapper.rb

@@ -23,14 +23,46 @@ require 'nio'
 module Async
 	# Represents an asynchronous IO within a reactor.
 	class Wrapper
+		class Cancelled < StandardError
+			def initialize
+				super "The operation has been cancelled!"
+			end
+		end
+		
+		# wait_readable, wait_writable and wait_any are not re-entrant, and will raise this failure.
+		class WaitError < StandardError
+			def initialize
+				super "A fiber is already waiting!"
+			end
+		end
+		
 		# @param io the native object to wrap.
 		# @param reactor [Reactor] the reactor that is managing this wrapper, or not specified, it's looked up by way of {Task.current}.
-		# @param bound [Boolean] whether the underlying socket will be closed if the wrapper is closed.
 		def initialize(io, reactor = nil)
 			@io = io
 			
 			@reactor = reactor
 			@monitor = nil
+			
+			@readable = nil
+			@writable = nil
+			@any = nil
+		end
+		
+		def resume(*args)
+			readiness = @monitor.readiness
+			
+			if @readable and (readiness == :r or readiness == :rw)
+				@readable.resume(*args)
+			end
+			
+			if @writable and (readiness == :w or readiness == :rw)
+				@writable.resume(*args)
+			end
+			
+			if @any
+				@any.resume(*args)
+			end
 		end
 		
 		# The underlying native `io`.
@@ -39,74 +71,138 @@ module Async
 		# The reactor this wrapper is associated with, if any.
 		attr :reactor
 		
+		# The monitor for this wrapper, if any.
+		attr :monitor
+		
 		# Bind this wrapper to a different reactor. Assign nil to convert to an unbound wrapper (can be used from any reactor/task but with slightly increased overhead.)
 		# Binding to a reactor is purely a performance consideration. Generally, I don't like APIs that exist only due to optimisations. This is borderline, so consider this functionality semi-private.
 		def reactor= reactor
-			if @monitor
-				@monitor.close 
-				@monitor = nil
-			end
+			return if @reactor.equal?(reactor)
+			
+			cancel_monitor
 			
 			@reactor = reactor
 		end
 		
 		# Wait for the io to become readable.
 		def wait_readable(duration = nil)
-			wait_any(:r, duration)
+			raise WaitError if @readable
+			
+			self.reactor = Task.current.reactor
+			
+			begin
+				@readable = Fiber.current
+				wait_for(duration)
+			ensure
+				@readable = nil
+				@monitor.interests = interests if @monitor
+			end
 		end
 		
 		# Wait for the io to become writable.
 		def wait_writable(duration = nil)
-			wait_any(:w, duration)
+			raise WaitError if @writable
+			
+			self.reactor = Task.current.reactor
+			
+			begin
+				@writable = Fiber.current
+				wait_for(duration)
+			ensure
+				@writable = nil
+				@monitor.interests = interests if @monitor
+			end
 		end
 		
 		# Wait fo the io to become either readable or writable.
-		# @param interests [:r | :w | :rw] what events to wait for.
 		# @param duration [Float] timeout after the given duration if not `nil`.
-		def wait_any(interests = :rw, duration = nil)
-			# There is value in caching this monitor - if you can reuse it, you will get about 2x the throughput, because you avoid calling Reactor#register and Monitor#close for every call. That being said, by caching it, you also introduce lifetime issues. I'm going to accept this overhead into the wrapper design because it's pretty convenient, but if you want faster IO, take a look at the performance spec which compares this method with a more direct alternative.
-			if @reactor
-				unless @monitor
-					@monitor = @reactor.register(@io, interests)
-				else
-					@monitor.interests = interests
-					@monitor.value = Fiber.current
-				end
-				
-				begin
-					wait_for(@reactor, @monitor, duration)
-				ensure
-					@monitor.interests = nil
-				end
-			else
-				reactor = Task.current.reactor
-				monitor = reactor.register(@io, interests)
-				
-				begin
-					wait_for(reactor, monitor, duration)
-				ensure
-					monitor.close
-				end
+		def wait_any(duration = nil)
+			raise WaitError if @any
+			
+			self.reactor = Task.current.reactor
+			
+			begin
+				@any = Fiber.current
+				wait_for(duration)
+			ensure
+				@any = nil
+				@monitor.interests = interests if @monitor
 			end
 		end
 		
 		# Close the io and monitor.
 		def close
-			if @monitor
-				@monitor.close 
-				@monitor = nil
-			end
+			cancel_monitor
 			
 			@io.close
 		end
 		
+		def closed?
+			@io.closed?
+		end
+		
 		private
 		
-		def wait_for(reactor, monitor, duration)
+		# What an abomination.
+		def interests
+			if @any
+				return :rw
+			elsif @readable
+				if @writable
+					return :rw
+				else
+					return :r
+				end
+			elsif @writable
+				return :w
+			end
+			
+			return nil
+		end
+		
+		def cancel_monitor
+			if @readable
+				readable = @readable
+				@readable = nil
+				
+				readable.resume(Cancelled.new)
+			end
+			
+			if @writable
+				writable = @writable
+				@writable = nil
+				
+				writable.resume(Cancelled.new)
+			end
+			
+			if @any
+				any = @any
+				@any = nil
+				
+				any.resume(Cancelled.new)
+			end
+			
+			if @monitor
+				@monitor.close
+				@monitor = nil
+			end
+		end
+		
+		def wait_for(duration)
+			if @monitor
+				@monitor.interests = interests
+			else
+				@monitor = @reactor.register(@io, interests, self)
+			end
+			
 			# If the user requested an explicit timeout for this operation:
 			if duration
-				reactor.timeout(duration) do
-					Task.yield
+				@reactor.timeout(duration) do
+					begin
+						Task.yield
+					rescue Async::TimeoutError
+						return false
+					end
 				end
 			else
 				Task.yield

data/spec/async/logger_spec.rb

@@ -19,29 +19,31 @@
 # THE SOFTWARE.
 
 RSpec.describe Async.logger do
-	let!(:debug) {$DEBUG}
-	after {$DEBUG = debug}
-	
-	let!(:verbose) {$VERBOSE}
-	after {$VERBOSE = verbose}
-	
-	it 'should set default log level' do
-		$DEBUG = false
-		$VERBOSE = false
+	describe '::default_log_level' do
+		let!(:debug) {$DEBUG}
+		after {$DEBUG = debug}
 		
-		expect(Async.default_log_level).to be == Logger::WARN
-	end
-	
-	it 'should set default log level based on $DEBUG' do
-		$DEBUG = true
+		let!(:verbose) {$VERBOSE}
+		after {$VERBOSE = verbose}
 		
-		expect(Async.default_log_level).to be == Logger::DEBUG
-	end
-	
-	it 'should set default log level based on $VERBOSE' do
-		$DEBUG = false
-		$VERBOSE = true
+		it 'should set default log level' do
+			$DEBUG = false
+			$VERBOSE = false
+			
+			expect(Async.default_log_level).to be == Logger::WARN
+		end
+		
+		it 'should set default log level based on $DEBUG' do
+			$DEBUG = true
+			
+			expect(Async.default_log_level).to be == Logger::DEBUG
+		end
 		
-		expect(Async.default_log_level).to be == Logger::INFO
+		it 'should set default log level based on $VERBOSE' do
+			$DEBUG = false
+			$VERBOSE = true
+			
+			expect(Async.default_log_level).to be == Logger::INFO
+		end
 	end
 end

data/spec/async/reactor_spec.rb

@@ -19,38 +19,60 @@
 # THE SOFTWARE.
 
 RSpec.describe Async::Reactor do
-	it "can run asynchronously" do
-		outer_fiber = Fiber.current
-		inner_fiber = nil
-		
-		described_class.run do |task|
-			task.sleep(0)
-			inner_fiber = Fiber.current
+	describe '#run' do
+		it "can run tasks on different fibers" do
+			outer_fiber = Fiber.current
+			inner_fiber = nil
+			
+			described_class.run do |task|
+				task.sleep(0)
+				inner_fiber = Fiber.current
+			end
+			
+			expect(inner_fiber).to_not be nil
+			expect(outer_fiber).to_not be == inner_fiber
 		end
-		
-		expect(inner_fiber).to_not be nil
-		expect(outer_fiber).to_not be == inner_fiber
 	end
 	
-	it "can be stopped" do
-		state = nil
-		
-		subject.async do |task|
-			state = :started
-			task.sleep(10)
-			state = :stopped
+	describe '#stop' do
+		it "can be stop reactor" do
+			state = nil
+			
+			subject.async do |task|
+				state = :started
+				task.sleep(10)
+				state = :stopped
+			end
+			
+			subject.async do |task|
+				task.sleep(0.1)
+				task.reactor.stop
+			end
+			
+			subject.run
+			
+			expect(state).to be == :started
 		end
 		
-		subject.async do |task|
-			task.sleep(0.1)
-			task.reactor.stop
+		it "can stop reactor from different thread" do
+			events = Thread::Queue.new
+			
+			thread = Thread.new do
+				if events.pop
+					subject.stop
+				end
+			end
+			
+			subject.async do |task|
+				events << true
+			end
+			
+			subject.run
+			
+			thread.join
+			expect(subject).to be_stopped
 		end
-		
-		subject.run
-		
-		expect(state).to be == :started
 	end
-	
 	it "can't return" do
 		expect do
 			Async::Reactor.run do |task|

data/spec/async/wrapper_spec.rb

@@ -21,61 +21,149 @@
 require 'benchmark'
 
 RSpec.describe Async::Wrapper do
+	include_context Async::RSpec::Reactor
+	
 	let(:pipe) {IO.pipe}
 	let(:input) {Async::Wrapper.new(pipe.last)}
 	let(:output) {Async::Wrapper.new(pipe.first)}
 	
-	describe '#wait_*' do
-		include_context Async::RSpec::Reactor
+	after(:each) do
+		input.close unless input.closed?
+		output.close unless output.closed?
 		
-		it "can wait for writability" do
-			expect(input.wait_writable(1)).to be_truthy
+		expect(input.monitor).to be_nil
+		expect(output.monitor).to be_nil
+	end
+	
+	describe '#wait_readable' do
+		it "can wait to be readable" do
+			reader = reactor.async do
+				expect(output.wait_readable).to be_truthy
+			end
 			
-			input.close
-			output.close
+			input.io.write('Hello World')
+			reader.wait
+		end
+		
+		it "can timeout if no event occurs" do
+			expect(output.wait_readable(0.1)).to be_falsey
 		end
 		
-		it "can wait for readability" do
+		it "can wait for readability in sequential tasks" do
 			reactor.async do
 				input.wait_writable(1)
 				input.io.write('Hello World')
 			end
 			
-			expect(output.wait_readable(1)).to be_truthy
+			2.times do
+				reactor.async do
+					expect(output.wait_readable(1)).to be_truthy
+				end.wait
+			end
+		end
+		
+		it "can be cancelled" do
+			reactor.async do
+				expect do
+					output.wait_readable
+				end.to raise_error(Async::Wrapper::Cancelled)
+			end
 			
-			input.close
-			output.close
+			expect(output.monitor).to_not be_nil
+		end
+	end
+	
+	describe '#wait_writable' do
+		it "can wait to be writable" do
+			expect(input.wait_writable).to be_truthy
 		end
 		
-		it "can wait for readability in multiple tasks" do
+		it "can be cancelled" do
 			reactor.async do
-				input.wait_writable(1)
+				expect do
+					input.wait_readable
+				end.to raise_error(Async::Wrapper::Cancelled)
+			end
+			
+			expect(input.monitor).to_not be_nil
+		end
+	end
+	
+	describe "#wait_any" do
+		it "can wait for any events" do
+			reactor.async do
+				input.wait_any(1)
 				input.io.write('Hello World')
 			end
 			
-			output.reactor = reactor
+			expect(output.wait_readable(1)).to be_truthy
+		end
+		
+		it "can wait for readability in one task and writability in another" do
+			reactor.async do
+				expect do
+					input.wait_readable(1)
+				end.to raise_error(Async::Wrapper::Cancelled)
+			end
+			
+			expect(input.monitor.interests).to be == :r
 			
-			2.times do
-				reactor.async do
-					expect(output.wait_readable(1)).to be_truthy
-				end.wait
+			reactor.async do
+				input.wait_writable
+				
+				input.close
+				output.close
+			end.wait
+		end
+		
+		it "fails if waiting on from multiple tasks" do
+			input.reactor = reactor
+			
+			reactor.async do
+				expect do
+					input.wait_readable
+				end.to raise_error(Async::Wrapper::Cancelled)
 			end
 			
-			input.close
-			output.close
+			expect(input.monitor.interests).to be == :r
+			
+			reactor.async do
+				expect do
+					input.wait_readable
+				end.to raise_error(Async::Wrapper::WaitError)
+			end
 		end
 	end
 	
 	describe '#reactor=' do
-		include_context Async::RSpec::Reactor
-		
 		it 'can assign a wrapper to a reactor' do
 			input.reactor = reactor
 			
 			expect(input.reactor).to be == reactor
+		end
+		
+		it 'assigns current reactor when waiting for events' do
+			input.wait_writable
 			
+			expect(input.reactor).to be == reactor
+		end
+	end
+	
+	describe '#close' do
+		it "closes monitor when closing wrapper" do
+			input.wait_writable
+			expect(input.monitor).to_not be_nil
+			input.close
+			expect(input.monitor).to be_nil
+		end
+		
+		it "can't wait on closed wrapper" do
 			input.close
 			output.close
+			
+			expect do
+				output.wait_readable
+			end.to raise_error(IOError, /closed stream/)
 		end
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.8.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-27 00:00:00.000000000 Z
+date: 2018-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nio4r
@@ -120,7 +120,8 @@ files:
 - lib/async.rb
 - lib/async/clock.rb
 - lib/async/condition.rb
-- lib/async/debug.rb
+- lib/async/debug/monitor.rb
+- lib/async/debug/selector.rb
 - lib/async/logger.rb
 - lib/async/measure.rb
 - lib/async/node.rb