foreman_discovery 5.0.2 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a15855ae2fea53392d85bbf74e58ad95a03e2f31
-  data.tar.gz: 4618507b72076897b1c03405964c7a544fa1a199
+  metadata.gz: 50f5e89c539ec3eb3bee287fc9251f4e0dad65f9
+  data.tar.gz: ccad5c9dcb424f30bd2802aaec3489b55aba7e71
 SHA512:
-  metadata.gz: 87adf7fa08550375f25e021ed9fe6749acf5d4ef09aad6370b9630e34ac5066cd9fb0009a7a0cbae071da765da542f30e6ea13e641195f42130adacd9edffffa
-  data.tar.gz: e03789da0d07c002a7098816e5b02875d55fdf7019cfcdfbab0076b13d2b9fa3b9feefbf657b92d539ec2690a49064bda090d6bac0c3e504fbf69666c7eaa62c
+  metadata.gz: 110b9578fc4bcf83d47e11254cbcd2c157268f2ba17c4aae6a9a21a47beeb68511b460f55d4427cbd88d7137d92dac1922589c2d4b20e48182799103e746f95c
+  data.tar.gz: c10cd4e42f0ac2c5d5a7eaa2b600a471a7f641e2d8a86fe3433201659813bba3f312a219f8efed4159697f0bbfd94ad39bd5c5d79f23fe95e43cdd738f796b11

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

@@ -94,13 +94,10 @@ module Api
 
       def facts
         state = true
