foreman-tasks 5.2.3 → 5.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f1c154c83d919ac42b7d12edd03cff55e67f11a1367a67250a9a090759cd099
-  data.tar.gz: 519d85e8e975aab38b2e2314eb5761cb2bb3fe2d07b291822f3c667e6c0feab4
+  metadata.gz: 6f5ae3bb36274977790149d11f722477d6db0254b251ffa1dc79ec850a206183
+  data.tar.gz: bfd76d0fcc43a78e34c1831a392042e5770bd09276d95d126043f3a14db174b7
 SHA512:
-  metadata.gz: 28a96b1b6c28bb5697607d69950167100815c667ecbebbc3f9f446f7e44899e7459e79a4f8efe8f53d798ee7ece6ebaad6d0becd610b11ab499cd32a4e2b5b53
-  data.tar.gz: 16c30b57fc2b2f82be9baf9d2dcf4c1b9f7a47df3013393d274fb6268ea04b6a066d3464bdeb1d911b998d7d5e68faa19ea9551193a25a07fb1cc12ddb45ee66
+  metadata.gz: b2bde1cb649304ba13019b544c8db8f7fa72b2e0539d47b2db07d6e945364d08b4e5fa0b100b701aa7f080e8be308ad7a6af404eaee2865e7b13fd423f9a9300
+  data.tar.gz: 00a77aaf192bbfc12a70dc034aa75bfd728c18956b1b9377bbef3d7fce7491c68cfa520d9fd04de4789c721fcc2d2b2b605b63a9165601092841e44184219dfc

data/app/controllers/foreman_tasks/tasks_controller.rb

@@ -4,8 +4,6 @@ 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?
@@ -33,7 +31,8 @@ module ForemanTasks
     end
 
     def cancel_step
-      result = ForemanTasks.dynflow.world.event(@dynflow_task.external_id, params[:step_id].to_i, ::Dynflow::Action::Cancellable::Cancel).wait
+      task = find_dynflow_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
@@ -42,7 +41,8 @@ module ForemanTasks
     end
 
     def cancel
-      if @dynflow_task.cancel
+      task = find_dynflow_task
+      if task.cancel
         render json: { statusText: 'OK' }
       else
         render json: {}, status: :bad_request
@@ -50,17 +50,19 @@ module ForemanTasks
     end
 
     def abort
-      if @dynflow_task.abort
+      task = find_dynflow_task
+      if 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(@dynflow_task))
+      redirect_back(:fallback_location => foreman_tasks_task_path(task))
     end
 
     def resume
-      if @dynflow_task.resumable?
-        ForemanTasks.dynflow.world.execute(@dynflow_task.execution_plan.id)
+      task = find_dynflow_task
+      if task.resumable?
+        ForemanTasks.dynflow.world.execute(task.execution_plan.id)
         render json: { statusText: 'OK' }
       else
         render json: {}, status: :bad_request
@@ -68,8 +70,10 @@ module ForemanTasks
     end
 
     def unlock
-      if @dynflow_task.paused?
-        unlock_task(@dynflow_task)
+      task = find_dynflow_task
+      if task.paused?
+        task.state = :stopped
+        task.save!
         render json: { statusText: 'OK' }
       else
         render json: {}, status: :bad_request
@@ -77,7 +81,9 @@ module ForemanTasks
     end
 
     def force_unlock
-      unlock_task(@dynflow_task)
+      task       = find_dynflow_task
+      task.state = :stopped
+      task.save!
       render json: { statusText: 'OK' }
     end
 
@@ -92,12 +98,6 @@ 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
-      @dynflow_task = resource_scope.where(:type => 'ForemanTasks::Task::DynflowTask').find(params[:id])
+      resource_scope.where(:type => 'ForemanTasks::Task::DynflowTask').find(params[:id])
     end
 
     def filter(scope, paginate: true)

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/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

@@ -263,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,11 +37,10 @@ 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"
-      action_logger.warn 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

data/app/models/foreman_tasks/recurring_logic.rb

@@ -90,7 +90,7 @@ module ForemanTasks
     def next_occurrence_time(time = Time.zone.now)
       @parser ||= CronParser.new(cron_line, Time.zone)
       # @parser.next(start_time) is not inclusive of the start_time hence stepping back one run to include checking start_time for the first run.
