rubydns 0.8.5 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 579892157e10443cf4e2959ff42da5f6d312a59b
-  data.tar.gz: eadc76b6e5c1bbc199aaecc6beae5ea6836ece29
+  metadata.gz: 1835f3164db6b9d4a9bf06f1b484be87abfee77b
+  data.tar.gz: 53f3a898b8cf9c5b4ecda1e09e061caeb48ee4c0
 SHA512:
-  metadata.gz: 2dab4ccffd9bfc4d2ee23be3cee574f1925e152999e754ded886d80b9b45c427815ae7e02bafed735a454706ea76436f91f44f604fe2162198e2ea7a34e5dfbe
-  data.tar.gz: d4d47c5ed9316a1177d42a8cc403d690031c343e10bf0ab0a5b387d02ed8bcfaa91e5bb78c620134d65a18d7bf10233bff9e4269bd4be9dac53f0434b1ef3210
+  metadata.gz: 7436649377952b0e4bcbe7e8edb0108b4f6cde35341c3f5f269baa0874e2c5c6eeeb13000ebde28b8035d40c3d6b62819bf3aa591c86b043528b2249b6bdc58f
+  data.tar.gz: db91f39c37441efb5092502e49a9ec3851f356dd0d2f89710ab6eb2464760cfa5aa73d47617b11541b69a8c0bd393377632cef534189099623a02fdd4957f441

data/.travis.yml

@@ -6,3 +6,7 @@ rvm:
   - 1.9
   - 2.0
   - 2.1
+  - rbx-2
+matrix:
+  allow_failures:
+    - rvm: rbx-2 

data/Gemfile

@@ -2,7 +2,3 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in trenni.gemspec
 gemspec
-
-group :test do
-	gem "minitest"
-end

data/README.md

@@ -81,16 +81,15 @@ This is the best way to integrate with other projects.
 
 ## Performance
 
-We welcome additional benchmarks and feedback regarding RubyDNS performance.
+We welcome additional benchmarks and feedback regarding RubyDNS performance. To check the current performance results, consult the [travis build job output](https://travis-ci.org/ioquatix/rubydns).
 
 ### 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:
+The performance is on the same magnitude as `bind9`. 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)
+	RubyDNS::Server        4.280000   0.450000   4.730000 (  4.854862)
+	Bind9                  4.970000   0.520000   5.490000 (  5.541213)
 
 These benchmarks are included in the unit tests. To test bind9 performance, it must be installed and `which named` must return the executable.
 
@@ -98,15 +97,24 @@ These benchmarks are included in the unit tests. To test bind9 performance, it m
 
 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)
+	RubyDNS::Resolver      0.020000   0.010000   0.030000 (  0.030507)
+	Resolv::DNS            0.070000   0.010000   0.080000 (  1.465975)
 
 These benchmarks are included in the unit tests.
 
 ## Compatibility
 
+### Migrating from RubyDNS 0.8.x 0.9.x
+
+RubyDNS 0.9.0 is based on a branch which replaced EventMachine with Celluloid. This reduces the complexity in writing concurrent systems hugely, but it is also a largely untested code path. RubyDNS 0.8.x using EventMachine has been tested over 4 years now by many projects.
+
+The reason for the change is simply that EventMachine is now a dead project and no longer being maintained/supported. The ramifications of this are: no IPv6 support, crashes/segfaults in certain workloads with no workable solution going forward, and lack of integration with external libraries.
+
+The difference for authors integrating RubyDNS in a daemon should be minimal. For users integrating RubyDNS into an existing system, you need to be aware of the contracts imposed by Celluloid, namely, whether it affects other parts of your system. Some areas of Celluloid are well developed, others are still needing attention (e.g. how it handles forking child processes). We expect the 0.8 branch should remain stable for a long time, but 0.9 branch will eventually become the 1.0 release.
+
+The benefits of using Celluloid include: fault tolerance, high performance, scalability across multiple hardware threads (when using Rubinius or JRuby), simpler integration with 3rd party data (e.g. `defer` has now been removed since it isn't necessary with celluloid).
+
 ### 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.

data/Rakefile

@@ -1,9 +1,9 @@
 require "bundler/gem_tasks"
-require "rake/testtask"
+require "rspec/core/rake_task"
 
-Rake::TestTask.new do |t|
-	t.libs << 'test'
-end
+RSpec::Core::RakeTask.new(:spec)
 
-desc "Run tests"
-task :default => :test
+task :default => :spec
+
+require 'celluloid'
+Celluloid.logger.level = Logger::ERROR

data/lib/rubydns/handler.rb

@@ -18,138 +18,169 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require_relative 'message'
-require_relative 'binary_string'
+require_relative 'transport'
 
 module RubyDNS
-	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
+	class GenericHandler
+		include Celluloid::IO
 		
 		def initialize(server)
 			@server = server
+			@logger = @server.logger || Celluloid.logger
 		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)..."}
