smart_proxy_dns_route53 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9425c48e0e02858ba2c5fc8745b0b7412a432895
-  data.tar.gz: d53e7bace7f3b919c0ae85cc03d3d487ddb012a1
+  metadata.gz: afc68be7898dff76e610ac85e992e403f86d6c92
+  data.tar.gz: e88894baa652431ea063b23287c9f9ff909da377
 SHA512:
-  metadata.gz: 412561d3bfde71176d188c4208bfa1a7a1d78e60afbfe1a015de485178b4028ada0c7a1993146feb7243290c041296480896385cff6e6522e7116e0ca6cfe3a0
-  data.tar.gz: c7af876d6513e401d1be94f3c669374904470f44860e565f361e3d3656c6328c0df3d70b8398401b3a4ddf379403a7eb96bd29df3d8a41c9296ec874a026c405
+  metadata.gz: 64b97a5cbfd2150c4df89b57d86acc26b07c10cc4ca6f630f39533bbfe35ad3e417bf39e998f60b5ec64726fcd7319e5555b3ae05a62c8ca2bac5b11a86dc12b
+  data.tar.gz: 39da40207db0a7083db676da32b085edb38b53c7a63f528a92638c5c4304521995d5e48cdc8210cdf70db5079b4805f4318cd5c64b6618f7eabac2b7fc7b8750

data/README.md

@@ -1,13 +1,18 @@
-# SmartProxyDnsRoute53
+# Route 53 smart proxy plugin
 
