smart_proxy_dhcp_infoblox 0.0.5 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1f93a00fc3b3226cd13507406635a76d39fdf5bf
-  data.tar.gz: 2af103b766051daba129f8a05918f704692f7362
+SHA256:
+  metadata.gz: 644a754d3e910db7479ae0a9bb5329dcb9c690af8c25ce1eba5a92425855f397
+  data.tar.gz: cb1a382785eb1accea703a945b187aa83cb74184ca06194829969d1d33b915a5
 SHA512:
-  metadata.gz: 629785c6c921e5a356af8ab70703bc13d9db487dc3b4cdc2fb24ab1ff320d620e67b6762ff557a400cc1a77b4a73e7d7817c07591160e6d3de4011cf65abef48
-  data.tar.gz: 442344c94cb0cf17e7e8915139149be7f50c545d771e570dcc7ae921c8ae98649a2f207c72e2c91c66bfdfc655fe73ab8b1b3a9ff1191c7ed2ecf470a4118fb7
+  metadata.gz: 07c4763058d119b947ff381d9977090aebd9365d556ad9ca61ede8e85f2f5191b214a4d6254ea042730cf85893df69c3040d67d7c91309148fdddc44946c6b6f
+  data.tar.gz: 1ab4070a4260f0e97ee442c50fb3e7eccf92c44b5afc75484ef300cfb222b8d536d21815475fdabd555ddabd6c05d12795f588e980100a796c5ccc0b52fea3c3

data/README.md

@@ -9,6 +9,19 @@ for how to install Smart Proxy plugins
 
 This plugin is compatible with Smart Proxy 1.11 or higher.
 
+Example installation command via foreman-installer:
+
+```
+# foreman-installer --enable-foreman-proxy-plugin-dhcp-infoblox \
+--foreman-proxy-dhcp-provider infoblox \
+--foreman-proxy-plugin-dhcp-infoblox-record-type host \
+--foreman-proxy-dhcp-server 192.168.201.2 \
+--foreman-proxy-plugin-dhcp-infoblox-username admin \
+--foreman-proxy-plugin-dhcp-infoblox-password infoblox \
+--foreman-proxy-plugin-dhcp-infoblox-network-view default \
+--foreman-proxy-plugin-dhcp-infoblox-dns-view default
+```
+
 When installing using "gem", make sure to install the bundle file:
 
     echo "gem 'smart_proxy_dhcp_infoblox'" > /usr/share/foreman-proxy/bundler.d/dhcp_infoblox.rb
@@ -24,15 +37,57 @@ To enable this DHCP provider, edit `/etc/foreman-proxy/settings.d/dhcp.yml` and
 Configuration options for this plugin are in `/etc/foreman-proxy/settings.d/dhcp_infoblox.yml` and include:
 
 * username: API Username
-* passowrd: API Password
+* password: API Password
 * record_type: host / fixedaddress (see different record types chapter)
-* use_range: use infoblox ranges (true) or infoblox networks (false) to find the next free ip in your infoblox
+* 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:
+
+```
+# update-ca-trust enable
+# openssl s_client -showcerts -connect 192.168.201.2:443 </dev/null | openssl x509 -text >/etc/pki/ca-trust/source/anchors/infoblox.crt
+# update-ca-trust extract
+```
+
+For Debian-compatible systems:
+
+```
+# openssl s_client -showcerts -connect 192.168.201.2:443 </dev/null | openssl x509 -text >/usr/local/share/ca-certificates/infoblox.crt
+# update-ca-certificates
+```
+
+To test the CA certificate, a simple curl query can be used. This is a positive test:
+
+```
+# curl -u admin:infoblox https://192.168.201.2/wapi/v2.0/network
+[
+    {
+        "_ref": "network/ZG5zLm5ldHdvcmskMTkyLjE2OC4yMDIuMC8yNC8w:192.168.202.0/24/default",
+        "network": "192.168.202.0/24",
+        "network_view": "default"
+    }
+]
+```
+
+And a negative one:
+
+```
+# curl -u admin:infoblox https://192.168.201.2/wapi/v2.0/network
+curl: (60) SSL certificate problem: self signed certificate
+```
+
 ## Contributing
 
 Fork and send a Pull Request. Thanks!

data/config/dhcp_infoblox.yml.example

@@ -1,17 +1,38 @@
 ---
-#
 # Configuration file for 'dhcp_infoblox' dhcp provider
 #
