foreman-tasks 3.0.5 → 4.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e389326a8086026cc0359932b9d3a3c0c13621f9f0cb60e682d785ecbacddcc
-  data.tar.gz: '0880da8a4cd833615fe5aa9b79aab13a5dcf1df0f84aea891a2490c6f7a342ba'
+  metadata.gz: 676dae1bc60b1633da496445b980e4b5fb491931bb227a70f2dcec4c44a9ae9e
+  data.tar.gz: 98d4f9798338d20bf7885a9e11b40d492eeeca4d30e2a7f84c4734e4f83e30d7
 SHA512:
-  metadata.gz: 15589c91365b2f7f0f14b38d000575048c2c9e316430eb1564357fd7aee02b9af275155e7021cc69bffc55e8eb46d83445554a46f615d703d6e5da52912a4a94
-  data.tar.gz: b5083cad3c0268b6c461574f7f9c86887bb395a85ec6cd41dd15d2816c07961bee099fc5e4d926029c1e57802c41852a4768c5c68674d26a8822e900ef879b59
+  metadata.gz: 8482b8a8e5ce147f2bd81d1eea004ba9507c95ecf5d83d0ebd50b7c74cc467a561f035d0049f0d1b44c3d63a29c35f3e55792705d37dfc0b4431e02d2370732a
+  data.tar.gz: c317248a7e396b2d556f397ba1fd91d162b5d38b75a593a7f8a28f555ef77ca15ec097f548162edd6c7a7198bfa7e84c6a902bbde6d7515c17b585f7632e9add

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/concerns/foreman_tasks/find_tasks_common.rb

@@ -0,0 +1,14 @@
+module ForemanTasks
+  module FindTasksCommon
+    def search_query
+      [current_taxonomy_search, params[:search]].select(&:present?).join(' AND ')
+    end
+
+    def current_taxonomy_search
+      conditions = []
+      conditions << "organization_id = #{Organization.current.id}" if Organization.current
+      conditions << "location_id = #{Location.current.id}" if Location.current
+      conditions.empty? ? '' : "(#{conditions.join(' AND ')})"
+    end
+  end
+end

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

@@ -1,6 +1,7 @@
 module ForemanTasks
   module Api
     class TasksController < ::Api::V2::BaseController
+      include ForemanTasks::FindTasksCommon
       include ::Foreman::Controller::SmartProxyAuth
       add_smart_proxy_filters :callback, :features => 'Dynflow'
 
@@ -51,7 +52,7 @@ module ForemanTasks
           In case :type = 'resource', what resource id we're searching the tasks for
         DESC
         param :action_types, [String], :desc => <<-DESC
-          Return just tasks of given action type, e.g. ["Actions::Katello::Repository::Synchronize"]
+          Return just tasks of given action type, e.g. `["Actions::Katello::Repository::Synchronize"]`
         DESC
         param :active_only, :bool
         param :page, String
@@ -195,7 +196,7 @@ module ForemanTasks
       end
 
       def search_options
-        [params[:search], {}]
+        [search_query, {}]
       end
 
       def_param_group :callback_target do
@@ -253,10 +254,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/controllers/foreman_tasks/tasks_controller.rb

@@ -2,6 +2,7 @@ module ForemanTasks
   class TasksController < ::ApplicationController
     include Foreman::Controller::AutoCompleteSearch
     include Foreman::Controller::CsvResponder
+    include ForemanTasks::FindTasksCommon
 
     def show
       @task = resource_base.find(params[:id])
@@ -126,19 +127,10 @@ module ForemanTasks
     end
 
     def filter(scope, paginate: true)
-      search = current_taxonomy_search
-      search = [search, params[:search]].select(&:present?).join(' AND ')
       scope = DashboardTableFilter.new(scope, params).scope
-      scope = scope.search_for(search, :order => params[:order])
-      scope = scope.paginate(:page => params[:page], :per_page => params[:per_page]) if paginate
+      scope = scope.search_for(search_query, order: params[:order])
+      scope = scope.paginate(page: params[:page], per_page: params[:per_page]) if paginate
       scope.distinct
     end
-
-    def current_taxonomy_search
-      conditions = []
-      conditions << "organization_id = #{Organization.current.id}" if Organization.current
-      conditions << "location_id = #{Location.current.id}" if Location.current
-      conditions.empty? ? '' : "(#{conditions.join(' AND ')})"
-    end
   end
 end

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/middleware/load_setting_values.rb

@@ -0,0 +1,35 @@
+module Actions
+  module Middleware
+    class LoadSettingValues < ::Dynflow::Middleware
+      # ::Actions::Middleware::LoadSettingValues
+      #
+      # A middleware to ensure we load current setting values
+
+      def delay(*args)
+        reload_setting_values
+        pass(*args)
+      end
+
+      def plan(*args)
+        reload_setting_values
+        pass(*args)
+      end
+
+      def run(*args)
+        reload_setting_values
+        pass(*args)
+      end
+
+      def finalize(*args)
+        reload_setting_values
+        pass(*args)
+      end
+
+      private
+
+      def reload_setting_values
+        ::Foreman.settings.load_values
+      end
+    end
+  end
+end

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