foreman-tasks 1.0.1 → 2.0.1

data/app/controllers/foreman_tasks/tasks_controller.rb

@@ -3,8 +3,6 @@ module ForemanTasks
     include Foreman::Controller::AutoCompleteSearch
     include Foreman::Controller::CsvResponder
 
-    before_action :restrict_dangerous_actions, :only => [:unlock, :force_unlock]
-
     def show
       @task = resource_base.find(params[:id])
       render :layout => !request.xhr?
@@ -33,9 +31,12 @@ module ForemanTasks
 
     def cancel_step
       task = find_dynflow_task
-      flash[:info] = _('Trying to cancel step %s') % params[:step_id]
-      ForemanTasks.dynflow.world.event(task.external_id, params[:step_id].to_i, ::Dynflow::Action::Cancellable::Cancel).wait
-      redirect_to foreman_tasks_task_path(task)
+      result = ForemanTasks.dynflow.world.event(task.external_id, params[:step_id].to_i, ::Dynflow::Action::Cancellable::Cancel).wait
+      if result.rejected?
+        render json: { error: result.reason }, status: :bad_request
+      else
+        render json: { statusText: 'OK' }
+      end
     end
 
     def cancel
@@ -72,19 +73,17 @@ module ForemanTasks
       if task.paused?
         task.state = :stopped
         task.save!
-        flash[:info] = _('The task resources were unlocked.')
+        render json: { statusText: 'OK' }
       else
-        flash[:warning] = _('The execution has to be paused.')
+        render json: {}, status: :bad_request
       end
-      redirect_back(:fallback_location => foreman_tasks_task_path(task))
     end
 
     def force_unlock
       task       = find_dynflow_task
       task.state = :stopped
       task.save!
-      flash[:info] = _('The task resources were unlocked with force.')
-      redirect_back(:fallback_location => foreman_tasks_task_path(task))
+      render json: { statusText: 'OK' }
     end
 
     # we need do this to make the Foreman helpers working properly
@@ -103,10 +102,6 @@ module ForemanTasks
       csv_response(@tasks, [:id, :action, :state, :result, 'started_at.in_time_zone', 'ended_at.in_time_zone', :username], ['Id', 'Action', 'State', 'Result', 'Started At', 'Ended At', 'User'])
     end
 
-    def restrict_dangerous_actions
-      render_403 unless Setting['dynflow_allow_dangerous_actions']
-    end
-
     def controller_permission
       'foreman_tasks'
     end

data/app/helpers/foreman_tasks/foreman_tasks_helper.rb

@@ -1,5 +1,4 @@
 module ForemanTasks
-  # rubocop:disable Metrics/ModuleLength
   module ForemanTasksHelper
     def recurring_logic_state(recurring_logic)
       icon, status = case recurring_logic.state
@@ -28,7 +27,7 @@ module ForemanTasks
     def troubleshooting_info_text
       return if @task.state != 'paused' || @task.main_action.nil?
       helper = TroubleshootingHelpGenerator.new(@task.main_action)
-      helper.generate_text
+      helper.generate_html
     end
 
     def username_link_task(owner, username)
@@ -209,5 +208,4 @@ module ForemanTasks
       tags.join.html_safe
     end
   end
-  # rubocop:enable Metrics/ModuleLength
 end

data/app/lib/actions/helpers/humanizer.rb

@@ -78,9 +78,7 @@ module Actions
           else
             head, *tail = subkeys
             if data.is_a?(Hash) && data.key?(head)
-              return fetch_data(data[head], *tail)
-            else
-              return nil
+              fetch_data(data[head], *tail)
             end
           end
         end

data/app/lib/actions/proxy_action.rb

@@ -41,12 +41,7 @@ module Actions
       with_connection_error_handling(event) do |event|
         case event
         when nil
-          if remote_task
-            on_resume
-          else
-            trigger_proxy_task
-          end
-          suspend
+          start_or_resume
         when ::Dynflow::Action::Skip
           # do nothing
         when ::Dynflow::Action::Cancellable::Cancel
@@ -77,6 +72,12 @@ module Actions
       end
     end
 
+    def trigger_remote_task
+      suspend do |_suspended_action|
+        ForemanTasks::RemoteTask.batch_trigger(remote_task.operation, [remote_task])
+      end
+    end
+
     def proxy_input(task_id = task.id)
       input.merge(:callback => { :task_id => task_id,
                                  :step_id => run_step_id })
@@ -88,7 +89,7 @@ module Actions
         if response['result'] == 'error'
           raise ::Foreman::Exception, _('The smart proxy task %s failed.') % proxy_task_id
         else
