smart_proxy_dhcp_infoblox 0.0.4 → 0.0.5

data/lib/smart_proxy_dhcp_infoblox/dhcp_infoblox_plugin.rb

@@ -1,24 +1,16 @@
-require 'smart_proxy_dhcp_infoblox/dhcp_infoblox_version'
-
 module Proxy::DHCP::Infoblox
   class Plugin < ::Proxy::Provider
-    plugin :dhcp_infoblox, ::Proxy::DHCP::Infoblox::VERSION, :provider_class => "::Proxy::DHCP::Infoblox::Provider"
+    plugin :dhcp_infoblox, ::Proxy::DHCP::Infoblox::VERSION
+
+    default_settings :record_type => 'host', :range => false
+    validate_presence :username, :password
 
-    # 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',
-     :record_type => 'host',
-     :wapi_version => '2.0',
-     :range => false
+    requires :dhcp, '>= 1.13'
 
-    requires :dhcp, '>= 1.11'
+    load_classes ::Proxy::DHCP::Infoblox::PluginConfiguration
+    load_validators :record_type_validator => ::Proxy::DHCP::Infoblox::RecordTypeValidator
+    load_dependency_injection_wirings ::Proxy::DHCP::Infoblox::PluginConfiguration
 
-    after_activation do
-      require 'smart_proxy_dhcp_infoblox/dhcp_infoblox_main'
-      require 'smart_proxy_dhcp_infoblox/dhcp_infoblox_dependencies'
-    end
+    validate :record_type, :record_type_validator => true
   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.4'
+      VERSION = '0.0.5'
     end
   end
 end

data/lib/smart_proxy_dhcp_infoblox/fixed_address_crud.rb

@@ -0,0 +1,53 @@
+require 'smart_proxy_dhcp_infoblox/common_crud'
+
+module ::Proxy::DHCP::Infoblox
+  class FixedAddressCRUD < CommonCRUD
+    def initialize(connection)
+      @memoized_host = nil
+      @memoized_condition = nil
+      super
+    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
+    end
+
+    def find_record_by_ip(subnet_address, ip_address)
+      found = find_host('ipv4addr' => ip_address)
+      return nil if found.nil?
+      build_reservation(found.name, found, subnet_address)
+    end
+
+    def find_record_by_mac(subnet_address, mac_address)
+      found = find_host('mac' => mac_address)
+      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)
+      @memoized_condition = condition
+      @memoized_host = ::Infoblox::Fixedaddress.find(@connection, condition.merge('_max_results' => 1)).first
+    end
+
+    def find_host_and_name_by_ip(ip_address)
+      h = find_host('ipv4addr' => ip_address)
+      [h.name, h]
+    end
+
+    def build_host(options)
+      host = ::Infoblox::Fixedaddress.new(:connection => @connection)
+      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
+    end
+  end
+end

data/lib/smart_proxy_dhcp_infoblox/grid_restart.rb

@@ -0,0 +1,31 @@
+module ::Proxy::DHCP::Infoblox
+  class GridRestart
+    MAX_ATTEMPTS = 3
+
+    include ::Proxy::Log
+    attr_reader :connection
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def try_restart
+      logger.debug 'Restarting grid.'
+
+      MAX_ATTEMPTS.times do |tries|
+        sleep tries
+        return if restart
+      end
+
+      logger.info 'Restarting Grid failed.'
+      false
+    end
+
+    def restart
+      (@grid ||= ::Infoblox::Grid.get(@connection).first).restartservices
+      true
+    rescue Exception => e
+      false
+    end
+  end
+end

data/lib/smart_proxy_dhcp_infoblox/host_ipv4_address_crud.rb

@@ -0,0 +1,60 @@
+require 'smart_proxy_dhcp_infoblox/common_crud'
+require 'smart_proxy_dhcp_infoblox/network_address_range_regex_generator'
+
+module ::Proxy::DHCP::Infoblox
+  class HostIpv4AddressCRUD < CommonCRUD
+    def initialize(connection)
+      @memoized_host = nil
+      @memoized_condition = nil
+      super
+    end
+
+    def all_hosts(subnet_address)
+      address_range_regex = NetworkAddressesRegularExpressionGenerator.new.generate_regex(subnet_address)
+
+      hosts = ::Infoblox::Host.find(
+          @connection,
+          'ipv4addr~' => address_range_regex,
+          '_max_results' => 2147483646)
+
+      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
+    end
+
+    def find_record_by_ip(subnet_address, ip_address)
+      found = find_host('ipv4addr' => ip_address)
+      return nil if found.nil?
+      build_reservation(found.name, found.ipv4addrs.find {|ip| ip.ipv4addr == ip_address}, subnet_address)
+    end
+
+    def find_record_by_mac(subnet_address, mac_address)
+      found = find_host('mac' => mac_address)
+      return nil if found.nil?
+      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}]
+    end
+
+    def find_host(condition)
+      return @memoized_host if (!@memoized_host.nil? && @memoized_condition == condition)
+      @memoized_condition = condition
+      @memoized_host = ::Infoblox::Host.find(@connection, condition.merge('_max_results' => 1)).first
+    end
+
+    def build_host(options)
+      host = ::Infoblox::Host.new(:connection => @connection)
+      host.name = options[:hostname]
+      host_addr = host.add_ipv4addr(options[:ip]).last
+      host_addr.mac = options[:mac]
+      host_addr.configure_for_dhcp = true
+      host_addr.nextserver = options[:nextServer]
+      host_addr.use_nextserver = true
+      host_addr.bootfile = options[:filename]
+      host_addr.use_bootfile = true
+      host
+    end
+  end
+end

