foreman_remote_execution 4.4.0 → 4.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28b7b4b36385dfde5221cc7d9b9d07d95f4515dafb657507015b9436086474ca
-  data.tar.gz: 27d3907329bcda250a9518903f069de480fda0609a53134369c2a348a31fb29a
+  metadata.gz: 812237a4d9fd4c4000c8522be1ecdaf539f8ca15e9b6e63a599da92419ade6f4
+  data.tar.gz: 8a0c5f90892a268816c0b16184faef14b55a36f60fdd0750303291d0688ba83f
 SHA512:
-  metadata.gz: 9bfc761d4d8343a7fce864c3155cea9d4a3c67ff42b60359901e8be0f890ddfc63f536e3288133877a448cbee367063a990619a1b85007ab8f0433f4acd917b6
-  data.tar.gz: 05b1af5c16a8c0d542b9876f86810e8ca2c44dbe4165ff10eccf08eb1172edacc94e68025e486324c52648be0b1cfaf2e85ceb552755428a5917163c28febfad
+  metadata.gz: a572fa58d1c7b1776c5493afdb9e2940f97e03a996e5e56c5ed633497b825a8e77b2013a7570c8990403f3f2e0f197036aee556c7177cae3fb6feac585f5c95b
+  data.tar.gz: 57d64d09cbd7b14984564201e53df9a76bd6e95fc7008283e506924813d7ee18996ece236d2d6258da4f61a8a56816491b9b690a01f36e0a94de364db4c5ba64

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

@@ -80,18 +80,15 @@ module Api
       api :POST, '/job_invocations/', N_('Create a job invocation')
       param_group :job_invocation, :as => :create
       def create
-        if job_invocation_params[:feature].present?
-          composer = composer_for_feature
-        else
-          validate_template
-          composer = JobInvocationComposer.from_api_params(
-            job_invocation_params
-          )
-        end
+        composer = JobInvocationComposer.from_api_params(
+          job_invocation_params
+        )
         composer.trigger!
         @job_invocation = composer.job_invocation
         @hosts = @job_invocation.targeting.hosts
         process_response @job_invocation
+      rescue JobInvocationComposer::JobTemplateNotFound, JobInvocationComposer::FeatureNotFound => e
+        not_found(error: { message: e.message })
       end
 
       api :GET, '/job_invocations/:id/hosts/:host_id', N_('Get output for a host')
@@ -128,7 +125,7 @@ module Api
           render :json => { :cancelled => result, :id => @job_invocation.id }
         else
           render :json => { :message => _('The job could not be cancelled.') },
-                 :status => :unprocessable_entity
+            :status => :unprocessable_entity
         end
       end
 
@@ -143,7 +140,7 @@ module Api
           process_response @job_invocation
         else
           render :json => { :error => _('Could not rerun job %{id} because its template could not be found') % { :id => composer.reruns } },
-                 :status => :not_found
+            :status => :not_found
         end
       end
 
@@ -190,19 +187,19 @@ module Api
         not_found({ :error => { :message => (_("Host with id '%{id}' was not found") % { :id => params['host_id'] }) } })
       end
 
-      def validate_template
-        JobTemplate.authorized(:view_job_templates).find(job_invocation_params['job_template_id'])
-      rescue ActiveRecord::RecordNotFound
-        not_found({ :error => { :message => (_("Template with id '%{id}' was not found") % { :id => job_invocation_params['job_template_id'] }) } })
-      end
-
       def job_invocation_params
         return @job_invocation_params if @job_invocation_params.present?
 
         job_invocation_params = params.fetch(:job_invocation, {}).dup
+
+        if job_invocation_params[:feature].present? && job_invocation_params[:job_template_id].present?
+          raise _("Only one of feature or job_template_id can be specified")
+        end
+
         if job_invocation_params.key?(:ssh)
           job_invocation_params.merge!(job_invocation_params.delete(:ssh).permit(:effective_user))
         end
+
         job_invocation_params[:inputs] ||= {}
         job_invocation_params[:inputs].permit!
         permit_provider_inputs job_invocation_params
@@ -214,14 +211,6 @@ module Api
         providers.each { |provider| invocation_params[provider.provider_input_namespace]&.permit! }
       end
 
-      def composer_for_feature
-        JobInvocationComposer.for_feature(
-          job_invocation_params[:feature],
-          job_invocation_params[:host_ids],
-          job_invocation_params[:inputs].to_hash
-        )
-      end
-
       def output_lines_since(task, time)
         since = time.to_f if time.present?
         line_sets = task.main_action.live_output

