foreman_discovery 3.0.0 → 4.0.0

data/app/models/host/discovered.rb

@@ -3,9 +3,6 @@ require 'foreman_discovery/proxy_operations'
 class Host::Discovered < ::Host::Base
   include ScopedSearchExtensions
 
-  belongs_to :location
-  belongs_to :organization
-  belongs_to :subnet
   belongs_to :hostgroup
   has_one    :discovery_attribute_set, :foreign_key => :host_id, :dependent => :destroy
 
@@ -13,71 +10,46 @@ class Host::Discovered < ::Host::Base
 
   delegate :memory, :cpu_count, :disk_count, :disks_size, :to => :discovery_attribute_set
 
-  scoped_search :on => :name, :complete_value => true, :default_order => true
+  scoped_search :on => :name, :complete_value => true
+  scoped_search :on => :created_at, :default_order => :desc
   scoped_search :on => :last_report, :complete_value => true
-  scoped_search :on => :ip, :complete_value => true
-  scoped_search :on => :mac, :complete_value => true
+  scoped_search :in => :primary_interface, :on => :ip, :complete_value => true
+  scoped_search :in => :primary_interface, :on => :mac, :complete_value => true
   scoped_search :in => :model, :on => :name, :complete_value => true, :rename => :model
   scoped_search :in => :fact_values, :on => :value, :in_key => :fact_names, :on_key => :name, :rename => :facts, :complete_value => true, :only_explicit => true
   scoped_search :in => :location, :on => :name, :rename => :location, :complete_value => true         if SETTINGS[:locations_enabled]
   scoped_search :in => :organization, :on => :name, :rename => :organization, :complete_value => true if SETTINGS[:organizations_enabled]
   scoped_search :in => :subnet, :on => :network, :complete_value => true, :rename => :subnet
+  scoped_search :in => :subnet, :on => :name, :complete_value => true, :rename => 'subnet.name'
   scoped_search :in => :discovery_attribute_set, :on => :cpu_count, :rename => :cpu_count, :complete_value => true, :only_explicit => true
   scoped_search :in => :discovery_attribute_set, :on => :memory, :rename => :memory, :complete_value => true, :only_explicit => true
   scoped_search :in => :discovery_attribute_set, :on => :disk_count, :rename => :disk_count, :complete_value => true, :only_explicit => true
   scoped_search :in => :discovery_attribute_set, :on => :disks_size, :rename => :disks_size, :complete_value => true, :only_explicit => true
 
   default_scope lambda {
-    org = Organization.current
-    loc = Location.current
-    conditions = {}
-    conditions[:organization_id] = org.subtree_ids if org
-    conditions[:location_id]     = loc.subtree_ids if loc
-    where(conditions)
+    where(taxonomy_conditions).order("hosts.created_at DESC")
   }
 
   def self.import_host_and_facts facts
     raise(::Foreman::Exception.new(N_("Invalid facts, must be a Hash"))) unless facts.is_a?(Hash)
-    fact_name = Setting[:discovery_fact] || 'discovery_bootif'
-    prefix_from_settings = Setting[:discovery_prefix]
-    hostname_prefix = prefix_from_settings if prefix_from_settings.present? && prefix_from_settings.match(/^[a-zA-Z].*/)
-    hostname_prefix ||= 'mac'
-    hostname = facts[fact_name].try(:downcase).try(:gsub,/:/,'').try(:sub,/^/, hostname_prefix)
-    raise(::Foreman::Exception.new(N_("Invalid facts: hash does not contain the required fact '%s'"), fact_name)) unless hostname
-    raise(::Foreman::Exception.new(N_("Invalid facts: hash does not contain IP address"))) unless facts['ipaddress']
 
     # filter facts
     facts.reject!{|k,v| k =~ /kernel|operatingsystem|osfamily|ruby|path|time|swap|free|filesystem/i }
 
+    raise ::Foreman::Exception.new(N_("Expected discovery_fact '%s' is missing, unable to detect primary interface and set hostname") % FacterUtils::bootif_name) unless FacterUtils::bootif_present(facts)
+
+    # construct hostname
+    prefix_from_settings = Setting[:discovery_prefix]
+    hostname_prefix = prefix_from_settings if prefix_from_settings.present? && prefix_from_settings.match(/^[a-zA-Z].*/)
+    hostname_prefix ||= 'mac'
+    hostname = FacterUtils::bootif_mac(facts).try(:downcase).try(:gsub,/:/,'').try(:sub,/^/, hostname_prefix)
+
+    # create new host record
     h = ::Host::Discovered.find_by_name hostname
     h ||= Host.new :name => hostname, :type => "Host::Discovered"
     h.type = "Host::Discovered"
 
