foreman-tasks 5.1.1 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c191bf6093506d0c5346c71a026908b3c5c6b10fa9ceb27e5fdfbfa93a72c2c6
-  data.tar.gz: 0fc1f15e955f6d13469aa28883db8447f8e3770d4751206faaec5c224d3ffcbc
+  metadata.gz: a31c8423a352c5eeb6ff93b23ce8ed3d868ee4bdb16d456233f2c3df475342cd
+  data.tar.gz: c181fdc4c13d8c3cfb7e8d8469c9188a8972b97ca223e68cb50d9a901e23d552
 SHA512:
-  metadata.gz: d57a47e629be8d4bcfaba9bc853f7ec0853ea8f968884d4b589e98d74027a73bcef5ff45ff53f3e01f8794a28a01729bb4c811b004430296304a86b7936d4bd4
-  data.tar.gz: e4e3b07b3e4f84e233534c40adadaa8c4032c33e5bd5a8623a8d54bcece9de022c1c4e2fd81ca0f3ed1c9e512df23dc14b5d2fe8be349de03df1a5b4a41c7235
+  metadata.gz: c7f2b880bb70b4fc2781ab9c5bff2c7bcd0434bc067669fae601f1815f6720e7dd771a170cdde8a4922565f1bd87c61d5b3dc1c0b10192bd895508d123aa84da
+  data.tar.gz: a4652958efa52fec83b6c0a8093914b1d22ad574bc4763cb66c3bc41e82bd67e5b1448be0fd79ae3ce64225cb44d6c25faeb324cd10a846dfbe77abee5d55b02

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/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/base.rb

@@ -2,6 +2,7 @@ module Actions
   class Base < Dynflow::Action
     middleware.use ::Actions::Middleware::RailsExecutorWrap
     include Actions::Helpers::LifecycleLogging
+    include Actions::TaskSynchronization
 
     execution_plan_hooks.use :notify_paused, :on => [:paused]
 

data/app/lib/actions/foreman/host/import_facts.rb

@@ -26,7 +26,7 @@ module Actions
         def run
           ::User.as :admin do
             host           = ::Host.find(input[:host][:id])
-            state          = host.import_facts(input[:facts], proxy)
+            state          = ::HostFactImporter.new(host).import_facts(input[:facts], proxy)
             output[:state] = state
           end
         rescue ::Foreman::Exception => e

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

@@ -7,7 +7,7 @@ module Actions
 
       def log_task_state_change(execution_plan)
         return unless root_action?
-        logger = Rails.application.dynflow.world.action_logger
+        logger = ::Rails.application.dynflow.world.action_logger
         task_id = ForemanTasks::Task::DynflowTask.where(external_id: execution_plan.id).pluck(:id).first
 
         task_id_parts = []

data/app/lib/actions/middleware/rails_executor_wrap.rb

@@ -10,13 +10,13 @@ module Actions
     # for more details.
     class RailsExecutorWrap < Dynflow::Middleware
       def run(*args)
-        Rails.application.executor.wrap do
+        ::Rails.application.executor.wrap do
           pass(*args)
         end
       end
 
       def finalize
-        Rails.application.executor.wrap do
+        ::Rails.application.executor.wrap do
           pass
         end
       end

data/app/lib/actions/middleware/watch_delegated_proxy_sub_tasks.rb

@@ -26,17 +26,26 @@ module Actions
       def check_triggered
         in_remote_task_batches(remote_tasks.triggered) do |batch|
           batch.group_by(&:proxy_url).each do |(url, tasks)|
-            tasks = poll_proxy_tasks(url, tasks).flatten
-            process_task_results tasks
+            results = poll_proxy_tasks(url, tasks)
+            process_task_results tasks, results
           end
         end
       end
 
