async 0.9.1 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0c677beaeb3fb10276210be29052382b077ac6ce
-  data.tar.gz: bc0719a32fbffef3861f111d7a245c45b6e24786
+  metadata.gz: f28936ef28f1828e6216b5c9bd1186a89f7037c1
+  data.tar.gz: c1319a57b9fc689dc77f6bea15a682759affa3b5
 SHA512:
-  metadata.gz: ad2df57e9e6ee7a4280a1b64c6429f6e8c69c2de40dcdd5cb9091c0e8f8b7debdd9f88d4ff3e049900aa16f97c48a3735630725ff4459db1e240360731844712
-  data.tar.gz: 1773d262ce191fcf566a385620ae7fd7f880f1e886f99e0f8bc4fd1829662b83e824cc3d694d6d4e37b25622608eff1a3452eb82b95e4f297f3aa9c41553d7d4
+  metadata.gz: 2e6ab3277515b79065c95cb9d88a6ffd7f56c86c2cfe1c5ecbe8145807d9d07d658f76dcf6b3c614aea5d4c370ac85f08966ff7fd3e0f549a1383f70aebbd254
+  data.tar.gz: 42687f2385510e39e7403cdeaf39b487468564295b360f5f1edff07097d06b3e65af8d2c7821ae31fc1d683b53a497a022ea838f0afd3758388b6c23d9a073ad

data/lib/async/node.rb

@@ -0,0 +1,68 @@
+# Copyright, 2017, 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 'set'
+
+module Async
+	class Node
+		def initialize(parent = nil)
+			@children = Set.new
+			@parent = nil
+			
+			if parent
+				self.parent = parent
+			end
+		end
+		
+		attr :parent
+		attr :children
+		
+		# Attach this node to an existing parent.
+		def parent=(parent)
+			return if @parent.equal?(parent)
+			
+			if @parent
+				@parent.reap(self)
+				@parent = nil
+			end
+			
+			if parent
+				@parent = parent
+				@parent.children << self
+			end
+		end
+		
+		def finished?
+			@children.empty?
+		end
+		
+		def consume
+			if @parent && finished?
+				@parent.reap(self)
+				@parent.consume
+				@parent = nil
+			end
+		end
+		
+		def reap(child)
+			@children.delete(child)
+		end
+	end
+end

data/lib/async/reactor.rb

@@ -30,23 +30,35 @@ module Async
 	class TimeoutError < RuntimeError
 	end
 	
-	class Reactor
+	class Reactor < Node
 		extend Forwardable
 		
 		def self.run(*args, &block)
-			reactor = self.new
-			
-			reactor.async(*args, &block)
+			if current = Task.current?
+				reactor = current.reactor
+				
+				reactor.async(*args, &block)
+			else
+				reactor = self.new
+				
+				begin
+					reactor.run(*args, &block)
+				ensure
+					reactor.close
+				end
+				
+				return reactor
+			end
 		end
 		
 		def initialize(wrappers: IO)
+			super(nil)
+			
 			@wrappers = wrappers
 			
 			@selector = NIO::Selector.new
 			@timers = Timers::Group.new
 			
-			@fibers = []
-			
 			@stopped = true
 		end
 		
@@ -75,10 +87,7 @@ module Async
 			# - Fail at the point of call where possible.
 			# - Execute determinstically where possible.
 			# - Avoid overhead if no blocking operation is performed.
-			fiber = task.run
-			
-			# We only start tracking this if the fiber is still alive:
-			@fibers << fiber if fiber.alive?
+			task.run
 			
 			# Async.logger.debug "Initial execution of task #{fiber} complete (#{result} -> #{fiber.alive?})..."
 			return task
@@ -93,6 +102,8 @@ module Async
 		end
 		
 		def run(*args, &block)
+			raise RuntimeError, 'Reactor has been closed' if @selector.nil?
+			
 			@stopped = false
 			
 			# Allow the user to kick of the initial async tasks.
@@ -105,16 +116,15 @@ module Async
 				# - +ve: timers waiting to fire
 				interval = 0 if interval && interval < 0
 				
-				# Async.logger.debug "[#{self} Pre] Updating #{@fibers.count} fibers..."
-				# Async.logger.debug @fibers.collect{|fiber| [fiber, fiber.alive?]}.inspect
+				Async.logger.debug "[#{self} Pre] Updating #{@children.count} children..."
+				Async.logger.debug @children.collect{|child| [child.to_s, child.alive?]}.inspect
 				# As timeouts may have been updated, and caused fibers to complete, we should check this.
