foreman-tasks 5.1.1 → 5.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c191bf6093506d0c5346c71a026908b3c5c6b10fa9ceb27e5fdfbfa93a72c2c6
-  data.tar.gz: 0fc1f15e955f6d13469aa28883db8447f8e3770d4751206faaec5c224d3ffcbc
+  metadata.gz: 882587333f9ebd555b6bd0ca6adf6c9e75789fce2e84cbbc2e3af0943cdf0051
+  data.tar.gz: 1db069d66971fed8af95856a2d582b1320c02c48fddec68f9f9a1061abc6965c
 SHA512:
-  metadata.gz: d57a47e629be8d4bcfaba9bc853f7ec0853ea8f968884d4b589e98d74027a73bcef5ff45ff53f3e01f8794a28a01729bb4c811b004430296304a86b7936d4bd4
-  data.tar.gz: e4e3b07b3e4f84e233534c40adadaa8c4032c33e5bd5a8623a8d54bcece9de022c1c4e2fd81ca0f3ed1c9e512df23dc14b5d2fe8be349de03df1a5b4a41c7235
+  metadata.gz: b204e43fe719216b44377fa0eb69654a404dfc7d53fbd5ed803efca3f5dd649d2dc901abd1b29b4048c1f99f7a37bd1b94c5c349ae9844e08ae95bd86a942b35
+  data.tar.gz: 90c69b77188a55d8d993a6e098945448dce1ff720697def8ea1914ba2c03fe2ed7efec30b4a7e33224afa9b32d3b9f1c8eb4fd37cdee37566321e69d67d78b1a

data/.rubocop.yml

@@ -46,10 +46,6 @@ Style/SymbolArray:
 Style/FormatString:
   Enabled: false
 
-Rails/Present:
-  Exclude:
-    - lib/foreman_tasks_core/**/*
-
 Rails/FilePath:
   Enabled: false
 

data/.rubocop_todo.yml

@@ -11,7 +11,6 @@
 # Include: **/*.gemspec
 Gemspec/RequiredRubyVersion:
   Exclude:
-    - 'foreman-tasks-core.gemspec'
     - 'foreman-tasks.gemspec'
 
 # Offense count: 1
@@ -37,7 +36,6 @@ Naming/MemoizedInstanceVariableName:
   Exclude:
     - 'app/controllers/foreman_tasks/recurring_logics_controller.rb'
     - 'app/lib/actions/recurring_action.rb'
-    - 'lib/foreman_tasks_core/otp_manager.rb'
 
 # Offense count: 11
 # Configuration parameters: MinNameLength, AllowNamesEndingInNumbers, AllowedNames, ForbiddenNames.

data/README.md

