foreman-tasks 5.2.2 → 6.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 882587333f9ebd555b6bd0ca6adf6c9e75789fce2e84cbbc2e3af0943cdf0051
-  data.tar.gz: 1db069d66971fed8af95856a2d582b1320c02c48fddec68f9f9a1061abc6965c
+  metadata.gz: 7fe4afd0fbe9eaa5cb5587310ddddd1538453e733b48b6f927e6bc14fa4ad42e
+  data.tar.gz: 27591131ac0329e66625a15c4b512fa7a24b23b3623abdc1eaef40fee7bdea9a
 SHA512:
-  metadata.gz: b204e43fe719216b44377fa0eb69654a404dfc7d53fbd5ed803efca3f5dd649d2dc901abd1b29b4048c1f99f7a37bd1b94c5c349ae9844e08ae95bd86a942b35
-  data.tar.gz: 90c69b77188a55d8d993a6e098945448dce1ff720697def8ea1914ba2c03fe2ed7efec30b4a7e33224afa9b32d3b9f1c8eb4fd37cdee37566321e69d67d78b1a
+  metadata.gz: 042c221e1f3c01b2d38b2011165479282165846d9b46923b5ef7cc4fc8f91c3ab6ff5921bd229a4a26dbf661dccff3a9d0f0d474e11eb18b074880fc8fc25870
+  data.tar.gz: 4fdf7dfc1836bd8b4ea0490f8c7a894569c7ccf9eca811945b517f7aedface6b04c0c6bbe9c7f34a7b7bbea77328edaadd27ebb624bc29c4acae2eb86bc25624

data/.github/workflows/ruby_tests.yml

@@ -4,6 +4,7 @@ env:
   RAILS_ENV: test
   DATABASE_URL: postgresql://postgres:@localhost/test
   DATABASE_CLEANER_ALLOW_REMOTE_DATABASE_URL: true
+  BUNDLE_WITHOUT: "journald:development:console:mysql2:sqlite:libvirt"
 jobs:
   rubocop:
     runs-on: ubuntu-latest
@@ -13,10 +14,7 @@ jobs:
         uses: ruby/setup-ruby@v1
         with:
           ruby-version: 2.7
-      - name: Setup
-        run: |
-          gem install bundler
-          bundle install --jobs=3 --retry=3
+          bundler-cache: true
       - name: Run rubocop
         run: bundle exec rubocop
   test_ruby:
@@ -43,30 +41,21 @@ jobs:
       - uses: actions/checkout@v2
         with:
           path: foreman-tasks
+      - name: Setup Plugin in Foreman
+        run: |
+          echo "gem 'foreman-tasks', path: './foreman-tasks'" > bundler.d/foreman-tasks.local.rb
+          echo "gem 'sqlite3'" >> bundler.d/foreman-tasks.local.rb
       - name: Setup Ruby
         uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
       - name: Setup Node
         uses: actions/setup-node@v1
         with:
           node-version:  ${{ matrix.node-version }}
-      - uses: actions/cache@v2
-        with:
-          path: vendor/bundle
-          key: ${{ runner.os }}-fgems-${{ matrix.ruby-version }}-${{ hashFiles('Gemfile.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-fgems-${{ matrix.ruby-version }}-
-      - name: Setup Bundler
-        run: |
-          echo "gem 'foreman-tasks', path: './foreman-tasks'" > bundler.d/foreman-tasks.local.rb
-          echo "gem 'sqlite3'" >> bundler.d/foreman-tasks.local.rb
-          gem install bundler
-          bundle config set without journald development console libvirt
-          bundle config set path vendor/bundle
       - name: Prepare test env
         run: |
-          bundle install --jobs=3 --retry=3
           bundle exec rake db:create
           bundle exec rake db:migrate
       - name: Run plugin tests

data/.rubocop.yml

@@ -9,6 +9,7 @@ AllCops:
   Exclude:
     - 'node_modules/**/*'
     - 'locale/*'
+    - 'vendor/**/*'
   TargetRubyVersion: 2.5
 
 Lint/ShadowingOuterLocalVariable:

data/app/lib/actions/base.rb

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

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

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

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

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

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

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

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

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

data/app/lib/actions/proxy_action.rb

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

data/app/models/foreman_tasks/lock.rb

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

data/app/models/foreman_tasks/remote_task.rb

@@ -33,20 +33,27 @@ module ForemanTasks
                                                        :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] }
+        group.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'
+require File.expand_path('lib/foreman/dynflow/configuration', ::Rails.root)
 
 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/dynflow.rb

@@ -17,7 +17,7 @@ module ForemanTasks
         set(:custom_navigation) do
           { _('Back to tasks') => "/#{ForemanTasks::TasksController.controller_path}" }
         end
-        set(:world) { Rails.application.dynflow.world }
+        set(:world) { ::Rails.application.dynflow.world }
       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.2.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.2'.freeze
+  VERSION = '6.0.1'.freeze
 end

data/locale/action_names.rb

@@ -1,6 +1,5 @@
 # Autogenerated!
-_("Preupgrade job")
-_("Remote action:")
 _("Import Puppet classes")
 _("Import facts")
-_("Action with sub plans")
+_("Action with sub plans")
+_("Remote action:")