smart_proxy_dhcp_infoblox 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b37b9aafe28027c77579ba06a180b28a8d64caa5
-  data.tar.gz: 55bee325d7c2b0447824270c7ad244f2c40370ed
+  metadata.gz: 1f93a00fc3b3226cd13507406635a76d39fdf5bf
+  data.tar.gz: 2af103b766051daba129f8a05918f704692f7362
 SHA512:
-  metadata.gz: a44fdb8a55966706ca342a5820013196e822883ae2c667f90bdb44974063529028334aea75a8e7c6f97b6d56e0c5fe27a99d2017fe4191f207cd9aa3b32b01a1
-  data.tar.gz: 22c4d7aa26b2047cae38ae0a9509bc715cc20cc5acabdb87d78b5e6aca3bd022f4d2d40f33de354fc8fd6a2c19531313799da90174a814507dea1abbf4d20cb6
+  metadata.gz: 629785c6c921e5a356af8ab70703bc13d9db487dc3b4cdc2fb24ab1ff320d620e67b6762ff557a400cc1a77b4a73e7d7817c07591160e6d3de4011cf65abef48
+  data.tar.gz: 442344c94cb0cf17e7e8915139149be7f50c545d771e570dcc7ae921c8ae98649a2f207c72e2c91c66bfdfc655fe73ab8b1b3a9ff1191c7ed2ecf470a4118fb7

data/README.md

@@ -1,32 +1,37 @@
 # SmartProxyDhcpInfoblox
 
-*Introduction here*
-
-This plugin adds a new DHCP provider for managing records with Infoblox Servers
+This plugin adds a new DHCP provider for managing records with infoblox servers
 
 ## 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.
+This plugin is compatible with Smart Proxy 1.11 or higher.
+
+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
 
 ## Configuration
 
 To enable this DHCP provider, edit `/etc/foreman-proxy/settings.d/dhcp.yml` and set:
 
     :use_provider: dhcp_infoblox
+    :server: IP of infoblox server
+    :subnets: subnets you want to use (optional unless you set infoblox_subnets to false)
 
 Configuration options for this plugin are in `/etc/foreman-proxy/settings.d/dhcp_infoblox.yml` and include:
 
-* infoblox_user: API Username
-* infoblox_pw: API Password
-* infoblox_host: IP/URL to infoblox Server
+* username: API Username
+* passowrd: 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
 
-//// TEMP ////
-Add this to the Smart Proxy's bundler.d/Gemfile.local.rb configuration:
+## 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.
 
-  gem 'smart_proxy_dhcp_infoblox', :path => '/path/tosmart_proxy_dhcp_infoblox'
+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.
 
 ## Contributing
 

data/config/dhcp_infoblox.yml.example

@@ -0,0 +1,17 @@
+---
+#
+# 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"
+: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

data/lib/smart_proxy_dhcp_infoblox.rb

@@ -1,4 +1,10 @@
-require 'dhcp_common/dhcp_common'
-require 'smart_proxy_dhcp_infoblox/dhcp_infoblox_plugin'
+module Proxy
+  module DHCP
+    module Infoblox; end
+  end
+end
 
-module Proxy::DHCP::Infoblox; 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/lib/smart_proxy_dhcp_infoblox/common_crud.rb

@@ -0,0 +1,75 @@
+require 'resolv'
+require 'smart_proxy_dhcp_infoblox/ip_address_arithmetic'
+require "proxy/validations"
+
+module ::Proxy::DHCP::Infoblox
+  class CommonCRUD
+    include Proxy::Validations
+    include IpAddressArithmetic
+
+    attr_reader :connection
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def all_leases(network_address)
+      [] # infoblox doesn't support leases
+    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
+
+    def add_record(options)
+      validate_ip(options[:ip])
+      validate_mac(options[:mac])
+      raise(Proxy::DHCP::Error, "Must provide hostname") unless options[:hostname]
+
+      build_host(options).post
+      # TODO: DELETE ME needed for testing on infoblox ipam express
+      #host.configure_for_dns = false
+    rescue Infoblox::Error => e
+      raise e unless e.message.include?("IB.Data.Conflict") # not a conflict
+
+      begin
+        existing_name, existing_host = find_host_and_name_by_ip(options[:ip])
+      rescue Exception
+        raise e
+      end
+      raise e if existing_host.nil? # something weird going on, re-raise the original exception
+
+      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)
+      return if found.nil?
+      found.delete
+    end
+
+    def build_reservation(name, host, full_subnet_address)
+      return nil if host.nil?
+      return nil if name.nil? || name.empty?
+      return nil if (host.respond_to?(:configure_for_dhcp) && !host.configure_for_dhcp)
+      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
+      # 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)))
+
+      Proxy::DHCP::Reservation.new(opts)
+    end
+  end
+end

