foreman-tasks 3.0.2 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c51f734a6c321d30bd6c3aa93499d9924b93435cadfd48bf129452758ed88338
-  data.tar.gz: ffd67ecf17550277bf7bcbc86f8fb98a1ac566c1d386350ff4ed1aa97ffad9e3
+  metadata.gz: 99321b6a250c3166881128f05a88feb20cf24cc14e6ccbf813e5cc1853f4447a
+  data.tar.gz: 99ce5e8f81c1dbbdf41a6980b0ff4cb98529928dfd0769676821e6c71f8e2302
 SHA512:
-  metadata.gz: 68b31fa072fbf39a1bd93184dfd6a0588270f897ba4a546d79a4f25be2e5815473eedf9a2975eb57c5344a024f7581e8427f39219af00cf6478ce0697b9fb403
-  data.tar.gz: b531f627380fc77b93c930b6b22051b60e4adad8861cc137cbedfee30237e05fa70a1226b1651b4e7268bd618816a3256ba8b2993a27b5bf04771c3f73c776da
+  metadata.gz: 7284f7dd3ff25480f57f697ebe57cbff5f6b865afd1e6792c710ea880bc23f0a6f261333c727a7917be9a30c9d1de54d7e4bfeebc9bc43635244fdd1ca8f5d79
+  data.tar.gz: 6580dd94504e0d9c5cf8f2d070bb42da3782feadbdba59ee9f1275e526b5b53b1cb34106163807f99eac09b59ba8991ea2f51bb224184007f7aee4bf30808553

data/.github/workflows/ruby_tests.yml

@@ -12,7 +12,7 @@ jobs:
       - name: Setup Ruby
         uses: ruby/setup-ruby@v1
         with:
-          ruby-version: 2.6
+          ruby-version: 2.7
       - name: Setup
         run: |
           gem install bundler
@@ -31,7 +31,7 @@ jobs:
       fail-fast: false
       matrix:
         foreman-core-branch: [develop]
-        ruby-version: [2.5, 2.6]
+        ruby-version: [2.5, 2.6, 2.7]
         node-version: [12]
     steps:
       - run: sudo apt-get update
@@ -60,6 +60,7 @@ jobs:
       - 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
@@ -70,5 +71,6 @@ jobs:
           bundle exec rake db:migrate
       - name: Run plugin tests
         run: |
-          bundle exec rake test:foreman-tasks
+          bundle exec rake test:foreman_tasks
+          bundle exec rake test:foreman_tasks_core
           bundle exec rake test TEST="test/unit/foreman/access_permissions_test.rb"

data/app/controllers/foreman_tasks/api/tasks_controller.rb

@@ -75,11 +75,16 @@ module ForemanTasks
       end
 
       api :POST, '/tasks/bulk_resume', N_('Resume all paused error tasks')
+      desc <<~DOC
+        Resumes all selected resumable tasks. If neither a search query nor an
+        explicit list of task IDs is provided, it tries to resume all tasks in
+        paused state with result error.
+      DOC
       param :search, String, :desc => N_('Resume tasks matching search string')
       param :task_ids, Array, :desc => N_('Resume specific tasks by ID')
       def bulk_resume
         if params[:search].nil? && params[:task_ids].nil?
-          raise BadRequest, _('Please provide at least one of search or task_ids parameters in the request')
+          params[:search] = 'state = paused and result = error'
         end
         resumed = []
         failed = []
@@ -109,9 +114,14 @@ module ForemanTasks
         }
       end
 
-      api :POST, '/tasks/bulk_cancel', N_('Cancel all cancellable tasks')
+      api :POST, '/tasks/bulk_cancel', N_('Cancel selected cancellable tasks')
+      desc <<~DOC
+        Cancels all selected cancellable tasks. Requires a search query or an
+        explicit list of task IDs to be provided.
+      DOC
       param :search, String, :desc => N_('Cancel tasks matching search string')
       param :task_ids, Array, :desc => N_('Cancel specific tasks by ID')
+      error :bad_request, 'Returned if neither search nor task_ids parameter is provided.'
       def bulk_cancel
         if params[:search].nil? && params[:task_ids].nil?
           raise BadRequest, _('Please provide at least one of search or task_ids parameters in the request')