-This plugin adds a new DNS provider for managing records in Amazon's Route53 service.
+This plugin adds a new DNS provider for managing records in Amazon's Route 53 service.
 
 ## Installation
 
 See [How_to_Install_a_Smart-Proxy_Plugin](http://projects.theforeman.org/projects/foreman/wiki/How_to_Install_a_Smart-Proxy_Plugin)
 for how to install Smart Proxy plugins
 
-This plugin is compatible with Smart Proxy 1.10 or higher.
+## Compatibility
+
+| Smart Proxy Version | Plugin Version |
+| ------------------- | --------------:|
+| >= 1.10, < 1.11     | ~> 1.0         |
+| >= 1.11             | ~> 2.0         |
 
 ## Configuration
 
@@ -15,7 +20,7 @@ To enable this DNS provider, edit `/etc/foreman-proxy/settings.d/dns.yml` and se
 
     :use_provider: dns_route53
 
-You will need an active Amazon Web Services account and to create a new IAM account with access to manage Route53 for the Smart Proxy plugin to work.
+You will need an active Amazon Web Services account and to create a new IAM account with access to manage Route 53 for the Smart Proxy plugin to work.
 
 Configuration options for this plugin are in `/etc/foreman-proxy/settings.d/dns_route53.yml` and include:
 

data/lib/smart_proxy_dns_route53/dns_route53_main.rb

@@ -1,4 +1,5 @@
 require 'dns/dns'
+require 'dns_common/dns_common'
 require 'resolv'
 require 'route53'
 
@@ -9,92 +10,72 @@ module Proxy::Dns::Route53
 
     attr_reader :aws_access_key, :aws_secret_key
 
-    def self.record(attrs = {})
-      new(attrs.merge(
-        :aws_access_key => ::Proxy::Dns::Route53::Plugin.settings.aws_access_key,
-        :aws_secret_key => ::Proxy::Dns::Route53::Plugin.settings.aws_secret_key
-      ))
+    def initialize(a_server = nil, a_ttl = nil)
+      @aws_access_key = Proxy::Dns::Route53::Plugin.settings.aws_access_key
+      @aws_secret_key = Proxy::Dns::Route53::Plugin.settings.aws_secret_key
+      super(a_server, a_ttl || ::Proxy::Dns::Plugin.settings.dns_ttl)
     end
 
-    def initialize options = {}
-      @aws_access_key = options[:aws_access_key]
-      @aws_secret_key = options[:aws_secret_key]
-      raise "dns_route53 provider needs AWS access and secret key options" unless aws_access_key && aws_secret_key
-      super(options)
+    def create_a_record(fqdn, ip)
+      if found = dns_find(fqdn)
+        raise(Proxy::Dns::Collision, "#{fqdn} is already used by #{ip}") unless found == ip
+      else
+        zone = get_zone(fqdn)
+        new_record = Route53::DNSRecord.new(fqdn, 'A', ttl, [ip], zone)
+        resp = new_record.create
+        raise "AWS Response Error: #{resp}" if resp.error?
+        true
+      end
+    end
+
+    def create_ptr_record(fqdn, ip)
+      if found = dns_find(ip)
+        raise(Proxy::Dns::Collision, "#{ip} is already used by #{found}") unless found == fqdn
+      else
+        zone = get_zone(ip)
+        new_record = Route53::DNSRecord.new(ip, 'PTR', ttl, [fqdn], zone)
+        resp = new_record.create
+        raise "AWS Response Error: #{resp}" if resp.error?
+        true
+      end
     end
 
-    def create
-      case @type
-        when "A"
-          if ip = dns_find(@fqdn)
-            raise(Proxy::Dns::Collision, "#{@fqdn} is already used by #{ip}") unless ip == @value
-          else
-            zone = get_zone(@fqdn)
-            new_record = Route53::DNSRecord.new(@fqdn, 'A', @ttl, [@value], zone)
-            resp = new_record.create
-            raise "AWS Response Error: #{resp}" if resp.error?
-            true
-          end
-        when "PTR"
-          if name = dns_find(@value)
-            raise(Proxy::Dns::Collision, "#{@value} is already used by #{name}") unless name == @fqdn
-          else
-            zone = get_zone(@value)
-            new_record = Route53::DNSRecord.new(@value, 'PTR', @ttl, [@fqdn], zone)
-            resp = new_record.create
-            raise "AWS Response Error: #{resp}" if resp.error?
-            true
-          end
+    def remove_a_record(fqdn)
+      zone = get_zone(fqdn)
+      recordset = zone.get_records
+      recordset.each do |rec|
+        if rec.name == fqdn + '.'
+          resp = rec.delete
+          raise "AWS Response Error: #{resp}" if resp.error?
+          return true
+        end
       end
+      raise Proxy::Dns::NotFound, "Could not find forward record #{fqdn}"
     end
 
-    def remove
-      case @type
-        when "A"
-          zone = get_zone(@fqdn)
-          recordset = zone.get_records
-          recordset.each do |rec|
-            if rec.name == @fqdn + '.'
-              resp = rec.delete
-              raise "AWS Response Error: #{resp}" if resp.error?
-              return true
-            end
-          end
-          raise Proxy::Dns::NotFound, "Could not find forward record #{@fqdn}"
-        when "PTR"
-          zone = get_zone(@value)
-          recordset = zone.get_records
-          recordset.each do |rec|
-            if rec.name == @value + '.'
-              resp = rec.delete
-              raise "AWS Response Error: #{resp}" if resp.error?
-              return true
-            end
-          end
-          raise Proxy::Dns::NotFound, "Could not find reverse record #{@value}"
+    def remove_ptr_record(ip)
+      zone = get_zone(ip)
+      recordset = zone.get_records
+      recordset.each do |rec|
+        if rec.name == ip + '.'
+          resp = rec.delete
+          raise "AWS Response Error: #{resp}" if resp.error?
+          return true
+        end
       end
+      raise Proxy::Dns::NotFound, "Could not find reverse record #{ip}"
     end
 
     private
 
     def conn
-      @conn ||= Route53::Connection.new(@aws_access_key, @aws_secret_key)
+      @conn ||= Route53::Connection.new(aws_access_key, aws_secret_key)
     end
 
     def resolver
       @resolver ||= Resolv::DNS.new
     end
 
-    def dns_find key
-      if match = key.match(/(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})/)
-        resolver.getname(match[1..4].reverse.join(".")).to_s
-      else
-        resolver.getaddress(key).to_s
-      end
-    rescue Resolv::ResolvError
-      false
-    end
-
     def get_zone(fqdn)
       domain = fqdn.split('.', 2).last + '.'
       conn.get_zones(domain)[0]

data/lib/smart_proxy_dns_route53/dns_route53_plugin.rb

@@ -2,13 +2,15 @@ require 'smart_proxy_dns_route53/dns_route53_version'
 
 module Proxy::Dns::Route53
   class Plugin < ::Proxy::Provider
-    plugin :dns_route53, ::Proxy::Dns::Route53::VERSION,
-           :factory => proc { |attrs| ::Proxy::Dns::Route53::Record.record(attrs) }
+    plugin :dns_route53, ::Proxy::Dns::Route53::VERSION
 
-    requires :dns, '>= 1.10'
+    requires :dns, '>= 1.11'
+
+    validate_presence :aws_access_key, :aws_secret_key
 
     after_activation do
       require 'smart_proxy_dns_route53/dns_route53_main'
+      require 'smart_proxy_dns_route53/route53_dependencies'
     end
   end
 end

data/lib/smart_proxy_dns_route53/dns_route53_version.rb

@@ -1,7 +1,7 @@
 module Proxy
   module Dns
     module Route53
