rubydns 0.8.5 → 0.9.0

data/lib/rubydns/transaction.rb

@@ -18,32 +18,23 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'eventmachine'
-
 module RubyDNS
 	
-	class PassthroughError < StandardError
-	end
-	
-	# This class provides all details of a single DNS question and answer. This is used by the DSL to provide DNS related functionality.
+	# This class provides all details of a single DNS question and response. This is used by the DSL to provide DNS related functionality.
 	# 
 	# The main functions to complete the trasaction are: {#append!} (evaluate a new query and append the results), {#passthrough!} (pass the query to an upstream server), {#respond!} (compute a specific response) and {#fail!} (fail with an error code).
 	class Transaction
 		# The default time used for responses (24 hours).
 		DEFAULT_TTL = 86400
 		
-		def initialize(server, query, question, resource_class, answer, options = {})
+		def initialize(server, query, question, resource_class, response, options = {})
 			@server = server
 			@query = query
 			@question = question
 			@resource_class = resource_class
-			@answer = answer
+			@response = response
 
 			@options = options
-
-			@question_appended = false
-
-			@fiber = nil
 		end
 
 		# The resource_class that was requested. This is typically used to generate a response.
@@ -55,8 +46,8 @@ module RubyDNS
 		# The question that this transaction represents.
 		attr :question
 		
-		# The current full answer to the incoming query.
-		attr :answer
+		# The current full response to the incoming query.
+		attr :response
 		
 		# Any options or configuration associated with the given transaction.
 		attr :options
@@ -75,9 +66,9 @@ module RubyDNS
 			"#{name} #{@resource_class.name}"
 		end
 		
-		# Run a new query through the rules with the given name and resource type. The results of this query are appended to the current transaction's `answer`.
+		# Run a new query through the rules with the given name and resource type. The results of this query are appended to the current transaction's `response`.
 		def append!(name, resource_class = nil, options = {})
-			Transaction.new(@server, @query, name, resource_class || @resource_class, @answer, options).process
+			Transaction.new(@server, @query, name, resource_class || @resource_class, @response, options).process
 		end
 		
 		# Use the given resolver to respond to the question. Uses `passthrough` to do the lookup and merges the result.
@@ -86,22 +77,21 @@ module RubyDNS
 		#
 		# If recursion is not requested, the result is `fail!(:Refused)`. This check is ignored if an explicit `options[:name]` or `options[:force]` is given.
 		#
-		# If the resolver does not respond, the result is `fail!(:NXDomain)`.
+		# If the resolver can't reach upstream servers, `fail!(:ServFail)` is invoked.
 		def passthrough!(resolver, options = {}, &block)
 			if @query.rd || options[:force] || options[:name]
-				passthrough(resolver, options) do |response|
-					if block_given?
-						yield response
-					end
-					
+				response = passthrough(resolver, options)
+				
+				if response
 					# Recursion is available and is being used:
 					# See issue #26 for more details.
-					@answer.ra = 1
-					
-					@answer.merge!(response)
+					@response.ra = 1
+					@response.merge!(response)
+				else
+					fail!(:ServFail)
 				end
 			else
-				raise PassthroughError.new("Request is not recursive!")
+				fail!(:Refused)
 			end
 		end
 		
@@ -110,25 +100,11 @@ module RubyDNS
 		# A block must be supplied, and provided a valid response is received from the upstream server, this function yields with the reply and reply_name.
 		#
 		# If `options[:name]` is provided, this overrides the default query name sent to the upstream server. The same logic applies to `options[:resource_class]`.
-		def passthrough(resolver, options = {}, &block)
+		def passthrough(resolver, options = {})
 			query_name = options[:name] || name
 			query_resource_class = options[:resource_class] || resource_class
 			
-			response = @server.defer do |handle|
-				resolver.query(query_name, query_resource_class) do |response|
-					# Not sure if this is potentially a race condition? Could fiber.resume occur before Fiber.yield?
-					handle.resume(response)
-				end
-			end
-			
-			case response
-			when RubyDNS::Message
-				yield response
-			when RubyDNS::ResolutionFailure
-				fail!(:ServFail)
-			else
-				throw PassthroughError.new("Bad response from query: #{response.inspect}")
-			end
+			resolver.query(query_name, query_resource_class)
 		end
 		
 		# Respond to the given query with a resource record. The arguments to this function depend on the `resource_class` requested. This function instantiates the resource class with the supplied arguments, and then passes it to {#append!}.
