foreman_remote_execution 3.0.3 → 3.1.0

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/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
@@ -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/smart_proxy_extensions.rb

@@ -6,6 +6,7 @@ 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

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/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

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, :dependent => :nullify
 
-  alias resource job_invocation
+  alias_method :resource, :job_invocation
 
   def resource_name
     N_('Job Invocation')

data/app/models/job_template.rb

@@ -7,8 +7,8 @@ class JobTemplate < ::Template
   end
 
   attr_exportable :job_category, :description_format,
-                  :foreign_input_sets, :provider_type,
-                  { :kind => ->(template) { template.class.name.underscore } }.merge(taxonomy_exportable)
+    :foreign_input_sets, :provider_type,
+    { :kind => ->(template) { template.class.name.underscore } }.merge(taxonomy_exportable)
 
   include Authorizable
   extend FriendlyId
@@ -65,7 +65,7 @@ class JobTemplate < ::Template
 
     def import_raw!(contents, options = {})
       template = import_raw(contents, options)
-      template.save! if template
+      template&.save!
       template
     end
 

data/app/models/remote_execution_feature.rb

@@ -23,7 +23,6 @@ class RemoteExecutionFeature < ApplicationRecord
     self.find_by(label: label) || raise(::Foreman::Exception.new(N_('Unknown remote execution feature %s'), label))
   end
 
-  # rubocop:disable Metrics/PerceivedComplexity
   def self.register(label, name, options = {})
     begin
       return false unless RemoteExecutionFeature.table_exists?
@@ -61,5 +60,4 @@ class RemoteExecutionFeature < ApplicationRecord
       return feature
     end
   end
-  # rubocop:enable Metrics/PerceivedComplexity
 end

data/app/models/remote_execution_provider.rb

@@ -89,9 +89,11 @@ class RemoteExecutionProvider
       host.host_param(setting.to_s) || Setting[setting]
     end
 
-    def ssh_password(_host) end
+    def ssh_password(_host)
+    end
 
-    def ssh_key_passphrase(_host) end
+    def ssh_key_passphrase(_host)
+    end
 
     def proxy_action_class
       ForemanRemoteExecutionCore::Actions::RunScript

data/app/models/setting/remote_execution.rb

@@ -2,79 +2,77 @@ class Setting::RemoteExecution < Setting
 
   ::Setting::BLANK_ATTRS.concat %w{remote_execution_ssh_password remote_execution_ssh_key_passphrase remote_execution_sudo_password remote_execution_cockpit_url remote_execution_form_job_template}
 
