async-dns 0.10.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0d06ded8c25acd3d3b198a45c291b47f70d26667
-  data.tar.gz: 708bfec661ce872d73137142ad338198f548a750
+  metadata.gz: 0302e920c59ef8d4ce72eaa34c0a442536304590
+  data.tar.gz: eede22f4c518bfa0dcf094933083aeda33bc82a1
 SHA512:
-  metadata.gz: 33fe2f59bf6907af89631f9b6bf13e05e8312df6d1d197cc2b530edc2e7d9a29581988830494127aaef4d95f5cdf775511e828b55c210ab07d8a6337c1281fba
-  data.tar.gz: b61ea4a2c6a9a336690165dbaa6e2789aaaccc53fb78e65e0dabc8a8ea99221b3c7d137020fac0f0e4dbe768f832fb5ab0ae72b9e9578989b3818107beba5c5c
+  metadata.gz: 60687d211cdcee0afecee281daa5ae79322713b0adff0baf78f2c82ef700ebe99e056dc5f40d14a059f3a0d5a18c5741091b2a20cfe61bb8efd184b201c789a3
+  data.tar.gz: '052292c7a58dcbfa650d902a7c7b15097fe1d7e1dd2b06ebda5d5009f68c7fc3ed130cbaeb36be26ee0a8f04b0099d7be080e028bcbe35016661e75c4d76f6cb'

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+/spec/**/log/
+
+# rspec failure tracking
+.rspec_status

data/.travis.yml

@@ -1,18 +1,19 @@
 language: ruby
 sudo: false
+dist: trusty
+cache: bundler
 addons:
   apt:
     packages:
     - bind9
 rvm:
-  - 2.2.6
-  - 2.3.3
-  - 2.4.0
-  - rbx-2
+  - 2.1
+  - 2.2
+  - 2.3
+  - 2.4
   - ruby-head
   - jruby-head
 matrix:
   allow_failures:
-    - rvm: rbx-2 
     - rvm: ruby-head
     - rvm: jruby-head

data/Gemfile

@@ -2,8 +2,6 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem "async"
-
 group :development do
 	gem "pry"
 end

data/async-dns.gemspec

@@ -21,11 +21,12 @@ Gem::Specification.new do |spec|
 	spec.require_paths = ["lib"]
 	spec.has_rdoc      = "yard"
 	
-	spec.add_dependency("async", "~> 0.10")
+	spec.add_dependency("async-io", "~> 0.1")
 	
-	spec.add_development_dependency "process-daemon", "~> 1.0.0"
+	spec.add_development_dependency "async-rspec", "~> 1.0"
+	spec.add_development_dependency "process-daemon", "~> 1.0"
 	
 	spec.add_development_dependency "bundler", "~> 1.3"
-	spec.add_development_dependency "rspec", "~> 3.4.0"
+	spec.add_development_dependency "rspec", "~> 3.6"
 	spec.add_development_dependency "rake"
 end

data/lib/async/dns.rb

@@ -19,8 +19,8 @@
 # THE SOFTWARE.
 
 require 'async'
-require 'async/tcp_socket'
-require 'async/udp_socket'
+require 'async/io/tcp_socket'
+require 'async/io/udp_socket'
 
 require_relative 'dns/version'
 

data/lib/async/dns/handler.rb

@@ -22,11 +22,16 @@ require_relative 'transport'
 
 module Async::DNS
 	class GenericHandler
-		def initialize(server)
+		def initialize(server, address)
 			@server = server
+			@address = address
+			
 			@logger = @server.logger || Async.logger
 		end
 		
+		attr :server
+		attr :address
+		
 		def error_response(query = nil, code = Resolv::DNS::RCode::ServFail)
 			# Encoding may fail, so we need to handle this particular case:
 			server_failure = Resolv::DNS::Message::new(query ? query.id : 0)
@@ -61,27 +66,23 @@ module Async::DNS
 	end
 	
 	# Handling incoming UDP requests, which are single data packets, and pass them on to the given server.