-# use :server setting in dhcp.yml if you are managing a dhcp server which is not localhost
-# use :subnets setting in dhcp.yml if you want to restrict subnets available to smart-proxy
-#
-:username: "infoblox"
+# Use :server setting in dhcp.yml if you are managing a dhcp server which is not localhost.
+# Use :subnets setting in dhcp.yml if you want to restrict subnets available to smart-proxy.
+
+# Credentials for Infoblox API, make sure the DHCP Role is assigned
+:username: "admin"
 :password: "infoblox"
-#
-# Record type to manage: can be "host" or "fixed_address"
-#
-:record_type: 'host'
-#
-# Use  pre-definded ranges in networks to find available IP's
-#
-:use_ranges: false
+
+# Record type to manage: can be "host" or "fixedaddress". The latter is recommended as
+# "host" setting will cause conflicts when using Infoblox DNS smart proxy plugin. When
+# 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'
+
+# View used for host record type, usually 'default.myview' for custom names.
+#:dns_view: 'default'
+
+# Number of seconds to wait after successful Grid restart (make sure to increase Foreman and CLI timeouts).
+# Set to 0 to disable the delay.
+#:wait_after_restart: 10
+
+# DHCP custom options (name, num, value and vendor_class). Set to blank to ignore.
+# This is only used for 'fixedaddress' record types.
+#:options:
+  #-
+    #name: "DHCP option name"
+    #num: 1234
+    #value: "A value"
+    #vendor_class: "A vendor class"

data/lib/smart_proxy_dhcp_infoblox/common_crud.rb

@@ -1,5 +1,6 @@
 require 'resolv'
 require 'smart_proxy_dhcp_infoblox/ip_address_arithmetic'
+require 'smart_proxy_dhcp_infoblox/network_address_range_regex_generator'
 require "proxy/validations"
 
 module ::Proxy::DHCP::Infoblox
@@ -9,16 +10,33 @@ 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)
-      [] # infoblox doesn't support leases
+    def all_leases(network_address, subnet)
+      address_range_regex = NetworkAddressesRegularExpressionGenerator.new.generate_regex(network_address)
+      ::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,
+          lease.hardware,
+          subnet,
+          lease.starts,
+          lease.ends,
+          lease.binding_state,
+          :hostname => lease.client_hostname
+        )
+      end.compact
     end
 
     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
 
@@ -43,14 +61,33 @@ 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_host('ipv4addr' => record.ip)
+
+      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
+
+    def del_record_by_mac(mac_address)
+      found = find_hosts('mac' => mac_address).first
+      return if found.nil?
+
       found.delete
+      nil
     end
 
     def build_reservation(name, host, full_subnet_address)
@@ -60,16 +97,16 @@ module ::Proxy::DHCP::Infoblox
       return nil if host.mac.nil? || host.mac.empty?
 
       opts = { :hostname => name }
-      opts[:mac] = host.mac
-      opts[:ip] = host.ipv4addr
       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)
