foreman_remote_execution 1.3.3 → 1.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb2c9a95f22cf5c9002035f47adfc90eee494da5
-  data.tar.gz: 75e9a15b54a3832e112c5b8d2706a3a353f48e86
+  metadata.gz: 0511db7a2c04a4ddd08d45ebfe0d21e03bd8a919
+  data.tar.gz: 121d18818212309d66f9c20f347c6436b4773c0a
 SHA512:
-  metadata.gz: af011f877cc95f1bf64cb3dd5c8633de7d0fd2aa6a445d15925c78950a50e636acdd298660b0c6970d2c4f17b53a492a51282004011a0fe5ac030ebed57bae3d
-  data.tar.gz: 4d8e436256f46a252dc95987de9e1749c41852baf2e33f837dc6465bcf802d84781ac6e5eac307b2717d2bbbd18b594cac8a9fecc1a0a6adb741edf7dfd1965f
+  metadata.gz: 947a9c319b0cfe8082cd6fc69da05a5d4ffae40b2e5501f5c5aaf8ab2bc4f9b2b354473d4bff53b7599fffeb182395ed4af5b2d39b2934866bccae9b5edc8f79
+  data.tar.gz: 3168906a4cc1bebf31465ef7b0a786ab093cfa29ef2f1fa6902564c1cfc273856663a6bcbacf3974317abb92f5bbfe574b95fb7d02a2a75f8050c0472c76ccae

data/.rubocop.yml

@@ -18,10 +18,6 @@ Rails/HttpPositionalArguments:
 Style/Documentation:
   Enabled: false
 
-# Force before_filter until upgrade to Rails 4
-Rails/ActionFilter:
-  EnforcedStyle: filter
-
 Metrics/MethodLength:
   Max: 40
 

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

@@ -5,8 +5,8 @@ module Api
       include ::Foreman::Renderer
       include ::Foreman::Controller::Parameters::ForeignInputSet
 
-      before_filter :find_required_nested_object
-      before_filter :find_resource, :only => %w{show update destroy}
+      before_action :find_required_nested_object
+      before_action :find_resource, :only => %w{show update destroy}
 
       api :GET, '/templates/:template_id/foreign_input_sets', N_('List foreign input sets')
       param :template_id, :identifier, :required => true

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

@@ -5,10 +5,10 @@ module Api
       include ::Api::TaxonomyScope
       include ::Foreman::Renderer
 
-      before_filter :find_optional_nested_object
-      before_filter :find_host, :only => %w{output}
-      before_filter :find_resource, :only => %w{show update destroy clone}
-      before_filter :validate_template, :only => :create
+      before_action :find_optional_nested_object
+      before_action :find_host, :only => %w{output}
+      before_action :find_resource, :only => %w{show update destroy clone}
+      before_action :validate_template, :only => :create
 
       wrap_parameters JobInvocation, :include => (JobInvocation.attribute_names + [:ssh])
 
@@ -97,7 +97,7 @@ module Api
       end
 
       def find_host
-        @host = Host::Base.authorized(:view_hosts).find(params['host_id'])
+        @host = Host.authorized(:view_hosts).find(params['host_id'])
       rescue ActiveRecord::RecordNotFound
         not_found({ :error => { :message => (_("Host with id '%{id}' was not found") % { :id => params['host_id'] }) } })
       end

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

@@ -7,10 +7,10 @@ module Api
       include ::Foreman::Controller::ProvisioningTemplates
       include ::Foreman::Controller::Parameters::JobTemplate
 
-      before_filter :find_optional_nested_object
-      before_filter :find_resource, :only => %w{show update destroy clone export}
+      before_action :find_optional_nested_object
+      before_action :find_resource, :only => %w{show update destroy clone export}
 
-      before_filter :handle_template_upload, :only => [:create, :update]
+      before_action :handle_template_upload, :only => [:create, :update]
 
       wrap_parameters JobTemplate, :include => (JobTemplate.attribute_names + [:ssh])
 

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

@@ -4,7 +4,7 @@ module Api
       include ::Api::Version2
       include ::Foreman::Controller::Parameters::RemoteExecutionFeature
 