-      before_next = @parser.next(@parser.last(time.in_time_zone))
+      before_next = @parser.next(@parser.last(time))
       return before_next if before_next >= time && tasks.count == 0
       @parser.next(time)
     end

data/app/models/foreman_tasks/remote_task.rb

@@ -18,8 +18,7 @@ module ForemanTasks
       response = begin
                    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"
-                   logger.warn e
+                   logger.warn "Could not trigger task on the smart proxy: #{e.message}"
                    {}
                  end
       update_from_batch_trigger(response)
@@ -27,26 +26,33 @@ module ForemanTasks
     end
 
     def self.batch_trigger(operation, remote_tasks)
-      remote_tasks.group_by(&:proxy_url).each_value do |group|
+      remote_tasks.group_by(&:proxy_url).values.map 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
-        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] }
+        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
 
-    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/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,21 +21,6 @@ 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...]
@@ -58,8 +43,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. 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
+-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
@@ -134,8 +119,6 @@ while true; do
     shift
 done
 
-validate_options!
-
 if [ "$EXECUTE" -eq 1 ]; then
     build_rake | sh
 else

data/foreman-tasks.gemspec

@@ -26,7 +26,7 @@ same resource. It also optionally provides Dynflow infrastructure for using it f
   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

data/lib/foreman_tasks/dynflow/configuration.rb

@@ -1,5 +1,4 @@
 require File.expand_path('lib/foreman/dynflow/configuration', Rails.root)
-require 'foreman_tasks/dynflow/persistence'
 
 module ForemanTasks
   # Import all Dynflow configuration from Foreman, and add our own for Tasks
@@ -34,9 +33,5 @@ module ForemanTasks
       end
       options
     end
-
-    def persistence_class
-      ForemanTasks::Dynflow::Persistence
-    end
   end
 end

data/lib/foreman_tasks/engine.rb

@@ -5,14 +5,6 @@ module ForemanTasks
   class Engine < ::Rails::Engine
     engine_name 'foreman_tasks'
 
-    initializer 'foreman_tasks.load_default_settings', :before => :load_config_initializers do
-      require_dependency File.expand_path('../../app/models/setting/foreman_tasks.rb', __dir__) if begin
-                                                                                                         Setting.table_exists?
-                                                                                                   rescue
-                                                                                                     false
-                                                                                                       end
-    end
-
     assets_to_precompile = %w[foreman_tasks/foreman_tasks.css
                               foreman_tasks/foreman_tasks.js]
 
@@ -33,7 +25,7 @@ module ForemanTasks
 
     initializer 'foreman_tasks.register_plugin', :before => :finisher_hook do |_app|
       Foreman::Plugin.register :"foreman-tasks" do
-        requires_foreman '>= 2.6.0'
+        requires_foreman '>= 3.0.0'
         divider :top_menu, :parent => :monitor_menu, :last => true, :caption => N_('Foreman Tasks')
         menu :top_menu, :tasks,
              :url_hash => { :controller => 'foreman_tasks/tasks', :action => :index },
@@ -65,6 +57,60 @@ module ForemanTasks
 
         add_all_permissions_to_default_roles
 