data/lib/smart_proxy_dhcp_infoblox/dhcp_infoblox_main.rb

@@ -1,256 +1,70 @@
 require 'dhcp_common/server'
-require 'infoblox'
-require 'ipaddr'
+require 'smart_proxy_dhcp_infoblox/ip_address_arithmetic'
 
 module Proxy::DHCP::Infoblox
   class Provider < ::Proxy::DHCP::Server
     include Proxy::Log
     include Proxy::Util
+    include IpAddressArithmetic
 
-    attr_reader :infoblox_user, :infoblox_pw, :server
+    attr_reader :connection, :crud, :restart_grid, :unused_ips
 
-    def initialize
-      # TODO: Verify input
-      server = Proxy::DhcpPlugin.settings.server
-      infoblox_user = Proxy::DHCP::Infoblox::Plugin.settings.infoblox_user
-      infoblox_pw = Proxy::DHCP::Infoblox::Plugin.settings.infoblox_pw
-      @record_type = Proxy::DHCP::Infoblox::Plugin.settings.record_type
-      @range = Proxy::DHCP::Infoblox::Plugin.settings.range
-      wapi_version = Proxy::DHCP::Infoblox::Plugin.settings.wapi_version
-      ::Infoblox.wapi_version = "#{wapi_version}"
-      @connection = ::Infoblox::Connection.new(username: infoblox_user, password: infoblox_pw, host: server)
-      logger.debug "Loaded infoblox provider with #{@record_type} record_type and #{wapi_version} wapi_version"
+    def initialize(connection, crud, restart_grid, unused_ips, managed_subnets)
+      @connection = connection
+      @crud = crud
+      @restart_grid = restart_grid
+      @unused_ips = unused_ips
+      super('infoblox', managed_subnets, nil)
     end
 
-    def initialize_for_testing(params)
-      @name = params[:name] || @name
-      @service = params[:service] || service
-      @dhcp_server = params[:dhcp_server] || @dhcp_server
-      @username = params[:username] || @username
-      @password = params[:password] || @password
-      @record_type = params[:record_type] || @record_type
-      @wapi_version = params[:wapi_version] || @wapi_version
-      self
-    end
-
-    def load_subnets
-      logger.debug 'load_subnets'
-      ::Infoblox::Network.all(@connection).each do |obj|
-        if match = obj.network.split('/')
-          tmp = IPAddr.new(obj.network)
-          netmask = IPAddr.new(tmp.instance_variable_get("@mask_addr"), Socket::AF_INET).to_s
-          next unless managed_subnet? "#{match[0]}/#{netmask}"
-          options = {}
-          service.add_subnets(Proxy::DHCP::Subnet.new(match[0], netmask, options))
-        end
-      end
-    end
-
-    def find_subnet(network_address)
-      # returns Proxy::DHCP::Subnet that has network_address or nil if none was found
-      # network = ::Infoblox::Ipv4address.find(connection, "ip_address" => network_address).first.network
-      super
-    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 load_subnet_data(subnet)
-      # intentionally do nothing
-    end
-
-    def load_infoblox_subnet_data(subnet)
-      # Load network from infoblox, iterate over ips to gather additional settings
-      logger.debug 'load_infoblox_subnet_data'
-      if @record_type == 'host'
-        # max results are currently set to work in my setup, one could calculate that setting by looking at netmask :)
-        network = ::Infoblox::Ipv4address.find(@connection, 'network' => "#{subnet.network}/#{subnet.cidr}", 'status' => 'USED', 'usage' => 'DHCP', '_max_results' => 2**(32-subnet.cidr))
-        # Find out which hosts are in use
-        network.each do |host|
-          # next if certain values are not set
-          next if host.names.empty? || host.mac_address.empty? || host.ip_address.empty?
-          hostdhcp = ::Infoblox::HostIpv4addr.find(@connection, 'ipv4addr' => host.ip_address).first
-          next unless hostdhcp.configure_for_dhcp
-          opts = { :hostname => host.names.first }
-          opts[:mac] = host.mac_address
-          opts[:ip] = host.ip_address
-          # broadcast and network entrys are not deleteable
-          opts[:deleteable] = true unless (host.types & %w(BROADCAST NETWORK)).any?
-          opts[:nextServer] = hostdhcp.nextserver unless hostdhcp.use_nextserver
-          opts[:filename] = hostdhcp.bootfile unless hostdhcp.use_bootfile
-          service.add_host(subnet.network, Proxy::DHCP::Reservation.new(opts.merge(:subnet => subnet)))
-        end
-      elsif @record_type == 'fixed_address'
-        network = ::Infoblox::Fixedaddress.find(@connection, 'network' => "#{subnet.network}/#{subnet.cidr}", '_max_results' => 2**(32-subnet.cidr))
-        network.each do |host|
-          logger.debug "Processing host: #{host.name} #{host.mac} #{host.ipv4addr}"
-          next if host.name == nil || host.mac == nil || host.ipv4addr == nil
-          opts = { :hostname => host.name }
-          opts[:mac] = host.mac
-          opts[:ip] = host.ipv4addr
-          service.add_host(subnet.network, Proxy::DHCP::Reservation.new(opts.merge(:subnet => subnet)))
-        end
-      end
+    def subnets
+      ::Infoblox::Network.all(connection).map do |network|
+        address, prefix_length = network.network.split("/")
+        netmask = cidr_to_ip_mask(prefix_length.to_i)
+        managed_subnet?("#{address}/#{netmask}") ? Proxy::DHCP::Subnet.new(address, netmask, {}) : nil
+      end.compact
     end
 
     def all_hosts(network_address)