-    macfact = facts[fact_name].try(:downcase)
-    begin
-      macfact = Net::Validations.normalize_mac(macfact)
-    rescue ArgumentError => e
-      macfact = facts['discovery_bootif'].try(:downcase)
-      h.name = facts['discovery_bootif'].try(:downcase).try(:gsub,/:/,'').try(:sub,/^/, hostname_prefix)
-    end
-    h.mac = macfact
-
-
-    if SETTINGS[:locations_enabled]
-      begin
-        h.location = (Location.find_by_name Setting[:discovery_location]) || Location.first
-      rescue
-        h.location = Location.first
-      end
-    end
-    if SETTINGS[:organizations_enabled]
-      begin
-        h.organization = (Organization.find_by_name Setting[:discovery_organization]) || Organization.first
-      rescue
-        h.organization = Organization.first
-      end
-    end
-
+    # and save (interfaces are created via puppet parser extension)
     h.save(:validate => false) if h.new_record?
     state = h.import_facts(facts)
     return h, state
@@ -100,17 +72,35 @@ class Host::Discovered < ::Host::Base
     super
   end
 
-  def populate_fields_from_facts facts = self.facts_hash, type = 'puppet'
-    # type arg only added in 1.7
-    if Gem::Dependency.new('', '>= 1.7').match?('', SETTINGS[:version].notag)
-      importer = super
+  def populate_fields_from_facts(facts = self.facts_hash, type = 'puppet')
+    # detect interfaces and primary interface using extensions
+    parser = super(facts, type)
+
+    # set additional discovery attributes
+    primary_ip = self.primary_interface.ip
+    unless primary_ip.nil?
+      subnet = Subnet.subnet_for(primary_ip)
+      Rails.logger.warn "Subnet not detected for #{primary_ip}" if subnet.nil?
+      # set subnet
+      self.primary_interface.subnet = subnet
+      # set location and organization
+      if SETTINGS[:locations_enabled]
+        self.location = Location.find_by_name(Setting[:discovery_location]) ||
+          subnet.try(:locations).try(:first) ||
+          Location.first
+      end
+      if SETTINGS[:organizations_enabled]
+        self.organization = Organization.find_by_name(Setting[:discovery_organization]) ||
+          subnet.try(:organizations).try(:first) ||
+          Organization.first
+      end
     else
-      importer = super(facts)
+      raise(::Foreman::Exception.new(N_("Unable to assign subnet, primary interface is missing IP address")))
     end
-    self.primary_interface.subnet = Subnet.subnet_for(self.primary_interface.ip)
     self.discovery_attribute_set = DiscoveryAttributeSet.where(:host_id => id).first_or_create
     self.discovery_attribute_set.update_attributes(import_from_facts)
-    self.save
+    self.save!
+    parser
   end
 
   def import_from_facts(facts = self.facts_hash)
@@ -160,18 +150,14 @@ class Host::Discovered < ::Host::Base
     proxy_url = self.proxy_url
 
     if proxy_url[:type] == 'proxy'
-      status = ForemanDiscovery::ProxyOperations.new(:url => proxy_url[:url], :operation => 'reboot').parse_put_operation
+      ForemanDiscovery::ProxyOperations.new(:url => proxy_url[:url], :operation => 'reboot').
+        parse_put_operation.try(:fetch, 'result')
     else
-      status = ::ProxyAPI::BMC.new(:url => "http://#{self.ip}:8443").power :action => "cycle"
+      ::ProxyAPI::BMC.new(:url => "http://#{self.ip}:8443").power :action => "cycle"
     end
-
-    msg = status ? 'successful' : 'failed'
-    logger.info "ForemanDiscovery: reboot result: #{msg}"
-    status
-    rescue => e
-      logger.info "ForemanDiscovery: reboot result: failed"
-      logger.warn e.backtrace.join('\n')
-      raise e
+  rescue => e
+    ::Foreman::Logging.exception("Unable to reboot #{name}", e)
+    raise ::Foreman::WrappedException.new(e, N_("Unable to reboot %{name}: %{msg}"), :name => name, :msg => e.to_s)
   end
 
   def self.model_name