+        settings do
+          category(:tasks, N_('Tasks')) do
+            setting('foreman_tasks_sync_task_timeout',
+                    type: :integer,
+                    description: N_('Number of seconds to wait for synchronous task to finish.'),
+                    default: 120,
+                    full_name: N_('Sync task timeout'))
+            setting('dynflow_enable_console',
+                    type: :boolean,
+                    description: N_('Enable the dynflow console (/foreman_tasks/dynflow) for debugging'),
+                    default: true,
+                    full_name: N_('Enable dynflow console'))
+            setting('dynflow_console_require_auth',
+                    type: :boolean,
+                    description: N_('Require user to be authenticated as user with admin rights when accessing dynflow console'),
+                    default: true,
+                    full_name: N_('Require auth for dynflow console'))
+            setting('foreman_tasks_proxy_action_retry_count',
+                    type: :integer,
+                    description: N_('Number of attempts to start a task on the smart proxy before failing'),
+                    default: 4,
+                    full_name: N_('Proxy action retry count'))
+            setting('foreman_tasks_proxy_action_retry_interval',
+                    type: :integer,
+                    description: N_('Time in seconds between retries'),
+                    default: 15,
+                    full_name: N_('Proxy action retry interval'))
+            setting('foreman_tasks_proxy_batch_trigger',
+                    type: :boolean,
+                    description: N_('Allow triggering tasks on the smart proxy in batches'),
+                    default: true,
+                    full_name: N_('Allow proxy batch tasks'))
+            setting('foreman_tasks_proxy_batch_size',
+                    type: :integer,
+                    description: N_('Number of tasks which should be sent to the smart proxy in one request, if foreman_tasks_proxy_batch_trigger is enabled'),
+                    default: 100,
+                    full_name: N_('Proxy tasks batch size'))
+            setting('foreman_tasks_troubleshooting_url',
+                    type: :string,
+                    description: 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.'),
+                    default: nil,
+                    full_name: N_('Tasks troubleshooting URL'))
+            setting('foreman_tasks_polling_multiplier',
+                    type: :integer,
+                    description: 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.'),
+                    default: 1,
+                    full_name: N_("Polling intervals multiplier"),
+                    validate: { numericality: { greater_than: 0 } })
+          end
+        end
+
         register_graphql_query_field :task, '::Types::Task', :record_field
         register_graphql_query_field :tasks, '::Types::Task', :collection_field
         register_graphql_query_field :recurring_logic, '::Types::RecurringLogic', :record_field
@@ -138,6 +184,7 @@ module ForemanTasks
       Authorizer.prepend AuthorizerExt
       User.include ForemanTasks::Concerns::UserExtensions
       ::Dynflow::Action::Polling.prepend ForemanTasks::Concerns::PollingActionExtensions
+      ::Dynflow::ActiveJob::QueueAdapters::JobWrapper.include Actions::TaskSynchronization
     end
 
     rake_tasks do

data/lib/foreman_tasks/tasks/export_tasks.rake

@@ -241,42 +241,35 @@ namespace :foreman_tasks do
       end
     end
 
-    def csv_export(export_filename, id_scope, task_scope)
+    def csv_export(export_filename, tasks)
       CSV.open(export_filename, 'wb') do |csv|
         csv << %w[id state type label result parent_task_id started_at ended_at 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
+        tasks.find_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
 
-    def html_export(workdir, id_scope, task_scope)
+    def html_export(workdir, tasks)
       PageHelper.copy_assets(workdir)
 
-      ids = id_scope.pluck(:id)
       renderer = TaskRender.new
-      count = 0
-      total = ids.count
+      total = tasks.count(:all)
       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|
-            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}"
+            tasks.find_each.each_with_index do |task, count|
+              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
+              puts "#{count + 1}/#{total}"
             end
           end
         end
@@ -307,7 +300,7 @@ namespace :foreman_tasks do
       end
     end
 
-    SKIP_ERRORS = ['true', '1', 'y', 'yes'].include? (ENV['SKIP_FAILED'] || '').downcase
+    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)}\" || " \
@@ -324,22 +317,21 @@ namespace :foreman_tasks do
     format = ENV['TASK_FORMAT'] || 'html'
     export_filename = ENV['TASK_FILE'] || generate_filename(format)
 
-    task_scope = ForemanTasks::Task.search_for(filter).with_duration.order(:started_at => :desc)
-    id_scope = task_scope.group(:id, :started_at)
+    tasks = ForemanTasks::Task.search_for(filter).order(:started_at => :desc).with_duration.distinct
 
     puts _("Exporting all tasks matching filter #{filter}")
-    puts _("Gathering #{id_scope.count(:all).count} tasks.")
+    puts _("Gathering #{tasks.count(:all)} tasks.")
     case format
     when 'html'
       Dir.mktmpdir('task-export') do |tmp_dir|
-        html_export(tmp_dir, id_scope, task_scope)
+        html_export(tmp_dir, tasks)
         system("tar", "czf", export_filename, tmp_dir)
       end
     when 'html-dir'
       FileUtils.mkdir_p(export_filename)
-      html_export(export_filename, id_scope, task_scope)
+      html_export(export_filename, tasks)
     when 'csv'
-      csv_export(export_filename, id_scope, task_scope)
+      csv_export(export_filename, tasks)
     else
       raise "Unkonwn export format '#{format}'"
     end

data/lib/foreman_tasks/test_helpers.rb

@@ -11,7 +11,7 @@ module ForemanTasks
       world_config = ForemanTasks.dynflow.config.world_config
       if @use_in_memory_sqlite
         world_config.persistence_adapter = lambda do |*_args|