@@ -6,7 +6,8 @@ happening/happened in your Foreman instance. A framework for asynchronous tasks
 
 * Website: [TheForeman.org](http://theforeman.org)
 * ServerFault tag: [Foreman](http://serverfault.com/questions/tagged/foreman)
-* Issues: [foreman-tasks Redmine](http://projects.theforeman.org/projects/foreman-tasks)
+* Issues: [Foreman-tasks Redmine](http://projects.theforeman.org/projects/foreman-tasks)
+* Manual: [Foreman-tasks Manual](https://www.theforeman.org/plugins/foreman_tasks/0.8/index.html)
 * Wiki: [Foreman wiki](http://projects.theforeman.org/projects/foreman/wiki/About)
 * Community and support: #theforeman for general support, #theforeman-dev for development chat in [Freenode](irc.freenode.net)
 * Mailing lists:
@@ -25,6 +26,7 @@ happening/happened in your Foreman instance. A framework for asynchronous tasks
 | >= 1.22         | ~> 0.15.0      |
 | >= 2.0          | ~> 1.0.0       |
 | >= 2.1          | ~> 2.0.0       |
+| >= 2.6          | ~> 5.2.0       |
 
 Installation
 ------------
@@ -154,9 +156,9 @@ rails root directory. See `-h` for more details and options
 Tasks cleanup
 -------------
 
-Although, the history of tasks has an auditing value, some kinds of
-tasks can grow up in number quite soon. Therefore there is a mechanism
-how to clean the tasks, using a rake command. When running without
+Although the history of tasks has an auditing value, some kinds of
+tasks can rapidly increase. Therefore, there is a mechanism for
+cleaning up the tasks using a rake command. When running without
 any arguments, the tasks are deleted based on the default parameters
 defined in the code.
 
@@ -179,7 +181,7 @@ override the default configuration inside the configuration
 ```
 :foreman-tasks:
   :cleanup:
-# the period after witch to delete all the tasks (by default all tasks are not being deleted after some period)
+# the period after which to delete all the tasks (by default, all tasks are not deleted after some period)
     :after: 365d
 # per action settings to override the default defined in the actions (cleanup_after method)
     :actions:
@@ -194,7 +196,7 @@ to specify the search criteria for the cleanup manually:
 * `TASK_SEARCH`: scoped search filter (example: 'label =
   "Actions::Foreman::Host::ImportFacts"')
 * `AFTER`: delete tasks created after `AFTER` period. Expected format
-  is a number followed by the time unit (`s`, `h`, `m`, `y`), such as
+  is a number followed by the time unit (`s`, `h`, `d`, `m`, `y`), such as
   `10d` for 10 days (applicable only when the `TASK_SEARCH` option is
   specified)
 * `STATES`: comma separated list of task states to touch with the

data/app/controllers/foreman_tasks/tasks_controller.rb

@@ -4,6 +4,8 @@ module ForemanTasks
     include Foreman::Controller::CsvResponder
     include ForemanTasks::FindTasksCommon
 
+    before_action :find_dynflow_task, only: [:unlock, :force_unlock, :cancel, :cancel_step, :resume]
+
     def show
       @task = resource_base.find(params[:id])
       render :layout => !request.xhr?
@@ -31,8 +33,7 @@ module ForemanTasks
     end
 
     def cancel_step
-      task = find_dynflow_task
-      result = ForemanTasks.dynflow.world.event(task.external_id, params[:step_id].to_i, ::Dynflow::Action::Cancellable::Cancel).wait
+      result = ForemanTasks.dynflow.world.event(@dynflow_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
@@ -41,8 +42,7 @@ module ForemanTasks
     end
 
     def cancel
-      task = find_dynflow_task
-      if task.cancel
+      if @dynflow_task.cancel
         render json: { statusText: 'OK' }
       else
         render json: {}, status: :bad_request
@@ -50,19 +50,17 @@ module ForemanTasks
     end
 
     def abort
-      task = find_dynflow_task
-      if task.abort
+      if @dynflow_task.abort
         flash[:info] = _('Trying to abort the task')
       else
         flash[:warning] = _('The task cannot be aborted at the moment.')
       end
-      redirect_back(:fallback_location => foreman_tasks_task_path(task))
+      redirect_back(:fallback_location => foreman_tasks_task_path(@dynflow_task))
     end
 
     def resume
-      task = find_dynflow_task
-      if task.resumable?
-        ForemanTasks.dynflow.world.execute(task.execution_plan.id)
+      if @dynflow_task.resumable?
+        ForemanTasks.dynflow.world.execute(@dynflow_task.execution_plan.id)
         render json: { statusText: 'OK' }
       else
         render json: {}, status: :bad_request
@@ -70,10 +68,8 @@ module ForemanTasks
     end
 
     def unlock
-      task = find_dynflow_task
-      if task.paused?
-        task.state = :stopped
-        task.save!
+      if @dynflow_task.paused?
+        unlock_task(@dynflow_task)
         render json: { statusText: 'OK' }
       else
         render json: {}, status: :bad_request
@@ -81,9 +77,7 @@ module ForemanTasks
     end
 
     def force_unlock
-      task       = find_dynflow_task
-      task.state = :stopped
-      task.save!
+      unlock_task(@dynflow_task)
       render json: { statusText: 'OK' }
     end
 
@@ -98,6 +92,12 @@ module ForemanTasks
 
     private
 
+    def unlock_task(task)
+      task.state = :stopped
+      task.locks.destroy_all
+      task.save!
+    end
+
     def respond_with_tasks(scope)
       @tasks = filter(scope, paginate: false).with_duration
       csv_response(@tasks, [:id, :action, :state, :result, 'started_at.in_time_zone', 'ended_at.in_time_zone', :duration, :username], ['Id', 'Action', 'State', 'Result', 'Started At', 'Ended At', 'Duration', 'User'])
@@ -123,7 +123,7 @@ module ForemanTasks
     end
 
     def find_dynflow_task
-      resource_scope.where(:type => 'ForemanTasks::Task::DynflowTask').find(params[:id])
+      @dynflow_task = resource_scope.where(:type => 'ForemanTasks::Task::DynflowTask').find(params[:id])
     end
 
     def filter(scope, paginate: true)

data/app/graphql/mutations/recurring_logics/cancel.rb

@@ -0,0 +1,27 @@
+module Mutations
+  module RecurringLogics
+    class Cancel < BaseMutation
+      graphql_name 'CancelRecurringLogic'
+      description 'Cancels recurring logic and all its active tasks'
+      resource_class ::ForemanTasks::RecurringLogic
+
+      argument :id, ID, required: true
+
+      field :errors, [Types::AttributeError], null: false
+      field :recurring_logic, Types::RecurringLogic, null: true
+
+      def resolve(id:)
+        recurring_logic = load_object_by(id: id)
+        authorize!(recurring_logic, :edit)
+        task_errors = []
+        begin
+          recurring_logic.cancel
+        rescue => e
+          task_errors = [{ path: ['tasks'], message: "There has been an error when canceling one of the tasks: #{e}" }]
+        end
+        errors = recurring_logic.errors.any? ? map_errors_to_path(recurring_logic) : []
+        { recurring_logic: recurring_logic, errors: (errors + task_errors) }
+      end
+    end
+  end
+end

data/app/graphql/types/recurring_logic.rb

@@ -3,6 +3,8 @@ module Types
     description 'A Recurring Logic'
     model_class ::ForemanTasks::RecurringLogic
 
+    include ::Types::Concerns::MetaField
+
     global_id_field :id
     field :cron_line, String
     field :end_time, GraphQL::Types::ISO8601DateTime

data/app/lib/actions/proxy_action.rb

@@ -29,10 +29,10 @@ module Actions
       default_connection_options.each do |key, value|
         options[:connection_options][key] = value unless options[:connection_options].key?(key)
       end
-      plan_self(options.merge(:proxy_url => proxy.url, :proxy_action_name => klass.to_s, :proxy_version => proxy_version(proxy)))
+      plan_self(options.merge(:proxy_url => proxy.url, :proxy_action_name => klass.to_s))
       # Just saving the RemoteTask is enough when using batch triggering
       # It will be picked up by the ProxyBatchTriggering middleware
-      if input[:use_batch_triggering] && with_batch_triggering?(input[:proxy_version])
+      if input[:use_batch_triggering] && input.dig(:connection_options, :proxy_batch_triggering)
         prepare_remote_task.save!
       end
     end
@@ -193,11 +193,6 @@ module Actions
         :proxy_batch_triggering => Setting['foreman_tasks_proxy_batch_trigger'] || false }
     end
 
-    def with_batch_triggering?(proxy_version)
-      ((proxy_version[:major] == 1 && proxy_version[:minor] > 20) || proxy_version[:major] > 1) &&
-        input.fetch(:connection_options, {}).fetch(:proxy_batch_triggering, false)
-    end
-
     def clean_remote_task(*_args)
       remote_task.destroy! if remote_task
     end
@@ -222,11 +217,6 @@ module Actions
                          .try(: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 }
-    end
-
     def failed_proxy_tasks
       metadata[:failed_proxy_tasks] ||= []
     end

data/app/lib/actions/trigger_proxy_batch.rb

@@ -40,7 +40,8 @@ module Actions
       end
       output[:planned_count] += batch.size
     rescue => e
-      action_logger.warn "Could not trigger task on the smart proxy: #{e.message}"
+      action_logger.warn "Could not trigger task on the smart proxy"
+      action_logger.warn e
       batch.each { |remote_task| remote_task.update_from_batch_trigger({}) }
       output[:failed_count] += batch.size
     end

data/app/models/foreman_tasks/remote_task.rb

@@ -16,9 +16,10 @@ module ForemanTasks
     # Triggers a task on the proxy "the old way"
     def trigger(proxy_action_name, input)
       response = begin
-                   proxy.trigger_task(proxy_action_name, input).merge('result' => 'success')
+                   proxy.launch_tasks('single', :action_class => proxy_action_name, :action_input => input)
                  rescue RestClient::Exception => e
-                   logger.warn "Could not trigger task on the smart proxy: #{e.message}"
+                   logger.warn "Could not trigger task on the smart proxy"
+                   logger.warn e
                    {}
                  end
       update_from_batch_trigger(response)
@@ -26,33 +27,17 @@ module ForemanTasks
     end
 
     def self.batch_trigger(operation, remote_tasks)
-      remote_tasks.group_by(&:proxy_url).values.map do |group|
+      remote_tasks.group_by(&:proxy_url).each_value do |group|
         input_hash = group.reduce({}) do |acc, remote_task|
           acc.merge(remote_task.execution_plan_id => { :action_input => remote_task.proxy_input,
                                                        :action_class => remote_task.proxy_action_name })
         end
-        safe_batch_trigger(operation, group, input_hash)
+        results = group.first.proxy.launch_tasks(operation, input_hash)
+        group.each { |remote_task| remote_task.update_from_batch_trigger results[remote_task.execution_plan_id] }
       end
       remote_tasks
     end
 
-    # Attempt to trigger the tasks using the new API and fall back to the old one
-    # if it fails
-    def self.safe_batch_trigger(operation, remote_tasks, input_hash)
-      results = remote_tasks.first.proxy.launch_tasks(operation, input_hash)
-      remote_tasks.each { |remote_task| remote_task.update_from_batch_trigger results[remote_task.execution_plan_id] }
-    rescue RestClient::NotFound
-      fallback_batch_trigger remote_tasks, input_hash
-    end
-
-    # Trigger the tasks one-by-one using the old API
-    def self.fallback_batch_trigger(remote_tasks, input_hash)
-      remote_tasks.each do |remote_task|
-        task_data = input_hash[remote_task.execution_plan_id]
-        remote_task.trigger(task_data[:action_class], task_data[:action_input])
-      end
-    end
-
     def update_from_batch_trigger(data)
       if data['result'] == 'success'
         self.remote_task_id = data['task_id']

data/app/views/foreman_tasks/task_groups/recurring_logic_task_groups/_recurring_logic_task_group.html.erb

@@ -40,4 +40,8 @@
     <th><%= N_("Purpose") %></th>
     <td><%= recurring_logic.purpose %></td>
   </tr>
+  <tr>
+    <th><%= N_("Task count") %></th>
+    <td><%= link_to(task_group.tasks.count, foreman_tasks_tasks_url(:search => "task_group.id = #{task_group.id}")) %></td>
+  </tr>
 </table>

data/extra/foreman-tasks-cleanup.sh

@@ -21,6 +21,21 @@ function build_rake() {
     echo
 }
 
+function incorrect_usage() {
+    echo "$1" >&2
+    echo
+    usage
+
+    exit 1
+}
+
+function validate_options!() {
+    if [ -z "$TASK_SEARCH" ]; then
+        [ -n "$AFTER" ] && incorrect_usage "Error: -a|--after cannot be used without -s|--search"
+        [ -n "$STATES" ] && incorrect_usage "Error: -S|--states cannot be used without -s|--search"
+    fi
+}
+
 function usage() {
         cat << EOF
 Usage: $PROGNAME [script_options...] [options...]
@@ -43,8 +58,8 @@ EOF
         echo Cleanup options:
         cat <<EOF | column -s\& -t
 -B|--batch-size BATCH_SIZE & process tasks in batches of BATCH_SIZE, 1000 by default
--S|--states STATES & operate on tasks in STATES, comma separated list of states, set to all to operate on tasks in any state
--a|--after AGE & operate on tasks older than AGE. Expected format is a number followed by the time unit (s,h,m,y), such as '10d' for 10 days
+-S|--states STATES & operate on tasks in STATES, comma separated list of states, set to all to operate on tasks in any state. Has to be used together with -s|--search
+-a|--after AGE & operate on tasks older than AGE. Expected format is a number followed by the time unit (s,h,m,y), such as '10d' for 10 days. Has to be used together with -s|--search
 -b|--backup & backup deleted tasks
 -n|--noop & do a dry run, print what would be done
 -s|--search QUERY & use QUERY in scoped search format to match tasks to delete
@@ -119,6 +134,8 @@ while true; do
     shift
 done
 
+validate_options!
+
 if [ "$EXECUTE" -eq 1 ]; then
     build_rake | sh
 else

data/extra/foreman-tasks-export.sh

@@ -14,7 +14,7 @@ function die() {
 function build_rake() {
     echo -n "$RAKE_COMMAND "
     echo -n 'foreman_tasks:export_tasks '
-    for env in TASK_SEARCH TASK_FILE TASK_FORMAT TASK_DAYS; do
+    for env in TASK_SEARCH TASK_FILE TASK_FORMAT TASK_DAYS SKIP_FAILED; do
         local value="${!env}"
         [ -n "${value}" ] && echo -n "${env}=$(printf '%q' "$value") "
     done
@@ -46,11 +46,12 @@ EOF
 -f|--format FORMAT & export tasks in FORMAT, one of html, html-dir, csv
 -o|--output FILE & export tasks into FILE, a random file will be used if not provided
 -s|--search QUERY & use QUERY in scoped search format to match tasks to export
+-S|--skip-failed & skip tasks that fail to export
 EOF
 }
 
-SHORTOPTS="d:Ehs:o:f:"
-LONGOPTS="days:,execute,help,search:,output:,format:"
+SHORTOPTS="d:Ehs:o:f:S"
+LONGOPTS="days:,execute,help,search:,output:,format:,skip-failed"
 
 ARGS=$(getopt -s bash \
               --options $SHORTOPTS \
@@ -96,6 +97,9 @@ while true; do
         -E|--execute)
             EXECUTE=1
             ;;
+        -S|--skip-failed)
+            SKIP_FAILED=1
+            ;;
         \?)
             die 1 "Invalid option: -$OPTARG"
             ;;

data/foreman-tasks.gemspec

@@ -20,9 +20,7 @@ same resource. It also optionally provides Dynflow infrastructure for using it f
   DESC
 
   s.files = `git ls-files`.split("\n").reject do |file|
-    file.end_with?("test.rake") ||
-      file.start_with?('lib/foreman_tasks_core') ||
-      file == 'foreman-tasks-core.gemspec'
+    file.end_with?("test.rake")
   end
 
   s.test_files = `git ls-files test`.split("\n")

data/lib/foreman_tasks/engine.rb

@@ -70,6 +70,8 @@ module ForemanTasks
         register_graphql_query_field :recurring_logic, '::Types::RecurringLogic', :record_field
         register_graphql_query_field :recurring_logics, '::Types::RecurringLogic', :collection_field
 
+        register_graphql_mutation_field :cancel_recurring_logic, ::Mutations::RecurringLogics::Cancel
+
         logger :dynflow, :enabled => true
         logger :action, :enabled => true
 

data/lib/foreman_tasks/tasks/export_tasks.rake

@@ -14,6 +14,7 @@ namespace :foreman_tasks do
       * TASK_FILE       : file to export to
       * TASK_FORMAT     : format to use for the export (either html, html-dir or csv)
       * TASK_DAYS       : number of days to go back
+      * SKIP_FAILED     : skip tasks that fail to export (true or false[default])
 
     If TASK_SEARCH is not defined, it defaults to all tasks in the past 7 days and
     all unsuccessful tasks in the past 60 days. The default TASK_FORMAT is html
@@ -240,30 +241,42 @@ namespace :foreman_tasks do
       end
     end
 
-    def csv_export(export_filename, tasks)
+    def csv_export(export_filename, id_scope, task_scope)
       CSV.open(export_filename, 'wb') do |csv|
         csv << %w[id state type label result parent_task_id started_at ended_at duration]
-        tasks.find_each do |task|
-          csv << [task.id, task.state, task.type, task.label, task.result,
-                  task.parent_task_id, task.started_at, task.ended_at, task.duration]
+        id_scope.pluck(:id).each_slice(1000).each do |ids|
+          task_scope.where(id: ids).each do |task|
+            with_error_handling(task) do
+              csv << [task.id, task.state, task.type, task.label, task.result,
+                      task.parent_task_id, task.started_at, task.ended_at, task.duration]
+            end
+          end
         end
       end
     end
 
-    def html_export(workdir, tasks)
+    def html_export(workdir, id_scope, task_scope)
       PageHelper.copy_assets(workdir)
 
+      ids = id_scope.pluck(:id)
       renderer = TaskRender.new
-      total = tasks.count(:all)
+      count = 0
+      total = ids.count
       index = File.open(File.join(workdir, 'index.html'), 'w')
 
       File.open(File.join(workdir, 'index.html'), 'w') do |index|
         PageHelper.pagify(index) do |io|
           PageHelper.generate_with_index(io) do |index|
-            tasks.find_each.each_with_index do |task, count|
-              File.open(File.join(workdir, "#{task.id}.html"), 'w') { |file| PageHelper.pagify(file, renderer.render_task(task)) }
-              PageHelper.generate_index_entry(index, task)
-              puts "#{count + 1}/#{total}"
+            ids.each_slice(1000).each do |ids|
+              task_scope.where(id: ids).each do |task|
+                content = with_error_handling(task) { renderer.render_task(task) }
+                if content
+                  File.open(File.join(workdir, "#{task.id}.html"), 'w') { |file| PageHelper.pagify(file, content) }
+                  with_error_handling(task, _('task index entry')) { PageHelper.generate_index_entry(index, task) }
+                end
+                count += 1
+                puts "#{count}/#{total}"
+              end
             end
           end
         end
@@ -282,6 +295,20 @@ namespace :foreman_tasks do
       end
     end
 
+    def with_error_handling(task, what = _('task'))
+      yield
+    rescue StandardError => e
+      resolution = SKIP_ERRORS ? _(', skipping') : ''
+      puts _("WARNING: %{what} failed to export%{resolution}. Additional task details below.") % { :what => what, :resolution => resolution }
+      puts task.inspect
+      unless SKIP_ERRORS
+        puts _("Re-run with SKIP_FAILED=true if you want to simply skip any tasks that fail to export.")
+        raise e
+      end
+    end
+
+    SKIP_ERRORS = ['true', '1', 'y', 'yes'].include? (ENV['SKIP_FAILED'] || '').downcase
+
     filter = if ENV['TASK_SEARCH'].nil? && ENV['TASK_DAYS'].nil?
                "started_at > \"#{7.days.ago.to_s(:db)}\" || " \
                  "(result != success && started_at > \"#{60.days.ago.to_s(:db)})\""
@@ -297,21 +324,22 @@ namespace :foreman_tasks do
     format = ENV['TASK_FORMAT'] || 'html'
     export_filename = ENV['TASK_FILE'] || generate_filename(format)
 
-    tasks = ForemanTasks::Task.search_for(filter).order(:started_at => :desc).with_duration.distinct
+    task_scope = ForemanTasks::Task.search_for(filter).with_duration.order(:started_at => :desc)
+    id_scope = task_scope.group(:id, :started_at)
 
     puts _("Exporting all tasks matching filter #{filter}")
-    puts _("Gathering #{tasks.count(:all)} tasks.")
+    puts _("Gathering #{id_scope.count(:all).count} tasks.")
     case format
     when 'html'
       Dir.mktmpdir('task-export') do |tmp_dir|
-        html_export(tmp_dir, tasks)
+        html_export(tmp_dir, id_scope, task_scope)
         system("tar", "czf", export_filename, tmp_dir)
       end
     when 'html-dir'
       FileUtils.mkdir_p(export_filename)
-      html_export(export_filename, tasks)
+      html_export(export_filename, id_scope, task_scope)
     when 'csv'
-      csv_export(export_filename, tasks)
+      csv_export(export_filename, id_scope, task_scope)
     else
       raise "Unkonwn export format '#{format}'"
     end

data/lib/foreman_tasks/version.rb

@@ -1,3 +1,3 @@
 module ForemanTasks
-  VERSION = '5.1.1'.freeze
+  VERSION = '5.2.2'.freeze
 end

data/package.json

@@ -23,20 +23,18 @@
     "url": "http://projects.theforeman.org/projects/foreman-tasks/issues"
   },
   "peerDependencies": {
-    "@theforeman/vendor": ">= 6.0.0"
+    "@theforeman/vendor": "^8.15.0"
   },
   "dependencies": {
-    "c3": "^0.4.11",
-    "humanize-duration": "^3.20.1",
-    "react-intl": "^2.8.0"
+    "c3": "^0.4.11"
   },
   "devDependencies": {
     "@babel/core": "^7.7.0",
-    "@theforeman/builder": "^6.0.0",
-    "@theforeman/eslint-plugin-foreman": "6.0.0",
-    "@theforeman/stories": "^6.0.0",
-    "@theforeman/test": "^6.0.0",
-    "@theforeman/vendor-dev": "^6.0.0",
+    "@theforeman/builder": "^8.15.0",
+    "@theforeman/eslint-plugin-foreman": "^8.15.0",
+    "@theforeman/stories": "^8.15.0",
+    "@theforeman/test": "^8.15.0",
+    "@theforeman/vendor-dev": "^8.15.0",
     "babel-eslint": "^10.0.3",
     "eslint": "^6.7.2",
     "jed": "^1.1.1",

data/test/controllers/api/tasks_controller_test.rb

@@ -192,7 +192,7 @@ module ForemanTasks
           _(task.state).must_equal 'running'
           _(task.result).must_equal 'pending'
 
-          callback = Support::DummyProxyAction.proxy.log[:trigger_task].first[1][:callback]
+          callback = Support::DummyProxyAction.proxy.log[:trigger_task].first[1][:action_input][:callback]
           post :callback, params: { 'callback' => callback, 'data' => { 'result' => 'success' } }
           triggered.finished.wait(5)
 

data/test/factories/recurring_logic_factory.rb

@@ -1,8 +1,14 @@
 FactoryBot.define do
   factory :recurring_logic, :class => ForemanTasks::RecurringLogic do
     cron_line { '* * * * *' }
-    after(:build) { |logic| logic.task_group = build(:recurring_logic_task_group) }
+    association :task_group
   end
 
+  factory :task_group, :class => ::ForemanTasks::TaskGroup do
+    type { "ForemanTasks::TaskGroups::RecurringLogicTaskGroup" }
+  end
   factory :recurring_logic_task_group, :class => ::ForemanTasks::TaskGroups::RecurringLogicTaskGroup
+  factory :task_group_member, :class => ::ForemanTasks::TaskGroupMember do
+    association :task_group, :task
+  end
 end

data/test/graphql/mutations/recurring_logics/cancel_mutation_test.rb

@@ -0,0 +1,66 @@
+require 'foreman_tasks_test_helper'
+
+module Mutations
+  module RecurringLogics
+    class CancelMutationTest < ActiveSupport::TestCase
+      setup do
+        @task = FactoryBot.create(:dynflow_task, state: 'pending')
+        @task_group = FactoryBot.create(:recurring_logic_task_group)
+        @task_group_member = FactoryBot.create(:task_group_member, task: @task, task_group: @task_group)
+        @recurring_logic = FactoryBot.create(:recurring_logic, task_group: @task_group)
+        @id = Foreman::GlobalId.for(@recurring_logic)
+        @variables = { id: @id }
+        @query =
+          <<-GRAPHQL
+          mutation CancelRecurringLogic($id:ID!) {
+            cancelRecurringLogic(input: { id: $id }){
+              recurringLogic {
+                id
+                state
+                cronLine
+              }
+              errors {
+                message
+                path
+              }
+            }
+          }
+          GRAPHQL
+      end
+
+      context 'as admin' do
+        setup do
+          @context = { current_user: FactoryBot.create(:user, :admin) }
+        end
+
+        test 'should cancel recurring logic' do
+          assert_not_equal 'cancelled', @recurring_logic.state
+          result = ForemanGraphqlSchema.execute(@query, variables: @variables, context: @context)
+          assert_empty result['errors']
+          assert_empty result['data']['cancelRecurringLogic']['errors']
+          assert_equal 'cancelled', result['data']['cancelRecurringLogic']['recurringLogic']['state']
+          @recurring_logic.reload
+          assert_equal 'cancelled', @recurring_logic.state
+        end
+
+        test 'should handle errors on execution plan load failure' do
+          invalid_plan = ::Dynflow::ExecutionPlan::InvalidPlan.new(StandardError.new('This is a failure'), 'xyz', 'test-label', 'invalid')
+          ::Dynflow::Persistence.any_instance.stubs(:load_execution_plan).returns(invalid_plan)
+          result = ForemanGraphqlSchema.execute(@query, variables: @variables, context: @context)
+          assert_equal "There has been an error when canceling one of the tasks: This is a failure", result['data']['cancelRecurringLogic']['errors'].first['message']
+        end
+      end
+
+      context 'as viewer' do
+        setup do
+          @context = { current_user: setup_user('view', 'recurring_logics') }
+        end
+
+        test 'should not allow to cancel recurring logic' do
+          result = ForemanGraphqlSchema.execute(@query, variables: @variables, context: @context)
+          assert_includes result['errors'].first['message'], 'Unauthorized.'
+        end
+      end
+    end
+  end
+end

data/test/support/dummy_proxy_action.rb

@@ -36,6 +36,12 @@ module Support
       def statuses
         { version: DummyProxyVersion.new('1.21.0') }
       end
+
+      def launch_tasks(operation, args = {})
+        @log[:trigger_task] << [operation, args]
+        @task_triggered.fulfill(true)
+        { 'task_id' => @uuid, 'result' => 'success' }
+      end
     end
 
     class ProxySelector < ::ForemanTasks::ProxySelector

data/test/unit/actions/proxy_action_test.rb

@@ -11,12 +11,11 @@ module ForemanTasks
       let(:batch_triggering) { false }
 
       before do
-        Support::DummyProxyAction.any_instance.stubs(:with_batch_triggering?).returns(batch_triggering)
         Support::DummyProxyAction.reset
         RemoteTask.any_instance.stubs(:proxy).returns(Support::DummyProxyAction.proxy)
         Setting.stubs(:[]).with('foreman_tasks_proxy_action_retry_interval')
         Setting.stubs(:[]).with('foreman_tasks_proxy_action_retry_count')
-        Setting.stubs(:[]).with('foreman_tasks_proxy_batch_trigger')
+        Setting.stubs(:[]).with('foreman_tasks_proxy_batch_trigger').returns(batch_triggering)
         @action = create_and_plan_action(Support::DummyProxyAction,
                                          Support::DummyProxyAction.proxy,
                                          'Proxy::DummyAction',
@@ -29,17 +28,18 @@ module ForemanTasks
       describe 'first run' do
         it 'triggers the corresponding action on the proxy' do
           proxy_call = Support::DummyProxyAction.proxy.log[:trigger_task].first
-          expected_call = ['Proxy::DummyAction',
-                           { 'foo' => 'bar',
-                             'secrets' => secrets,
-                             'connection_options' =>
+          expected_call = ['single',
+                           { :action_class => 'Proxy::DummyAction',
+                             :action_input =>
+                             { 'foo' => 'bar',
+                               'secrets' => secrets,
+                               'connection_options' =>
                                { 'retry_interval' => 15, 'retry_count' => 4,
                                  'proxy_batch_triggering' => batch_triggering },
-                             'use_batch_triggering' => batch_triggering,
-                             'proxy_url' => 'proxy.example.com',
-                             'proxy_action_name' => 'Proxy::DummyAction',
-                             "proxy_version" => { "major" => 1, "minor" => 21, "patch" => 0 },
-                             'callback' => { 'task_id' => Support::DummyProxyAction.proxy.uuid, 'step_id' => @action.run_step_id } }]
+                               'use_batch_triggering' => batch_triggering,
+                               'proxy_url' => 'proxy.example.com',
+                               'proxy_action_name' => 'Proxy::DummyAction',
+                               'callback' => { 'task_id' => Support::DummyProxyAction.proxy.uuid, 'step_id' => @action.run_step_id } } }]
           _(proxy_call).must_equal(expected_call)
         end
 

data/test/unit/remote_task_test.rb

@@ -29,12 +29,30 @@ module ForemanTasks
         end
       end
 
-      it 'fallbacks to old way when batch trigger gets 404' do
+      it 'honors the batches with multiple proxies' do
+        remote_task = remote_tasks.last
+        remote_task.proxy_url = 'something else'
+
+        results = remote_tasks.reduce({}) do |acc, cur|
+          acc.merge(cur.execution_plan_id.to_s => { 'task_id' => cur.id + 5, 'result' => 'success' })
+        end
+        other_results = { remote_task.execution_plan_id => results.delete(remote_task.execution_plan_id) }
+
         fake_proxy = mock
-        fake_proxy.expects(:launch_tasks).raises(RestClient::NotFound.new)
+        fake_proxy.expects(:launch_tasks).returns(results)
+
+        another_fake_proxy = mock
+        another_fake_proxy.expects(:launch_tasks).returns(other_results)
+
         remote_tasks.first.expects(:proxy).returns(fake_proxy)
-        remote_tasks.each { |task| task.expects(:trigger) }
+        remote_tasks.last.expects(:proxy).returns(another_fake_proxy)
+
         RemoteTask.batch_trigger('a_operation', remote_tasks)
+        remote_tasks.each do |remote_task|
+          remote_task.reload
+          _(remote_task.state).must_equal 'triggered'
+          _(remote_task.remote_task_id).must_equal((remote_task.id + 5).to_s)
+        end
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foreman-tasks
 version: !ruby/object:Gem::Version
-  version: 5.1.1
+  version: 5.2.2
 platform: ruby
 authors:
 - Ivan Nečas
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-21 00:00:00.000000000 Z
+date: 1980-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dynflow
@@ -133,6 +133,7 @@ files:
 - app/controllers/foreman_tasks/react_controller.rb
 - app/controllers/foreman_tasks/recurring_logics_controller.rb
 - app/controllers/foreman_tasks/tasks_controller.rb
+- app/graphql/mutations/recurring_logics/cancel.rb
 - app/graphql/types/recurring_logic.rb
 - app/graphql/types/task.rb
 - app/graphql/types/triggering.rb
@@ -304,6 +305,7 @@ files:
 - test/factories/task_factory.rb
 - test/factories/triggering_factory.rb
 - test/foreman_tasks_test_helper.rb
+- test/graphql/mutations/recurring_logics/cancel_mutation_test.rb
 - test/graphql/queries/recurring_logic_test.rb
 - test/graphql/queries/recurring_logics_query_test.rb
 - test/graphql/queries/task_query_test.rb
@@ -605,7 +607,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.2.26
 signing_key:
 specification_version: 4
 summary: Foreman plugin for showing tasks information for resources and users
@@ -618,6 +620,7 @@ test_files:
 - test/factories/task_factory.rb
 - test/factories/triggering_factory.rb
 - test/foreman_tasks_test_helper.rb
+- test/graphql/mutations/recurring_logics/cancel_mutation_test.rb
 - test/graphql/queries/recurring_logic_test.rb
 - test/graphql/queries/recurring_logics_query_test.rb
 - test/graphql/queries/task_query_test.rb