@@ -130,9 +140,14 @@ module ForemanTasks
         }
       end
 
-      api :POST, '/tasks/bulk_stop', N_('Stop all stoppable tasks')
+      api :POST, '/tasks/bulk_stop', N_('Stop selected stoppable tasks')
+      desc <<~DOC
+        Stops all selected tasks which are not already stopped. Requires a
+        search query or an explicit list of task IDs to be provided.
+      DOC
       param :search, String, :desc => N_('Stop tasks matching search string')
       param :task_ids, Array, :desc => N_('Stop specific tasks by ID')
+      error :bad_request, 'Returned if neither search nor task_ids parameter is provided.'
       def bulk_stop
         if params[:search].nil? && params[:task_ids].nil?
           raise BadRequest, _('Please provide at least one of search or task_ids parameters in the request')
@@ -238,10 +253,7 @@ module ForemanTasks
           if search_params[:user_id].blank?
             raise BadRequest, _('User search_params requires user_id to be specified')
           end
-          scope.joins(:locks).where(foreman_tasks_locks:
-                                        { name:          ::ForemanTasks::Lock::OWNER_LOCK_NAME,
-                                          resource_type: 'User',
-                                          resource_id:   search_params[:user_id] })
+          scope.search_for("user_id = #{search_params[:user_id]}")
         when 'resource'
           if search_params[:resource_type].blank? || search_params[:resource_id].blank?
             raise BadRequest,

data/app/lib/actions/entry_action.rb

@@ -3,6 +3,8 @@ module Actions
     include Helpers::ArgsSerialization
     include Helpers::Lock
 
+    execution_plan_hooks.use :drop_all_locks!, :on => :stopped
+
     # what locks to use on the resource? All by default, can be overriden.
     # It might one or more locks available for the resource. This following
     # special values are supported as well:
@@ -34,12 +36,10 @@ module Actions
       input.update serialize_args(resource, *resource.all_related_resources, *additional_args)
 
       if resource.is_a? ActiveRecord::Base
-        if resource_locks == :exclusive
-          exclusive_lock!(resource)
-        elsif resource_locks == :link
+        if resource_locks == :link
           link!(resource)
         else
-          lock!(resource, resource_locks)
+          exclusive_lock!(resource)
         end
       end
     end
@@ -63,5 +63,9 @@ module Actions
     def self.serializer_class
       Serializers::ActiveRecordSerializer
     end
+
+    def drop_all_locks!(_execution_plan)
+      ForemanTasks::Lock.where(:task_id => task.id).destroy_all
+    end
   end
 end

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

@@ -4,19 +4,25 @@ module Actions
       # @see Lock.exclusive!
       def exclusive_lock!(resource)
         phase! Dynflow::Action::Plan
-        ::ForemanTasks::Lock.exclusive!(resource, task.id)
+        parent_lock = ::ForemanTasks::Lock.for_resource(resource).where(:task_id => task.self_and_parents.map(&:id)).first
+        if parent_lock
+          ForemanTasks::Link.link_resource_and_related!(resource, task)
+          parent_lock
+        else
+          ::ForemanTasks::Lock.exclusive!(resource, task)
+        end
       end
 
       # @see Lock.lock!
-      def lock!(resource, *lock_names)
-        phase! Dynflow::Action::Plan
-        ::ForemanTasks::Lock.lock!(resource, task.id, *lock_names.flatten)
+      def lock!(resource, *_lock_names)
+        Foreman::Deprecation.deprecation_warning('2.4', 'locking in foreman-tasks was reworked, please use a combination of exclusive_lock! and link! instead.')
+        exclusive_lock!(resource)
       end
 
       # @see Lock.link!
       def link!(resource)
         phase! Dynflow::Action::Plan
-        ::ForemanTasks::Lock.link!(resource, task.id)
+        ::ForemanTasks::Link.link!(resource, task)
       end
     end
   end

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

@@ -21,7 +21,10 @@ module Actions
 
       # Run all execution plan lifecycle hooks as the original request_id
       def hook(*args)
-        restore_current_request_id { pass(*args) }
+        store_current_request_id if !action.input.key?(:current_request_id) && ::Logging.mdc['request']
+        restore_current_request_id do
+          pass(*args)
+        end
       end
 
       private

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

