smart_proxy_dns_infoblox 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7d7a93d41d181fc6748937bb4aa4f855b80438a8
-  data.tar.gz: 66a8acdb1320e1f5aa412e2468b683553cb061fe
+  metadata.gz: f067a373f17dd6adba9aea33e3084c5e005d3b26
+  data.tar.gz: 6e19878e4ac1cd475a30da5a23632cf35e245ab6
 SHA512:
-  metadata.gz: c6245b3a70f9295f6e40cc800e751167b7732cfa3b3e04c49c432e72d2ddf64b4e9336d62f346168bae8f83a4f098c4d6e1b48869e4c25406f44c91ce2653401
-  data.tar.gz: dc19c4c51440d517e874333818dd3151be474726370739837b092bcc5daa5d83a52713dd4d97701390c253bc8dfa0ed26aba0a2c40c213880975bd26216b2b4e
+  metadata.gz: 0f67055c0fb692c6380c6bcda4b1f56c046d9b39c5c526f80622256b9e31a937efa3c5485b14f9589890e85a2d8322e8f9a52df0d0c09aefd623cba28f0cc410
+  data.tar.gz: 422837060375ce89e38fbedbf5f98ea48c515c21e2c961fb70d57a30391ea659bd9add9e3ab21eae78824dd0f189556ad08a974a4230241c716ee60edbf21efb

data/config/dns_infoblox.yml.example

@@ -0,0 +1,8 @@
+---
+#
+# Configuration file for 'infoblox dns provider
+#
+
+:username: "infoblox"
+:password: "infoblox"
+:dns_server: "infoblox.my.domain"

data/lib/smart_proxy_dns_infoblox.rb

@@ -1,3 +1,9 @@
-require 'smart_proxy_dns_infoblox/dns_infoblox_plugin'
+module Proxy
+  module Dns
+    module Infoblox; end
+  end
+end
 
-module Proxy::Dns::Infoblox; end
+require 'smart_proxy_dns_infoblox/plugin_configuration'
+require 'smart_proxy_dns_infoblox/dns_infoblox_version'
+require 'smart_proxy_dns_infoblox/dns_infoblox_plugin'

data/lib/smart_proxy_dns_infoblox/dns_infoblox_main.rb

@@ -1,57 +1,58 @@
-require 'dns/dns'
-require 'dns_common/dns_common'
-require 'infoblox'
 module Proxy::Dns::Infoblox
   class Record < ::Proxy::Dns::Record
-    include Proxy::Log
-    include Proxy::Util
+    attr_reader :connection
 
-    attr_reader :example_setting, :optional_path, :required_setting, :required_path
-
-    def initialize
+    def initialize(host, connection, ttl)
       ENV['WAPI_VERSION']='2.0'
-      @infoblox_user = ::Proxy::Dns::Infoblox::Plugin.settings.infoblox_user
-      @infoblox_pw   = ::Proxy::Dns::Infoblox::Plugin.settings.infoblox_pw
-      @infoblox_host = ::Proxy::Dns::Infoblox::Plugin.settings.infoblox_host
-      @conn          = ::Infoblox::Connection.new(username: @infoblox_user ,password: @infoblox_pw, host: @infoblox_host)
-      super('localhost', ::Proxy::Dns::Plugin.settings.dns_ttl)
+      @connection = connection
+      super(host, ttl)
     end
 
-    # Calls to these methods are guaranteed to have non-nil parameters
     def create_a_record(fqdn, ip)
-      raise(Proxy::Dns::Collision, "#{fqdn} is already used by #{ip_in_use}") if dns_find(fqdn)
-
-      a_record = Infoblox::Arecord.new(connection: @conn, name: fqdn, ipv4addr: ip)
-      a_record.post
+      case a_record_conflicts(fqdn, ip) #returns -1, 0, 1
+      when 1
+        raise(Proxy::Dns::Collision, "'#{fqdn} 'is already in use")
+      when 0 then
+        return nil
+      else
+        do_create(Infoblox::Arecord, :connection => connection, :name => fqdn, :ipv4addr => ip)
+      end
     end
 
