smart_proxy_dhcp_infoblox 0.0.16 → 0.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 386bb53985d3965e87d2ed0b4928858efe542d1a6bc28e1147795aae21871691
-  data.tar.gz: fffe1218aacbb214c899c01f72900756d3c92d13ec64b019e75fdc1307df0712
+  metadata.gz: 8270d920065fc68c07721637c04e6a5160540ad55299b02396db1485dfe2e497
+  data.tar.gz: b12bb3bb5530f560c0d9b98690bd8f202be137a53cb5a2d598dab847c6d1cf05
 SHA512:
-  metadata.gz: 9e6e8069b8151c468aa55e93aacb28bb657ce7b08a5b8ad2fb3a487b016672fb96dcf4c5c32be628d2a2500d890ab498be486c00aad4a94e3a08dac6e918041c
-  data.tar.gz: a63c13ca94c2e74a5fc7ffc0819d2df23a087c8650e817df7d303a695e56140f605a426108982be65fab94b5c3aa6547c578be701cb602c51cb009a9812052cf
+  metadata.gz: 6161907b7c06cf812682b6b7b886522104a79733dd2a14f6b0d2f99b2ba1ffb0abd34d6ca614ff7e07427aa1281d00f2f8841bdcef6fbc863ba099618d62b7fa
+  data.tar.gz: '097863ad2d3322617c153644dcab13217fae52d4fbb7906bbd30b9b0b1ce19cfb4cfc86b28b0247a7cc41097c063922eec60cb3a81ead07289ee0f987a99d73a'

data/README.md