-				@fibers.delete_if{|fiber| !fiber.alive?}
 				
 				# If there is nothing to do, then finish:
-				# Async.logger.debug "[#{self}] @fibers.empty? = #{@fibers.empty?} && interval #{interval.inspect}"
-				return if @fibers.empty? && interval.nil?
+				Async.logger.debug "[#{self}] @children.empty? = #{@children.empty?} && interval #{interval.inspect}"
+				return if @children.empty? && interval.nil?
 				
-				# Async.logger.debug "Selecting with #{@fibers.count} fibers interval = #{interval}..."
+				Async.logger.debug "Selecting with #{@children.count} fibers interval = #{interval}..."
 				if monitors = @selector.select(interval)
 					monitors.each do |monitor|
 						if task = monitor.value
@@ -124,12 +134,25 @@ module Async
 					end
 				end
 			end until @stopped
+			
+			return self
 		ensure
-			# Async.logger.debug "[#{self} Ensure] Exiting run-loop (stopped: #{@stopped} exception: #{$!})..."
-			# Async.logger.debug @fibers.collect{|fiber| [fiber, fiber.alive?]}.inspect
+			Async.logger.debug "[#{self} Ensure] Exiting run-loop (stopped: #{@stopped} exception: #{$!})..."
+			Async.logger.debug @children.collect{|child| [child.to_s, child.alive?]}.inspect
 			@stopped = true
 		end
 		
+		def close
+			@children.each(&:stop)
+			
+			@selector.close
+			@selector = nil
+		end
+		
+		def closed?
+			@selector.nil?
+		end
+		
 		def sleep(duration)
 			task = Fiber.current
 			

data/lib/async/task.rb

@@ -21,52 +21,82 @@
 require 'fiber'
 require 'forwardable'
 
+require_relative 'node'
+
 module Async
 	class Interrupt < Exception
 	end
 	
-	class Task
+	class Task < Node
 		extend Forwardable
 		
-		def initialize(ios, reactor, &block)
+		def initialize(ios, reactor)
+			if parent = Task.current?
+				super(parent)
+			else
+				super(reactor)
+			end
+			
 			@ios = Hash[
 				ios.collect{|io| [io.fileno, reactor.wrap(io, self)]}
 			]
 			
 			@reactor = reactor
 			
+			@status = :running
+			@result = nil
+			
 			@fiber = Fiber.new do
 				set!
 				
 				begin
-					yield(*@ios.values, self)
+					@result = yield(*@ios.values, self)
+					@status = :complete
 					# Async.logger.debug("Task #{self} completed normally.")
 				rescue Interrupt
+					@status = :interrupted
 					# Async.logger.debug("Task #{self} interrupted: #{$!}")
+				rescue Exception
+					@status = :failed
+					# Async.logger.debug("Task #{self} failed: #{$!}")
+					raise
 				ensure
+					# Async.logger.debug("Task #{self} closing: #{$!}")
 					close
 				end
 			end
 		end
 		
+		def to_s
+			"#{super}[#{@status}]"
+		end
+		
+		attr :ios
+		
+		attr :reactor
 		def_delegators :@reactor, :timeout, :sleep
 		
+		attr :fiber
+		def_delegators :@fiber, :alive?
+		
+		attr :status
+		attr :result
+		
 		def run
 			@fiber.resume
 				
 			return @fiber
 		end
 		
-		def stop!
+		def stop
+			@children.each(&:stop)
+			
 			if @fiber.alive?
 				exception = Interrupt.new("Stop right now!")
 				@fiber.resume(exception)
 			end
 		end
 		
-		attr :ios
-		attr :reactor
-		
 		def with(io)
 			wrapper = @reactor.wrap(io, self)
 			
@@ -88,12 +118,24 @@ module Async
 			Thread.current[:async_task] or raise RuntimeError, "No async task available!"
 		end
 		
-		private
+		def self.current?
+			Thread.current[:async_task]
+		end
+		
+		# Whether we can remove this node from the reactor graph.
+		def finished?
+			super && @status != :running
+		end
 		
 		def close
 			@ios.each_value(&:close)
+			@ios = []
+			
+			consume
 		end
 		
+		private
+		
 		def set!
 			# This is actually fiber-local:
 			Thread.current[:async_task] = self

data/lib/async/version.rb

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

