smart_proxy_dns_powerdns 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c0bc4acefdd0c176ea6f1d9fcbb4037f36da5606
-  data.tar.gz: 4386be7b8b5d77463f91fd005a35735893fa64f4
+  metadata.gz: 5915405ebcc666b7bea1a17d2422b0209e25c140
+  data.tar.gz: 51643c7ca288e9af25a0f3df8fd209b631098b48
 SHA512:
-  metadata.gz: 2a4143021040bf61c3de7509fe63db0c3951cc3bc3a3f42ab8ce3f9e95777228282063801cae652de32b7e8d51e5fe9f18a61b66e5061021fc0934cf05d692b3
-  data.tar.gz: 6ef93f4db7399b45c31937ba71a5a5fbb208880a5ec503c4a3c82ff7255167850f78ce9a6f7951dc4beb6dc7e612105ac5531116da6be32c6a33140f26e2d237
+  metadata.gz: 6e56cf914dbf2dce5334691d4bf332cf272c47e859402b202453f8998b90a6e993def0a38ca865f7906167d7769c94120b38f7efcf5842dd44a1fcdd583bc75c
+  data.tar.gz: 40b5f8ebac73a321889d4f7e3edeb3e24f25050a4972df7d9a81f7e6ede6fb0ef08cd2c002e62561fd5d9c9cb8f5fb6f67abb571821139e8c3f8cefaadc1972a

data/README.md

@@ -62,7 +62,7 @@ First you need to run the smart proxy on `http://localhost:8000` and a powerdns
 
 It is assumed the powerdns instance has both the `example.com` and `in-addr.arpa` domains configured. If not, create them:
 
-    INSERT INTO domains (name, type) VALUES ('example.com', 'master'), ('in-addr.arpa', 'master');
+    INSERT INTO domains (name, type) VALUES ('example.com', 'master'), ('in-addr.arpa', 'master'), ('ip6.arpa', 'master');
     INSERT INTO records (domain_id, name, type, content) SELECT id domain_id, name, 'SOA', 'ns1.example.com hostmaster.example.com. 0 3600 1800 1209600 3600' FROM domains WHERE NOT EXISTS (SELECT 1 FROM records WHERE records.domain_id=domains.id AND records.name=domains.name AND type='SOA');
 
 Then run the tests:

data/lib/smart_proxy_dns_powerdns/dns_powerdns_main.rb

@@ -22,13 +22,12 @@ module Proxy::Dns::Powerdns
       do_create(fqdn, ip, "A")
     end
 
-    def create_ptr_record(fqdn, ip)
-      if found = dns_find(ip)
-        raise Proxy::Dns::Collision, "#{ip} is already in use by #{found}" unless found == fqdn
+    def create_ptr_record(fqdn, value)
+      if found = dns_find(value)
+        raise Proxy::Dns::Collision, "#{value} is already in use by #{found}" unless found == fqdn
       end
 
-      name = IPAddr.new(ip).reverse
-      do_create(name, fqdn, "PTR")
+      do_create(value, fqdn, "PTR")
     end
 
     def do_create(name, value, type)
@@ -40,8 +39,7 @@ module Proxy::Dns::Powerdns
       do_remove(fqdn, "A")
     end
 
-    def remove_ptr_record(ip)
-      name = ip # Note ip is already in-addr.arpa
+    def remove_ptr_record(name)
       do_remove(name, "PTR")
     end
 

data/lib/smart_proxy_dns_powerdns/dns_powerdns_version.rb

@@ -1,7 +1,7 @@
 module Proxy
   module Dns
     module Powerdns
-      VERSION = '0.2.0'
+      VERSION = '0.2.1'
     end
   end
 end

data/test/integration/integration_test.rb

@@ -7,32 +7,31 @@ class DnsPowerdnsIntegrationTest < Test::Unit::TestCase
 
   def test_forward_dns
     data = {'fqdn' => fqdn, 'value' => ip, 'type' => 'A'}
+    type = Resolv::DNS::Resource::IN::A
+    expected = type.new(Resolv::IPv4.create(data['value']))
 
-    uri = URI(smart_proxy_url)
-
-    Net::HTTP.start(uri.host, uri.port) do |http|
-      request = Net::HTTP::Post.new(smart_proxy_url + 'dns/')
-      request.form_data = data
-      response = http.request request
-      assert_equal(200, response.code.to_i)
+    test_scenario(data, data['fqdn'], type, expected)
+  end
 