-        @discovered_host, state = Host::Discovered.import_host_and_facts(params[:facts])
-        if Setting['discovery_auto']
-          if state && rule = find_discovery_rule(@discovered_host)
-            state = perform_auto_provision(@discovered_host, rule)
-          else
-            Rails.logger.warn "Discovered facts import unsuccessful, skipping auto provisioning"
-          end
+        @discovered_host = Host::Discovered.import_host(params[: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)
         end
         process_response state
       rescue Exception => e

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

@@ -35,6 +35,7 @@ module Api
           param :max_count, Integer, :desc => N_("enables to limit maximum amount of provisioned hosts per rule")
           param :priority, Integer, :desc => N_("puts the rules in order, low numbers go first. Must be greater then zero")
           param :enabled, :bool, :desc => N_("flag is used for temporary shutdown of rules")
+          param_group :taxonomies, ::Api::V2::BaseController
         end
       end
 

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

@@ -0,0 +1,11 @@
+module Api
+  module V2
+    module FactValuesControllerExtensions
+      extend ActiveSupport::Concern
+
+      included do
+        api :GET, "/discovered_hosts/:discovered_host_id/facts/", N_("List all fact values of a given discovered host")
+      end
+    end
+  end
+end

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

@@ -5,8 +5,8 @@ module Foreman::Controller::DiscoveredExtensions
   def find_discovery_rule host
     raise(::Foreman::Exception.new(N_("Unable to find a discovery rule, no host provided (check permissions)"))) if host.nil?
     Rails.logger.debug "Finding auto discovery rule for host #{host.name} (#{host.id})"
-    # for each discovery rule ordered by priority
-    DiscoveryRule.where(:enabled => true).order(:priority).each do |rule|
+    # rule with *lower* priority wins (older wins for same priority)
+    DiscoveryRule.where(:enabled => true).reorder(:priority, :created_at).each do |rule|
       max = rule.max_count
       usage = rule.hosts.size
       Rails.logger.debug "Found rule #{rule.name} (#{rule.id}) [#{usage}/#{max}]"
@@ -54,8 +54,11 @@ module Foreman::Controller::DiscoveredExtensions
     host.name = host.render_template(rule.hostname) unless rule.hostname.empty?
     # fallback to the original if template did not expand
     host.name = original_name if host.name.empty?
+    # explicitly set all inheritable attributes from hostgroup
+    host.attributes = host.apply_inherited_attributes(hostgroup_id: rule.hostgroup_id)
+    host.set_hostgroup_defaults
     # save! does not work here
-    host.save
+    host.save ? host : false
   end
 
   def perform_reboot_all hosts = Host::Discovered.all

data/app/controllers/discovered_hosts_controller.rb

@@ -38,7 +38,7 @@ class DiscoveredHostsController < ::ApplicationController
     get_interfaces
     @host.facts_hash.each do |key, value|
       value = number_to_human_size(value) if /size$/.match(key)
-      assign_fact_to_category(key, value) unless @interfaces.any? {|interface| key.include? interface[:identifier]}
+      assign_fact_to_category(key, value)
     end
     add_custom_facts
   end
@@ -50,20 +50,37 @@ class DiscoveredHostsController < ::ApplicationController
 
   def edit
     @host = ::ForemanDiscovery::HostConverter.to_managed(@host, true, false) unless @host.nil?
-    render :template => 'hosts/edit'
+    @host.attributes = @host.apply_inherited_attributes(params[:host]) unless params[:host].empty?
+    @host.set_hostgroup_defaults
+    setup_host_class_variables(@host)
+    @override_taxonomy = true
+    if params[:quick_submit]
+      perform_update(@host, _('Successfully provisioned %s') % @host.name)
+    else
+      render :template => 'hosts/edit'
+    end
   end
 
   def update
     @host = ::ForemanDiscovery::HostConverter.to_managed(@host)
     forward_url_options
+    @host.attributes = params[:host]
+
+    perform_update(@host)
+  end
+
+  def perform_update(host, success_message = nil)
     Taxonomy.no_taxonomy_scope do
-      if @host.update_attributes(params[:host])
-        process_success :success_redirect => host_path(@host), :redirect_xhr => request.xhr?
+      ::ForemanDiscovery::HostConverter.set_build_clean_facts(host)
+      if host.save
+        success_options = { :success_redirect => host_path(host), :redirect_xhr => request.xhr? }
+        success_options[:success_msg] = success_message if success_message
+        process_success success_options
       else
         taxonomy_scope
         load_vars_for_ajax
         offer_to_overwrite_conflicts
-        process_error :object => @host, :render => 'hosts/edit'
+        process_error :object => host, :render => 'hosts/edit'
       end
     end
   end
@@ -184,11 +201,23 @@ class DiscoveredHostsController < ::ApplicationController
 
   private
 
+  def setup_host_class_variables(host)
+    if host.hostgroup
+      @architecture    = host.hostgroup.architecture
+      @operatingsystem = host.hostgroup.operatingsystem
+      @environment     = host.hostgroup.environment
+      @domain          = host.hostgroup.domain
+      @subnet          = host.hostgroup.subnet
+      @compute_profile = host.hostgroup.compute_profile
+      @realm           = host.hostgroup.realm
+    end
+  end
+
   def init_regex_and_categories
     hightlights = Setting[:discovery_facts_highlights].empty? ? /^(productname|memorysize|manufacturer|architecture|macaddress$|processorcount|physicalprocessorcount|discovery_subnet|discovery_boot|ipaddress$)/ : Regexp.new(Setting[:discovery_facts_highlights])
     storage = Setting[:discovery_facts_storage].empty? ? /^blockdevice/ : Regexp.new(Setting[:discovery_facts_storage])
     hardware = Setting[:discovery_facts_hardware].empty? ? /^(hardw|manufacturer|memo|process)/ : Regexp.new(Setting[:discovery_facts__hardware])
-    network = Setting[:discovery_facts_network].empty? ? /^(ipaddress|interfaces|dhcp|fqdn|hostname|link|mtu|net|macaddress|wol|port|speed)/ : Regexp.new(Setting[:discovery_facts_network])
+    network = Setting[:discovery_facts_network].empty? ? /^(interfaces|dhcp|fqdn|hostname)/ : Regexp.new(Setting[:discovery_facts_network])
     software = Setting[:discovery_facts_software].empty? ? /^(bios|os|discovery)/ : Regexp.new(Setting[:discovery_facts_software])
     ipmi = Setting[:discovery_facts_ipmi].empty? ? /^ipmi/ : Regexp.new(Setting[:discovery_facts_ipmi])
     @regex_array = [hightlights, storage, hardware, network, software, ipmi, false]
@@ -196,7 +225,11 @@ class DiscoveredHostsController < ::ApplicationController
     @categories_names = [N_("Highlights"), N_("Storage"), N_("Hardware"), N_("Network"), N_("Software"), N_("IPMI"), N_("Miscellaneous")]
   end
 
-  def assign_fact_to_category(key, value )
+  def assign_fact_to_category(key, value)
+    if @interfaces.any? {|interface| key.include? interface[:identifier]}
+      @categories[3][key] = value
+      return
+    end
     @regex_array.each_with_index do |regex, index|
       if !regex
         @categories[index][key] = value
@@ -249,10 +282,12 @@ class DiscoveredHostsController < ::ApplicationController
   end
 
   def find_by_name(*includes)
-    params[:id].downcase! if params[:id].present?
-    @host = includes.empty? ? resource_base.find_by_id(params[:id]) : resource_base.includes(includes).find_by_id(params[:id])
-    @host ||= includes.empty? ? resource_base.find_by_name(params[:id]) : resource_base.includes(includes).find_by_name(params[:id])
-    return false unless @host
+    not_found and return false if (id = params[:id]).blank?
+    id.downcase!
+    @host = includes.empty? ? resource_base.find_by_id(id) : resource_base.includes(includes).find_by_id(id)
+    @host ||= includes.empty? ? resource_base.find_by_name(id) : resource_base.includes(includes).find_by_name(id)
+    not_found and return(false) unless @host
+    @host
   end
 
   def find_by_name_incl_subnet

data/app/controllers/discovery_rules_controller.rb

@@ -5,7 +5,7 @@ class DiscoveryRulesController < ApplicationController
   before_filter :find_resource, :only => [:edit, :update, :destroy, :enable, :disable, :auto_provision]
 
   def index
-    base = resource_base.search_for(params[:search], :order => (params[:order] || 'priority ASC'))
+    base = resource_base.search_for(params[:search], :order => (params[:order]))
     @discovery_rules = base.paginate(:page => params[:page]).includes(:hostgroup)
   end
 

data/app/helpers/discovered_hosts_helper.rb

@@ -1,5 +1,4 @@
 module DiscoveredHostsHelper
-
   def attach_flags(interface)
     flags = ""
     flags += "flag-primary " if interface[:primary]
@@ -12,28 +11,22 @@ module DiscoveredHostsHelper
   end
 
   def discovered_hosts_title_actions(host)
-    actions = [[_('Provision'),  hash_for_edit_discovered_host_path(:id => host)]]
-    actions <<  [_('Auto Provision'), hash_for_auto_provision_discovered_host_path(:id => host), :method => :post]
-    actions <<  [_('Refresh facts') ,hash_for_refresh_facts_discovered_host_path(:id => host)]
-    actions <<  [_('Reboot') ,hash_for_reboot_discovered_host_path(:id => host), :method => :put]
+    actions = [[_('Provision'), hash_for_edit_discovered_host_path(:id => host).merge(:auth_object => host, :permission => :provision_discovered_hosts)]]
+    actions <<  [_('Auto Provision'), hash_for_auto_provision_discovered_host_path(:id => host).merge(:auth_object => host, :permission => :auto_provision_discovered_hosts), :method => :post]
+    actions <<  [_('Refresh facts') ,hash_for_refresh_facts_discovered_host_path(:id => host).merge(:auth_object => host, :permission => :edit_discovered_hosts)]
+    actions <<  [_('Reboot') ,hash_for_reboot_discovered_host_path(:id => host).merge(:auth_object => host, :permission => :edit_discovered_hosts), :method => :put]
     title_actions(
         button_group(
-            link_to(_("Back"), :back)
-        ),
-        select_action_button( _("Select Action"), {},
-                              actions.map do |action|
-                                method = action[2] if action.size > 1
-                                link_to(action[0] , action[1], method)
-                              end.flatten
+            link_to(_("Back"), :back, :class => "btn btn-default")
         ),
+        select_action_button( _("Select Action"), {}, actions.map { |action| display_link_if_authorized(action[0] , action[1], action[2] || {}) }.flatten ),
       button_group(
-        link_to(_("Expand All"),"#",:class => "btn ",:onclick => "$('.glyphicon-plus-sign').toggleClass('glyphicon glyphicon-minus-sign glyphicon glyphicon-plus-sign');
+        link_to(_("Expand All"),"#",:class => "btn btn-default",:onclick => "$('.glyphicon-plus-sign').toggleClass('glyphicon glyphicon-minus-sign glyphicon glyphicon-plus-sign');
                 $('.facts-panel').addClass('collapse in').height('auto');"
         )
       ),
       button_group(
-        link_to(_("Delete"), hash_for_discovered_host_path(:id => host),
-                :class => "btn btn-danger", :confirm => _('Are you sure?'), :method => :delete)
+        display_delete_if_authorized(hash_for_discovered_host_path(:id => host).merge(:auth_object => host, :permission => :destroy_discovered_hosts), :class => "btn btn-danger", :data => { :confirm => _('Delete %s?') % host.name })
       )
     )
   end
@@ -68,7 +61,7 @@ module DiscoveredHostsHelper
       status_glyph = 'glyphicon-plus-sign'
       status_message = _('New in the last 24 hours')
       status_color = '#89A54E'
-    elsif host.last_report < 7.days.ago
+    elsif host.last_report.present? && host.last_report < 7.days.ago
       status_glyph = 'glyphicon-exclamation-sign'
       status_message = _('Not reported in more than 7 days')
       status_color = '#AA4643'
@@ -81,4 +74,28 @@ module DiscoveredHostsHelper
     "<span class='glyphicon #{status_glyph}' style='color: #{status_color}'
       title='#{status_message}'/>".html_safe
   end
+
+  def host_taxonomy_select(f, taxonomy)
+    # Add hidden field with taxonomy value to be updated by the form on submit
+    tax_html = super
+    tax_id = "#{taxonomy.to_s.downcase}_id"
+    selected_taxonomy = params[:host][tax_id] if params[:host]
+    if @override_taxonomy && selected_taxonomy
+      hidden_tax = f.hidden_field tax_id.to_sym, :value => selected_taxonomy
+      tax_html += hidden_tax
+    end
+    tax_html
+  end
+
+  def provision_button(host, authorization_options)
+    return '' unless authorized_for(authorization_options)
+
+    button_tag(
+      _('Provision'),
+      :type => :button,
+      :class => 'btn btn-sm btn-default',
+      :data => {
+        :toggle => 'modal',
+        :target => "#fixedPropertiesSelector-#{host.id}"})
+  end
 end

data/app/models/concerns/discovery_taxonomy_extensions.rb

@@ -0,0 +1,7 @@
+module DiscoveryTaxonomyExtensions
+  extend ActiveSupport::Concern
+  included do
+    has_many :discovered_hosts, :class_name => 'Host::Discovered'
+    before_destroy ActiveRecord::Base::EnsureNotUsedBy.new(:discovered_hosts)
+  end
+end

data/app/models/concerns/fact_value_extensions.rb

@@ -0,0 +1,8 @@
+module FactValueExtensions
+  extend ActiveSupport::Concern
+
+  included do
+    belongs_to :discovered_host, :class_name => "Host::Discovered", :foreign_key => :host_id
+    scoped_search :in => :discovered_host, :on => :id, :complete_enabled => false, :only_explicit => true, :rename => :discovered_host
+  end
+end

data/app/models/discovery_rule.rb

@@ -28,13 +28,11 @@ class DiscoveryRule < ActiveRecord::Base
   scoped_search :on => :enabled
   scoped_search :in => :hostgroup, :on => :name, :complete_value => true, :rename => :hostgroup
 
-  # with proc support, default_scope can no longer be chained
-  # include all default scoping here
   default_scope lambda {
-                  with_taxonomy_scope do
-                    order("discovery_rules.name")
-                  end
-                }
+    with_taxonomy_scope do
+      order('discovery_rules.priority, discovery_rules.created_at')
+    end
+  }
 
   def default_int_attributes
    self.max_count ||= 0

data/app/models/host/discovered.rb

@@ -1,5 +1,6 @@
 class Host::Discovered < ::Host::Base
   include ScopedSearchExtensions
+  include Foreman::Renderer
 
   attr_accessible :discovery_rule_id
 
@@ -30,7 +31,7 @@ class Host::Discovered < ::Host::Base
     where(taxonomy_conditions).order("hosts.created_at DESC")
   }
 