-    def create_ptr_record(fqdn, ip)
-      #ip here comes in as 2.1.168.192.in-addr.arpa, so we need to strip and reverse.
-      raise(Proxy::Dns::Collision, "#{ip} is already used by #{fqdn_in_use}") if dns_find(ip)
-      fixed_ip = ip.chomp('.in-addr.arpa').split('.').reverse .join('.')
-      ptr_record = Infoblox::Ptr.new(connection: @conn, ptrdname: fqdn, ipv4addr: fixed_ip)
-
-      ptr_record.post
+    def create_ptr_record(fqdn, ptr)
+      case ptr_record_conflicts(fqdn, ptr_to_ip(ptr)) #returns -1, 0, 1
+      when 1
+        raise(Proxy::Dns::Collision, "'#{fqdn} 'is already in use")
+      when 0 then
+        return nil
+      else
+        do_create(Infoblox::Ptr, :connection => connection, :ptrdname => fqdn, :ipv4addr => ptr_to_ip(ptr))
+      end
       # FIXME: add a reverse 'PTR' record with ip, fqdn
-      # Raise an error if the IP is already in DNS but with a different FQDN:
-      #   raise(Proxy::Dns::Collision, "#{ip} is already used by #{fqdn_in_use}")
     end
 
     def remove_a_record(fqdn)
-      a_record = Infoblox::Arecord.find( @conn, {name: fqdn}).first
-      a_record.delete || raise(Proxy::Dns::NotFound.new("Cannot find DNS entry for #{fqdn}"))
+      do_delete(Infoblox::Arecord.find(connection, :name => fqdn, :_max_results => 1).first, fqdn)
     end
 
-    def remove_ptr_record(ip)
-      #ip here comes in as 2.1.168.192.in-addr.arpa, so we need to strip and reverse.
-      fixed_ip = ip.chomp('.in-addr.arpa').split('.').reverse .join('.')
-      ptr_record = Infoblox::Ptr.find(@conn, { ipv4addr: fixed_ip }).first
-      ptr_record.ipv6addr=nil
-      ptr_record.view=nil
-      ptr_record.delete || raise(Proxy::Dns::NotFound.new("Cannot find DNS entry for #{ip}"))
+    def remove_ptr_record(ptr)
+      ptr_record = Infoblox::Ptr.find(connection, :ipv4addr => ptr_to_ip(ptr), :_max_results => 1).first
+      unless ptr_record.nil?
+        ptr_record.ipv6addr = nil
+        ptr_record.view = nil
+      end
+
+      do_delete(ptr_record, ptr)
       # FIXME: remove the reverse 'PTR' record with ip
-      # Raise an error if the IP is not in DNS:
-      #   raise Proxy::Dns::NotFound.new("Cannot find DNS entry for #{ip}")
+    end
+
+    def do_create(clazz, params)
+      clazz.new(params).post
+    end
+
+    def do_delete(record, id)
+      raise Proxy::Dns::NotFound, "Cannot find DNS entry for #{id}" if record.nil?
+      record.delete || (raise Proxy::Dns::NotFound, "Cannot find DNS entry for #{id}")
     end
   end
 end

data/lib/smart_proxy_dns_infoblox/dns_infoblox_plugin.rb

@@ -1,21 +1,12 @@
-require 'smart_proxy_dns_infoblox/dns_infoblox_version'
-
 module Proxy::Dns::Infoblox
   class Plugin < ::Proxy::Provider
-    plugin :dns_infoblox, ::Proxy::Dns::Infoblox::VERSION, :factory => proc { |attrs| ::Proxy::Dns::Infoblox::Record.record(attrs) }
-
-    # Settings listed under default_settings are required.
-    # An exception will be raised if they are initialized with nil values.
-    # Settings not listed under default_settings are considered optional and by default have nil value.
-    default_settings :infoblox_user => 'infoblox', :infoblox_pw => 'infoblox', :infoblox_host => 'infoblox.my.domain'
+    plugin :dns_infoblox, ::Proxy::Dns::Infoblox::VERSION
 
-    requires :dns, '>= 1.11'
+    default_settings :username => 'infoblox', :password => 'infoblox', :dns_server => 'infoblox.my.domain'
 
-    #validate_presence :infoblox_user, :infoblox_pw, :infoblox_host
+    requires :dns, '>= 1.12'
 
-    after_activation do
-      require 'smart_proxy_dns_infoblox/dns_infoblox_main'
-      require 'smart_proxy_dns_infoblox/dns_infoblox_dependencies'
-    end
+    load_classes ::Proxy::Dns::Infoblox::PluginConfiguration
+    load_dependency_injection_wirings ::Proxy::Dns::Infoblox::PluginConfiguration
   end
 end

data/lib/smart_proxy_dns_infoblox/dns_infoblox_version.rb

@@ -1,7 +1,7 @@
 module Proxy
   module Dns
     module Infoblox
-      VERSION = '0.0.3'
+      VERSION = '0.0.4'
     end
   end
 end

