foreman_discovery 15.0.2 → 16.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7da55b634c6847d6d4694e7c01c05640481de4589267d8b0f8bfad89e18be03e
-  data.tar.gz: e4321f0bd91cb985955c30f39c2497dc56cd43f7c9452d8bf81e933a4a704dbf
+  metadata.gz: accf12de8ae1253e5023ba98c65da7c3af14aa8da4691fe67dd7f18bc5717518
+  data.tar.gz: 0dd4c83a875917ccf3933679a31a747d8f559e5195415fab619cc0220bcd97c4
 SHA512:
-  metadata.gz: 6b8adac21ff97553128c433c222a45ee8529a1d83ab75c9a0657d7b536320bc0b7420af6562eecdf5c0f1d684b118d64331c8e96158553edf9f5be93d4b6b600
-  data.tar.gz: 8ee273cf286df977a582413f006ecc7529b47b4507b2be598cde0c9db6fa91f0b6fbc3fcbfd5ff815873622fe5d1b6d3162cd0ba766c029d2635162a4168889a
+  metadata.gz: a8fd61670a325106898043ab9533f7512835394a6141139580436e9c8fdd0027ff0aee02c0a53f6d92b5b4535d5bcbcabfb1cd91ddc0fd85ce8a0a54d2cde27e
+  data.tar.gz: 90263e8535e3d338ee335a280ff89dafd188d7e92c8f7becb340bc6ede0884bbf4ee915ad158de546c84058240c7338d1d4a736f3124e8c6c57f935862073f83

data/app/controllers/api/v2/discovery_rules_controller.rb

@@ -55,7 +55,7 @@ module Api
       param_group :discovery_rule, :as => :update
 
       def update
-        process_response @discovery_rule.update_attributes(discovery_rule_params)
+        process_response @discovery_rule.update(discovery_rule_params)
       end
 
       api :DELETE, "/discovery_rules/:id/", N_("Delete a rule")

data/app/controllers/concerns/foreman/controller/discovered_extensions.rb

@@ -41,6 +41,8 @@ module Foreman::Controller::DiscoveredExtensions
   # trigger the provisioning
   def perform_auto_provision original_host, rule
     raise(::Foreman::Exception.new(N_("No hostgroup associated with rule '%s'"), rule)) if rule.hostgroup.nil?
+
+    logger.debug "Auto-provisioning via rule #{rule} hostgroup #{rule.hostgroup} subnet #{rule.hostgroup.subnet}"
     host = ::ForemanDiscovery::HostConverter.to_managed(original_host)
     host.hostgroup_id = rule.hostgroup_id
     host.comment = "Auto-discovered and provisioned via rule '#{rule.name}'"
@@ -55,6 +57,8 @@ module Foreman::Controller::DiscoveredExtensions
     # explicitly set all inheritable attributes from hostgroup
     host.attributes = host.apply_inherited_attributes(hostgroup_id: rule.hostgroup_id)
     host.set_hostgroup_defaults
+    # change subnet and fetch unused IPs
+    ::ForemanDiscovery::HostConverter.unused_ip_for_host(host, rule.hostgroup.subnet, rule.hostgroup.subnet6)
     # save! does not work here
     if host.save
       host

data/app/controllers/discovered_hosts_controller.rb

@@ -78,6 +78,7 @@ class DiscoveredHostsController < ::ApplicationController
   def perform_update(host, success_message = nil)
     Taxonomy.no_taxonomy_scope do
       ::ForemanDiscovery::HostConverter.set_build_clean_facts(host)
+      ::ForemanDiscovery::HostConverter.unused_ip_for_host(host)
       if host.save
         success_options = { :success_redirect => host_path(host), :redirect_xhr => request.xhr? }
         success_options[:success_msg] = success_message if success_message
@@ -198,15 +199,17 @@ class DiscoveredHostsController < ::ApplicationController
 
   def setup_host_class_variables
     if @host.hostgroup
+      subnet = @host.hostgroup.subnet || @host.subnet
+      subnet6 = @host.hostgroup.subnet6 || @host.subnet6
       @architecture    = @host.hostgroup.architecture
       @operatingsystem = @host.hostgroup.operatingsystem
       @environment     = @host.hostgroup.environment
       @domain          = @host.hostgroup.domain
