rubydns 0.9.3 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b96c1f2e9752973d51217be442205e95defe642
-  data.tar.gz: 0200c178cbbffe9429b7ec0997f0bfc407a00868
+  metadata.gz: 29d3991adacb8a0b1d03b6fa1a6a4283c13a4c09
+  data.tar.gz: 12ac3d2fec1d3e96afcae1ee35d35be91b948c7c
 SHA512:
-  metadata.gz: 007c979c79a868f387b0ed0168649c9a8ff7b188c7b9a5e8c63e959c761dfa15b5ce517fac63ecdf7070e18d316f3a6ac48913cf91ac48267a49e4aee002c26a
-  data.tar.gz: 20287eb57c761aebb9742c9ac563725a5b8dd3a5adb3c4741ca9441d3eceaee5a4422f4e3e70a1028a4c91c7a2d6562d0c325b6f2935c21dfead3a7f1ac82da8
+  metadata.gz: 489667f6def732211dac4a3d88bfb5bc4fa250ec4f4873999141a99a32c98b6f69f3c14755449b874c4aaa461dcf2c57892cf40046463c6a0fd95fc0c203d180
+  data.tar.gz: a68f53b8e32e2dc3bf25906f0c9dbc17da641bfcf5e32f1f71373dffd5ce17a6aef222dbce991b3ed4fac1d273e06691f89353377d026d018ce139ab7c7cb595

data/.travis.yml

@@ -3,10 +3,11 @@ before_install:
   - sudo apt-get update -qq
   - sudo apt-get install -y bind9
 rvm:
-  - 1.9
-  - 2.0
+  - 2.2
   - 2.1
+  - 2.0.0
+  - 1.9.3
   - rbx-2
 matrix:
   allow_failures:
-    - rvm: rbx-2 
+    - rvm: rbx-2 

data/README.md

@@ -17,15 +17,15 @@ For examples and documentation please see the main [project page][2].
 
 Add this line to your application's Gemfile:
 
-    gem 'rubydns'
+	gem 'rubydns'
 
 And then execute:
 
-    $ bundle
+	$ bundle
 
 Or install it yourself as:
 
-    $ gem install rubydns
+	$ gem install rubydns
 
 ## Usage
 
@@ -75,9 +75,13 @@ It is possible to create and integrate your own custom servers.
 		end
 	end
 	
-	EventMachine.run do
-		MyServer.new.run
-	end
+	# Use the RubyDNS infrastructure for running the daemon:
+	# If asynchronous is true, it will return immediately, otherwise, it will block the current thread until Ctrl-C is pressed (SIGINT).
+	RubyDNS::run_server(asynchronous: false, server_class: MyServer)
+	
+	# Directly instantiate the celluloid supervisor:
+	supervisor = MyServer.supervise
+	supervisor.actors.first.run
 
 This is the best way to integrate with other projects.
 
@@ -180,7 +184,7 @@ Here is a basic example of how to use the new resolver in full. It is important
 	resolver = RubyDNS::Resolver.new([[:udp, "8.8.8.8", 53], [:tcp, "8.8.8.8", 53]])
 
 	EventMachine::run do
-	  resolver.query('google.com', IN::A) do |response|
+		resolver.query('google.com', IN::A) do |response|
 			case response
 			when RubyDNS::Message
 				puts "Got response: #{response.answers.first}"

data/lib/rubydns.rb

@@ -29,9 +29,9 @@ require_relative 'rubydns/logger'
 module RubyDNS
 	# Run a server with the given rules.
 	def self.run_server (options = {}, &block)
-		supervisor_class = options[:supervisor_class] || RuleBasedServer
+		server_class = options[:server_class] || RuleBasedServer
 		
-		supervisor = supervisor_class.supervise(options, &block)
+		supervisor = server_class.supervise(options, &block)
 		
 		supervisor.actors.first.run
 		if options[:asynchronous]

data/lib/rubydns/extensions/resolv.rb

@@ -45,5 +45,41 @@ class Resolv
 				@rd = @rd || other.rd
 			end
 		end
