foreman_remote_execution 4.2.2 → 4.5.0

data/app/models/host_status/execution_status.rb

@@ -49,6 +49,13 @@ class HostStatus::ExecutionStatus < HostStatus::Status
     end
   end
 
+  def status_link
+    job_invocation = last_stopped_task.parent_task.job_invocations.first
+    return nil unless User.current.can?(:view_job_invocations, job_invocation)
+
+    Rails.application.routes.url_helpers.job_invocation_path(job_invocation)
+  end
+
   class ExecutionTaskStatusMapper
     attr_accessor :task
 
@@ -57,15 +64,15 @@ class HostStatus::ExecutionStatus < HostStatus::Status
 
       case status
         when OK
-          [ "state = 'stopped' AND result = 'success'" ]
+          [ "foreman_tasks_tasks.state = 'stopped' AND result = 'success'" ]
         when CANCELLED
-          [ "state = 'stopped' AND result = 'cancelled'" ]
+          [ "foreman_tasks_tasks.state = 'stopped' AND result = 'cancelled'" ]
         when ERROR
-          [ "state = 'stopped' AND (result = 'error' OR result = 'warning')" ]
+          [ "foreman_tasks_tasks.state = 'stopped' AND (result = 'error' OR result = 'warning')" ]
         when QUEUED
-          [ "state = 'scheduled' OR state IS NULL" ]
+          [ "foreman_tasks_tasks.state = 'scheduled' OR foreman_tasks_tasks.state IS NULL" ]
         when RUNNING
-          [ "state <> 'stopped'" ]
+          [ "foreman_tasks_tasks.state <> 'stopped'" ]
         else
           [ '1 = 0' ]
       end

data/app/models/invocation_provider_input_value.rb

@@ -0,0 +1,12 @@
+class InvocationProviderInputValue < ApplicationRecord
+  belongs_to :template_invocation
+
+  validates :name, :presence => true
+
+  validates :value, :inclusion => { :in => proc { |v| v.provider_input.options_array } },
+                    :if => proc { |v| v.provider_input.options_array.present? }
+
+  def provider_input
+    template_invocation.template.provider.provider_inputs.find { |item| item.name == name }
+  end
+end

data/app/models/job_invocation.rb

@@ -15,8 +15,9 @@ class JobInvocation < ApplicationRecord
 
   belongs_to :targeting, :dependent => :destroy
   has_many :all_template_invocations, :inverse_of => :job_invocation, :dependent => :destroy, :class_name => 'TemplateInvocation'
-  has_many :template_invocations, -> { where('host_id IS NOT NULL') }, :inverse_of => :job_invocation
-  has_many :pattern_template_invocations, -> { where('host_id IS NULL') }, :inverse_of => :job_invocation, :class_name => 'TemplateInvocation'
+  has_many :template_invocations, -> { where('template_invocations.host_id IS NOT NULL') }, :inverse_of => :job_invocation
+  has_many :pattern_template_invocations, -> { where('template_invocations.host_id IS NULL') }, :inverse_of => :job_invocation, :class_name => 'TemplateInvocation'
+  has_many :pattern_templates, :through => :pattern_template_invocations, :source => :template
 
   validates :targeting, :presence => true
   validates :job_category, :presence => true
@@ -44,26 +45,33 @@ class JobInvocation < ApplicationRecord
                                        :source => 'run_host_job_task'
   has_one :user, through: :task
   scoped_search relation: :user, on: :login, rename: 'user', complete_value: true,
-                value_translation: ->(value) { value == 'current_user' ? User.current.login : value },
-                special_values: [:current_user], aliases: ['owner'], :only_explicit => true
+    value_translation: ->(value) { value == 'current_user' ? User.current.login : value },
+    special_values: [:current_user], aliases: ['owner'], :only_explicit => true
   scoped_search :relation => :task, :on => :started_at, :rename => 'started_at', :complete_value => true
   scoped_search :relation => :task, :on => :start_at, :rename => 'start_at', :complete_value => true
   scoped_search :relation => :task, :on => :ended_at, :rename => 'ended_at', :complete_value => true
   scoped_search :relation => :task, :on => :state, :rename => 'status', :ext_method => :search_by_status,
