foreman-tasks 4.1.4 → 5.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3152af7ac771946d9090d5a1b867c6843ff6657ab2434c4daba986c60c83579e
-  data.tar.gz: 4d3cd7b0d58af7f59a5d7745e1b75444dc43066089c60854344c49dc1d58ed43
+  metadata.gz: c191bf6093506d0c5346c71a026908b3c5c6b10fa9ceb27e5fdfbfa93a72c2c6
+  data.tar.gz: 0fc1f15e955f6d13469aa28883db8447f8e3770d4751206faaec5c224d3ffcbc
 SHA512:
-  metadata.gz: 528a33eb7ef2128cdc476411c705762b3b63ba22d8a3ff3ca70755a42247c5a538494b1b248eee547a2a7ffa49821612f05f0f53e42ef026a70e107e064246f1
-  data.tar.gz: 85033e3dd3c84eb6aa8dd99e837ad024acd42639c1351f518883ef431b9b95c9ddb833f11e6708bda488113c1a33faf7959ac4a11bbeb4ea16e29a32c955e670
+  metadata.gz: d57a47e629be8d4bcfaba9bc853f7ec0853ea8f968884d4b589e98d74027a73bcef5ff45ff53f3e01f8794a28a01729bb4c811b004430296304a86b7936d4bd4
+  data.tar.gz: e4e3b07b3e4f84e233534c40adadaa8c4032c33e5bd5a8623a8d54bcece9de022c1c4e2fd81ca0f3ed1c9e512df23dc14b5d2fe8be349de03df1a5b4a41c7235

data/.github/workflows/ruby_tests.yml

@@ -72,5 +72,4 @@ jobs:
       - name: Run plugin tests
         run: |
           bundle exec rake test:foreman_tasks
-          bundle exec rake test:foreman_tasks_core
           bundle exec rake test TEST="test/unit/foreman/access_permissions_test.rb"

data/app/assets/javascripts/foreman_tasks/trigger_form.js

@@ -8,6 +8,7 @@ function trigger_form_selector_binds(form_name, form_object_name) {
       form.find('fieldset.trigger_mode_form#trigger_mode_' + type).hide();
     });
     form.find('fieldset.trigger_mode_form#trigger_mode_' + $(this).val()).show();
+    disable_hidden_start_field($(this).val(), form)
   });
 
   input_type_selector.on('change', function () {
@@ -39,3 +40,9 @@ function trigger_form_selector_binds(form_name, form_object_name) {
     };
   });
 };
+
+function disable_hidden_start_field(clicked, form) {
+  ["future", "recurring"].forEach(function(type) {
+    form.find('.trigger_mode_form#trigger_mode_' + type + ' #triggering_start_at_raw').prop('disabled', type !== clicked);
+  });
+};

data/app/controllers/foreman_tasks/api/tasks_controller.rb

@@ -260,7 +260,7 @@ module ForemanTasks
             raise BadRequest,
                   _('Resource search_params requires resource_type and resource_id to be specified')
           end