-      opts[: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(opts)
+      Proxy::DHCP::Reservation.new(name, host.ipv4addr, host.mac, subnet, opts)
     end
   end
 end

data/lib/smart_proxy_dhcp_infoblox/dhcp_infoblox_main.rb

@@ -7,19 +7,17 @@ module Proxy::DHCP::Infoblox
     include Proxy::Util
     include IpAddressArithmetic
 
-    attr_reader :connection, :crud, :restart_grid, :unused_ips
+    attr_reader :connection, :crud, :restart_grid, :network_view
 
-    def initialize(connection, crud, restart_grid, unused_ips, managed_subnets)
+    def initialize(connection, crud, restart_grid, unused_ips, managed_subnets, network_view)
       @connection = connection
       @crud = crud
       @restart_grid = restart_grid
-      @unused_ips = unused_ips
-      super('infoblox', managed_subnets, nil)
+      @network_view = network_view
+      super('infoblox', managed_subnets, nil, unused_ips)
     end
 
-    def find_subnet(address);::Proxy::DHCP::Subnet.new(address, '255.255.255.0'); end
-    def load_subnets; end
-    def load_subnet_data(_); end
+    def find_subnet(address); ::Proxy::DHCP::Subnet.new(address, '255.255.255.0'); end
 
     def subnets
       ::Infoblox::Network.all(connection).map do |network|
@@ -34,32 +32,68 @@ module Proxy::DHCP::Infoblox
     end
 
     def all_leases(network_address)
-      crud.all_leases(full_network_address(network_address))
+      crud.all_leases(full_network_address(network_address), find_subnet(network_address))
     end
 
     def find_record(subnet_address, an_address)
       crud.find_record(full_network_address(subnet_address), an_address)
     end
 
+    def find_record_by_mac(subnet_address, mac_address)
+      crud.find_record_by_mac(full_network_address(subnet_address), mac_address)
+    end
+
+    def find_records_by_ip(subnet_address, ip_address)
+      crud.find_records_by_ip(full_network_address(subnet_address), ip_address)
+    end
+
     def add_record(options)
       crud.add_record(options)
       logger.debug("Added DHCP reservation for #{options[:ip]}/#{options[:mac]}")
       restart_grid.try_restart
     end
 
-    def del_record(subnet, record)
-      crud.del_record(full_network_address(subnet.network), record)
+    def del_record(record)
+      crud.del_record(full_network_address(record.subnet_address), record)
       logger.debug("Removed DHCP reservation for #{record.ip} => #{record}")
       restart_grid.try_restart
     end
 
-    def unused_ip(subnet, _, from_ip_address, to_ip_address)
-      unused_ips.unused_ip(subnet.network, from_ip_address, to_ip_address)
+    def del_record_by_mac(_, mac_address)
+      crud.del_record_by_mac(mac_address)
+      logger.debug("Removed DHCP reservation for #{mac_address}")
+      restart_grid.try_restart
+    end
+
+    def del_records_by_ip(_, ip_address)
+      crud.del_records_by_ip(ip_address)
+      logger.debug("Removed DHCP reservation(s) for #{ip_address}")
+      restart_grid.try_restart
+    end
+
+    require 'dhcp_common/subnet'
+    def get_subnet(subnet_address)
+      address, prefix_length = full_network_address(subnet_address).split("/")
+      netmask = cidr_to_ip_mask(prefix_length.to_i)
+      ::Proxy::DHCP::Subnet.new(address, netmask)
+    end
+
+    def find_ip_by_mac_address_and_range(subnet, mac_address, from_address, to_address)
+      r = crud.find_record_by_mac("#{subnet.network}/#{subnet.cidr}", mac_address)
+
+      if r && (IPAddr.new(from_address)..IPAddr.new(to_address)).cover?(IPAddr.new(r.ip))
+        logger.debug "Found an existing DHCP record #{r}, reusing..."
+        return r.ip
+      end
+
+      nil
     end
 
     def find_network(network_address)
-      network = ::Infoblox::Network.find(connection, 'network~' => network_address, '_max_results' => 1).first
-      raise "Subnet #{network_address} not found" if network.nil?
+      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

@@ -2,15 +2,24 @@ module Proxy::DHCP::Infoblox
   class Plugin < ::Proxy::Provider
     plugin :dhcp_infoblox, ::Proxy::DHCP::Infoblox::VERSION
 
-    default_settings :record_type => 'host', :range => false
+    default_settings :record_type => 'fixedaddress',
+                     :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]
+
+    start_services :unused_ips
   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.5'
+      VERSION = '0.0.18'.freeze
     end
   end
 end

data/lib/smart_proxy_dhcp_infoblox/fixed_address_crud.rb

@@ -1,39 +1,80 @@
+require 'yaml'
 require 'smart_proxy_dhcp_infoblox/common_crud'
 
 module ::Proxy::DHCP::Infoblox
   class FixedAddressCRUD < CommonCRUD
-    def initialize(connection)
-      @memoized_host = nil
+    attr_reader :network_view
+
+    def initialize(connection, network_view, used_ips_search_type)
+      @memoized_hosts = []
       @memoized_condition = nil
-      super
+      @network_view = network_view
+      super(connection, used_ips_search_type)
     end
 
     def all_hosts(subnet_address)