data/app/controllers/job_invocations_controller.rb

@@ -67,7 +67,7 @@ class JobInvocationsController < ApplicationController
   end
 
   def index
-    @job_invocations = resource_base_search_and_page.with_task.order('job_invocations.id DESC')
+    @job_invocations = resource_base_search_and_page.preload(:task, :targeting).order('job_invocations.id DESC')
   end
 
   # refreshes the form

data/app/controllers/job_templates_controller.rb

@@ -24,10 +24,10 @@ class JobTemplatesController < ::TemplatesController
       render :plain => output
     else
       render status: :not_acceptable,
-             plain: _(
-               'Problem with previewing the template: %{error}. Note that you must save template input changes before you try to preview it.' %
-               {:error => renderer.error_message}
-             )
+        plain: _(
+          'Problem with previewing the template: %{error}. Note that you must save template input changes before you try to preview it.' %
+          {:error => renderer.error_message}
+        )
     end
   end
 

data/app/controllers/ui_job_wizard_controller.rb

@@ -8,6 +8,25 @@ class UiJobWizardController < ::Api::V2::BaseController
     render :json => {:job_categories =>job_categories}
   end
 
+  def template
+    job_template = JobTemplate.authorized.find(params[:id])
+    advanced_template_inputs, template_inputs = map_template_inputs(job_template.template_inputs_with_foreign).partition { |x| x["advanced"] }
+    render :json => {
+      :job_template => job_template,
+      :effective_user => job_template.effective_user,
+      :template_inputs => template_inputs,
+      :advanced_template_inputs => advanced_template_inputs,
+    }
+  end
+
+  def resource_name(nested_resource = nil)
+    nested_resource || 'job_template'
+  end
+
+  def map_template_inputs(template_inputs_with_foreign)
+    template_inputs_with_foreign.map { |input| input.attributes.merge({:resource_type => input.resource_type&.tableize }) }
+  end
+
   def resource_class
     JobTemplate
   end

data/app/helpers/job_invocations_helper.rb

@@ -34,8 +34,8 @@ module JobInvocationsHelper
     hosts.map do |host|
       collapsed_preview(host) +
         render(:partial => 'job_invocations/user_input',
-               :locals => { :template_invocation => template_invocation,
-                            :target => host })
+          :locals => { :template_invocation => template_invocation,
+                       :target => host })
     end.reduce(:+)
   end
 

data/app/helpers/remote_execution_helper.rb

@@ -7,6 +7,10 @@ module RemoteExecutionHelper
     @job_hosts_authorizer ||= Authorizer.new(User.current, :collection => @hosts)
   end
 
+  def host_tasks_authorizer
+    @host_tasks_authorizer ||= Authorizer.new(User.current, :collection => @job_invocation.sub_tasks)
+  end
+
   def host_counter(label, count)
     content_tag(:div, :class => 'host_counter') do
       content_tag(:div, label, :class => 'header') + content_tag(:div, count.to_s, :class => 'count')
@@ -27,19 +31,19 @@ module RemoteExecutionHelper
 
     if authorized_for(hash_for_host_path(host).merge(auth_object: host, permission: :view_hosts, authorizer: job_hosts_authorizer))
       links << { title: _('Host detail'),
-                 action: { href: host_path(host), 'data-method': 'get', id: "#{host.name}-actions-detail" } }
+        action: { href: host_path(host), 'data-method': 'get', id: "#{host.name}-actions-detail" } }
     end
 
     if authorized_for(hash_for_rerun_job_invocation_path(id: job_invocation, host_ids: [ host.id ], authorizer: job_hosts_authorizer))
       links << { title: (_('Rerun on %s') % host.name),
-                 action: { href: rerun_job_invocation_path(job_invocation, host_ids: [ host.id ]),
-                           'data-method': 'get', id: "#{host.name}-actions-rerun" } }
+        action: { href: rerun_job_invocation_path(job_invocation, host_ids: [ host.id ]),
+                  'data-method': 'get', id: "#{host.name}-actions-rerun" } }
     end
 
-    if host_task.present? && authorized_for(hash_for_foreman_tasks_task_path(host_task).merge(auth_object: host_task, permission: :view_foreman_tasks))
+    if host_task.present? && authorized_for(hash_for_foreman_tasks_task_path(host_task).merge(auth_object: host_task, permission: :view_foreman_tasks, authorizer: host_tasks_authorizer))
       links << { title: _('Host task'),
-                 action: { href: foreman_tasks_task_path(host_task),
-                           'data-method': 'get', id: "#{host.name}-actions-task" } }
+        action: { href: foreman_tasks_task_path(host_task),
+                  'data-method': 'get', id: "#{host.name}-actions-task" } }
     end
 
     links