+		def error_response(query = nil, code = Resolv::DNS::RCode::ServFail)
+			# Encoding may fail, so we need to handle this particular case:
+			server_failure = Resolv::DNS::Message::new(query ? query.id : 0)
+			
+			server_failure.qr = 1
+			server_failure.opcode = query ? query.opcode : 0
+			server_failure.aa = 1
+			server_failure.rd = 0
+			server_failure.ra = 0
+
+			server_failure.rcode = code
+
+			# We can't do anything at this point...
+			return server_failure
+		end
+		
+		def process_query(data, options)
+			@logger.debug "<> Receiving incoming query (#{data.bytesize} bytes) to #{self.class.name}..."
 			query = nil
 
 			begin
 				query = RubyDNS::decode_message(data)
-
-				return server.process_query(query, options, &block)
-			rescue => error
-				server.logger.error "Error processing request!"
-				server.logger.error "#{error.class}: #{error.message}"
-
-				error.backtrace.each { |at| server.logger.error at }
-
-				# Encoding may fail, so we need to handle this particular case:
-				server_failure = Resolv::DNS::Message::new(query ? query.id : 0)
-				server_failure.qr = 1
-				server_failure.opcode = query ? query.opcode : 0
-				server_failure.aa = 1
-				server_failure.rd = 0
-				server_failure.ra = 0
-
-				server_failure.rcode = Resolv::DNS::RCode::ServFail
-
-				# We can't do anything at this point...
-				yield server_failure
+				
+				return @server.process_query(query, options)
+			rescue Celluloid::ResumableError
+				# Celluloid terminates tasks, we may be stuck in a task when the server is terminated. We don't want to reply to the client in this case, because the server is being terminated. It might be an option to return a server failure
+				raise
+			rescue StandardError => error
+				@logger.error "<> Error processing request: #{error.inspect}!"
+				RubyDNS::log_exception(@logger, error)
+				
+				return error_response(query)
 			end
 		end
+	end
+	
+	# Handling incoming UDP requests, which are single data packets, and pass them on to the given server.
+	class UDPSocketHandler < GenericHandler
+		include Celluloid::IO
+		
+		def initialize(server, socket)
+			super(server)
+			
+			@socket = socket
+			
+			async.run
+		end
 		
-		def peername
-			Socket.unpack_sockaddr_in(self.get_peername)
+		def run
+			loop { handle_connection }
 		end
 		
-		def receive_data(data)
-			options = {:connection => self}
+		def respond(input_data, remote_host, remote_port)
+			options = {peer: remote_host}
 			
-			UDPHandler.process(@server, data, options) do |answer|
-				data = answer.encode
-				
-				@server.logger.debug {"Writing response to client (#{data.bytesize} bytes) via UDP..."}
+			response = process_query(input_data, options)
+			
+			output_data = response.encode
+			
+			@logger.debug "<#{response.id}> Writing #{output_data.bytesize} bytes response to client via UDP..."
+			
+			if output_data.bytesize > UDP_TRUNCATION_SIZE
+				@logger.warn "<#{response.id}>Response via UDP was larger than #{UDP_TRUNCATION_SIZE}!"
 				
-				if data.bytesize > 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)
-					truncation_error.tc = 1
-					
-					data = truncation_error.encode
-				end
+				# Reencode data with truncation flag marked as true:
+				truncation_error = Resolv::DNS::Message.new(response.id)
+				truncation_error.tc = 1
 				