data/app/models/host/managed_extensions.rb

@@ -4,24 +4,33 @@ module Host::ManagedExtensions
   included do
     # execute standard callbacks
     after_validation :queue_reboot
+    after_save :delete_discovery_attribute_set
 
     belongs_to :discovery_rule
   end
 
   def queue_reboot
+    return unless errors.empty? && Setting[:discovery_reboot]
     return if new_record? # Discovered Hosts already exist, and new_records will break `find`
     return unless type_changed? and ::Host::Base.find(self.id).type == "Host::Discovered"
+    # reboot task must be high priority and there is no compensation action apparently
     post_queue.create(:name => _("Rebooting %s") % self, :priority => 10000,
                       :action => [self, :setReboot])
   end
 
   def setReboot
     old.becomes(Host::Discovered).reboot
+    # 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.
+    true
+  rescue ::Foreman::Exception
+    true
   end
 
-  def delReboot
-    # nothing to do here, in reality we should never hit this method since this should be the
-    # last action in the queue.
+  def delete_discovery_attribute_set
+    return if new_record?
+    DiscoveryAttributeSet.destroy_all(:host_id => self.id) if type_changed?
   end
 
 end

data/app/models/setting/discovered.rb

@@ -9,34 +9,35 @@ class Setting::Discovered < ::Setting
 
     Setting.transaction do
       [
-        self.set('discovery_fact', _("The default fact name to use for the MAC of the system"), "discovery_bootif"),
-        self.set('discovery_auto', _("Automatically provision newly discovered hosts, according to the provisioning rules"), false),
+        self.set('discovery_fact', N_("Fact name to use for primary interface detection and hostname"), "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', _("The default prefix to use for the host name, must start with a letter"), "mac"),
+        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', _("Show fact as an extra column in the discovered hosts list"), ""),
+        self.set('discovery_fact_column', N_("Extra facter columns to show in host lists (separate by comma)"), ""),
       ].compact.each { |s| self.create s.update(:category => "Setting::Discovered")}
     end
 
     if SETTINGS[:locations_enabled]
       Setting.transaction do
         [
-          self.set('discovery_location', _("The default location to place discovered hosts in"), ""),
+          self.set('discovery_location', N_("The default location to place discovered hosts in"), ""),
         ].compact.each { |s| self.create s.update(:category => "Setting::Discovered")}
       end
     end
     if SETTINGS[:organizations_enabled]
       Setting.transaction do
         [
-          self.set('discovery_organization', _("The default organization to place discovered hosts in"), "" ),
+          self.set('discovery_organization', N_("The default organization to place discovered hosts in"), "" ),
         ].compact.each { |s| self.create s.update(:category => "Setting::Discovered")}
       end
     end
@@ -45,4 +46,15 @@ class Setting::Discovered < ::Setting
 
   end
 
+  def self.discovery_fact_column_array
+    return [] if !Setting['discovery_fact_column'].present?
+    list = []
+    Setting['discovery_fact_column'].to_s.split(",").each do |value|
+      list << value.strip
+    end
+  rescue => error
+    logger.warn "Failed to parse comma delimited list [%s] into array. Error: %s" % [list,error]
+  ensure
+    list
+  end
 end

data/app/services/foreman_discovery/host_converter.rb

@@ -0,0 +1,22 @@
+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).
+  # This method MUST be called from a SQL transaction.
+  def self.to_managed(original_host, set_managed = true, set_build = true)
+    if ActiveRecord::Base.connection.open_transactions <= 0
+      raise "This method must be executed with explicit transaction"
+    end
+    host = original_host.becomes(::Host::Managed)
+    host.type = 'Host::Managed'
+    # the following flags can be skipped when parameters are set to false
+    if set_managed
+      host.managed = set_managed
+      host.primary_interface.managed = set_managed
+    end
+    # set build only and only on final save (otherwise interfaces are not being identified)
+    host.build = set_build if set_build
+    host
+  end
+
+end

data/app/views/api/v2/discovered_hosts/main.json.rabl

@@ -2,7 +2,7 @@ object @discovered_host
 
 extends "api/v2/discovered_hosts/base"
 
-attributes :ip, :mac, :last_report, :subnet_id, :subnet_name, :memory, :disk_count, :disks_size
+attributes :ip, :mac, :last_report, :subnet_id, :subnet_name, :model_name, :memory, :disk_count, :disks_size
 attribute :cpu_count => :cpus
 
 if SETTINGS[:organizations_enabled]