-          scope.joins(:locks).where(foreman_tasks_locks:
+          scope.joins(:links).where(foreman_tasks_links:
                                         { resource_type: search_params[:resource_type],
                                           resource_id:   search_params[:resource_id] })
         when 'task'
@@ -320,7 +320,7 @@ module ForemanTasks
       end
 
       def find_task
-        @task = resource_scope.find(params[:id])
+        @task = resource_scope.with_duration.find(params[:id])
       end
 
       def resource_scope(_options = {})
@@ -330,7 +330,7 @@ module ForemanTasks
       end
 
       def resource_scope_for_index(*args)
-        super.select("DISTINCT foreman_tasks_tasks.*, coalesce(ended_at, current_timestamp) - coalesce(coalesce(started_at, ended_at), current_timestamp) as duration")
+        super.with_duration.distinct
       end
 
       def controller_permission

data/app/controllers/foreman_tasks/tasks_controller.rb

@@ -99,8 +99,8 @@ module ForemanTasks
     private
 
     def respond_with_tasks(scope)
-      @tasks = filter(scope, paginate: false)
-      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'])
+      @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'])
     end
 
     def controller_permission

data/app/graphql/types/recurring_logic.rb

@@ -0,0 +1,19 @@
+module Types
+  class RecurringLogic < Types::BaseObject
+    description 'A Recurring Logic'
+    model_class ::ForemanTasks::RecurringLogic
+
+    global_id_field :id
+    field :cron_line, String
+    field :end_time, GraphQL::Types::ISO8601DateTime
+    field :max_iteration, Integer
+    field :iteration, Integer
+    field :state, String
+    field :purpose, String
+    belongs_to :triggering, Types::Triggering
+
+    def self.graphql_definition
+      super.tap { |type| type.instance_variable_set(:@name, 'ForemanTasks::RecurringLogic') }
+    end
+  end
+end

data/app/graphql/types/task.rb

@@ -0,0 +1,25 @@
+module Types
+  class Task < Types::BaseObject
+    description 'A Task'
+    model_class ::ForemanTasks::Task
+
+    global_id_field :id
+    field :type, String
+    field :label, String
+    field :started_at, GraphQL::Types::ISO8601DateTime
+    field :ended_at, GraphQL::Types::ISO8601DateTime
+    field :state, String
+    field :result, String
+    field :external_id, String
+    field :parent_task_id, String
+    field :start_at, GraphQL::Types::ISO8601DateTime
+    field :start_before, GraphQL::Types::ISO8601DateTime
+    field :action, String
+    field :user_id, Integer
+    field :state_updated_at, GraphQL::Types::ISO8601DateTime
+
+    def self.graphql_definition
+      super.tap { |type| type.instance_variable_set(:@name, 'ForemanTasks::Task') }
+    end
+  end
+end

data/app/graphql/types/triggering.rb

@@ -0,0 +1,16 @@
+module Types
+  class Triggering < Types::BaseObject
+    description 'A Task Triggering'
+    model_class ::ForemanTasks::Triggering
+
+    global_id_field :id
+    field :mode, String
+    field :start_at, GraphQL::Types::ISO8601DateTime
+    field :start_before, GraphQL::Types::ISO8601DateTime
+    field :recurring_logic, Types::RecurringLogic
+
+    def self.graphql_definition
+      super.tap { |type| type.instance_variable_set(:@name, 'ForemanTasks::Triggering') }
+    end
+  end
+end

data/app/helpers/foreman_tasks/foreman_tasks_helper.rb

@@ -141,7 +141,10 @@ module ForemanTasks
         weekly_fieldset(f, triggering),
         time_picker_fieldset(f, triggering),
       ]
-
+      tags << text_f(f, :start_at_raw, :label => _('Start at'), :placeholder => 'YYYY-mm-dd HH:MM')
+      tags << text_f(f, :purpose,
+                     :label => _('Purpose'),
+                     :label_help => N_('A special label for tracking a recurring job. There can be only one active job with a given purpose at a time.'))
       content_tag(:fieldset, nil, :id => 'trigger_mode_recurring', :class => "trigger_mode_form #{'hidden' unless triggering.recurring?}") do
         tags.join.html_safe
       end

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

@@ -8,7 +8,7 @@ module Actions
       end
 
       def continuous_output
-        continuous_output = ::ForemanTasksCore::ContinuousOutput.new
+        continuous_output = ::ForemanTasks::ContinuousOutput.new
         continuous_output_providers.each do |continous_output_provider|
           continous_output_provider.fill_continuous_output(continuous_output)
         end

data/app/lib/actions/trigger_proxy_batch.rb

@@ -0,0 +1,79 @@
+module Actions
+  # This action plans proxy tasks in batches.
+  # It needs to be manually notified about the next batch being available by sending a TriggerNextBatch event.
+  #
+  # The ProxyAction needs to be planned with `:use_batch_triggering => true` to activate the feature
+  class TriggerProxyBatch < Base
+    TriggerNextBatch = Algebrick.type do
+      fields! batches: Integer
+    end
+    TriggerLastBatch = Algebrick.atom
+
+    def run(event = nil)
+      case event
+      when nil
+        if output[:planned_count]
+          check_finish
+        else
+          init_counts and suspend
+        end
+      when TriggerNextBatch
+        trigger_remote_tasks_batches(event.batches) and suspend
+      when TriggerLastBatch
+        trigger_remote_tasks_batch and on_finish
+      when ::Dynflow::Action::Skip
+        # do nothing
+      end
+    end
+
+    def trigger_remote_tasks_batches(amount = 1)
+      amount.times { trigger_remote_tasks_batch }
+    end
+
+    def trigger_remote_tasks_batch
+      # Find the tasks in batches, order them by proxy_url so we get all tasks
+      # to a certain proxy "close to each other"
+      batch = remote_tasks.pending.order(:proxy_url, :id).first(batch_size)
+      # Group the tasks by operation, in theory there should be only one operation
+      batch.group_by(&:operation).each do |operation, group|
+        ForemanTasks::RemoteTask.batch_trigger(operation, group)
+      end
+      output[:planned_count] += batch.size
+    rescue => e
+      action_logger.warn "Could not trigger task on the smart proxy: #{e.message}"
+      batch.each { |remote_task| remote_task.update_from_batch_trigger({}) }
+      output[:failed_count] += batch.size
+    end
+
+    def init_counts
+      output[:planned_count] = 0
+      output[:failed_count] = 0
+    end
+
+    def check_finish
+      if output[:planned_count] + output[:failed_count] + batch_size >= input[:total_count]
+        trigger_remote_tasks_batch and on_finish
+      else
+        suspend
+      end
+    end
+
+    def done?
+      output[:planned_count] + output[:failed_count] >= input[:total_count]
+    end
+
+    def remote_tasks
+      task.remote_sub_tasks
+    end
+
+    def on_finish
+      # nothing for now
+    end
+
+    private
+
+    def batch_size
+      input[:batch_size] || Setting['foreman_tasks_proxy_batch_size']
+    end
+  end
+end