-      @subnet          = @host.hostgroup.subnet
+      @subnet          = subnet
+      @subnet6         = subnet6
       @compute_profile = @host.hostgroup.compute_profile
       @realm           = @host.hostgroup.realm
-      @host.interfaces.first.assign_attributes(subnet: @subnet,
-                                               domain: @domain)
+      @host.interfaces.first.assign_attributes(subnet: subnet, subnet6: subnet6, domain: @domain)
       @host.environment = @environment
     end
   end

data/app/controllers/discovery_rules_controller.rb

@@ -28,7 +28,7 @@ class DiscoveryRulesController < ApplicationController
   end
 
   def update
-    if @discovery_rule.update_attributes(discovery_rule_params)
+    if @discovery_rule.update(discovery_rule_params)
       process_success
     else
       process_error

data/app/models/discovery_rule.rb

@@ -22,7 +22,7 @@ class DiscoveryRule < ApplicationRecord
   before_validation :enforce_taxonomy
 
   belongs_to :hostgroup
-  has_many :hosts, :dependent => :nullify
+  has_many_hosts :dependent => :nullify
 
   scoped_search :on => :name, :complete_value => :true
   scoped_search :on => :priority, :only_explicit => true

data/app/models/host/discovered.rb

@@ -44,9 +44,13 @@ class Host::Discovered < ::Host::Base
 
   # Discovery import workflow:
   # discovered#import_host ->
-  #  discovered#import_facts -> base#import_facts -> base#parse_facts ->
-  #  discovered#populate_fields_from_facts -> base#populate_fields_from_facts -> base#set_interfaces
-  #  discovered#populate_discovery_fields_from_facts
+  # ForemanDiscovery::HostFactImporter#import_facts ->
+  # ::HostFactImporter#import_facts ->
+  # ::HostFactImporter#parse_facts ->
+  # discovered#populate_fields_from_facts ->
+  # base#populate_fields_from_facts ->
+  # base#set_interfaces ->
+  # discovered#populate_discovery_fields_from_facts
   def self.import_host facts
     raise(::Foreman::Exception.new(N_("Invalid facts, must be a Hash"))) unless facts.is_a?(Hash) || facts.is_a?(ActionController::Parameters)
 
@@ -92,19 +96,11 @@ class Host::Discovered < ::Host::Base
 
     # and save (interfaces are created via puppet parser extension)
     host.save(:validate => false) if host.new_record?
-    raise ::Foreman::Exception.new(N_("Facts could not be imported")) unless host.import_facts(facts)
+    importer = ForemanDiscovery::HostFactImporter.new(host)
+    raise ::Foreman::Exception.new(N_("Facts could not be imported")) unless importer.import_facts(facts)
     host
   end
 
-  def import_facts(facts)
-    # Discovered Hosts won't report in via puppet, so we can use that field to
-    # record the last time it sent facts...
-    self.last_report = Time.now
-    # Set the correct facts type for new foreman facts importing code.
-    facts[:_type] = :foreman_discovery
-    super(facts)
-  end
-
   def setup_clone
     # Nic::Managed needs this method but Discovered hosts shouldn't
     # be doing orchestration anyway...
@@ -137,33 +133,55 @@ class Host::Discovered < ::Host::Base
     subnet.present? && subnet.discovery.present?
   end
 
-  def proxy_url
-    proxied? ? subnet.discovery.url + "/discovery/#{self.ip}" : "https://#{self.ip}:8443"
+  def proxy_url(node_ip)
+    proxied? ? subnet.discovery.url + "/discovery/#{node_ip}" : "https://#{node_ip}:8443"
   end
 
   def refresh_facts
-    facts = ::ForemanDiscovery::NodeAPI::Inventory.new(:url => proxy_url).facter
+    facts = ::ForemanDiscovery::NodeAPI::Inventory.new(:url => proxy_url(self.ip)).facter
     self.class.import_host facts
-    import_facts facts
+    ::ForemanDiscovery::HostFactImporter.new(self).import_facts facts
   rescue => e
     ::Foreman::Logging.exception("Unable to get facts from proxy", e)
     raise ::Foreman::WrappedException.new(e, N_("Could not get facts from proxy %{url}: %{error}"), :url => proxy_url, :error => e)
   end
 
-  def reboot
-    resource = ::ForemanDiscovery::NodeAPI::Power.service(:url => proxy_url)
-    resource.reboot
-  rescue => e
-    ::Foreman::Logging.exception("Unable to reboot #{name}", e)
-    raise ::Foreman::WrappedException.new(e, N_("Unable to reboot %{name} via %{url}: %{msg}"), :name => name, :url => proxy_url, :msg => e.to_s)
-  end
-
-  def kexec json
-    resource = ::ForemanDiscovery::NodeAPI::Power.service(:url => proxy_url)
-    resource.kexec json
-  rescue => e
-    ::Foreman::Logging.exception("Unable to perform kexec on #{name}", e)
-    raise ::Foreman::WrappedException.new(e, N_("Unable to perform kexec on %{name} via %{url}: %{msg}"), :name => name, :url => proxy_url, :msg => e.to_s)
+  def reboot(old_ip = nil, new_ip = nil)
+    # perform the action against the original lease as well as the new reservation
+    ips = [old_ip, new_ip, self.ip].compact.uniq
+    logger.debug "Performing reboot calls against #{ips.to_sentence}, facts left #{facts.count}"
+    ips.each do |next_ip|
+      begin
+        node_url = proxy_url(next_ip)
+        logger.debug "Performing reboot call against #{node_url}"
+        resource = ::ForemanDiscovery::NodeAPI::Power.service(:url => node_url)
+        return true if resource.reboot
+      rescue => e
+        msg = N_("Unable to perform reboot on %{name} (%{url}): %{msg}")
+        ::Foreman::Logging.exception(msg % { :name => name, :url => node_url, :msg => e.to_s }, e)
+      end
+    end
+    msg = N_("Unable to perform %{action} on %{ips}")
+    raise ::Foreman::Exception.new(msg, action: "reboot", ips: ips.to_sentence)
+  end
+
+  def kexec(json, old_ip = nil, new_ip = nil)
+    # perform the action against the original lease as well as the new reservation
+    ips = [old_ip, new_ip, self.ip].compact.uniq
+    logger.debug "Performing kexec calls against #{ips.to_sentence}, #{facts.count} facts left"
+    ips.each do |next_ip|
+      begin
+        node_url = proxy_url(next_ip)
+        logger.debug "Performing kexec call against #{node_url}"
+        resource = ::ForemanDiscovery::NodeAPI::Power.service(:url => node_url)
+        return true if resource.kexec(json)
+      rescue => e
+        msg = N_("Unable to perform kexec on %{name} (%{url}): %{msg}")
+        ::Foreman::Logging.exception(msg % { :name => name, :url => node_url, :msg => e.to_s }, e)
+      end
+    end
+    msg = N_("Unable to perform %{action} on %{ips}")
+    raise ::Foreman::Exception.new(msg, action: "kexec", ips: ips.to_sentence)
   end
 
   def self.model_name

data/app/models/host/managed_extensions.rb

@@ -27,7 +27,7 @@ module Host::ManagedExtensions
   end
 
   def setReboot
-    old.becomes(Host::Discovered).reboot
+    old.becomes(Host::Discovered).reboot(old.ip, ip)
     # It is too late to report error in the post_queue, we catch them and
     # continue. If flash is implemented for new hosts (http://projects.theforeman.org/issues/10559)
     # we can report the error to the user perhaps.
@@ -55,7 +55,7 @@ module Host::ManagedExtensions
   end
 
   def setKexec
-    old.becomes(Host::Discovered).kexec(render_kexec_template.to_json)
+    old.becomes(Host::Discovered).kexec(render_kexec_template.to_json, old.ip, ip)
     true
   rescue ::Foreman::Exception => e
     Foreman::Logging.exception("Unable to kexec", e)

data/app/models/setting/discovered.rb

@@ -8,41 +8,36 @@ class Setting::Discovered < ::Setting
   BLANK_ATTRS << 'discovery_facts_hardware'
   BLANK_ATTRS << 'discovery_facts_network'
   BLANK_ATTRS << 'discovery_facts_ipmi'
-  BLANK_ATTRS << 'discovery_prefix'
 