data/lib/smart_proxy_dns_infoblox/plugin_configuration.rb

@@ -0,0 +1,25 @@
+module Proxy::Dns::Infoblox
+  class PluginConfiguration
+    def load_classes
+      require 'infoblox'
+      require 'dns_common/dns_common'
+      require 'smart_proxy_dns_infoblox/dns_infoblox_main'
+    end
+
+    def load_dependency_injection_wirings(container_instance, settings)
+      container_instance.dependency :connection,
+                                    (lambda do
+                                      ::Infoblox.wapi_version = '2.0'
+                                      ::Infoblox::Connection.new(:username => settings[:username],
+                                                                 :password => settings[:password],
+                                                                 :host => settings[:dns_server],
+                                                                 :ssl_opts => {:verify => false})
+                                    end)
+      container_instance.dependency :dns_provider,
+                                    lambda {::Proxy::Dns::Infoblox::Record.new(
+                                        settings[:dns_server],
+                                        container_instance.get_dependency(:connection),
+                                        settings[:dns_ttl]) }
+    end
+  end
+end

data/test/configuration_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+require 'infoblox'
+require 'smart_proxy_dns_infoblox/plugin_configuration'
+
+class InfobloxProviderWiringTest < Test::Unit::TestCase
+  def setup
+    @container = ::Proxy::DependencyInjection::Container.new
+    @config = ::Proxy::Dns::Infoblox::PluginConfiguration.new
+  end
+
+  def test_connection_wiring
+    @config.load_dependency_injection_wirings(@container, :username => 'user', :password => 'password', :dns_server => 'a_host')
+    connection = @container.get_dependency(:connection)
+
+    assert_equal 'user', connection.username
+    assert_equal 'password', connection.password
+    assert_equal 'https://a_host', connection.host
+    assert_equal({:verify => false}, connection.ssl_opts)
+  end
+
+  def test_dns_provider_wiring
+    @config.load_dependency_injection_wirings(@container, :username => 'user', :password => 'password', :dns_server => 'a_host')
+    provider = @container.get_dependency(:dns_provider)
+
+    assert !provider.connection.nil?
+    assert_equal 'a_host', provider.server
+  end
+end

data/test/infoblox_test.rb