@@ -173,7 +149,7 @@ module RubyDNS
 			resources.each do |resource|
 				@server.logger.debug "#{method}: #{resource.inspect} #{resource.class::TypeValue} #{resource.class::ClassValue}"
 				
-				@answer.send(method, name, ttl, resource)
+				@response.send(method, name, ttl, resource)
 			end
 		end
 		
@@ -196,9 +172,9 @@ module RubyDNS
 			append_question!
 			
 			if rcode.kind_of? Symbol
-				@answer.rcode = Resolv::DNS::RCode.const_get(rcode)
+				@response.rcode = Resolv::DNS::RCode.const_get(rcode)
 			else
-				@answer.rcode = rcode.to_i
+				@response.rcode = rcode.to_i
 			end
 		end
 		
@@ -216,10 +192,10 @@ module RubyDNS
 		
 		protected
 		
-		# A typical response to a DNS request includes both the question and answer. This helper appends the question unless it looks like the user is already managing that aspect of the response.
+		# A typical response to a DNS request includes both the question and response. This helper appends the question unless it looks like the user is already managing that aspect of the response.
 		def append_question!
-			if @answer.question.size == 0
-				@answer.add_question(@question, @resource_class) unless @question_appended
+			if @response.question.size == 0
+				@response.add_question(@question, @resource_class)
 			end
 		end
 	end

data/lib/rubydns/{binary_string.rb → transport.rb}

@@ -20,6 +20,8 @@
 
 require 'stringio'
 
+require_relative 'message'
+
 module RubyDNS
 	# A helper class for processing incoming network data.
 	class BinaryStringIO < StringIO
@@ -29,4 +31,40 @@ module RubyDNS
 			set_encoding("BINARY")
 		end
 	end
+	
+	module StreamTransport
+		def self.read_chunk(socket)
+			# The data buffer:
+			buffer = BinaryStringIO.new
+			
+			# First we need to read in the length of the packet
+			while buffer.size < 2
+				buffer.write socket.readpartial(1)
+			end
+			
+			# Read in the length, the first two bytes:
+			length = buffer.string.byteslice(0, 2).unpack('n')[0]
+			
+			# Read data until we have the amount specified:
+			while (buffer.size - 2) < length
+				required = (2 + length) - buffer.size
+				
+				# Read precisely the required amount:
+				buffer.write socket.readpartial(required)
+			end
+			
+			return buffer.string.byteslice(2, length)
+		end
+		
+		def self.write_message(socket, message)
+			write_chunk(socket, message.encode)
+		end
+		
+		def self.write_chunk(socket, output_data)
+			socket.write([output_data.bytesize].pack('n'))
+			socket.write(output_data)
+			
+			return output_data.bytesize
+		end
+	end
 end

data/lib/rubydns/version.rb

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

data/lib/rubydns.rb

@@ -24,20 +24,27 @@ require_relative 'rubydns/message'
 require_relative 'rubydns/server'
 require_relative 'rubydns/resolver'
 require_relative 'rubydns/handler'
+require_relative 'rubydns/logger'
 
 module RubyDNS
 	# Run a server with the given rules.
 	def self.run_server (options = {}, &block)
-		server = RubyDNS::RuleBasedServer.new(&block)
+		supervisor = RubyDNS::RuleBasedServer.supervise(options, &block)
 		
-		EventMachine.run do
-			trap("INT") do
-				EventMachine::stop
-			end
+		supervisor.actors.first.run
+		
+		if options[:asynchronous]
+			return supervisor
+		else
+			read, write = IO.pipe
+
+			trap(:INT) {
+				write.puts
+			}
+
+			IO.select([read])
 			
-			server.run(options)
+			supervisor.terminate
 		end
-		
-		server.fire(:stop)
 	end
 end

data/rubydns.gemspec

@@ -30,9 +30,12 @@ Gem::Specification.new do |spec|
 	
 	spec.required_ruby_version = '>= 1.9.3'
 
