async-dns 0.12.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0302e920c59ef8d4ce72eaa34c0a442536304590
-  data.tar.gz: eede22f4c518bfa0dcf094933083aeda33bc82a1
+  metadata.gz: a69c3e892e1022681eb81ec89cf6953b27f2dd65
+  data.tar.gz: f4b1bbfe1e36b9bae37681343c4eb1bc71f5b621
 SHA512:
-  metadata.gz: 60687d211cdcee0afecee281daa5ae79322713b0adff0baf78f2c82ef700ebe99e056dc5f40d14a059f3a0d5a18c5741091b2a20cfe61bb8efd184b201c789a3
-  data.tar.gz: '052292c7a58dcbfa650d902a7c7b15097fe1d7e1dd2b06ebda5d5009f68c7fc3ed130cbaeb36be26ee0a8f04b0099d7be080e028bcbe35016661e75c4d76f6cb'
+  metadata.gz: 0dc107b7e33810d8a45fdb660dfc7421ad95383d8e14db6006175a335b0cc80500065e2c78c3d80ef53291a2ae8f3617a5cdb081475009ddff5c0edf3ff06576
+  data.tar.gz: 3209d74dc8a3ae956acb687da50ac5049f5c5a4be820ae8e5f1ca88c3c02b1bcd077e02ba33a23a498d90f8cd86b2ad52b2582907c734ccfee45f4372487cb42

data/.rspec

@@ -1,4 +1,3 @@
---color
 --format documentation
 --warnings
 --require spec_helper

data/.travis.yml

@@ -6,14 +6,17 @@ addons:
   apt:
     packages:
     - bind9
-rvm:
-  - 2.1
-  - 2.2
-  - 2.3
-  - 2.4
-  - ruby-head
-  - jruby-head
+
 matrix:
+  include:
+    - rvm: 2.1
+    - rvm: 2.2
+    - rvm: 2.3
+    - rvm: 2.4
+    - rvm: ruby-head
+    - rvm: jruby-head
+      env:
+        - JRUBY_OPTS="--debug -X+O"
   allow_failures:
     - rvm: ruby-head
-    - rvm: jruby-head
+    - rvm: jruby-head

data/Gemfile

@@ -7,6 +7,12 @@ group :development do
 end
 
 group :test do
+	gem 'ruby-prof', platforms: [:mri]
+	gem "benchmark-ips"
+	
 	gem 'simplecov'
 	gem 'coveralls', require: false
+	
+	# For comparisons:
+	gem "nokogiri"
 end

data/README.md

@@ -28,6 +28,7 @@ Or install it yourself as:
 
 Here is a simple example showing how to use the resolver:
 
+```ruby
 	Async::Reactor.run do
 		resolver = Async::DNS::Resolver.new([[:udp, "8.8.8.8", 53], [:tcp, "8.8.8.8", 53]])
 
@@ -36,11 +37,13 @@ Here is a simple example showing how to use the resolver:
 		puts addresses.inspect
 	end
 	=> [#<Resolv::IPv4 202.124.127.240>, #<Resolv::IPv4 202.124.127.216>, #<Resolv::IPv4 202.124.127.223>, #<Resolv::IPv4 202.124.127.227>, #<Resolv::IPv4 202.124.127.234>, #<Resolv::IPv4 202.124.127.230>, #<Resolv::IPv4 202.124.127.208>, #<Resolv::IPv4 202.124.127.249>, #<Resolv::IPv4 202.124.127.219>, #<Resolv::IPv4 202.124.127.218>, #<Resolv::IPv4 202.124.127.212>, #<Resolv::IPv4 202.124.127.241>, #<Resolv::IPv4 202.124.127.238>, #<Resolv::IPv4 202.124.127.245>, #<Resolv::IPv4 202.124.127.251>, #<Resolv::IPv4 202.124.127.229>]
+```
 
 ### Server
 
 Here is a simple example showing how to use the server:
 
