rubydns 0.6.0 → 2.0.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NWFmMGQwYzlmMGFkMjczY2VlNzExMjdmMDI3NDZiNTFjMTc2Nzk4NQ==
-  data.tar.gz: !binary |-
-    MjljNzMxODYwNmZlNTdmNzBjMjFkNjRmYjYxZDIxZWRlZmIzYTQ0OA==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    MWZiMTBlY2YxYjdiYzIzMDU0OTBhMzBkN2RiZjY4OWZlNGFjNzM2ZGUxZTUx
-    NDE0MzdiMjFiZTg5OTM2NmVhNjcwMmY0NjE1MzNlN2JmZWM4MTIxMjQwYjk2
-    MjVjOTViMDNkYzQ0NTBlZTdlODIzM2IyZDg3NjEwZjNhMDBlNTM=
-  data.tar.gz: !binary |-
-    NzJiNGE4YjhjY2Q4MjQ3MWU0ODgwOTk4NWJlM2YwYmQ4OWZlNDdkYTIxOTU2
-    Y2FjN2UwZjZhNGYzMzc5NDY2NDYyNDFmMmVkMDZkYjg4Zjk2MWQyZjA3YzEw
-    NTRlYzZjM2JkYTFjNzUyZDYyNGMwODUxZDdiNjc5NTllZjhmODM=
+SHA1:
+  metadata.gz: bac5139eae169f981088495e6dc4bde5d13fa966
+  data.tar.gz: 0ee8216c43d6600fb811ee83d708ac984d2807df
+SHA512:
+  metadata.gz: caa862959c454afebceddbf387e5722ff6a013a6c1c6012f5cb5acf1ec4d6c9422ea1c641fb3b776ecd270ec9278640e6b7088b64cbcea9ce8e8783c579f45a1
+  data.tar.gz: 136467f2543e9eb1ae01b158cca987ec1757d01bd2aa10c695249a204a68a8e88137b39cc907f4bf9cc544c9046a94848542fddde3578f6bf553459e1c81c9bf

data/.gitignore

@@ -1,17 +1,26 @@
 *.gem
 *.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
 tmp
+
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+/.bundle/
+/lib/bundler/man/
+
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+/examples/log
+/examples/run
+/spec/rubydns/server/bind9/log/

data/.rspec

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

data/.simplecov

@@ -0,0 +1,15 @@
+
+SimpleCov.start do
+	add_filter "/spec/"
+end
+
+# Work correctly across forks:
+pid = Process.pid
+SimpleCov.at_exit do
+	SimpleCov.result.format! if Process.pid == pid
+end
+
+if ENV['TRAVIS']
+	require 'coveralls'
+	Coveralls.wear!
+end

data/.travis.yml

@@ -1,7 +1,11 @@
 language: ruby
+sudo: false
 rvm:
-  - "1.8.7"
-  - "1.9.2"
-  - "1.9.3"
-  - rbx-18mode
-  - rbx-19mode
+  - 2.2.6
+  - 2.3.0
+  - 2.4.0
+  - ruby-head
+addons:
+  apt:
+    packages:
+    - bind9

data/.yardopts

@@ -0,0 +1 @@
+--markup=markdown

data/Gemfile

@@ -1,8 +1,12 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in trenni.gemspec
 gemspec
 
+group :development do
+	gem "process-daemon"
+end
+
 group :test do
-	gem "rake"
+	gem 'simplecov'
+	gem 'coveralls', require: false
 end

data/README.md

@@ -1,144 +1,125 @@
 # RubyDNS
 