-	spec.add_dependency("eventmachine", "~> 1.0.0")
+	spec.add_dependency("celluloid", "~> 0.16.0")
+	spec.add_dependency("celluloid-io", "~> 0.16.1")
+	spec.add_dependency("timers", "~> 4.0.1")
 	
 	spec.add_development_dependency "bundler", "~> 1.3"
-	spec.add_development_dependency "process-daemon", "~> 0.5.3"
+	spec.add_development_dependency "process-daemon", "~> 0.5.5"
+	spec.add_development_dependency "rspec", "~> 3.0.0"
 	spec.add_development_dependency "rake"
 end

data/{test/test_daemon.rb → spec/rubydns/daemon_spec.rb}

@@ -20,10 +20,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'minitest/autorun'
-
 require 'rubydns'
-
 require 'process/daemon'
 
 class BasicTestServer < Process::Daemon
@@ -36,6 +33,8 @@ class BasicTestServer < Process::Daemon
 	end
 
 	def startup
+		Celluloid.boot
+		
 		# Start the RubyDNS server
 		RubyDNS::run_server(:listen => SERVER_PORTS) do
 			match("test.local", IN::A) do |transaction|
@@ -47,7 +46,7 @@ class BasicTestServer < Process::Daemon
 			end
 
 			match(/peername/, IN::A) do |transaction|
-				transaction.respond!(transaction[:connection].peername[1])
+				transaction.respond!(transaction[:peer])
 			end
 
 			# Default DNS handler
@@ -58,64 +57,53 @@ class BasicTestServer < Process::Daemon
 	end
 end
 
-class DaemonTest < MiniTest::Test
-	def setup
-		BasicTestServer.controller output: File.open("/dev/null", "w")
+describe "RubyDNS Daemonized Server" do
+	before(:all) do
+		Celluloid.shutdown
 		
+		# Trying to fork with Celluloid running is a recipe for disaster.
+		# BasicTestServer.controller output: $stderr
 		BasicTestServer.start
+		
+		Celluloid.boot
 	end
 	
-	def teardown
+	after(:all) do
 		BasicTestServer.stop
 	end
 	
-	def test_basic_dns
-		assert_equal :running, BasicTestServer.status
+	it "should resolve local domain correctly" do
+		expect(BasicTestServer.status).to be == :running
 		
-		EventMachine.run do
-			resolver = RubyDNS::Resolver.new(BasicTestServer::SERVER_PORTS)
+		resolver = RubyDNS::Resolver.new(BasicTestServer::SERVER_PORTS)
+	
+		response = resolver.query("test.local")
+		answer = response.answer.first
 		
-			resolver.query("test.local") do |response|
-				answer = response.answer.first
-				
-				assert_equal "test.local", answer[0].to_s
-				assert_equal "192.168.1.1", answer[2].address.to_s
-				
-				EventMachine.stop
-			end
-		end
+		expect(answer[0].to_s).to be == "test.local"
+		expect(answer[2].address.to_s).to be == "192.168.1.1"
 	end
 	
-	def test_pattern_matching
-		assert_equal :running, BasicTestServer.status
-
-		EventMachine.run do
-			resolver = RubyDNS::Resolver.new(BasicTestServer::SERVER_PORTS)
+	it "should pattern match correctly" do
+		expect(BasicTestServer.status).to be == :running
+		
+		resolver = RubyDNS::Resolver.new(BasicTestServer::SERVER_PORTS)
 
-			resolver.query("foobar") do |response|
-				answer = response.answer.first
-				
-				assert_equal "foobar", answer[0].to_s
-				assert_equal "192.168.1.2", answer[2].address.to_s
-				
-				EventMachine.stop
-			end
-		end
+		response = resolver.query("foobar")
+		answer = response.answer.first
+		
+		expect(answer[0].to_s).to be == "foobar"
+		expect(answer[2].address.to_s).to be == "192.168.1.2"
 	end
 	
-	def test_peername
-		assert_equal :running, BasicTestServer.status
-
-		EventMachine.run do
-			resolver = RubyDNS::Resolver.new(BasicTestServer::SERVER_PORTS)
+	it "should give peer ip address" do
+		expect(BasicTestServer.status).to be == :running
+		
+		resolver = RubyDNS::Resolver.new(BasicTestServer::SERVER_PORTS)
 