data/app/models/foreman_tasks/recurring_logic.rb

@@ -4,6 +4,8 @@ module ForemanTasks
   class RecurringLogic < ApplicationRecord
     include Authorizable
 
+    graphql_type '::Types::RecurringLogic'
+
     belongs_to :task_group
     belongs_to :triggering
 
@@ -15,6 +17,9 @@ module ForemanTasks
     scoped_search :on => :iteration, :complete_value => false
     scoped_search :on => :cron_line, :complete_value => true
     scoped_search :on => :state, :complete_value => true
+    scoped_search :on => :purpose, :complete_value => true
+
+    validate :valid_purpose
 
     before_create do
       task_group.save
@@ -167,6 +172,7 @@ module ForemanTasks
       ::ForemanTasks::RecurringLogic.new_from_cronline(cronline).tap do |manager|
         manager.end_time = triggering.end_time if triggering.end_time_limited.present?
         manager.max_iteration = triggering.max_iteration if triggering.max_iteration.present?
+        manager.purpose = triggering.purpose if triggering.purpose.present?
         manager.triggering = triggering
       end
     end
@@ -187,5 +193,9 @@ module ForemanTasks
                      end
       hash.select { |key, _| allowed_keys.include? key }
     end
+
+    def valid_purpose?
+      !(purpose.present? && self.class.where(:purpose => purpose, :state => %w[active disabled]).any?)
+    end
   end
 end

data/app/models/foreman_tasks/task.rb

@@ -5,6 +5,8 @@ module ForemanTasks
     include Authorizable
     extend Search
 
+    graphql_type '::Types::Task'
+
     def check_permissions_after_save
       # there's no create_tasks permission, tasks are created as a result of internal actions, in such case we
       # don't do authorization, that should have been performed on wrapping action level
@@ -76,6 +78,7 @@ module ForemanTasks
                                  :"foreman_tasks_links.resource_type" => resource.class.name)
            end)
     scope :for_action_types, (->(action_types) { where('foreman_tasks_tasks.label IN (?)', Array(action_types)) })
+    scope :with_duration, -> { select("foreman_tasks_tasks.*, coalesce(ended_at, current_timestamp) - coalesce(coalesce(started_at, ended_at), current_timestamp) as duration") }
 
     apipie :class, "A class representing #{model_name.human} object" do
       name 'Task'
@@ -255,6 +258,32 @@ module ForemanTasks
       main_action.continuous_output.raw_outputs
     end
 
+    def self.latest_tasks_by_resource_ids(label, resource_type, resource_ids)
+      tasks = arel_table
+      links = ForemanTasks::Link.arel_table
+      started_at = tasks[:started_at]
+      resource_id = links[:resource_id]
+
+      base_combined_table = tasks
+                            .join(links).on(tasks[:id].eq(links[:task_id]))
+                            .where(tasks[:label].eq(label)
+                                                .and(links[:resource_type].eq(resource_type))
+                                                .and(links[:resource_id].in(resource_ids)))
+
+      grouped = base_combined_table.project(
+        started_at.maximum.as('started_at_max'),
+        resource_id
+      ).group(resource_id).order(resource_id).as('grouped')
+
+      max_per_resource_id = tasks
+                            .join(links).on(tasks[:id].eq(links[:task_id]))
+                            .join(grouped).on(grouped[:started_at_max].eq(started_at).and(grouped[:resource_id].eq(resource_id)))
+                            .distinct
+                            .project(tasks[Arel.star], grouped[:resource_id])
+
+      find_by_sql(max_per_resource_id.to_sql).index_by(&:resource_id)
+    end
+
     protected
 
     def generate_id