-  def self.import_host_and_facts facts
+  def self.import_host facts
     raise(::Foreman::Exception.new(N_("Invalid facts, must be a Hash"))) unless facts.is_a?(Hash)
 
     # filter facts
@@ -47,15 +48,21 @@ class Host::Discovered < ::Host::Base
     hostname = normalize_string_for_hostname("#{hostname_prefix}#{name_fact}")
     Rails.logger.warn "Hostname does not start with an alphabetical character" unless hostname.downcase.match /^[a-z]/
 
-    # create new host record
-    host = ::Host::Discovered.includes(:interfaces).find_by_name hostname
-    host ||= Host.new :name => hostname, :type => "Host::Discovered"
+    # find existing or create new host record
+    bootif_mac = FacterUtils::bootif_mac(facts).try(:downcase)
+    hosts = ::Nic::Managed.where(:mac => bootif_mac, :primary => true)
+    if hosts.size == 0
+      host = Host.new(:name => hostname, :type => "Host::Discovered")
+    else
+      Rails.logger.warn "Multiple discovered hosts found with MAC address #{name_fact}, choosing one" if hosts.size > 1
+      host = hosts.first.host
+    end
     host.type = "Host::Discovered"
 
     # and save (interfaces are created via puppet parser extension)
     host.save(:validate => false) if host.new_record?