@@ -39,12 +39,18 @@ Configuration options for this plugin are in `/etc/foreman-proxy/settings.d/dhcp
 * username: API Username
 * password: API Password
 * record_type: host / fixedaddress (see different record types chapter)
+* used_ips_search_type: record_type / used
 
 ## Different record types
 The main difference between host and fixedaddress is that a host record already includes the dns records. It's an infoblox object that includes dhcp/a record/ptr records. If you use the host objects there is no need to use a dns smart proxy. Everything gets handled inside the dhcp smart proxy. This does however limit functionality. You can't delete conflicting records or you can't change dns names using foreman gui. Beware when editing host objects manually in infoblox, once you delete a host in foreman all associated host objects get deleted.
 
 If you chose to use fixedaddress you'll need to use the infoblox dns smart proxy (https://github.com/theforeman/smart_proxy_dns_infoblox) if you want to manage dns records.
 
+## Used IP search type
+When using "record_type" here, used IPs will be looked up among the record type you select on the record_type setting (host or fixedaddress). So everything which is not a host or a fixedaddress (depending on the setting), will be defined as free and can be selected as an IP to provision a host.
+If the IP is used by just a DNS A entry for example, this can lead to conflicts. If "used" is set here, any usage of an IP will mark it as used and the IP will not be selected as free ip to provision a host.
+Usages without a mac address will get a dummy mac address ("00:00:00:00:00:00"), when Foreman looks for "all_hosts".
+
 ## SSL
 
 The plugin enforces HTTPS server certificate verification. Follow a standard CA cert installation procedure for your operating system. It's possible to either download the server certificate from Infoblox web UI or use openssl command to extract it from server response. Here are example steps for Red Hat compatible systems:

data/config/dhcp_infoblox.yml.example

@@ -13,6 +13,11 @@
 # using "host" setting make sure domain exists in Infoblox.
 :record_type: 'fixedaddress'
 
+# Search type used when looking for used IPs: can be "record_type" or "used". The latter can be used when you want to include all "USED"
+# IPs in the search for used IPs, so that only really "UNUSED" (no Host, no DNS object, no DHCP Range, not unmanaged, etc.) are used, when
+# searching for a unused IP. Defaults to "record_type", which uses the record_type selected above to look for used IPs.
+#:used_ips_search_type: 'record_type'
+
 # View used for fixedaddress record type.
 #:network_view: 'default'
 

data/lib/smart_proxy_dhcp_infoblox/common_crud.rb

@@ -10,8 +10,9 @@ module ::Proxy::DHCP::Infoblox
 
     attr_reader :connection
 
-    def initialize(connection)
+    def initialize(connection, used_ips_search_type)
       @connection = connection
+      @used_ips_search_type = used_ips_search_type
     end
 
     def all_leases(network_address, subnet)
@@ -19,6 +20,7 @@ module ::Proxy::DHCP::Infoblox
       ::Infoblox::Lease.find(@connection, 'address~' => address_range_regex).map do |lease|
         # Infoblox can return MAC address set to nil
         next unless lease.hardware
+
         Proxy::DHCP::Lease.new(
           lease.client_hostname,
           lease.address,
@@ -34,6 +36,7 @@ module ::Proxy::DHCP::Infoblox
 
     def find_record(subnet_address, an_address)
       return find_record_by_ip(subnet_address, an_address) if Resolv::IPv4::Regex =~ an_address
+
       find_record_by_mac(subnet_address, an_address)
     end
 
@@ -58,19 +61,23 @@ module ::Proxy::DHCP::Infoblox
       if options[:mac] != existing_host.mac || options[:hostname] != existing_name
         raise Proxy::DHCP::Collision, "Record #{options[:ip]} conflicts with an existing record."
       end
+
       raise Proxy::DHCP::AlreadyExists, "Record #{options[:ip]} already exists."
     end
 
     def del_record(_, record)
       raise InvalidRecord, "#{record} is static - unable to delete" unless record.deleteable?
+
       found = find_hosts('ipv4addr' => record.ip).first
       return if found.nil?
+
       found.delete
     end
 
     def del_records_by_ip(ip_address)
       found = find_hosts({ 'ipv4addr' => ip_address }, 2147483646)
       return if found.empty?
+
       found.each { |record| record.delete }
       nil
     end
@@ -78,6 +85,7 @@ module ::Proxy::DHCP::Infoblox
     def del_record_by_mac(mac_address)
       found = find_hosts('mac' => mac_address).first
       return if found.nil?
+
       found.delete
       nil
     end
@@ -90,11 +98,13 @@ module ::Proxy::DHCP::Infoblox
 
       opts = { :hostname => name }
       opts[:deleteable] = true
-      # TODO: nextserver, use_nextserver, bootfile, and use_bootfile attrs exist but are not available in the Fixedaddress model
+      # TODO: nextserver, use_nextserver, bootfile, and use_bootfile attrs exist
+      # but are not available in the Fixedaddress model
       # Might be useful to extend the model to include these
       opts[:nextServer] = host.nextserver if (host.respond_to?(:use_nextserver) && host.use_nextserver)
       opts[:filename] = host.bootfile if (host.respond_to?(:use_bootfile) && host.use_bootfile)
-      subnet = ::Proxy::DHCP::Subnet.new(full_subnet_address.split('/').first, cidr_to_ip_mask(cidr_to_i(full_subnet_address.split('/').last)))
+      subnet = ::Proxy::DHCP::Subnet.new(full_subnet_address.split('/').first,
+                                         cidr_to_ip_mask(cidr_to_i(full_subnet_address.split('/').last)))
 
       Proxy::DHCP::Reservation.new(name, host.ipv4addr, host.mac, subnet, opts)
     end

data/lib/smart_proxy_dhcp_infoblox/dhcp_infoblox_main.rb

@@ -93,6 +93,7 @@ module Proxy::DHCP::Infoblox
       network = ::Infoblox::Network.find(connection, 'network' => network_address, 'network_view' => network_view,
                                          '_max_results' => 1).first
       raise "Subnet #{network_address} not found in network view #{network_view}" if network.nil?
+
       network
     end
 

data/lib/smart_proxy_dhcp_infoblox/dhcp_infoblox_plugin.rb

@@ -3,20 +3,21 @@ module Proxy::DHCP::Infoblox
     plugin :dhcp_infoblox, ::Proxy::DHCP::Infoblox::VERSION
 
     default_settings :record_type => 'fixedaddress',
-        :dns_view => "default",
-        :network_view => "default",
-        :blacklist_duration_minutes => 30 * 60,
-        :wait_after_restart => 10,
-        :options => []
+                     :used_ips_search_type => "record_type",
+                     :dns_view => "default",
+                     :network_view => "default",
+                     :blacklist_duration_minutes => 30 * 60,
+                     :wait_after_restart => 10,
+                     :options => []
 
     validate_presence :username, :password
 
-    requires :dhcp, '>= 1.13'
+    requires :dhcp, '>= 3.2'
 
     load_classes ::Proxy::DHCP::Infoblox::PluginConfiguration
-    load_validators :record_type_validator => ::Proxy::DHCP::Infoblox::RecordTypeValidator
     load_dependency_injection_wirings ::Proxy::DHCP::Infoblox::PluginConfiguration
 
-    validate :record_type, :record_type_validator => true
+    validate :record_type, enum: %w[host fixedaddress]
+    validate :used_ips_search_type, enum: %w[record_type used]
   end
 end

data/lib/smart_proxy_dhcp_infoblox/dhcp_infoblox_version.rb

@@ -1,7 +1,7 @@
 module Proxy
   module DHCP
     module Infoblox
-      VERSION = '0.0.16'.freeze
+      VERSION = '0.0.17'.freeze
     end
   end
 end

data/lib/smart_proxy_dhcp_infoblox/fixed_address_crud.rb

@@ -5,28 +5,54 @@ module ::Proxy::DHCP::Infoblox
   class FixedAddressCRUD < CommonCRUD
     attr_reader :network_view
 
-    def initialize(connection, network_view)
+    def initialize(connection, network_view, used_ips_search_type)
       @memoized_hosts = []
       @memoized_condition = nil
       @network_view = network_view
-      super(connection)
+      super(connection, used_ips_search_type)
     end
 
     def all_hosts(subnet_address)
-      network = ::Infoblox::Fixedaddress.find(@connection, 'network' => subnet_address, 'network_view' => network_view,
-                                              '_max_results' => 2147483646) #2**(32-cidr_to_i(subnet_address)))
+      if @used_ips_search_type == 'used'
+        addresses = ::Infoblox::Ipv4address.find(
+          @connection,
+          'network' => subnet_address,
+          'status' => 'USED',
+          '_max_results' => 2147483646)
+        network = addresses.map do |address|
+          if address.mac_address.nil? || address.mac_address.empty?
+            checked_mac = '00:00:00:00:00:00'
+          else
+            checked_mac = address.mac_address
+          end
+          ::Infoblox::Fixedaddress.new(
+            :name => address.names[0],
+            :ipv4addr => address.ip_address,
+            :mac => checked_mac
+          )
+        end
+      else
+        network = ::Infoblox::Fixedaddress.find(
+          @connection,
+          'network' => subnet_address,
+          'network_view' => network_view,
+          '_max_results' => 2147483646) #2**(32-cidr_to_i(subnet_address)))
+      end
+
       network.map { |h| build_reservation(h.name, h, subnet_address) }.compact
     end
 
     def find_record_by_ip(subnet_address, ip_address)
       found = find_hosts('ipv4addr' => ip_address).first
       return nil if found.nil?
+
       build_reservation(found.name, found, subnet_address)
     end
 
     def find_records_by_ip(subnet_address, ip_address)
       found = find_hosts({ 'ipv4addr' => ip_address }, 2147483646)
       return [] if found.empty?
+
       to_return = found.map { |record| build_reservation(record.name, record, subnet_address) }
       to_return.compact
     end
@@ -34,11 +60,13 @@ module ::Proxy::DHCP::Infoblox
     def find_record_by_mac(subnet_address, mac_address)
       found = find_hosts('mac' => mac_address).first
       return nil if found.nil?
+
       build_reservation(found.name, found, subnet_address)
     end
 
     def find_hosts(condition, max_results = 1)
       return @memoized_hosts if (!@memoized_hosts.empty? && @memoized_condition = condition)
+
       @memoized_condition = condition
       @memoized_hosts = ::Infoblox::Fixedaddress.find(@connection, condition.merge('_max_results' => max_results,
                                                                                    'network_view' => network_view))

data/lib/smart_proxy_dhcp_infoblox/host_ipv4_address_crud.rb

@@ -5,42 +5,70 @@ module ::Proxy::DHCP::Infoblox
   class HostIpv4AddressCRUD < CommonCRUD
     attr_reader :dns_view
 
-    def initialize(connection, dns_view)
+    def initialize(connection, dns_view, used_ips_search_type)
       @memoized_hosts = []
       @memoized_condition = nil
       @dns_view = dns_view
-      super(connection)
+      super(connection, used_ips_search_type)
     end
 
     def all_hosts(subnet_address)
       address_range_regex = NetworkAddressesRegularExpressionGenerator.new.generate_regex(subnet_address)
 
-      hosts = ::Infoblox::Host.find(
-        @connection,
+      if @used_ips_search_type == 'used'
+        addresses = ::Infoblox::Ipv4address.find(
+          @connection,
+          'network' => subnet_address,
+          'status' => 'USED',
+          '_max_results' => 2147483646
+        )
+        hosts = addresses.map do |address|
+          if address.mac_address.nil? || address.mac_address.empty?
+            checked_mac = '00:00:00:00:00:00'
+          else
+            checked_mac = address.mac_address
+          end
+          ::Infoblox::Host.new(
+            :name => address.names[0],
+            :ipv4addrs => [{ :name => address.names[0], :ipv4addr => address.ip_address, :mac => checked_mac,
+                             :configure_for_dhcp => true }]
+          )
+        end
+      else
+        hosts = ::Infoblox::Host.find(
+          @connection,
           'ipv4addr~' => address_range_regex,
           'view' => dns_view,
-          '_max_results' => 2147483646)
+          '_max_results' => 2147483646
+        )
+      end
 
       ip_addr_matcher = Regexp.new(address_range_regex) # pre-compile the regex
-      hosts.map { |host| build_reservation(host.name, host.ipv4addrs.find { |ip| ip_addr_matcher =~ ip.ipv4addr }, subnet_address) }.compact
+      hosts.map do |host|
+        build_reservation(host.name, host.ipv4addrs.find { |ip| ip_addr_matcher =~ ip.ipv4addr }, subnet_address)
+      end.compact
     end
 
     def find_record_by_ip(subnet_address, ip_address)
       found = find_hosts('ipv4addr' => ip_address).first
       return nil if found.nil?
+
       build_reservation(found.name, found.ipv4addrs.find { |ip| ip.ipv4addr == ip_address }, subnet_address)
     end
 
     def find_records_by_ip(subnet_address, ip_address)
       found = find_hosts({ 'ipv4addr' => ip_address }, 2147483646)
       return [] if found.empty?
-      to_return = found.map { |record| build_reservation(record.name, record.ipv4addrs.find { |ip| ip.ipv4addr == ip_address }, subnet_address) }
-      to_return.compact
+
+      found.map do |record|
+        build_reservation(record.name, record.ipv4addrs.find { |ip| ip.ipv4addr == ip_address }, subnet_address)
+      end.compact
     end
 
     def find_record_by_mac(subnet_address, mac_address)
       found = find_hosts('mac' => mac_address).first
       return nil if found.nil?
+
       build_reservation(found.name, found.ipv4addrs.find { |ip| ip.mac == mac_address }, subnet_address)
     end
 
@@ -51,6 +79,7 @@ module ::Proxy::DHCP::Infoblox
 
     def find_hosts(condition, max_results = 1)
       return @memoized_hosts if (!@memoized_hosts.empty? && @memoized_condition == condition)
+
       @memoized_condition = condition
       @memoized_hosts = ::Infoblox::Host.find(@connection, condition.merge('view' => dns_view,
                                                                            '_max_results' => max_results))

data/lib/smart_proxy_dhcp_infoblox/ip_address_arithmetic.rb

@@ -1,20 +1,20 @@
 module ::Proxy::DHCP::Infoblox
   module IpAddressArithmetic
     def cidr_to_ip_mask(prefix_length)
-      bitmask = 0xFFFFFFFF ^ (2**(32 - prefix_length) - 1)
-      (0..3).map { |i| (bitmask >> i * 8) & 0xFF }.reverse.join('.')
+      bitmask = 0xFFFFFFFF ^ ((2**(32 - prefix_length)) - 1)
+      (0..3).map { |i| (bitmask >> (i * 8)) & 0xFF }.reverse.join('.')
     end
 
     def ipv4_to_i(an_address)
       an_address.split('.').inject(0) { |a, c| (a << 8) + c.to_i }
     end
 
-    def i_to_ipv4(i)
+    def i_to_ipv4(i) # rubocop:todo Naming/MethodParameterName
       (0..3).inject([]) { |a, c| a.push((i >> (c * 8)) & 0xFF) }.reverse.join('.')
     end
 
     def cidr_to_bitmask(prefix_length)
-      0xFFFFFFFF ^ (2**(32 - prefix_length) - 1)
+      0xFFFFFFFF ^ ((2**(32 - prefix_length)) - 1)
     end
 
     def cidr_to_i(an_address_with_cidr)

data/lib/smart_proxy_dhcp_infoblox/network_address_range_regex_generator.rb

@@ -12,6 +12,7 @@ module ::Proxy::DHCP::Infoblox
 
       def add_children(values)
         return if values.empty?
+
         node = (found = children.find { |n| n.value == values.first }).nil? ? add_child(Node.new(values.first)) : found
         node.add_children(values[1..-1])
       end
@@ -21,6 +22,7 @@ module ::Proxy::DHCP::Infoblox
         return 1 if other.value.to_s == '0?'
         return 0 if value == other.value
         return -1 if value < other.value
+
         1
       end
 
@@ -33,9 +35,13 @@ module ::Proxy::DHCP::Infoblox
       def group_children
         children.each { |n| n.group_children }
         return if children.size < 2
+
         @children = children[1..-1].each_with_object([MergedNode.new(children.first)]) do |to_group, grouped|
           current = MergedNode.new(to_group)
-          found = grouped.find { |g| ((g.value != ['0?'] && current.value != ['0?']) || (current.value == ['0?'] && g.value == ['0?'])) && (g.children == current.children) }
+          found = grouped.find do |g|
+            ((g.value != ['0?'] && current.value != ['0?']) || (current.value == ['0?'] && g.value == ['0?'])) && \
+              (g.children == current.children)
+          end
           found.nil? ? grouped.push(current) : found.merge(current)
         end
       end
@@ -47,6 +53,7 @@ module ::Proxy::DHCP::Infoblox
 
     class MergedNode
       attr_accessor :value, :children
+
       def initialize(a_node)
         @value = [a_node.value].flatten
         @children = a_node.children
@@ -62,11 +69,12 @@ module ::Proxy::DHCP::Infoblox
       end
 
       def value_as_regex
-        (value.size < 2) ? value.first.to_s : "[#{value.join('')}]"
+        (value.size < 2) ? value.first.to_s : "[#{value.join}]"
       end
 
       def ==(other)
         return false if self.class != other.class
+
         value == other.value
       end
     end

data/lib/smart_proxy_dhcp_infoblox/plugin_configuration.rb

@@ -10,27 +10,34 @@ module Proxy::DHCP::Infoblox
       require 'smart_proxy_dhcp_infoblox/dhcp_infoblox_main'
     end
 
-    def load_dependency_injection_wirings(c, settings)
+    def load_dependency_injection_wirings(c, settings) # rubocop:todo Naming/MethodParameterName
       c.dependency :connection, (lambda {
         ::Infoblox.wapi_version = '2.0'
         ::Infoblox::Connection.new(:username => settings[:username], :password => settings[:password],
-                                   :host => settings[:server], :ssl_opts => { :verify => !ENV['FOREMAN_INFOBLOX_NOSSLVERIFY'] },
+                                   :host => settings[:server],
+                                   :ssl_opts => { :verify => !ENV['FOREMAN_INFOBLOX_NOSSLVERIFY'] },
                                    :logger => ::Proxy::LogBuffer::Decorator.instance)
       })
 
       c.singleton_dependency :unused_ips, lambda { ::Proxy::DHCP::FreeIps.new(settings[:blacklist_duration_minutes]) }
 
       c.dependency :host_ipv4_crud, (lambda {
-        ::Proxy::DHCP::Infoblox::HostIpv4AddressCRUD.new(c.get_dependency(:connection), settings[:dns_view])
+        ::Proxy::DHCP::Infoblox::HostIpv4AddressCRUD.new(
+          c.get_dependency(:connection),
+          settings[:dns_view],
+          settings[:used_ips_search_type])
       })
       c.dependency :fixed_address_crud, (lambda {
-        ::Proxy::DHCP::Infoblox::FixedAddressCRUD.new(c.get_dependency(:connection), settings[:network_view])
+        ::Proxy::DHCP::Infoblox::FixedAddressCRUD.new(
+          c.get_dependency(:connection),
+          settings[:network_view],
+          settings[:used_ips_search_type])
       })
       c.dependency :grid_restart, lambda { ::Proxy::DHCP::Infoblox::GridRestart.new(c.get_dependency(:connection)) }
       c.dependency :dhcp_provider, (lambda {
         ::Proxy::DHCP::Infoblox::Provider.new(
           c.get_dependency(:connection),
-          (settings[:record_type] == 'host') ? c.get_dependency(:host_ipv4_crud) : c.get_dependency(:fixed_address_crud),
+          c.get_dependency(settings[:record_type] == 'host' ? :host_ipv4_crud : :fixed_address_crud),
           c.get_dependency(:grid_restart),
           c.get_dependency(:unused_ips),
           settings[:subnets],

data/lib/smart_proxy_dhcp_infoblox.rb

@@ -5,6 +5,5 @@ module Proxy
 end
 
 require 'smart_proxy_dhcp_infoblox/plugin_configuration'
-require 'smart_proxy_dhcp_infoblox/record_type_validator'
 require 'smart_proxy_dhcp_infoblox/dhcp_infoblox_version'
 require 'smart_proxy_dhcp_infoblox/dhcp_infoblox_plugin'

data/test/host_and_fixedaddress_crud_test.rb

@@ -93,7 +93,7 @@ class HostCrudTest < Test::Unit::TestCase
   def setup
     @connection = Object.new
     @view = "something"
-    @crud = ::Proxy::DHCP::Infoblox::HostIpv4AddressCRUD.new(@connection, @view)
+    @crud = ::Proxy::DHCP::Infoblox::HostIpv4AddressCRUD.new(@connection, @view, 'record_type')
 
     @entity = ::Infoblox::Host
 
@@ -115,17 +115,50 @@ class HostCrudTest < Test::Unit::TestCase
       :ipv4addrs => [{ :ipv4addr => @ip, :mac => '00:01:02:03:05:07', :nextserver => @nextserver, :use_nextserver => true,
                       :bootfile => @filename, :use_bootfile => true, :configure_for_dhcp => true }])
 
+    @ipv4address = ::Infoblox::Ipv4address.new(
+      :names => [@hostname],
+      :ip_address => @ip,
+      :mac_address => @mac
+    )
+
+    @ipv4address_dnsonly = ::Infoblox::Ipv4address.new(
+      :names => ['dnsonly.test.com'],
+      :ip_address => '192.168.42.2',
+      :mac_address => ''
+    )
+
     @reservation = ::Proxy::DHCP::Reservation.new(@hostname, @ip, @mac, ::Proxy::DHCP::Subnet.new(@subnet_ip, '255.255.255.0'),
                                                   :hostname => @hostname, :nextServer => @nextserver, :filename => @filename,
                                                   :deleteable => true)
+
+    @reservation_without_opts = ::Proxy::DHCP::Reservation.new(@hostname, @ip, @mac, ::Proxy::DHCP::Subnet.new(@subnet_ip, '255.255.255.0'),
+                                                             :hostname => @hostname, :deleteable => true)
+
+    @reservation_dnsonly = ::Proxy::DHCP::Reservation.new('dnsonly.test.com', '192.168.42.2', '00:00:00:00:00:00',
+                                                        ::Proxy::DHCP::Subnet.new(@subnet_ip, '255.255.255.0'),
+                                                        :hostname => 'dnsonly.test.com', :deleteable => true)
   end
 
-  def test_all_hosts
+  def test_all_hosts_with_find_by_record_type
     ::Infoblox::Host.expects(:find).with(@connection, 'ipv4addr~' => '192\.168\.42\..+', 'view' => @view,
                                          '_max_results' => 2147483646).returns([@host])
     assert_equal @reservation, @crud.all_hosts('192.168.42.0/24').first
   end
 
+  def test_all_hosts_with_find_by_used
+    @crud_used = ::Proxy::DHCP::Infoblox::HostIpv4AddressCRUD.new(@connection, @view, 'used')
+    ::Infoblox::Ipv4address.expects(:find).with(@connection, 'network' => '192.168.42.0/24', 'status' => 'USED',
+                                         '_max_results' => 2147483646).returns([@ipv4address])
+    assert_equal @reservation_without_opts, @crud_used.all_hosts('192.168.42.0/24').first
+  end
+
+  def test_all_hosts_with_find_by_used_dns_record_creates_reservation
+    @crud_dnsonly = ::Proxy::DHCP::Infoblox::HostIpv4AddressCRUD.new(@connection, @view, 'used')
+    ::Infoblox::Ipv4address.expects(:find).with(@connection, 'network' => '192.168.42.0/24', 'status' => 'USED',
+                                                '_max_results' => 2147483646).returns([@ipv4address_dnsonly])
+    assert_equal @reservation_dnsonly, @crud_dnsonly.all_hosts('192.168.42.0/24').first
+  end
+
   def test_build_host
     built = @crud.build_host(:hostname => @hostname, :mac => @mac, :ip => @ip, :nextServer => @nextserver,
                              :filename => @filename, :deleteable => true)
@@ -166,7 +199,7 @@ class FixedaddressCrudTest < Test::Unit::TestCase
   def setup
     @connection = Object.new
     @network_view = "something"
-    @crud = ::Proxy::DHCP::Infoblox::FixedAddressCRUD.new(@connection, @network_view)
+    @crud = ::Proxy::DHCP::Infoblox::FixedAddressCRUD.new(@connection, @network_view, 'record_type')
 
     @entity = ::Infoblox::Fixedaddress
 
@@ -184,16 +217,49 @@ class FixedaddressCrudTest < Test::Unit::TestCase
       :name => 'another.test.com',
       :ipv4addr => @ip, :mac => '00:01:02:03:05:07', :network_view => @network_view)
 
+    @ipv4address = ::Infoblox::Ipv4address.new(
+      :names => [@hostname],
+      :ip_address => @ip,
+      :mac_address => @mac
+    )
+
+    @ipv4address_dnsonly = ::Infoblox::Ipv4address.new(
+      :names => ['dnsonly.test.com'],
+      :ip_address => '192.168.42.2',
+      :mac_address => ''
+    )
+
     @reservation = ::Proxy::DHCP::Reservation.new(@hostname, @ip, @mac, ::Proxy::DHCP::Subnet.new(@subnet_ip, '255.255.255.0'),
                                                   :deleteable => true, :hostname => @hostname)
+
+    @reservation_without_opts = ::Proxy::DHCP::Reservation.new(@hostname, @ip, @mac, ::Proxy::DHCP::Subnet.new(@subnet_ip, '255.255.255.0'),
+                                                             :hostname => @hostname, :deleteable => true)
+
+    @reservation_dnsonly = ::Proxy::DHCP::Reservation.new('dnsonly.test.com', '192.168.42.2', '00:00:00:00:00:00',
+                                                        ::Proxy::DHCP::Subnet.new(@subnet_ip, '255.255.255.0'),
+                                                        :hostname => 'dnsonly.test.com', :deleteable => true)
   end
 
-  def test_all_hosts
+  def test_all_hosts_with_find_by_record_type
     ::Infoblox::Fixedaddress.expects(:find).with(@connection, 'network' => '192.168.42.0/24', 'network_view' => @network_view,
                                                  '_max_results' => 2147483646).returns([@host])
     assert_equal @reservation, @crud.all_hosts('192.168.42.0/24').first
   end
 
+  def test_all_hosts_with_find_by_used
+    @crud_used = ::Proxy::DHCP::Infoblox::FixedAddressCRUD.new(@connection, @network_view, 'used')
+    ::Infoblox::Ipv4address.expects(:find).with(@connection, 'network' => '192.168.42.0/24', 'status' => 'USED',
+                                                '_max_results' => 2147483646).returns([@ipv4address])
+    assert_equal @reservation_without_opts, @crud_used.all_hosts('192.168.42.0/24').first
+  end
+
+  def test_all_hosts_with_find_by_used_dns_record_creates_reservation
+    @crud_dnsonly = ::Proxy::DHCP::Infoblox::FixedAddressCRUD.new(@connection, @network_view, 'used')
+    ::Infoblox::Ipv4address.expects(:find).with(@connection, 'network' => '192.168.42.0/24', 'status' => 'USED',
+                                                '_max_results' => 2147483646).returns([@ipv4address_dnsonly])
+    assert_equal @reservation_dnsonly, @crud_dnsonly.all_hosts('192.168.42.0/24').first
+  end
+
   def test_build_host
     built = @crud.build_host(:hostname => @hostname, :mac => @mac, :ip => @ip, :nextServer => @nextserver,
                              :filename => @filename, :deleteable => true)

data/test/infoblox_provider_test.rb

@@ -12,6 +12,7 @@ class InfobloxProviderTest < Test::Unit::TestCase
     @unused_ips = Object.new
     @managed_subnets = nil
     @network_view = "another"
+    @used_ips_search_type = 'record_type'
 
     @network = Infoblox::Network.new(:network => '192.168.42.0/24')
     @subnet = ::Proxy::DHCP::Subnet.new('192.168.42.0', '255.255.255.0')
@@ -42,7 +43,7 @@ class InfobloxProviderTest < Test::Unit::TestCase
   end
 
   def test_leases
-    @crud = ::Proxy::DHCP::Infoblox::CommonCRUD.new(@connection)
+    @crud = ::Proxy::DHCP::Infoblox::CommonCRUD.new(@connection, @used_ips_search_type)
     @provider = Proxy::DHCP::Infoblox::Provider.new(@connection, @crud, @restart_grid,
                                                     @unused_ips, @managed_subnets, @network_view)
 
@@ -52,7 +53,7 @@ class InfobloxProviderTest < Test::Unit::TestCase
   end
 
   def test_nonclass_leases
-    @crud = ::Proxy::DHCP::Infoblox::CommonCRUD.new(@connection)
+    @crud = ::Proxy::DHCP::Infoblox::CommonCRUD.new(@connection,@used_ips_search_type)
     @provider = Proxy::DHCP::Infoblox::Provider.new(@connection, @crud, @restart_grid,
                                                     @unused_ips, @managed_subnets, @network_view)
 

data/test/plugin_configuration_test.rb

@@ -3,7 +3,6 @@ require 'infoblox'
 require 'dhcp_common/dhcp_common'
 require 'dhcp_common/free_ips'
 require 'smart_proxy_dhcp_infoblox/plugin_configuration'
-require 'smart_proxy_dhcp_infoblox/record_type_validator'
 require 'smart_proxy_dhcp_infoblox/dhcp_infoblox_plugin'
 require 'smart_proxy_dhcp_infoblox/host_ipv4_address_crud'
 require 'smart_proxy_dhcp_infoblox/fixed_address_crud'
@@ -13,6 +12,7 @@ require 'smart_proxy_dhcp_infoblox/dhcp_infoblox_main'
 class PluginDefaultConfigurationTest < Test::Unit::TestCase
   def test_default_settings
     assert_equal({ :record_type => 'fixedaddress',
+      :used_ips_search_type => "record_type",
       :blacklist_duration_minutes => 30 * 60,
       :wait_after_restart => 10,
       :dns_view => "default",
@@ -27,8 +27,8 @@ class InfobloxDhcpProductionWiringTest < Test::Unit::TestCase
     @network_view = "network_view"
     @dns_view = "dns_view"
     @settings = { :username => 'user', :password => 'password', :server => '127.0.0.1', :record_type => 'fixedaddress',
-                 :subnets => ['1.1.1.0/255.255.255.0'], :blacklist_duration_minutes => 300, :wait_after_restart => 1,
-                 :dns_view => @dns_view, :network_view => @network_view }
+                 :used_ips_search_type => 'record_type', :subnets => ['1.1.1.0/255.255.255.0'], :blacklist_duration_minutes => 300,
+                 :wait_after_restart => 1,:dns_view => @dns_view, :network_view => @network_view }
     @container = ::Proxy::DependencyInjection::Container.new
     Proxy::DHCP::Infoblox::PluginConfiguration.new.load_dependency_injection_wirings(@container, @settings)
   end
@@ -76,8 +76,8 @@ class InfobloxDhcpProductionWiringTest < Test::Unit::TestCase
 
   def test_provider_configuration_with_fixedaddress_crud
     Proxy::DHCP::Infoblox::PluginConfiguration.new.
-      load_dependency_injection_wirings(@container, :username => 'user', :password => 'password',
-                                          :server => '127.0.0.1', :record_type => 'fixed_address')
+      load_dependency_injection_wirings(@container, :username => 'user', :password => 'password', :server => '127.0.0.1',
+                                        :record_type => 'fixed_address', :used_ips_search_type => 'record_type')
 
     provider = @container.get_dependency(:dhcp_provider)
     assert provider.crud.instance_of?(::Proxy::DHCP::Infoblox::FixedAddressCRUD)

data/test/test_helper.rb

@@ -1,5 +1,5 @@
 require 'test/unit'
-require 'mocha/setup'
+require 'mocha/test_unit'
 
 require 'smart_proxy_for_testing'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_dhcp_infoblox
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.0.17
 platform: ruby
 authors:
 - Klaas Demter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-04 00:00:00.000000000 Z
+date: 2022-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: infoblox
@@ -24,20 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.50.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.50.0
 description: Infoblox DHCP provider plugin for Foreman's smart proxy
 email:
 - demter@atix.de
@@ -60,12 +46,10 @@ files:
 - lib/smart_proxy_dhcp_infoblox/ip_address_arithmetic.rb
 - lib/smart_proxy_dhcp_infoblox/network_address_range_regex_generator.rb
 - lib/smart_proxy_dhcp_infoblox/plugin_configuration.rb
-- lib/smart_proxy_dhcp_infoblox/record_type_validator.rb
 - test/host_and_fixedaddress_crud_test.rb
 - test/infoblox_provider_test.rb
 - test/integration_test.rb
 - test/plugin_configuration_test.rb
-- test/record_type_validator_test.rb
 - test/regex_generator_test.rb
 - test/test_helper.rb
 - test/unused_ip_test.rb
@@ -81,23 +65,22 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: Infoblox DHCP provider plugin for Foreman's smart proxy
 test_files:
-- test/test_helper.rb
+- test/host_and_fixedaddress_crud_test.rb
 - test/infoblox_provider_test.rb
+- test/integration_test.rb
 - test/plugin_configuration_test.rb
-- test/record_type_validator_test.rb
-- test/unused_ip_test.rb
-- test/host_and_fixedaddress_crud_test.rb
 - test/regex_generator_test.rb
-- test/integration_test.rb
+- test/test_helper.rb
+- test/unused_ip_test.rb

data/lib/smart_proxy_dhcp_infoblox/record_type_validator.rb

@@ -1,8 +0,0 @@
-module ::Proxy::DHCP::Infoblox
-  class RecordTypeValidator < ::Proxy::PluginValidators::Base
-    def validate!(settings)
-      return true if ['host', 'fixedaddress'].include?(settings[:record_type])
-      raise ::Proxy::Error::ConfigurationError, "Setting 'record_type' can be set to either 'host' or 'fixedaddress'"
-    end
-  end
-end

data/test/record_type_validator_test.rb

@@ -1,20 +0,0 @@
-require 'test_helper'
-require 'smart_proxy_dhcp_infoblox/record_type_validator'
-
-class RecordTypeValidatorTest < Test::Unit::TestCase
-  def setup
-    @validator = ::Proxy::DHCP::Infoblox::RecordTypeValidator.new(:dhcp_infoblox, :record_type, nil, nil)
-  end
-
-  def test_should_pass_when_record_type_is_host
-    assert @validator.validate!(:record_type => 'host')
-  end
-
-  def test_should_pass_when_record_type_is_fixedaddress
-    assert @validator.validate!(:record_type => 'fixedaddress')
-  end
-
-  def test_should_raise_exception_when_record_type_is_unrecognised
-    assert_raises(::Proxy::Error::ConfigurationError) { @validator.validate!(:record_type => '') }
-  end
-end