async-dns 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a69c3e892e1022681eb81ec89cf6953b27f2dd65
-  data.tar.gz: f4b1bbfe1e36b9bae37681343c4eb1bc71f5b621
+SHA256:
+  metadata.gz: 75dfa7c3b610755410a52e52a8d17f3b98ffafcd0c74949b1f276e654cdf0677
+  data.tar.gz: 3d3434f03a5cd4492dcb0d1ba5ea2257952ba756a3a284ad021b9e58105e615c
 SHA512:
-  metadata.gz: 0dc107b7e33810d8a45fdb660dfc7421ad95383d8e14db6006175a335b0cc80500065e2c78c3d80ef53291a2ae8f3617a5cdb081475009ddff5c0edf3ff06576
-  data.tar.gz: 3209d74dc8a3ae956acb687da50ac5049f5c5a4be820ae8e5f1ca88c3c02b1bcd077e02ba33a23a498d90f8cd86b2ad52b2582907c734ccfee45f4372487cb42
+  metadata.gz: ad1b54307fc07a786260573d9d97e619a1662af47786460f04d24c35220ef72787f719b174bb676089a8c4f1680f23c2a05c60b256097182ed63935fbfe7263b
+  data.tar.gz: 332b76c624b5965f41c8d9242252fd4b9e713d9e6cab8a1ccc593101eea6a8a57327f81ea069642d8cafc63460e995a72cae858a66c7427bc79e43e3cd0a1acb

data/.travis.yml

@@ -7,6 +7,8 @@ addons:
     packages:
     - bind9
 
+before_script: sudo sh -c 'echo 0 > /proc/sys/net/ipv6/conf/all/disable_ipv6'
+
 matrix:
   include:
     - rvm: 2.1

data/async-dns.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
 	spec.require_paths = ["lib"]
 	spec.has_rdoc      = "yard"
 	
-	spec.add_dependency("async-io", "~> 1.0")
+	spec.add_dependency("async-io", "~> 1.3")
 	
 	spec.add_development_dependency "async-rspec", "~> 1.0"
 	spec.add_development_dependency "process-daemon", "~> 1.0"

data/lib/async/dns/handler.rb

@@ -22,15 +22,15 @@ require_relative 'transport'
 
 module Async::DNS
 	class GenericHandler
-		def initialize(server, endpoint)
+		def initialize(server, socket)
 			@server = server
-			@endpoint = endpoint
+			@socket = socket
 			
 			@logger = @server.logger || Async.logger
 		end
 		
 		attr :server
-		attr :endpoint
+		attr :socket
 		
 		def error_response(query = nil, code = Resolv::DNS::RCode::ServFail)
 			# Encoding may fail, so we need to handle this particular case:
@@ -68,15 +68,11 @@ module Async::DNS
 	# Handling incoming UDP requests, which are single data packets, and pass them on to the given server.
 	class DatagramHandler < GenericHandler
 		def run(task: Async::Task.current)
-			@endpoint.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
+			while true
+				input_data, remote_address = @socket.recvmsg(UDP_TRUNCATION_SIZE)
+				
+				task.async do
+					respond(@socket, input_data, remote_address)
 				end
 			end
 		end
@@ -109,15 +105,15 @@ module Async::DNS
 	end
 	
 	class StreamHandler < GenericHandler
-		def run(task: Async::Task.current)
-			@endpoint.accept do |client, address|
+		def run(backlog = Socket::SOMAXCONN)
+			@socket.listen(backlog)
+			
+			@socket.accept_each do |client, address|
 				handle_connection(client)
 			end
 		end
 		
 		def handle_connection(socket)
-			context = Async::Task.current
-			
 			input_data = StreamTransport.read_chunk(socket)
 			
 			response = process_query(input_data, remote_address: socket.remote_address)

data/lib/async/dns/resolver.rb

@@ -185,13 +185,15 @@ module Async::DNS
 		end
 		
 		def try_server(request, endpoint)