-                :only_explicit => true, :complete_value => Hash[HostStatus::ExecutionStatus::STATUS_NAMES.values.map { |v| [v, v] }]
+    :only_explicit => true, :complete_value => Hash[HostStatus::ExecutionStatus::STATUS_NAMES.values.map { |v| [v, v] }]
 
   belongs_to :triggering, :class_name => 'ForemanTasks::Triggering'
   has_one :recurring_logic, :through => :triggering, :class_name => 'ForemanTasks::RecurringLogic'
 
   belongs_to :remote_execution_feature
 
+  has_many :targeted_hosts, :through => :targeting, :source => :hosts
+  scoped_search :on => 'targeted_host_id', :rename => 'targeted_host_id', :operators => ['= '],
+    :complete_value => false, :only_explicit => true, :ext_method => :search_by_targeted_host
+
+  scoped_search :on => 'pattern_template_name', :rename => 'pattern_template_name', :operators => ['= '],
+    :complete_value => false, :only_explicit => true, :ext_method => :search_by_pattern_template
+
   scope :with_task, -> { references(:task) }
 
   scoped_search :relation => :recurring_logic, :on => 'id', :rename => 'recurring_logic.id'
 
   scoped_search :relation => :recurring_logic, :on => 'id', :rename => 'recurring',
-                :ext_method => :search_by_recurring_logic, :only_explicit => true,
-                :complete_value => { :true => true, :false => false }
+    :ext_method => :search_by_recurring_logic, :only_explicit => true,
+    :complete_value => { :true => true, :false => false }
 
   default_scope -> { order('job_invocations.id DESC') }
 
@@ -76,6 +84,18 @@ class JobInvocation < ApplicationRecord
 
   encrypts :password, :key_passphrase, :effective_user_password
 
+  class Jail < Safemode::Jail
+    allow :sub_task_for_host, :template_invocations_hosts
+  end
+
+  def self.search_by_targeted_host(key, operator, value)
+    { :conditions => sanitize_sql_for_conditions(["hosts.id = ?", value]), :joins => :targeted_hosts }
+  end
+
+  def self.search_by_pattern_template(key, operator, value)
+    { :conditions => sanitize_sql_for_conditions(["templates.name = ?", value]), :joins => :pattern_templates }
+  end
+
   def self.search_by_status(key, operator, value)
     conditions = HostStatus::ExecutionStatus::ExecutionTaskStatusMapper.sql_conditions_for(value)
     conditions[0] = "NOT (#{conditions[0]})" if operator == '<>'
@@ -241,7 +261,7 @@ class JobInvocation < ApplicationRecord
   end
 
   def finished?
-    !task.pending?
+    !(task.nil? || task.pending?)
   end
 
   def missing_hosts_count

data/app/models/job_invocation_composer.rb

@@ -1,4 +1,7 @@
 class JobInvocationComposer
+  class JobTemplateNotFound < StandardError; end
+
+  class FeatureNotFound < StandardError; end
 
   class UiParams
     attr_reader :ui_params
@@ -64,6 +67,10 @@ class JobInvocationComposer
           values.merge(:template_input_id => id)
         end
 
+        provider_values_params = template_base.fetch(:provider_input_values, {})
+        template_base[:provider_input_values] = provider_values_params.map do |key, hash|
+          { :name => key, :value => hash[:value] }
+        end
         template_base
       end
     end
@@ -96,6 +103,17 @@ class JobInvocationComposer
 
     def initialize(api_params)
       @api_params = api_params
+
+      if api_params[:feature]
+        # set a default targeting type for backward compatibility
+        # when `for_feature` was used by the API it automatically set a default
+        api_params[:targeting_type] = Targeting::STATIC_TYPE
+      end
+
+      if api_params[:search_query].blank? && api_params[:host_ids].present?
+        translator = HostIdsTranslator.new(api_params[:host_ids])
+        api_params[:search_query] = translator.scoped_search
+      end
     end
 
     def params
