foreman_remote_execution 1.3.0 → 1.3.1

data/app/models/job_invocation.rb

@@ -6,7 +6,7 @@ class JobInvocation < ActiveRecord::Base
     :pattern_template_invocations => lambda do |template_invocation|
       _('template') + " #{template_invocation.template.name}"
     end
-  }
+  }.freeze
 
   belongs_to :targeting, :dependent => :destroy
   has_many :all_template_invocations, :inverse_of => :job_invocation, :dependent => :destroy, :class_name => 'TemplateInvocation'
@@ -119,7 +119,7 @@ class JobInvocation < ActiveRecord::Base
   end
 
   def failed_template_invocation_tasks
-    template_invocation_tasks.where(:result => [ 'error', 'warning' ])
+    template_invocation_tasks.where(:result => TemplateInvocation::TaskResultMap.status_to_task_result(:failed))
   end
 
   def failed_host_ids
@@ -167,7 +167,9 @@ class JobInvocation < ActiveRecord::Base
     key_re = /%\{([^\}]+)\}/
     template_invocation = pattern_template_invocations.first
     hash_base = Hash.new { |hash, key| hash[key] = "%{#{key}}" }
-    input_hash = template_invocation.input_values.reduce(hash_base) { |h, v| h.update(v.template_input.name => v.value) }
+    input_hash = template_invocation.input_values.reduce(hash_base) do |h, v|
+      h.update(v.template_input.name => v.value)
+    end
     input_hash.update(:job_category => job_category)
     input_hash.update(:template_name => template_invocation.template.name)
     description_format.scan(key_re) { |key| input_hash[key.first] }
@@ -179,21 +181,24 @@ class JobInvocation < ActiveRecord::Base
   end
 
   def progress_report
+    map = TemplateInvocation::TaskResultMap
+    all_keys = (map.results | map.statuses | [:progress, :total])
     if queued? || !targeting.resolved?
-      %w(success total cancelled failed error warning pending progress).map(&:to_sym).reduce({}) do |acc, key|
+      all_keys.reduce({}) do |acc, key|
         acc.merge(key => 0)
       end
     else
       counts  = task.sub_tasks_counts
-      done    = counts.values_at(:cancelled, :error, :success, :warning).reduce(:+)
+      done    = counts.values_at(*map.results).reduce(:+)
       percent = progress(counts[:total], done)
-      counts.merge(:progress => percent, :failed => counts[:error] + counts[:warning])
+      counts.merge(:progress => percent, :failed => counts.values_at(*map.status_to_task_result(:failed)).reduce(:+))
     end
   end
 
   private
 
   def failed_template_invocations
-    template_invocations.joins(:run_host_job_task).where("#{ForemanTasks::Task.table_name}.result" => ['error', 'warning'])
+    results = TemplateInvocation::TaskResultMap.status_to_task_result(:failed)
+    template_invocations.joins(:run_host_job_task).where("#{ForemanTasks::Task.table_name}.result" => results)
   end
 end

data/app/models/job_invocation_composer.rb

@@ -40,7 +40,7 @@ class JobInvocationComposer
     # }
     def template_invocations_params
       providers_base.values.map do |template_params|
-        template_base = (template_params.fetch(:job_templates, {}).fetch(template_params[:job_template_id], {})).dup.with_indifferent_access
+        template_base = template_params.fetch(:job_templates, {}).fetch(template_params[:job_template_id], {}).dup.with_indifferent_access
         template_base[:template_id] = template_params[:job_template_id]
         input_values_params = template_base.fetch(:input_values, {})
         template_base[:input_values] = input_values_params.map do |id, values|
@@ -146,8 +146,13 @@ class JobInvocationComposer
   class ParamsFromJobInvocation
     attr_reader :job_invocation
 
-    def initialize(job_invocation)
+    def initialize(job_invocation, params = {})
       @job_invocation = job_invocation
+      if params[:host_ids]
+        @host_ids = params[:host_ids]
+      elsif params[:failed_only]
+        @host_ids = job_invocation.failed_host_ids
+      end
     end
 
     def params