-			resolver.query("peername") do |response|
-				answer = response.answer.first
-				
-				assert_equal "127.0.0.1", answer[2].address.to_s
-				
-				EventMachine.stop
-			end
-		end
+		response = resolver.query("peername")
+		answer = response.answer.first
+		
+		expect(answer[2].address.to_s).to be == "127.0.0.1"
 	end
 end

data/{test/test_rules.rb → spec/rubydns/message_spec.rb}

@@ -20,55 +20,37 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'minitest/autorun'
-
 require 'rubydns'
+require 'base64'
 
-class RulesTest < MiniTest::Test
-	IN = Resolv::DNS::Resource::IN
+module RubyDNS::MessageSpec
+	describe RubyDNS::Message do
+		it "should be decoded correctly" do
+			data = Base64.decode64(<<-EOF)
+			HQCBgAABAAgAAAABA3d3dwV5YWhvbwNjb20AAAEAAcAMAAUAAQAAASwADwZm
+			ZC1mcDMDd2cxAWLAEMArAAUAAQAAASwACQZkcy1mcDPAMsBGAAUAAQAAADwA
+			FQ5kcy1hbnktZnAzLWxmYgN3YTHANsBbAAUAAQAAASwAEg9kcy1hbnktZnAz
+			LXJlYWzAasB8AAEAAQAAADwABGKK/B7AfAABAAEAAAA8AARii7SVwHwAAQAB
+			AAAAPAAEYou3GMB8AAEAAQAAADwABGKK/W0AACkQAAAAAAAAAA==
+			EOF
 	
-	def setup
-		@logger = Logger.new($stderr)
-		@logger.level = Logger::INFO
-		
-		@server = RubyDNS::Server.new(logger: @logger)
-		@true_callback = Proc.new { true }
-	end
+			message = RubyDNS::decode_message(data)
+			expect(message.class).to be == RubyDNS::Message
+			expect(message.id).to be == 0x1d00
 	
-	def teardown
-	end
-	
-	def test_string_pattern
-		rule = RubyDNS::RuleBasedServer::Rule.new(["foobar", IN::A], @true_callback)
-		
-		assert rule.call(@server, "foobar", IN::A)
-		assert !rule.call(@server, "barfoo", IN::A)
-		assert !rule.call(@server, "foobar", IN::TXT)
-	end
-	
-	def test_regexp_pattern
-		rule = RubyDNS::RuleBasedServer::Rule.new([/foo/, IN::A], @true_callback)
-		
-		assert rule.call(@server, "foobar", IN::A)
-		assert !rule.call(@server, "barbaz", IN::A)
-		assert !rule.call(@server, "foobar", IN::TXT)
-	end
+			expect(message.question.count).to be == 1
+			expect(message.answer.count).to be == 8
+			expect(message.authority.count).to be == 0
+			expect(message.additional.count).to be == 1
+		end
+
+		it "should fail to decode due to bad AAAA length" do
+			data = Base64.decode64(<<-EOF)
+			6p6BgAABAAEAAAABCGJhaWNhaWNuA2NvbQAAHAABwAwAHAABAAABHgAEMhd7
+			dwAAKRAAAAAAAAAA
+			EOF
 	
-	def test_callback_pattern
-		calls = 0
-		
-		callback = Proc.new do |name, resource_class|
-			# A counter used to check the number of times this block was invoked.
-			calls += 1
-			
-			name.size == 6
+			expect{RubyDNS::decode_message(data)}.to raise_error(RubyDNS::DecodeError)
 		end
-		
-		rule = RubyDNS::RuleBasedServer::Rule.new([callback], @true_callback)
-		
-		assert rule.call(@server, "foobar", IN::A)
-		assert !rule.call(@server, "foobarbaz", IN::A)
-		
-		assert_equal 2, calls
 	end
 end