-	class UDPHandler < GenericHandler
-		def run(socket, reactor:)
-			Async.logger.debug(self.class.name) {"-> Run on #{socket}..."}
-			
-			while true
-				Async.logger.debug(self.class.name) {"-> socket.recvfrom"}
-				input_data, (_, remote_port, remote_host) = socket.recvfrom(UDP_TRUNCATION_SIZE)
-				Async.logger.debug(self.class.name) {"<- socket.recvfrom"}
-				
-				reactor.async do
-					respond(socket, input_data, remote_host, remote_port)
+	class DatagramHandler < GenericHandler
+		def run(task: Async::Task.current)
+			@address.bind do |socket|
+				while true
+					Async.logger.debug(self.class.name) {"-> socket.recvfrom"}
+					input_data, remote_address = socket.recvmsg(UDP_TRUNCATION_SIZE)
+					Async.logger.debug(self.class.name) {"<- socket.recvfrom"}
+					
+					task.async do
+						respond(socket, input_data, remote_address)
+					end
 				end
 			end
-		ensure
-			Async.logger.debug(self.class.name) {"<- Run ensure... #{$!}"}
 		end
 		
-		def respond(socket, input_data, remote_host, remote_port)
-			options = {peer: remote_host, port: remote_port, proto: :udp}
-			
-			response = process_query(input_data, options)
+		def respond(socket, input_data, remote_address)
+			response = process_query(input_data, remote_address: remote_address)
 			
 			output_data = response.encode
 			
@@ -97,7 +98,7 @@ module Async::DNS
 				output_data = truncation_error.encode
 			end
 			
-			socket.send(output_data, 0, remote_host, remote_port)
+			socket.sendmsg(output_data, 0, remote_address)
 		rescue IOError => error
 			@logger.warn "<> UDP response failed: #{error.inspect}!"
 		rescue EOFError => error
@@ -107,71 +108,19 @@ module Async::DNS
 		end
 	end
 	
-	class UDPSocketHandler < UDPHandler
-		def initialize(server, socket)
-			@socket = socket
-			
-			super(server)
-		end
-		
-		attr :socket
-		
-		def run(reactor: Async::Task.current.reactor)
-			reactor.async(self.socket) do |socket|
-				super(socket, reactor: reactor)
-			end
-		end
-	end
-	
-	class UDPServerHandler < UDPHandler
-		def initialize(server, host, port)
-			@host = host
-			@port = port
-			
-			super(server)
-		end
-		
-		attr :host
-		attr :port
-		
-		def run(reactor: Async::Task.current.reactor)
-			reactor.with(make_socket) do |socket|
-				super(socket, reactor: reactor)
-			end
-		end
-		
-		private
-		
-		def make_socket
-			family ||= Async::DNS::address_family(@host)
-			
-			socket = ::UDPSocket.new(family)
-			socket.bind(@host, @port)
-			
-			return socket
-		end
-	end
-	
-	class TCPHandler < GenericHandler
-		def run(socket, reactor:)
-			Async.logger.debug(self.class.name) {"-> Run on #{socket}..."}
-			
-			reactor.with(socket.accept) do |client|
+	class StreamHandler < GenericHandler
+		def run(task: Async::Task.current)
+			@address.accept do |client, address|
 				handle_connection(client)
-			end while true
-		ensure
-			Async.logger.debug(self.class.name) {"<- Run ensure... #{$!}"}
+			end
 		end
 		
 		def handle_connection(socket)
 			context = Async::Task.current
 			
-			_, remote_port, remote_host = socket.io.peeraddr
-			options = {peer: remote_host, port: remote_port, proto: :tcp}
-			
 			input_data = StreamTransport.read_chunk(socket)
 			
-			response = process_query(input_data, options)
+			response = process_query(input_data, remote_address: socket.remote_address)
 			
 			length = StreamTransport.write_message(socket, response)
 			
@@ -186,44 +135,4 @@ module Async::DNS
 			@logger.warn "<> Error: Could not decode incoming TCP data!"
 		end
 	end