-      before_filter :find_resource, :only => %w{show update}
+      before_action :find_resource, :only => %w{show update}
 
       api :GET, '/remote_execution_features/', N_('List remote execution features')
       def index

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

@@ -5,9 +5,9 @@ module Api
       include ::Foreman::Renderer
       include ::Foreman::Controller::Parameters::TemplateInput
 
-      before_filter :find_required_nested_object
-      before_filter :find_resource, :only => %w{show update destroy}
-      before_filter :normalize_options, :only => %w{create update}
+      before_action :find_required_nested_object
+      before_action :find_resource, :only => %w{show update destroy}
+      before_action :normalize_options, :only => %w{create update}
 
       api :GET, '/templates/:template_id/template_inputs', N_('List template inputs')
       param :template_id, :identifier, :required => true

data/app/controllers/job_templates_controller.rb

@@ -20,7 +20,7 @@ class JobTemplatesController < ::TemplatesController
     @template.template = params[:template]
     renderer = InputTemplateRenderer.new(@template, host)
     if (output = renderer.preview)
-      render :text => output
+      render :plain => output
     else
       render :status => 406, :text => _('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

data/app/controllers/remote_execution_features_controller.rb

@@ -1,5 +1,5 @@
 class RemoteExecutionFeaturesController < ::ApplicationController
-  before_filter :find_resource, :only => [:show, :update]
+  before_action :find_resource, :only => [:show, :update]
   include ::Foreman::Controller::Parameters::RemoteExecutionFeature
 
   def index

data/app/helpers/concerns/foreman_remote_execution/hosts_helper_extensions.rb

@@ -1,14 +1,7 @@
 module ForemanRemoteExecution
   module HostsHelperExtensions
-    extend ActiveSupport::Concern
-
-    included do
-      alias_method_chain(:host_title_actions, :run_button)
-      alias_method_chain :multiple_actions, :remote_execution
-    end
-
-    def multiple_actions_with_remote_execution
-      multiple_actions_without_remote_execution + [ [_('Schedule Remote Job'), new_job_invocation_path, false] ]
+    def multiple_actions
+      super + [ [_('Schedule Remote Job'), new_job_invocation_path, false] ]
     end
 
     def schedule_job_multi_button(*args)
@@ -27,9 +20,9 @@ module ForemanRemoteExecution
       link_to(_('Schedule Remote Job'), new_job_invocation_path(:host_ids => [args.first.id]), :id => :run_button, :class => 'btn btn-default')
     end
 
-    def host_title_actions_with_run_button(*args)
+    def host_title_actions(*args)
       title_actions(button_group(schedule_job_multi_button(*args)))
-      host_title_actions_without_run_button(*args)
+      super(*args)
     end
   end
 end

data/app/helpers/concerns/foreman_remote_execution/job_templates_extensions.rb

@@ -1,13 +1,7 @@
 module ForemanRemoteExecution
   module JobTemplatesExtensions
-    extend ActiveSupport::Concern
-
-    included do
-      alias_method_chain :permitted_actions, :run_button
-    end
-
-    def permitted_actions_with_run_button(template)
-      original = permitted_actions_without_run_button(template)
+    def permitted_actions(template)
+      original = super(template)
 
       if template.is_a?(JobTemplate)
         original.unshift(display_link_if_authorized(_('Run'), hash_for_new_job_invocation_path(:template_id => template.id).merge(:authorizer => authorizer))) unless template.snippet

data/app/helpers/remote_execution_helper.rb

@@ -122,6 +122,11 @@ module RemoteExecutionHelper
                          :title => _('Try to cancel the job'),
                          :disabled => !task.cancellable?,
                          :method => :post)
+      buttons << link_to(_('Abort Job'), abort_foreman_tasks_task_path(task),
+                         :class => 'btn btn-danger',
+                         :title => _('Try to abort the job without waiting for the results from the remote hosts'),
+                         :disabled => !task.cancellable?,
+                         :method => :post)
     end
     return buttons
   end