-          on_data(response['actions'].find { |block_action| block_action['class'] == proxy_action_name }['output'])
+          on_data(get_proxy_data(response))
         end
       else
         suspend
@@ -154,10 +155,8 @@ module Actions
       if output.key?(:proxy_output) || state == :error
         output.fetch(:proxy_output, {})
       elsif live && proxy_task_id
-        proxy_data = proxy.status_of_task(proxy_task_id)['actions'].detect do |action|
-          action['class'] == proxy_action_name || action.fetch('input', {})['proxy_operation_name'] == proxy_operation_name
-        end
-        proxy_data.fetch('output', {})
+        response = proxy.status_of_task(proxy_task_id)
+        get_proxy_data(response)
       else
         {}
       end
@@ -205,6 +204,26 @@ module Actions
 
     private
 
+    def start_or_resume
+      if remote_task
+        if remote_task.state == 'external'
+          trigger_remote_task
+        else
+          on_resume
+        end
+      else
+        trigger_proxy_task
+      end
+      suspend
+    end
+
+    def get_proxy_data(response)
+      proxy_data = response['actions'].detect do |action|
+        action['class'] == proxy_action_name || action.fetch('input', {})['proxy_operation_name'] == proxy_operation_name
+      end
+      proxy_data.fetch('output', {})
+    end
+
     def proxy_version(proxy)
       match = proxy.statuses[:version].version['version'].match(/(\d+)\.(\d+)\.(\d+)/)
       { :major => match[1].to_i, :minor => match[2].to_i, :patch => match[3].to_i }
@@ -247,10 +266,12 @@ module Actions
     end
 
     def prepare_remote_task
+      state = input[:use_concurrency_control] ? 'external' : 'new'
       ::ForemanTasks::RemoteTask.new(:execution_plan_id => execution_plan_id,
                                      :proxy_url => input[:proxy_url],
                                      :step_id => run_step_id,
-                                     :operation => proxy_operation_name)
+                                     :operation => proxy_operation_name,
+                                     :state => state)
     end
 
     def proxy_task_id

data/app/lib/foreman_tasks/concerns/polling_action_extensions.rb

@@ -0,0 +1,12 @@
+module ForemanTasks
+  module Concerns
+    module PollingActionExtensions
+      def poll_intervals
+        multiplier = Setting[:foreman_tasks_polling_multiplier] || 1
+
+        # Prevent the intervals from going below 0.5 seconds
+        super.map { |interval| [interval * multiplier, 0.5].max }
+      end
+    end
+  end
+end

data/app/models/foreman_tasks/concerns/action_triggering.rb

@@ -158,7 +158,7 @@ module ForemanTasks
             end
           end
         end
-        return true
+        true
       ensure
         # to not execute the same execution plan twice in a row
         @execution_plan = nil

data/app/models/foreman_tasks/recurring_logic.rb

@@ -14,6 +14,7 @@ module ForemanTasks
     scoped_search :on => :max_iteration, :complete_value => false, :rename => :iteration_limit
     scoped_search :on => :iteration, :complete_value => false
     scoped_search :on => :cron_line, :complete_value => true
+    scoped_search :on => :state, :complete_value => true
 
     before_create do
       task_group.save

data/app/models/foreman_tasks/remote_task.rb

@@ -9,6 +9,7 @@ module ForemanTasks
 
     scope :triggered, -> { where(:state => 'triggered') }
     scope :pending,   -> { where(:state => 'new') }
+    scope :external,  -> { where(:state => 'external') }
 
     delegate :proxy_action_name, :to => :action
 

data/app/models/foreman_tasks/task.rb

@@ -42,6 +42,10 @@ module ForemanTasks
     scoped_search :on => :start_at, :complete_value => false
     scoped_search :on => :ended_at, :complete_value => false
     scoped_search :on => :parent_task_id, :complete_value => true
+    scoped_search :on => :duration, :complete_value => false, :ext_method => :search_by_duration, :operators => %w[> >= = <= <], :only_explicit => true
+
+    # Note: the following searches may return duplicates, this is due to
+    #       one task maybe having multiple locks (e.g. read/write) for the same resource_id
     scoped_search :relation => :locks,  :on => :resource_id, :complete_value => false, :rename => 'location_id', :ext_method => :search_by_taxonomy, :only_explicit => true
     scoped_search :relation => :locks,  :on => :resource_id, :complete_value => false, :rename => 'organization_id', :ext_method => :search_by_taxonomy, :only_explicit => true
     scoped_search :relation => :locks,  :on => :resource_type, :complete_value => true, :rename => 'resource_type', :ext_method => :search_by_generic_resource, :only_explicit => true
