rubydns 0.8.1 → 0.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dbd9b4d8a8eec2e1ae92fb9d8e5b57cf0eb120d4
-  data.tar.gz: dc2b13bae0244a6bade2b299f13b7ce1524aafc1
+  metadata.gz: 204ba4e799634855d87e3a5b0d4969e17b7aafcf
+  data.tar.gz: 55f9a962495018de41eeb37656b61d2e9580e519
 SHA512:
-  metadata.gz: 661f8462c7fd1f6769b1674a556d34c3859b8ef8832435d294c9879a49d230a27ec1cb961bfc4814d43e1d81d5ea5b2b701c7f423465ab0b24c9f72df4822f7e
-  data.tar.gz: 99aab4506a8903ad037f6bcbfb1d0fb8c64a25c48b9599f14336e4bb4522649de45b24ff8d983cbf1ef598730ee70ea53b923e9f425d630921eb89da6f670113
+  metadata.gz: 9a08e54d3e38cb82e735a65750dae55452c94115d28a1ea115452069afacb6ac978645de0dd25a547c65168703249df4a6f5bbb75254e8a4d5b1e368db58229d
+  data.tar.gz: 18220b387aec7b2b145f1af7760947b08aee115ab87a8e04fdbc34d0d230c0d49a3396c0252b3e87bf94d956982bba1aa905106f368059db6c286fbb42c03924

data/.travis.yml

@@ -1,4 +1,8 @@
 language: ruby
+before_install:
+  - sudo apt-get update -qq
+  - sudo apt-get install -y bind9
 rvm:
-  - 2.0.0
-  - 2.1.0
+  - 1.9
+  - 2.0
+  - 2.1

data/README.md

@@ -8,7 +8,7 @@ For examples and documentation please see the main [project page][1].
 
 [1]: http://www.codeotaku.com/projects/rubydns/
 