@@ -103,12 +121,16 @@ class JobInvocationComposer
         :targeting => targeting_params,
         :triggering => triggering_params,
         :description_format => api_params[:description_format],
-        :remote_execution_feature_id => api_params[:remote_execution_feature_id],
+        :remote_execution_feature_id => remote_execution_feature_id,
         :concurrency_control => concurrency_control_params,
         :execution_timeout_interval => api_params[:execution_timeout_interval] || template.execution_timeout_interval,
         :template_invocations => template_invocations_params }.with_indifferent_access
     end
 
+    def remote_execution_feature_id
+      feature&.id || api_params[:remote_execution_feature_id]
+    end
+
     def targeting_params
       raise ::Foreman::Exception, _('Cannot specify both bookmark_id and search_query') if api_params[:bookmark_id] && api_params[:search_query]
 
@@ -147,6 +169,7 @@ class JobInvocationComposer
 
     def template_invocations_params
       template_invocation_params = { :template_id => template.id, :effective_user => api_params[:effective_user] }
+      template_invocation_params[:provider_input_values] = filter_provider_inputs api_params
       template_invocation_params[:input_values] = api_params.fetch(:inputs, {}).to_h.map do |name, value|
         input = template.template_inputs_with_foreign.find { |i| i.name == name }
         unless input
@@ -158,8 +181,27 @@ class JobInvocationComposer
       [template_invocation_params]
     end
 
+    def filter_provider_inputs(api_params)
+      return [] if template.provider.provider_input_namespace.empty?
+      inputs = api_params[template.provider.provider_input_namespace].to_h
+      provider_input_names = template.provider.provider_inputs.map(&:name)
+      inputs.select { |key, value| provider_input_names.include? key }.map { |key, value| { :name => key, :value => value } }
+    end
+
+    def feature
+      @feature ||= RemoteExecutionFeature.feature(api_params[:feature]) if api_params[:feature]
+    rescue => e
+      raise(FeatureNotFound, e.message)
+    end
+
+    def job_template_id
+      feature&.job_template_id || api_params[:job_template_id]
+    end
+
     def template
-      @template ||= JobTemplate.authorized(:view_job_templates).find(api_params[:job_template_id])
+      @template ||= JobTemplate.authorized(:view_job_templates).find(job_template_id)
+    rescue ActiveRecord::RecordNotFound
+      raise(JobTemplateNotFound, _("Template with id '%{id}' was not found") % { id: job_template_id })
     end
 
     private
@@ -227,25 +269,38 @@ class JobInvocationComposer
     end
   end
 
+  class HostIdsTranslator
+    attr_reader :bookmark, :hosts, :scoped_search, :host_ids
+
+    def initialize(input)
+      case input
+      when Bookmark
+        @bookmark = input
+      when Host::Base
+        @hosts = [input]
+      when Array
+        @hosts = input.map do |id|
+          Host::Managed.authorized.friendly.find(id)
+        end
+      when String
+        @scoped_search = input
+      else
+        @hosts = input
+      end
+
+      @scoped_search ||= Targeting.build_query_from_hosts(hosts.map(&:id)) if @hosts
+    end
+  end
+
   class ParamsForFeature
     attr_reader :feature_label, :feature, :provided_inputs
 
     def initialize(feature_label, hosts, provided_inputs = {})
       @feature = RemoteExecutionFeature.feature(feature_label)
       @provided_inputs = provided_inputs
-      if hosts.is_a? Bookmark
-        @host_bookmark = hosts
-      elsif hosts.is_a? Host::Base
-        @host_objects = [hosts]
-      elsif hosts.is_a? Array
-        @host_objects = hosts.map do |id|
-          Host::Managed.authorized.friendly.find(id)
-        end
-      elsif hosts.is_a? String
-        @host_scoped_search = hosts
-      else
-        @host_objects = hosts
-      end
+      translator = HostIdsTranslator.new(hosts)
+      @host_bookmark = translator.bookmark
+      @host_scoped_search = translator.scoped_search
     end
 
     def params