-      # returns all reservations in a subnet with network_address
-      logger.debug "infoblox.all_hosts #{network_address}"
-      load_infoblox_subnet_data(find_subnet(network_address))
-      super
+      crud.all_hosts(full_network_address(network_address))
     end
 
-    def unused_ip(network_address, mac_address, from_ip_address, to_ip_address)
-      # returns first available ip address in a subnet with network_address, for a host with mac_address, in the range of ip addresses: from_ip_address, to_ip_address
-      # Deliberatly ignoring everything but first argument
-      logger.debug "Infoblox unused_ip Network_address: #{network_address} #{mac_address}, #{from_ip_address}, #{to_ip_address}"
-      #next_available_ip can take a number to return (1), and an array of ips to exclude. So, we need to:
-      #build a list of all ips in the network (all_addresses)
-      #build a list of all ips in between from_ip_address and to_ip_address (include_addresses)
-      #remove all of the from_ip_address and to_ip_address from the all_address (exclude_addresses)
-      #and call next_available_ip with exclude_addresses passed
-      all_addresses = Array.new
-      net=IPAddr.new("#{network_address.network}/#{network_address.cidr}")
-      net.to_range.each do |ip|
-        all_addresses.push(ip.to_s)
-      end
-      range_start=IPAddr.new(from_ip_address)
-      range_stop=IPAddr.new(to_ip_address)
-      included_addresses=Array.new
-      (range_start..range_stop).each do |ip|
-        included_addresses.push(ip.to_s)
-      end
-      excluded_addresses=all_addresses-included_addresses
-      #excluded_addresses is now an array of ips containing all the ips from the network not between from, and to_ip_address
-
-      if @range
-        ::Infoblox::Range.find(@connection, network: "#{network_address.network}/#{network_address.cidr}").first.next_available_ip(1,excluded_addresses)
-      else
-        ::Infoblox::Network.find(@connection, network: "#{network_address.network}/#{network_address.cidr}").first.next_available_ip(1,excluded_addresses)
-      end
-      # Idea for randomisation in case of concurrent installs:
-      #::Infoblox::Network.find(@connection, network: "#{network_address.network}/#{network_address.cidr}").first.next_available_ip(15).sample
+    def all_leases(network_address)
+      crud.all_leases(full_network_address(network_address))
     end
 
     def find_record(subnet_address, an_address)
-      logger.debug 'find_record'
-      # record can be either ip or mac, true = mac --> lookup ip
-      if an_address.is_a?(String) && valid_mac?(an_address)
-        if @record_type == 'host'
-          hostdhcp = ::Infoblox::HostIpv4addr.find(@connection, 'mac' => an_address)
-        elsif @record_type == 'fixed_address'
-          hostdhcp = ::Infoblox::Fixedaddress.find(@connection,'mac' => an_address)
-        end
-        return nil if hostdhcp.empty?
-        ipv4address = hostdhcp.first.ipv4addr
-      elsif an_address.is_a?(String)
-        validate_ip(an_address)
-        ipv4address = an_address
-      end
-
-      if @record_type == 'host'
-        host = ::Infoblox::Host.find(@connection, 'ipv4addr' => ipv4address)
-        return nil if host.empty? || host.first.name.empty?
-        hostdhcp = ::Infoblox::HostIpv4addr.find(@connection, 'ipv4addr' => ipv4address).first
-        return nil unless hostdhcp.configure_for_dhcp
-        return nil if hostdhcp.mac.empty? || hostdhcp.ipv4addr.empty?
-        opts = { :hostname => host.first.name }
-        opts[:mac] = hostdhcp.mac
-        opts[:ip] = hostdhcp.ipv4addr
-        opts[:deleteable] = true
-        opts[:nextServer] = hostdhcp.nextserver if hostdhcp.use_nextserver
-        opts[:filename] = hostdhcp.bootfile if hostdhcp.use_bootfile
-      elsif @record_type == 'fixed_address'
-        logger.debug "find_record for #{an_address}"
-        fixed_address = ::Infoblox::Fixedaddress.find(@connection, 'ipv4addr' => ipv4address)
-        #logger.debug "#{fixed_address.inspect}"
-        return nil if fixed_address == []
-        #return nil if fixed_address.emtpy? || fixed_address.first.name.empty?
-        #return nil if fixed_address.emtpy?
-        opts = { :hostname => fixed_address.first.name }
-        opts[:deleteable] = true
-        opts[:mac] = fixed_address.first.mac
-        opts[:ip] = fixed_address.first.ipv4addr
-      end
-      # Subnet should only be one, not checking that yet
-      subnet = subnets.find { |s| s.include? ipv4address }
-      Proxy::DHCP::Record.new(opts.merge(:subnet => subnet))
+      crud.find_record(full_network_address(subnet_address), an_address)
     end
 