-      addresses = resolver.getaddresses(data['fqdn'])
-      assert_equal([Resolv::IPv4.create(data['value'])], addresses, "#{data['fqdn']} should resolve to #{data['value']}")
+  def test_reverse_dns_v4
+    data = {'fqdn' => fqdn, 'value' => IPAddr.new(ip).reverse, 'type' => 'PTR'}
+    type = Resolv::DNS::Resource::IN::PTR
+    expected = type.new(Resolv::DNS::Name.create(data['fqdn'] + '.'))
 
-      request = Net::HTTP::Delete.new(smart_proxy_url + 'dns/' + data['fqdn'])
-      response = http.request request
-      assert_equal(200, response.code.to_i)
+    test_scenario(data, data['value'], type, expected)
+  end
 
-      assert(purge_cache data['fqdn'])
+  def test_reverse_dns_v6
+    data = {'fqdn' => fqdn, 'value' => IPAddr.new(ipv6).reverse, 'type' => 'PTR'}
+    type = Resolv::DNS::Resource::IN::PTR
+    expected = type.new(Resolv::DNS::Name.create(data['fqdn'] + '.'))
 
-      addresses = resolver.getaddresses(data['fqdn'])
-      assert_equal([], addresses)
-    end
+    test_scenario(data, data['value'], type, expected)
   end
 
-  def test_reverse_dns
-    data = {'fqdn' => fqdn, 'value' => ip, 'type' => 'PTR'}
+  private
 
+  def test_scenario(data, name, type, expected)
     uri = URI(smart_proxy_url)
 
     Net::HTTP.start(uri.host, uri.port) do |http|
@@ -41,10 +40,7 @@ class DnsPowerdnsIntegrationTest < Test::Unit::TestCase
       response = http.request request
       assert_equal(200, response.code.to_i)
 
-      name = Resolv::IPv4.create(data['value']).to_name.to_s
-
-      addresses = resolver.getnames(data['value'])
-      assert_equal([Resolv::DNS::Name.create(data['fqdn'] + '.')], addresses, "#{data['value']} should reverse to #{data['fqdn']}")
+      assert_equal([expected], resolver.getresources(name, type))
 
       request = Net::HTTP::Delete.new(smart_proxy_url + 'dns/' + name)
       response = http.request request
@@ -52,13 +48,10 @@ class DnsPowerdnsIntegrationTest < Test::Unit::TestCase
 
       assert(purge_cache name)
 
-      addresses = resolver.getnames(data['value'])
-      assert_equal([], addresses)
+      assert_equal([], resolver.getresources(name, type))
     end
   end
 
-  private
-
   def resolver
     Resolv::DNS.new(:nameserver_port => [['127.0.0.1', 5300]])
   end
@@ -76,6 +69,10 @@ class DnsPowerdnsIntegrationTest < Test::Unit::TestCase
     IPAddr.new(rand(2 ** 32), Socket::AF_INET).to_s
   end
 
+  def ipv6
+    IPAddr.new(rand(2 ** 128), Socket::AF_INET6).to_s
+  end
+
   def purge_cache name
     %x{#{ENV['PDNS_CONTROL'] || "pdns_control"} purge "#{name}"}
     $? == 0

data/test/unit/dns_powerdns_record_test.rb

@@ -36,21 +36,21 @@ class DnsPowerdnsRecordTest < Test::Unit::TestCase
   def test_create_ptr
     instance = klass.new
 
-    instance.expects(:dns_find).with('10.1.1.1').returns(false)
+    instance.expects(:dns_find).with('1.1.1.10.in-addr.arpa').returns(false)
     instance.expects(:get_zone).with('1.1.1.10.in-addr.arpa').returns({'id' => 1, 'name' => '1.1.10.in-addr.arpa'})
     instance.expects(:create_record).with(1, '1.1.1.10.in-addr.arpa', 'PTR', 'test.example.com').returns(true)
     instance.expects(:rectify_zone).with('1.1.10.in-addr.arpa').returns(true)
 
-    assert instance.create_ptr_record(fqdn, ip)
+    assert instance.create_ptr_record(fqdn, reverse_ip)
   end
 
   # Test PTR record creation fails if the record exists
   def test_create_ptr_conflict
     instance = klass.new
 
-    instance.expects(:dns_find).with('10.1.1.1').returns('test2.example.com')
+    instance.expects(:dns_find).with('1.1.1.10.in-addr.arpa').returns('test2.example.com')
 
-    assert_raise(Proxy::Dns::Collision) { instance.create_ptr_record(fqdn, ip) }
+    assert_raise(Proxy::Dns::Collision) { instance.create_ptr_record(fqdn, reverse_ip) }
   end
 
   # Test A record removal

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_dns_powerdns
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Ewoud Kohl van Wijngaarden
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-21 00:00:00.000000000 Z
+date: 2016-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake