foreman_discovery 15.1.0 → 16.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 279682fd72f6cdf11166d4feb018e13f7fbe17137a23186507178000a387aeb0
-  data.tar.gz: 2d2fb544411f4db3594f0cd46ddc2a89afe216a12fdbdff769fc39e63e78879d
+  metadata.gz: 6ac7d31fa470fc53b81672be0f21309d8df92eef200481143055c9ad3af467be
+  data.tar.gz: a71a4512c1bd4f90d0163dfaf07b5a670112f4825395a004c723e2f6da98d8ba
 SHA512:
-  metadata.gz: 5ffd16f5840e43beed5ae06306292569d445027b4a0a48a547cf16e9e3f8e8eba9ccb94796cbe20d723b478c02e5fa0a0b2667f1fa8417b1a0520575cd8f121a
-  data.tar.gz: 1e7defe44767c8dc6d2716d7a5eec5a30b57ef24008cf4a10ec3e6e88bc766b8fcd7a147d44d9ccd032a5ace60f981e6fd9502217760b30746c336b9bf84486f
+  metadata.gz: e271f6b3990930e40277c8921254e1fd45ae89796b7d4693816d6083eb5fdcce078eb310b73579bab68e7c07c51c3e3ebf2bf93242339e6b62424d6bc48692df
+  data.tar.gz: ae858e8f800237891cb92ce4868d43820e9f20e409c26f0bd887df6bef3c783c9e3dffbb90ce8b91971a3b5b331334593c0968712a93dc3c5c7df174346651f3

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

@@ -102,9 +102,16 @@ module Api
         state = true
         User.as_anonymous_admin do
           @discovered_host = Host::Discovered.import_host(facts)
-          Rails.logger.warn 'Discovered facts import unsuccessful, skipping auto provisioning' unless @discovered_host
-          if Setting['discovery_auto'] && @discovered_host && (rule = find_discovery_rule(@discovered_host))
-            state = perform_auto_provision(@discovered_host, rule)
+          # Host::Based.set_taxonomies sets taxonomies during import from either
+          # facts or via Global Foreman setting "default_taxonomy", reset it back so
+          # the anonymous admin can see all records. We set taxonomy explicitly via
+          # discovery SubnetAndTaxonomy import hook and enforce taxnomy manually
+          # in find_discovery_rule method via validate_rule_by_taxonomy.
+          Taxonomy.no_taxonomy_scope do
+            Rails.logger.warn 'Discovered facts import unsuccessful, skipping auto provisioning' unless @discovered_host
+            if Setting['discovery_auto'] && @discovered_host && (rule = find_discovery_rule(@discovered_host))
+              state = perform_auto_provision(@discovered_host, rule)
+            end
           end
         end
         process_response state

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

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

@@ -137,12 +137,12 @@ 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
   rescue => e
@@ -150,20 +150,42 @@ class Host::Discovered < ::Host::Base
     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

@@ -10,39 +10,32 @@ class Setting::Discovered < ::Setting
   BLANK_ATTRS << 'discovery_facts_ipmi'
   BLANK_ATTRS << 'discovery_prefix'
 
-  def self.load_defaults
-    # Check the table exists
-    return unless super
-
-    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/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/discovered_hosts/_discovered_host_modal.html.erb

@@ -17,6 +17,8 @@
           <% if show_location_tab? %>
             <%= select_f f, :location_id, Location.my_locations, :id, :to_label, {}, {:size => 'col-md-10'} %>
           <% end %>
+
+          <div>Changing the Host's Subnet is not possible via Customize Host form, use Create Host or Auto provisioning and set the desired Subnet in the Hostgroup.</div>
         </div>
         <div class="modal-footer">
           <button type="button" class="btn btn-default" data-dismiss="modal">Cancel</button>

data/app/views/foreman_discovery/debian_kexec.erb