data/lib/smart_proxy_dhcp_infoblox/ip_address_arithmetic.rb

@@ -0,0 +1,34 @@
+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('.')
+    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)
+      (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)
+    end
+
+    def cidr_to_i(an_address_with_cidr)
+      an_address_with_cidr.split("/").last.to_i
+    end
+
+    def network_cidr_to_range(network_and_cidr)
+      network_addr, cidr = network_and_cidr.split('/')
+      mask = cidr_to_bitmask(cidr.to_i)
+
+      range_start = ipv4_to_i(network_addr) & mask
+      range_end = range_start | (0xFFFFFFFF ^ mask)
+
+      [i_to_ipv4(range_start), i_to_ipv4(range_end)]
+    end
+  end
+end

data/lib/smart_proxy_dhcp_infoblox/network_address_range_regex_generator.rb

@@ -0,0 +1,131 @@
+require 'smart_proxy_dhcp_infoblox/ip_address_arithmetic'
+
+module ::Proxy::DHCP::Infoblox
+  class RangeRegularExpressionGenerator
+    class Node
+      attr_accessor :value, :children
+
+      def initialize(value, children = [])
+        @value = value
+        @children = children
+      end
+
+      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
+
+      def <=>(other)
+        return -1 if value.to_s == '0?'
+        return 1 if other.value.to_s == '0?'
+        return 0 if value == other.value
+        return -1 if value < other.value
+        1
+      end
+
+      def add_child(a_node)
+        children.push(a_node)
+        children.sort!
+        a_node
+      end
+
+      def group_children
+        children.each {|n| n.group_children}
+        return if children.size < 2
+        @children = children[1..-1].inject([MergedNode.new(children.first)]) do |grouped, to_group|
+          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.nil? ? grouped.push(current) : found.merge(current)
+          grouped
+        end
+      end
+
+      def as_regex
+        children.empty? ? [value.to_s] : children.map {|c| c.as_regex.map {|r| value.to_s + r}}.flatten
+      end
+    end
+
+    class MergedNode
+      attr_accessor :value, :children
+      def initialize(a_node)
+        @value = [a_node.value].flatten
+        @children = a_node.children
+      end
+
+      def merge(other)
+        value.push(other.value).flatten!
+        self
+      end
+
+      def as_regex
+        children.empty? ? [value_as_regex] : children.map {|c| c.as_regex.map {|r| value_as_regex + r}}.flatten
+      end
+
+      def value_as_regex
+        value.size < 2 ? value.first.to_s : "[#{value.join('')}]"
+      end
+
+      def ==(other)
+        return false if self.class != other.class
+        value == other.value
+      end
+    end
+
+    class Root < Node
+      def add_number(a_number)
+        add_children((['0?', '0?'] + digits(a_number))[-3, 3])
+      end
+
+      def as_regex
+        group_children
+        "(%s)" % children.map {|c| c.as_regex}.join('|')
+      end
+
+      def digits(a_number)
+        to_return = []
+        begin
+          to_return.push(a_number % 10)
+          a_number = a_number / 10
+        end while a_number != 0
+        to_return.reverse
+      end
+    end
+
+    def range_regex(range_start, range_end)
+      root = Root.new(nil)
+      (range_start..range_end).to_a.each {|i| root.add_number(i)}
+      root.as_regex
+    end
+  end
+
+  class NetworkAddressesRegularExpressionGenerator
+    include IpAddressArithmetic
+
+    def generate_regex(network_and_cidr)
+      range_to_regex(network_cidr_range_octets(network_and_cidr))
+    end
+
+    def network_cidr_range_octets(network_and_cidr)
+      range = network_cidr_to_range(network_and_cidr)
+      range_start_octets = range.first.split('.').map(&:to_i)
+      range_end_octets = range.last.split('.').map(&:to_i)
+
+      (0..3).map {|i| [range_start_octets[i], range_end_octets[i]]}
+    end
+
+    def range_to_regex(range)
+      range.inject([]) do |a, c|
+        start_range, end_range = c
+        regex = if start_range == end_range
+                  start_range.to_s
+                elsif start_range == 0 && end_range == 255
+                  '.+'
+                else
+                  RangeRegularExpressionGenerator.new.range_regex(start_range + 1, end_range - 1)
+                end
+        a.push(regex)
+      end.join('\.')
+    end
+  end
+end