-			case endpoint.socket_type
-			when Socket::SOCK_DGRAM
-				try_datagram_server(request, endpoint)
-			when Socket::SOCK_STREAM
-				try_stream_server(request, endpoint)
-			else
-				raise InvalidProtocolError.new(endpoint)
+			endpoint.connect do |socket|
+				case socket.type
+				when Socket::SOCK_DGRAM
+					try_datagram_server(request, socket)
+				when Socket::SOCK_STREAM
+					try_stream_server(request, socket)
+				else
+					raise InvalidProtocolError.new(endpoint)
+				end
 			end
 		end
 		
@@ -209,26 +211,20 @@ module Async::DNS
 			return false
 		end
 		
-		def try_datagram_server(request, endpoint, task: Async::Task.current)
-		endpoint.connect do |socket|
-				socket.sendmsg(request.packet, 0)
-				
-				data, peer = socket.recvmsg(UDP_TRUNCATION_SIZE)
-				
-				return Async::DNS::decode_message(data)
-			end
+		def try_datagram_server(request, socket)
+			socket.sendmsg(request.packet, 0)
+			
+			data, peer = socket.recvmsg(UDP_TRUNCATION_SIZE)
+			
+			return Async::DNS::decode_message(data)
 		end
 		
-		def try_stream_server(request, endpoint)
-			context = Async::Task.current
+		def try_stream_server(request, socket)
+			StreamTransport.write_chunk(socket, request.packet)
 			
-			endpoint.connect do |socket|
-				StreamTransport.write_chunk(socket, request.packet)
-				
-				input_data = StreamTransport.read_chunk(socket)
-				
-				return Async::DNS::decode_message(input_data)
-			end
+			input_data = StreamTransport.read_chunk(socket)
+			
+			return Async::DNS::decode_message(input_data)
 		end
 		
 		# Manages a single DNS question message across one or more servers.

data/lib/async/dns/server.rb

@@ -41,8 +41,6 @@ module Async::DNS
 			@endpoints = endpoints
 			@origin = origin
 			@logger = logger
-			
-			@handlers = []
 		end
 
 		# Records are relative to this origin:
@@ -106,12 +104,23 @@ module Async::DNS
 		def run(*args)
 			@logger.info "Starting Async::DNS server (v#{Async::DNS::VERSION})..."
 			
-			setup_handlers if @handlers.empty?
-			
 			Async::Reactor.run do |task|
-				@handlers.each do |handler|
+				fire(:setup)
+				
+				Async::IO::Endpoint.each(@endpoints) do |endpoint|
 					task.async do
-						handler.run(*args)
+						endpoint.bind do |socket|
+							case socket.type
+							when Socket::SOCK_DGRAM
+								@logger.info "<> Listening for datagrams on #{socket.local_address.inspect}"
+								DatagramHandler.new(self, socket).run
+							when Socket::SOCK_STREAM
+								@logger.info "<> Listening for connections on #{socket.local_address.inspect}"
+								StreamHandler.new(self, socket).run
+							else
+								raise ArgumentError.new("Don't know how to handle #{address}")
+							end
+						end
 					end
 				end
 				
@@ -119,23 +128,5 @@ module Async::DNS
 			end
 		end
 		
-		private
-		
-		def setup_handlers
-			fire(:setup)
-			
-			Async::IO::Endpoint.each(@endpoints) do |endpoint|
-				case endpoint.socket_type
-				when Socket::SOCK_DGRAM
-					@logger.info "<> Listening for datagrams on #{endpoint.inspect}"
-					@handlers << DatagramHandler.new(self, endpoint)
-				when Socket::SOCK_STREAM
-					@logger.info "<> Listening for connections on #{endpoint.inspect}"
-					@handlers << StreamHandler.new(self, endpoint)
-				else
-					raise ArgumentError.new("Don't know how to handle #{address}")
-				end
-			end
-		end
 	end
 end

data/lib/async/dns/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module DNS
-		VERSION = '1.0.0'
+		VERSION = '1.1.0'
 	end
 end

data/spec/async/dns/handler_spec.rb

@@ -25,14 +25,14 @@ describe Async::DNS::StreamHandler do
 	include_context Async::RSpec::Reactor
 	
 	let(:server) {Async::DNS::Server.new}