@@ -66,6 +70,10 @@ module ForemanTasks
            end)
     scope :for_action_types, (->(action_types) { where('foreman_tasks_tasks.label IN (?)', Array(action_types)) })
 
+    class Jail < Safemode::Jail
+      allow :started_at, :ended_at, :result, :state, :label, :main_action
+    end
+
     def input
       {}
     end

data/app/models/foreman_tasks/task/dynflow_task.rb

@@ -119,6 +119,7 @@ module ForemanTasks
         begin
           f_action = f.action(execution_plan)
           {
+            id: f_action.id,
             action_class: f.action_class.name,
             state: f.state,
             input: f_action.input.pretty_inspect,
@@ -228,7 +229,7 @@ module ForemanTasks
           # if we fail updating the data from dynflow, it usually means there is something
           # odd with the data consistency and at this point it is not possible to resume, switching
           # the task to stopped/error
-          task.update_attributes(:state => 'stopped', :result => 'error')
+          task.update(:state => 'stopped', :result => 'error')
           Foreman::Logging.exception("Failed at consistency check for task #{task.id}", e, :logger => 'foreman-tasks')
         end
       end

data/app/models/foreman_tasks/task/search.rb

@@ -4,7 +4,8 @@ module ForemanTasks
       def search_by_generic_resource(key, operator, value)
         key = 'resource_type' if key.blank?
         key_name = connection.quote_column_name(key.sub(/^.*\./, ''))
-        condition = sanitize_sql_for_conditions(["foreman_tasks_locks.#{key_name} #{operator} ?", value])
+        value = value.split(',') if operator.index(/IN/i)
+        condition = sanitize_sql_for_conditions(["foreman_tasks_locks.#{key_name} #{operator} (?)", value])
 
         { :conditions => condition, :joins => :locks }
       end
@@ -22,6 +23,15 @@ module ForemanTasks
         sql = "foreman_tasks_locks_taxonomy#{uniq_suffix}.resource_id #{operator} ? OR foreman_tasks_locks_taxonomy#{uniq_suffix}.resource_id IS NULL"
         { :conditions => sanitize_sql_for_conditions([sql, value]), :joins => joins }
       end
+
+      # Expects the time in the format "\d+ (seconds|minutes|hours|days|months|years)"
+      SUPPORTED_DURATION_FORMAT = /\A\s*(\d+(\s+\b(seconds?|minutes?|hours?|days?|months?|years?)\b)?)\b\s*\z/i.freeze
+      def search_by_duration(_key, operator, value)
+        raise "Unsupported duration '#{value}' specified for searching" unless value =~ SUPPORTED_DURATION_FORMAT
+        value = value.strip
+        { :conditions => "coalesce(ended_at, current_timestamp) - coalesce(coalesce(started_at, ended_at), current_timestamp) #{operator} ?::interval",
+          :parameter => [value] }
+      end
     end
   end
 end

data/app/models/setting/foreman_tasks.rb

@@ -2,7 +2,6 @@ class Setting::ForemanTasks < Setting
   def self.default_settings
     [
       set('foreman_tasks_sync_task_timeout', N_('Number of seconds to wait for synchronous task to finish.'), 120),
-      set('dynflow_allow_dangerous_actions', N_('Allow unlocking actions which can have dangerous consequences.'), false),
       set('dynflow_enable_console', N_('Enable the dynflow console (/foreman_tasks/dynflow) for debugging'), true),
       set('dynflow_console_require_auth', N_('Require user to be authenticated as user with admin rights when accessing dynflow console'), true),
       set('foreman_tasks_proxy_action_retry_count', N_('Number of attempts to start a task on the smart proxy before failing'), 4),
@@ -13,12 +12,18 @@ class Setting::ForemanTasks < Setting
           N_('Url pointing to the task troubleshooting documentation. '\
              'It should contain %{label} placeholder, that will be replaced with normalized task label '\
              '(restricted to only alphanumeric characters)). %{version} placeholder is also available.'),
-          nil)
+          nil),
+      set('foreman_tasks_polling_multiplier',
+          N_('Polling multiplier which is used to multiply the default polling intervals. '\
+             'This can be used to prevent polling too frequently for long running tasks.'),
+          1,
+          N_("Polling intervals multiplier"))
     ]
   end
 
   def self.load_defaults
     Setting::BLANK_ATTRS.push('foreman_tasks_troubleshooting_url')
+    Setting::NONZERO_ATTRS.push('foreman_tasks_polling_multiplier')
     super
   end
 end

data/app/services/foreman_tasks/troubleshooting_help_generator.rb

@@ -44,10 +44,6 @@ module ForemanTasks
       # rubocop:enable Rails/OutputSafety
     end
 