data/spec/async/node_spec.rb

@@ -0,0 +1,59 @@
+# Copyright, 2017, 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 'benchmark'
+
+RSpec.describe Async::Node do
+	describe '#parent=' do
+		let(:child) {Async::Node.new(subject)}
+		
+		it "should construct nested tree" do
+			expect(child.parent).to be subject
+			expect(subject.children).to include(child)
+		end
+		
+		it "should break nested tree" do
+			child.parent = nil
+			
+			expect(child.parent).to be_nil
+			expect(subject.children).to be_empty
+		end
+		
+		it "can consume bottom to top" do
+			child.consume
+			
+			expect(child.parent).to be_nil
+			expect(subject.children).to be_empty
+		end
+	end
+	
+	describe '#consume' do
+		let(:middle) {Async::Node.new(subject)}
+		let(:bottom) {Async::Node.new(middle)}
+		
+		it "can't consume middle node" do
+			expect(bottom.parent).to be middle
+			
+			middle.consume
+			
+			expect(bottom.parent).to be middle
+		end
+	end
+end

data/spec/async/reactor/nested_spec.rb

@@ -0,0 +1,50 @@
+# Copyright, 2017, 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.
+
+RSpec.describe Async::Reactor do
+	describe '::run (in existing reactor)' do
+		include_context "reactor"
+		
+		it "should nest reactor" do
+			outer_reactor = Async::Task.current.reactor
+			inner_reactor = nil
+			
+			task = described_class.run do |task|
+				inner_reactor = task.reactor
+			end 
+			
+			expect(outer_reactor).to be_kind_of(described_class)
+			expect(outer_reactor).to be_eql(inner_reactor)
+		end
+	end
+	
+	describe '::run' do
+		it "should nest reactor" do
+			expect(Async::Task.current?).to be_nil
+			inner_reactor = nil
+			
+			task = described_class.run do |task|
+				inner_reactor = task.reactor
+			end 
+			
+			expect(inner_reactor).to be_kind_of(described_class)
+		end
+	end
+end

data/spec/async/reactor_spec.rb

@@ -19,18 +19,17 @@
 # THE SOFTWARE.
 
 RSpec.describe Async::Reactor do
-	# Shared port for localhost network tests.
-	let(:port) {6778}
-	
 	it "can run asynchronously" do
 		outer_fiber = Fiber.current
 		inner_fiber = nil
 		
-		described_class.run do
+		described_class.run do |task|
+			task.sleep(0)
 			inner_fiber = Fiber.current
 		end
 		
-		expect(outer_fiber).not_to be == inner_fiber
+		expect(inner_fiber).to_not be nil
+		expect(outer_fiber).to_not be == inner_fiber
 	end
 	
 	it "can be stopped" do
@@ -47,127 +46,20 @@ RSpec.describe Async::Reactor do
 		expect(state).to be == :started
 	end
 	
-	describe 'basic tcp server' do
-		include_context "reactor"
-		
-		# These may block:
-		let(:server) {TCPServer.new("localhost", port)}
-		let(:client) {TCPSocket.new("localhost", port)}
-		
-		let(:data) {"The quick brown fox jumped over the lazy dog."}
-		
-		after(:each) do
-			server.close
-		end
-		
-		it "should start server and send data" do
-			subject.async(server) do |server, task|
-				task.with(server.accept) do |peer|
-					peer.write(peer.read(512))
-				end
-			end
-			
-			subject.with(client) do |client|
-				client.write(data)
-				
-				expect(client.read(512)).to be == data
+	it "can't return" do
+		expect do
+			Async::Reactor.run do |task|
+				return
 			end
-			
-			subject.run
-			
-			expect(client).to be_closed
-		end
+		end.to raise_error(LocalJumpError)
 	end
 	
-	describe 'non-blocking tcp connect' do
-		include_context "reactor"
-		
-		# These may block:
-		let(:server) {TCPServer.new("localhost", port)}
-		
-		let(:data) {"The quick brown fox jumped over the lazy dog."}
-		
-		after(:each) do
-			server.close
-		end
-		
-		it "should start server and send data" do
-			subject.async(server) do |server, task|
-				task.with(server.accept) do |peer|
-					peer.write(peer.read(512))
-				end
-			end
-			
-			subject.async do |task|
-				Async::TCPSocket.connect("localhost", port) do |client|
-					client.write(data)
-					expect(client.read(512)).to be == data
-				end
-			end
-			
-			subject.run
+	it "is closed after running" do
+		reactor = Async::Reactor.run do
 		end
 		