+		
+		class OriginError < ArgumentError
+		end
+		
+		class Name
+			def to_s
+				"#{@labels.join('.')}#{@absolute ? '.' : ''}"
+			end
+			
+			def inspect
+				"#<#{self.class}: #{self.to_s}>"
+			end
+			
+			# Return the name, typically absolute, with the specified origin as a suffix. If the origin is nil, don't change the name, but change it to absolute (as specified).
+			def with_origin(origin, absolute = true)
+				return self.class.new(@labels, absolute) if origin == nil
+				
+				origin = Label.split(origin) if String === origin
+				
+				return self.class.new(@labels + origin, absolute)
+			end
+			
+			
+			# Return the name, typically relative, without the specified origin suffix. If the origin is nil, don't change the name, but change it to absolute (as specified).
+			def without_origin(origin, absolute = false)
+				return self.class.new(@labels, absolute) if origin == nil
+				
+				origin = Label.split(origin) if String === origin
+				
+				if @labels.last(origin.length) == origin
+					return self.class.new(@labels.first(@labels.length - origin.length), absolute)
+				else
+					raise OriginError.new("#{self} does not end with #{origin.join('.')}")
+				end
+			end
+		end
 	end
 end

data/lib/rubydns/resolver.rb

@@ -44,8 +44,30 @@ module RubyDNS
 			
 			@options = options
 			
+			@origin = options[:origin] || nil
+			
 			@logger = options[:logger] || Celluloid.logger
 		end
+		
+		attr_accessor :origin
+		
+		def fully_qualified_name(name)
+			# If we are passed an existing deconstructed name:
+			if Resolv::DNS::Name === name
+				if name.absolute?
+					return name
+				else
+					return name.with_origin(@origin)
+				end
+			end
+			
+			# ..else if we have a string, we need to do some basic processing:
+			if name.end_with? '.'
+				return Resolv::DNS::Name.create(name)
+			else
+				return Resolv::DNS::Name.create(name).with_origin(@origin)
+			end
+		end
 
 		# Provides the next sequence identification number which is used to keep track of DNS messages.
 		def next_id!
@@ -57,28 +79,52 @@ module RubyDNS
 		def query(name, resource_class = Resolv::DNS::Resource::IN::A)
 			message = Resolv::DNS::Message.new(next_id!)
 			message.rd = 1
-			message.add_question name, resource_class
+			message.add_question fully_qualified_name(name), resource_class
 			
 			dispatch_request(message)
 		end
 		
 		# Yields a list of `Resolv::IPv4` and `Resolv::IPv6` addresses for the given `name` and `resource_class`. Raises a ResolutionFailure if no severs respond.
 		def addresses_for(name, resource_class = Resolv::DNS::Resource::IN::A, options = {})
-			(options[:retries] || 5).times do
-				response = query(name, resource_class)
+			name = fully_qualified_name(name)
+			
+			cache = options.fetch(:cache, {})
+			retries = options.fetch(:retries, 10)
+			delay = options.fetch(:delay, 0.01)
+			
+			records = lookup(name, resource_class, cache) do |name, resource_class|
+				response = nil
 				
-				if response
-					# Resolv::DNS::Name doesn't retain the trailing dot.
-					name = name.sub(/\.$/, '')
+				retries.times do |i|
+					# Wait 10ms before trying again:
+					sleep delay if delay and i > 0
 					
-					return response.answer.select{|record| record[0].to_s == name}.collect{|record| record[2].address}
+					response = query(name, resource_class)
+					
+					break if response
 				end
 				
-				# Wait 10ms before trying again:
-				sleep 0.01
+				response or abort ResolutionFailure.new("Could not resolve #{name} after #{retries} attempt(s).")
+			end
+			
+			addresses = []
+			
+			if records
+				records.each do |record|
+					if record.respond_to? :address
+						addresses << record.address
+					else
+						# The most common case here is that record.class is IN::CNAME and we need to figure out the address. Usually the upstream DNS server would have replied with this too, and this will be loaded from the response if possible without requesting additional information.
+						addresses += addresses_for(record.name, record.class, options.merge(cache: cache))
+					end
+				end
 			end
 			
-			abort ResolutionFailure.new("No server replied.")
+			if addresses.size > 0
+				return addresses
+			else
+				abort ResolutionFailure.new("Could not find any addresses for #{name}.")
+			end
 		end
 		
 		def request_timeout
