foreman_discovery 3.0.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 73911ee5b9b16a403e8f2709babed0be65bcdd31
-  data.tar.gz: ba4db8e574a8fac66bf4a7b481750581c2e22484
+  metadata.gz: fa7dff0a0f4756c41176a4e6b6be41f2815375cc
+  data.tar.gz: 7f83b17405564440f5939d66e15527363d07ad27
 SHA512:
-  metadata.gz: ab7fba75b6799fcc3c95890a3f942cafea7f4c590a45514f0ebba707256cff977bc5cdec67bdea7bd5ed96c0a5897e6f3c1133b47bc930184fc3750458eee121
-  data.tar.gz: 3fc4a54ee297c7c3134c3ef02e373225bfc809bc162a90b07dad598455318926065da63696fa0925066709cf1bbb4f54a00183ed8d9da1151243a8b048154695
+  metadata.gz: a588c3c7c19787aa5fa1cb36557e786889f294c0005bd4f1cb12dd614be77b88b2a8dbf3f46483ecf5129ad4cabc8f2a9a8cfd025eda077c9f160e0dc10debd0
+  data.tar.gz: 0e0e298f9a57c4a310e474f7dd3c6dd38b226d407a55a4a02a8e5c687b06c7149fd5c65da5cd951a61aa01e79833b7dd06539ad522a7e15f3d010aa268e1349d

data/README.md

@@ -4,7 +4,7 @@ This plugin enables MaaS hardware discovery in Foreman.
 
 # Documentation
 