-      def process_task_results(tasks)
-        missing, present = tasks.partition { |task| task.result.nil? }
+      def process_task_results(tasks, results)
+        possibly_missing, present = tasks.partition { |task| !results.key?(task.remote_task_id) }
+        missing = possibly_missing.select do |task|
+          # Really missing are tasks which are missing and:
+          # don't have a remote parent
+          # had a remote parent but the proxy doesn't have the remote parent anymore
+          # has a remote parent, proxy has the remote parent but it is stopped or paused
+          task.parent_task_id.nil? ||
+            !results.key?(task.parent_task_id) ||
+            %(stopped paused).include?(results[task.parent_task_id]['state'])
+        end
         notify ::Actions::ProxyAction::ProxyActionMissing.new, missing if missing.any?
 
-        stopped = present.select { |task| %w[stopped paused].include? task.result['state'] }
+        stopped = present.select { |task| %w[stopped paused].include? results.dig(task.remote_task_id, 'state') }
         notify ::Actions::ProxyAction::ProxyActionStopped.new, stopped if stopped.any?
       end
 
@@ -52,15 +61,13 @@ module Actions
 
       def poll_proxy_tasks(url, tasks)
         proxy = ProxyAPI::ForemanDynflow::DynflowProxy.new(:url => url)
-        results = proxy.task_states(tasks.map(&:remote_task_id))
-        tasks.map do |task|
-          task.result = results[task.remote_task_id]
-          task
-        end
+        # Get statuses of tasks and their optional parent tasks
+        ids = (tasks.map(&:remote_task_id) + tasks.map(&:parent_task_id)).uniq
+        proxy.task_states(ids)
       rescue => e
         # We could not reach the remote task, we'll try again next time
         action.action_logger.warn(_('Failed to check on tasks on proxy at %{url}: %{exception}') % { :url => url, :exception => e.message })
-        []
+        {}
       end
 
       def in_remote_task_batches(scope)

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
@@ -67,7 +67,7 @@ module Actions
     def trigger_proxy_task
       suspend do |_suspended_action|
         remote_task = prepare_remote_task
-        remote_task.trigger(proxy_action_name, proxy_input)
+        ForemanTasks::RemoteTask.batch_trigger(remote_task.operation, [remote_task])
         output[:proxy_task_id] = remote_task.remote_task_id
       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
@@ -273,7 +263,7 @@ module Actions
     end
 
     def proxy_task_id
-      output[:proxy_task_id] ||= remote_task.try(:remote_task_id)
+      output[:proxy_task_id] || remote_task.try(:remote_task_id) || @execution_plan_id
     end
   end
 end

data/app/lib/actions/task_synchronization.rb

@@ -0,0 +1,65 @@
+module Actions
+  # Examples:
+
+  # # Action A which emits an event when it successfully finishes.
+  # class A
+  #   include ::Actions::ObservableAction
+  #   # ... rest ...
+  # end
+
+  # # Action B which emits an event when it successfully finishes or fails.
+  # class B
+  #   include ::Actions::ObservableAction
+  #
+  #   execution_plan_hooks.use :emit_event_failure, :on => [:failure]
+  #
+  #   def self.event_names
+  #     super + [event_name_base + '_' + event_name_suffix(:failure)]
+  #   end
+  #
+  #   def emit_event_failure(plan)
+  #     emit_event(plan, :failure)
+  #   end
+  #   # ... rest ...
+  # end
+  module TaskSynchronization
+    def self.included(base)
+      base.execution_plan_hooks.use :sync_execution_plan_to_task, on: ::Dynflow::ExecutionPlan.states
+    end
+
+    def sync_execution_plan_to_task(plan)
+      return unless root_action?
+      on_execution_plan_save(plan)
+    rescue => e
+      ::Foreman::Logging.exception('Error on on_execution_plan_save event', e,
+                                   :logger => 'dynflow')
+    end
+
+    private
+
+    def on_execution_plan_save(execution_plan)
+      # We can load the data unless the execution plan was properly planned and saved
+      # including its steps
+      case execution_plan.state
+      when :pending
+        task = ForemanTasks::Task::DynflowTask.new_for_execution_plan(execution_plan)
+        task.start_at ||= Time.zone.now
+        task.save!
+      when :scheduled
+        delayed_plan = world.persistence.load_delayed_plan(execution_plan.id)
+        raise ::Foreman::Exception, 'Plan is delayed but the delay record is missing' if delayed_plan.nil?
+        task = ::ForemanTasks::Task::DynflowTask.find_by!(:external_id => execution_plan.id)
+        task.update_from_dynflow(execution_plan, delayed_plan)
+      when :planning
+        task = ::ForemanTasks::Task::DynflowTask.where(:external_id => execution_plan.id).first
+        task.update_from_dynflow(execution_plan)
+      else
+        if (task = ::ForemanTasks::Task::DynflowTask.where(:external_id => execution_plan.id).first)
+          unless task.state.to_s == execution_plan.state.to_s
+            task.update_from_dynflow(execution_plan)
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/trigger_proxy_batch.rb