data/app/views/api/v2/discovery_rules/main.json.rabl

@@ -2,4 +2,9 @@ object @discovery_rule
 
 extends "api/v2/discovery_rules/base"
 
-attributes :name, :enabled, :hostgroup_id, :hostname, :max_count, :priority, :search
+attributes :name, :enabled, :hostgroup_id, :hostgroup_name, :hostname, :priority, :search
+attribute :max_count => :hosts_limit
+
+child :hosts do
+  extends "api/v2/discovered_hosts/base"
+end

data/app/views/api/v2/discovery_rules/show.json.rabl

@@ -1,3 +1,7 @@
 object @discovery_rule
 
 extends "api/v2/discovery_rules/main"
+
+node do |discovery_rule|
+  partial("api/v2/taxonomies/children_nodes", :object => discovery_rule)
+end

data/app/views/dashboard/_discovery_widget.html.erb

@@ -1,10 +1,12 @@
-<h4 class="ca"><%= _('Discovered Host Pool') %> - <%= @current_permission %></h4>
 <% all_hosts = Host::Discovered.includes(:model).includes(:discovery_attribute_set).scoped %>
-<% hosts = all_hosts.limit(5) %>
+<% hosts = all_hosts.limit(6) %>
+
+<h4 class="header">
+  <%= link_to "#{all_hosts.size} #{n_('Discovered Host', 'Discovered Hosts', all_hosts.size)}", discovered_hosts_path %>
+</h4>
+
 <% if hosts.empty? %>
    <p class="ca"><%= _("No discovered hosts available") %></p>
 <% else %>
     <%= render :partial => 'discovery_widget_host_list', :locals => { :hosts => hosts } %>
-    <p class="ca"><%= link_to n_("Total pool size", "Total pool size", all_hosts.size), discovered_hosts_path %>
-      - <%= all_hosts.size %> </p>
 <% end %>

data/app/views/dashboard/_discovery_widget_host.html.erb

@@ -0,0 +1,4 @@
+<td><%= discovery_status_icon(host) %>&#8239;<%= link_to trunc_with_tooltip(h(host.name)), discovered_host_path(host) %></td>
+<td class="hidden-tablet hidden-xs"><%= model_name host %></td>
+<td class="hidden-tablet hidden-xs"><%= discovery_attribute(host, :cpu_count) %></td>
+<td class="hidden-tablet hidden-xs"><%= number_to_human_size(discovery_attribute(host, :memory, 0) * 1024 * 1024) %></td>

data/app/views/dashboard/_discovery_widget_host_list.html.erb

@@ -2,15 +2,14 @@
   <thead>
   <th><%= _('Host') %></th>
   <th><%= _('Model') %></th>
-  <th><%= _('IP Address') %></th>
   <th><%= _('CPUs') %></th>
   <th><%= _('Memory') %></th>
   </thead>
   <tbody>
   <% hosts.each do |host| %>
     <tr>
-      <%= render :partial => "discovered_hosts/discovered_host", :locals => {
-        :host => host, :hide_disk => true } %>
+      <%= render :partial => "discovery_widget_host", :locals => {
+        :host => host } %>
   </tr>
   <% end %>
   </tbody>

data/app/views/discovered_hosts/_discovered_host.html.erb

@@ -1,12 +1,10 @@
-<td><%= link_to trunc_with_tooltip(h(host.name)), discovered_host_path(host) %></td>
+<td><%= discovery_status_icon(host) %>&#8239;<%= link_to trunc_with_tooltip(h(host.name)), discovered_host_path(host) %></td>
 <td class="hidden-tablet hidden-xs"><%= model_name host %></td>
 <td class="hidden-tablet hidden-xs"><%= host.ip %></td>
 <td class="hidden-tablet hidden-xs"><%= discovery_attribute(host, :cpu_count) %></td>
 <td class="hidden-tablet hidden-xs"><%= number_to_human_size(discovery_attribute(host, :memory, 0) * 1024 * 1024) %></td>
-<% unless defined? hide_disk %>
 <td class="hidden-tablet hidden-xs"><%= discovery_attribute(host, :disk_count) %></td>
 <td class="hidden-tablet hidden-xs"><%= number_to_human_size(discovery_attribute(host, :disks_size, 0) * 1024 * 1024) %></td>