@@ -263,7 +318,6 @@ class JobInvocationComposer
       ret = {}
       ret['targeting_type'] = Targeting::STATIC_TYPE
       ret['search_query'] = @host_scoped_search if @host_scoped_search
-      ret['search_query'] = Targeting.build_query_from_hosts(@host_objects) if @host_objects
       ret['bookmark_id'] = @host_bookmark.id if @host_bookmark
       ret['user_id'] = User.current.id
       ret
@@ -503,6 +557,7 @@ class JobInvocationComposer
       input = template_invocation.template.template_inputs_with_foreign.find { |i| i.id.to_s == attributes[:template_input_id].to_s }
       input ? input.template_invocation_input_values.build(attributes) : nil
     end.compact
+    template_invocation.provider_input_values.build job_template_base.fetch('provider_input_values', [])
   end
 
   def build_targeting
@@ -540,7 +595,7 @@ class JobInvocationComposer
 
     params[:template_invocations].select { |t| valid_template_ids.include?(t[:template_id].to_i) }.map do |template_invocation_params|
       template_invocation = job_invocation.pattern_template_invocations.build(:template_id => template_invocation_params[:template_id],
-                                                                              :effective_user => build_effective_user(template_invocation_params))
+        :effective_user => build_effective_user(template_invocation_params))
       build_input_values_for(template_invocation, template_invocation_params)
       template_invocation
     end

data/app/models/remote_execution_provider.rb

@@ -20,7 +20,7 @@ class RemoteExecutionProvider
     end
 
     def proxy_command_options(template_invocation, host)
-      {:proxy_operation_name => proxy_operation_name}
+      {:proxy_operation_name => proxy_operation_name}.merge(proxy_command_provider_inputs(template_invocation))
     end
 
     def secrets(_host)
@@ -35,6 +35,9 @@ class RemoteExecutionProvider
       self.name
     end
 
+    def provider_input_namespace
+    end
+
     def supports_effective_user?
       false
     end
@@ -95,8 +98,20 @@ class RemoteExecutionProvider
     def ssh_key_passphrase(_host)
     end
 
+    def provider_inputs
+      []
+    end
+
+    def provider_inputs_doc
+      {}
+    end
+
+    def proxy_command_provider_inputs(template_invocation)
+      {}
+    end
+
     def proxy_action_class
-      ForemanRemoteExecutionCore::Actions::RunScript
+      'ForemanRemoteExecutionCore::Actions::RunScript'
     end
 
     # Return a specific proxy selector to use for running a given template

data/app/models/setting/remote_execution.rb

@@ -73,6 +73,16 @@ class Setting::RemoteExecution < Setting
         _('Form Job Template'),
         nil,
         { :collection => proc { Hash[JobTemplate.unscoped.map { |template| [template.name, template.name] }] } }),
+      self.set('remote_execution_job_invocation_report_template',
+        N_('Select a report template used for generating a report for a particular remote execution job'),
+        'Jobs - Invocation report template',
+        _('Job Invocation Report Template'),
+        nil,
+        { :collection => proc { self.job_invocation_report_templates_select } }),
     ]
   end
+
+  def self.job_invocation_report_templates_select
+    Hash[ReportTemplate.unscoped.joins(:template_inputs).where(template_inputs: TemplateInput.where(name: 'job_id')).map { |template| [template.name, template.name] }]
+  end
 end

data/app/models/ssh_execution_provider.rb

@@ -2,10 +2,10 @@ class SSHExecutionProvider < RemoteExecutionProvider
   class << self
     def proxy_command_options(template_invocation, host)
       super.merge(:ssh_user => ssh_user(host),
-                  :effective_user => effective_user(template_invocation),
-                  :effective_user_method => effective_user_method(host),
-                  :cleanup_working_dirs => cleanup_working_dirs?(host),
-                  :ssh_port => ssh_port(host))
+        :effective_user => effective_user(template_invocation),
+        :effective_user_method => effective_user_method(host),
+        :cleanup_working_dirs => cleanup_working_dirs?(host),
+        :ssh_port => ssh_port(host))
     end
 
     def humanized_name

data/app/models/template_invocation.rb