+```ruby
 	require 'async/dns'
 	
 	class TestServer < Async::DNS::Server
@@ -51,9 +54,10 @@ Here is a simple example showing how to use the server:
 		end
 	end
 	
-	server = TestServer.new(listen: [[:udp, '127.0.0.1', 2346]])
+	server = TestServer.new([[:udp, '127.0.0.1', 2346]])
 	
 	server.run
+```
 
 Then to test you could use `dig` like so:
 

data/Rakefile

@@ -24,7 +24,7 @@ task :server do
 		end
 	end
 	
-	server = TestServer.new(listen: [[:udp, '127.0.0.1', 2346]])
+	server = TestServer.new([[:udp, '127.0.0.1', 2346]])
 	
 	Async::Reactor.run do
 		server.run

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", "~> 0.1")
+	spec.add_dependency("async-io", "~> 1.0")
 	
 	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, address)
+		def initialize(server, endpoint)
 			@server = server
-			@address = address
+			@endpoint = endpoint
 			
 			@logger = @server.logger || Async.logger
 		end
 		
 		attr :server
-		attr :address
+		attr :endpoint
 		
 		def error_response(query = nil, code = Resolv::DNS::RCode::ServFail)
 			# Encoding may fail, so we need to handle this particular case:
@@ -68,7 +68,7 @@ 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)
-			@address.bind do |socket|
+			@endpoint.bind do |socket|
 				while true
 					Async.logger.debug(self.class.name) {"-> socket.recvfrom"}
 					input_data, remote_address = socket.recvmsg(UDP_TRUNCATION_SIZE)
@@ -110,7 +110,7 @@ module Async::DNS
 	
 	class StreamHandler < GenericHandler
 		def run(task: Async::Task.current)
-			@address.accept do |client, address|
+			@endpoint.accept do |client, address|
 				handle_connection(client)
 			end
 		end

data/lib/async/dns/replace.rb

@@ -24,7 +24,7 @@ require 'resolv-replace'
 module Async::DNS
 	module Replace
 		class << self
-			attr :resolver, true
+			attr_accessor :resolver
 			
 			def resolver?
 				resolver != nil

data/lib/async/dns/resolver.rb

@@ -46,8 +46,8 @@ module Async::DNS
 		# Servers are specified in the same manor as options[:listen], e.g.
 		#   [:tcp/:udp, address, port]
 		# In the case of multiple servers, they will be checked in sequence.
-		def initialize(servers, origin: nil, logger: Async.logger, timeout: DEFAULT_TIMEOUT)
-			@servers = servers
+		def initialize(endpoints, origin: nil, logger: Async.logger, timeout: DEFAULT_TIMEOUT)
+			@endpoints = endpoints
 			
 			@origin = origin
 			@logger = logger
@@ -97,14 +97,14 @@ module Async::DNS
 			retries = options.fetch(:retries, DEFAULT_RETRIES)
 			delay = options.fetch(:delay, DEFAULT_DELAY)
 			
-			records = lookup(name, resource_class, cache) do |name, resource_class|
+			records = lookup(name, resource_class, cache) do |lookup_name, lookup_resource_class|
 				response = nil
 				
 				retries.times do |i|
 					# Wait 10ms before trying again:
 					sleep delay if delay and i > 0
 					
-					response = query(name, resource_class)
+					response = query(lookup_name, lookup_resource_class)
 					
 					break if response
 				end
@@ -134,18 +134,18 @@ module Async::DNS
 		
 		# 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, task: Async::Task.current)
-			request = Request.new(message, @servers)
+			request = Request.new(message, @endpoints)
 			
-			request.each do |address|
-				@logger.debug "[#{message.id}] Sending request #{message.question.inspect} to address #{address.inspect}" if @logger
+			request.each do |endpoint|
+				@logger.debug "[#{message.id}] Sending request #{message.question.inspect} to address #{endpoint.inspect}" if @logger
 				
 				begin
 					response = nil
 					
 					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