-		it "can connect socket and read/write in a different task" do
-			subject.async(server) do |server, task|
-				task.with(server.accept) do |peer|
-					peer.write(peer.read(512))
-				end
-			end
-			
-			socket = nil
-			
-			subject.async do |task|
-				socket = Async::TCPSocket.connect("localhost", port)
-				
-				# Stop the reactor once the connection was made.
-				subject.stop
-			end
-			
-			subject.run
-			
-			expect(socket).to_not be_nil
-			
-			subject.async(socket) do |client|
-				client.write(data)
-				expect(client.read(512)).to be == data
-			end
-			
-			subject.run
-		end
-	end
-	
-	describe 'basic udp server' do
-		include_context "reactor"
-		
-		# These may block:
-		let(:server) {UDPSocket.new.tap{|socket| socket.bind("localhost", port)}}
-		let(:client) {UDPSocket.new}
-		
-		let(:data) {"The quick brown fox jumped over the lazy dog."}
-		
-		after(:each) do
-			server.close
-		end
+		expect(reactor).to be_closed
 		
-		it "should echo data back to peer" do
-			subject.async(server) do |server, task|
-				packet, (_, remote_port, remote_host) = server.recvfrom(512)
-				
-				reactor.async do
-					server.send(packet, 0, remote_host, remote_port)
-				end
-			end
-			
-			subject.async(client) do |client|
-				client.send(data, 0, "localhost", port)
-				
-				response, _ = client.recvfrom(512)
-				
-				expect(response).to be == data
-			end
-			
-			subject.run
-		end
+		expect{reactor.run}.to raise_error(RuntimeError, /closed/)
 	end
 end

data/spec/async/task_spec.rb

@@ -23,7 +23,7 @@ require 'benchmark'
 RSpec.describe Async::Task do
 	let(:reactor) {Async::Reactor.new}
 	
-	describe '#stop!' do
+	describe '#stop' do
 		it "can be stopped" do
 			state = nil
 			
@@ -33,10 +33,51 @@ RSpec.describe Async::Task do
 				state = :finished
 			end
 			
-			task.stop!
+			task.stop
 			
 			expect(state).to be == :started
 		end
+		
+		it "should kill direct child" do
+			parent_task = child_task = nil
+			
+			task = reactor.async do |task|
+				parent_task = task
+				reactor.async do |task|
+					child_task = task
+					task.sleep(10)
+				end
+				task.sleep(10)
+			end
+			
+			expect(parent_task).to_not be_nil
+			expect(child_task).to_not be_nil
+			
+			expect(parent_task.fiber).to be_alive
+			expect(child_task.fiber).to be_alive
+			
+			parent_task.stop
+			
+			expect(parent_task.fiber).to_not be_alive
+			expect(child_task.fiber).to_not be_alive
+		end
+		
+		it "should not remove running task" do
+			top_task = middle_task = bottom_task = nil
+			
+			top_task = reactor.async do |task|
+				middle_task = reactor.async do |task|
+					bottom_task = reactor.async do |task|
+						task.sleep(10)
+					end
+					task.sleep(10)
+				end
+				task.sleep(10)
+			end
+			
+			bottom_task.stop
+			expect(top_task.children).to include(middle_task)
+		end
 	end
 	
 	describe '#sleep' do

data/spec/async/tcp_socket_spec.rb

