foreman-tasks 5.0.0 → 5.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e48966ae6049eb85b3051151b7d15d48beb91a55b3580525fe114a3e045ad0f
-  data.tar.gz: 93da446f348f1a27600a79223ba4daab0e5e83417db711919392cfab2eedf57a
+  metadata.gz: 6f5ae3bb36274977790149d11f722477d6db0254b251ffa1dc79ec850a206183
+  data.tar.gz: bfd76d0fcc43a78e34c1831a392042e5770bd09276d95d126043f3a14db174b7
 SHA512:
-  metadata.gz: 740ff700f75e43154068d3838611dc7c7306d7f5da91e3d2d41a6fce5ea0ccde84bd5f027545f24874b8fb112d9848505ae2a535386ee2f356852695dacd61a2
-  data.tar.gz: 8f61c3c868af4b7c3d3173b728858537c72ccf695e60b63971ec19f8a675a6ad9c19ecdd3dedb2549e2eb27b7cde62a2be67ead4d737bb43b774301abb303228
+  metadata.gz: b2bde1cb649304ba13019b544c8db8f7fa72b2e0539d47b2db07d6e945364d08b4e5fa0b100b701aa7f080e8be308ad7a6af404eaee2865e7b13fd423f9a9300
+  data.tar.gz: 00a77aaf192bbfc12a70dc034aa75bfd728c18956b1b9377bbef3d7fce7491c68cfa520d9fd04de4789c721fcc2d2b2b605b63a9165601092841e44184219dfc

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

@@ -192,7 +192,7 @@ module ForemanTasks
           params[:order] = "#{ordering_params[:sort_by]} #{ordering_params[:sort_order]}"
         end
         params[:order] ||= 'started_at DESC'
-        @tasks = DashboardTableFilter.new(resource_scope_for_index, params).scope.order(params[:order].to_s)
+        @tasks = resource_scope_for_index.order(params[:order].to_s)
       end
 
       def search_options
@@ -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
@@ -127,8 +127,9 @@ module ForemanTasks
     end
 
     def filter(scope, paginate: true)
-      scope = DashboardTableFilter.new(scope, params).scope
-      scope = scope.search_for(search_query, order: params[:order])
+      search = current_taxonomy_search
+      search = [search, params[:search]].select(&:present?).join(' AND ')
+      scope = scope.search_for(search, order: params[:order])
       scope = scope.paginate(page: params[:page], per_page: params[:per_page]) if paginate
       scope.distinct
     end

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,12 +3,15 @@ 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
     field :max_iteration, Integer
     field :iteration, Integer
     field :state, String
+    field :purpose, String
     belongs_to :triggering, Types::Triggering
 
     def self.graphql_definition

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

@@ -20,33 +20,38 @@ module Actions
       private
 
       def set_clock
-        action.world.clock.ping action.send(:suspended_action),
-                                POLL_INTERVAL,
-                                CheckOnProxyActions
+        action.plan_event(CheckOnProxyActions, POLL_INTERVAL, optional: true)
       end
 
       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
 
       def notify(event, tasks)
         tasks.each do |task|
-          action.world.event task.execution_plan_id,
-                             task.step_id,
-                             event
+          action.plan_event(event, execution_plan_id: task.execution_plan_id, step_id: task.step_id)
         end
       end
 
@@ -56,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
@@ -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

@@ -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)
+        output[:planned_count] += group.size
+      end
+    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

@@ -17,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
@@ -169,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
@@ -189,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/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