-[![Build Status](https://travis-ci.org/ioquatix/rubydns.svg)](https://travis-ci.org/ioquatix/rubydns)
+[![Build Status](https://travis-ci.org/ioquatix/rubydns.svg?branch=master)](https://travis-ci.org/ioquatix/rubydns)
 [![Code Climate](https://codeclimate.com/github/ioquatix/rubydns.png)](https://codeclimate.com/github/ioquatix/rubydns)
 
 ## Installation
@@ -63,6 +63,10 @@ Start the server using `rvmsudo ./test.rb`. You can then test it using dig:
 	$ dig @localhost dev.mydomain.org
 	$ dig @localhost google.com
 
+### File Handle Limitations
+
+On some platforms (e.g. Mac OS X) the number of file descriptors is relatively low by default and should be increased by calling `ulimit -n 10000` before running tests or even before starting a server which expects a large number of concurrent incoming connections.
+
 ### Custom servers
 
 It is possible to create and integrate your own custom servers.
@@ -79,12 +83,44 @@ It is possible to create and integrate your own custom servers.
 
 This is the best way to integrate with other projects.
 
+## Performance
+
+We welcome additional benchmarks and feedback regarding RubyDNS performance.
+
+### Server
+
+The performance is on the same magnitude as `bind9` however `bind9` supports multiple CPUs and thus can scale more easily than RubyDNS using MRI. Some basic benchmarks resolving 1000 names concurrently, repeated 5 times, using `RubyDNS::Resolver` gives the following:
+
+	Testing server performance...
+	                           user     system      total        real
+	RubyDNS::Server        1.040000   0.320000   1.360000 (  6.469213)
+	Bind9                  1.940000   0.120000   2.060000 (  2.062983)
+
+These benchmarks are included in the unit tests. To test bind9 performance, it must be installed and `which named` must return the executable.
+
+### Resolver
+
+The `RubyDNS::Resolver` is highly concurrent and can resolve individual names as fast as the built in `Resolv::DNS` resolver. Because the resolver is asynchronous, when dealing with multiple names, it can work more efficiently:
+
+	Comparing resolvers...
+	                           user     system      total        real
+	RubyDNS::Resolver      0.020000   0.010000   0.030000 (  0.280679)
+	Resolv::DNS            0.030000   0.010000   0.040000 (  2.801773)
+
+These benchmarks are included in the unit tests.
+
 ## Compatibility
 
 ### Migrating from RubyDNS 0.7.x to 0.8.x
 
 The primary change is the removal of the dependency on `RExec` which was used for daemons and the addition of the testing dependency `process-daemon`. In order to create and run your own daemon, you may use `process-daemon` or another tool of your choice.
 
+The transaction options are now conveniently available:
+
+	transaction.options[key] == transaction[key]
+
+The remote peer address used to be available directly via `transaction[:peer]` but profiling revealed that the `EventMachine::Connection#get_peername` was moderately expensive. Therefore, the incoming connection is now available in `transaction[:connection]` and more specifically `transaction[:peer]` is no longer available and replaced by `transaction[:connection].peername` which gives `[ip_address, port]`.
+
 ### Migrating from RubyDNS 0.6.x to 0.7.x
 
 The asynchronous deferred processing became the default and only method for processing requests in `0.7.0`. This simplifies the API but there were a few changes, notably the removal of `defer!` and the addition of `defer`. The reason for this was due to issues relating to deferred processing and the flow of control, which were confusing and introduced bugs in specific situations. Now, you can assume flow control through the entire block even with non-blocking functions.

data/lib/rubydns/handler.rb

@@ -22,20 +22,24 @@ require_relative 'message'
 require_relative 'binary_string'
 
 module RubyDNS
-	# @returns the [port, ip address] of the given connection.
-	def self.get_peer_details(connection)
-		Socket.unpack_sockaddr_in(connection.get_peername)
+	module Peername
+		# Available for both UDP and TCP connections, returns `[address, port]`.
+		def peername
+			Socket.unpack_sockaddr_in(self.get_peername).reverse
+		end
 	end
 	
 	# Handling incoming UDP requests, which are single data packets, and pass them on to the given server.
 	module UDPHandler
+		include Peername
+		
 		def initialize(server)
 			@server = server
 		end
 		
 		# Process a packet of data with the given server. If an exception is thrown, a failure message will be sent back.
 		def self.process(server, data, options = {}, &block)
-			server.logger.debug "Receiving incoming query (#{data.bytesize} bytes)..."
+			server.logger.debug {"Receiving incoming query (#{data.bytesize} bytes)..."}
 			query = nil
 
 			begin
@@ -63,17 +67,20 @@ module RubyDNS
 			end
 		end
 		
+		def peername
+			Socket.unpack_sockaddr_in(self.get_peername)
+		end
+		
 		def receive_data(data)
-			peer_port, peer_ip = RubyDNS::get_peer_details(self)
-			options = {:peer => peer_ip}
+			options = {:connection => self}
 			
 			UDPHandler.process(@server, data, options) do |answer|
 				data = answer.encode
 				
-				@server.logger.debug "Writing response to client (#{data.bytesize} bytes) via UDP..."
+				@server.logger.debug {"Writing response to client (#{data.bytesize} bytes) via UDP..."}
 				
 				if data.bytesize > UDP_TRUNCATION_SIZE
-					@server.logger.warn "Response via UDP was larger than #{UDP_TRUNCATION_SIZE}!"
+					@server.logger.warn {"Response via UDP was larger than #{UDP_TRUNCATION_SIZE}!"}
 					
 					# Reencode data with truncation flag marked as true:
 					truncation_error = Resolv::DNS::Message.new(answer.id)
@@ -83,7 +90,8 @@ module RubyDNS
 				end
 				
 				# We explicitly use the ip and port given, because we found that send_data was unreliable in a callback.
-				self.send_datagram(data, peer_ip, peer_port)
+				# self.send_datagram(data, peer_ip, peer_port)
+				self.send_data(data)
 			end
 		end
 	end
@@ -92,6 +100,8 @@ module RubyDNS
 	end
 	
 	module TCPHandler
+		include Peername
+		
 		def initialize(server)
 			@server = server
 			
@@ -120,7 +130,7 @@ module RubyDNS
 			if (@buffer.size - @processed) >= @length
 				data = @buffer.string.byteslice(@processed, @length)
 				
-				options = {:peer => RubyDNS::get_peer_details(self)}
+				options = {:connection => self}
 				
 				UDPHandler.process(@server, data, options) do |answer|
 					data = answer.encode

data/lib/rubydns/server.rb

@@ -63,6 +63,8 @@ module RubyDNS
 		
 		# Process an incoming DNS message. Returns a serialized message to be sent back to the client.
 		def process_query(query, options = {}, &block)
+			start_time = Time.now
+			
 			# Setup answer
 			answer = Resolv::DNS::Message::new(query.id)
 			answer.qr = 1                 # 0 = Query, 1 = Response
@@ -77,20 +79,23 @@ module RubyDNS
 				
 				begin
 					query.question.each do |question, resource_class|
-						@logger.debug "Processing question #{question} #{resource_class}..."
+						@logger.debug {"[#{query.id}] Processing question #{question} #{resource_class}..."}
 				
 						transaction = Transaction.new(self, query, question, resource_class, answer, options)
 						
 						transaction.process
 					end
 				rescue
-					@logger.error "Exception thrown while processing #{transaction}!"
+					@logger.error {"[#{query.id}] Exception thrown while processing #{transaction}!"}
 					RubyDNS.log_exception(@logger, $!)
 				
 					answer.rcode = Resolv::DNS::RCode::ServFail
 				end
-			
+				
 				yield answer
+				
+				end_time = Time.now
+				@logger.debug {"[#{query.id}] Time to process request: #{end_time - start_time}s"}
 			end.resume
 		end
 		
@@ -267,10 +272,10 @@ module RubyDNS
 		
 		# Give a name and a record type, try to match a rule and use it for processing the given arguments.
 		def process(name, resource_class, *args)
-			@logger.debug "Searching for #{name} #{resource_class.name}"
+			@logger.debug {"Searching for #{name} #{resource_class.name}"}
 			
 			@rules.each do |rule|
-				@logger.debug "Checking rule #{rule}..."
+				@logger.debug {"Checking rule #{rule}..."}
 				
 				catch (:next) do
 					# If the rule returns true, we assume that it was successful and no further rules need to be evaluated.

data/lib/rubydns/transaction.rb

@@ -61,6 +61,10 @@ module RubyDNS
 		# Any options or configuration associated with the given transaction.
 		attr :options
 		
+		def [] key
+			@options[key]
+		end
+		
 		# The name of the question, which is typically the requested hostname.
 		def name
 			@question.to_s

data/lib/rubydns/version.rb

@@ -19,5 +19,5 @@
 # THE SOFTWARE.
 
 module RubyDNS
-	VERSION = "0.8.1"
+	VERSION = "0.8.4"
 end

data/lib/rubydns.rb

@@ -31,6 +31,10 @@ module RubyDNS
 		server = RubyDNS::RuleBasedServer.new(&block)
 		
 		EventMachine.run do
+			trap("INT") do
+				EventMachine::stop
+			end
+			
 			server.run(options)
 		end
 		

data/rubydns.gemspec

@@ -33,6 +33,6 @@ Gem::Specification.new do |spec|
 	spec.add_dependency("eventmachine", "~> 1.0.0")
 	
 	spec.add_development_dependency "bundler", "~> 1.3"
-	spec.add_development_dependency "process-daemon", "~> 0.5.0"
+	spec.add_development_dependency "process-daemon", "~> 0.5.3"
 	spec.add_development_dependency "rake"
 end

data/test/examples/dropping-dns.rb

@@ -30,10 +30,6 @@ INTERFACES = [
 ]
 
 class DroppingDaemon < Process::Daemon
-	# You can specify a specific directory to use for run-time information (pid, logs, etc):
-	# @@base_directory = File.expand_path("../", __FILE__)
-	# @@base_directory = "/var"
-
 	Name = Resolv::DNS::Name
 	IN = Resolv::DNS::Resource::IN
 	R = RubyDNS::Resolver.new(RubyDNS::System::nameservers)

data/test/examples/fortune-dns.rb

@@ -43,8 +43,6 @@ end
 # To use, start the daemon and try:
 # dig @localhost fortune CNAME
 class FortuneDNS < Process::Daemon
-	@@base_directory = File.dirname(__FILE__)
-
 	Name = Resolv::DNS::Name
 	IN = Resolv::DNS::Resource::IN
 

data/test/examples/geoip-dns.rb

@@ -35,10 +35,6 @@ INTERFACES = [
 # For more information, please see http://www.maxmind.com/en/geolite and http://geoip.rubyforge.org
 
 class GeoIPDNSDaemon < Process::Daemon
-	# You can specify a specific directory to use for run-time information (pid, logs, etc):
-	# @@base_directory = File.expand_path("../", __FILE__)
-	# @@base_directory = "/var"
-
 	Name = Resolv::DNS::Name
 	IN = Resolv::DNS::Resource::IN
 	R = RubyDNS::Resolver.new(RubyDNS::System::nameservers)
@@ -48,7 +44,7 @@ class GeoIPDNSDaemon < Process::Daemon
 		RubyDNS::run_server(:listen => INTERFACES) do
 			match(//, IN::A) do |transaction|
 				location = nil
-				peer = transaction.options[:peer]
+				peer = transaction.options[:connection].peername[0]
 				
 				if peer
 					logger.debug "Looking up geographic information for peer #{peer}"

data/test/examples/wikipedia-dns.rb

@@ -57,8 +57,6 @@ end
 # To use, start the daemon and try:
 # dig @localhost fortune CNAME
 class WikipediaDNS < Process::Daemon
-	@@base_directory = File.dirname(__FILE__)
-
 	Name = Resolv::DNS::Name
 	IN = Resolv::DNS::Resource::IN
 

data/test/performance/benchmark.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require 'benchmark'
+require 'rubydns'
+
+Benchmark.bm(20) do |x|
+	DOMAINS = (1..1000).collect do |i|
+		"domain#{i}.local"
+	end
+	
+	resolved = {}
+	
+	x.report("RubyDNS::Resolver") do
+		resolver = RubyDNS::Resolver.new([[:udp, '127.0.0.1', 5300]])
+		
+		# Number of requests remaining since this is an asynchronous event loop:
+		pending = DOMAINS.size
+		
+		EventMachine::run do
+			DOMAINS.each do |domain|
+				resolver.addresses_for(domain) do |addresses|
+					resolved[domain] = addresses
+					
+					EventMachine::stop if (pending -= 1) == 0
+				end
+			end
+		end
+	end
+end

data/test/performance/bind9/generate-local.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+File.open("local.zone", "w") do |f|
+	f.write(DATA.read)
+	
+	(1..5_000).each do |i|
+		f.puts "domain#{i} IN A #{69}.#{(i >> 16)%256}.#{(i >> 8)%256}.#{i%256}"
+	end
+end
+
+__END__
+;
+; BIND data file for local loopback interface
+;
+$TTL    604800
+@       IN      SOA     ns.local. postmaster.localhost (
+                      2         ; Serial
+                 604800         ; Refresh
+                  86400         ; Retry
+                2419200         ; Expire
+                 604800 )       ; Negative Cache TTL
+;
+local.            IN	NS	ns.local.
+ns.local.         IN	A	127.0.0.1
+