data/lib/smart_proxy_dhcp_infoblox/plugin_configuration.rb

@@ -0,0 +1,37 @@
+module Proxy::DHCP::Infoblox
+  class PluginConfiguration
+    def load_classes
+      require 'infoblox'
+      require 'dhcp_common/dhcp_common'
+      require 'smart_proxy_dhcp_infoblox/host_ipv4_address_crud'
+      require 'smart_proxy_dhcp_infoblox/fixed_address_crud'
+      require 'smart_proxy_dhcp_infoblox/grid_restart'
+      require 'smart_proxy_dhcp_infoblox/unused_ips'
+      require 'smart_proxy_dhcp_infoblox/dhcp_infoblox_main'
+    end
+
+    def load_dependency_injection_wirings(c, settings)
+
+
+      c.dependency :connection, (lambda do
+                                  ::Infoblox.wapi_version = '2.0'
+                                  ::Infoblox::Connection.new(:username => settings[:username] ,:password => settings[:password],
+                                                             :host => settings[:server], :ssl_opts => {:verify => false})
+                                end)
+
+
+      c.dependency :unused_ips, lambda { ::Proxy::DHCP::Infoblox::UnusedIps.new(c.get_dependency(:connection), settings[:use_ranges])}
+      c.dependency :host_ipv4_crud, lambda { ::Proxy::DHCP::Infoblox::HostIpv4AddressCRUD.new(c.get_dependency(:connection))}
+      c.dependency :fixed_address_crud, lambda { ::Proxy::DHCP::Infoblox::FixedAddressCRUD.new(c.get_dependency(:connection))}
+      c.dependency :grid_restart, lambda { ::Proxy::DHCP::Infoblox::GridRestart.new(c.get_dependency(:connection))}
+      c.dependency :dhcp_provider, (lambda do
+                                      ::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(:grid_restart),
+                                        c.get_dependency(:unused_ips),
+                                        settings[:subnets])
+                                      end)
+    end
+  end
+end

data/lib/smart_proxy_dhcp_infoblox/record_type_validator.rb

@@ -0,0 +1,8 @@
+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/lib/smart_proxy_dhcp_infoblox/unused_ips.rb

@@ -0,0 +1,47 @@
+require 'ipaddr'
+require 'smart_proxy_dhcp_infoblox/ip_address_arithmetic'
+
+module Proxy::DHCP::Infoblox
+  class UnusedIps
+    include IpAddressArithmetic
+    attr_reader :connection, :use_ranges
+
+    def initialize(connection, use_ranges)
+      @connection = connection
+      @use_ranges = use_ranges
+    end
+
+    def unused_ip(network_address, from_ip_address, to_ip_address)
+      @use_ranges ? unused_range_ip(network_address, from_ip_address, to_ip_address) : unused_network_ip(network_address, from_ip_address, to_ip_address)
+    end
+
+    def unused_network_ip(network_address, from_ip_address, to_ip_address)
+      find_network(network_address).next_available_ip(1, excluded_ips(find_network(network_address).network, from_ip_address, to_ip_address)).first
+    end
+
+    def unused_range_ip(network_address, from_ip_address, to_ip_address)
+      find_range(network_address, from_ip_address, to_ip_address).next_available_ip(1).first
+    end
+
+    def excluded_ips(subnet_address, from, to)
+      return [] if from.nil? || to.nil?
+      (IPAddr.new(network_cidr_to_range(subnet_address).first)..IPAddr.new(network_cidr_to_range(subnet_address).last)).to_a.map(&:to_s) -
+          (IPAddr.new(from)..IPAddr.new(to)).to_a.map(&:to_s)
+    end
+
+    def find_range(network_address, from, to)
+      ranges = ::Infoblox::Range.find(@connection, 'network~' => network_address)
+      range = (from.nil? || to.nil?) ? ranges.first : ranges.find {|r| r.start_addr == from && r.end_addr == to}
+      raise "No Ranges found for #{network_address} network" if range.nil?
+      range
+    end
+
+    def find_network(network_address)
+      return @memoized_network if !@memoized_network.nil? && @memoized_address == network_address
+      @memoized_address = network_address
+      @memoized_network = ::Infoblox::Network.find(@connection, 'network~' => network_address, '_max_results' => 1).first
+      raise "Subnet #{network_address} not found" if @memoized_network.nil?
+      @memoized_network
+    end
+  end
+end