@@ -11,6 +11,7 @@ class TemplateInvocation < ApplicationRecord
   belongs_to :template, :class_name => 'JobTemplate', :foreign_key => 'template_id'
   belongs_to :job_invocation, :inverse_of => :template_invocations
   has_many :input_values, :class_name => 'TemplateInvocationInputValue', :dependent => :destroy
+  has_many :provider_input_values, :class_name => 'InvocationProviderInputValue', :dependent => :destroy
   has_one :targeting, :through => :job_invocation
   belongs_to :host, :class_name => 'Host::Managed', :foreign_key => :host_id
   has_one :host_group, :through => :host, :source => :hostgroup
@@ -77,6 +78,7 @@ class TemplateInvocation < ApplicationRecord
   def deep_clone
     self.dup.tap do |invocation|
       invocation.input_values = self.input_values.map(&:dup)
+      invocation.provider_input_values = self.provider_input_values.map(&:dup)
     end
   end
 

data/app/overrides/execution_interface.rb

@@ -1,9 +1,9 @@
-Deface::Override.new(:virtual_path    => 'hosts/_form',
-                     :name            => 'add_execution_interface_js',
-                     :insert_before   => 'div#primary',
-                     :text            => '<%= javascript "foreman_remote_execution/execution_interface" %>')
+Deface::Override.new(:virtual_path => 'hosts/_form',
+  :name            => 'add_execution_interface_js',
+  :insert_before   => 'div#primary',
+  :text            => '<%= javascript "foreman_remote_execution/execution_interface" %>')
 
-Deface::Override.new(:virtual_path  => 'nic/_base_form',
-                     :name          => 'add_execution_interface',
-                     :insert_after  => 'erb[loud]:contains("interface_provision")',
-                     :partial       => 'overrides/nics/execution_interface')
+Deface::Override.new(:virtual_path => 'nic/_base_form',
+  :name          => 'add_execution_interface',
+  :insert_after  => 'erb[loud]:contains("interface_provision")',
+  :partial       => 'overrides/nics/execution_interface')

data/app/overrides/subnet_proxies.rb

@@ -1,9 +1,9 @@
 Deface::Override.new(:virtual_path => 'subnets/_form',
-                     :name => 'add_remote_execution_proxies_tab',
-                     :insert_after => 'li.active',
-                     :partial => 'overrides/subnets/rex_tab')
+  :name => 'add_remote_execution_proxies_tab',
+  :insert_after => 'li.active',
+  :partial => 'overrides/subnets/rex_tab')
 
 Deface::Override.new(:virtual_path => 'subnets/_form',
-                     :name => 'add_remote_execution_proxies_tab_pane',
-                     :insert_after => 'div#proxies',
-                     :partial => 'overrides/subnets/rex_tab_pane')
+  :name => 'add_remote_execution_proxies_tab_pane',
+  :insert_after => 'div#proxies',
+  :partial => 'overrides/subnets/rex_tab_pane')

data/app/services/renderer_methods.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# macros to fetch information about invoked jobs
+module RendererMethods
+  extend ActiveSupport::Concern
+
+  def find_job_invocation_by_id(job_id, preload: nil)
+    JobInvocation.preload(preload).find_by(id: job_id)
+  rescue ActiveRecord::NotFound => _e
+    raise ::Foreman::Exception.new(N_("Can't find Job Invocation for an id %s"), job_id)
+  end
+end

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

@@ -74,6 +74,14 @@
                     <% end %>
 
                     <div class="advanced hidden">
+                      <%= job_template_fields.fields_for :provider_input_values do |provider_input_fields| %>
+                        <% job_template.provider.provider_inputs.each do |input| %>
+                            <%= provider_input_fields.fields_for input.name, input do |input_fields| %>
+                              <%= template_input_f(input_fields) %>
+                            <% end %>
+                        <% end %>
+                      <% end %>
+
                       <% if job_template.effective_user.overridable? %>
                         <%= text_f job_template_fields, :effective_user, :value => @composer.template_invocation(job_template).try(:effective_user), :label => _('Effective user'), :label_help => 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 %>