@@ -169,7 +174,11 @@ class JobInvocationComposer
     end
 
     def targeting_params
-      job_invocation.targeting.attributes.slice('search_query', 'bookmark_id', 'user_id', 'targeting_type')
+      if @host_ids
+        { :search_query => Targeting.build_query_from_hosts(@host_ids) }
+      else
+        job_invocation.targeting.attributes.slice('search_query', 'bookmark_id', 'user_id', 'targeting_type')
+      end
     end
 
     def template_invocations_params
@@ -243,7 +252,7 @@ class JobInvocationComposer
         raise Foreman::Exception.new(N_('No template mapped to feature %{feature_name}'),
                                      :feature_name => feature.name)
       end
-      template = JobTemplate.authorized(:view_job_templates).find_by_id(feature.job_template_id)
+      template = JobTemplate.authorized(:view_job_templates).find_by(id: feature.job_template_id)
 
       unless template
         raise Foreman::Exception.new(N_('The template %{template_name} mapped to feature %{feature_name} is not accessible by the user'),
@@ -268,8 +277,8 @@ class JobInvocationComposer
     @search_query = job_invocation.targeting.search_query unless job_invocation.targeting.bookmark_id.present?
   end
 
-  def self.from_job_invocation(job_invocation)
-    self.new(ParamsFromJobInvocation.new(job_invocation).params)
+  def self.from_job_invocation(job_invocation, params = {})
+    self.new(ParamsFromJobInvocation.new(job_invocation, params).params)
   end
 
   def self.from_ui_params(ui_params)

data/app/models/job_invocation_task_group.rb

@@ -2,7 +2,7 @@ class JobInvocationTaskGroup < ::ForemanTasks::TaskGroup
 
   has_one :job_invocation, :foreign_key => :task_group_id
 
-  alias_method :resource, :job_invocation
+  alias resource job_invocation
 
   def resource_name
     N_('Job Invocation')

data/app/models/job_template.rb

@@ -55,40 +55,56 @@ class JobTemplate < ::Template
   has_one :effective_user, :class_name => 'JobTemplateEffectiveUser', :foreign_key => 'job_template_id', :dependent => :destroy
   accepts_nested_attributes_for :effective_user, :update_only => true
 
-  # we have to override the base_class because polymorphic associations does not detect it correctly, more details at
-  # http://apidock.com/rails/ActiveRecord/Associations/ClassMethods/has_many#1010-Polymorphic-has-many-within-inherited-class-gotcha
-  def self.base_class
-    self
-  end
-  self.table_name = 'templates'
+  class << self
+    # we have to override the base_class because polymorphic associations does not detect it correctly, more details at
+    # http://apidock.com/rails/ActiveRecord/Associations/ClassMethods/has_many#1010-Polymorphic-has-many-within-inherited-class-gotcha
+    def base_class
+      self
+    end
+    table_name = 'templates'
 
-  # Import a template from ERB, with YAML metadata in the first comment.  It
-  # will overwrite (sync) an existing template if options[:update] is true.
-  def self.import(contents, options = {})
-    transaction do
+    # Import a template from ERB, with YAML metadata in the first comment.  It
+    # will overwrite (sync) an existing template if options[:update] is true.
+    def import_raw(contents, options = {})
       metadata = parse_metadata(contents)
-      return if metadata.blank? || metadata.delete('kind') != 'job_template'
-
-      # Don't look for existing if we should always create a new template
-      existing = self.find_by_name(metadata['name']) unless options.delete(:build_new)
-      # Don't update if the template already exists, unless we're told to
-      return if !options.delete(:update) && existing
-
-      template = existing || self.new
-      template.sync_inputs(metadata.delete('template_inputs'))
-      template.sync_foreign_input_sets(metadata.delete('foreign_input_sets'))
-      template.sync_feature(metadata.delete('feature'))
-      template.assign_attributes(metadata.merge(:template => contents.gsub(/<%\#.+?.-?%>\n?/m, '').strip).merge(options))
-      template.assign_taxonomies if template.new_record?
+      import_parsed(metadata['name'], contents, metadata, options)
+    end
 
+    def import_raw!(contents, options = {})
+      template = import_raw(contents, options)
+      template.save! if template
       template
     end
-  end
 
-  def self.import!(template, options = {})
-    template = import(template, options)
-    template.save! if template
-    template
+    # This method is used by foreman_templates to import templates, the API should be kept compatible with it
+    def import!(name, text, metadata, force = false)
+      metadata = metadata.dup
+      metadata.delete('associate')
+      JobTemplateImporter.import!(name, text, metadata)
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def import_parsed(name, text, metadata, options = {})
+      transaction do
+        return if metadata.blank? || metadata.delete('kind') != 'job_template' ||
+                  (metadata.key?('model') && metadata.delete('model') != self.to_s)
+        metadata['name'] = name
+        # Don't look for existing if we should always create a new template
+        existing = self.find_by(:name => name) unless options.delete(:build_new)
+        # Don't update if the template already exists, unless we're told to
+        return if !options.delete(:update) && existing
+
+        template = existing || self.new
+        template.sync_inputs(metadata.delete('template_inputs'))
+        template.sync_foreign_input_sets(metadata.delete('foreign_input_sets'))
+        template.sync_feature(metadata.delete('feature'))
+        template.locked = false if options.delete(:force)
+        template.assign_attributes(metadata.merge(:template => text.gsub(/<%\#.+?.-?%>\n?/m, '').strip).merge(options))
+        template.assign_taxonomies if template.new_record?
+        template
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    end
   end
 
   def metadata
@@ -130,7 +146,7 @@ class JobTemplate < ::Template
   end
 
   def effective_user
-    super || (build_effective_user.tap(&:set_defaults))
+    super || build_effective_user.tap(&:set_defaults)
   end
 
   def generate_description_format

data/app/models/job_template_importer.rb

@@ -5,20 +5,32 @@
 # translation layer.
 
 class JobTemplateImporter
-  def self.import!(name, text, _metadata)
-    template = JobTemplate.import(
-      text.sub(/^name: .*$/, "name: #{name}").sub(/^model: .*$/, ''),
-      :update => true
-    )
+  def self.import!(name, text, metadata, force = false)
+    skip = skip_locked(name, force)
+    return skip if skip
 
+    template = JobTemplate.import_parsed(name, text, metadata, :update => true, :force => force)
     c_or_u = template.new_record? ? 'Created' : 'Updated'
-    id_string = ('id' + template.id) rescue ''
 
-    result = "  #{c_or_u} Template #{id_string}:#{name}"
+    result = "  #{c_or_u} Template #{id_string template}:#{name}"
     { :old => template.template_was,
       :new => template.template,
       :status => template.save,
-      :result => result
-    }
+      :result => result}
+  end
+
+  def self.skip_locked(name, force)
+    template = JobTemplate.find_by :name => name
+
+    if template && template.locked? && !template.new_record? && !force
+      { :old => template.template_was,
+        :new => template.template,
+        :status => false,
+        :result => "Skipping Template #{id_string template}:#{name} - template is locked" }
+    end
+  end
+
+  def self.id_string(template)
+    template ? template.id.to_s : ''
   end
 end

data/app/models/remote_execution_feature.rb

@@ -1,5 +1,5 @@
 class RemoteExecutionFeature < ActiveRecord::Base
-  VALID_OPTIONS = [:provided_inputs, :description, :host_action_button]
+  VALID_OPTIONS = [:provided_inputs, :description, :host_action_button].freeze
   validates :label, :name, :presence => true, :uniqueness => true
 
   belongs_to :job_template
@@ -7,7 +7,7 @@ class RemoteExecutionFeature < ActiveRecord::Base
   extend FriendlyId
   friendly_id :label
 
-  scope :with_host_action_button, lambda { where(:host_action_button => true) }
+  scope :with_host_action_button, -> { where(:host_action_button => true) }
 
   def provided_input_names
     self.provided_inputs.to_s.split(',').map(&:strip)
@@ -18,7 +18,7 @@ class RemoteExecutionFeature < ActiveRecord::Base
   end
 
   def self.feature(label)
-    self.find_by_label(label) || raise(::Foreman::Exception.new(N_('Unknown remote execution feature %s'), label))
+    self.find_by(label: label) || raise(::Foreman::Exception.new(N_('Unknown remote execution feature %s'), label))
   end
 
   def self.register(label, name, options = {})
@@ -26,7 +26,7 @@ class RemoteExecutionFeature < ActiveRecord::Base
     options.assert_valid_keys(*VALID_OPTIONS)
     options[:host_action_button] = false unless options.key?(:host_action_button)
 
-    feature = self.find_by_label(label)
+    feature = self.find_by(label: label)
 
     attributes = { :name => name, :provided_input_names => options[:provided_inputs], :description => options[:description], :host_action_button => options[:host_action_button] }
     # in case DB does not have the attribute created yet but plugin initializer registers the feature, we need to skip this attribute

data/app/models/setting/remote_execution.rb

@@ -4,6 +4,7 @@ class Setting::RemoteExecution < Setting
     # Check the table exists
     return unless super
 
+    # rubocop:disable Metrics/BlockLength
     self.transaction do
       [
         self.set('remote_execution_fallback_proxy',
@@ -29,16 +30,17 @@ class Setting::RemoteExecution < Setting
                  'sudo',
                  'remote_execution_effective_user_method',
                  nil,
-                 { :collection => Proc.new {Hash[SSHExecutionProvider::EFFECTIVE_USER_METHODS.map{|method| [method, method]}]} }),
+                 { :collection => proc { Hash[SSHExecutionProvider::EFFECTIVE_USER_METHODS.map { |method| [method, method] }] } }),
         self.set('remote_execution_sync_templates',
                  N_('Whether we should sync templates from disk when running db:seed.'),
                  true),
         self.set('remote_execution_ssh_port',
-                N_('Port to use for SSH communication. Default port 22. You may override per host by setting a parameter called remote_execution_ssh_port.'),
-                '22'),
+                 N_('Port to use for SSH communication. Default port 22. You may override per host by setting a parameter called remote_execution_ssh_port.'),
+                 '22'),
         self.set('remote_execution_connect_by_ip',
-                 N_('Should the ip addresses on host interfaces be preferred over the fqdn? It is useful, when DNS not resolving the fqdns properly. You may override this per host by setting a parameter called remote_execution_connect_by_ip.'),
-                false),
+                 N_('Should the ip addresses on host interfaces be preferred over the fqdn? '\
+                 'It is useful, when DNS not resolving the fqdns properly. You may override this per host by setting a parameter called remote_execution_connect_by_ip.'),
+                 false),
       ].each { |s| self.create! s.update(:category => 'Setting::RemoteExecution') }
     end
 

data/app/models/ssh_execution_provider.rb

@@ -1,6 +1,6 @@
 class SSHExecutionProvider < RemoteExecutionProvider
 
-  EFFECTIVE_USER_METHODS = %w[sudo su]
+  EFFECTIVE_USER_METHODS = %w[sudo su].freeze
 
   class << self
     def proxy_command_options(template_invocation, host)
@@ -58,8 +58,6 @@ class SSHExecutionProvider < RemoteExecutionProvider
       method
     end
 
-    private
-
     def effective_interfaces(host)
       interfaces = []
       %w(execution primary provision).map do |flag|

data/app/models/targeting.rb

@@ -1,8 +1,8 @@
 class Targeting < ActiveRecord::Base
 
-  STATIC_TYPE = 'static_query'
-  DYNAMIC_TYPE = 'dynamic_query'
-  TYPES = { STATIC_TYPE => N_('Static Query'), DYNAMIC_TYPE => N_('Dynamic Query') }
+  STATIC_TYPE = 'static_query'.freeze
+  DYNAMIC_TYPE = 'dynamic_query'.freeze
+  TYPES = { STATIC_TYPE => N_('Static Query'), DYNAMIC_TYPE => N_('Dynamic Query') }.freeze
   RESOLVE_PERMISSION = :view_hosts
 
   belongs_to :user
@@ -54,8 +54,9 @@ class Targeting < ActiveRecord::Base
   end
 
   def self.build_query_from_hosts(ids)
-    hosts = Host.where(:id => ids).all.group_by(&:id)
-    hosts.map { |id, h| "name = #{h.first.name}" }.join(' or ')
+    return '' if ids.empty?
+    hosts = Host.where(:id => ids).distinct.pluck(:name)
+    "name ^ (#{hosts.join(', ')})"
   end
 
   def resolved?

data/app/models/template_invocation.rb

@@ -5,7 +5,7 @@ class TemplateInvocation < ActiveRecord::Base
   include ForemanRemoteExecution::ErrorsFlattener
   FLATTENED_ERRORS_MAPPING = { :input_values => lambda do |input_value|
                                                  _('Input') + " #{input_value.template_input.name}"
-                                                end }
+                                                end }.freeze
 
 
   belongs_to :template, :class_name => 'JobTemplate', :foreign_key => 'template_id'
@@ -25,6 +25,48 @@ class TemplateInvocation < ActiveRecord::Base
   scoped_search :in => :template, :on => :job_category, :complete_value => true
   scoped_search :in => :template, :on => :name, :complete_value => true
 
+  class TaskResultMap
+    MAP = {
+      :cancelled => :cancelled,
+      :error     => :failed,
+      :pending   => :pending,
+      :success   => :success,
+      :warning   => :failed
+    }.with_indifferent_access
+
+    REVERSE_MAP = MAP.reduce({}) do |acc, (key, value)|
+      acc[value] ||= []
+      acc[value] << key
+      acc
+    end.with_indifferent_access
+
+    class << self
+      def results
+        MAP.keys.map(&:to_sym)
+      end
+
+      def statuses
+        REVERSE_MAP.keys.map(&:to_sym)
+      end
+
+      # 1:1
+      # error => failed
+      def task_result_to_status(result)
+        MAP[result].try(:to_sym) || result
+      end
+
+      # 1:n
+      # failed => [:error, :warning]
+      def status_to_task_result(status)
+        if REVERSE_MAP.key? status
+          REVERSE_MAP[status].map(&:to_sym)
+        else
+          Array(status)
+        end
+      end
+    end
+  end
+
   def to_action_input
     { :id => id, :name => template.name }
   end

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

@@ -72,7 +72,7 @@
 
                     <div class="advanced hidden">
                       <% if job_template.effective_user.overridable? %>
-                        <%= text_f job_template_fields, :effective_user, :label => _('Effective user'), :help_inline => N_("A user to be used for executing the script. If it differs from the SSH user, su or sudo is used to switch the accounts.") %>
+                        <%= text_f job_template_fields, :effective_user, :value => @composer.template_invocation(job_template).try(:effective_user), :label => _('Effective user'), :help_inline => N_("A user to be used for executing the script. If it differs from the SSH user, su or sudo is used to switch the accounts.") %>
                       <% end %>
                       <%= render :partial => 'description_fields', :locals => { :f => f, :job_template => job_template, :disabled => job_template != selected_templates_per_provider[provider_type] } %>
                     </div>

data/app/views/job_invocations/_tab_overview.html.erb

@@ -41,7 +41,16 @@
       </ul>
     <% end %>
     <% if template_invocation.effective_user %>
-      <b><%= _("Effective user") %></b>: <%= template_invocation.effective_user %>
+      <b><%= _("Effective user") %></b>: <%= template_invocation.effective_user %><br>
+    <% end %>
+    <% if job_invocation.concurrency_level %>
+      <b><%= _("Concurrency level limited to") %></b>: <%= job_invocation.concurrency_level %> <%= _('tasks at a time') %><br>
+    <% end %>
+    <% if job_invocation.time_span %>
+      <b><%= _("Set to distribute over") %></b>: <%= job_invocation.concurrency_level %> <%= _('minutes') %><br>
+    <% end %>
+    <% if job_invocation.task && job_invocation.task.delayed? || job_invocation.task.recurring? %>
+      <b><%= _("Scheduled to start at") %></b>: <%= job_invocation.task.start_at.try(:in_time_zone) %><br>
     <% end %>
   <% end %>
 </div>