@@ -16,9 +16,19 @@ module Actions
       end
 
       def finalize
+        current_id = User.current.try(:id)
+        saved_id = action.input[:current_user_id]
+        if User.current && saved_id && current_id != saved_id
+          Foreman::Deprecation.deprecation_warning('2.5', 'relying on per-step setting of current user in finalize phase')
+        end
+
         restore_curent_user { pass }
       end
 
+      def finalize_phase(execution_plan, *args)
+        restore_curent_user(execution_plan.entry_action) { pass(execution_plan, *args) }
+      end
+
       # Run all execution plan lifecycle hooks as the original user
       def hook(*args)
         restore_curent_user { pass(*args) }
@@ -38,7 +48,7 @@ module Actions
         action.input[:current_user_id] = User.current.try(:id)
       end
 
-      def restore_curent_user
+      def restore_curent_user(action = self.action)
         old_user = User.current
         User.current = User.unscoped.find(action.input[:current_user_id]) if action.input[:current_user_id].present?
         yield

data/app/lib/actions/observable_action.rb

@@ -0,0 +1,80 @@
+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 ObservableAction
+    module ClassMethods
+      def event_name_suffix(hook)
+        case hook
+        when :success
+          'succeeded'
+        when :failure
+          'failed'
+        else
+          hook
+        end
+      end
+
+      def event_names
+        [event_name_base + '_' + event_name_suffix(:success)]
+      end
+
+      def namespaced_event_names
+        event_names.map { |e| ::Foreman::Observable.event_name_for(e) }
+      end
+
+      def event_name_base
+        to_s.underscore.tr('/', '.')
+      end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.include ::Foreman::Observable
+      base.execution_plan_hooks.use :emit_event, :on => :success
+    end
+
+    def emit_event(execution_plan, hook = :success)
+      return unless root_action?
+
+      trigger_hook "#{self.class.event_name_base}_#{self.class.event_name_suffix(hook)}",
+                   payload: event_payload(execution_plan)
+    end
+
+    def event_payload(_execution_plan)
+      { object: self }
+    end
+
+    extend ApipieDSL::Module
+
+    apipie :class, "An common ancestor action for observable actions" do
+      name 'Actions::ObservableAction'
+      refs 'Actions::ObservableAction'
+      sections only: %w[all webhooks]
+      property :task, object_of: 'Task', desc: 'Returns the task to which this action belongs'
+    end
+    class Jail < Safemode::Jail
+      allow :task
+    end
+  end
+end

data/app/lib/actions/proxy_action.rb

@@ -218,10 +218,8 @@ module Actions
     end
 
     def get_proxy_data(response)
-      proxy_data = response['actions'].detect do |action|
-        action['class'] == proxy_action_name || action.fetch('input', {})['proxy_operation_name'] == proxy_operation_name
-      end
-      proxy_data.fetch('output', {})
+      response['actions'].detect { |action| action.fetch('input', {})['task_id'] == task.id }
+                         .try(:fetch, 'output', {})
     end
 
     def proxy_version(proxy)

data/app/models/foreman_tasks/concerns/action_subject.rb

@@ -3,12 +3,6 @@ module ForemanTasks
     module ActionSubject
       extend ActiveSupport::Concern
 
-      module ClassMethods
-        def available_locks
-          [:read, :write]
-        end
-      end
-
       def action_input_key
         self.class.name.demodulize.underscore
       end

data/app/models/foreman_tasks/link.rb