-    state = host.import_facts(facts)
-    return host, state
+    raise ::Foreman::Exception.new(N_("Facts could not be imported")) unless host.import_facts(facts)
+    host
   end
 
   def import_facts facts
@@ -75,7 +82,7 @@ class Host::Discovered < ::Host::Base
     super
   end
 
-  def populate_fields_from_facts(facts = self.facts_hash, ignored_type)
+  def populate_fields_from_facts(facts = self.facts_hash, ignored_type = nil)
     # detect interfaces and primary interface using extensions
     parser = super(facts, :foreman_discovery)
 
@@ -92,13 +99,13 @@ class Host::Discovered < ::Host::Base
       self.primary_interface.subnet = subnet
       # set location and organization
       if SETTINGS[:locations_enabled]
-        self.location = Location.find_by_name(Setting[:discovery_location]) ||
+        self.location = Location.find_by_title(Setting[:discovery_location]) ||
           subnet.try(:locations).try(:first) ||
           Location.first
         Rails.logger.info "Assigned location: #{self.location}"
       end
       if SETTINGS[:organizations_enabled]
-        self.organization = Organization.find_by_name(Setting[:discovery_organization]) ||
+        self.organization = Organization.find_by_title(Setting[:discovery_organization]) ||
           subnet.try(:organizations).try(:first) ||
           Organization.first
         Rails.logger.info "Assigned organization: #{self.organization}"
