foreman_remote_execution 3.0.2 → 3.2.2

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

@@ -42,7 +42,8 @@ module Actions
                                :script => script,
                                :execution_timeout_interval => job_invocation.execution_timeout_interval,
                                :secrets => secrets(host, job_invocation, provider),
-                               :use_batch_triggering => true}
+                               :use_batch_triggering => true,
+                               :use_concurrency_control => options[:use_concurrency_control]}
         action_options = provider.proxy_command_options(template_invocation, host)
                                  .merge(additional_options)
 
@@ -94,7 +95,6 @@ module Actions
         super << self
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def fill_continuous_output(continuous_output)
         delegated_output.fetch('result', []).each do |raw_output|
           continuous_output.add_raw_output(raw_output)
@@ -109,13 +109,12 @@ module Actions
         end
         if exit_status
           continuous_output.add_output(_('Exit status: %s') % exit_status, 'stdout', final_timestamp)
-        elsif run_step && run_step.error
+        elsif run_step&.error
           continuous_output.add_output(_('Job finished with error') + ": #{run_step.error.exception_class} - #{run_step.error.message}", 'debug', final_timestamp)
         end
       rescue => e
         continuous_output.add_exception(_('Error loading data from proxy'), e)
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
       def exit_status
         delegated_output[:exit_status]
@@ -162,8 +161,8 @@ module Actions
           offline_proxies = proxy_selector.offline
           settings = { :count => offline_proxies.count, :proxy_names => offline_proxies.map(&:name).join(', ') }
           raise n_('The only applicable proxy %{proxy_names} is down',
-                   'All %{count} applicable proxies are down. Tried %{proxy_names}',
-                   offline_proxies.count) % settings
+            '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' }

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

@@ -42,7 +42,7 @@ module Actions
           # during actual run (here) so we build template invocations from these patterns
           template_invocation = job_invocation.pattern_template_invocation_for_host(host).deep_clone
           template_invocation.host_id = host.id
-          trigger(RunHostJob, job_invocation, host, template_invocation, proxy_selector)
+          trigger(RunHostJob, job_invocation, host, template_invocation, proxy_selector, { :use_concurrency_control => uses_concurrency_control })
         end
       end
 
@@ -76,7 +76,7 @@ module Actions
         limit_concurrency_level invocation.concurrency_level unless invocation.concurrency_level.nil?
         unless invocation.time_span.nil?
           distribute_over_time(invocation.time_span,
-                               invocation.targeting.hosts.count)
+            invocation.targeting.hosts.count)
         end
       end
 

data/app/lib/foreman_remote_execution/renderer/scope/input.rb

@@ -61,6 +61,7 @@ module ForemanRemoteExecution
 
         def input(name)
           return template_input_values[name.to_s] if template_input_values.key?(name.to_s)
+
           input = find_by_name(template.template_inputs_with_foreign, name) # rubocop:disable Rails/DynamicFindBy
           if input
             @preview ? input.preview(self) : input.value(self)

data/app/lib/proxy_api/remote_execution_ssh.rb

@@ -10,5 +10,11 @@ module ::ProxyAPI
     rescue => e
       raise ProxyException.new(url, e, N_('Unable to fetch public key'))
     end
+
+    def drop_from_known_hosts(hostname)
+      delete('known_hosts/' + hostname)
+    rescue => e
+      raise ProxyException.new(url, e, N_('Unable to remove host from known hosts'))
+    end
   end
 end

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

@@ -7,7 +7,6 @@ module ForemanRemoteExecution
     def flattened_errors
       errors = Hash.new { |h, k| h[k] = [] }
       # self.errors is ActiveModel::Errors, not Hash and doesn't have the #each_key method
-      # rubocop:disable Performance/HashEachMethods
       self.errors.keys.each do |key|
         messages = self.errors[key]
         invalid_objects = invalid_objects_for_attribute(key)
@@ -19,7 +18,6 @@ module ForemanRemoteExecution
           end
         end
       end
-      # rubocop:enable Performance/HashEachMethods
       errors.map { |key, messages| self.errors.full_message(key, messages.join(', ')) }
     end
 

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

@@ -1,6 +1,5 @@
 module ForemanRemoteExecution
   module HostExtensions
-    # rubocop:disable Metrics/BlockLength
     def self.prepended(base)
       base.instance_eval do
         has_many :targeting_hosts, :dependent => :destroy, :foreign_key => 'host_id'