-<% if Setting['discovery_fact_column'].present? %>
-  <td class="hidden-tablet hidden-xs"><%= host.facts_hash[Setting['discovery_fact_column']] || 'N/A' %></td>
-<% end %>
+<% Setting::Discovered.discovery_fact_column_array.each do |fact_column| %>
+<td class="hidden-tablet hidden-xs"><%= host.facts_hash[fact_column.strip] || 'N/A' %></td>
 <% end %>

data/app/views/discovered_hosts/_discovered_hosts_list.html.erb

@@ -10,8 +10,8 @@
     <th class="hidden-tablet hidden-xs"><%= sort :memory, :as => _('Memory') %></th>
     <th class="hidden-tablet hidden-xs"><%= sort :disk_count, :as => _('Disk count') %></th>
     <th class="hidden-tablet hidden-xs"><%= sort :disks_size, :as => _('Disks size') %></th>
-    <% if Setting['discovery_fact_column'].present? %>
-      <th class="hidden-tablet hidden-xs"><%= Setting['discovery_fact_column'].capitalize %></th>
+    <% Setting::Discovered.discovery_fact_column_array.each do |fact_column| %>
+      <th class="hidden-tablet hidden-xs"><%= fact_column.strip.capitalize %></th>
     <% end %>
     <% if SETTINGS[:locations_enabled] -%>
       <th class="hidden-tablet hidden-xs"><%= sort :location, :as => _('Location') %></th>
@@ -26,7 +26,7 @@
   <% @hosts.each do |host| -%>
     <tr>
       <td class="ca">
-        <%= check_box_tag "host_ids[]", nil, false, :id => "host_ids_#{host.id}", :disabled => !authorized?, :class => 'host_select_boxes', :onclick => 'hostChecked(this)' -%>
+        <%= check_box_tag "host_ids[]", nil, false, :id => "host_ids_#{host.id}", :disabled => !authorized_for_edit_destroy?, :class => 'host_select_boxes', :onclick => 'hostChecked(this)' -%>
       </td>
       <%= render :partial => "discovered_host", :locals => {:host => host} %>
       <% if SETTINGS[:locations_enabled] -%>
@@ -39,10 +39,10 @@
       <td class="hidden-tablet hidden-xs"><%= disc_report_column(host) %></td>
       <td>
         <%= action_buttons(
-          link_to(_("Provision"), hash_for_edit_discovered_host_path(:id => host)),
-          link_to(_("Auto Provision"), hash_for_auto_provision_discovered_host_path(:id => host), :method => :post),
-          link_to(_("Refresh facts"), hash_for_refresh_facts_discovered_host_path(:id => host)),
-          link_to(_("Reboot"), hash_for_reboot_discovered_host_path(:id => host), :method => :put),
+          display_link_if_authorized(_("Provision"), hash_for_edit_discovered_host_path(:id => host)),
+          display_link_if_authorized(_("Auto Provision"), hash_for_auto_provision_discovered_host_path(:id => host), :method => :post),
+          display_link_if_authorized(_("Refresh facts"), hash_for_refresh_facts_discovered_host_path(:id => host)),
+          display_link_if_authorized(_("Reboot"), hash_for_reboot_discovered_host_path(:id => host), :method => :put),
           display_delete_if_authorized(hash_for_discovered_host_path(:id => host), :confirm => _("Delete %s?") % host.name, :action => :destroy))%>
         </td>
       </tr>

data/app/views/discovered_hosts/index.html.erb

@@ -1,3 +1,4 @@
 <% title_actions multiple_discovered_hosts_actions_select -%>
+<% title_actions display_link_if_authorized(_("Reboot All"), hash_for_reboot_all_discovered_hosts_path, {:method => :put, :disabled => @hosts.empty?}) %>
 <% title_actions display_link_if_authorized(_("Auto Provision All"), hash_for_auto_provision_all_discovered_hosts_path, {:method => :post, :disabled => @hosts.empty?}) %>
 <%= render 'discovered_hosts_list' %>

data/app/views/discovery_rules/_form.html.erb

@@ -1,34 +1,53 @@
 <%= form_for @discovery_rule, :url => (@discovery_rule.new_record? ? discovery_rules_path : discovery_rule_path(:id => @discovery_rule.id)) do |f| %>