@@ -140,6 +145,11 @@ module RemoteExecutionHelper
                          :title => _('Try to cancel the job on a host'),
                          :disabled => !task.cancellable?,
                          :method => :post)
+      buttons << link_to(_('Abort Job'), abort_foreman_tasks_task_path(task),
+                         :class => 'btn btn-danger',
+                         :title => _('Try to abort the job on a host without waiting for its result'),
+                         :disabled => !task.cancellable?,
+                         :method => :post)
     end
     return buttons
   end

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

@@ -60,6 +60,7 @@ module Actions
       end
 
       def check_exit_status
+        error! ForemanTasks::Task::TaskCancelledException.new(_('Task cancelled')) if delegated_action && delegated_action.output[:cancel_sent]
         error! _('Job execution failed') if exit_status.to_s != '0'
       end
 
@@ -89,20 +90,28 @@ module Actions
         super << self
       end
 
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def fill_continuous_output(continuous_output)
-        fill_planning_errors_to_continuous_output(continuous_output) unless exit_status
         delegated_output.fetch('result', []).each do |raw_output|
           continuous_output.add_raw_output(raw_output)
         end
+
         final_timestamp = (continuous_output.last_timestamp || task.ended_at).to_f + 1
+
+        if task.state == 'stopped' && task.result == 'cancelled'
+          continuous_output.add_output(_('Job cancelled by user'), 'debug', final_timestamp)
+        else
+          fill_planning_errors_to_continuous_output(continuous_output) unless exit_status
+        end
         if exit_status
           continuous_output.add_output(_('Exit status: %s') % exit_status, 'stdout', final_timestamp)
         elsif run_step && run_step.error
-          continuous_output.add_ouput(_('Job finished with error') + ": #{run_step.error.exception_class} - #{run_step.error.message}", 'debug', final_timestamp)
+          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]

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

@@ -3,6 +3,7 @@ module Actions
     class RunHostsJob < Actions::ActionWithSubPlans
 
       include Dynflow::Action::WithBulkSubPlans
+      include Dynflow::Action::WithPollingSubPlans
 
       middleware.use Actions::Middleware::BindJobInvocation
       middleware.use Actions::Middleware::RecurringLogic
@@ -10,15 +11,16 @@ module Actions
       def delay(delay_options, job_invocation)
         task.add_missing_task_groups(job_invocation.task_group)
         job_invocation.targeting.resolve_hosts! if job_invocation.targeting.static? && !job_invocation.targeting.resolved?
+        input.update :job_invocation => job_invocation.to_action_input
         super delay_options, job_invocation
       end
 
       def plan(job_invocation)
-        set_up_concurrency_control job_invocation
         job_invocation.task_group.save! if job_invocation.task_group.try(:new_record?)
         task.add_missing_task_groups(job_invocation.task_group) if job_invocation.task_group
         action_subject(job_invocation)
         job_invocation.targeting.resolve_hosts! if job_invocation.targeting.dynamic? || !job_invocation.targeting.resolved?
+        set_up_concurrency_control job_invocation
         input.update(:job_category => job_invocation.job_category)
         plan_self(:job_invocation_id => job_invocation.id)
       end
@@ -50,7 +52,10 @@ module Actions
 
       def set_up_concurrency_control(invocation)
         limit_concurrency_level invocation.concurrency_level unless invocation.concurrency_level.nil?
-        distribute_over_time invocation.time_span unless invocation.time_span.nil?
+        unless invocation.time_span.nil?
+          distribute_over_time(invocation.time_span,
+                               invocation.targeting.hosts.count)
+        end
       end
 
       def rescue_strategy
@@ -62,7 +67,7 @@ module Actions
       end
 
       def humanized_input
-        input[:job_invocation][:description]
+        input.fetch(:job_invocation, {}).fetch(:description, '')
       end
 
       def humanized_name

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

@@ -1,47 +1,41 @@
 module ForemanRemoteExecution
   module HostExtensions
-    extend ActiveSupport::Concern
-
     # rubocop:disable Metrics/BlockLength