-  def self.load_defaults
-    # Check the table exists
-    return unless super
+  STRING_PRESENCE_ATTRS = ['discovery_hostname', 'discovery_prefix']
+  validates :value, :presence => true, :if => proc { |s| STRING_PRESENCE_ATTRS.include?(s.name) }
 
-    Setting.transaction do
-      [
-        self.set('discovery_location', N_("The default location to place discovered hosts in"), "", N_("Discovery location"), nil, { :collection => Proc.new {Hash[Location.all.map{|loc| [loc[:title], loc[:title]]}]} }),
-        self.set('discovery_organization', N_("The default organization to place discovered hosts in"), "", N_("Discovery organization"), nil, { :collection => Proc.new {Hash[Organization.all.map{|org| [org[:title], org[:title]]}]} }),
-        self.set('discovery_fact', N_("Fact name to use for primary interface detection"), "discovery_bootif", N_("Interface fact")),
-        self.set('discovery_auto_bond', N_("Automatic bond interface (if another interface is detected on the same VLAN via LLDP)"), false, N_("Create bond interfaces")),
-        self.set('discovery_clean_facts', N_("Clean all reported facts during provisioning (except discovery facts)"), false, N_("Clean all facts")),
-        self.set('discovery_hostname', N_("List of facts to use for the hostname (separated by comma, first wins)"), "discovery_bootif", N_("Hostname facts")),
-        self.set('discovery_auto', N_("Automatically provision newly discovered hosts, according to the provisioning rules"), false, N_("Auto provisioning")),
-        self.set('discovery_reboot', N_("Automatically reboot or kexec discovered host during provisioning"), true, N_("Reboot")),
-        self.set('discovery_prefix', N_("The default prefix to use for the host name, must start with a letter"), "mac", N_("Hostname prefix")),
-        self.set('discovery_fact_column', N_("Extra facter columns to show in host lists (separate by comma)"), "", N_("Fact columns")),
-        self.set('discovery_facts_highlights', N_("Regex to organize facts for highlights section - e.g. ^(abc|cde)$"), "", N_("Highlighted facts")),
-        self.set('discovery_facts_storage', N_("Regex to organize facts for storage section"), "", N_("Storage facts")),
-        self.set('discovery_facts_software', N_("Regex to organize facts for software section"), "", N_("Software facts")),
-        self.set('discovery_facts_hardware', N_("Regex to organize facts for hardware section"), "", N_("Hardware facts")),
-        self.set('discovery_facts_network', N_("Regex to organize facts for network section"), "", N_("Network facts")),
-        self.set('discovery_facts_ipmi', N_("Regex to organize facts for ipmi section"), "", N_("IPMI facts")),
-        self.set('discovery_lock', N_("Automatically generate PXE configuration to pin a newly discovered host to discovery"), false, N_("Lock PXE")),
-        self.set('discovery_pxelinux_lock_template', N_("PXELinux template to be used when pinning a host to discovery"), 'pxelinux_discovery', N_("Locked PXELinux template name"), nil, { :collection => Proc.new {Hash[ProvisioningTemplate.where(:template_kind => TemplateKind.find_by_name(:snippet)).map{|template| [template[:name], template[:name]]}]} }),
-        self.set('discovery_pxegrub_lock_template', N_("PXEGrub template to be used when pinning a host to discovery"), 'pxegrub_discovery', N_("Locked PXEGrub template name"), nil, { :collection => Proc.new {Hash[ProvisioningTemplate.where(:template_kind => TemplateKind.find_by_name(:snippet)).map{|template| [template[:name], template[:name]]}]} }),
-        self.set('discovery_pxegrub2_lock_template', N_("PXEGrub2 template to be used when pinning a host to discovery"), 'pxegrub2_discovery', N_("Locked PXEGrub2 template name"), nil, { :collection => Proc.new {Hash[ProvisioningTemplate.where(:template_kind => TemplateKind.find_by_name(:snippet)).map{|template| [template[:name], template[:name]]}]} }),
-        self.set('discovery_always_rebuild_dns', N_("Force DNS entries creation when provisioning discovered host"), true, N_("Force DNS")),
-        self.set('discovery_error_on_existing', N_("Do not allow to discover existing managed host matching MAC of a provisioning NIC (errors out early)"), false, N_("Error on existing NIC")),
-        self.set('discovery_naming', N_("Discovery hostname naming pattern"), 'Fact', N_("Type of name generator"), nil, {:collection => Proc.new {::Host::Discovered::NAMING_PATTERNS} }),
-      ].compact.each { |s| self.create s.update(:category => "Setting::Discovered")}
-    end
-
-    true
+  def self.default_settings
+    [
+      self.set('discovery_location', N_("The default location to place discovered hosts in"), "", N_("Discovery location"), nil, { :collection => Proc.new {Hash[Location.all.map{|loc| [loc[:title], loc[:title]]}]} }),
+      self.set('discovery_organization', N_("The default organization to place discovered hosts in"), "", N_("Discovery organization"), nil, { :collection => Proc.new {Hash[Organization.all.map{|org| [org[:title], org[:title]]}]} }),
+      self.set('discovery_fact', N_("Fact name to use for primary interface detection"), "discovery_bootif", N_("Interface fact")),
+      self.set('discovery_auto_bond', N_("Automatic bond interface (if another interface is detected on the same VLAN via LLDP)"), false, N_("Create bond interfaces")),
+      self.set('discovery_clean_facts', N_("Clean all reported facts during provisioning (except discovery facts)"), false, N_("Clean all facts")),
+      self.set('discovery_hostname', N_("List of facts to use for the hostname (separated by comma, first wins)"), "discovery_bootif", N_("Hostname facts")),
+      self.set('discovery_auto', N_("Automatically provision newly discovered hosts, according to the provisioning rules"), false, N_("Auto provisioning")),
+      self.set('discovery_reboot', N_("Automatically reboot or kexec discovered host during provisioning"), true, N_("Reboot")),
+      self.set('discovery_prefix', N_("The default prefix to use for the host name, must start with a letter"), "mac", N_("Hostname prefix")),
+      self.set('discovery_fact_column', N_("Extra facter columns to show in host lists (separate by comma)"), "", N_("Fact columns")),
+      self.set('discovery_facts_highlights', N_("Regex to organize facts for highlights section - e.g. ^(abc|cde)$"), "", N_("Highlighted facts")),
+      self.set('discovery_facts_storage', N_("Regex to organize facts for storage section"), "", N_("Storage facts")),
+      self.set('discovery_facts_software', N_("Regex to organize facts for software section"), "", N_("Software facts")),
+      self.set('discovery_facts_hardware', N_("Regex to organize facts for hardware section"), "", N_("Hardware facts")),
+      self.set('discovery_facts_network', N_("Regex to organize facts for network section"), "", N_("Network facts")),
+      self.set('discovery_facts_ipmi', N_("Regex to organize facts for ipmi section"), "", N_("IPMI facts")),
+      self.set('discovery_lock', N_("Automatically generate PXE configuration to pin a newly discovered host to discovery"), false, N_("Lock PXE")),
+      self.set('discovery_pxelinux_lock_template', N_("PXELinux template to be used when pinning a host to discovery"), 'pxelinux_discovery', N_("Locked PXELinux template name"), nil, { :collection => Proc.new {Hash[ProvisioningTemplate.where(:template_kind => TemplateKind.find_by_name(:snippet)).map{|template| [template[:name], template[:name]]}]} }),
+      self.set('discovery_pxegrub_lock_template', N_("PXEGrub template to be used when pinning a host to discovery"), 'pxegrub_discovery', N_("Locked PXEGrub template name"), nil, { :collection => Proc.new {Hash[ProvisioningTemplate.where(:template_kind => TemplateKind.find_by_name(:snippet)).map{|template| [template[:name], template[:name]]}]} }),
+      self.set('discovery_pxegrub2_lock_template', N_("PXEGrub2 template to be used when pinning a host to discovery"), 'pxegrub2_discovery', N_("Locked PXEGrub2 template name"), nil, { :collection => Proc.new {Hash[ProvisioningTemplate.where(:template_kind => TemplateKind.find_by_name(:snippet)).map{|template| [template[:name], template[:name]]}]} }),
+      self.set('discovery_always_rebuild_dns', N_("Force DNS entries creation when provisioning discovered host"), true, N_("Force DNS")),
+      self.set('discovery_error_on_existing', N_("Do not allow to discover existing managed host matching MAC of a provisioning NIC (errors out early)"), false, N_("Error on existing NIC")),
+      self.set('discovery_naming', N_("Discovery hostname naming pattern"), 'Fact', N_("Type of name generator"), nil, {:collection => Proc.new {::Host::Discovered::NAMING_PATTERNS} }),
+    ]
   end
 
   def self.discovery_fact_column_array