@@ -0,0 +1,60 @@
+module ForemanTasks
+  class Link < ApplicationRecord
+    belongs_to :task
+
+    belongs_to :resource, polymorphic: true
+
+    scope :for_resource, ->(resource) { where(:resource => resource) }
+
+    validates :task_id, :resource_id, :resource_type, presence: true
+
+    class << self
+      # Assigns the resource to the task to easily track the task in context of
+      # the resource. This doesn't prevent other actions to lock the resource
+      # and should be used only for actions that tolerate other actions to be
+      # performed on the resource. Usually, this shouldn't needed to be done
+      # through the action directly, because the lock should assign it's parent
+      # objects to the action recursively (using +related_resources+ method in model
+      # objects)
+      def link!(resource, task)
+        link = build(resource, task)
+        link.save!
+        link
+      end
+
+      # Records the information about the user that triggered the task
+      def owner!(user, task)
+        link!(user, task)
+      end
+
+      def link_resource_and_related!(resource, task)
+        link!(resource, task)
+        build_related_links(resource, task).each(&:save!)
+      end
+
+      def build_related_links(resource, task)
+        related_resources(resource).map do |related_resource|
+          build(related_resource, task)
+        end
+      end
+
+      private
+
+      def build(resource, task)
+        find_or_initialize_by(task_id:       task.id,
+                              resource_type: resource.class.name,
+                              resource_id:   resource.id)
+      end
+
+      # recursively search for related resources of the resource (using
+      # the +related_resources+ method, avoiding the cycles
+      def related_resources(resource)
+        if resource.respond_to?(:all_related_resources)
+          resource.all_related_resources
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/app/models/foreman_tasks/lock.rb

@@ -1,14 +1,5 @@
 module ForemanTasks
   class Lock < ApplicationRecord
-    LINK_LOCK_NAME  = :link_resource
-    OWNER_LOCK_NAME = :task_owner
-
-    # not really intended to be created in database, but it's used for
-    # explicitly stating that the all the locks for resource should be used
-    ALL_LOCK_NAME   = :all
-
-    RESERVED_LOCK_NAMES = [LINK_LOCK_NAME, OWNER_LOCK_NAME, ALL_LOCK_NAME].freeze
-
     class LockConflict < StandardError
       attr_reader :required_lock, :conflicting_locks
       def initialize(required_lock, conflicting_locks)
@@ -16,7 +7,6 @@ module ForemanTasks
         | #{_('Required lock is already taken by other running tasks.')}
         | #{_('Please inspect their state, fix their errors and resume them.')}
         |
-        | #{_('Required lock: %s') % required_lock.name}
         | #{_('Conflicts with tasks:')}
         HEADER
         url_helpers = Rails.application.routes.url_helpers
@@ -36,30 +26,28 @@ module ForemanTasks
 
     belongs_to :resource, polymorphic: true
 
-    scope :active, -> { joins(:task).where('foreman_tasks_tasks.state != ?', :stopped) }
-
-    validates :task_id, :name, :resource_id, :resource_type, presence: true
+    validates :task_id, :resource_id, :resource_type, presence: true
 
     validate do
-      raise LockConflict.new(self, colliding_locks) unless available?
+      if (locks = colliding_locks).any?
+        raise LockConflict.new(self, locks)
+      end
     end
 
-    # returns true if it's possible to aquire this kind of lock
-    def available?
-      !colliding_locks.exists?
-    end
+    scope :for_resource, ->(resource) { where(:resource => resource) }
 
     # returns a scope of the locks colliding with this one
     def colliding_locks
       task_ids = task.self_and_parents.map(&:id)
-      colliding_locks_scope = Lock.active.where(Lock.arel_table[:task_id].not_in(task_ids))
-      colliding_locks_scope = colliding_locks_scope.where(name:          name,
-                                                          resource_id:   resource_id,
-                                                          resource_type: resource_type)
-      unless exclusive?
-        colliding_locks_scope = colliding_locks_scope.where(:exclusive => true)
-      end
-      colliding_locks_scope
+      colliding_locks_scope = Lock.where(Lock.arel_table[:task_id].not_in(task_ids))
+      colliding_locks_scope.where(resource_id:   resource_id,
+                                  resource_type: resource_type)
+    end
+
+    def save!
+      super
+    rescue ActiveRecord::RecordNotUnique
+      raise LockConflict.new(self, colliding_locks)
     end
 
     class << self
@@ -67,116 +55,30 @@ module ForemanTasks
       # No other task related to the resource is not allowed (even not-locking ones)
       # A typical usecase is resource deletion, where it's good idea to make sure
       # nothing else related to the resource is really running.