-          ::ForemanTasks::Dynflow::Persistence.new('adapter' => 'sqlite', 'database' => ':memory:')
+          ::Dynflow::PersistenceAdapters::Sequel.new('adapter' => 'sqlite', 'database' => ':memory:')
         end
       end
       @test_in_thread_world = ::Dynflow::Testing::InThreadWorld.new(world_config)

data/lib/foreman_tasks/version.rb

@@ -1,3 +1,3 @@
 module ForemanTasks
-  VERSION = '5.2.3'.freeze
+  VERSION = '5.3.0'.freeze
 end

data/test/factories/task_factory.rb

@@ -24,7 +24,7 @@ FactoryBot.define do
         ForemanTasks::Task.where(:external_id => execution_plan.id).delete_all
         task.update!(:external_id => execution_plan.id)
         if evaluator.sync_with_dynflow
-          task.update_from_dynflow(execution_plan.to_hash)
+          task.update_from_dynflow(execution_plan)
         end
       end
 

data/test/lib/actions/middleware/keep_current_taxonomies_test.rb

@@ -15,7 +15,7 @@ module Actions
         middleware.use KeepCurrentTaxonomies
         execution_plan_hooks.use :null_hook, :on => :planning
 
-        def null_hook; end
+        def null_hook(plan); end
       end
 
       before do
@@ -78,6 +78,14 @@ module Actions
           Organization.stubs(:current=)
           Location.stubs(:current=)
 
+          org_finder = mock('organization finder')
+          org_finder.stubs(:find).with(@org.id).returns(@org)
+          Organization.stubs(:unscoped).returns(org_finder)
+
+          loc_finder = mock('location finder')
+          loc_finder.stubs(:find).with(@loc.id).returns(@loc)
+          Location.stubs(:unscoped).returns(loc_finder)
+
           triggered = ForemanTasks.trigger(TestHookAction)
           task = ForemanTasks::Task.where(:external_id => triggered.id).first
           wait_for { task.reload.state == 'stopped' }

data/test/support/dummy_dynflow_action.rb

@@ -1,5 +1,5 @@
 module Support
-  class DummyDynflowAction < Dynflow::Action
+  class DummyDynflowAction < Actions::EntryAction
   end
 
   class DummyPauseAction < Actions::EntryAction

data/test/unit/actions/trigger_proxy_batch_test.rb

@@ -46,7 +46,6 @@ module ForemanTasks
 
         it 'fetches batch_size of tasks and triggers them' do
           remote_tasks.expects(:first).with(batch_size).returns(remote_tasks)
-          remote_tasks.expects(:size).returns(batch_size)
           triggered.expects(:remote_tasks).returns(remote_tasks)
           ForemanTasks::RemoteTask.expects(:batch_trigger).with(proxy_operation_name, grouped_remote_batch)
 

data/test/unit/remote_task_test.rb

@@ -28,32 +28,6 @@ module ForemanTasks
           _(remote_task.remote_task_id).must_equal((remote_task.id + 5).to_s)
         end
       end
-
-      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).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.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
 end

data/test/unit/troubleshooting_help_generator_test.rb

@@ -21,7 +21,6 @@ module ForemanTasks
     end
 
     before do
-      Setting::ForemanTasks.load_defaults
       ::ForemanTasks::Task.delete_all
       @task = trigger_task
       Setting[:foreman_tasks_troubleshooting_url] = sample_troubleshooting_url

data/test/unit/ui_notifications_test.rb

@@ -12,7 +12,6 @@ module ForemanTasks
     end
 
     before do
-      Setting::ForemanTasks.load_defaults
       ::ForemanTasks::Task.delete_all
       load File.join(ForemanTasks::Engine.root, 'db', 'seeds.d', '30-notification_blueprints.rb')
       @admin_user = FactoryBot.create(:user, :admin)

data/webpack/ForemanTasks/Components/TaskActions/TaskActionHelpers.js

@@ -1,5 +1,5 @@
 import { translate as __, sprintf } from 'foremanReact/common/I18n';