-    def create_infoblox_host_record(record)
-      logger.debug 'create_infoblox_host_record'
-      host = ::Infoblox::Host.new(:connection => @connection)
-      host.name = record.name
-      host.add_ipv4addr(record.ip)
-      host.post
+    def add_record(options)
+      crud.add_record(options)
+      logger.debug("Added DHCP reservation for #{options[:ip]}/#{options[:mac]}")
+      restart_grid.try_restart
     end
 
-    def create_infoblox_fixed_address(record)
-      logger.debug 'create_infoblox_fixed_address'
-      fixed_address = ::Infoblox::Fixedaddress.new(:connection => @connection)
-      fixed_address.name = record.name
-      fixed_address.ipv4addr = record.ip
-      fixed_address.mac = record.mac
-      fixed_address.post
+    def del_record(subnet, record)
+      crud.del_record(full_network_address(subnet.network), record)
+      logger.debug("Removed DHCP reservation for #{record.ip} => #{record}")
+      restart_grid.try_restart
     end
 
-    def add_record options={}
-      logger.debug 'Add Record'
-      record = super
-      #Since we support 2 types of records, do the right thing with each one.
-      if @record_type == 'host'
-        host = ::Infoblox::Host.find(@connection, 'ipv4addr' => record.ip)
-        # If empty create:
-        if host.empty?
-          create_infoblox_host_record(record)
-        end
-        host = ::Infoblox::Host.find(@connection, 'ipv4addr' => record.ip).first
-        options = record.options
-        # Overwrite values without checking
-        # Select correct ipv4addr object from ipv4addrs array
-        hostip = host.ipv4addrs.find { |ip| ip.ipv4addr == record.ip }
-        logger.debug "Add Record - record.name: #{record.name}, hostip.host #{hostip.host}, record.mac #{record.mac}, record.ip #{record.ip}"
-        logger.debug "Add Record - options[:nextServer] #{options[:nextServer]}, options[:filename] #{options[:filename]}, hostip.ipv4addr: #{hostip.ipv4addr} "
-        raise InvalidRecord, "#{record} Hostname mismatch" unless hostip.host == record.name
-        hostip.mac = record.mac
-        hostip.configure_for_dhcp = true
-        hostip.nextserver = options[:nextServer]
-        hostip.use_nextserver = true
-        hostip.bootfile = options[:filename]
-        hostip.use_bootfile = true
-        ## Test if Host Entry has correct IP
-        raise InvalidRecord, "#{record} IP mismatch" unless hostip.ipv4addr == record.ip
-        # Send object
-        host.put
-        record
-      elsif @record_type == 'fixed_address'
-        create_infoblox_fixed_address(record)
-        record
-      end
+    def unused_ip(subnet, _, from_ip_address, to_ip_address)
+      unused_ips.unused_ip(subnet.network, from_ip_address, to_ip_address)
     end
 
-    def del_record subnet, record
-      logger.debug 'Infoblox del_record'
-      validate_subnet subnet
-      validate_record record
-      # TODO: Refactor this into the base class
-      raise InvalidRecord, "#{record} is static - unable to delete" unless record.deleteable?
-      if @record_type == 'host'
-        # "Deleting" a record here means just disabling dhcp
-        host = ::Infoblox::Host.find(@connection, 'ipv4addr' => record.ip)
-        unless host.empty?
-          # if not empty, first element is what we want to edit
-          host = host.first
-          # Select correct ipv4addr object from ipv4addrs array
-          hostip = host.ipv4addrs.find { |ip| ip.ipv4addr == record.ip }
-          hostip.configure_for_dhcp = false
-          # Send object
-          host.put
-        end
-      elsif @record_type == 'fixed_address'
-        #Delete the fixed address record.
-        fixed_address = ::Infoblox::Fixedaddress.find(@connection, 'ipv4addr' => record.ip).first
-        fixed_address.delete
-      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
+    end
 
-      logger.debug "Disabled DHCP on #{record}"
+    def full_network_address(network_address)
+      find_network(network_address).network
     end
   end
 end