foreman_remote_execution 4.4.0 → 4.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28b7b4b36385dfde5221cc7d9b9d07d95f4515dafb657507015b9436086474ca
-  data.tar.gz: 27d3907329bcda250a9518903f069de480fda0609a53134369c2a348a31fb29a
+  metadata.gz: 113fb04d80f92308f55da87e148b2c30de510b5a97dda5c400bdac598d3a407f
+  data.tar.gz: 42a44014bbb85af6ccef059d4d716a9e840865be30735cea61fb65cd94a63d2f
 SHA512:
-  metadata.gz: 9bfc761d4d8343a7fce864c3155cea9d4a3c67ff42b60359901e8be0f890ddfc63f536e3288133877a448cbee367063a990619a1b85007ab8f0433f4acd917b6
-  data.tar.gz: 05b1af5c16a8c0d542b9876f86810e8ca2c44dbe4165ff10eccf08eb1172edacc94e68025e486324c52648be0b1cfaf2e85ceb552755428a5917163c28febfad
+  metadata.gz: 6321f8795de48743746748a71b3a64d4c75de23f55bfe0e79bfd660a54ecd2b5522f10554fa96c16d11350a6800457b47ae0a82fec7f905142f9d062103b3ce6
+  data.tar.gz: 41962649438f42c27845b6e7b6694cff343c4f44e8b7771534a25127458ed2b9a15b404e319e00958f36f81a0d139733820873dd5a2771cb5efeaaebbbfa7223

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_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,18 @@ class UiJobWizardController < ::Api::V2::BaseController
     render :json => {:job_categories =>job_categories}
   end
 
+  def template
+    job_template = JobTemplate.authorized.find(params[:id])
+    render :json => {
+      :job_template => job_template,
+      :effective_user => job_template.effective_user,
+    }
+  end
+
+  def resource_name(nested_resource = nil)
+    nested_resource || 'job_template'
+  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

@@ -27,19 +27,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))
       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 +159,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
@@ -58,6 +65,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 +101,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 +209,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

@@ -8,15 +8,15 @@ module ForemanRemoteExecution
         has_many :run_host_job_tasks, :through => :template_invocations
 
         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/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 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/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') }
 
@@ -80,6 +88,14 @@ 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 == '<>'

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
@@ -100,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
@@ -107,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]
 
@@ -170,8 +188,20 @@ class JobInvocationComposer
       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
@@ -239,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
@@ -275,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
@@ -553,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