-	
-	class TCPSocketHandler < TCPHandler
-		def initialize(server, socket)
-			@socket = socket
-			
-			super(server)
-		end
-		
-		attr :socket
-		
-		def run(reactor: Async::Task.current.reactor)
-			reactor.async(@socket) do |socket|
-				super(socket, reactor: reactor)
-			end
-		end
-	end
-	
-	class TCPServerHandler < TCPHandler
-		def initialize(server, host, port)
-			@host = host
-			@port = port
-			
-			super(server)
-		end
-		
-		attr :host
-		attr :port
-		
-		def run(reactor: Async::Task.current.reactor)
-			reactor.with(make_socket) do |socket|
-				super(socket, reactor: reactor)
-			end
-		end
-		
-		private
-		
-		def make_socket
-			::TCPServer.new(@host, @port)
-		end
-	end
 end

data/lib/async/dns/message.rb

@@ -33,7 +33,7 @@ module Async::DNS
 	Message = ::Resolv::DNS::Message
 	DecodeError = ::Resolv::DNS::DecodeError
 
-	@@dump_bad_message = nil
+	@dump_bad_message = nil
 	
 	# Call this function with a path where bad messages will be saved. Any message that causes an exception to be thrown while decoding the binary will be saved in base64 for later inspection. The log file could grow quickly so be careful - not designed for long term use.
 	def self.log_bad_messages!(log_path)

data/lib/async/dns/resolver.rb

@@ -133,20 +133,19 @@ module Async::DNS
 		end
 		
 		# Send the message to available servers. If no servers respond correctly, nil is returned. This result indicates a failure of the resolver to correctly contact any server and get a valid response.
-		def dispatch_request(message)
+		def dispatch_request(message, task: Async::Task.current)
 			request = Request.new(message, @servers)
-			context = Async::Task.current
 			
-			request.each do |server|
-				@logger.debug "[#{message.id}] Sending request #{message.question.inspect} to server #{server.inspect}" if @logger
+			request.each do |address|
+				@logger.debug "[#{message.id}] Sending request #{message.question.inspect} to address #{address.inspect}" if @logger
 				
 				begin
 					response = nil
 					
-					context.timeout(@timeout) do
-						@logger.debug "[#{message.id}] -> Try server #{server}" if @logger
-						response = try_server(request, server)
-						@logger.debug "[#{message.id}] <- Try server #{server} = #{response}" if @logger
+					task.timeout(@timeout) do
+						@logger.debug "[#{message.id}] -> Try address #{address}" if @logger
+						response = try_server(request, address)
+						@logger.debug "[#{message.id}] <- Try address #{address} = #{response}" if @logger
 					end
 					
 					if valid_response(message, response)
@@ -158,8 +157,10 @@ module Async::DNS
 					@logger.warn "[#{message.id}] Invalid response from network: #{$!}!" if @logger
 				rescue DecodeError
 					@logger.warn "[#{message.id}] Error while decoding data from network: #{$!}!" if @logger
-				rescue IOError
+				rescue IOError, Errno::ECONNRESET
 					@logger.warn "[#{message.id}] Error while reading from network: #{$!}!" if @logger
+				rescue EOFError
+					@logger.warn "[#{message.id}] Could not read complete response from network: #{$!}" if @logger
 				end
 			end
 			
@@ -183,14 +184,14 @@ module Async::DNS
 			end
 		end
 		
-		def try_server(request, server)
-			case server[0]
-			when :udp
-				try_udp_server(request, server[1], server[2])
-			when :tcp
-				try_tcp_server(request, server[1], server[2])
+		def try_server(request, address)
+			case address.type
+			when Socket::SOCK_DGRAM
+				try_datagram_server(request, address)
+			when Socket::SOCK_STREAM
+				try_stream_server(request, address)
 			else
-				raise InvalidProtocolError.new(server)
+				raise InvalidProtocolError.new(address)
 			end
 		end
 		
@@ -208,34 +209,20 @@ module Async::DNS
 			return false
 		end
 		
-		def udp_socket(family)
-			@udp_sockets[family] ||= UDPSocket.new(family)
-		end
-		
-		def try_udp_server(request, host, port)
-			context = Async::Task.current
-			
-			family = Async::DNS::address_family(host)
-			
-			context.with(UDPSocket.new(family)) do |socket|
-				socket.send(request.packet, 0, host, port)
-				
-				data, (_, remote_port) = socket.recvfrom(UDP_TRUNCATION_SIZE)
-				# Need to check host, otherwise security issue.
+		def try_datagram_server(request, address, task: Async::Task.current)
+			address.connect do |socket|
+				socket.sendmsg(request.packet, 0)
 				