-	let(:address) {Async::IO::Endpoint.tcp('127.0.0.1', 6666)}
-	
-	subject {described_class.new(server, address)}
+	let(:endpoint) {Async::IO::Endpoint.tcp('127.0.0.1', 6666, reuse_port: true)}
 	
 	it "can rebind port" do
 		2.times do
 			task = reactor.async do
-				subject.run
+				endpoint.bind do |socket|
+					described_class.new(server, socket).run
+				end
 			end
 			
 			task.stop
@@ -44,14 +44,14 @@ describe Async::DNS::DatagramHandler do
 	include_context Async::RSpec::Reactor
 	
 	let(:server) {Async::DNS::Server.new}
-	let(:address) {Async::IO::Endpoint.udp('127.0.0.1', 6666)}
-	
-	subject {described_class.new(server, address)}
+	let(:endpoint) {Async::IO::Endpoint.udp('127.0.0.1', 6666)}
 	
 	it "can rebind port" do
 		2.times do
 			task = reactor.async do
-				subject.run
+				endpoint.bind do |socket|
+					described_class.new(server, socket).run
+				end
 			end
 			
 			task.stop

data/spec/async/dns/junk_server_context.rb

@@ -0,0 +1,62 @@
+# 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.
+
+RSpec.shared_context "Junk UDP Server" do
+	let(:server_endpoint) {Async::IO::Endpoint.udp('0.0.0.0', 6060, reuse_port: true)}
+	
+	let!(:server_task) do
+		reactor.async do
+			server_endpoint.bind do |socket|
+				begin
+					while true
+						data, address = socket.recvfrom(1024)
+						socket.send("foobar", 0, address)
+					end
+				rescue
+					socket.close
+				end
+			end
+		end
+	end
+	
+	after(:each) do
+		server_task.stop
+	end
+end
+
+RSpec.shared_context "Junk TCP Server" do
+	let(:server_endpoint) {Async::IO::Endpoint.tcp('0.0.0.0', 6060, reuse_port: true)}
+	
+	let!(:server_task) do
+		reactor.async do
+			server_endpoint.accept do |socket|
+				begin
+					socket.write("f\0\0bar")
+				rescue
+					socket.close
+				end
+			end
+		end
+	end
+	
+	after(:each) do
+		server_task.stop
+	end
+end

data/spec/async/dns/resolver_spec.rb

@@ -22,118 +22,83 @@
 
 require 'async/dns'
 
-module Async::DNS::ResolverSpec
-	describe Async::DNS::Resolver do
-		include_context Async::RSpec::Reactor
-		
-		class JunkUDPServer
-			def initialize(server_address = nil)
-				@server_address = server_address || Addrinfo.udp('0.0.0.0', 6060)
-			end
-		
-			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
+require_relative 'junk_server_context'
 
-		class JunkTCPServer
-			def initialize(server_address = nil)
-				@server_address = server_address || Addrinfo.tcp('0.0.0.0', 6060)
-			end
-		
-			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
-		end
-		
-		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]])
-	
-			response = resolver.query('foobar.oriontransfer.org')
+RSpec.describe Async::DNS::Resolver do
+	include_context Async::RSpec::Reactor
 	
-			expect(response.rcode).to be == Resolv::DNS::RCode::NXDomain
-		end
+	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]])
 
-		it "should result in some answers" do
-			resolver = Async::DNS::Resolver.new([[:udp, "8.8.8.8", 53], [:tcp, "8.8.8.8", 53]])
-	
-			response = resolver.query('google.com')
-	
-			expect(response.class).to be == Async::DNS::Message
-			expect(response.answer.size).to be > 0
-		end
+		response = resolver.query('foobar.oriontransfer.org')
 
-		it "should return no results" do
-			resolver = Async::DNS::Resolver.new([])
-	
-			response = resolver.query('google.com')
-	
-			expect(response).to be == nil
-		end
+		expect(response.rcode).to be == Resolv::DNS::RCode::NXDomain
+	end
+
+	it "should result in some answers" do
+		resolver = Async::DNS::Resolver.new([[:udp, "8.8.8.8", 53], [:tcp, "8.8.8.8", 53]])
+
+		response = resolver.query('google.com')
+
+		expect(response.class).to be == Async::DNS::Message
+		expect(response.answer.size).to be > 0
+	end
+
+	it "should return no results" do
+		resolver = Async::DNS::Resolver.new([])
+
+		response = resolver.query('google.com')
+
+		expect(response).to be == nil
+	end
+
+	it "should fail to get addresses" do
+		resolver = Async::DNS::Resolver.new([])
 