@@ -90,7 +136,7 @@ module RubyDNS
 			request = Request.new(message, @servers)
 			
 			request.each do |server|
-				@logger.debug "[#{message.id}] Sending request to server #{server.inspect}" if @logger
+				@logger.debug "[#{message.id}] Sending request #{message.question.inspect} to server #{server.inspect}" if @logger
 				
 				begin
 					response = nil
@@ -121,6 +167,21 @@ module RubyDNS
 		
 		private
 		
+		# Lookup a name/resource_class record but use the records cache if possible reather than making a new request if possible.
+		def lookup(name, resource_class = Resolv::DNS::Resource::IN::A, records = {})
+			records.fetch(name) do
+				response = yield(name, resource_class)
+				
+				if response
+					response.answer.each do |name, ttl, record|
+						(records[name] ||= []) << record
+					end
+				end
+				
+				records[name]
+			end
+		end
+		
 		def try_server(request, server)
 			case server[0]
 			when :udp
@@ -139,7 +200,7 @@ module RubyDNS
 				@logger.warn "[#{message.id}] Received response with incorrect message id: #{response.id}!" if @logger
 			else
 				@logger.debug "[#{message.id}] Received valid response with #{response.answer.count} answer(s)." if @logger
-		
+				
 				return true
 			end
 			

data/lib/rubydns/server.rb

@@ -57,8 +57,13 @@ module RubyDNS
 			
 			@logger = options[:logger] || Celluloid.logger
 			@interfaces = options[:listen] || DEFAULT_INTERFACES
+			
+			@origin = options[:origin] || '.'
 		end
 
+		# Records are relative to this origin:
+		attr_accessor :origin
+
 		attr_accessor :logger
 
 		# Fire the named event as part of running the server.
@@ -91,11 +96,18 @@ module RubyDNS
 			
 			begin
 				query.question.each do |question, resource_class|
-					@logger.debug {"<#{query.id}> Processing question #{question} #{resource_class}..."}
-			
-					transaction = Transaction.new(self, query, question, resource_class, response, options)
-					
-					transaction.process
+					begin
+						question = question.without_origin(@origin)
+						
+						@logger.debug {"<#{query.id}> Processing question #{question} #{resource_class}..."}
+						
+						transaction = Transaction.new(self, query, question, resource_class, response, options)
+						
+						transaction.process
+					rescue Resolv::DNS::OriginError
+						# This is triggered if the question is not part of the specified @origin:
+						@logger.debug {"<#{query.id}> Skipping question #{question} #{resource_class} because #{$!}"}
+					end
 				end
 			rescue Celluloid::ResumableError
 				raise

data/lib/rubydns/version.rb

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

data/spec/rubydns/daemon_spec.rb

@@ -75,12 +75,14 @@ describe "RubyDNS Daemonized Server" do
 	it "should resolve local domain correctly" do
 		expect(BasicTestServer.status).to be == :running
 		
-		resolver = RubyDNS::Resolver.new(BasicTestServer::SERVER_PORTS)
+		resolver = RubyDNS::Resolver.new(BasicTestServer::SERVER_PORTS, search_domain: '')
 	
 		response = resolver.query("test.local")
+		puts "Response: #{response.inspect}"
+		
 		answer = response.answer.first
 		
-		expect(answer[0].to_s).to be == "test.local"
+		expect(answer[0].to_s).to be == "test.local."
 		expect(answer[2].address.to_s).to be == "192.168.1.1"
 	end
 	
@@ -92,7 +94,7 @@ describe "RubyDNS Daemonized Server" do
 		response = resolver.query("foobar")
 		answer = response.answer.first
 		
-		expect(answer[0].to_s).to be == "foobar"
+		expect(answer[0]).to be == resolver.fully_qualified_name("foobar")
 		expect(answer[2].address.to_s).to be == "192.168.1.2"
 	end
 	

data/spec/rubydns/injected_supervisor_spec.rb

@@ -39,7 +39,7 @@ module RubyDNS::InjectedSupervisorSpec
 			Celluloid.boot
 			
 			# Start the RubyDNS server
-			RubyDNS::run_server(listen: SERVER_PORTS, supervisor_class: TestServer, asynchronous: true) do
+			RubyDNS::run_server(listen: SERVER_PORTS, server_class: TestServer, asynchronous: true) do
 				match("test_message", IN::TXT) do |transaction|
 					transaction.respond!(*test_message.chunked)
 				end