@@ -27,11 +26,11 @@ module ForemanRemoteExecution
 
           mapping = {
             'job_invocation.id'     => %(#{TemplateInvocation.table_name}.job_invocation_id #{operator} ?),
-            'job_invocation.result' => %(#{ForemanTasks::Task.table_name}.result #{operator} (?))
+            'job_invocation.result' => %(#{ForemanTasks::Task.table_name}.result #{operator} (?)),
           }
           {
             :conditions => sanitize_sql_for_conditions([mapping[key], value_to_sql(operator, value)]),
-            :joins => { :template_invocations => [:run_host_job_task] }
+            :joins => { :template_invocations => [:run_host_job_task] },
           }
         end
       end
@@ -50,7 +49,7 @@ module ForemanRemoteExecution
       keys = remote_execution_ssh_keys
       source = 'global'
       if keys.present?
-        value, safe_value = params.fetch('remote_execution_ssh_keys', {}).values_at(:value, :safe_value).map { |v| v || [] }
+        value, safe_value = params.fetch('remote_execution_ssh_keys', {}).values_at(:value, :safe_value).map { |v| [v].flatten.compact }
         params['remote_execution_ssh_keys'] = {:value => value + keys, :safe_value => safe_value + keys, :source => source}
       end
       [:remote_execution_ssh_user, :remote_execution_effective_user_method,
@@ -65,10 +64,9 @@ module ForemanRemoteExecution
       get_interface_by_flag(:execution)
     end
 
-    # rubocop:disable Metrics/PerceivedComplexity
     def remote_execution_proxies(provider, authorized = true)
       proxies = {}
-      proxies[:subnet]   = execution_interface.subnet.remote_execution_proxies.with_features(provider) if execution_interface && execution_interface.subnet
+      proxies[:subnet]   = execution_interface.subnet.remote_execution_proxies.with_features(provider) if execution_interface&.subnet
       proxies[:fallback] = smart_proxies.with_features(provider) if Setting[:remote_execution_fallback_proxy]
 
       if Setting[:remote_execution_global_proxy]

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

@@ -11,6 +11,7 @@ module ForemanRemoteExecution
 
     def set_execution_flag
       return unless primary? && host.present?
+
       self.execution = true if host.interfaces.detect(&:execution).nil?
     end
 

data/app/models/concerns/foreman_remote_execution/orchestration/ssh.rb

@@ -0,0 +1,63 @@
+module ForemanRemoteExecution
+  module Orchestration::SSH
+    extend ActiveSupport::Concern
+
+    included do
+      before_destroy :ssh_destroy
+      after_validation :queue_ssh_destroy
+      register_rebuild(:queue_ssh_destroy, N_("SSH_#{self.to_s.split('::').first}"))
+    end
+
+    def drop_from_known_hosts(proxy_id)
+      _, _, target = host_kind_target
+      return true if target.nil?
+
+      proxy = ::SmartProxy.find(proxy_id)
+      begin
+        proxy.drop_host_from_known_hosts(target)
+      rescue RestClient::ResourceNotFound => e
+        # ignore 404 when known_hosts entry is missing or the module was not enabled
+        Foreman::Logging.exception "Proxy failed to delete SSH known_hosts for #{name}, #{ip}", e, :level => :error
+      rescue => e
+        Rails.logger.warn e.message
+        return false
+      end
+      true
+    end
+
+    def ssh_destroy
+      logger.debug "Scheduling SSH known_hosts cleanup"
+
+      host, _kind, _target = host_kind_target
+      proxies = host.remote_execution_proxies('SSH').values
+      proxies.flatten.uniq.each do |proxy|
+        queue.create(id: queue_id(proxy.id), name: _("Remove SSH known hosts for %s") % self,
+          priority: 200, action: [self, :drop_from_known_hosts, proxy.id])
+      end
+    end
+
+    def queue_ssh_destroy
+      should_drop_from_known_hosts? && ssh_destroy
+    end
+
+    def should_drop_from_known_hosts?
+      host, = host_kind_target
+      host && !host.new_record? && host.build && host.changes.key?('build')
+    end
+
+    private
+
+    def host_kind_target
+      if self.is_a?(::Host::Base)
+        [self, 'host', name]
+      else
+        [self.host, 'interface', ip]
+      end
+    end
+
+    def queue_id(proxy_id)
+      _, kind, id = host_kind_target
+      "ssh_remove_known_hosts_#{kind}_#{id}_#{proxy_id}"
+    end
+  end
+end

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

@@ -6,11 +6,16 @@ module ForemanRemoteExecution
 
     def update_pubkey
       return unless has_feature?('SSH')
+
       key = ::ProxyAPI::RemoteExecutionSSH.new(:url => url).pubkey
       self.update_attribute(:pubkey, key) if key
       key
     end
 
+    def drop_host_from_known_hosts(host)
+      ::ProxyAPI::RemoteExecutionSSH.new(:url => url).drop_from_known_hosts(host)
+    end
+
     def refresh
       errors = super
       update_pubkey

data/app/models/foreign_input_set.rb

@@ -16,9 +16,10 @@ class ForeignInputSet < ApplicationRecord
 
   def inputs(templates_stack = [])
     return [] unless target_template
-    if templates_stack.include?(target_template)
+
+    if templates_stack.include?(target_template) || template&.id == target_template&.id
       raise CircularDependencyError.new(N_("Circular dependency detected in foreign input set '%{template}' -> '%{target_template}'. Templates stack: %{templates_stack}"),
-                                        :template => template.name, :target_template => target_template.name, :templates_stack => templates_stack.map(&:name).inspect)
+        :template => template.name, :target_template => target_template.name, :templates_stack => templates_stack.map(&:name).inspect)
     end
     inputs = target_template.template_inputs_with_foreign(templates_stack + [target_template])
     unless self.include_all?

data/app/models/host_status/execution_status.rb

@@ -7,8 +7,10 @@ class HostStatus::ExecutionStatus < HostStatus::Status
   QUEUED = 2
   # execution is in progress, dynflow task was created
   RUNNING = 3
+  # execution has been cancelled
+  CANCELLED = 4
   # mapping to string representation
-  STATUS_NAMES = { OK => 'succeeded', ERROR => 'failed', QUEUED => 'queued', RUNNING => 'running' }.freeze
+  STATUS_NAMES = { OK => 'succeeded', ERROR => 'failed', QUEUED => 'queued', RUNNING => 'running', CANCELLED => 'cancelled' }.freeze
 
   def relevant?(*args)
     execution_tasks.present?
@@ -38,6 +40,8 @@ class HostStatus::ExecutionStatus < HostStatus::Status
     case to_status(options)
       when OK
         execution_tasks.present? ? N_('Last execution succeeded') : N_('No execution finished yet')
+      when CANCELLED
+        N_('Last execution cancelled')
       when ERROR
         N_('Last execution failed')
       else
@@ -54,6 +58,8 @@ class HostStatus::ExecutionStatus < HostStatus::Status
       case status
         when OK
           [ "state = 'stopped' AND result = 'success'" ]
+        when CANCELLED
+          [ "state = 'stopped' AND result = 'cancelled'" ]
         when ERROR
           [ "state = 'stopped' AND (result = 'error' OR result = 'warning')" ]
         when QUEUED
@@ -74,6 +80,8 @@ class HostStatus::ExecutionStatus < HostStatus::Status
         QUEUED
       elsif task.state == 'stopped' && task.result == 'success'
         OK
+      elsif task.state == 'stopped' && task.result == 'cancelled'
+        CANCELLED
       elsif task.pending?
         RUNNING
       else

data/app/models/input_template_renderer.rb

@@ -43,7 +43,7 @@ class InputTemplateRenderer
         input_values: @template_input_values,
         templates_stack: templates_stack,
         input_template_instance: self,
-        current_user: User.current.try(:login)
+        current_user: User.current.try(:login),
       }
     )
     Foreman::Renderer.render(source, @scope)

data/app/models/job_invocation.rb

@@ -10,7 +10,7 @@ class JobInvocation < ApplicationRecord
   FLATTENED_ERRORS_MAPPING = {
     :pattern_template_invocations => lambda do |template_invocation|
       _('template') + " #{template_invocation.template.name}"
-    end
+    end,
   }.freeze
 
   belongs_to :targeting, :dependent => :destroy
@@ -198,23 +198,21 @@ class JobInvocation < ApplicationRecord
 
   def output(host)
     return unless (task = sub_task_for_host(host)) && task.main_action && task.main_action.live_output.any?
+
     task.main_action.live_output.first['output']
   end
 
   def generate_description
-    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) 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] }
-    self.description = description_format
-    input_hash.each do |k, v|
-      self.description.gsub!(Regexp.new("%\{#{k}\}"), v || '')
+    input_hash = template_invocation.input_values.reduce({}) do |h, v|
+      value = v.value
+      value = '*' * 3 if v.template_input.respond_to?(:hidden_value) && v.template_input.hidden_value?
+      h.update("%{#{v.template_input.name}}" => value)
     end