-    def generate_text
-      (description + link_descriptions_html).join("\n")
-    end
-
     def link_descriptions_html
       links.map do |link|
         link.description % { link: %(<a href="%{href}">%{title}</a>) % link.to_h }

data/app/services/ui_notifications/tasks/task_bulk_cancel.rb

@@ -0,0 +1,36 @@
+module UINotifications
+  module Tasks
+    class TaskBulkCancel < ::UINotifications::Base
+      def initialize(task, cancelled_length, skipped_length)
+        @subject = task
+        @cancelled_length = cancelled_length
+        @skipped_length = skipped_length
+      end
+
+      def create
+        Notification.create!(
+          initiator: initiator,
+          audience: audience,
+          subject: subject,
+          notification_blueprint: blueprint,
+          message: message,
+          notification_recipients: [NotificationRecipient.create({ :user => User.current })]
+        )
+      end
+
+      def audience
+        Notification::AUDIENCE_GLOBAL
+      end
+
+      def message
+        ('%{cancelled} Tasks were cancelled. %{skipped} Tasks were skipped. ' %
+          { cancelled: @cancelled_length,
+          skipped: @skipped_length })
+      end
+
+      def blueprint
+        @blueprint ||= NotificationBlueprint.find_by(name: 'tasks_bulk_cancel')
+      end
+    end
+  end
+end

data/app/services/ui_notifications/tasks/task_bulk_resume.rb

@@ -0,0 +1,38 @@
+module UINotifications
+  module Tasks
+    class TaskBulkResume < ::UINotifications::Base
+      def initialize(task, resumed_length, failed_length, skipped_length)
+        @subject = task
+        @resumed_length = resumed_length
+        @failed_length = failed_length
+        @skipped_length = skipped_length
+      end
+
+      def create
+        Notification.create!(
+          initiator: initiator,
+          audience: audience,
+          subject: subject,
+          notification_blueprint: blueprint,
+          message: message,
+          notification_recipients: [NotificationRecipient.create({ :user => User.current })]
+        )
+      end
+
+      def audience
+        Notification::AUDIENCE_USER
+      end
+
+      def message
+        ('%{resumed} Tasks were resumed. %{failed} Tasks failed to resume. %{skipped} Tasks were skipped. ' %
+          { resumed: @resumed_length,
+          failed: @failed_length,
+          skipped: @skipped_length })
+      end
+
+      def blueprint
+        @blueprint ||= NotificationBlueprint.find_by(name: 'tasks_bulk_resume')
+      end
+    end
+  end
+end

data/app/services/ui_notifications/tasks/task_bulk_stop.rb

@@ -0,0 +1,36 @@
+module UINotifications
+  module Tasks
+    class TaskBulkStop < ::UINotifications::Base
+      def initialize(task, stopped_length, skipped_length)
+        @subject = task
+        @stopped_length = stopped_length
+        @skipped_length = skipped_length
+      end
+
+      def create
+        Notification.create!(
+          initiator: initiator,
+          audience: audience,
+          subject: subject,
+          notification_blueprint: blueprint,
+          message: message,
+          notification_recipients: [NotificationRecipient.create(:user => User.current)]
+        )
+      end
+
+      def audience
+        Notification::AUDIENCE_GLOBAL
+      end
+
+      def message
+        ('%{stopped} Tasks were stopped. %{skipped} Tasks were already stopped. ' %
+          { stopped: @stopped_length,
+          skipped: @skipped_length })
+      end
+
+      def blueprint
+        @blueprint ||= NotificationBlueprint.find_by(name: 'tasks_bulk_stop')
+      end
+    end
+  end
+end

data/app/views/foreman_tasks/api/recurring_logics/base.json.rabl

@@ -1,3 +1,4 @@
 object @recurring_logic
 
-attributes :id, :cron_line, :end_time, :iteration, :task_group_id, :state
+attributes :id, :cron_line, :end_time, :iteration, :task_group_id, :state,
+           :max_iteration

data/app/views/foreman_tasks/api/tasks/details.json.rabl

@@ -9,10 +9,10 @@ node(:failed_steps) { @task.input_output_failed_steps }
 node(:running_steps) { @task.input_output_running_steps }
 node(:help) { troubleshooting_info_text }
 node(:has_sub_tasks) { @task.sub_tasks.any? }
-node(:allowDangerousActions) { Setting['dynflow_allow_dangerous_actions'] }
 node(:locks) do
   @task.locks.map do |lock|
     { name: lock.name, exclusive: lock.exclusive, resource_type: lock.resource_type, resource_id: lock.resource_id }
   end
 end
 node(:username_path) { username_link_task(@task.owner, @task.username) }
+node(:dynflow_enable_console) { Setting['dynflow_enable_console'] }