-    included do
-      alias_method_chain :build_required_interfaces, :remote_execution
-      alias_method_chain :reload, :remote_execution
-      alias_method_chain :becomes, :remote_execution
-      alias_method_chain :host_params, :remote_execution
-
-      has_many :targeting_hosts, :dependent => :destroy, :foreign_key => 'host_id'
-      has_many :template_invocations, :dependent => :destroy, :foreign_key => 'host_id'
-      has_one :execution_status_object, :class_name => 'HostStatus::ExecutionStatus', :foreign_key => 'host_id'
-      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
-
-      scoped_search :relation => :template_invocations, :on => :job_invocation_id,
-                    :rename => 'job_invocation.id', :only_explicit => true, :ext_method => :search_by_job_invocation
-
-      scoped_search :in => :execution_status_object, :on => :status, :rename => :execution_status,
-                    :complete_value => { :ok => HostStatus::ExecutionStatus::OK, :error => HostStatus::ExecutionStatus::ERROR }
-
-      def self.search_by_job_invocation(key, operator, value)
-        if key == 'job_invocation.result'
-          operator = operator == '=' ? 'IN' : 'NOT IN'
-          value = TemplateInvocation::TaskResultMap.status_to_task_result(value)
+    def self.prepended(base)
+      base.instance_eval do
+        has_many :targeting_hosts, :dependent => :destroy, :foreign_key => 'host_id'
+        has_many :template_invocations, :dependent => :destroy, :foreign_key => 'host_id'
+        has_one :execution_status_object, :class_name => 'HostStatus::ExecutionStatus', :foreign_key => 'host_id'
+        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
+
+        scoped_search :relation => :template_invocations, :on => :job_invocation_id,
+                      :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 }
+
+        def search_by_job_invocation(key, operator, value)
+          if key == 'job_invocation.result'
+            operator = operator == '=' ? 'IN' : 'NOT IN'
+            value = TemplateInvocation::TaskResultMap.status_to_task_result(value)
+          end
+
+          mapping = {
+            'job_invocation.id'     => %(#{TemplateInvocation.table_name}.job_invocation_id #{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] }
+          }
         end
-
-        mapping = {
-          'job_invocation.id'     => %(#{TemplateInvocation.table_name}.job_invocation_id #{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] }
-        }
       end
     end
-    # rubocop:enable Metrics/BlockLength
 
     def execution_status(options = {})
       @execution_status ||= get_status(HostStatus::ExecutionStatus).to_status(options)
@@ -51,8 +45,8 @@ module ForemanRemoteExecution
       @execution_status_label ||= get_status(HostStatus::ExecutionStatus).to_label(options)
     end
 
-    def host_params_with_remote_execution
-      params = host_params_without_remote_execution
+    def host_params
+      params = super
       keys = remote_execution_ssh_keys
       params['remote_execution_ssh_keys'] = keys if keys.present?
       [:remote_execution_ssh_user, :remote_execution_effective_user_method,
@@ -94,21 +88,21 @@ module ForemanRemoteExecution
       @execution_interface = nil
     end
 
-    def becomes_with_remote_execution(*args)
-      became = becomes_without_remote_execution(*args)
+    def becomes(*args)
+      became = super(*args)
       became.drop_execution_interface_cache if became.respond_to? :drop_execution_interface_cache
       became
     end
 
-    def reload_with_remote_execution(*args)
+    def reload(*args)
       drop_execution_interface_cache
-      reload_without_remote_execution(*args)
+      super(*args)
     end
 
     private
 
-    def build_required_interfaces_with_remote_execution(attrs = {})
-      build_required_interfaces_without_remote_execution(attrs)
+    def build_required_interfaces(attrs = {})
+      super(attrs)
       self.primary_interface.execution = true if self.execution_interface.nil?
     end
   end

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

@@ -1,11 +1,5 @@
 module ForemanRemoteExecution
   module SmartProxyExtensions
-    extend ActiveSupport::Concern
-
-    included do
-      alias_method_chain :refresh, :remote_execution
-    end
-
     def pubkey
       self[:pubkey] || update_pubkey
     end
@@ -17,8 +11,8 @@ module ForemanRemoteExecution
       key
     end
 
-    def refresh_with_remote_execution
-      errors = refresh_without_remote_execution
+    def refresh
+      errors = super
       update_pubkey
       errors
     end

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

@@ -5,11 +5,12 @@ module ForemanRemoteExecution
     included do
       has_many :job_templates, :through => :taxable_taxonomies, :source => :taxable, :source_type => 'JobTemplate'
 
-      # FIXME - workaround for #11805 - use before_create for setting
+      # TODO: on foreman_version_bump
+      # workaround for #11805 - use before_create for setting
       # the default templates, remove after it's fixed in upstream
-      # (https://github.com/theforeman/foreman/pull/2723) and we don't
-      # support Foreman 1.9
-      skip_callback :create, :after, :assign_default_templates
+      # (https://github.com/theforeman/foreman/pull/4890) and gets
+      # into a 1.17 release
+      skip_callback :create, :after, :assign_default_templates, :raise => false
       before_create :assign_default_templates
     end
   end

data/app/models/job_invocation.rb

@@ -1,5 +1,6 @@
 class JobInvocation < ActiveRecord::Base
   include Authorizable
+  audited :except => [ :task_id, :targeting_id, :task_group_id, :triggering_id ]
 
   include ForemanRemoteExecution::ErrorsFlattener
   FLATTENED_ERRORS_MAPPING = {
@@ -21,7 +22,7 @@ class JobInvocation < ActiveRecord::Base
   scoped_search :on => :description # FIXME No auto complete because of https://github.com/wvanbergen/scoped_search/issues/138
 
   has_many :template_invocations_hosts, :through => :template_invocations, :source => :host
-  scoped_search :in => :template_invocations_hosts, :on => :name, :rename => 'host', :complete_value => true
+  scoped_search :relation => :template_invocations_hosts, :on => :name, :rename => 'host', :complete_value => true
 
   delegate :bookmark, :resolved?, :to => :targeting, :allow_nil => true
 
@@ -37,10 +38,10 @@ class JobInvocation < ActiveRecord::Base
                                        :class_name => 'ForemanTasks::Task',
                                        :source => 'run_host_job_task'
 
-  scoped_search :in => :task, :on => :started_at, :rename => 'started_at', :complete_value => true
-  scoped_search :in => :task, :on => :start_at, :rename => 'start_at', :complete_value => true
-  scoped_search :in => :task, :on => :ended_at, :rename => 'ended_at', :complete_value => true
-  scoped_search :in => :task, :on => :state, :rename => 'status', :ext_method => :search_by_status,
+  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] }]
 
   belongs_to :triggering, :class_name => 'ForemanTasks::Triggering'
@@ -48,9 +49,9 @@ class JobInvocation < ActiveRecord::Base
 
   scope :with_task, -> { references(:task) }
 
-  scoped_search :in => :recurring_logic, :on => 'id', :rename => 'recurring_logic.id'
+  scoped_search :relation => :recurring_logic, :on => 'id', :rename => 'recurring_logic.id'
 
-  scoped_search :in => :recurring_logic, :on => 'id', :rename => 'recurring',
+  scoped_search :relation => :recurring_logic, :on => 'id', :rename => 'recurring',
                 :ext_method => :search_by_recurring_logic, :only_explicit => true,
                 :complete_value => { :true => true, :false => false }
 
@@ -85,6 +86,10 @@ class JobInvocation < ActiveRecord::Base
     HostStatus::ExecutionStatus::ExecutionTaskStatusMapper.new(task).status_label
   end
 
+  def to_label
+    description
+  end
+
   # returns progress in percents
   def progress(total = nil, done = nil)
     if queued? || !targeting.resolved? || done == 0
@@ -183,7 +188,7 @@ class JobInvocation < ActiveRecord::Base
   def progress_report
     map = TemplateInvocation::TaskResultMap
     all_keys = (map.results | map.statuses | [:progress, :total])
-    if queued? || !targeting.resolved?
+    if queued? || (task && task.started_at.nil?) || !targeting.resolved?
       all_keys.reduce({}) do |acc, key|
         acc.merge(key => 0)
       end

data/app/models/job_invocation_composer.rb

@@ -186,7 +186,7 @@ class JobInvocationComposer
 
     def targeting_params
       if @host_ids
-        { :search_query => Targeting.build_query_from_hosts(@host_ids) }
+        { :search_query => Targeting.build_query_from_hosts(@host_ids), :targeting_type => job_invocation.targeting.targeting_type }
       else
         job_invocation.targeting.attributes.slice('search_query', 'bookmark_id', 'user_id', 'targeting_type')
       end

data/app/models/template_invocation.rb

@@ -20,10 +20,10 @@ class TemplateInvocation < ActiveRecord::Base
   validate :provides_required_input_values
   before_validation :set_effective_user
 
-  scoped_search :in => :host, :on => :name, :rename => 'host.name', :complete_value => true
-  scoped_search :in => :host_group, :on => :name, :rename => 'host_group.name', :complete_value => true
-  scoped_search :in => :template, :on => :job_category, :complete_value => true
-  scoped_search :in => :template, :on => :name, :complete_value => true
+  scoped_search :relation => :host, :on => :name, :rename => 'host.name', :complete_value => true
+  scoped_search :relation => :host_group, :on => :name, :rename => 'host_group.name', :complete_value => true
+  scoped_search :relation => :template, :on => :job_category, :complete_value => true
+  scoped_search :relation => :template, :on => :name, :complete_value => true
 
   class TaskResultMap
     MAP = {

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

@@ -47,7 +47,7 @@
       <b><%= _("Concurrency level limited to") %></b>: <%= job_invocation.concurrency_level %> <%= _('tasks at a time') %><br>
     <% end %>
     <% if job_invocation.time_span %>
-      <b><%= _("Set to distribute over") %></b>: <%= job_invocation.concurrency_level %> <%= _('minutes') %><br>
+      <b><%= _("Set to distribute over") %></b>: <%= job_invocation.time_span %> <%= _('seconds') %><br>
     <% end %>
     <% if job_invocation.task && (job_invocation.task.delayed? || job_invocation.task.recurring?) %>
       <b><%= _("Scheduled to start at") %></b>: <%= job_invocation.task.start_at.try(:in_time_zone) %><br>

data/db/migrate/20150616080015_create_template_input.rb

@@ -11,7 +11,7 @@ class CreateTemplateInput < ActiveRecord::Migration
       t.text :description
       t.integer :template_id
 
-      t.timestamps
+      t.timestamps :null => true
     end
 
     add_foreign_key :template_inputs, :templates, :name => 'templates_template_id_fk', :column => 'template_id'

data/db/migrate/20150708133241_add_targeting.rb

@@ -5,7 +5,7 @@ class AddTargeting < ActiveRecord::Migration
       t.references :bookmark
       t.references :user
       t.string :targeting_type, :null => false, :limit => 255
-      t.timestamps
+      t.timestamps :null => true
     end
 
     add_index :targetings, [:bookmark_id], :name => 'targetings_bookmark_id'

data/foreman_remote_execution.gemspec

@@ -24,9 +24,9 @@ Gem::Specification.new do |s|
   s.extra_rdoc_files = `git ls-files doc`.split("\n") + Dir['README*', 'LICENSE']
 
   s.add_dependency 'deface'
-  s.add_dependency 'dynflow', '~> 0.8.10'
+  s.add_dependency 'dynflow', '~> 0.8.26'
   s.add_dependency 'foreman_remote_execution_core'
-  s.add_dependency 'foreman-tasks', '>= 0.9'
+  s.add_dependency 'foreman-tasks', '>= 0.9.5'
 
   s.add_development_dependency 'rubocop'
   s.add_development_dependency 'rdoc'

data/lib/foreman_remote_execution/engine.rb

@@ -109,7 +109,9 @@ module ForemanRemoteExecution
         # widget 'foreman_remote_execution_widget', name: N_('Foreman plugin template widget'), sizex: 4, sizey: 1
 
         parameter_filter Subnet, :remote_execution_proxies, :remote_execution_proxy_ids => []
-        parameter_filter Nic, :execution
+        parameter_filter Nic::Interface do |ctx|
+          ctx.permit :execution
+        end
       end
     end
 
@@ -146,7 +148,7 @@ module ForemanRemoteExecution
 
       User.send(:include, ForemanRemoteExecution::UserExtensions)
 
-      Host::Managed.send(:include, ForemanRemoteExecution::HostExtensions)
+      Host::Managed.send(:prepend, ForemanRemoteExecution::HostExtensions)
       Host::Managed.send(:include, ForemanTasks::Concerns::HostActionSubject)
 
       (Nic::Base.descendants + [Nic::Base]).each do |klass|
@@ -154,10 +156,10 @@ module ForemanRemoteExecution
       end
 
       Bookmark.send(:include, ForemanRemoteExecution::BookmarkExtensions)
-      HostsHelper.send(:include, ForemanRemoteExecution::HostsHelperExtensions)
-      ProvisioningTemplatesHelper.send(:include, ForemanRemoteExecution::JobTemplatesExtensions)
+      HostsHelper.send(:prepend, ForemanRemoteExecution::HostsHelperExtensions)
+      ProvisioningTemplatesHelper.send(:prepend, ForemanRemoteExecution::JobTemplatesExtensions)
 
-      SmartProxy.send(:include, ForemanRemoteExecution::SmartProxyExtensions)
+      SmartProxy.send(:prepend, ForemanRemoteExecution::SmartProxyExtensions)
       Subnet.send(:include, ForemanRemoteExecution::SubnetExtensions)
 
       # We need to explicitly force to load the Task model due to Rails loader

data/lib/foreman_remote_execution/version.rb

@@ -1,3 +1,3 @@
 module ForemanRemoteExecution
-  VERSION = '1.3.3'.freeze
+  VERSION = '1.3.4'.freeze
 end

data/test/unit/actions/run_hosts_job_test.rb

@@ -11,6 +11,7 @@ module ForemanRemoteExecution
     let(:job_invocation) do
       FactoryGirl.build(:job_invocation, :with_template).tap do |invocation|
         invocation.targeting = targeting
+        invocation.description = 'Some short description'
         invocation.save
       end
     end
@@ -31,6 +32,11 @@ module ForemanRemoteExecution
       plan_action action, job_invocation
     end
 
+    let(:delayed) do
+      action.delay({ :start_at => Time.now.getlocal }, job_invocation)
+      action
+    end
+
     before do
       ProxyAPI::ForemanDynflow::DynflowProxy.any_instance.stubs(:tasks_count).returns(0)
       User.current = users :admin
@@ -38,11 +44,6 @@ module ForemanRemoteExecution
     end
 
     context 'targeting resolving' do
-      let(:delayed) do
-        action.delay({ :start_at => Time.now.getlocal }, job_invocation)
-        action
-      end
-
       it 'resolves dynamic targeting in plan' do
         targeting.targeting_type = 'dynamic_query'
         refute targeting.resolved?
@@ -78,6 +79,15 @@ module ForemanRemoteExecution
       job_invocation.task_id.must_equal '123'
     end
 
+    # In plan phase this is handled by #action_subject
+    #   which is expected in tests
+    it 'sets input in delay phase when delayed' do
+      delayed.input[:job_invocation]['id'].must_equal job_invocation.id
+      delayed.input[:job_invocation]['name'].must_equal job_invocation.job_category
+      delayed.input[:job_invocation]['description'].must_equal job_invocation.description
+      planned # To make the expectations happy
+    end
+
     describe 'concurrency control' do
       let(:level) { 5 }
       let(:span) { 60 }
@@ -85,33 +95,28 @@ module ForemanRemoteExecution
       it 'can be disabled' do
         job_invocation.expects(:concurrency_level)
         job_invocation.expects(:time_span)
-        action.expects(:limit_concurrency_level).never
-        action.expects(:distribute_over_time).never
-        planned
+        planned.input.key?(:concurrency_control).must_equal false
       end
 
       it 'can limit concurrency level' do
         job_invocation.expects(:concurrency_level).returns(level).twice
         job_invocation.expects(:time_span)
-        action.expects(:limit_concurrency_level).with(level)
-        action.expects(:distribute_over_time).never
-        planned
+        planned.input[:concurrency_control][:level].wont_be_empty
+        planned.input[:concurrency_control].key?(:time).must_equal false
       end
 
       it 'can distribute tasks over time' do
         job_invocation.expects(:time_span).returns(span).twice
         job_invocation.expects(:concurrency_level)
-        action.expects(:distribute_over_time).with(span)
-        action.expects(:distribute_over_time).never
-        planned
+        planned.input[:concurrency_control][:time].wont_be_empty
+        planned.input[:concurrency_control].key?(:level).must_equal false
       end
 
       it 'can use both' do
         job_invocation.expects(:time_span).returns(span).twice
-        action.expects(:distribute_over_time).with(span)
         job_invocation.expects(:concurrency_level).returns(level).twice
-        action.expects(:limit_concurrency_level).with(level)
-        planned
+        planned.input[:concurrency_control][:time].wont_be_empty
+        planned.input[:concurrency_control][:level].wont_be_empty
       end
     end
   end

data/test/unit/job_invocation_composer_test.rb

@@ -4,9 +4,15 @@ RemoteExecutionProvider.register(:Mcollective, OpenStruct)
 
 class JobInvocationComposerTest < ActiveSupport::TestCase
   before do
-    setup_user('view', 'job_templates', 'name ~ trying*')
-    setup_user('view', 'bookmarks')
-    setup_user('view', 'hosts')
+    setup_user('view',   'job_templates', 'name ~ trying*')
+    setup_user('create', 'job_templates', 'name ~ trying*')
+    setup_user('view',   'job_invocations')
+    setup_user('create', 'job_invocations')
+    setup_user('view',   'bookmarks')
+    setup_user('create', 'bookmarks')
+    setup_user('edit',   'bookmarks')
+    setup_user('view',   'hosts')
+    setup_user('create', 'hosts')
   end
 
   let(:trying_job_template_1) { FactoryGirl.create(:job_template, :job_category => 'trying_job_template_1', :name => 'trying1', :provider_type => 'SSH') }
@@ -500,8 +506,7 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
             }
           }.with_indifferent_access
         end