-  <%= base_errors_for @discovery_rule %>
-  <%= text_f f, :name %>
-  <%= autocomplete_f f, :search,
-                     :path => "discovered_hosts",
-                     :control_group_id => 'search_group', :size => 'col-md-9' %>
-  <%= select_f f, :hostgroup_id, accessible_hostgroups, :id, :to_label, { :include_blank => false },
-    { :help_inline => _('Target host group for this rule with all properties set')} %>
-  <%= text_f f, :hostname, :help_inline => popover(
-    _("Template"),
-    "<div>" +
-    _("Specify target hostname template pattern in the same syntax as in Provisioning Templates (ERB).") +
-    "</div>"+
-    "<div>" +
-    _("Domain will be appended automatically. A hostname based on MAC address will be used when left blank. In addition to @host attribute function rand for random integers is available. Examples:") +
-    "</div>"+
-    "<pre>"+
-    "myhost-&lt;%= rand(99999) %&gt;" + "\n\n" +
-    "abc-&lt;%= @host.facts['bios_vendor'] + " + "\n" +
-    " '-' + rand(99999) %&gt;" + "\n\n" +
-    "xyz-&lt;%= @host.hostgroup.name %&gt;" + "\n\n" +
-    "srv-&lt;%= @host.discovery_rule.name %&gt;" + "\n\n" +
-    "server-&lt;%= @host.ip.gsub('.','-') + " + "\n" +
-    " '-' + @host.hostgroup.subnet.name %&gt;" + "\n" +
-    "</pre>"+
-    "</div>"+
-    "<div>"+
-    _("When creating hostname patterns, make sure the resulting host names are unique. Hostnames must not start with numbers. A good approach is to use unique information provided by facter (MAC address, BIOS or serial ID).") +
-    "</div>", :title => _("Hostname for provisioned hosts")).html_safe %>
-  <%= text_f f, :max_count, :label => _('Hosts limit'), :help_inline => _('Maximum hosts provisioned with this rule (0 = unlimited)') %>
-  <%= text_f f, :priority, :help_inline => _('Rule priority (lower integer means higher priority)')  %>
-  <%= checkbox_f f, :enabled %>
-  <%= submit_or_cancel f %>
+    <%= base_errors_for @discovery_rule %>
+
+        <ul class="nav nav-tabs" data-tabs="tabs">
+          <li class="active"><a href="#primary" data-toggle="tab"><%= _('Primary') %></a></li>
+          <% if show_location_tab? %>
+              <li><a href="#locations" data-toggle="tab"><%= _('Locations') %></a></li>
+          <% end %>
+          <% if show_organization_tab? %>
+              <li><a href="#organizations" data-toggle="tab"><%= _('Organizations') %></a></li>
+          <% end %>
+        </ul>
+
+        <div class="tab-content">
+
+          <div class="tab-pane active" id="primary">
+            <%= text_f f, :name %>
+            <%= autocomplete_f f, :search,
+                               :path             => "discovered_hosts",
+                               :control_group_id => 'search_group', :size => 'col-md-9' %>
+            <%= select_f f, :hostgroup_id, accessible_hostgroups, :id, :to_label, { :include_blank => false },
+                         { :help_inline => _('Target host group for this rule with all properties set') } %>
+            <%= text_f f, :hostname, :help_inline => popover(
+                                _("Template"),
+                                "<div>" +
+                                        _("Specify target hostname template pattern in the same syntax as in Provisioning Templates (ERB).") +
+                                        "</div>"+
+                                        "<div>" +
+                                        _("Domain will be appended automatically. A hostname based on MAC address will be used when left blank. In addition to @host attribute function rand for random integers is available. Examples:") +
+                                        "</div>"+
+                                        "<pre>"+
+                                        "myhost-&lt;%= rand(99999) %&gt;" + "\n\n" +
+                                        "abc-&lt;%= @host.facts['bios_vendor'] + " + "\n" +
+                                        " '-' + rand(99999) %&gt;" + "\n\n" +
+                                        "xyz-&lt;%= @host.hostgroup.name %&gt;" + "\n\n" +
+                                        "srv-&lt;%= @host.discovery_rule.name %&gt;" + "\n\n" +
+                                        "server-&lt;%= @host.ip.gsub('.','-') + " + "\n" +
+                                        " '-' + @host.hostgroup.subnet.name %&gt;" + "\n" +
+                                        "</pre>"+
+                                        "</div>"+
+                                        "<div>"+
+                                        _("When creating hostname patterns, make sure the resulting host names are unique. Hostnames must not start with numbers. A good approach is to use unique information provided by facter (MAC address, BIOS or serial ID).") +
+                                        "</div>", :title => _("Hostname for provisioned hosts")).html_safe %>
+            <%= text_f f, :max_count, :label => _('Hosts limit'), :help_inline => _('Maximum hosts provisioned with this rule (0 = unlimited)') %>
+            <%= text_f f, :priority, :help_inline => _('Rule priority (lower integer means higher priority)') %>
+            <%= checkbox_f f, :enabled %>
+          </div>
+          <% if show_taxonomy_tabs? %>
+            <%= render 'taxonomies/loc_org_tabs', :f => f, :obj => @discovery_rule %>
+          <% end %>
+        </div>
+    <%= submit_or_cancel f %>
 <% end %>