-RubyDNS is a high-performance DNS server which can be easily integrated into other projects or used as a stand-alone daemon (via RExec). By default it uses rule-based pattern matching. Results can be hard-coded, computed, fetched from a remote DNS server or fetched from a local cache, depending on requirements.
+[![Gitter](https://badges.gitter.im/Join+Chat.svg)](https://gitter.im/ioquatix/rubydns?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
-In addition, RubyDNS includes a high-performance asynchronous DNS resolver built on top of EventMachine. This module can be used by itself in client applications without using the full RubyDNS server stack.
+RubyDNS is a high-performance DNS server which can be easily integrated into other projects or used as a stand-alone daemon. By default it uses rule-based pattern matching. Results can be hard-coded, computed, fetched from a remote DNS server or fetched from a local cache, depending on requirements.
 
-For examples and documentation please see the main [project page][1].
+[![Build Status](https://travis-ci.org/ioquatix/rubydns.svg)](https://travis-ci.org/ioquatix/rubydns)
+[![Code Climate](https://codeclimate.com/github/ioquatix/rubydns.svg)](https://codeclimate.com/github/ioquatix/rubydns)
+[![Coverage Status](https://coveralls.io/repos/ioquatix/rubydns/badge.svg)](https://coveralls.io/r/ioquatix/rubydns)
 
-[1]: http://www.oriontransfer.co.nz/gems/rubydns
-
-[![Build Status](https://secure.travis-ci.org/ioquatix/rubydns.png)](http://travis-ci.org/ioquatix/rubydns)
+[![RubyDNS Introduction](http://img.youtube.com/vi/B9ygq0xh3HQ/maxresdefault.jpg)](https://www.youtube.com/watch?v=B9ygq0xh3HQ&feature=youtu.be&hd=1 "RubyDNS Introduction")
 
 ## Installation
 
 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
 
-This is copied from `test/examples/test-dns-2.rb`. It has been simplified slightly.
+There are [lots of examples available](examples/README.md) in the `examples/` directory.
+
+### Basic DNS Server
+
+Here is the code from `examples/basic-dns.rb`:
+
 ```ruby
 #!/usr/bin/env ruby
 require 'rubydns'
 
 INTERFACES = [
-	[:udp, "0.0.0.0", 53],
-	[:tcp, "0.0.0.0", 53]
+	[:udp, "0.0.0.0", 5300],
+	[:tcp, "0.0.0.0", 5300],
 ]
-Name = Resolv::DNS::Name
+
 IN = Resolv::DNS::Resource::IN
 
 # Use upstream DNS for name resolution.
 UPSTREAM = RubyDNS::Resolver.new([[:udp, "8.8.8.8", 53], [:tcp, "8.8.8.8", 53]])
 
-def self.run
-    # Start the RubyDNS server
-    RubyDNS::run_server(:listen => INTERFACES) do
-        match(/test.mydomain.org/, IN::A) do |transaction|
-            transaction.respond!("10.0.0.80")
-        end
-
-        # Default DNS handler
-        otherwise do |transaction|
-            transaction.passthrough!(UPSTREAM)
-        end
-    end
+# Start the RubyDNS server
+RubyDNS::run_server(INTERFACES) do
+	match(%r{test.local}, IN::A) do |transaction|
+		transaction.respond!("10.0.0.80")
+	end
+
+	# Default DNS handler
+	otherwise do |transaction|
+		transaction.passthrough!(UPSTREAM)
+	end
 end
-run
-```
-Start the server using `rvmsudo ./test.rb`. You can then test it using dig:
-```
-$ dig @localhost test1.mydomain.org
-$ dig @localhost dev.mydomain.org
-$ dig @localhost google.com
 ```
 
-## Compatibility
+Start the server using `RUBYOPT=-w ./examples/basic-dns.rb`. You can then test it using dig:
 
-### Migrating from RubyDNS 0.5.x to 0.6.x ###
+	$ dig @localhost -p 5300 test.local
+	$ dig @localhost -p 5300 google.com
 
-The order of arguments to pattern based rules has changed. For regular expression based rules, the arguments are now ordered `|transaction, match_data|`. The main reason for this change was that in many cases match_data is not important and can thus be ignored, e.g. `|transaction|`.
+### File Handle Limitations
 
-### Migrating from RubyDNS 0.3.x to 0.4.x ###
+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.
 
-Due to changes in `resolv.rb`, superficial parts of RubyDNS have changed. Rather than using `:A` to specify A-records, one must now use the class name.
-```ruby
-match(..., :A)
-```
-becomes
-```ruby
-IN = Resolv::DNS::Resource::IN
-match(..., IN::A)
-```
-### Migrating from RubyDNS 0.4.x to 0.5.x ###
+### Custom Servers
 
-The system standard resolver was synchronous, and this could stall the server when making upstream requests to other DNS servers. A new resolver `RubyDNS::Resolver` now provides an asynchronous interface and the `Transaction::passthrough` makes exclusive use of this to provide high performance asynchonous resolution.
+It is possible to create and integrate your own custom servers, however this functionality has now moved to [`Async::DNS::Server`](https://github.com/socketry/async-dns).
 
-Here is a basic example of how to use the new resolver in full. It is important to provide both `:udp` and `:tcp` connection specifications, so that large requests will be handled correctly:
 ```ruby
-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|
-		case response
-		when RubyDNS::Message
-			puts "Got response: #{response.answers.first}"
-		else
-			# Response is of class RubyDNS::ResolutionFailure
-			puts "Failed: #{response.message}"
-		end
-
-		EventMachine::stop
+class MyServer < Async::DNS::Server
+	def process(name, resource_class, transaction)
+		transaction.fail!(:NXDomain)
 	end
 end
-```
-Existing code that uses `Resolv::DNS` as a resolver will need to be updated:
-```ruby
-# 1/ Add this at the top of your file; Host specific system information:
-require 'rubydns/system'
+
+Async::Reactor.run do
+	task = MyServer.run
+	
+	# ... do other things
 	
-# 2/ Change from R = Resolv::DNS.new to:
-R = RubyDNS::Resolver.new(RubyDNS::System::nameservers)
+	# Shut down the server:
+	task.stop
+end
 ```
-Everything else in the server can remain the same. You can see a complete example in `test/test_resolver.rb`.
 
-#### Deferred Transactions ####
+This is the best way to integrate with other projects.
 
-The implementation of the above depends on a new feature which was added in 0.5.0:
+## Performance
 
-```ruby
-transaction.defer!
-```
+**Due to changes in the underlying code, there have been some very minor performance regressions. The numbers below will be updated in due course.**
 
-Once you call this, the transaction won't complete until you call either `transaction.succeed` or `transaction.fail`.
-```ruby
-RubyDNS::run_server(:listen => SERVER_PORTS) do
-	match(/\.*.com/, IN::A) do |transaction|
-		transaction.defer!
-		
-		# No domain exists, after 5 seconds:
-		EventMachine::Timer.new(5) do
-			transaction.failure!(:NXDomain)
-		end
-	end
+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).
 
-	otherwise do
-		transaction.failure!(:NXDomain)
-	end
-end
-```
+### Server
+
+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:
+
+	                           user     system      total        real
+	RubyDNS::Server        4.280000   0.450000   4.730000 (  4.854862)
+	Bind9                  4.970000   0.520000   5.490000 (  5.541213)
 
-You can see a complete example in `test/test_slow_server.rb`.
+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:
+
+	                           user     system      total        real
+	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.
+
+### DNSSEC support
+
+DNSSEC is currently not supported and is [unlikely to be supported in the future](http://sockpuppet.org/blog/2015/01/15/against-dnssec/).
 
 ## Contributing
 
@@ -152,12 +133,21 @@ You can see a complete example in `test/test_slow_server.rb`.
 
 * Support for more features of DNS such as zone transfer.
 * Support reverse records more easily.
+* Some kind of system level integration, e.g. registering a DNS server with the currently running system resolver.
+
+## See Also
+
+The majority of this gem is now implemented by `async-dns`.
+
+- [async-io](https://github.com/socketry/async-io) — Asynchronous networking and sockets.
+- [async-dns](https://github.com/socketry/async-dns) — Asynchronous DNS resolver and server.
+- [async-rspec](https://github.com/socketry/async-rspec) — Shared contexts for running async specs.
 
 ## License
 
 Released under the MIT license.
 
-Copyright, 2009, 2012, by [Samuel G. D. Williams](http://www.codeotaku.com/samuel-williams).
+Copyright, 2017, by [Samuel G. D. Williams](http://www.codeotaku.com/samuel-williams).
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/Rakefile

@@ -1,9 +1,6 @@
 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(:test)
 
-desc "Run tests"
 task :default => :test