-				# May indicate some kind of spoofing attack:
-				if port != remote_port
-					raise InvalidResponseError.new("Data was not received from correct remote port (#{port} != #{remote_port})")
-				end
+				data, peer = socket.recvmsg(UDP_TRUNCATION_SIZE)
 				
 				return Async::DNS::decode_message(data)
 			end
 		end
 		
-		def try_tcp_server(request, host, port)
+		def try_stream_server(request, address)
 			context = Async::Task.current
 			
-			context.with(TCPSocket.new(host, port)) do |socket|
+			address.connect do |socket|
 				StreamTransport.write_chunk(socket, request.packet)
 				
 				input_data = StreamTransport.read_chunk(socket)
@@ -263,12 +250,7 @@ module Async::DNS
 			attr :logger
 			
 			def each(&block)
-				@servers.each do |server|
-					# TODO: This seems odd...
-					next if @packet.bytesize > UDP_TRUNCATION_SIZE
-					
-					yield server
-				end
+				Async::IO::Address.each(@servers, &block)
 			end
 
 			def update_id!(id)

data/lib/async/dns/server.rb

@@ -19,6 +19,7 @@
 # THE SOFTWARE.
 
 require 'async'
+require 'async/io/address'
 
 require_relative 'transaction'
 require_relative 'logger'
@@ -107,9 +108,11 @@ module Async::DNS
 			
 			setup_handlers if @handlers.empty?
 			
-			Async::Reactor.run do
+			Async::Reactor.run do |task|
 				@handlers.each do |handler|
-					handler.run(*args)
+					task.async do
+						handler.run(*args)
+					end
 				end
 				
 				fire(:start)
@@ -121,32 +124,16 @@ module Async::DNS
 		def setup_handlers
 			fire(:setup)
 			
-			# Setup server sockets
-			@interfaces.each do |spec|
-				if spec.is_a?(BasicSocket)
-					spec.do_not_reverse_lookup
-					protocol = spec.getsockopt(Socket::SOL_SOCKET, Socket::SO_TYPE).unpack("i")[0]
-					ip = spec.local_address.ip_address
-					port = spec.local_address.ip_port
-					
-					case protocol
-					when Socket::SOCK_DGRAM
-						@logger.info "<> Attaching to pre-existing UDP socket #{ip}:#{port}"
-						@handlers << UDPSocketHandler.new(self, spec)
-					when Socket::SOCK_STREAM
-						@logger.info "<> Attaching to pre-existing TCP socket #{ip}:#{port}"
-						@handlers << TCPSocketHandler.new(self, spec)
-					else
-						raise ArgumentError.new("Unknown socket protocol: #{protocol}")
-					end
-				elsif spec[0] == :udp
-					@logger.info "<> Listening on #{spec.join(':')}"
-					@handlers << UDPServerHandler.new(self, spec[1], spec[2])
-				elsif spec[0] == :tcp
-					@logger.info "<> Listening on #{spec.join(':')}"
-					@handlers << TCPServerHandler.new(self, spec[1], spec[2])
+			Async::IO::Address.each(@interfaces) do |address|
+				case address.type
+				when Socket::SOCK_DGRAM
+					@logger.info "<> Listening for datagrams on #{address.inspect}"
+					@handlers << DatagramHandler.new(self, address)
+				when Socket::SOCK_STREAM
+					@logger.info "<> Listening for connections on #{address.inspect}"
+					@handlers << StreamHandler.new(self, address)
 				else
-					raise ArgumentError.new("Invalid connection specification: #{spec.inspect}")
+					raise ArgumentError.new("Don't know how to handle #{address}")
 				end
 			end
 		end

data/lib/async/dns/transport.rb

@@ -44,7 +44,11 @@ module Async::DNS
 			
 			# First we need to read in the length of the packet
 			while buffer.size < 2