@@ -37,8 +37,8 @@ module Actions
       # 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)
+        output[:planned_count] += group.size
       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({}) }

data/app/models/foreman_tasks/lock.rb

@@ -9,7 +9,7 @@ module ForemanTasks
         |
         | #{_('Conflicts with tasks:')}
         HEADER
-        url_helpers = Rails.application.routes.url_helpers
+        url_helpers = ::Rails.application.routes.url_helpers
         conflicting_tasks = conflicting_locks
                             .map(&:task)
                             .uniq

data/app/models/foreman_tasks/remote_task.rb

@@ -16,7 +16,7 @@ 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}"
                    {}
@@ -31,37 +31,28 @@ module ForemanTasks
           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 = remote_tasks.first.proxy.launch_tasks(operation, input_hash)
+        remote_tasks.each do |remote_task|
+          remote_task.update_from_batch_trigger results.fetch(remote_task.execution_plan_id, {}),
+                                                results.fetch('parent', {})
+        end
       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)
+    def update_from_batch_trigger(data, parent = {})
       if data['result'] == 'success'
         self.remote_task_id = data['task_id']
         self.state = 'triggered'
+      elsif !parent.empty?
+        self.parent_task_id = parent['task_id']
+        self.state = 'parent-triggered'
       else
         # Tell the action the task on the smart proxy stopped
         ForemanTasks.dynflow.world.event execution_plan_id,
                                          step_id,
-                                         ::Actions::ProxyAction::ProxyActionStopped.new
+                                         ::Actions::ProxyAction::ProxyActionStopped.new,
+                                         optional: true
       end
       save!
     end

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

@@ -5,15 +5,14 @@ module ForemanTasks
     scope :for_action, ->(action_class) { where(label: action_class.name) }
     after_validation :set_action_field
 
-    def update_from_dynflow(data)
-      utc_zone = ActiveSupport::TimeZone.new('UTC')
-      self.external_id    = data[:id]
-      self.result         = map_result(data).to_s
-      self.state          = data[:state].to_s
-      self.started_at     = string_to_time(utc_zone, data[:started_at]) unless data[:started_at].nil?
-      self.ended_at       = string_to_time(utc_zone, data[:ended_at]) unless data[:ended_at].nil?
-      self.start_at       = string_to_time(utc_zone, data[:start_at]) if data[:start_at]
-      self.start_before   = string_to_time(utc_zone, data[:start_before]) if data[:start_before]
+    def update_from_dynflow(plan, delayed_plan = nil)
+      self.external_id    = plan.id
+      self.result         = map_result(plan).to_s
+      self.state          = plan.state.to_s
+      self.started_at     = plan.started_at unless plan.started_at.nil?
+      self.ended_at       = plan.ended_at unless plan.ended_at.nil?
+      self.start_at       = delayed_plan.start_at if delayed_plan
+      self.start_before   = delayed_plan.start_before if delayed_plan
       self.parent_task_id ||= begin
                                 if main_action.try(:caller_execution_plan_id)
                                   DynflowTask.where(:external_id => main_action.caller_execution_plan_id).first!.id