data/app/services/foreman_discovery/fact_parser.rb

@@ -6,7 +6,7 @@ module ForemanDiscovery
       raise(::Foreman::Exception.new(N_("Discovered host '%{host}' has all NICs filtered out, filter: %{filter}") %
         {:host => host, :filter => Setting[:ignored_interface_identifiers]})) if interfaces.size == 0
       bootif_mac = FacterUtils::bootif_mac(facts).try(:downcase)
-      detected = interfaces.detect { |_, values| values[:macaddress].try(:downcase) == bootif_mac && values[:ipaddress].present? }
+      detected = interfaces.detect { |_, values| values[:macaddress].try(:downcase) == bootif_mac && (values[:ipaddress].present? || values[:ipaddress6].present?) }
       Rails.logger.debug "Discovery fact parser detected primary interface: #{detected}"
       # return the detected interface as array [name, facts]
       detected || raise(::Foreman::Exception.new(N_("Unable to find primary NIC with %{mac} specified via '%{fact}', NIC filter: %{filter}") %

data/app/services/foreman_discovery/host_converter.rb

@@ -1,7 +1,6 @@
 class ForemanDiscovery::HostConverter
-
   # Converts discovered host to managed host without uptading the database.
-  # Record must be saved explicitly (using save! or update_attributes! or similar).
+  # Record must be saved explicitly (using save! or update! or similar).
   # Creates shallow copy.
   def self.to_managed(original_host, set_managed = true, set_build = true, added_attributes = {})
     host = original_host.becomes(::Host::Managed)
@@ -35,4 +34,41 @@ class ForemanDiscovery::HostConverter
     host.build = true
   end
 
+  def self.unused_ip_for_subnet(subnet, mac, existing_ip)
+    # prefer existing reservation to prevent conflicts
+    existing_rec = subnet&.dhcp_proxy&.record(subnet.network, mac)
+
+    if existing_rec && existing_rec.type == "reservation"
+      # reuse the reservation
+      existing_rec.ip
+    else
+      # no reservation - find new unused IP
+      ipam = subnet.unused_ip(mac)
+      raise(::Foreman::Exception.new(N_("IPAM must be configured for subnet '%s'"), subnet)) unless ipam.present?
+
+      # None IPAM returns nil - in that case keep the current address
+      suggested_ip = ipam.suggest_ip
+      suggested_ip.nil? ? existing_ip : suggested_ip
+    end
+  end
+
+  def self.unused_ip_for_host(host, new_subnet = nil, new_subnet6 = nil)
+    host.interfaces.each do |interface|
+      next unless interface.managed?
+
+      interface.subnet = new_subnet if new_subnet
+      interface.subnet6 = new_subnet6 if new_subnet6
+      interface.ip = unused_ip_for_subnet(interface.subnet, interface.mac, interface.ip) if interface.subnet
+      interface.ip6 = unused_ip_for_subnet(interface.subnet6, interface.mac, interface.ip6) if interface.subnet6
+    end
+  end
+
+  def self.change_subnet_and_unused_ip(host, hostgroup)
+    if host.subnet != hostgroup.subnet || host.subnet6 != hostgroup.subnet6
+      Rails.logger.debug "Discovered host subnets #{[host.subnet, host.subnet6]} do not match hostgroup subnets #{[hostgroup.subnet, hostgroup.subnet6]}"
+      unused_ip_for_host(host, host.hostgroup.subnet, host.hostgroup.subnet6)
+    else
+      Rails.logger.debug "Discovered host subnets #{[host.subnet, host.subnet6]} match hostgroup subnets"
+    end
+  end
 end

data/app/services/foreman_discovery/host_fact_importer.rb

@@ -0,0 +1,10 @@
+class ForemanDiscovery::HostFactImporter < ::HostFactImporter
+    def import_facts(facts)
+        # Discovered Hosts won't report in via puppet, so we can use that field to
+        # record the last time it sent facts...
+        host.last_report = Time.now
+        # Set the correct facts type for new foreman facts importing code.
+        facts[:_type] = :foreman_discovery
+        super(facts)
+    end
+end

data/app/services/foreman_discovery/import_hooks/subnet_and_taxonomy.rb

@@ -4,14 +4,15 @@ module ForemanDiscovery
     class SubnetAndTaxonomy < ImportHook
       def after_populate
         primary_ip = host.primary_interface.ip
+        primary_ip6 = host.primary_interface.ip6
 
-        unless primary_ip
+        unless primary_ip || primary_ip6
           logger.warn "Unable to assign subnet - reboot trigger may not be possible, primary interface is missing IP address"
           return
         end
 
         # set subnet
-        set_subnet(primary_ip)
+        set_subnets(primary_ip, primary_ip6)
         # set location and organization
         set_location
         set_organization
@@ -19,18 +20,9 @@ module ForemanDiscovery
 
       private
 
-      def set_subnet(ip)
-        host.primary_interface.subnet = suggested_subnet(ip)
-      end
-
-      def suggested_subnet(ip)
-        subnet = Subnet.subnet_for(ip)
-        if subnet
-          logger.info "Detected subnet: #{subnet} with taxonomy #{subnet.organizations.collect(&:name)}/#{subnet.locations.collect(&:name)}"
-        else
-          logger.warn "Subnet could not be detected for #{ip}"
-        end
-        subnet
+      def set_subnets(ip, ip6)
+        host.primary_interface.subnet = ForemanDiscovery::SubnetSuggestion.for(ip: ip, kind: 'IPv4') if ip
+        host.primary_interface.subnet6 = ForemanDiscovery::SubnetSuggestion.for(ip: ip6, kind: 'IPv6') if ip6
       end
 
       def set_location

data/app/services/foreman_discovery/node_api/node_resource.rb

@@ -6,6 +6,7 @@ module ForemanDiscovery::NodeAPI
       @args = args
       @connect_params = {
         :headers => { :accept => :json },
+        :timeout => 20, # tighter timeout, discovery performs up to two calls per request
       }
 
       if url.match(/^https/i) && Rails.env != "test"

data/app/services/foreman_discovery/subnet_suggestion.rb

@@ -0,0 +1,26 @@
+module ForemanDiscovery
+  class SubnetSuggestion
+    attr_accessor :ip, :kind
+
+    def self.for(ip:, kind:)
+      new(ip: ip, kind: kind).()
+    end
+
+    def initialize(ip:, kind:)
+      self.ip = ip
+      self.kind = kind
+    end
+
+    def call
+      return unless ip
+
+      subnet = Subnet.unscoped.subnet_for(ip)
+      if subnet
+        Rails.logger.info "Detected #{kind} subnet: #{subnet} with taxonomy #{subnet.organizations.collect(&:name)}/#{subnet.locations.collect(&:name)}"
+      else
+        Rails.logger.info "#{kind} subnet could not be detected for #{ip}"
+      end
+      subnet
+    end
+  end
+end

data/app/views/foreman_discovery/debian_kexec.erb

@@ -12,9 +12,10 @@ environments. The template must generate JSON format with the following items
 "kernel", "initram", "append" and "extra". The kexec command is composed in
 the following way:
 
-kexec --force --reset-vga --append=$append --initrd=$initram $extra $kernel
+kexec --force --debug --append=$append --initrd=$initram $extra $kernel
 
 Please read kexec(8) man page for more information about semantics.
+Extra options like --reset-vga can be set via "extra" array.
 -%>
 <%
   mac = @host.facts['discovery_bootif']
@@ -28,7 +29,7 @@ Please read kexec(8) man page for more information about semantics.
   options << @host.facts['append']
   options << "domain=#{@host.domain}"
   options << 'console-setup/ask_detect=false console-setup/layout=USA console-setup/variant=USA keyboard-configuration/layoutcode=us localechooser/translation/warn-light=true localechooser/translation/warn-severe=true'
-  options << "locale=#{@host.params['lang'] || 'en_US'}"
+  options << "locale=#{host_param('lang') || 'en_US'}"
   options << "inst.stage2=#{@host.operatingsystem.medium_uri(@host)}" if @host.operatingsystem.name.match(/Atomic/i)
 -%>
 {