-				buffer.write socket.read(1)
+				if data = socket.read(1)
+					buffer.write data
+				else
+					raise EOFError, "Could not read message size!"
+				end
 			end
 			
 			# Read in the length, the first two bytes:
@@ -55,7 +59,11 @@ module Async::DNS
 				required = (2 + length) - buffer.size
 				
 				# Read precisely the required amount:
-				buffer.write socket.read(required)
+				if data = socket.read(required)
+					buffer.write data
+				else
+					raise EOFError, "Could not read message data!"
+				end
 			end
 			
 			return buffer.string.byteslice(2, length)

data/lib/async/dns/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module DNS
-		VERSION = '0.10.0'
+		VERSION = '0.12.0'
 	end
 end

data/spec/async/dns/handler_spec.rb

@@ -21,38 +21,40 @@
 require 'async/dns'
 require 'async/dns/system'
 
-describe Async::DNS::TCPServerHandler do
+describe Async::DNS::StreamHandler do
+	include_context Async::RSpec::Reactor
+	
 	let(:server) {Async::DNS::Server.new}
-	let(:host) {'127.0.0.1'}
-	let(:port) {6665}
+	let(:address) {Async::IO::Address.tcp('127.0.0.1', 6666)}
 	
-	subject {described_class.new(server, host, port)}
+	subject {described_class.new(server, address)}
 	
 	it "can rebind port" do
 		2.times do
-			socket = subject.send(:make_socket)
-			expect(socket).to_not be_closed
+			task = reactor.async do
+				subject.run
+			end
 			
-			socket.close
-			expect(socket).to be_closed
+			task.stop
 		end
 	end
 end
 
-describe Async::DNS::UDPServerHandler do
+describe Async::DNS::DatagramHandler do
+	include_context Async::RSpec::Reactor
+	
 	let(:server) {Async::DNS::Server.new}
-	let(:host) {'127.0.0.1'}
-	let(:port) {6665}
+	let(:address) {Async::IO::Address.udp('127.0.0.1', 6666)}
 	
-	subject {described_class.new(server, host, port)}
+	subject {described_class.new(server, address)}
 	
 	it "can rebind port" do
 		2.times do
-			socket = subject.send(:make_socket)
-			expect(socket).to_not be_closed
+			task = reactor.async do
+				subject.run
+			end
 			
-			socket.close
-			expect(socket).to be_closed
+			task.stop
 		end
 	end
 end

data/spec/async/dns/ipv6_spec.rb

@@ -34,12 +34,12 @@ module Async::DNS::IPv6Spec
 		end
 	end
 	
-	describe Async::DNS::TCPSocketHandler do
+	describe Async::DNS::StreamHandler do
+		include_context Async::RSpec::Reactor
+		
 		let(:server_interfaces) {[[:tcp, '::', 2004]]}
 		let(:server) {TestServer.new(listen: server_interfaces)}
 		
-		include_context "reactor"
-		
 		it "should connect to the server using TCP via IPv6" do
 			task = server.run
 			
@@ -55,12 +55,12 @@ module Async::DNS::IPv6Spec
 		end
 	end
 	
-	describe Async::DNS::UDPSocketHandler do
+	describe Async::DNS::DatagramHandler do
+		include_context Async::RSpec::Reactor
+		
 		let(:server_interfaces) {[[:udp, '::', 2006]]}
 		let(:server) {TestServer.new(listen: server_interfaces)}
 		
-		include_context "reactor"
-		
 		it "should connect to the server using UDP via IPv6" do
 			task = server.run
 			

data/spec/async/dns/replace_spec.rb

@@ -25,7 +25,7 @@ require 'async/dns/replace'
 
 module Async::DNS::ReplaceSpec
 	describe Async::DNS::Replace do
-		include_context "reactor"
+		include_context Async::RSpec::Reactor
 		
 		let(:default_resolver) {Async::DNS::Resolver.new([[:udp, "8.8.8.8", 53], [:tcp, "8.8.8.8", 53]])}
 		

data/spec/async/dns/resolver_performance_spec.rb