+						@logger.debug "[#{message.id}] -> Try address #{endpoint}" if @logger
+						response = try_server(request, endpoint)
+						@logger.debug "[#{message.id}] <- Try address #{endpoint} = #{response}" if @logger
 					end
 					
 					if valid_response(message, response)
@@ -175,8 +175,8 @@ module Async::DNS
 				response = yield(name, resource_class)
 				
 				if response
-					response.answer.each do |name, ttl, record|
-						(records[name] ||= []) << record
+					response.answer.each do |name_in_answer, ttl, record|
+						(records[name_in_answer] ||= []) << record
 					end
 				end
 				
@@ -184,14 +184,14 @@ module Async::DNS
 			end
 		end
 		
-		def try_server(request, address)
-			case address.type
+		def try_server(request, endpoint)
+			case endpoint.socket_type
 			when Socket::SOCK_DGRAM
-				try_datagram_server(request, address)
+				try_datagram_server(request, endpoint)
 			when Socket::SOCK_STREAM
-				try_stream_server(request, address)
+				try_stream_server(request, endpoint)
 			else
-				raise InvalidProtocolError.new(address)
+				raise InvalidProtocolError.new(endpoint)
 			end
 		end
 		
@@ -209,8 +209,8 @@ module Async::DNS
 			return false
 		end
 		
-		def try_datagram_server(request, address, task: Async::Task.current)
-			address.connect do |socket|
+		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)
@@ -219,10 +219,10 @@ module Async::DNS
 			end
 		end
 		
-		def try_stream_server(request, address)
+		def try_stream_server(request, endpoint)
 			context = Async::Task.current
 			
-			address.connect do |socket|
+			endpoint.connect do |socket|
 				StreamTransport.write_chunk(socket, request.packet)
 				
 				input_data = StreamTransport.read_chunk(socket)
@@ -233,15 +233,15 @@ module Async::DNS
 		
 		# Manages a single DNS question message across one or more servers.
 		class Request
-			def initialize(message, servers)
+			def initialize(message, endpoints)
 				@message = message
 				@packet = message.encode
 				
-				@servers = servers.dup
+				@endpoints = endpoints.dup
 				
 				# We select the protocol based on the size of the data:
 				if @packet.bytesize > UDP_TRUNCATION_SIZE
-					@servers.delete_if{|server| server[0] == :udp}
+					@endpoints.delete_if{|server| server[0] == :udp}
 				end
 			end
 			
@@ -250,7 +250,7 @@ module Async::DNS
 			attr :logger
 			
 			def each(&block)
-				Async::IO::Address.each(@servers, &block)
+				Async::IO::Endpoint.each(@endpoints, &block)
 			end
 
 			def update_id!(id)

data/lib/async/dns/server.rb

@@ -19,7 +19,7 @@
 # THE SOFTWARE.
 
 require 'async'
-require 'async/io/address'
+require 'async/io/endpoint'
 
 require_relative 'transaction'
 require_relative 'logger'
@@ -27,7 +27,7 @@ require_relative 'logger'
 module Async::DNS
 	class Server
 		# The default server interfaces
-		DEFAULT_INTERFACES = [[:udp, "0.0.0.0", 53], [:tcp, "0.0.0.0", 53]]
+		DEFAULT_ENDPOINTS = [[:udp, "0.0.0.0", 53], [:tcp, "0.0.0.0", 53]]
 		
 		# Instantiate a server with a block
 		#
@@ -37,8 +37,8 @@ module Async::DNS
 		#		end
 		#	end
 		#
-		def initialize(listen: DEFAULT_INTERFACES, origin: '.', logger: Async.logger)
-			@interfaces = listen
+		def initialize(endpoints = DEFAULT_ENDPOINTS, origin: '.', logger: Async.logger)
+			@endpoints = endpoints
 			@origin = origin
 			@logger = logger
 			
@@ -124,14 +124,14 @@ module Async::DNS
 		def setup_handlers
 			fire(:setup)
 			
-			Async::IO::Address.each(@interfaces) do |address|
-				case address.type
+			Async::IO::Endpoint.each(@endpoints) do |endpoint|
+				case endpoint.socket_type
 				when Socket::SOCK_DGRAM