-      def exclusive!(resource, uuid)
-        build_exclusive_locks(resource, uuid).each(&:save!)
-      end
-
-      def exclusive?(resource)
-        build_exclusive_locks(resource).all?(&:available?)
-      end
-
-      # Locks the resource so that no other task can lock it while running.
-      # Other not-locking tasks are tolerated.
-      #
-      # The lock names allow to specify what locks should be activated. It has to
-      # be a subset of names defined in model's class available_locks method
-      #
-      # When no lock name is specified, the resource is locked against all the available
-      # locks.
-      #
-      # It also looks at +related_resources+ method of the resource to calcuate all
-      # the related resources (recursively) and links the task to them as well.
-      def lock!(resource, uuid, *lock_names)
-        build_locks(resource, lock_names, uuid).each(&:save!)
-      end
-
-      def lockable?(resource, uuid, *lock_names)
-        build_locks(resource, lock_names, uuid).all?(&:available?)
+      # It also creates a Link between the task and the resource and between the task
+      # and all related resources.
+      def exclusive!(resource, task)
+        lock = build(resource, task)
+        lock.save!
+        ForemanTasks::Link.link_resource_and_related!(resource, task)
+        lock
       end
 
-      def locked?(resource, uuid, *lock_names)
-        !lockable?(resource, uuid, *lock_names)
+      # See #exclusive!
+      def lock!(resource, task, *_lock_names)
+        exclusive!(resource, task)
       end
 
-      def colliding_locks(resource, uuid, *lock_names)
-        build_locks(resource, lock_names, uuid)
-          .inject([]) { |collisions, lock| collisions.concat lock.colliding_locks.to_a }
-      end
-
-      # Assigns the resource to the task to easily track the task in context of
-      # the resource. This doesn't prevent other actions to lock the resource
-      # and should be used only for actions that tolerate other actions to be
-      # performed on the resource. Usually, this shouldn't needed to be done
-      # through the action directly, because the lock should assign it's parrent
-      # objects to the action srecursively (using +related_resources+ method in model
-      # objects)
-      def link!(resource, uuid)
-        build_link(resource, uuid).save!
-      end
-
-      def link?(resource, uuid)
-        build_link(resource, uuid).available?
+      def colliding_locks(resource, task, *_lock_names)
+        build(resource, task).colliding_locks.to_a
       end
 
       private
 
-      def all_lock_names(resource, include_links = false)
-        lock_names = []
-        if resource.class.respond_to?(:available_locks) &&
-           resource.class.available_locks.any?
-          lock_names.concat(resource.class.available_locks)
-        else
-          raise "The resource #{resource.class.name} doesn't define any available lock"
-        end
-        if lock_names.any? { |lock_name| RESERVED_LOCK_NAMES.include?(lock_name) }
-          raise "Lock name #{lock_name} is reserved"
-        end
-        lock_names.concat([LINK_LOCK_NAME, OWNER_LOCK_NAME]) if include_links
-        lock_names
-      end
-
-      def build_exclusive_locks(resource, uuid = nil)
-        build_locks(resource, all_lock_names(resource, true), uuid)
-      end
-
-      def build_locks(resource, lock_names, uuid = nil)
-        locks = []
-        if lock_names.empty? || lock_names == [:all]
-          lock_names = all_lock_names(resource)
-        end
-        lock_names.map do |lock_name|
-          locks << build(uuid, resource, lock_name, true)
-        end
-        locks.concat(build_links(resource, uuid))
-        locks
-      end
-
-      def build_links(resource, uuid = nil)
-        related_resources(resource).map do |related_resource|
-          build_link(related_resource, uuid)
-        end
-      end
-
-      def build_link(resource, uuid = nil)
-        build(uuid, resource, LINK_LOCK_NAME, false)
-      end
-
-      def build(uuid, resource, lock_name, exclusive)
-        new(task_id:       uuid,
-            name:          lock_name,
-            resource_type: resource.class.name,
-            resource_id:   resource.id,
-            exclusive:     !!exclusive)
-      end
-
-      # recursively search for related resources of the resource (using
-      # the +related_resources+ method, avoiding the cycles
-      def related_resources(resource)
-        if resource.respond_to?(:all_related_resources)
-          resource.all_related_resources
-        else
-          []
-        end
+      def build(resource, task)
+        find_or_initialize_by(task_id:       task.id,
+                              resource_type: resource.class.name,
+                              resource_id:   resource.id)
       end
     end
   end