data/app/models/foreman_tasks/triggering.rb

@@ -2,9 +2,11 @@ module ForemanTasks
   class Triggering < ApplicationRecord
     PARAMS = [:start_at_raw, :start_before_raw, :max_iteration, :input_type,
               :cronline, :days, :days_of_week, :time, :end_time_limited,
-              :end_time].freeze
+              :end_time, :purpose].freeze
     attr_accessor(*PARAMS)
 
+    graphql_type '::Types::Triggering'
+
     before_save do
       if future?
         parse_start_at!
@@ -28,7 +30,7 @@ module ForemanTasks
     validates :input_type, :if => :recurring?,
                            :inclusion => { :in => ALLOWED_INPUT_TYPES,
                                            :message => _('%{value} is not allowed input type') }
-    validates :start_at_raw, format: { :with => TIME_REGEXP, :if => :future?,
+    validates :start_at_raw, format: { :with => TIME_REGEXP, :if => ->(triggering) { triggering.future? || (triggering.recurring? && triggering.start_at_raw) },
                                        :message => _('%{value} is wrong format') }
     validates :start_before_raw, format: { :with => TIME_REGEXP, :if => :future?,
                                            :message => _('%{value} is wrong format'), :allow_blank => true }
@@ -68,7 +70,7 @@ module ForemanTasks
                              delay_options,
                              *args
       when :recurring
-        recurring_logic.start(action, *args)
+        recurring_logic.start_after(action, delay_options[:start_at] || Time.zone.now, *args)
       end
     end
 
@@ -92,7 +94,13 @@ module ForemanTasks
     end
 
     def parse_start_at!
-      self.start_at ||= Time.zone.parse(start_at_raw)
+      self.start_at ||= Time.zone.parse(start_at_raw) if start_at_raw.present?
+    end
+
+    def parse_start_at
+      self.start_at ||= Time.zone.parse(start_at_raw) if start_at_raw.present?
+    rescue ArgumentError
+      errors.add(:start_at, _('is not a valid format'))
     end
 
     def parse_start_before!
@@ -102,7 +110,9 @@ module ForemanTasks
     private
 
     def can_start_recurring
+      parse_start_at
       errors.add(:input_type, _('No task could be started')) unless recurring_logic.valid?
+      errors.add(:purpose, _('Active or disabled recurring logic with purpose %s already exists') % recurring_logic.purpose) unless recurring_logic.valid_purpose?
       errors.add(:cronline, _('%s is not valid format of cron line') % cronline) unless recurring_logic.valid_cronline?
     end
 

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

@@ -3,6 +3,6 @@ object @task if @task
 extends 'api/v2/layouts/permissions'
 
 attributes :id, :label, :pending, :action
-attributes :username, :started_at, :ended_at, :state, :result, :progress
+attributes :username, :started_at, :ended_at, :duration, :state, :result, :progress
 attributes :input, :output, :humanized, :cli_example, :start_at
 node(:available_actions) { |t| { cancellable: t.execution_plan&.cancellable?, resumable: t.resumable? } }

data/app/views/foreman_tasks/layouts/react.html.erb

@@ -6,7 +6,6 @@
 <% end %>
 
 <% content_for(:content) do %>
-  <%= notifications %>
   <div id="organization-id" data-id="<%= Organization.current.id if Organization.current %>" ></div>
   <div id="user-id" data-id="<%= User.current.id if User.current %>" ></div>
   <%= react_component('ForemanTasks') %>

data/app/views/foreman_tasks/recurring_logics/index.html.erb

@@ -8,9 +8,9 @@
 <% if authorized_for(:permission => :edit_recurring_logics, :auth_object => @recurring_logics) %>
   <% title_actions link_to(_('Clear Cancelled'),
               clear_cancelled_foreman_tasks_recurring_logics_path,
-              class:  ['btn', 'btn-sm', 'btn-danger'],                  
+              class:  ['btn', 'btn-sm', 'btn-danger'],
               :'data-toggle' => "modal",
-              :'data-target' => "#clear_modal") 
+              :'data-target' => "#clear_modal")
               %>
 
   <div class="modal fade" id="clear_modal" tabindex="-1" role="dialog" aria-labelledby="Deploy" aria-hidden="true">
@@ -47,6 +47,7 @@
     <th><%= N_("Iteration limit") %></th>
     <th><%= N_("Repeat until") %></th>
     <th><%= N_("State") %></th>