-        let(:existing) { composer.job_invocation.reload }
-        let(:new_job_invocation) { JobInvocation.new }
+        let(:existing) { composer.job_invocation }
         let(:new_composer) { JobInvocationComposer.from_job_invocation(composer.job_invocation) }
 
         before do
@@ -590,7 +595,7 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
 
       it 'finds the inputs by name' do
         assert composer.save!
-        assert_equal 1, composer.pattern_template_invocations.first.input_values.count
+        assert_equal 1, composer.pattern_template_invocations.first.input_values.collect.count
       end
     end
 

data/test/unit/job_invocation_test.rb

@@ -127,6 +127,19 @@ class JobInvocationTest < ActiveSupport::TestCase
       specify { job_invocation.progress_report.must_equal progress_report_without_sub_tasks }
     end
 
+    context 'with cancelled task' do
+      before do
+        task.state = 'stopped'
+        task.result = 'error'
+      end
+
+      it 'calculates the progress correctly' do
+        job_invocation.targeting.stubs(:resolved?).returns(true)
+        task.expects(:sub_tasks_counts).never
+        job_invocation.progress_report.must_equal progress_report_without_sub_tasks
+      end
+    end
+
     context 'with succeeded task' do
       before do
         task.state = 'stopped'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foreman_remote_execution
 version: !ruby/object:Gem::Version
-  version: 1.3.3
+  version: 1.3.4
 platform: ruby
 authors:
 - Foreman Remote Execution team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-20 00:00:00.000000000 Z
+date: 2017-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: deface
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.10
+        version: 0.8.26
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.10
+        version: 0.8.26
 - !ruby/object:Gem::Dependency
   name: foreman_remote_execution_core
   requirement: !ruby/object:Gem::Requirement
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: 0.9.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: 0.9.5
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -431,7 +431,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: A plugin bringing remote execution to the Foreman, completing the config