foreman-tasks 5.2.0 → 5.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa2189368cc093a6ca613ca1b91add99bc3689b2cb22cd0c04a3718821b5f27f
-  data.tar.gz: f7e82294bbbb76fe6576b6c2de9e55c16342962f711a8e5c9070787be304a87c
+  metadata.gz: 6f5ae3bb36274977790149d11f722477d6db0254b251ffa1dc79ec850a206183
+  data.tar.gz: bfd76d0fcc43a78e34c1831a392042e5770bd09276d95d126043f3a14db174b7
 SHA512:
-  metadata.gz: f20e5fba4dbc2401a4fed1f5eb68961ccc7095071fc309316ad14392b9209141e96aa2372eb7bb5db0e7f829ef08727ff2e232e53de86baa8385183ddb722252
-  data.tar.gz: 534ac74d1c8010ac25330562a6bdb713beacc413d2c681ee72f865727741cfb17e04d9dda2c0ea8ab7bde2f7f2e08f54fa4266e25686ca9d1f38c5309b24b94c
+  metadata.gz: b2bde1cb649304ba13019b544c8db8f7fa72b2e0539d47b2db07d6e945364d08b4e5fa0b100b701aa7f080e8be308ad7a6af404eaee2865e7b13fd423f9a9300
+  data.tar.gz: 00a77aaf192bbfc12a70dc034aa75bfd728c18956b1b9377bbef3d7fce7491c68cfa520d9fd04de4789c721fcc2d2b2b605b63a9165601092841e44184219dfc

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,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/remote_task.rb

@@ -32,20 +32,27 @@ module ForemanTasks
                                                        :action_class => remote_task.proxy_action_name })
         end
         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] }
+        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/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/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.0'.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/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.0
+  version: 5.3.0
 platform: ruby
 authors:
 - Ivan Nečas
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-11 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

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