data/spec/rubydns/origin_spec.rb

@@ -0,0 +1,106 @@
+#!/usr/bin/env rspec
+
+# Copyright, 2014, 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 'rubydns'
+
+module RubyDNS::OriginSpec
+	describe RubyDNS::Resolver do
+		it "should generate fully qualified domain name with specified origin" do
+			resolver = RubyDNS::Resolver.new([], origin: "foo.bar.")
+			
+			fully_qualified_name = resolver.fully_qualified_name("baz")
+			
+			expect(fully_qualified_name).to be_absolute
+			expect(fully_qualified_name.to_s).to be == "baz.foo.bar."
+		end
+	end
+	
+	describe Resolv::DNS::Name do
+		let(:name) {Resolv::DNS::Name.create("foo.bar")}
+		
+		it "should be relative" do
+			expect(name).to_not be_absolute
+			expect(name.to_s).to be == "foo.bar"
+		end
+		
+		it "should add the specified origin" do
+			fully_qualified_name = name.with_origin("org")
+			
+			expect(fully_qualified_name.to_a.size).to be 3
+			expect(fully_qualified_name).to be_absolute
+			expect(fully_qualified_name.to_s).to be == "foo.bar.org."
+		end
+		
+		it "should handle nil origin as absolute" do
+			fully_qualified_name = name.with_origin(nil)
+			
+			expect(fully_qualified_name.to_a.size).to be 2
+			expect(fully_qualified_name).to be_absolute
+			expect(fully_qualified_name.to_s).to be == "foo.bar."
+		end
+		
+		it "should handle empty origin as absolute" do
+			fully_qualified_name = name.with_origin('')
+			
+			expect(fully_qualified_name.to_a.size).to be 2
+			expect(fully_qualified_name).to be_absolute
+			expect(fully_qualified_name.to_s).to be == "foo.bar."
+		end
+	end
+	
+	describe Resolv::DNS::Name do
+		let(:name) {Resolv::DNS::Name.create("foo.bar.")}
+		
+		it "should be absolute" do
+			expect(name).to be_absolute
+			expect(name.to_s).to be == "foo.bar."
+		end
+		
+		it "should remove the specified origin" do
+			relative_name = name.without_origin("bar")
+			
+			expect(relative_name.to_a.size).to be 1
+			expect(relative_name).to_not be_absolute
+			expect(relative_name.to_s).to be == "foo"
+		end
+		
+		it "should not remove nil origin but become relative" do
+			relative_name = name.without_origin(nil)
+			
+			expect(relative_name.to_a.size).to be 2
+			expect(relative_name).to_not be_absolute
+			expect(relative_name.to_s).to be == "foo.bar"
+		end
+		
+		it "should not remove empty string origin but become relative" do
+			relative_name = name.without_origin('')
+			
+			expect(relative_name.to_a.size).to be 2
+			expect(relative_name).to_not be_absolute
+			expect(relative_name.to_s).to be == "foo.bar"
+		end
+		
+		it "should not raise an exception when origin isn't valid" do
+			expect{name.without_origin('bob')}.to raise_exception(Resolv::DNS::OriginError)
+		end
+	end
+end

data/spec/rubydns/resolver_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env rspec
 
 # Copyright, 2012, by Samuel G. D. Williams. <http://www.codeotaku.com>
 # 
@@ -140,5 +140,13 @@ module RubyDNS::ResolverSpec
 				expect(address).to be_kind_of(Resolv::IPv4) | be_kind_of(Resolv::IPv6)
 			end
 		end
+		
+		it "should recursively resolve CNAME records" do
+			resolver = RubyDNS::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
 	end
 end

data/spec/rubydns/transaction_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env rspec
 
 # Copyright, 2012, by Samuel G. D. Williams. <http://www.codeotaku.com>
 # 
@@ -30,7 +30,7 @@ module RubyDNS::TransactionSpec
 	describe RubyDNS::Transaction do
 		let(:server) { RubyDNS::Server.new }
 		let(:query) { RubyDNS::Message.new(0) }