@@ -0,0 +1,119 @@
+# Copyright, 2017, 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.
+
+RSpec.describe Async::Reactor do
+	# Shared port for localhost network tests.
+	let(:port) {6779}
+	
+	def run_echo_server
+		# Accept a single incoming connection and then finish.
+		subject.async(server) do |server, task|
+			task.with(server.accept) do |peer|
+				data = peer.read(512)
+				peer.write(data)
+			end
+		end
+		
+		yield
+		
+		subject.run
+		
+		server.close
+	end
+	
+	describe 'basic tcp server' do
+		# These may block:
+		let(:server) {TCPServer.new("localhost", port)}
+		let(:client) {TCPSocket.new("localhost", port)}
+		
+		let(:data) {"The quick brown fox jumped over the lazy dog."}
+		
+		it "should start server and send data" do
+			run_echo_server do
+				subject.with(client) do |client|
+					client.write(data)
+					expect(client.read(512)).to be == data
+				end
+			end
+			
+			expect(client).to be_closed
+		end
+	end
+	
+	describe 'non-blocking tcp connect' do
+		# These may block:
+		let(:server) {TCPServer.new("localhost", port)}
+		
+		let(:data) {"The quick brown fox jumped over the lazy dog."}
+		
+		it "should start server and send data" do
+			run_echo_server do
+				subject.async do |task|
+					Async::TCPSocket.connect("localhost", port) do |client|
+						client.write(data)
+						expect(client.read(512)).to be == data
+					end
+				end
+			end
+		end
+		
+		it "can connect socket and read/write in a different task" do
+			socket = nil
+			
+			run_echo_server do
+				subject.async do |task|
+					socket = Async::TCPSocket.connect("localhost", port)
+					
+					# Stop the reactor once the connection was made.
+					subject.stop
+				end
+			
+				subject.run
+				
+				expect(socket).to_not be_nil
+				
+				subject.async(socket) do |client|
+					client.write(data)
+					expect(client.read(512)).to be == data
+				end
+				
+				subject.run
+			end
+		end
+		
+		it "can't use a socket in nested tasks" do
+			socket = nil
+			
+			run_echo_server do
+				subject.async do |task|
+					socket = Async::TCPSocket.connect("localhost", port)
+					
+					# I'm not sure if this is the right behaviour or not. Without a significant amont of work, async sockets are tied to the task that creates them.
+					expect do
+						subject.async(socket) do |client|
+							client.write(data)
+							expect(client.read(512)).to be == data
+						end
+					end.to raise_error(ArgumentError, /already registered with selector/)
+				end
+			end
+		end
+	end
+end

data/spec/async/udp_socket_spec.rb

@@ -0,0 +1,56 @@
+# Copyright, 2017, 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.
+
+RSpec.describe Async::Reactor do
+	# Shared port for localhost network tests.
+	let(:port) {6778}
+	
+	describe 'basic udp server' do
+		# These may block:
+		let(:server) {UDPSocket.new.tap{|socket| socket.bind("localhost", port)}}
+		let(:client) {UDPSocket.new}
+		
+		let(:data) {"The quick brown fox jumped over the lazy dog."}
+		
+		after(:each) do
+			server.close
+		end
+		
+		it "should echo data back to peer" do
+			subject.async(server) do |server, task|
+				packet, (_, remote_port, remote_host) = server.recvfrom(512)
+				
+				subject.async do
+					server.send(packet, 0, remote_host, remote_port)
+				end
+			end
+			
+			subject.async(client) do |client|
+				client.send(data, 0, "localhost", port)
+				
+				response, _ = client.recvfrom(512)
+				
+				expect(response).to be == data
+			end
+			
+			subject.run
+		end
+	end
+end

data/spec/spec_helper.rb

@@ -22,10 +22,10 @@ require "async/tcp_socket"
 require "async/udp_socket"
 
 RSpec.shared_context "reactor" do
-	let(:reactor) {Async::Reactor.new}
+	let(:reactor) {Async::Task.current.reactor}
 	
 	around(:each) do |example|
-		reactor.run do
+		Async::Reactor.run do
 			example.run
 		end
 	end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.10.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-07 00:00:00.000000000 Z
+date: 2017-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nio4r
@@ -115,6 +115,7 @@ files:
 - lib/async.rb
 - lib/async/io.rb
 - lib/async/logger.rb
+- lib/async/node.rb
 - lib/async/reactor.rb
 - lib/async/socket.rb
 - lib/async/ssl_socket.rb
@@ -124,8 +125,12 @@ files:
 - lib/async/unix_socket.rb
 - lib/async/version.rb
 - lib/async/wrapper.rb
+- spec/async/node_spec.rb
+- spec/async/reactor/nested_spec.rb
 - spec/async/reactor_spec.rb
 - spec/async/task_spec.rb
+- spec/async/tcp_socket_spec.rb
+- spec/async/udp_socket_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/socketry/async
 licenses:
@@ -152,6 +157,10 @@ signing_key:
 specification_version: 4
 summary: Async is an asynchronous I/O framework based on nio4r.
 test_files:
+- spec/async/node_spec.rb
+- spec/async/reactor/nested_spec.rb
 - spec/async/reactor_spec.rb
 - spec/async/task_spec.rb
+- spec/async/tcp_socket_spec.rb
+- spec/async/udp_socket_spec.rb
 - spec/spec_helper.rb