-				# 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_data(data)
+				output_data = truncation_error.encode
 			end
+			
+			@socket.send(output_data, 0, remote_host, remote_port)
+		rescue IOError => error
+			@logger.warn "<> UDP response failed: #{error.inspect}!"
+		rescue EOFError => error
+			@logger.warn "<> UDP session ended prematurely: #{error.inspect}!"
+		rescue DecodeError
+			@logger.warn "<> Could not decode incoming UDP data!"
+		end
+		
+		def handle_connection
+			# @logger.debug "Waiting for incoming UDP packet #{@socket.inspect}..."
+			
+			input_data, (_, remote_port, remote_host) = @socket.recvfrom(UDP_TRUNCATION_SIZE)
+			
+			async.respond(input_data, remote_host, remote_port)
+		rescue IOError => error
+			@logger.warn "<> UDP connection failed: #{error.inspect}!"
+		rescue EOFError => error
+			@logger.warn "<> UDP session ended prematurely!"
 		end
 	end
 	
-	module TCPHandler
-		include Peername
+	class UDPHandler < UDPSocketHandler
+		def initialize(server, host, port)
+			socket = UDPSocket.new
+			socket.bind(host, port)
+			
+			super(server, socket)
+		end
 		
-		def initialize(server)
-			@server = server
+		finalizer :finalize
+		
+		def finalize
+			@socket.close if @socket
+		end
+	end
+	
+	class TCPSocketHandler < GenericHandler
+		def initialize(server, socket)
+			super(server)
 			
-			@buffer = BinaryStringIO.new
+			@socket = socket
 			
-			@length = nil
-			@processed = 0
+			async.run
 		end
 		
-		# Receive the data via a TCP connection, process messages when we receive the indicated amount of data.
-		def receive_data(data)
-			# We buffer data until we've received the entire packet:
-			@buffer.write(data)
-			
-			# Message includes a 16-bit length field.. we need to see if we have received it yet:
-			if @length == nil
-				# Not enough data received yet...
-				if (@buffer.size - @processed) < 2
-					return
-				end
-				
-				# Grab the length field:
-				@length = @buffer.string.byteslice(@processed, 2).unpack('n')[0]
-				@processed += 2
-			end
-			
-			if (@buffer.size - @processed) >= @length
-				data = @buffer.string.byteslice(@processed, @length)
-				
-				options = {:connection => self}
-				
-				UDPHandler.process(@server, data, options) do |answer|
-					data = answer.encode
-					
-					@server.logger.debug "Writing response to client (#{data.bytesize} bytes) via TCP..."
-					
-					self.send_data([data.bytesize].pack('n'))
-					self.send_data(data)
-				end
-				
-				@processed += @length
-				@length = nil
-			end
+		def run
+			loop { async.handle_connection @socket.accept }
 		end
 		
-		# Check that all data received was processed.
-		def unbind
-			if @processed != @buffer.size
-				@server.logger.debug "Unprocessed data remaining (#{@buffer.size - @processed} bytes unprocessed) on incoming TCP connection."
-			end
+		def handle_connection(socket)
+			_, remote_port, remote_host = socket.peeraddr
+			options = {peer: remote_host}
+			
+			input_data = StreamTransport.read_chunk(socket)
+			
+			response = process_query(input_data, options)
+			
+			length = StreamTransport.write_message(socket, response)
+			
+			@logger.debug "<#{response.id}> Wrote #{length} bytes via TCP..."
+		rescue EOFError => error
+			@logger.warn "<> TCP session ended prematurely!"
+		rescue DecodeError
+			@logger.warn "<> Could not decode incoming TCP data!"
+		ensure
+			socket.close
 		end
 	end
 	
-end
+	class TCPHandler < TCPSocketHandler
+		def initialize(server, host, port)
+			socket = TCPServer.new(host, port)
+			
+			super(server, socket)
+		end
+		
+		finalizer :finalize
+		
+		def finalize
+			@socket.close if @socket
+		end
+	end
+end

data/lib/rubydns/message.rb

@@ -18,7 +18,6 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'eventmachine'
 require 'stringio'
 require 'resolv'