data/spec/rubydns/passthrough_spec.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+
+# Copyright, 2012, 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::PassthroughSpec
+	SERVER_PORTS = [[:udp, '127.0.0.1', 5340], [:tcp, '127.0.0.1', 5340]]
+	Name = Resolv::DNS::Name
+	IN = Resolv::DNS::Resource::IN
+	
+	describe "RubyDNS Passthrough Server" do
+		before(:all) do
+			Celluloid.shutdown
+			Celluloid.boot
+		
+			# Start the RubyDNS server
+			@server = RubyDNS::run_server(:listen => SERVER_PORTS, asynchronous: true) do
+				resolver = RubyDNS::Resolver.new([[:udp, "8.8.8.8", 53], [:tcp, "8.8.8.8", 53]])
+			
+				match(/.*\.com/, IN::A) do |transaction|
+					transaction.passthrough!(resolver)
+				end
+
+				match(/a-(.*\.org)/) do |transaction, match_data|
+					transaction.passthrough!(resolver, :name => match_data[1])
+				end
+
+				# Default DNS handler
+				otherwise do |transaction|
+					transaction.fail!(:NXDomain)
+				end
+			end
+		end
+	
+		it "should resolve domain correctly" do
+			resolver = RubyDNS::Resolver.new(SERVER_PORTS)
+		
+			response = resolver.query("google.com")
+			expect(response.ra).to be == 1
+		
+			answer = response.answer.first
+			expect(answer).not_to be == nil
+			expect(answer.count).to be > 0
+		
+			addresses = answer.select {|record| record.kind_of? Resolv::DNS::Resource::IN::A}
+			expect(addresses.size).to be > 0
+		end
+	
+		it "should resolve prefixed domain correctly" do
+			resolver = RubyDNS::Resolver.new(SERVER_PORTS)
+		
+			response = resolver.query("a-slashdot.org")
+			answer = response.answer.first
+		
+			expect(answer).not_to be == nil
+			expect(answer.count).to be > 0
+		end
+	end
+end

data/spec/rubydns/resolver_performance_spec.rb

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+
+# Copyright, 2012, 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::ResolverPerformanceSpec
+	describe RubyDNS::Resolver do
+		context 'benchmark' do
+			domains = %W{
+				Facebook.com
+				Twitter.com
+				Google.com
+				Youtube.com
+				Wordpress.org
+				Adobe.com
+				Blogspot.com
+				Wikipedia.org
+				Linkedin.com
+				Wordpress.com
+				Yahoo.com
+				Amazon.com
+				Flickr.com
+				Pinterest.com
+				Tumblr.com
+				W3.org
+				Apple.com
+				Myspace.com
+				Vimeo.com
+				Microsoft.com
+				Youtu.be
+				Qq.com
+				Digg.com
+				Baidu.com
+				Stumbleupon.com
+				Addthis.com
+				Statcounter.com
+				Feedburner.com
+				TradeMe.co.nz
+				Delicious.com
+				Nytimes.com
+				Reddit.com
+				Weebly.com
+				Bbc.co.uk
+				Blogger.com
+				Msn.com
+				Macromedia.com
+				Goo.gl
+				Instagram.com
+				Gov.uk
+				Icio.us
+				Yandex.ru
+				Cnn.com
+				Webs.com
+				Google.de
+				T.co
+				Livejournal.com
+				Imdb.com
+				Mail.ru
+				Jimdo.com
+			}
+		
+			before do
+				require 'benchmark'
+			end
+		
+			it 'should be faster than native resolver' do
+				Celluloid.logger.level = Logger::ERROR
+			
+				Benchmark.bm(20) do |x|
+					a = x.report("RubyDNS::Resolver") do
+						resolver = RubyDNS::Resolver.new([[:udp, "8.8.8.8", 53], [:tcp, "8.8.8.8", 53]])
+					
+						futures = domains.collect{|domain| resolver.future.addresses_for(domain)}
+					
+						futures.collect{|future| future.value}
+					end
+			
+					b = x.report("Resolv::DNS") do
+						resolver = Resolv::DNS.new(:nameserver => "8.8.8.8")
+				
+						resolved = domains.collect do |domain|
+							[domain, resolver.getaddresses(domain)]
+						end
+					end
+				
+					expect(a.real).to be < b.real
+				end
+			end
+		end
+	end
+end