@@ -81,7 +81,7 @@ module Async::DNS::ResolverPerformanceSpec
 				require 'benchmark'
 			end
 			
-			include_context "reactor"
+			include_context Async::RSpec::Reactor
 			
 			it 'should be faster than native resolver' do
 				# Async.logger.level = Logger::ERROR

data/spec/async/dns/resolver_spec.rb

@@ -24,51 +24,39 @@ require 'async/dns'
 
 module Async::DNS::ResolverSpec
 	describe Async::DNS::Resolver do
+		include_context Async::RSpec::Reactor
+		
 		class JunkUDPServer
-			def initialize
-				@socket = UDPSocket.new
-				@socket.bind("0.0.0.0", 6060)
+			def initialize(server_address = nil)
+				@server_address = server_address || Addrinfo.udp('0.0.0.0', 6060)
 			end
 		
-			def stop
-				@task.stop
-				@socket.close
-			end
-	
-			def run(reactor: Async::Task.current.reactor)
-				@task = reactor.async(@socket) do |socket|
-					data, (_, port, host) = socket.recvfrom(1024)
-					socket.send("Foobar", 0, host, port)
+			def run(task: Async::Task.current)
+				task.async do
+					Async::IO::Socket.bind(@server_address) do |socket|
+						while true
+							data, address = socket.recvfrom(1024)
+							socket.send("foobar", 0, address)
+						end
+					end
 				end
 			end
 		end
 
 		class JunkTCPServer
-			def initialize
-				@socket = TCPServer.new("0.0.0.0", 6060)
-			end
-			
-			def stop
-				@task.stop
-				@socket.close
+			def initialize(server_address = nil)
+				@server_address = server_address || Addrinfo.tcp('0.0.0.0', 6060)
 			end
-			
-			def run(reactor: Async::Task.current.reactor)
-				# @logger.debug "Waiting for incoming TCP connections #{@socket.inspect}..."
-				@task = reactor.async(@socket) do |socket|
-					reactor.with(socket.accept) do |client|
-						handle_connection(client)
-					end while true
+		
+			def run(task: Async::Task.current)
+				task.async do
+					Async::IO::Socket.accept(@server_address, backlog: 10) do |socket|
+						socket.write("f\0\0bar")
+					end
 				end
 			end
-			
-			def handle_connection(socket)
-				socket.write("\0\0obar")
-			end
 		end
 		
-		include_context "reactor"
-		
 		it "should result in non-existent domain" do
 			resolver = Async::DNS::Resolver.new([[:udp, "8.8.8.8", 53], [:tcp, "8.8.8.8", 53]])
 	
@@ -103,7 +91,7 @@ module Async::DNS::ResolverSpec
 		let(:udp_server) {JunkUDPServer.new}
 		
 		it "should fail with decode error from bad udp server" do
-			udp_server.run
+			server = udp_server.run
 			
 			resolver = Async::DNS::Resolver.new([[:udp, "0.0.0.0", 6060]])
 			
@@ -111,13 +99,13 @@ module Async::DNS::ResolverSpec
 			
 			expect(response).to be == nil
 			
-			udp_server.stop
+			server.stop
 		end
 		
 		let(:tcp_server) {JunkTCPServer.new}
 		
 		it "should fail with decode error from bad tcp server" do
-			tcp_server.run
+			server = tcp_server.run
 			
 			resolver = Async::DNS::Resolver.new([[:tcp, "0.0.0.0", 6060]])
 			
@@ -125,7 +113,7 @@ module Async::DNS::ResolverSpec
 			
 			expect(response).to be == nil
 			
-			tcp_server.stop
+			server.stop
 		end
 
 		it "should return some IPv4 and IPv6 addresses" do

data/spec/async/dns/server_performance_spec.rb

@@ -26,7 +26,7 @@ require 'process/daemon'
 
 module Async::DNS::ServerPerformanceSpec
 	describe Async::DNS::Server do
-		include_context "reactor"
+		include_context Async::RSpec::Reactor
 		
 		context 'benchmark' do
 			class MillionServer < Async::DNS::Server

data/spec/async/dns/slow_server_spec.rb