-      VERSION = '1.0.0'
+      VERSION = '2.0.0'
     end
   end
 end

data/lib/smart_proxy_dns_route53/route53_dependencies.rb

@@ -0,0 +1,5 @@
+require 'dns_common/dependency_injection/dependencies'
+
+class Proxy::Dns::DependencyInjection::Dependencies
+  dependency :dns_provider, Proxy::Dns::Route53::Record
+end

data/test/dns_route53_record_test.rb

@@ -1,97 +1,92 @@
 require 'test_helper'
 
+require 'smart_proxy_dns_route53/dns_route53_plugin'
 require 'smart_proxy_dns_route53/dns_route53_main'
 
 class DnsRoute53RecordTest < Test::Unit::TestCase
-  # Test that a missing :example_setting throws an error
-  def test_initialize_without_settings
-    assert_raise(RuntimeError) do
-      klass.new(settings.delete_if { |k,v| k == :aws_secret_key || k == :aws_access_key })
-    end
-  end
-
   # Test that correct initialization works
-  def test_initialize_with_settings
-    assert_nothing_raised do
-      klass.new(settings)
-    end
+  def test_provider_initialization
+    Proxy::Dns::Route53::Plugin.load_test_settings(:aws_access_key => 'foo', :aws_secret_key => 'bar')
+    provider = klass.new
+    assert_equal 'foo', provider.aws_access_key
+    assert_equal 'bar', provider.aws_secret_key
   end
 
   # Test A record creation
   def test_create_a
-    record = klass.new(settings)
+    record = klass.new
     record.expects(:dns_find).returns(false)
 
     zone = mock()
     record.expects(:get_zone).with('test.example.com').returns(zone)
 
     dnsrecord = mock(:create => mock(:error? => false))
-    Route53::DNSRecord.expects(:new).with('test.example.com', 'A', '86400', ['10.1.1.1'], zone).returns(dnsrecord)
+    Route53::DNSRecord.expects(:new).with('test.example.com', 'A', 86400, ['10.1.1.1'], zone).returns(dnsrecord)
 
-    assert record.create
+    assert record.create_a_record(fqdn, ip)
   end
 
   # Test A record creation fails if the record exists
   def test_create_a_conflict
-    record = klass.new(settings)
+    record = klass.new
     record.expects(:dns_find).returns('10.2.2.2')
-    assert_raise(Proxy::Dns::Collision) { record.create }
+    assert_raise(Proxy::Dns::Collision) { record.create_a_record(fqdn, ip) }
   end
 
   # Test PTR record creation
   def test_create_ptr
-    record = klass.new(settings.merge(:type => 'PTR'))
+    record = klass.new
     record.expects(:dns_find).returns(false)
 
     zone = mock()
     record.expects(:get_zone).with('10.1.1.1').returns(zone)
 
     dnsrecord = mock(:create => mock(:error? => false))
-    Route53::DNSRecord.expects(:new).with('10.1.1.1', 'PTR', '86400', ['test.example.com'], zone).returns(dnsrecord)
+    Route53::DNSRecord.expects(:new).with('10.1.1.1', 'PTR', 86400, ['test.example.com'], zone).returns(dnsrecord)
 
-    assert record.create
+    assert record.create_ptr_record(fqdn, ip)
   end
 
   # Test PTR record creation fails if the record exists
   def test_create_ptr_conflict
-    record = klass.new(settings.merge(:type => 'PTR'))
+    record = klass.new
     record.expects(:dns_find).returns('else.example.com')
-    assert_raise(Proxy::Dns::Collision) { record.create }
+    assert_raise(Proxy::Dns::Collision) { record.create_ptr_record(fqdn, ip) }
   end
 
   # Test A record removal
   def test_remove_a
     zone = mock(:get_records => [mock(:name => 'test.example.com.', :delete => mock(:error? => false))])
-    record = klass.new(settings)
+    record = klass.new
     record.expects(:get_zone).with('test.example.com').returns(zone)
-    assert record.remove
+    assert record.remove_a_record(fqdn)
   end
 
   # Test A record removal fails if the record doesn't exist
   def test_remove_a_not_found
-    record = klass.new(settings)
+    record = klass.new
     record.expects(:get_zone).with('test.example.com').returns(mock(:get_records => []))
-    assert_raise(Proxy::Dns::NotFound) { assert record.remove }
+    assert_raise(Proxy::Dns::NotFound) { assert record.remove_a_record(fqdn) }
   end
 
   # Test PTR record removal
   def test_remove_ptr
     # FIXME: record name seems incorrect for rDNS
     zone = mock(:get_records => [mock(:name => '10.1.1.1.', :delete => mock(:error? => false))])