-					@logger.info "<> Listening for datagrams on #{address.inspect}"
-					@handlers << DatagramHandler.new(self, address)
+					@logger.info "<> Listening for datagrams on #{endpoint.inspect}"
+					@handlers << DatagramHandler.new(self, endpoint)
 				when Socket::SOCK_STREAM
-					@logger.info "<> Listening for connections on #{address.inspect}"
-					@handlers << StreamHandler.new(self, address)
+					@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

data/lib/async/dns/version.rb

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

data/spec/async/dns/handler_spec.rb

@@ -25,7 +25,7 @@ describe Async::DNS::StreamHandler do
 	include_context Async::RSpec::Reactor
 	
 	let(:server) {Async::DNS::Server.new}
-	let(:address) {Async::IO::Address.tcp('127.0.0.1', 6666)}
+	let(:address) {Async::IO::Endpoint.tcp('127.0.0.1', 6666)}
 	
 	subject {described_class.new(server, address)}
 	
@@ -44,7 +44,7 @@ describe Async::DNS::DatagramHandler do
 	include_context Async::RSpec::Reactor
 	
 	let(:server) {Async::DNS::Server.new}
-	let(:address) {Async::IO::Address.udp('127.0.0.1', 6666)}
+	let(:address) {Async::IO::Endpoint.udp('127.0.0.1', 6666)}
 	
 	subject {described_class.new(server, address)}
 	

data/spec/async/dns/ipv6_spec.rb

@@ -38,7 +38,7 @@ module Async::DNS::IPv6Spec
 		include_context Async::RSpec::Reactor
 		
 		let(:server_interfaces) {[[:tcp, '::', 2004]]}
-		let(:server) {TestServer.new(listen: server_interfaces)}
+		let(:server) {TestServer.new(server_interfaces)}
 		
 		it "should connect to the server using TCP via IPv6" do
 			task = server.run
@@ -59,7 +59,7 @@ module Async::DNS::IPv6Spec
 		include_context Async::RSpec::Reactor
 		
 		let(:server_interfaces) {[[:udp, '::', 2006]]}
-		let(:server) {TestServer.new(listen: server_interfaces)}
+		let(:server) {TestServer.new(server_interfaces)}
 		
 		it "should connect to the server using UDP via IPv6" do
 			task = server.run

data/spec/async/dns/server_performance_spec.rb

@@ -25,28 +25,49 @@ require 'benchmark'
 require 'process/daemon'
 
 module Async::DNS::ServerPerformanceSpec
-	describe Async::DNS::Server do
-		include_context Async::RSpec::Reactor
+	class MillionServer < Async::DNS::Server
+		def initialize(*)
+			super
+			
+			@domains = {}
+			
+			(1..5_000).each do |i|
+				domain = "domain#{i}.local"
+
+				@domains[domain] = "#{69}.#{(i >> 16)%256}.#{(i >> 8)%256}.#{i%256}"
+			end
+		end
 		
-		context 'benchmark' do
-			class MillionServer < Async::DNS::Server
-				def initialize(*)
-					super
-					
-					@million = {}
-					
-					(1..5_000).each do |i|
-						domain = "domain#{i}.local"
+		attr :domains
+		
+		def process(name, resource_class, transaction)
+			transaction.respond!(@domains[name])
+		end
+	end
 	
-						@million[domain] = "#{69}.#{(i >> 16)%256}.#{(i >> 8)%256}.#{i%256}"
-					end
-				end
-				
-				def process(name, resource_class, transaction)
-					transaction.respond!(@million[name])
-				end
+	RSpec.describe MillionServer do
+		# include_context "profile"
+		include_context Async::RSpec::Reactor
+		
+		let(:interfaces) {[[:udp, '127.0.0.1', 8899]]}
+		let(:server) {MillionServer.new(interfaces)}
+		let(:resolver) {Async::DNS::Resolver.new(interfaces)}
+		
+		it "should be fast" do
+			task = server.run
+			
+			server.domains.each do |name, address|
+				resolved = resolver.addresses_for(name)
 			end
 			