data/config/routes.rb

@@ -7,7 +7,7 @@ Rails.application.routes.draw do
   match 'medium_selected_discovered_hosts'       => 'hosts#medium_selected'
 
   constraints(:id => /[^\/]+/) do
-    resources :discovered_hosts do
+    resources :discovered_hosts, :except => [:new, :create] do
       member do
         get 'refresh_facts'
         put 'reboot'
@@ -22,6 +22,7 @@ Rails.application.routes.draw do
         post 'update_multiple_location'
         get  'auto_complete_search'
         post 'auto_provision_all'
+        put  'reboot_all'
       end
     end
   end
@@ -40,13 +41,12 @@ Rails.application.routes.draw do
         member do
           post 'auto_provision'
           put 'reboot'
+          put 'refresh_facts'
         end
         collection do
           post 'facts'
           post 'auto_provision_all'
-        end
-        member do
-          put 'refresh_facts'
+          put  'reboot_all'
         end
       end
       resources :discovery_rules, :except => [:new, :edit]

data/db/migrate/20150310153859_remove_discovery_attribute_sets_from_managed_hosts.rb

@@ -0,0 +1,8 @@
+class RemoveDiscoveryAttributeSetsFromManagedHosts < ActiveRecord::Migration
+  def up
+    DiscoveryAttributeSet.where(:id => DiscoveryAttributeSet.joins(:host).where(:'hosts.managed' => true).pluck("#{DiscoveryAttributeSet.table_name}.id")).delete_all
+  end
+
+  def down
+  end
+end

data/db/migrate/20150331132115_remove_old_permissions.rb

@@ -0,0 +1,16 @@
+class RemoveOldPermissions < ActiveRecord::Migration
+  def up
+    # remove invalid permissions causing http://projects.theforeman.org/issues/9963
+    perms = Permission.where("name like '%_discovered_hosts' and resource_type is null").destroy_all
+    say "Removed invalid permissions: #{perms.inspect}" if perms.size > 0
+
+    # unassociate and remove unused role "Discovery" (renamed to "Discovery Manager")
+    if old_role = Role.where(:name => "Discovery").first
+      UserRole.where(:role_id => old_role.id).destroy_all
+      say "Role 'Discovery' was removed, use 'Discovery Manager' instead" if old_role.destroy
+    end
+  end
+
+  def down
+  end
+end

data/db/migrate/20150505111345_remove_leftover_tokens.rb

@@ -0,0 +1,13 @@
+class RemoveLeftoverTokens < ActiveRecord::Migration
+  def up
+    existing_tokens = Host::Managed.all.map(&:token).compact
+    if existing_tokens.empty?
+      Token.delete_all
+    else
+      Token.where('id not in (?)', existing_tokens).delete_all
+    end
+  end
+
+  def down
+  end
+end

data/db/migrate/20150512150432_remove_old_discovery_reader_permissions.rb

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

data/db/migrate/20150714144500_review_discovery_permissions.rb

@@ -0,0 +1,17 @@
+class ReviewDiscoveryPermissions < ActiveRecord::Migration
+  def up
+    if (mgr = Role.find_by_name("Discovery Manager"))
+      perms = []
+      perms << "submit_discovered_hosts" if Permission.find_by_name("edit_discovered_hosts")
+      perms << "auto_provision_discovered_hosts" if Permission.find_by_name("provision_discovered_hosts")
+      perms << "create_discovery_rules" if Permission.find_by_name("new_discovery_rules")
+      perms << "destroy_discovery_rules" if Permission.find_by_name("delete_discovery_rules")
+      mgr.add_permissions!(perms)
+    end
+    Permission.find_by_name("new_discovery_rules").try(:destroy)
+  end
+
+  def down
+    # rollback is not supported
+  end
+end