-		let(:question) { Resolv::DNS::Name.create("www.google.com") }
+		let(:question) { Resolv::DNS::Name.create("www.google.com.") }
 		let(:response) { RubyDNS::Message.new(0) }
 		let(:resolver) { RubyDNS::Resolver.new([[:udp, '8.8.8.8', 53], [:tcp, '8.8.8.8', 53]])}
 		
@@ -39,7 +39,7 @@ module RubyDNS::TransactionSpec
 			
 			transaction.respond!("1.2.3.4")
 			
-			expect(transaction.response.answer[0][0].to_s).to be == question.to_s
+			expect(transaction.response.answer[0][0]).to be == question
 			expect(transaction.response.answer[0][2].address.to_s).to be == "1.2.3.4"
 		end
 		
@@ -84,5 +84,55 @@ module RubyDNS::TransactionSpec
 			
 			expect(transaction.response.rcode).to be Resolv::DNS::RCode::NXDomain
 		end
+		
+		it "should return AAAA record" do
+			transaction = RubyDNS::Transaction.new(server, query, question, IN::AAAA, response)
+			
+			expect(transaction.response.answer.size).to be 0
+			
+			transaction.passthrough!(resolver)
+			
+			expect(transaction.response.answer.first[2]).to be_kind_of IN::AAAA
+		end
+		
+		it "should return MX record" do
+			transaction = RubyDNS::Transaction.new(server,query,"google.com",IN::MX, response)
+			
+			expect(transaction.response.answer.size).to be 0
+			
+			transaction.passthrough!(resolver)
+			
+			expect(transaction.response.answer.first[2]).to be_kind_of IN::MX
+		end
+		
+		it "should return NS record" do
+			transaction = RubyDNS::Transaction.new(server, query, "google.com", IN::NS, response)
+			
+			expect(transaction.response.answer.size).to be 0
+			
+			transaction.passthrough!(resolver)
+			
+			expect(transaction.response.answer.first[2]).to be_kind_of IN::NS
+		end
+		
+		it "should return PTR record" do
+			transaction = RubyDNS::Transaction.new(server, query, "8.8.8.8.in-addr.arpa", IN::PTR, response)
+			
+			expect(transaction.response.answer.size).to be 0
+			
+			transaction.passthrough!(resolver)
+			
+			expect(transaction.response.answer.first[2]).to be_kind_of IN::PTR
+		end
+		
+		it "should return SOA record" do
+			transaction = RubyDNS::Transaction.new(server, query, "google.com", IN::SOA, response)
+			
+			expect(transaction.response.answer.size).to be 0
+			
+			transaction.passthrough!(resolver)
+			
+			expect(transaction.response.answer.first[2]).to be_kind_of IN::SOA
+		end
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubydns
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.9.4
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-26 00:00:00.000000000 Z
+date: 2015-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid
@@ -155,11 +155,11 @@ files:
 - spec/rubydns/injected_supervisor_spec.rb
 - spec/rubydns/ipv6_spec.rb
 - spec/rubydns/message_spec.rb
+- spec/rubydns/origin_spec.rb
 - spec/rubydns/passthrough_spec.rb
 - spec/rubydns/resolver_performance_spec.rb
 - spec/rubydns/resolver_spec.rb
 - spec/rubydns/rules_spec.rb
-- spec/rubydns/server/benchmark.rb
 - spec/rubydns/server/bind9/generate-local.rb
 - spec/rubydns/server/bind9/local.zone
 - spec/rubydns/server/bind9/named.conf
@@ -203,11 +203,11 @@ test_files:
 - spec/rubydns/injected_supervisor_spec.rb
 - spec/rubydns/ipv6_spec.rb
 - spec/rubydns/message_spec.rb
+- spec/rubydns/origin_spec.rb
 - spec/rubydns/passthrough_spec.rb
 - spec/rubydns/resolver_performance_spec.rb
 - spec/rubydns/resolver_spec.rb
 - spec/rubydns/rules_spec.rb
-- spec/rubydns/server/benchmark.rb
 - spec/rubydns/server/bind9/generate-local.rb
 - spec/rubydns/server/bind9/local.zone
 - spec/rubydns/server/bind9/named.conf

data/spec/rubydns/server/benchmark.rb

@@ -1,29 +0,0 @@
-#!/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