@@ -221,7 +220,7 @@ module ForemanTasks
       fixed_count = 0
       logger = Foreman::Logging.logger('foreman-tasks')
       running.each do |task|
-        changes = task.update_from_dynflow(task.execution_plan.to_hash)
+        changes = task.update_from_dynflow(task.execution_plan)
         unless changes.empty?
           fixed_count += 1
           logger.warn('Task %s updated at consistency check: %s' % [task.id, changes.inspect])
@@ -236,10 +235,10 @@ module ForemanTasks
       fixed_count
     end
 
-    def self.new_for_execution_plan(execution_plan_id, data)
-      new(:external_id => execution_plan_id,
-          :state => data[:state].to_s,
-          :result => data[:result].to_s,
+    def self.new_for_execution_plan(execution_plan)
+      new(:external_id => execution_plan.id,
+          :state => execution_plan.state.to_s,
+          :result => execution_plan.result.to_s,
           :user_id => User.current.try(:id))
     end
 
@@ -258,20 +257,20 @@ module ForemanTasks
       self.action = to_label
     end
 
-    def map_result(data)
-      if state_result_transitioned?(%w[planned pending], %w[stopped error], data) ||
-         (data[:result] == :error && cancelled?)
+    def map_result(plan)
+      if state_result_transitioned?(%w[planned pending], %w[stopped error], plan) ||
+         (plan.result == :error && cancelled?)
         :cancelled
       else
-        data[:result]
+        plan.result
       end
     end
 
-    def state_result_transitioned?(from, to, data)
+    def state_result_transitioned?(from, to, plan)
       oldstate, oldresult = from
       newstate, newresult = to
-      state == oldstate && data[:state].to_s == newstate &&
-        result == oldresult && data[:result].to_s == newresult
+      state == oldstate && plan.state.to_s == newstate &&
+        result == oldresult && plan.result.to_s == newresult
     end
 
     def cancelled?

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

@@ -2,3 +2,7 @@ object @lock
 
 attributes :name, :resource_type, :resource_id
 node(:exclusive) { !locals[:link] }
+node(:link) do
+  method = "#{@object.resource_type.underscore.split('/').first}_path".to_sym
+  public_send(method, @object.resource_id) if defined?(method)
+end

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/config/routes.rb

@@ -70,7 +70,7 @@ Foreman::Application.routes.draw do
       mount ForemanTasks.dynflow.web_console => '/dynflow'
       if defined? ::Sidekiq
         require 'sidekiq/web'
-        redis_url = SETTINGS.dig(:dynflow, :redis_url)
+        redis_url = ENV['DYNFLOW_REDIS_URL'] || SETTINGS.dig(:dynflow, :redis_url)
         Sidekiq.redis = { url: redis_url }
         Sidekiq::Web.set :sessions, false
         mount Sidekiq::Web => '/sidekiq', :constraints => ForemanTasks::Dynflow::SidekiqConsoleConstraint.new

data/db/migrate/20210708123832_add_parent_task_id_to_remote_tasks.foreman_tasks.rb

@@ -0,0 +1,5 @@
+class AddParentTaskIdToRemoteTasks < ActiveRecord::Migration[5.0]
+  def change
+    add_column :foreman_tasks_remote_tasks, :parent_task_id, :string
+  end
+end

data/db/migrate/20211123170430_tasks_settings_to_dsl_category.rb

@@ -0,0 +1,5 @@
+class TasksSettingsToDslCategory < ActiveRecord::Migration[6.0]
+  def up
+    Setting.where(category: 'Setting::ForemanTasks').update_all(category: 'Setting')
+  end
+end

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,15 +20,13 @@ 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")
   s.extra_rdoc_files = Dir['README*', 'LICENSE']
 
-  s.add_dependency "dynflow", '>= 1.2.3'
+  s.add_dependency "dynflow", '>= 1.6.0'
   s.add_dependency "get_process_mem" # for memory polling
   s.add_dependency "parse-cron", '~> 0.1.4'
   s.add_dependency "sinatra" # for Dynflow web console