@@ -28,7 +28,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)
 -%>
 {

data/config/routes.rb

@@ -6,6 +6,8 @@ Rails.application.routes.draw do
   post 'os_selected_discovered_hosts'           => 'hosts#os_selected'
   post 'medium_selected_discovered_hosts'       => 'hosts#medium_selected'
 
+  get 'discovered_hosts/help', :action => :welcome, :controller => 'discovered_hosts'
+
   constraints(:id => /[^\/]+/) do
     resources :discovered_hosts, :except => [:new, :create] do
       member do

data/db/migrate/20150512150432_remove_old_discovery_reader_permissions.rb

@@ -1,7 +1,7 @@
 class RemoveOldDiscoveryReaderPermissions < ActiveRecord::Migration[4.2]
   def up
     Permission.where("name like '%_discovery_rules' and resource_type is null").each do |permission|
-      permission.update_attributes(:resource_type => 'DiscoveryRule')
+      permission.update(:resource_type => 'DiscoveryRule')
     end
   end
 

data/db/migrate/20151023144501_regenerate_red_hat_kexec.rb

@@ -1,7 +1,7 @@
 class RegenerateRedHatKexec < ActiveRecord::Migration[4.2]
   def up
     t = ProvisioningTemplate.find_by_name("Discovery Red Hat kexec")
-    t.update_attributes(:template => t.template.sub(/rescue ''$/, 'if mac')) if t
+    t.update(:template => t.template.sub(/rescue ''$/, 'if mac')) if t
   end
 
   def down

data/db/migrate/20180412124505_add_priority_score_to_discovery_rules.rb

@@ -9,7 +9,7 @@
     # and makes sure there are no two entities with the same priority.
     DiscoveryRules.reset_column_information
     DiscoveryRules.unscoped.reorder(:priority, :created_at).find_each do |rule|
-      rule.update_attributes!(:priority => score)
+      rule.update!(:priority => score)
       score += delta
     end
     change_column :discovery_rules, :priority, :integer, null: false

data/extra/discover-host

@@ -3,10 +3,12 @@ require 'optparse'
 require 'json'
 require 'rest-client'
 
-def find_base name="default"
-  return name if File.exists?(name)
+def find_base name = "default"
+  return name if File.exist?(name)
+
   file = File.absolute_path(File.dirname(__FILE__) + "../../test/facts/#{name}.json")
-  raise "Unable to find file #{file}" unless File.exists?(file)
+  raise "Unable to find file #{file}" unless File.exist?(file)
+
   file
 end
 
@@ -14,6 +16,7 @@ base = find_base
 version = "3.4.0"
 interfaces = []
 preserve_interfaces = false
+use_facts_endpoint = false
 primary = nil
 bootif = nil
 url = "http://admin:changeme@localhost:3000"
@@ -38,6 +41,10 @@ OptionParser.new do |opts|
     preserve_interfaces = true
   end
 
+  opts.on("-a", "--facts", "Use host facts endpoint") do |v|
+    use_facts_endpoint = true
+  end
+
   opts.on("-pNAME", "--primary=NAME", "Interface to use as primary (defaults to the first one)") do |v|
     primary = v
   end
@@ -70,8 +77,8 @@ unless preserve_interfaces
   json["interfaces"] = interfaces.map{|i| i.first}.join(',')
   interfaces.each do |iface|
     name, subnet, ipo, mac = iface
-    mac = (["52"] + 5.times.map { '%02x' % rand(0..255) }).join(':') unless mac
-    ipo = rand(1..253) unless ipo
+    mac ||= (["52"] + 5.times.map { '%02x' % rand(0..255) }).join(':')
+    ipo ||= rand(1..253)
     ip = "192.168.#{subnet}.#{ipo}"
     json["macaddress_#{name}"] = mac
     json["ipaddress_#{name}"] = ip
@@ -83,7 +90,14 @@ unless preserve_interfaces
   end
 end
 puts JSON.pretty_generate(json)
-resource = RestClient::Resource.new(url + "/api/v2/discovered_hosts/facts", verify_ssl: OpenSSL::SSL::VERIFY_NONE)
-response = resource.post({"facts" => json}.to_json, {content_type: :json, accept: :json})
+if use_facts_endpoint
+  endpoint = url + "/api/v2/hosts/facts"
+  payload = {"facts" => json, "name" => json["hostname"] || json["networking"]["fqdn"]}
+else
+  endpoint = url + "/api/v2/discovered_hosts/facts"
+  payload = {"facts" => json}
+end
+resource = RestClient::Resource.new(endpoint, verify_ssl: OpenSSL::SSL::VERIFY_NONE)
+response = resource.post(payload.to_json, {content_type: :json, accept: :json})
 puts response.code
 puts response.body