-The main documentation can be found in [Foreman Discovery 2.0 Manual] (http://theforeman.org/plugins/foreman_discovery/2.0/).
+The main documentation can be found in the [Foreman Discovery manual] (http://theforeman.org/plugins/foreman_discovery/).
 
 ## Latest code
 

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

@@ -3,7 +3,7 @@ module Api
     class DiscoveredHostsController < ::Api::V2::BaseController
       include Foreman::Controller::DiscoveredExtensions
 
-      before_filter :find_resource, :except => %w{index create facts auto_provision_all}
+      before_filter :find_resource, :except => %w{index create facts auto_provision_all reboot_all}
       skip_before_filter :authorize, :only => :facts
 
       resource_description do
@@ -36,7 +36,7 @@ module Api
         end
       end
 
-      api :POST, "/discovered_hosts/", N_("Create a discovered host")
+      api :POST, "/discovered_hosts/", N_("Create a discovered host for testing (use /facts to create new hosts)")
       param_group :discovered_host, :as => :create
 
       def create
@@ -92,7 +92,7 @@ module Api
       end
 
       api :POST, "/discovered_hosts/facts", N_("Upload facts for a host, creating the host if required")
-      param :facts, Hash, :required => true, :desc => N_("hash containing facts for the host")
+      param :facts, Hash, :required => true, :desc => N_("hash containing facts for the host with minimum set of facts: discovery_bootif, macaddress_eth0, ipaddress, ipaddress_eth0, interfaces: eth0 (example in case primary interface is named eth0)")
 
       def facts
         state = true
@@ -100,7 +100,7 @@ module Api
           @discovered_host, state = Host::Discovered.import_host_and_facts(params[:facts])
         end
         if Setting['discovery_auto']
-          @discovered_host.transaction do
+          Host.transaction do
             if state && rule = find_discovery_rule(@discovered_host)
               state = perform_auto_provision(@discovered_host, rule)
             else
@@ -109,7 +109,9 @@ module Api
           end
         end
         process_response state
-      rescue ::Foreman::Exception => e
+      rescue Exception => e
+        logger.warn "Host discovery failed, facts: #{params[:facts]}"
+        logger.debug e.message + "\n" + e.backtrace.join("\n")
         render :json => {'message'=>e.to_s}, :status => :unprocessable_entity
       end
 
@@ -117,12 +119,15 @@ module Api
       param :id, :identifier, :required => true
 
       def auto_provision
-        @discovered_host.transaction do
+        Host.transaction do
           if rule = find_discovery_rule(@discovered_host)
             msg = _("Host %{host} was provisioned with rule %{rule}") % {:host => @discovered_host.name, :rule => rule.name}
             process_response perform_auto_provision(@discovered_host, rule), msg
           else
-            process_success _("No rule found for host %s") % @discovered_host.name
+            render_error :custom_error, :status => :not_found,
+                         :locals => {
+                             :message => _("No rule found for host %s") % @discovered_host.name
+                         }
           end
         end
       rescue ::Foreman::Exception => e
@@ -185,6 +190,21 @@ module Api
         render :json => {'message'=>e.to_s}
       end
 
+      api :PUT, "/discovered_hosts/reboot_all", N_("Rebooting all discovered hosts")
+
+      def reboot_all
+        error_message = perform_reboot_all
+        if error_message
+          render_error :custom_error,
+                       :status => :unprocessable_entity,
+                       :locals => {
+                           :message => error_message
+                       }
+        else
+          process_success _("Discovered hosts are rebooting now")
+        end
+      end
+
       private
 
       def resource_class
@@ -197,12 +217,12 @@ module Api
 
       def action_permission
         case params[:action]
-          when 'auto_provision'
+          when 'auto_provision', 'auto_provision_all'
             :auto_provision
-          when 'auto_provision_all'
-            :auto_provision_all
-          when 'refresh_facts', 'reboot'
+          when 'refresh_facts', 'reboot', 'reboot_all'
             :edit
+          when 'facts', 'create'
+            :submit
           else
             super
         end

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

@@ -28,13 +28,13 @@ module Api
 
       def_param_group :discovery_rule do
         param :discovery_rule, Hash, :action_aware => true do
-          param :name, String, :required => true
-          param :search, String, :required => true
-          param :hostgroup_id, Integer, :required => true
-          param :hostname, String, :required => true
-          param :max_count, Integer
-          param :priority, Integer
-          param :enabled, :bool
+          param :name, String, :required => true, :desc => N_("represents rule name shown to the users")
+          param :search, String, :required => true, :desc => N_("query to match discovered hosts for the particular rule")
+          param :hostgroup_id, Integer, :required => true, :desc => N_("the hostgroup that is used to auto provision a host")
+          param :hostname, String, :desc => N_("defines a pattern to assign human-readable hostnames to the matching hosts")
+          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")
         end
       end
 
@@ -48,15 +48,7 @@ module Api
 
       api :PUT, "/discovery_rules/:id/", N_("Update a rule")
       param :id, :identifier, :required => true
-      param :discovery_rule, Hash, :action_aware => true do
-          param :name, String, :required => true
-          param :search, String, :required => true
-          param :hostgroup_id, Integer, :required => true
-          param :hostname, String, :required => true
-          param :max_count, Integer
-          param :priority, Integer
-          param :enabled, :bool
-      end
+      param_group :discovery_rule, :as => :update
 
       def update
         process_response @discovery_rule.update_attributes(params[:discovery_rule])

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

@@ -3,6 +3,7 @@ module Foreman::Controller::DiscoveredExtensions
 
   # return auto provision rule or false when not present
   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|
@@ -14,8 +15,12 @@ module Foreman::Controller::DiscoveredExtensions
         # try to match the search
         begin
           if Host::Discovered.where(:id => host.id).search_for(rule.search).size > 0
-            Rails.logger.info "Match found for host #{host.name} (#{host.id}) rule #{rule.name} (#{rule.id})"
-            return rule
+            if validate_rule_by_taxonomy(rule, host)
+              Rails.logger.info "Match found for host #{host.name} (#{host.id}) rule #{rule.name} (#{rule.id})"
+              return rule
+            else
+              Rails.logger.warn "Rule #{rule.name} (#{rule.id}) can not be applied due to a difference in organization/location from host #{host.name} (#{host.id})"
+            end
           end
         rescue ScopedSearch::QueryNotSupported => e
           Rails.logger.warn "Invalid query for rule #{rule.name} (#{rule.id}): #{e.message}"
@@ -27,6 +32,16 @@ module Foreman::Controller::DiscoveredExtensions
     return false
   end
 
+  def validate_rule_by_taxonomy rule, host
+    if SETTINGS[:organizations_enabled]
+      return false unless rule.organizations.include?(host.organization)
+    end
+    if SETTINGS[:locations_enabled]
+      return false unless rule.locations.include?(host.location)
+    end
+    true
+  end
+
   # trigger the provisioning
   def perform_auto_provision original_host, rule
     Host.transaction do
@@ -44,5 +59,35 @@ module Foreman::Controller::DiscoveredExtensions
     end
   end
 
+  def perform_reboot_all hosts = Host::Discovered.all
+    result = true
+    error_message = _("Errors during reboot: %s")
+    overall_errors = ""
+
+    if hosts.count > 0
+      Host.transaction do
+        hosts.each do |discovered_host|
+          begin
+            unless discovered_host.reboot
+              error =  "#{discovered_host.name}: failed to reboot "
+              overall_errors << error
+              logger.error error
+            end
+          rescue Exception => e
+            error = "#{discovered_host.name}: #{e.to_s} "
+            overall_errors << error
+            logger.error error
+          end
+        end
+      end
+    else
+      error_message = _("No discovered hosts to reboot")
+      result = false
+    end
+
+    if overall_errors.present? || !result
+      error_message % overall_errors.strip
+    end
+  end
 
 end

data/app/controllers/discovered_hosts_controller.rb

@@ -4,45 +4,23 @@ class DiscoveredHostsController < ::ApplicationController
   include Foreman::Controller::DiscoveredExtensions
   unloadable
 
-  # Avoid auth for discovered host creation
-  skip_before_filter :require_login, :require_ssl, :authorize, :verify_authenticity_token, :set_taxonomy, :session_expiry, :update_activity_time, :only => :create
-
   before_filter :find_by_name, :only => %w[show edit update destroy refresh_facts convert reboot auto_provision]
   before_filter :find_multiple, :only => [:multiple_destroy, :submit_multiple_destroy]
   before_filter :taxonomy_scope, :only => [:edit]
 
+  around_filter :skip_bullet, :only => [:edit]
+
   helper :hosts
 
   layout 'layouts/application'
 
   def index
-    search = resource_base.search_for(params[:search], :order => params[:order])
-    respond_to do |format|
-      format.html do
-        @hosts = search.includes(:location, :organization, :subnet, :model, :discovery_attribute_set).paginate(:page => params[:page])
-      end
-      format.json { render :json => search }
-    end
-  end
-
-  # Importing yaml is restricted to puppetmasters, so instead we take the ip
-  # as a parameter and use refresh_facts to get the rest
-  def create
-    Taxonomy.no_taxonomy_scope do
-      host, imported = Host::Discovered.new(:ip => get_ip_from_env).refresh_facts
-      respond_to do |format|
-        format.yml {
-          if imported
-            render :text => _("Imported discovered host"), :status => 200 and return
-          else
-            render :text => _("Failed to import facts for discovered host"), :status => 400
-          end
-        }
-      end
-    end
-  rescue Exception => e
-    logger.warn "Failed to import facts for discovered host: #{e}"
-    render :text => _("Failed to import facts for discovered host: %s") % (e), :status => 400
+    @hosts = resource_base.search_for(params[:search], :order => params[:order]).includes([
+      :location,
+      :organization,
+      :model,
+      :discovery_attribute_set
+    ], {:interfaces => :subnet}).paginate(:page => params[:page])
   end
 
   def show
@@ -60,14 +38,14 @@ class DiscoveredHostsController < ::ApplicationController
 
   def edit
     Host.transaction do
-      @host = ::ForemanDiscovery::HostConverter.to_managed(@host) unless @host.nil?
+      @host = ::ForemanDiscovery::HostConverter.to_managed(@host, true, false) unless @host.nil?
       render :template => 'hosts/edit'
     end
   end
 
   def update
     Host.transaction do
-      @host = ::ForemanDiscovery::HostConverter.to_managed(@host, false, false)
+      @host = ::ForemanDiscovery::HostConverter.to_managed(@host)
       forward_url_options
       Taxonomy.no_taxonomy_scope do
         if @host.update_attributes(params[:host])
@@ -105,6 +83,16 @@ class DiscoveredHostsController < ::ApplicationController
                     :redirect => :back
   end
 
+  def reboot_all
+    error_message = perform_reboot_all
+
+    if error_message
+      process_error :error_msg => error_message, :redirect => :back
+    else
+      process_success :success_msg => _("Discovered hosts are rebooting now"), :success_redirect => :back
+    end
+  end
+
   def multiple_destroy
   end
 
@@ -137,7 +125,7 @@ class DiscoveredHostsController < ::ApplicationController
   end
 
   def auto_provision
-    @host.transaction do
+    Host.transaction do
       if rule = find_discovery_rule(@host)
         if perform_auto_provision(@host, rule)
           process_success :success_msg => _("Host %{host} was provisioned with rule %{rule}") % {:host => @host.name, :rule => rule.name}, :success_redirect => discovered_hosts_path
@@ -214,18 +202,12 @@ class DiscoveredHostsController < ::ApplicationController
 
   def action_permission
     case params[:action]
-      when 'refresh_facts', 'reboot'
-        :view
-      when 'new', 'create'
-        :provision
-      when 'update_multiple_location', 'select_multiple_organization', 'update_multiple_organization', 'select_multiple_location'
+      when 'refresh_facts', 'reboot', 'reboot_all', 'update_multiple_location', 'select_multiple_organization', 'update_multiple_organization', 'select_multiple_location'
         :edit
       when 'submit_multiple_destroy', 'multiple_destroy'
         :destroy
-      when 'auto_provision'
+      when 'auto_provision', 'auto_provision_all'
         :auto_provision
-      when 'auto_provision_all'
-        :auto_provision_all
       else
         super
     end
@@ -257,20 +239,6 @@ class DiscoveredHostsController < ::ApplicationController
     redirect_to discovered_hosts_path
   end
 
-  def get_ip_from_env
-    # try to find host based on our client ip address
-    ip = request.env['REMOTE_ADDR']
-
-    # check if someone is asking on behave of another system (load balance etc)
-    ip = request.env['HTTP_X_FORWARDED_FOR'] if request.env['HTTP_X_FORWARDED_FOR'].present?
-
-    # Check for explicit parameter override
-    ip = params.delete('ip') if params.include?('ip')
-
-    # in case we got back multiple ips (see #1619)
-    ip = ip.split(',').first
-  end
-
   def taxonomy_scope
     if @host
       @organization = @host.organization
@@ -287,4 +255,11 @@ class DiscoveredHostsController < ::ApplicationController
     end
   end
 
+  # particular actions will always raise N+1 queries
+  def skip_bullet
+    Bullet.enable = false if defined? Bullet
+    yield
+  ensure
+    Bullet.enable = true if defined? Bullet
+  end
 end

data/app/controllers/discovery_rules_controller.rb

@@ -53,10 +53,8 @@ class DiscoveryRulesController < ApplicationController
 
   def action_permission
     case params[:action]
-    when 'enable'
-      :enable
-    when 'disable'
-      :disable
+    when 'enable', 'disable'
+      :edit
     else
       super
     end

data/app/helpers/discovered_hosts_helper.rb

@@ -24,16 +24,15 @@ module DiscoveredHostsHelper
   end
 
   def multiple_discovered_hosts_actions_select
-    actions = [[_('Delete hosts'), multiple_destroy_discovered_hosts_path]]
-    actions <<  [_('Assign Organization'), select_multiple_organization_discovered_hosts_path] if SETTINGS[:organizations_enabled]
-    actions <<  [_('Assign Location'), select_multiple_location_discovered_hosts_path] if SETTINGS[:locations_enabled]
+    actions = [[_('Delete hosts'), multiple_destroy_discovered_hosts_path, hash_for_multiple_destroy_discovered_hosts_path]]
+    actions <<  [_('Assign Organization'), select_multiple_organization_discovered_hosts_path,  hash_for_select_multiple_organization_discovered_hosts_path] if SETTINGS[:organizations_enabled]
+    actions <<  [_('Assign Location'), select_multiple_location_discovered_hosts_path,  hash_for_select_multiple_location_discovered_hosts_path] if SETTINGS[:locations_enabled]
 
     select_action_button( _("Select Action"), {:id => 'submit_multiple'},
       actions.map do |action|
-        link_to_function(action[0], "build_modal(this, '#{action[1]}')", :'data-dialog-title' => _("%s - The following hosts are about to be changed") % action[0])
+        link_to_function(action[0], "build_modal(this, '#{action[1]}')", :'data-dialog-title' => _("%s - The following hosts are about to be changed") % action[0]) if authorized_for(action[2])
       end.flatten
     )
-
   end
 
   def turn_zero_to_not_available(value)
@@ -44,4 +43,27 @@ module DiscoveredHostsHelper
     host.try(:discovery_attribute_set).try(attr) || default_value
   end
 
+  def authorized_for_edit_destroy?
+    authorized_for(:controller => :discovered_hosts, :action => :edit) or
+        authorized_for(:controller => :discovered_hosts, :action => :destroy)
+  end
+
+  def discovery_status_icon(host)
+    if host.created_at > 1.day.ago
+      status_glyph = 'glyphicon-plus-sign'
+      status_message = _('New in the last 24 hours')
+      status_color = '#89A54E'
+    elsif host.last_report < 7.days.ago
+      status_glyph = 'glyphicon-exclamation-sign'
+      status_message = _('Not reported in more than 7 days')
+      status_color = '#AA4643'
+    else
+      status_glyph = 'glyphicon-ok-sign'
+      status_message = _('Reported in the last 7 days')
+      status_color = '#4572A7'
+    end
+
+    "<span class='glyphicon #{status_glyph}' style='color: #{status_color}'
+      title='#{status_message}'/>".html_safe
+  end
 end

data/app/lib/facter_utils.rb

@@ -0,0 +1,18 @@
+module FacterUtils
+  class << self
+    # booted interface fact name
+    def bootif_name
+      Setting[:discovery_fact] || 'discovery_bootif'
+    end
+
+    # booted interface fact is present
+    def bootif_present(facts)
+      ! bootif_mac(facts).nil?
+    end
+
+    # booted interface MAC address (nil when not present)
+    def bootif_mac(facts)
+      facts[bootif_name]
+    end
+  end
+end

data/app/lib/puppet_fact_parser_extensions.rb

@@ -2,42 +2,28 @@ module PuppetFactParserExtensions
   extend ActiveSupport::Concern
 
   included do
-    # In Foreman 1.8 these two methods have been removed, we could reuse discovery_mac_fact_name in suggested_primary_interface(host) if needed
-    if instance_methods.include?(:primary_interface)
-      alias_method_chain :primary_interface, :discovery_fact
-    end
-
-    if instance_methods.include?(:ip)
-      alias_method_chain :ip, :discovery_fact
+    begin
+      raise "method: suggested_primary_interface" unless instance_methods.include?(:suggested_primary_interface)
+      raise "method: parse_interfaces?" unless instance_methods.include?(:parse_interfaces?)
+      alias_method_chain :suggested_primary_interface, :bootif
+      alias_method_chain :parse_interfaces?, :bootif
+    rescue Exception => e
+      raise ::Foreman::WrappedException.new(e, N_("Incompatible version of puppet fact parser"))
     end
   end
 
-  # we prefer discovery_bootif fact to choose right primary interface (interface used to boot the image)
-  def primary_interface_with_discovery_fact
-    if facts.has_key?(discovery_mac_fact_name)
-      mac = facts[discovery_mac_fact_name]
-      interfaces.each do |int, values|
-        return int.to_s if (values[:macaddress].try(:downcase) == mac.try(:downcase))
-      end
-    end
-    primary_interface_without_discovery_fact # fallback if we didn't find interface with such macaddress
+  # discovery has its own method of finding primary iface
+  def suggested_primary_interface_with_bootif(host)
+    return suggested_primary_interface_without_bootif(host) if host.type != "Host::Discovered"
+    bootif_mac = FacterUtils::bootif_mac(facts).try(:downcase)
+    detected = interfaces.detect { |_, values| values[:macaddress].try(:downcase) == bootif_mac }
+    Rails.logger.debug "Detected primary interface: #{detected}"
+    # return the detected interface as array [name, facts]
+    detected || raise(::Foreman::Exception.new(N_("Unable to detect primary interface using MAC '%{mac}' specified by discovery_fact '%{fact}'") % {:mac => bootif_mac, :fact => FacterUtils::bootif_name}))
   end
 
-  # search for IP of interface with primary interface macaddress (ipaddress fact does not have to be interface used for boot)
-  def ip_with_discovery_fact
-    if facts[:interfaces] && facts.has_key?(discovery_mac_fact_name)
-      facts[:interfaces].split(',').each do |interface|
-        if facts["macaddress_#{interface}"].try(:downcase) == facts[discovery_mac_fact_name].try(:downcase)
-          return facts["ipaddress_#{interface}"]
-        end
-      end
-    end
-    ip_without_discovery_fact # fallback if IP was not found
-  end
-
-  private
-
-  def discovery_mac_fact_name
-    Setting[:discovery_fact] || 'discovery_bootif'
+  # make 'ignore_puppet_facts_for_provisioning' setting non-effective
+  def parse_interfaces_with_bootif?
+    true
   end
 end

data/app/models/discovery_rule.rb

@@ -3,8 +3,7 @@ class DiscoveryRule < ActiveRecord::Base
   extend FriendlyId
   friendly_id :name
   include Parameterizable::ByIdName
-
-  attr_accessible :name, :enabled, :hostgroup_id, :hostname, :max_count, :priority, :search
+  include Taxonomix
 
   validates :name, :presence => true, :uniqueness => true,
     :format => { :with => /\A(\S+)\Z/, :message => N_("can't contain white spaces.") }
@@ -15,6 +14,8 @@ class DiscoveryRule < ActiveRecord::Base
   validates :max_count, :numericality => { :only_integer => true, :greater_than_or_equal_to => 0 }
   validates :priority, :presence => true, :numericality => { :only_integer => true, :greater_than_or_equal_to => 0 }
   validates_lengths_from_database
+  before_validation :default_int_attributes
+  before_validation :enforce_taxonomy
 
   belongs_to :hostgroup
   has_many :hosts
@@ -23,4 +24,34 @@ class DiscoveryRule < ActiveRecord::Base
   scoped_search :on => :priority
   scoped_search :on => :search
   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
+                }
+
+  def default_int_attributes
+   self.max_count ||= 0
+   self.priority  ||= 0
+  end
+
+  def enforce_taxonomy
+    return if hostgroup.nil?
+    if SETTINGS[:organizations_enabled]
+      unless (ms = hostgroup.organizations - organizations).empty?
+        names = ms.collect(&:name).to_sentence
+        errors.add(:organizations, n_("Host group organization %s must also be associated to the discovery rule", "Host group organizations %s must also be associated to the discovery rule", ms.size) % names)
+      end
+    end
+    if SETTINGS[:locations_enabled]
+      unless (ms = hostgroup.locations - locations).empty?
+        names = ms.collect(&:name).to_sentence
+        errors.add(:locations, n_("Host group location %s must also be associated to the discovery rule", "Host group locations %s must also be associated to the discovery rule", ms.size) % names)
+      end
+    end
+  end
 end