@@ -0,0 +1,115 @@
+require 'test_helper'
+require 'dns_common/dns_common'
+require 'infoblox'
+require 'smart_proxy_dns_infoblox/dns_infoblox_main'
+
+
+class InfobloxTest < Test::Unit::TestCase
+  class DummyRecord
+    attr_accessor :ipv6addr, :view
+  end
+
+  def setup
+    @connection = Object.new
+    @record = DummyRecord.new
+    @provider = Proxy::Dns::Infoblox::Record.new('a_host', @connection, 999)
+  end
+
+  def test_create_a
+    fqdn = 'test.example.com'
+    ip = '10.1.1.1'
+
+    @provider.expects(:a_record_conflicts).with(fqdn, ip).returns(-1)
+    @provider.expects(:do_create).with(Infoblox::Arecord, :connection => @connection, :name => fqdn, :ipv4addr => ip)
+
+    @provider.create_a_record(fqdn, ip)
+  end
+
+  def test_create_a_conflicting_record
+    fqdn = 'test.example.com'
+    ip = '10.1.1.1'
+
+    @provider.expects(:a_record_conflicts).with(fqdn, ip).returns(1)
+    assert_raises(Proxy::Dns::Collision) { @provider.create_a_record(fqdn, ip) }
+  end
+
+  def test_create_a_already_exists
+    fqdn = 'test.example.com'
+    ip = '10.1.1.1'
+
+    @provider.expects(:a_record_conflicts).with(fqdn, ip).returns(0)
+    assert_nil @provider.create_a_record(fqdn, ip)
+  end
+
+  def test_create_ptr
+    fqdn = 'test.example.com'
+    ptr = '1.1.1.10.in-addr.arpa'
+    ip = '10.1.1.1'
+
+    @provider.expects(:ptr_record_conflicts).with(fqdn, ip).returns(-1)
+    @provider.expects(:do_create).with(Infoblox::Ptr, :connection => @connection, :ptrdname => fqdn, :ipv4addr => ip)
+
+    @provider.create_ptr_record(fqdn, ptr)
+  end
+
+  def test_create_ptr_conflicting_record
+    fqdn = 'test.example.com'
+    ptr = '1.1.1.10.in-addr.arpa'
+    ip = '10.1.1.1'
+
+    @provider.expects(:ptr_record_conflicts).with(fqdn, ip).returns(1)
+    assert_raises(Proxy::Dns::Collision) { @provider.create_ptr_record(fqdn, ptr) }
+  end
+
+  def test_create_ptr_already_exists
+    fqdn = 'test.example.com'
+    ptr = '1.1.1.10.in-addr.arpa'
+    ip = '10.1.1.1'
+
+    @provider.expects(:ptr_record_conflicts).with(fqdn, ip).returns(0)
+    assert_nil @provider.create_ptr_record(fqdn, ptr)
+  end
+
+  def test_remove_a
+    fqdn = 'test.example.com'
+    Infoblox::Arecord.expects(:find).with(@connection, :name => fqdn, :_max_results => 1).returns([@record])
+    @record.expects(:delete).returns(true)
+    @provider.remove_a_record(fqdn)
+  end
+
+  def test_remove_a_not_found
+    fqdn = 'test.example.com'
+    Infoblox::Arecord.expects(:find).with(@connection, :name => fqdn, :_max_results => 1).returns([])
+    assert_raises(Proxy::Dns::NotFound) { @provider.remove_a_record(fqdn) }
+  end
+
+  def test_remove_a_returns_with_a_non_200_status
+    fqdn = 'test.example.com'
+    Infoblox::Arecord.expects(:find).with(@connection, :name => fqdn, :_max_results => 1).returns([@record])
+    @record.expects(:delete).returns(false)
+    assert_raises(Proxy::Dns::NotFound) { @provider.remove_a_record(fqdn) }
+  end
+
+  def test_remove_ptr
+    ptr = '1.1.1.10.in-addr.arpa'
+    ip = '10.1.1.1'
+    Infoblox::Ptr.expects(:find).with(@connection, :ipv4addr => ip, :_max_results => 1).returns([@record])
+    @record.expects(:delete).returns(true)
+    @provider.remove_ptr_record(ptr)
+  end
+
+  def test_remove_ptr_not_found
+    ptr = '1.1.1.10.in-addr.arpa'
+    ip = '10.1.1.1'
+    Infoblox::Ptr.expects(:find).with(@connection, :ipv4addr => ip, :_max_results => 1).returns([])
+    assert_raises(Proxy::Dns::NotFound) { @provider.remove_ptr_record(ptr) }
+  end
+
+  def test_remove_ptr_returns_with_a_non_200_status
+    ptr = '1.1.1.10.in-addr.arpa'
+    ip = '10.1.1.1'
+    Infoblox::Ptr.expects(:find).with(@connection, :ipv4addr => ip, :_max_results => 1).returns([@record])
+    @record.expects(:delete).returns(false)
+    assert_raises(Proxy::Dns::NotFound) { @provider.remove_ptr_record(ptr) }
+  end
+end

metadata

@@ -1,71 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_dns_infoblox
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Matthew Nicholson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-04 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: infoblox
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: mocha
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: test-unit
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+date: 2016-09-08 00:00:00.000000000 Z
+dependencies: []
 description: Infoblox DNS provider plugin for Foreman's smart proxy
 email:
 - matthew.a.nicholson@gmail.com
@@ -76,13 +20,14 @@ files:
 - LICENSE
 - README.md
 - bundler.d/dns_infoblox.rb
-- config/dns_infoblox.yml
+- config/dns_infoblox.yml.example
 - lib/smart_proxy_dns_infoblox.rb
-- lib/smart_proxy_dns_infoblox/dns_infoblox_dependencies.rb
 - lib/smart_proxy_dns_infoblox/dns_infoblox_main.rb
 - lib/smart_proxy_dns_infoblox/dns_infoblox_plugin.rb
 - lib/smart_proxy_dns_infoblox/dns_infoblox_version.rb
-- test/dns_infoblox_record_test.rb
+- lib/smart_proxy_dns_infoblox/plugin_configuration.rb
+- test/configuration_test.rb
+- test/infoblox_test.rb
 - test/test_helper.rb
 homepage: https://github.com/sjoeboo/smart_proxy_dns_infoblox
 licenses:
@@ -104,10 +49,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Infoblox DNS provider plugin for Foreman's smart proxy
 test_files:
-- test/dns_infoblox_record_test.rb
+- test/configuration_test.rb
+- test/infoblox_test.rb
 - test/test_helper.rb

data/config/dns_infoblox.yml

@@ -1,8 +0,0 @@
----
-#
-# Configuration file for 'infoblox dns provider
-#
-
-:infoblox_user: "infoblox"
-:infoblox_pw: "infoblox"
-infoblox_host: "infoblox.my.domain"