-import { addToast } from 'foremanReact/redux/actions/toasts';
+import { addToast } from 'foremanReact/components/ToastsList';
 import { TASKS_DASHBOARD_JS_QUERY_MODES } from '../TasksDashboard/TasksDashboardConstants';
 import { timeToHoursNumber } from '../TasksDashboard/TasksDashboardHelper';
 import {

data/webpack/ForemanTasks/Components/TaskActions/index.js

@@ -1,6 +1,6 @@
 import { sprintf } from 'foremanReact/common/I18n';
 import { API } from 'foremanReact/redux/API';
-import { addToast } from 'foremanReact/redux/actions/toasts';
+import { addToast } from 'foremanReact/components/ToastsList';
 import {
   TASKS_RESUME_REQUEST,
   TASKS_RESUME_SUCCESS,

data/webpack/ForemanTasks/Components/TaskDetails/Components/Locks.js

@@ -3,6 +3,18 @@ import PropTypes from 'prop-types';
 import { Alert, Card, Row, Col } from 'patternfly-react';
 import { translate as __ } from 'foremanReact/common/I18n';
 
+const ConditionalLink = ({ children, link }) =>
+  link ? <a href={link}>{children}</a> : children;
+
+ConditionalLink.propTypes = {
+  children: PropTypes.node.isRequired,
+  link: PropTypes.string,
+};
+
+ConditionalLink.defaultProps = {
+  link: null,
+};
+
 const Locks = ({ locks }) => (
   <div>
     <Alert type="info">
@@ -14,20 +26,22 @@ const Locks = ({ locks }) => (
       <Row>
         {locks.map((lock, key) => (
           <Col xs={6} sm={4} md={4} key={key}>
-            <Card className="card-pf-aggregate-status" accented>
-              <Card.Title>
-                <span
-                  className={`fa ${
-                    lock.exclusive ? 'fa-lock' : 'fa-unlock-alt'
-                  }`}
-                />
-                {lock.resource_type}
-              </Card.Title>
-              <Card.Body>
-                {`id:${lock.resource_id}`}
-                <br />
-              </Card.Body>
-            </Card>
+            <ConditionalLink link={lock.link}>
+              <Card className="card-pf-aggregate-status" accented>
+                <Card.Title>
+                  <span
+                    className={`fa ${
+                      lock.exclusive ? 'fa-lock' : 'fa-unlock-alt'
+                    }`}
+                  />
+                  {lock.resource_type}
+                </Card.Title>
+                <Card.Body>
+                  {`id:${lock.resource_id}`}
+                  <br />
+                </Card.Body>
+              </Card>
+            </ConditionalLink>
           </Col>
         ))}
       </Row>

data/webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/__snapshots__/Locks.test.js.snap

@@ -25,29 +25,33 @@ exports[`Locks rendering render with Props 1`] = `
         sm={4}
         xs={6}
       >
-        <Card
-          accented={true}
-          aggregated={false}
-          aggregatedMini={false}
-          cardRef={null}
-          className="card-pf-aggregate-status"
-          matchHeight={false}
+        <ConditionalLink
+          link={null}
         >
-          <CardTitle
-            className=""
+          <Card
+            accented={true}
+            aggregated={false}
+            aggregatedMini={false}
+            cardRef={null}
+            className="card-pf-aggregate-status"
+            matchHeight={false}
           >
-            <span
-              className="fa fa-unlock-alt"
-            />
-            User
-          </CardTitle>
-          <CardBody
-            className=""
-          >
-            id:4
-            <br />
-          </CardBody>
-        </Card>
+            <CardTitle
+              className=""
+            >
+              <span
+                className="fa fa-unlock-alt"
+              />
+              User
+            </CardTitle>
+            <CardBody
+              className=""
+            >
+              id:4
+              <br />
+            </CardBody>
+          </Card>
+        </ConditionalLink>
       </Col>
       <Col
         bsClass="col"
@@ -57,29 +61,33 @@ exports[`Locks rendering render with Props 1`] = `
         sm={4}
         xs={6}
       >
-        <Card
-          accented={true}
-          aggregated={false}
-          aggregatedMini={false}
-          cardRef={null}
-          className="card-pf-aggregate-status"
-          matchHeight={false}
+        <ConditionalLink
+          link={null}
         >
-          <CardTitle
-            className=""
-          >
-            <span
-              className="fa fa-unlock-alt"
-            />
-            User
-          </CardTitle>
-          <CardBody
-            className=""
+          <Card
+            accented={true}
+            aggregated={false}
+            aggregatedMini={false}
+            cardRef={null}
+            className="card-pf-aggregate-status"
+            matchHeight={false}
           >
-            id:2
-            <br />
-          </CardBody>
-        </Card>
+            <CardTitle
+              className=""
+            >
+              <span
+                className="fa fa-unlock-alt"
+              />
+              User
+            </CardTitle>
+            <CardBody
+              className=""
+            >
+              id:2
+              <br />
+            </CardBody>
+          </Card>
+        </ConditionalLink>
       </Col>
     </Row>
   </CardGrid>

data/webpack/ForemanTasks/Components/TaskDetails/TaskDetailsActions.js

@@ -1,5 +1,5 @@
 import { post, get } from 'foremanReact/redux/API';
-import { addToast } from 'foremanReact/redux/actions/toasts';
+import { addToast } from 'foremanReact/components/ToastsList';
 import { translate as __ } from 'foremanReact/common/I18n';
 import {
   withInterval,

data/webpack/ForemanTasks/Components/TasksTable/TasksBulkActions.js

@@ -1,5 +1,5 @@
 import { API } from 'foremanReact/redux/API';
-import { addToast } from 'foremanReact/redux/actions/toasts';
+import { addToast } from 'foremanReact/components/ToastsList';
 import { translate as __, sprintf } from 'foremanReact/common/I18n';
 import {
   BULK_CANCEL_PATH,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foreman-tasks
 version: !ruby/object:Gem::Version
-  version: 5.2.3
+  version: 5.3.0
 platform: ruby
 authors:
 - Ivan Nečas
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-21 00:00:00.000000000 Z
+date: 2021-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dynflow
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.3
+        version: 1.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.3
+        version: 1.6.0
 - !ruby/object:Gem::Dependency
   name: get_process_mem
   requirement: !ruby/object:Gem::Requirement
@@ -166,6 +166,7 @@ files:
 - app/lib/actions/proxy_action.rb
 - app/lib/actions/recurring_action.rb
 - app/lib/actions/serializers/active_record_serializer.rb
+- app/lib/actions/task_synchronization.rb
 - app/lib/actions/trigger_proxy_batch.rb
 - app/lib/foreman_tasks/concerns/polling_action_extensions.rb
 - app/lib/proxy_api/foreman_dynflow/dynflow_proxy.rb
@@ -188,7 +189,6 @@ files:
 - app/models/foreman_tasks/task_group_member.rb
 - app/models/foreman_tasks/task_groups/recurring_logic_task_group.rb
 - app/models/foreman_tasks/triggering.rb
-- app/models/setting/foreman_tasks.rb
 - app/services/foreman_tasks/proxy_selector.rb
 - app/services/foreman_tasks/troubleshooting_help_generator.rb
 - app/services/ui_notifications/tasks.rb
@@ -250,7 +250,9 @@ files:
 - db/migrate/20200517215015_rename_bookmarks_controller.rb
 - db/migrate/20200519093217_drop_dynflow_allow_dangerous_actions_setting.foreman_tasks.rb
 - db/migrate/20200611090846_add_task_lock_index_on_resource_type_and_task_id.rb
+- db/migrate/20210708123832_add_parent_task_id_to_remote_tasks.foreman_tasks.rb
 - db/migrate/20210720115251_add_purpose_to_recurring_logic.rb
+- db/migrate/20211123170430_tasks_settings_to_dsl_category.rb
 - db/seeds.d/20-foreman_tasks_permissions.rb
 - db/seeds.d/30-notification_blueprints.rb
 - db/seeds.d/60-dynflow_proxy_feature.rb
@@ -271,7 +273,6 @@ files:
 - lib/foreman_tasks/dynflow.rb
 - lib/foreman_tasks/dynflow/configuration.rb
 - lib/foreman_tasks/dynflow/console_authorizer.rb
-- lib/foreman_tasks/dynflow/persistence.rb
 - lib/foreman_tasks/engine.rb
 - lib/foreman_tasks/task_error.rb
 - lib/foreman_tasks/tasks/cleanup.rake
@@ -572,6 +573,7 @@ files:
 - webpack/__mocks__/foremanReact/components/ForemanModal/index.js
 - webpack/__mocks__/foremanReact/components/Layout/LayoutActions.js
 - webpack/__mocks__/foremanReact/components/Pagination/PaginationWrapper.js
+- webpack/__mocks__/foremanReact/components/ToastsList/index.js
 - webpack/__mocks__/foremanReact/components/common/ActionButtons/ActionButtons.js
 - webpack/__mocks__/foremanReact/components/common/MessageBox.js
 - webpack/__mocks__/foremanReact/components/common/dates/LongDateTime.js
@@ -581,7 +583,6 @@ files:
 - webpack/__mocks__/foremanReact/constants.js
 - webpack/__mocks__/foremanReact/redux/API/APISelectors.js
 - webpack/__mocks__/foremanReact/redux/API/index.js
-- webpack/__mocks__/foremanReact/redux/actions/toasts.js
 - webpack/__mocks__/foremanReact/redux/middlewares/IntervalMiddleware.js
 - webpack/__mocks__/foremanReact/routes/common/PageLayout/PageLayout.js
 - webpack/__mocks__/foremanReact/routes/common/PageLayout/components/ExportButton/ExportButton.js
@@ -607,7 +608,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.1.2
 signing_key:
 specification_version: 4
 summary: Foreman plugin for showing tasks information for resources and users

data/app/models/setting/foreman_tasks.rb

@@ -1,29 +0,0 @@
-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, N_('Sync task timeout')),
-      set('dynflow_enable_console', N_('Enable the dynflow console (/foreman_tasks/dynflow) for debugging'), true, N_('Enable dynflow console')),
-      set('dynflow_console_require_auth', N_('Require user to be authenticated as user with admin rights when accessing dynflow console'), true, N_('Require auth for dynflow console')),
-      set('foreman_tasks_proxy_action_retry_count', N_('Number of attempts to start a task on the smart proxy before failing'), 4, N_('Proxy action retry count')),
-      set('foreman_tasks_proxy_action_retry_interval', N_('Time in seconds between retries'), 15, N_('Proxy action retry interval')),
-      set('foreman_tasks_proxy_batch_trigger', N_('Allow triggering tasks on the smart proxy in batches'), true, N_('Allow proxy batch tasks')),
-      set('foreman_tasks_proxy_batch_size', N_('Number of tasks which should be sent to the smart proxy in one request, if foreman_tasks_proxy_batch_trigger is enabled'), 100, N_('Proxy tasks batch size')),
-      set('foreman_tasks_troubleshooting_url',
-          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, N_('Tasks troubleshooting URL')),
-      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/lib/foreman_tasks/dynflow/persistence.rb

@@ -1,46 +0,0 @@
-module ForemanTasks
-  # Wrap the Dynflow persistence to reflect the changes to execution plan
-  # in the Task model. This is probably a temporary solution and
-  # Dynflow will probably get more events-based API but it should be enought
-  # for start, until the requiements on the API are clear enough.
-  class Dynflow::Persistence < ::Dynflow::PersistenceAdapters::Sequel
-    def save_execution_plan(execution_plan_id, value)
-      # clear connection only if not running in some active record transaction already
-      clear_connections = ActiveRecord::Base.connection.open_transactions.zero?
-      super.tap do
-        on_execution_plan_save(execution_plan_id, value)
-      rescue => e
-        Foreman::Logging.exception('Error on on_execution_plan_save event', e,
-                                   :logger => 'dynflow')
-      end
-    ensure
-      ::ActiveRecord::Base.clear_active_connections! if clear_connections
-    end
-
-    def on_execution_plan_save(execution_plan_id, data)
-      # We can load the data unless the execution plan was properly planned and saved
-      # including its steps
-      case data[:state]
-      when :pending
-        task = ForemanTasks::Task::DynflowTask.new_for_execution_plan(execution_plan_id, data)
-        task.start_at ||= Time.zone.now
-        task.save!
-      when :scheduled
-        delayed_plan = 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(data.merge(:start_at => delayed_plan[:start_at],
-                                            :start_before => delayed_plan[:start_before]))
-      when :planning
-        task = ::ForemanTasks::Task::DynflowTask.where(:external_id => execution_plan_id).first
-        task.update_from_dynflow(data)
-      else
-        if (task = ::ForemanTasks::Task::DynflowTask.where(:external_id => execution_plan_id).first)
-          unless task.state.to_s == data[:state].to_s
-            task.update_from_dynflow(data)
-          end
-        end
-      end
-    end
-  end
-end