-  # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
   def self.default_settings
     [
       self.set('remote_execution_fallback_proxy',
-               N_('Search the host for any proxy with Remote Execution, useful when the host has no subnet or the subnet does not have an execution proxy'),
-               false,
-               N_('Fallback to Any Proxy')),
+        N_('Search the host for any proxy with Remote Execution, useful when the host has no subnet or the subnet does not have an execution proxy'),
+        false,
+        N_('Fallback to Any Proxy')),
       self.set('remote_execution_global_proxy',
-               N_('Search for remote execution proxy outside of the proxies assigned to the host. ' +
-               "The search will be limited to the host's organization and location."),
-               true,
-               N_('Enable Global Proxy')),
+        N_('Search for remote execution proxy outside of the proxies assigned to the host. ' +
+        "The search will be limited to the host's organization and location."),
+        true,
+        N_('Enable Global Proxy')),
       self.set('remote_execution_ssh_user',
-               N_('Default user to use for SSH.  You may override per host by setting a parameter called remote_execution_ssh_user.'),
-               'root',
-               N_('SSH User')),
+        N_('Default user to use for SSH.  You may override per host by setting a parameter called remote_execution_ssh_user.'),
+        'root',
+        N_('SSH User')),
       self.set('remote_execution_effective_user',
-               N_('Default user to use for executing the script. If the user differs from the SSH user, su or sudo is used to switch the user.'),
-               'root',
-               N_('Effective User')),
+        N_('Default user to use for executing the script. If the user differs from the SSH user, su or sudo is used to switch the user.'),
+        'root',
+        N_('Effective User')),
       self.set('remote_execution_effective_user_method',
-               N_('What command should be used to switch to the effective user. One of %s') % SSHExecutionProvider::EFFECTIVE_USER_METHODS.inspect,
-               'sudo',
-               N_('Effective User Method'),
-               nil,
-               { :collection => proc { Hash[SSHExecutionProvider::EFFECTIVE_USER_METHODS.map { |method| [method, method] }] } }),
+        N_('What command should be used to switch to the effective user. One of %s') % SSHExecutionProvider::EFFECTIVE_USER_METHODS.inspect,
+        'sudo',
+        N_('Effective User Method'),
+        nil,
+        { :collection => proc { Hash[SSHExecutionProvider::EFFECTIVE_USER_METHODS.map { |method| [method, method] }] } }),
       self.set('remote_execution_sudo_password', N_("Sudo password"), '', N_("Sudo password"), nil, {:encrypted => true}),
       self.set('remote_execution_sync_templates',
-               N_('Whether we should sync templates from disk when running db:seed.'),
-               true,
-               N_('Sync Job Templates')),
+        N_('Whether we should sync templates from disk when running db:seed.'),
+        true,
+        N_('Sync Job Templates')),
       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_('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_('SSH Port')),
       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_('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. '\
+        'This setting only applies to IPv4. When the host has only an IPv6 address on the interface used for remote execution, hostname will be used even if this setting is set to true.'),
+        false,
+        N_('Connect by IP')),
       self.set('remote_execution_ssh_password',
-               N_('Default password to use for SSH. You may override per host by setting a parameter called remote_execution_ssh_password'),
-               nil,
-               N_('Default SSH password'),
-               nil,
-               { :encrypted => true }),
+        N_('Default password to use for SSH. You may override per host by setting a parameter called remote_execution_ssh_password'),
+        nil,
+        N_('Default SSH password'),
+        nil,
+        { :encrypted => true }),
       self.set('remote_execution_ssh_key_passphrase',
-               N_('Default key passphrase to use for SSH. You may override per host by setting a parameter called remote_execution_ssh_key_passphrase'),
-               nil,
-               N_('Default SSH key passphrase'),
-               nil,
-               { :encrypted => true }),
+        N_('Default key passphrase to use for SSH. You may override per host by setting a parameter called remote_execution_ssh_key_passphrase'),
+        nil,
+        N_('Default SSH key passphrase'),
+        nil,
+        { :encrypted => true }),
       self.set('remote_execution_workers_pool_size',
-               N_('Amount of workers in the pool to handle the execution of the remote execution jobs. Restart of the dynflowd/foreman-tasks service is required.'),
-               5,
-               N_('Workers pool size')),
+        N_('Amount of workers in the pool to handle the execution of the remote execution jobs. Restart of the dynflowd/foreman-tasks service is required.'),
+        5,
+        N_('Workers pool size')),
       self.set('remote_execution_cleanup_working_dirs',
-               N_('When enabled, working directories will be removed after task completion. You may override this per host by setting a parameter called remote_execution_cleanup_working_dirs.'),
-               true,
-               N_('Cleanup working directories')),
+        N_('When enabled, working directories will be removed after task completion. You may override this per host by setting a parameter called remote_execution_cleanup_working_dirs.'),
+        true,
+        N_('Cleanup working directories')),
       self.set('remote_execution_cockpit_url',
-               N_('Where to find the Cockpit instance for the Web Console button.  By default, no button is shown.'),
-               nil,
-               N_('Cockpit URL'),
-               nil),
+        N_('Where to find the Cockpit instance for the Web Console button.  By default, no button is shown.'),
+        nil,
+        N_('Cockpit URL'),
+        nil),
       self.set('remote_execution_form_job_template',
-               N_('Choose a job template that is pre-selected in job invocation form'),
-               'Run Command - SSH Default',
-               _('Form Job Template'),
-               nil,
-               { :collection => proc { Hash[JobTemplate.unscoped.map { |template| [template.name, template.name] }] } })
+        N_('Choose a job template that is pre-selected in job invocation form'),
+        'Run Command - SSH Default',
+        _('Form Job Template'),
+        nil,
+        { :collection => proc { Hash[JobTemplate.unscoped.map { |template| [template.name, template.name] }] } }),
     ]
   end
-  # rubocop:enable AbcSize
-  # rubocop:enable Metrics/MethodLength,Metrics/AbcSize
 end