+    <th><%= N_("Purpose") %></th>
     <th/>
   </thead>
   <% @recurring_logics.each do |recurring_logic| %>
@@ -61,6 +62,7 @@
       <td><%= format_recurring_logic_limit recurring_logic.max_iteration %></td>
       <td><%= format_recurring_logic_limit recurring_logic.end_time.try(:in_time_zone) %></td>
       <td><%= recurring_logic_state(recurring_logic) %></td>
+      <td><%= recurring_logic.purpose %></td>
       <td><%= recurring_logic_action_buttons(recurring_logic) %></td>
     </tr>
   <% end %>

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

@@ -36,4 +36,8 @@
     <th><%= N_("State") %></th>
     <td><%= recurring_logic_state(recurring_logic) %></td>
   </tr>
+  <tr>
+    <th><%= N_("Purpose") %></th>
+    <td><%= recurring_logic.purpose %></td>
+  </tr>
 </table>

data/db/migrate/20210720115251_add_purpose_to_recurring_logic.rb

@@ -0,0 +1,6 @@
+class AddPurposeToRecurringLogic < ActiveRecord::Migration[6.0]
+  def change
+    add_column :foreman_tasks_recurring_logics, :purpose, :string
+    add_index :foreman_tasks_recurring_logics, :purpose, unique: true, where: "state IN ('active', 'disabled')"
+  end
+end

data/extra/foreman-tasks-cleanup.sh

@@ -0,0 +1,127 @@
+#!/bin/bash
+
+PROGNAME="$0"
+EXECUTE=0
+RAKE_COMMAND="${RAKE_COMMAND:-"foreman-rake"}"
+
+function die() {
+    local code="$1"
+    local message="$2"
+    echo "$message" >&2
+    exit $code
+}
+
+function build_rake() {
+    echo -n "$RAKE_COMMAND "
+    echo -n 'foreman_tasks:cleanup '
+    for env in AFTER TASK_BACKUP BATCH_SIZE NOOP TASK_SEARCH STATES VERBOSE; do
+        local value="${!env}"
+        [ -n "${value}" ] && echo -n "${env}=$(printf '%q' "$value") "
+    done
+    echo
+}
+
+function usage() {
+        cat << EOF
+Usage: $PROGNAME [script_options...] [options...]
+
+An interface script for setting environment variables properly
+for foreman-tasks:cleanup rake task. By default only prints
+the command to run, with -E|--execute flag performs the cleanup.
+
+Environment variables:
+RAKE_COMMAND: can be used to redefine path to rake, by default foreman-rake
+
+Script options:
+EOF
+        cat <<EOF | column -s\& -t
+-E|--execute & execute the created rake command
+-h|--help & show this output
+EOF
+
+        echo
+        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
+-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
+-v|--verbose & be verbose
+EOF
+}
+
+SHORTOPTS="a:bB:Ehns:S:v"
+LONGOPTS="after:,backup,batch-size:,execute,help,noop,search:,states:,verbose"
+
+ARGS=$(getopt -s bash \
+              --options $SHORTOPTS \
+              --longoptions $LONGOPTS \
+              --name $PROGNAME \
+              -- "$@" )
+
+if [ $? -gt 0 ]; then
+    die 1 "getopt failed"
+fi
+
+eval set -- "$ARGS"
+
+while true; do
+    case $1 in
+        -a|--after)
+            shift
+            AFTER="$1"
+            ;;
+        -b|--backup)
+            TASK_BACKUP=true
+            ;;
+        -B|--batch-size)
+            shift
+            BATCH_SIZE="$1"
+            ;;
+        -n|--noop)
+            NOOP=1
+            ;;
+        -s|--search)
+            shift
+            TASK_SEARCH="$1"
+            ;;
+        -S|--states)
+            shift
+            if [ "$1" == "all" ]; then
+                STATES=","
+            else
+                STATES="$1"
+            fi
+            ;;
+        -v|--verbose)
+            VERBOSE=1
+            ;;
+        -h|--help)
+            usage
+            exit 0
+            ;;
+        -E|--execute)
+            EXECUTE=1
+            ;;
+        \?)
+            die 1 "Invalid option: -$OPTARG"
+            ;;
+        --)
+            ;;
+        *)
+            [ -n "$1" ] || break
+            die 1 "Unaccepted parameter: $1"
+            shift
+            ;;
+    esac
+    shift
+done
+
+if [ "$EXECUTE" -eq 1 ]; then
+    build_rake | sh
+else
+    build_rake
+fi
+