@@ -108,6 +115,17 @@ class Host::Discovered < ::Host::Base
     end
     self.discovery_attribute_set = DiscoveryAttributeSet.where(:host_id => id).first_or_create
     self.discovery_attribute_set.update_attributes(import_from_facts)
+    # lock the host into discovery via PXE, if feature is enabled in settings
+    if Setting::Discovered.discovery_lock? && self.subnet.tftp?
+      begin
+        @host = self
+        Rails.logger.info "Locking discovered host #{self.mac} in subnet #{subnet}"
+        template = unattended_render(::ProvisioningTemplate.find_by_name(Setting['discovery_lock_template']).template)
+        subnet.tftp_proxy.set mac, :pxeconfig => template
+      rescue ::Foreman::Exception => e
+        ::Foreman::Logging.exception("Could not set tftp_proxy from proxy", e)
+      end
+    end
     self.save!
     parser
   end
@@ -144,7 +162,8 @@ class Host::Discovered < ::Host::Base
 
   def refresh_facts
     facts = ::ForemanDiscovery::NodeAPI::Inventory.new(:url => proxy_url).facter
-    self.class.import_host_and_facts facts
+    self.class.import_host facts
+    import_facts facts
   rescue Exception => e
     raise _("Could not get facts from proxy %{url}: %{error}") % {:url => proxy_url, :error => e}
   end

data/app/models/host/managed_extensions.rb

@@ -41,20 +41,12 @@ module Host::ManagedExtensions
     # no reboot on orchestration rollback
   end
 
