foreman-tasks 3.0.6 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29e160b9773db8ef5b9f8cb9e26011b957578caccf2d56bc6a57852c5553df9d
-  data.tar.gz: 863c9436e788ede17b6e2a80aae49b259f96a1372c80a004ed66e70409957435
+  metadata.gz: bded348bac199b96bf0c1bf458c0785cdc233892acc1a5d06a940a8c5b28309b
+  data.tar.gz: f90eaf365ebfb191b45ab12b4693c7253d829ffcf0c57192e8bb4c1fa3e51986
 SHA512:
-  metadata.gz: 4140dea3980dcbbc2d140b3e83dc23458a53ff6be35f5012feb8d3bd87c24ed45e98eb98a19aaf7228c1ca620f4e91e57236cc4c17e36754bd1cbe65dd1b3249
-  data.tar.gz: e2836f3e5061587913504a69509e21fab8e640f002cf026641d8948e64f830c8abf1aa4b7d72e9a9c64f49c47116ac94be299367b6fba9d44689d410f1805cb3
+  metadata.gz: 41d60c3a188d66c0f7f3e9982c72de16f323d458529e2b90a16e8c023733acaedcf94a09ae30e94e54a66f4303f0b904a06d54c33b6db2af3acf49669c8b8b0f
+  data.tar.gz: b0ec169bf37128b471263c189b839416d8ae572a69732d3a9d4dcb64d4e2cdf2aef53d423cb2a7eef1c5f50f0756d332066dc9a244788f2b8c05643e1ca73b0f

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