-      network = ::Infoblox::Fixedaddress.find(@connection, 'network' => subnet_address, '_max_results' => 2147483646) #2**(32-cidr_to_i(subnet_address)))
-      network.map {|h| build_reservation(h.name, h, subnet_address)}.compact
+      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_host('ipv4addr' => 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
+
     def find_record_by_mac(subnet_address, mac_address)
-      found = find_host('mac' => mac_address)
+      found = find_hosts('mac' => mac_address).first
       return nil if found.nil?
+
       build_reservation(found.name, found, subnet_address)
     end
 
-    def find_host(condition)
-      return @memoized_host if (!@memoized_host.nil? && @memoized_condition == condition)
+    def find_hosts(condition, max_results = 1)
+      return @memoized_hosts if (!@memoized_hosts.empty? && @memoized_condition = condition)
+
       @memoized_condition = condition
-      @memoized_host = ::Infoblox::Fixedaddress.find(@connection, condition.merge('_max_results' => 1)).first
+      @memoized_hosts = ::Infoblox::Fixedaddress.find(@connection, condition.merge('_max_results' => max_results,
+                                                                                   'network_view' => network_view))
     end
 
     def find_host_and_name_by_ip(ip_address)
-      h = find_host('ipv4addr' => ip_address)
-      [h.name, h]
+      h = find_hosts('ipv4addr' => ip_address).first
+      h.nil? ? [nil, nil] : [h.name, h]
     end
 
     def build_host(options)
@@ -41,12 +82,12 @@ module ::Proxy::DHCP::Infoblox
       host.name = options[:hostname]
       host.ipv4addr = options[:ip]
       host.mac = options[:mac]
-      # TODO: nextserver, use_nextserver, bootfile, and use_bootfile attrs exist but are not available in the model
-      # Might be useful to extend the model to include these
-      #host.nextserver = options[:nextServer]
-      #host.use_nextserver = true
-      #host.bootfile = options[:filename]
-      #host.use_bootfile = true
+      host.nextserver = options[:nextServer]
+      host.use_nextserver = true
+      host.bootfile = options[:filename]
+      host.use_bootfile = true
+      host.network_view = network_view
+      host.options = Proxy::DHCP::Infoblox::Plugin.settings.options
       host
     end
   end

data/lib/smart_proxy_dhcp_infoblox/grid_restart.rb

@@ -1,6 +1,6 @@
 module ::Proxy::DHCP::Infoblox
   class GridRestart
-    MAX_ATTEMPTS = 3
+    MAX_ATTEMPTS = 5
 
     include ::Proxy::Log
     attr_reader :connection
@@ -10,21 +10,32 @@ module ::Proxy::DHCP::Infoblox
     end
 
     def try_restart
-      logger.debug 'Restarting grid.'
+      logger.info 'Restarting Infoblox Grid'
 
+      delay = Proxy::DHCP::Infoblox::Plugin.settings.wait_after_restart.to_i
       MAX_ATTEMPTS.times do |tries|
+        if restart
+          if delay > 0
+            logger.info "Starting post-restart delay of #{delay} seconds..."
+            sleep delay
+            logger.debug "Post-restart delay done"
+          end
+          return
+        end
         sleep tries
-        return if restart
       end
 
-      logger.info 'Restarting Grid failed.'
+      logger.warn 'Restarting Infoblox Grid failed, giving up'
       false
     end
 
+    private
+
     def restart
       (@grid ||= ::Infoblox::Grid.get(@connection).first).restartservices
       true
     rescue Exception => e
+      logger.warn "Error during Grid restart: #{e}"
       false
     end
   end

data/lib/smart_proxy_dhcp_infoblox/host_ipv4_address_crud.rb

@@ -3,45 +3,86 @@ require 'smart_proxy_dhcp_infoblox/network_address_range_regex_generator'
 
 module ::Proxy::DHCP::Infoblox
   class HostIpv4AddressCRUD < CommonCRUD
-    def initialize(connection)
-      @memoized_host = nil
+    attr_reader :dns_view
+
+    def initialize(connection, dns_view, used_ips_search_type)
+      @memoized_hosts = []
       @memoized_condition = nil
-      super
+      @dns_view = dns_view
+      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(
+      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,
-          '_max_results' => 2147483646)
+          'view' => dns_view,
+          '_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_host('ipv4addr' => 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)
+
+      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?
+
+      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_host('mac' => 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)
+
+      build_reservation(found.name, found.ipv4addrs.find { |ip| ip.mac == mac_address }, subnet_address)
     end
 
     def find_host_and_name_by_ip(ip_address)
-      h = find_host('ipv4addr' => ip_address)
-      [h.name, h.ipv4addrs.find {|ip| ip.ipv4addr == ip_address}]
+      h = find_hosts('ipv4addr' => ip_address).first
+      h.nil? ? [nil, nil] : [h.name, h.ipv4addrs.find { |ip| ip.ipv4addr == ip_address }]
     end
 
-    def find_host(condition)
-      return @memoized_host if (!@memoized_host.nil? && @memoized_condition == condition)
+    def find_hosts(condition, max_results = 1)
+      return @memoized_hosts if (!@memoized_hosts.empty? && @memoized_condition == condition)
+
       @memoized_condition = condition
-      @memoized_host = ::Infoblox::Host.find(@connection, condition.merge('_max_results' => 1)).first
+      @memoized_hosts = ::Infoblox::Host.find(@connection, condition.merge('view' => dns_view,
+                                                                           '_max_results' => max_results))
     end
 
     def build_host(options)
@@ -54,6 +95,7 @@ module ::Proxy::DHCP::Infoblox
       host_addr.use_nextserver = true
       host_addr.bootfile = options[:filename]
       host_addr.use_bootfile = true
+      host.view = dns_view
       host
     end
   end