-  def boot_url pxe_file
-    raise ::Foreman::Exception.new(N_("Operating system not set for host/hostgroup")) unless operatingsystem
-    base = operatingsystem.medium_uri(self)
-    raise ::Foreman::Exception.new(N_("Medium not set for host/hostgroup")) unless base
-    path = operatingsystem.url_for_boot(pxe_file)
-    operatingsystem.medium_vars_to_uri("#{base}/#{path}", architecture.name, operatingsystem).to_s
-  end
-
   def setKexec
     template = provisioning_template(:kind => 'kexec')
     raise ::Foreman::Exception.new(N_("Kexec template not associated with operating system")) unless template
     @host = self
-    @kernel = boot_url(:kernel)
-    @initrd = boot_url(:initrd)
+    # the following two attributes are overwritten by TFTP in preview mode (kept for compatibility)
+    @kernel, @initrd = operatingsystem.boot_files_uri(@host.medium, @host.architecture)
     json = unattended_render(template)
     old.becomes(Host::Discovered).kexec json
     true

data/app/models/setting/discovered.rb

@@ -16,50 +16,40 @@ class Setting::Discovered < ::Setting
 
     Setting.transaction do
       [
-        self.set('discovery_fact', N_("Fact name to use for primary interface detection"), "discovery_bootif"),
-        self.set('discovery_hostname', N_("List of facts to use for the hostname (separated by comma, first wins)"), "discovery_bootif"),
-        self.set('discovery_auto', N_("Automatically provision newly discovered hosts, according to the provisioning rules"), false),
-        self.set('discovery_reboot', N_("Automatically reboot discovered host during provisioning"), true),
-      ].compact.each { |s| self.create s.update(:category => "Setting::Discovered")}
-    end
-
-    Setting.transaction do
-      [
-        self.set('discovery_prefix', N_("The default prefix to use for the host name, must start with a letter"), "mac"),
-      ].compact.each { |s| self.create s.update(:category => "Setting::Discovered")}
-    end
-
-    Setting.transaction do
-      [
-        self.set('discovery_fact_column', N_("Extra facter columns to show in host lists (separate by comma)"), ""),
+        self.set('discovery_fact', N_("Fact name to use for primary interface detection"), "discovery_bootif", N_("Interface fact")),
+        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_lock_template', N_("PXE template to be used when pinning a host to discovery"), 'pxelinux_discovery', N_("Locked template name"),nil,{ :collection => Proc.new {Hash[ProvisioningTemplate.all.map{|template| [template[:name], template[:name]]}]} }),
       ].compact.each { |s| self.create s.update(:category => "Setting::Discovered")}
     end
 
     if SETTINGS[:locations_enabled]
       Setting.transaction do
         [
-          self.set('discovery_location', N_("The default location to place discovered hosts in"), ""),
+          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]]}]} }),
         ].compact.each { |s| self.create s.update(:category => "Setting::Discovered")}
       end
     end
+
     if SETTINGS[:organizations_enabled]
       Setting.transaction do
         [
-          self.set('discovery_organization', N_("The default organization to place discovered hosts in"), "" ),
+          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]]}]} }),
         ].compact.each { |s| self.create s.update(:category => "Setting::Discovered")}
       end
     end
 
-    Setting.transaction do
-      [
-          self.set('discovery_facts_highlights', N_("Regex to organize facts for highlights section - e.g. ^(abc|cde)$"), ""),
-          self.set('discovery_facts_storage', N_("Regex to organize facts for storage section"), ""),
-          self.set('discovery_facts_software', N_("Regex to organize facts for software section"), ""),
-          self.set('discovery_facts_hardware', N_("Regex to organize facts for hardware section"), ""),
-          self.set('discovery_facts_network', N_("Regex to organize facts for network section"), ""),
-          self.set('discovery_facts_ipmi', N_("Regex to organize facts for ipmi section"), ""),
-      ].compact.each { |s| self.create s.update(:category => "Setting::Discovered")}
-    end
     true
   end
 
@@ -72,6 +62,10 @@ class Setting::Discovered < ::Setting
     from_array Setting['discovery_hostname']
   end
 
+  def self.discovery_lock?
+    Foreman::Cast.to_bool(Setting['discovery_lock']) && !Setting['discovery_lock_template'].blank? && ProvisioningTemplate.exists?(:name => Setting['discovery_lock_template'])
+  end
+
   def self.from_array(setting)
     return [] unless setting.present?
     setting.to_s.split(",").map(&:strip)