-		it "should fail to get addresses" do
-			resolver = Async::DNS::Resolver.new([])
+		expect{resolver.addresses_for('google.com')}.to raise_error(Async::DNS::ResolutionFailure)
+	end
 	
-			expect{resolver.addresses_for('google.com')}.to raise_error(Async::DNS::ResolutionFailure)
-		end
+	context 'with junk UDP server' do
+		include_context 'Junk UDP Server'
 		
-		let(:udp_server) {JunkUDPServer.new}
-		
-		it "should fail with decode error from bad udp server" do
-			server = udp_server.run
-			
+		it "should fail with decode error" do
 			resolver = Async::DNS::Resolver.new([[:udp, "0.0.0.0", 6060]])
 			
 			response = resolver.query('google.com')
 			
 			expect(response).to be == nil
-			
-			server.stop
 		end
+	end
+	
+	context 'with junk TCP server' do
+		include_context 'Junk TCP Server'
 		
-		let(:tcp_server) {JunkTCPServer.new}
-		
-		it "should fail with decode error from bad tcp server" do
-			server = tcp_server.run
-			
+		it "should fail with decode error" do
 			resolver = Async::DNS::Resolver.new([[:tcp, "0.0.0.0", 6060]])
 			
 			response = resolver.query('google.com')
 			
 			expect(response).to be == nil
-			
-			server.stop
 		end
-
-		it "should return some IPv4 and IPv6 addresses" do
-			resolver = Async::DNS::Resolver.new([[:udp, "8.8.8.8", 53], [:tcp, "8.8.8.8", 53]])
-	
-			addresses = resolver.addresses_for("www.google.com.")
-	
-			expect(addresses.size).to be > 0
+	end
 	
-			addresses.each do |address|
-				expect(address).to be_kind_of(Resolv::IPv4) | be_kind_of(Resolv::IPv6)
-			end
+	it "should return some IPv4 and IPv6 addresses" do
+		resolver = Async::DNS::Resolver.new([[:udp, "8.8.8.8", 53], [:tcp, "8.8.8.8", 53]])
+
+		addresses = resolver.addresses_for("www.google.com.")
+
+		expect(addresses.size).to be > 0
+
+		addresses.each do |address|
+			expect(address).to be_kind_of(Resolv::IPv4) | be_kind_of(Resolv::IPv6)
 		end
+	end
+	
+	it "should recursively resolve CNAME records" do
+		resolver = Async::DNS::Resolver.new([[:udp, "8.8.8.8", 53], [:tcp, "8.8.8.8", 53]])
 		
-		it "should recursively resolve CNAME records" do
-			resolver = Async::DNS::Resolver.new([[:udp, "8.8.8.8", 53], [:tcp, "8.8.8.8", 53]])
-			
-			addresses = resolver.addresses_for('www.baidu.com')
-			
-			expect(addresses.size).to be > 0
-		end
+		addresses = resolver.addresses_for('www.baidu.com')
+		
+		expect(addresses.size).to be > 0
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-dns
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-30 00:00:00.000000000 Z
+date: 2018-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-io
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: async-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -126,6 +126,7 @@ files:
 - spec/async/dns/handler_spec.rb
 - spec/async/dns/hosts.txt
 - spec/async/dns/ipv6_spec.rb
+- spec/async/dns/junk_server_context.rb
 - spec/async/dns/message_spec.rb
 - spec/async/dns/origin_spec.rb
 - spec/async/dns/replace_spec.rb
@@ -163,7 +164,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: An easy to use DNS client resolver and server for Ruby.
@@ -171,6 +172,7 @@ test_files:
 - spec/async/dns/handler_spec.rb
 - spec/async/dns/hosts.txt
 - spec/async/dns/ipv6_spec.rb
+- spec/async/dns/junk_server_context.rb
 - spec/async/dns/message_spec.rb
 - spec/async/dns/origin_spec.rb
 - spec/async/dns/replace_spec.rb