@@ -36,7 +36,7 @@ module Async::DNS::SlowServerSpec
 	end
 	
 	describe "Async::DNS Slow Server" do
-		include_context "reactor"
+		include_context Async::RSpec::Reactor
 		
 		let(:server_interfaces) {[[:udp, '0.0.0.0', 5330], [:tcp, '0.0.0.0', 5330]]}
 		let(:server) {SlowServer.new(listen: server_interfaces)}

data/spec/async/dns/socket_spec.rb

@@ -34,8 +34,8 @@ module Async::DNS::SocketSpec
 		end
 	end
 	
-	describe Async::DNS::TCPSocketHandler do
-		include_context "reactor"
+	describe Async::DNS::StreamHandler do
+		include_context Async::RSpec::Reactor
 		
 		let(:server_interfaces) {[TCPServer.new('127.0.0.1', 2002)]}
 		let(:server) {TestServer.new(listen: server_interfaces)}
@@ -48,11 +48,12 @@ module Async::DNS::SocketSpec
 			expect(response.class).to be == Async::DNS::Message
 			
 			task.stop
+			server_interfaces.each(&:close)
 		end
 	end
 	
-	describe Async::DNS::UDPSocketHandler do
-		include_context "reactor"
+	describe Async::DNS::DatagramHandler do
+		include_context Async::RSpec::Reactor
 		
 		let(:server_interfaces) {[UDPSocket.new.tap{|socket| socket.bind('127.0.0.1', 2002)}]}
 		let(:server) {TestServer.new(listen: server_interfaces)}
@@ -65,6 +66,7 @@ module Async::DNS::SocketSpec
 			expect(response.class).to be == Async::DNS::Message
 			
 			task.stop
+			server_interfaces.each(&:close)
 		end
 	end
 end

data/spec/async/dns/system_spec.rb

@@ -25,7 +25,7 @@ require 'async/dns/system'
 
 module Async::DNS::SystemSpec
 	describe Async::DNS::System do
-		include_context "reactor"
+		include_context Async::RSpec::Reactor
 		
 		it "should have at least one namesever" do
 			expect(Async::DNS::System::nameservers.length).to be > 0

data/spec/async/dns/transaction_spec.rb

@@ -34,7 +34,7 @@ module Async::DNS::TransactionSpec
 		let(:response) { Async::DNS::Message.new(0) }
 		let(:resolver) { Async::DNS::Resolver.new([[:udp, '8.8.8.8', 53], [:tcp, '8.8.8.8', 53]])}
 		
-		include_context "reactor"
+		include_context Async::RSpec::Reactor
 		
 		it "should append an address" do
 			transaction = Async::DNS::Transaction.new(server, query, question, IN::A, response)

data/spec/async/dns/truncation_spec.rb

@@ -40,7 +40,7 @@ module Async::DNS::TruncationSpec
 	end
 	
 	describe "Async::DNS Truncation Server" do
-		include_context "reactor"
+		include_context Async::RSpec::Reactor
 		
 		let(:server) {TestServer.new(listen: SERVER_PORTS)}
 		

data/spec/spec_helper.rb

@@ -23,30 +23,8 @@ if ENV['COVERAGE'] || ENV['TRAVIS']
 end
 
 require "bundler/setup"
-require "pry"
+require "async/rspec"
 require "async/dns"
-require "pp"
-
-RSpec.shared_context "reactor" do
-	let(:reactor) {Async::Reactor.new}
-	
-	around(:each) do |example|
-		result = nil
-		
-		reactor.run do
-			result = example.run
-			
-			# Force the reactor to stop running if the result was an error.
-			if result.is_a? Exception
-				reactor.stop
-			end
-		end
-		
-		reactor.close
-		
-		result
-	end
-end
 
 # abort "Warning, ulimit is too low!" if `ulimit -n`.to_i < 10000
 

metadata

@@ -1,43 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: async-dns
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-09 00:00:00.000000000 Z
+date: 2017-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: async
+  name: async-io
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: async-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: process-daemon
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -58,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.4.0
+        version: '3.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.4.0
+        version: '3.6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -88,6 +102,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
 - ".rspec"
 - ".travis.yml"
 - Gemfile