+			task.stop
+		end
+	end
+	
+	RSpec.describe Async::DNS::Server do
+		include_context Async::RSpec::Reactor
+		
+		context 'benchmark' do
 			class AsyncServerDaemon < Process::Daemon
 				def working_directory
 					File.expand_path("../tmp", __FILE__)
@@ -58,7 +79,7 @@ module Async::DNS::ServerPerformanceSpec
 				
 				def startup
 					puts "Starting DNS server..."
-					@server = MillionServer.new(listen: [[:udp, '0.0.0.0', 5300]])
+					@server = MillionServer.new([[:udp, '0.0.0.0', 5300]])
 					
 					reactor.async do
 						@task = @server.run
@@ -121,13 +142,15 @@ module Async::DNS::ServerPerformanceSpec
 						resolver = Async::DNS::Resolver.new([[:udp, '127.0.0.1', port]])
 					
 						x.report(name) do
-							# Number of requests remaining since this is an asynchronous event loop:
-							5.times do
-								pending = @domains.size
-							
-								resolved = @domains.collect{|domain| resolver.addresses_for(domain)}
+							Async::Reactor.run do
+								# Number of requests remaining since this is an asynchronous event loop:
+								5.times do
+									pending = @domains.size
 								
-								expect(resolved).to_not include(nil)
+									resolved = @domains.collect{|domain| resolver.addresses_for(domain)}
+									
+									expect(resolved).to_not include(nil)
+								end
 							end
 						end
 					end

data/spec/async/dns/slow_server_spec.rb

@@ -39,7 +39,7 @@ module Async::DNS::SlowServerSpec
 		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)}
+		let(:server) {SlowServer.new(server_interfaces)}
 		
 		around(:each) do |example|
 			begin

data/spec/async/dns/socket_spec.rb

@@ -38,7 +38,7 @@ module Async::DNS::SocketSpec
 		include_context Async::RSpec::Reactor
 		
 		let(:server_interfaces) {[TCPServer.new('127.0.0.1', 2002)]}
-		let(:server) {TestServer.new(listen: server_interfaces)}
+		let(:server) {TestServer.new(server_interfaces)}
 		
 		it "should create server with existing TCP socket" do
 			task = server.run
@@ -56,7 +56,7 @@ module Async::DNS::SocketSpec
 		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)}
+		let(:server) {TestServer.new(server_interfaces)}
 		
 		it "should create server with existing UDP socket" do
 			task = server.run

data/spec/async/dns/truncation_spec.rb

@@ -42,7 +42,7 @@ module Async::DNS::TruncationSpec
 	describe "Async::DNS Truncation Server" do
 		include_context Async::RSpec::Reactor
 		
-		let(:server) {TestServer.new(listen: SERVER_PORTS)}
+		let(:server) {TestServer.new(SERVER_PORTS)}
 		
 		it "should use tcp because of large response" do
 			task = server.run

data/spec/spec_helper.rb

@@ -26,7 +26,26 @@ require "bundler/setup"
 require "async/rspec"
 require "async/dns"
 
-# abort "Warning, ulimit is too low!" if `ulimit -n`.to_i < 10000
+begin
+	require 'ruby-prof'
+	
+	RSpec.shared_context "profile" do
+		around(:each) do |example|
+			profile = RubyProf.profile(merge_fibers: true) do
+				example.run
+			end
+			
+			printer = RubyProf::FlatPrinter.new(profile)
+			printer.print(STDOUT)
+		end
+	end
+rescue LoadError
+	RSpec.shared_context "profile" do
+		before(:all) do
+			puts "Profiling not supported on this platform."
+		end
+	end
+end
 
 RSpec.configure do |config|
 	# Enable flags like --only-failures and --next-failure

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-dns
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-25 00:00:00.000000000 Z
+date: 2017-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-io
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: async-rspec
   requirement: !ruby/object:Gem::Requirement