@@ -159,11 +163,11 @@ module RemoteExecutionHelper
       content_tag :pre, preview
     elsif target.nil?
       alert :text => _('Could not render the preview because no host matches the search query.'),
-            :class => 'alert alert-block alert-warning base',
-            :close => false
+        :class => 'alert alert-block alert-warning base',
+        :close => false
     else
       alert :class => 'alert-block alert-danger base in fade has-error',
-            :text => renderer.error_message.html_safe # rubocop:disable Rails/OutputSafety
+        :text => renderer.error_message.html_safe # rubocop:disable Rails/OutputSafety
     end
   end
 

data/app/lib/actions/remote_execution/run_host_job.rb

@@ -5,6 +5,8 @@ module Actions
       include ::Actions::Helpers::WithDelegatedAction
       include ::Actions::ObservableAction
 
+      execution_plan_hooks.use :emit_feature_event, :on => :success
+
       middleware.do_not_use Dynflow::Middleware::Common::Transaction
       middleware.use Actions::Middleware::HideSecrets
 
@@ -17,7 +19,12 @@ module Actions
       end
 
       def plan(job_invocation, host, template_invocation, proxy_selector = ::RemoteExecutionProxySelector.new, options = {})
-        action_subject(host, :job_category => job_invocation.job_category, :description => job_invocation.description, :job_invocation_id => job_invocation.id)
+        features = template_invocation.template.remote_execution_features.pluck(:label).uniq
+        action_subject(host,
+          :job_category => job_invocation.job_category,
+          :description => job_invocation.description,
+          :job_invocation_id => job_invocation.id,
+          :job_features => features)
 
         template_invocation.host_id = host.id
         template_invocation.run_host_job_task_id = task.id
@@ -40,12 +47,16 @@ module Actions
         script = renderer.render
         raise _('Failed rendering template: %s') % renderer.error_message unless script
 
+        first_execution = host.executed_through_proxies.where(:id => proxy.id).none?
+        host.executed_through_proxies << proxy if first_execution
+
         additional_options = { :hostname => provider.find_ip_or_hostname(host),
                                :script => script,
                                :execution_timeout_interval => job_invocation.execution_timeout_interval,
                                :secrets => secrets(host, job_invocation, provider),
                                :use_batch_triggering => true,
-                               :use_concurrency_control => options[:use_concurrency_control]}
+                               :use_concurrency_control => options[:use_concurrency_control],
+                               :first_execution => first_execution }
         action_options = provider.proxy_command_options(template_invocation, host)
                                  .merge(additional_options)
 
@@ -58,6 +69,22 @@ module Actions
         check_exit_status
       end
 
+      def self.feature_job_event_name(label, suffix = :success)
+        ::Foreman::Observable.event_name_for("#{::Actions::RemoteExecution::RunHostJob.event_name_base}_#{label}_#{::Actions::RemoteExecution::RunHostJob.event_name_suffix(suffix)}")
+      end
+
+      def emit_feature_event(execution_plan, hook = :success)
+        return unless root_action?
+
+        payload = event_payload(execution_plan)
+        if input["job_features"]&.any?
+          input['job_features'].each do |feature|
+            name = "#{self.class.event_name_base}_#{feature}_#{self.class.event_name_suffix(hook)}"
+            trigger_hook name, payload: payload
+          end
+        end
+      end
+
       def secrets(host, job_invocation, provider)
         job_secrets = { :ssh_password => job_invocation.password,
                         :key_passphrase => job_invocation.key_passphrase,
@@ -78,7 +105,7 @@ module Actions
 
       def humanized_input
         N_('%{description} on %{host}') % { :host => input[:host].try(:[], :name),
-                                            :description => input[:description].try(:capitalize) || input[:job_category] }
+          :description => input[:description].try(:capitalize) || input[:job_category] }
       end
 
       def humanized_name
@@ -186,10 +213,13 @@ module Actions
             'All %{count} applicable proxies are down. Tried %{proxy_names}',
             offline_proxies.count) % settings
         elsif proxy == :not_defined
-          settings = { :global_proxy => 'remote_execution_global_proxy',
-                       :fallback_proxy => 'remote_execution_fallback_proxy' }
+          settings = {
+            global_proxy: 'remote_execution_global_proxy',
+            fallback_proxy: 'remote_execution_fallback_proxy',
+            provider: provider,
+          }
 