+    input_hash.update("%{job_category}" => job_category)
+    input_hash.update("%{template_name}" => template_invocation.template.name)
+    input_hash.default = "''"
+    self.description = description_format.gsub(/%{[^}]+}/) { |key| input_hash[key] }
     self.description = self.description[0..(JobInvocation.columns_hash['description'].limit - 1)]
   end
 

data/app/models/job_invocation_composer.rb

@@ -37,7 +37,7 @@ class JobInvocationComposer
     end
 
     def blank_to_nil(thing)
-      thing.blank? ? nil : thing
+      thing.presence
     end
 
     # TODO: Fix this comment
@@ -71,16 +71,19 @@ class JobInvocationComposer
     def concurrency_control_params
       {
         :time_span => job_invocation_base[:time_span],
-        :level => job_invocation_base[:concurrency_level]
+        :level => job_invocation_base[:concurrency_level],
       }
     end
 
     def triggering
       return {} unless ui_params.key?(:triggering)
+
       trig = ui_params[:triggering]
       keys = (1..5).map { |i| "end_time(#{i}i)" }
-      return trig unless trig.key?(:end_time) && trig[:end_time].keys == keys
-      trig.merge(:end_time => Time.local(*trig[:end_time].values_at(*keys)))
+      values = trig.fetch(:end_time, {}).values_at(*keys)
+      return trig if values.any?(&:nil?)
+
+      trig.merge(:end_time => Time.local(*values))
     end
 
     def targeting(targeting_params)