-    record = klass.new(settings.merge(:type => 'PTR'))
+    record = klass.new
     record.expects(:get_zone).with('10.1.1.1').returns(zone)
-    assert record.remove
+    assert record.remove_ptr_record(ip)
   end
 
   # Test PTR record removal fails if the record doesn't exist
   def test_remove_ptr_not_found
-    record = klass.new(settings.merge(:type => 'PTR'))
+    record = klass.new
     record.expects(:get_zone).with('10.1.1.1').returns(mock(:get_records => []))
-    assert_raise(Proxy::Dns::NotFound) { assert record.remove }
+    assert_raise(Proxy::Dns::NotFound) { assert record.remove_ptr_record(ip) }
   end
 
   def test_get_zone_forward
-    record = klass.new(settings)
+    record = klass.new
     conn = mock()
     conn.expects(:get_zones).with('example.com.').returns([:zone])
     record.expects(:conn).returns(conn)
@@ -99,7 +94,7 @@ class DnsRoute53RecordTest < Test::Unit::TestCase
   end
 
   def test_get_zone_reverse
-    record = klass.new(settings)
+    record = klass.new
     conn = mock()
     conn.expects(:get_zones).with('1.1.1.').returns([:zone])  # FIXME, incorrect rDNS zone
     record.expects(:conn).returns(conn)
@@ -107,7 +102,7 @@ class DnsRoute53RecordTest < Test::Unit::TestCase
   end
 
   def test_dns_find_forward
-    record = klass.new(settings)
+    record = klass.new
     resolver = mock()
     resolver.expects(:getaddress).with('test.example.com').returns('10.1.1.1')
     record.expects(:resolver).returns(resolver)
@@ -115,7 +110,7 @@ class DnsRoute53RecordTest < Test::Unit::TestCase
   end
 
   def test_dns_find_forward_not_found
-    record = klass.new(settings)
+    record = klass.new
     resolver = mock()
     resolver.expects(:getaddress).with('test.example.com').raises(Resolv::ResolvError)
     record.expects(:resolver).returns(resolver)
@@ -123,7 +118,7 @@ class DnsRoute53RecordTest < Test::Unit::TestCase
   end
 
   def test_dns_find_reverse
-    record = klass.new(settings)
+    record = klass.new
     resolver = mock()
     resolver.expects(:getname).with('3.2.1.10').returns('test.example.com')
     record.expects(:resolver).returns(resolver)
@@ -131,7 +126,7 @@ class DnsRoute53RecordTest < Test::Unit::TestCase
   end
 
   def test_dns_find_reverse_not_found
-    record = klass.new(settings)
+    record = klass.new
     resolver = mock()
     resolver.expects(:getname).with('3.2.1.10').raises(Resolv::ResolvError)
     record.expects(:resolver).returns(resolver)
@@ -144,13 +139,11 @@ class DnsRoute53RecordTest < Test::Unit::TestCase
     Proxy::Dns::Route53::Record
   end
 
-  def settings
-    {
-      :aws_access_key => 'foo',
-      :aws_secret_key => 'bar',
-      :fqdn => 'test.example.com',
-      :value => '10.1.1.1',
-      :type => 'A'
-    }
+  def fqdn
+    'test.example.com'
+  end
+
+  def ip
+    '10.1.1.1'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_dns_route53
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Foreman developers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-10 00:00:00.000000000 Z
+date: 2016-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: route53
@@ -26,6 +26,20 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '11'
+- !ruby/object:Gem::Dependency
+  name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: mocha
+  name: test-unit
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -52,7 +66,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Route53 DNS provider plugin for Foreman's smart proxy
+description: Route 53 DNS provider plugin for Foreman's smart proxy
 email:
 - foreman-dev@googlegroups.com
 executables: []
@@ -67,6 +81,7 @@ files:
 - lib/smart_proxy_dns_route53/dns_route53_main.rb
 - lib/smart_proxy_dns_route53/dns_route53_plugin.rb
 - lib/smart_proxy_dns_route53/dns_route53_version.rb
+- lib/smart_proxy_dns_route53/route53_dependencies.rb
 - test/dns_route53_record_test.rb
 - test/test_helper.rb
 homepage: https://github.com/theforeman/smart_proxy_dns_route53
@@ -92,7 +107,7 @@ rubyforge_project:
 rubygems_version: 2.2.1
 signing_key: 
 specification_version: 4
-summary: Route53 DNS provider plugin for Foreman's smart proxy
+summary: Route 53 DNS provider plugin for Foreman's smart proxy
 test_files:
 - test/dns_route53_record_test.rb
 - test/test_helper.rb