data/lib/smart_proxy_dns_infoblox/dns_infoblox_dependencies.rb

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

data/test/dns_infoblox_record_test.rb

@@ -1,95 +0,0 @@
-require 'test_helper'
-require 'dns/dns_plugin'
-require 'smart_proxy_dns_infoblox/dns_infoblox_plugin'
-require 'smart_proxy_dns_infoblox/dns_infoblox_main'
-
-
-class DnsInfobloxRecordTest < Test::Unit::TestCase
-
-  def test_default_settings
-    Proxy::Dns::Infoblox::Plugin.load_test_settings({})
-    assert_equal "default_value", Proxy::Dns::Nsupdate::Plugin.settings.required_setting
-    assert_equal "/must/exist", Proxy::Dns::Nsupdate::Plugin.settings.required_path
-  end
-
-  def test_initialized_correctly
-    Proxy::Dns::Infoblox::Plugin.load_test_settings(:example_setting => 'a_value',
-                                                          :required_setting => 'required_setting',
-                                                          :optional_path => '/some/path',
-                                                          :required_path => '/required/path')
-
-    assert_equal 'a_value', klass.new.example_setting
-    assert_equal 'required_value', klass.new.required_setting
-    assert_equal '/some/path', klass.new.optional_path
-    assert_equal '/required/path', klass.new.required_path
-  end
-
-  # Test that a missing :example_setting throws an error
-  # Test A record creation
-  def test_create_a
-    # Use mocha to expect any calls to backend services to prevent creating real records
-    #   MyService.expects(:create).with(:ip => '10.1.1.1', :name => 'test.example.com').returns(true)
-
-    assert klass.new.create_a_record('test.example.com', '10.1.1.1')
-  end
-
-  # Test A record creation fails if the record exists
-  def test_create_a_conflict
-    # Use mocha to expect any calls to backend services to prevent creating real records
-    #   MyService.expects(:create).with(:ip => '10.1.1.1', :name => 'test.example.com').returns(false)
-
-    assert_raise(Proxy::Dns::Collision) { klass.new.create_a_record('test.example.com', '10.1.1.1') }
-  end
-
-  # Test PTR record creation
-  def test_create_ptr
-    # Use mocha to expect any calls to backend services to prevent creating real records
-    #   MyService.expects(:create_reverse).with(:ip => '10.1.1.1', :name => 'test.example.com').returns(true)
-
-    assert klass.new.create_ptr_record('test.example.com', '10.1.1.1')
-  end
-
-  # Test PTR record creation fails if the record exists
-  def test_create_ptr_conflict
-    # Use mocha to expect any calls to backend services to prevent creating real records
-    #   MyService.expects(:create_reverse).with(:ip => '10.1.1.1', :name => 'test.example.com').returns(false)
-
-    assert_raise(Proxy::Dns::Collision) { klass.new.create_ptr_record('test.example.com', '10.1.1.1') }
-  end
-
-  # Test A record removal
-  def test_remove_a
-    # Use mocha to expect any calls to backend services to prevent deleting real records
-    #   MyService.expects(:delete).with(:name => 'test.example.com').returns(true)
-
-    assert klass.new.remove_a_record('test.example.com')
-  end
-
-  # Test A record removal fails if the record doesn't exist
-  def test_remove_a_not_found
-    # Use mocha to expect any calls to backend services to prevent deleting real records
-    #   MyService.expects(:delete).with(:name => 'test.example.com').returns(false)
-
-    assert_raise(Proxy::Dns::NotFound) { assert klass.new.remove_a_record('test.example.com') }
-  end
-
-  # Test PTR record removal
-  def test_remove_ptr
-    # Use mocha to expect any calls to backend services to prevent deleting real records
-    #   MyService.expects(:delete).with(:ip => '10.1.1.1').returns(true)
-
-    assert klass.new.remove_ptr_record('1.1.1.10.in-addr.arpa')
-  end
-
-  # Test PTR record removal fails if the record doesn't exist
-  def test_remove_ptr_not_found
-    # Use mocha to expect any calls to backend services to prevent deleting real records
-    #   MyService.expects(:delete).with(:ip => '10.1.1.1').returns(false)
-
-    assert_raise(Proxy::Dns::NotFound) { assert klass.new.remove_ptr_record('1.1.1.10.in-addr.arpa') }
-  end
-
-  def klass
-    Proxy::Dns::Infoblox::Record
-  end
-end