-          raise _('Could not use any proxy. Consider configuring %{global_proxy}, ' +
+          raise _('Could not use any proxy for the %{provider} job. Consider configuring %{global_proxy}, ' +
                   '%{fallback_proxy} in settings') % settings
         end
         proxy

data/app/models/concerns/foreman_remote_execution/host_extensions.rb

@@ -6,17 +6,19 @@ module ForemanRemoteExecution
         has_many :template_invocations, :dependent => :destroy, :foreign_key => 'host_id'
         has_one :execution_status_object, :class_name => 'HostStatus::ExecutionStatus', :foreign_key => 'host_id', :dependent => :destroy
         has_many :run_host_job_tasks, :through => :template_invocations
+        has_many :host_proxy_invocations, :foreign_key => 'host_id', :dependent => :destroy
+        has_many :executed_through_proxies, :through => :host_proxy_invocations, :source => 'smart_proxy'
 
         scoped_search :relation => :run_host_job_tasks, :on => :result, :rename => 'job_invocation.result',
-                      :ext_method => :search_by_job_invocation,
-                      :only_explicit => true,
-                      :complete_value => TemplateInvocation::TaskResultMap::REVERSE_MAP
+          :ext_method => :search_by_job_invocation,
+          :only_explicit => true,
+          :complete_value => TemplateInvocation::TaskResultMap::REVERSE_MAP
 
         scoped_search :relation => :template_invocations, :on => :job_invocation_id,
-                      :rename => 'job_invocation.id', :only_explicit => true, :ext_method => :search_by_job_invocation
+          :rename => 'job_invocation.id', :only_explicit => true, :ext_method => :search_by_job_invocation
 
         scoped_search :relation => :execution_status_object, :on => :status, :rename => :execution_status,
-                      :complete_value => { :ok => HostStatus::ExecutionStatus::OK, :error => HostStatus::ExecutionStatus::ERROR }
+          :complete_value => { :ok => HostStatus::ExecutionStatus::OK, :error => HostStatus::ExecutionStatus::ERROR }
 
         def search_by_job_invocation(key, operator, value)
           if key == 'job_invocation.result'

data/app/models/concerns/foreman_remote_execution/smart_proxy_extensions.rb

@@ -1,5 +1,11 @@
 module ForemanRemoteExecution
   module SmartProxyExtensions
+    def self.prepended(base)
+      base.instance_eval do
+        has_many :host_proxy_invocations, :dependent => :destroy
+      end
+    end
+
     def pubkey
       self[:pubkey] || update_pubkey
     end

data/app/models/host_proxy_invocation.rb

@@ -0,0 +1,4 @@
+class HostProxyInvocation < ApplicationRecord
+  belongs_to :host, :class_name => 'Host::Managed', :inverse_of => :host_proxy_invocations
+  belongs_to :smart_proxy
+end

data/app/models/host_status/execution_status.rb

@@ -64,15 +64,15 @@ class HostStatus::ExecutionStatus < HostStatus::Status
 
       case status
         when OK
-          [ "state = 'stopped' AND result = 'success'" ]
+          [ "foreman_tasks_tasks.state = 'stopped' AND foreman_tasks_tasks.result = 'success'" ]
         when CANCELLED
-          [ "state = 'stopped' AND result = 'cancelled'" ]
+          [ "foreman_tasks_tasks.state = 'stopped' AND foreman_tasks_tasks.result = 'cancelled'" ]
         when ERROR
-          [ "state = 'stopped' AND (result = 'error' OR result = 'warning')" ]
+          [ "foreman_tasks_tasks.state = 'stopped' AND (foreman_tasks_tasks.result = 'error' OR foreman_tasks_tasks.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/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,31 @@ 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
 
-  scope :with_task, -> { references(:task) }
+  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
 
   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') }
 
@@ -80,10 +86,18 @@ class JobInvocation < ApplicationRecord
     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 == '<>'
-    { :conditions => sanitize_sql_for_conditions(conditions), :include => :task }
+    { :conditions => sanitize_sql_for_conditions(conditions), :joins => :task }
   end
 
   def self.search_by_recurring_logic(key, operator, value)
@@ -177,11 +191,16 @@ class JobInvocation < ApplicationRecord
   end
 
   def total_hosts_count
+    count = _('N/A')
+
     if targeting.resolved?
-      task&.main_action&.total_count || targeting.hosts.count
-    else
-      _('N/A')
+      count = if task&.main_action.respond_to?(:total_count)
+                task.main_action.total_count
+              else
+                targeting.hosts.count
+              end
     end
+    count
   end
 
   def pattern_template_invocation_for_host(host)