@@ -108,6 +111,7 @@ class JobInvocationComposer
 
     def targeting_params
       raise ::Foreman::Exception, _('Cannot specify both bookmark_id and search_query') if api_params[:bookmark_id] && api_params[:search_query]
+
       api_params.slice(:targeting_type, :bookmark_id, :search_query, :randomized_ordering).merge(:user_id => User.current.id)
     end
 
@@ -120,14 +124,14 @@ class JobInvocationComposer
           :cronline => api_params[:recurrence][:cron_line],
           :end_time => format_datetime(api_params[:recurrence][:end_time]),
           :input_type => :cronline,
-          :max_iteration => api_params[:recurrence][:max_iteration]
+          :max_iteration => api_params[:recurrence][:max_iteration],
         }
       elsif api_params[:scheduling].present?
         {
           :mode => :future,
           :start_at_raw => format_datetime(api_params[:scheduling][:start_at]),
           :start_before_raw => format_datetime(api_params[:scheduling][:start_before]),
-          :end_time_limited => api_params[:scheduling][:start_before] ? true : false
+          :end_time_limited => api_params[:scheduling][:start_before] ? true : false,
         }
       else
         {}
@@ -137,7 +141,7 @@ class JobInvocationComposer
     def concurrency_control_params
       {
         :level => api_params.fetch(:concurrency_control, {})[:concurrency_level],
-        :time_span => api_params.fetch(:concurrency_control, {})[:time_span]
+        :time_span => api_params.fetch(:concurrency_control, {})[:time_span],
       }
     end
 
@@ -162,6 +166,7 @@ class JobInvocationComposer
 
     def format_datetime(datetime)
       return datetime if datetime.blank?
+
       Time.parse(datetime).strftime('%Y-%m-%d %H:%M')
     end
   end
@@ -195,7 +200,7 @@ class JobInvocationComposer
     def concurrency_control_params
       {
         :level => job_invocation.concurrency_level,
-        :time_span => job_invocation.time_span
+        :time_span => job_invocation.time_span,
       }
     end
 
@@ -271,11 +276,12 @@ class JobInvocationComposer
 
     def input_values_params
       return {} if @provided_inputs.blank?
+
       @provided_inputs.map do |key, value|
         input = job_template.template_inputs_with_foreign.find { |i| i.name == key.to_s }
         unless input
           raise Foreman::Exception.new(N_('Feature input %{input_name} not defined in template %{template_name}'),
-                                       :input_name => key, :template_name => job_template.name)
+            :input_name => key, :template_name => job_template.name)
         end
         { 'template_input_id' => input.id, 'value' => value }
       end
@@ -284,14 +290,14 @@ class JobInvocationComposer
     def job_template
       unless feature.job_template
         raise Foreman::Exception.new(N_('No template mapped to feature %{feature_name}'),
-                                     :feature_name => feature.name)
+          :feature_name => feature.name)
       end
       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'),
-                                     :template_name => template.name,
-                                     :feature_name => feature.name)
+          :template_name => template.name,
+          :feature_name => feature.name)
       end
       template
     end
@@ -329,7 +335,6 @@ class JobInvocationComposer
     self.new(ParamsForFeature.new(feature_label, hosts, provided_inputs).params)
   end
 
-  # rubocop:disable Metrics/AbcSize
   def compose
     job_invocation.job_category = validate_job_category(params[:job_category])
     job_invocation.job_category ||= resolve_job_category(available_job_categories.first) { |tempate| template.job_category } if @set_defaults
@@ -354,7 +359,6 @@ class JobInvocationComposer
 
     self
   end
-  # rubocop:enable Metrics/AbcSize
 
   def trigger(raise_on_error = false)
     generate_description
@@ -576,8 +580,10 @@ class JobInvocationComposer
   def resolve_for_composer(default_value, &block)
     setting_value = Setting['remote_execution_form_job_template']
     return default_value unless setting_value
+
     form_template = JobTemplate.find_by :name => setting_value
     return default_value unless form_template
+
     if block_given?
       yield form_template
     else