foreman-tasks 3.0.6 → 4.0.0

data/app/models/foreman_tasks/task.rb

@@ -31,6 +31,7 @@ module ForemanTasks
     has_many :recurring_logic_task_groups, -> { where :type => 'ForemanTasks::TaskGroups::RecurringLogicTaskGroup' },
              :through => :task_group_members, :source => :task_group
     belongs_to :user
+    has_many :links, :dependent => :destroy
 
     scoped_search :on => :id, :complete_value => false
     scoped_search :on => :action, :complete_value => false
@@ -46,10 +47,16 @@ module ForemanTasks
 
     # Note: the following searches may return duplicates, this is due to
     #       one task maybe having multiple locks (e.g. read/write) for the same resource_id
-    scoped_search :relation => :locks,  :on => :resource_id, :complete_value => false, :rename => 'location_id', :ext_method => :search_by_taxonomy, :only_explicit => true
-    scoped_search :relation => :locks,  :on => :resource_id, :complete_value => false, :rename => 'organization_id', :ext_method => :search_by_taxonomy, :only_explicit => true
-    scoped_search :relation => :locks,  :on => :resource_type, :complete_value => true, :rename => 'resource_type', :ext_method => :search_by_generic_resource, :only_explicit => true
-    scoped_search :relation => :locks,  :on => :resource_id, :complete_value => false, :rename => 'resource_id', :ext_method => :search_by_generic_resource, :only_explicit => true
+    scoped_search :relation => :locks,  :on => :resource_id, :complete_value => false, :rename => 'locked_location_id', :ext_method => :search_by_taxonomy, :only_explicit => true
+    scoped_search :relation => :locks,  :on => :resource_id, :complete_value => false, :rename => 'locked_organization_id', :ext_method => :search_by_taxonomy, :only_explicit => true
+    scoped_search :relation => :locks,  :on => :resource_type, :complete_value => true, :rename => 'locked_resource_type', :ext_method => :search_by_generic_resource, :only_explicit => true
+    scoped_search :relation => :locks,  :on => :resource_id, :complete_value => false, :rename => 'locked_resource_id', :ext_method => :search_by_generic_resource, :only_explicit => true
+
+    scoped_search :relation => :links,  :on => :resource_id, :complete_value => false, :rename => 'location_id', :ext_method => :search_by_taxonomy, :only_explicit => true
+    scoped_search :relation => :links,  :on => :resource_id, :complete_value => false, :rename => 'organization_id', :ext_method => :search_by_taxonomy, :only_explicit => true
+    scoped_search :relation => :links,  :on => :resource_type, :complete_value => true, :rename => 'resource_type', :ext_method => :search_by_generic_resource, :only_explicit => true
+    scoped_search :relation => :links,  :on => :resource_id, :complete_value => false, :rename => 'resource_id', :ext_method => :search_by_generic_resource, :only_explicit => true
+
     scoped_search :on => :user_id,
                   :complete_value => true,
                   :rename => 'user.id',
@@ -65,8 +72,8 @@ module ForemanTasks
     scope :running, -> { where("foreman_tasks_tasks.state NOT IN ('stopped', 'paused')") }
     scope :for_resource,
           (lambda do |resource|
-             joins(:locks).where(:"foreman_tasks_locks.resource_id" => resource.id,
-                                 :"foreman_tasks_locks.resource_type" => resource.class.name)
+             joins(:links).where(:"foreman_tasks_links.resource_id" => resource.id,
+                                 :"foreman_tasks_links.resource_type" => resource.class.name)
            end)
     scope :for_action_types, (->(action_types) { where('foreman_tasks_tasks.label IN (?)', Array(action_types)) })
 
@@ -82,7 +89,7 @@ module ForemanTasks
       property :ended_at, ActiveSupport::TimeWithZone, desc: 'Returns date with time the task ended at'
     end
     class Jail < Safemode::Jail
-      allow :started_at, :ended_at, :result, :state, :label, :main_action
+      allow :started_at, :ended_at, :result, :state, :label, :main_action, :action_output
     end
 
     def input
@@ -242,6 +249,12 @@ module ForemanTasks
       parts.join(' ').strip
     end
 
+    def action_output
+      return unless main_action.is_a?(Actions::Helpers::WithContinuousOutput)
+      main_action.continuous_output.sort!
+      main_action.continuous_output.raw_outputs
+    end
+
     protected
 
     def generate_id

data/app/models/foreman_tasks/task/dynflow_task.rb

@@ -140,17 +140,12 @@ module ForemanTasks
 
     def main_action
       return @main_action if defined?(@main_action)
-
-      @main_action = execution_plan && execution_plan.root_plan_step.try(:action, execution_plan)
       if active_job?
         job_data = active_job_data
-        begin
-          @main_action = active_job_action(job_data['job_class'], job_data['arguments'])
-        rescue => e
-          Foreman::Logging.exception("Failed to load ActiveJob for task #{id}", e, :logger => 'foreman-tasks')
-        end
+        @main_action = active_job_action(job_data['job_class'], job_data['arguments'])
+      else
+        @main_action = execution_plan && execution_plan.root_plan_step.try(:action, execution_plan)
       end
-      @main_action
     end
 
     # The class for ActiveJob jobs in Dynflow, JobWrapper is not expected to

data/app/models/foreman_tasks/task/search.rb

@@ -5,9 +5,9 @@ module ForemanTasks
         key = 'resource_type' if key.blank?
         key_name = connection.quote_column_name(key.sub(/^.*\./, ''))
         value = value.split(',') if operator.index(/IN/i)
-        condition = sanitize_sql_for_conditions(["foreman_tasks_locks.#{key_name} #{operator} (?)", value])
+        condition = sanitize_sql_for_conditions(["foreman_tasks_links.#{key_name} #{operator} (?)", value])
 
-        { :conditions => condition, :joins => :locks }
+        { :conditions => condition, :joins => :links }
       end
 
       def search_by_taxonomy(key, operator, value)
@@ -15,12 +15,12 @@ module ForemanTasks
         resource_type = key == 'location_id' ? 'Location' : 'Organization'
 
         joins = <<-SQL
-        LEFT JOIN foreman_tasks_locks AS foreman_tasks_locks_taxonomy#{uniq_suffix}
-        ON (foreman_tasks_locks_taxonomy#{uniq_suffix}.task_id = foreman_tasks_tasks.id AND
-            foreman_tasks_locks_taxonomy#{uniq_suffix}.resource_type = '#{resource_type}')
+        LEFT JOIN foreman_tasks_links AS foreman_tasks_links_taxonomy#{uniq_suffix}
+        ON (foreman_tasks_links_taxonomy#{uniq_suffix}.task_id = foreman_tasks_tasks.id AND
+            foreman_tasks_links_taxonomy#{uniq_suffix}.resource_type = '#{resource_type}')
         SQL
         # Select only those tasks which either have the correct taxonomy or are not related to any
-        sql = "foreman_tasks_locks_taxonomy#{uniq_suffix}.resource_id #{operator} (?) OR foreman_tasks_locks_taxonomy#{uniq_suffix}.resource_id IS NULL"
+        sql = "foreman_tasks_links_taxonomy#{uniq_suffix}.resource_id #{operator} (?) OR foreman_tasks_links_taxonomy#{uniq_suffix}.resource_id IS NULL"
         value = value.split(',') if operator.index(/IN/i)
         { :conditions => sanitize_sql_for_conditions([sql, value]), :joins => joins }
       end

data/app/views/foreman_tasks/api/locks/show.json.rabl

@@ -0,0 +1,4 @@
+object @lock
+
+attributes :name, :resource_type, :resource_id
+node(:exclusive) { !locals[:link] }

data/app/views/foreman_tasks/api/tasks/details.json.rabl

@@ -9,10 +9,12 @@ node(:failed_steps) { @task.input_output_failed_steps }
 node(:running_steps) { @task.input_output_running_steps }
 node(:help) { troubleshooting_info_text }
 node(:has_sub_tasks) { @task.sub_tasks.any? }
+
 node(:locks) do
-  @task.locks.map do |lock|
-    { name: lock.name, exclusive: lock.exclusive, resource_type: lock.resource_type, resource_id: lock.resource_id }
-  end
+  @task.locks.map { |lock| partial('foreman_tasks/api/locks/show', :object => lock) }
+end
+node(:links) do
+  @task.links.map { |link| partial('foreman_tasks/api/locks/show', :object => link, :locals => { :link => true }) }
 end
 node(:username_path) { username_link_task(@task.owner, @task.username) }
 node(:dynflow_enable_console) { Setting['dynflow_enable_console'] }

data/app/views/foreman_tasks/tasks/_lock_card.html.erb

@@ -0,0 +1,10 @@
+<div class="col-xs-6 col-sm-4 col-md-4">
+  <div class="card-pf card-pf-accented card-pf-aggregate-status">
+    <h2 class="card-pf-title">
+      <span class="fa <%= lock.is_a?(::ForemanTasks::Lock) ? 'fa-lock' : 'fa-unlock-alt' %>"></span> <%= lock.resource_type %>
+    </h2>
+    <div class="card-pf-body">
+      <%= format('id:%s', lock.resource_id) %><br>
+    </div>
+  </div>
+</div>

data/db/migrate/20181206123910_create_foreman_tasks_links.foreman_tasks.rb

@@ -0,0 +1,26 @@
+class CreateForemanTasksLinks < ActiveRecord::Migration[4.2]
+  def change
+    # rubocop:disable Rails/CreateTableWithTimestamps
+    create_table :foreman_tasks_links do |t|
+      task_id_options = { :index => true, :null => true }
+      if on_postgresql?
+        t.uuid :task_id, task_id_options
+      else
+        t.string :task_id, task_id_options
+      end
+      t.string :resource_type
+      t.integer :resource_id
+    end
+    # rubocop:enable Rails/CreateTableWithTimestamps
+
+    add_index :foreman_tasks_links, [:resource_type, :resource_id]
+    add_index :foreman_tasks_links, [:task_id, :resource_type, :resource_id],
+              :unique => true, :name => 'foreman_tasks_links_unique_index'
+  end
+
+  private
+
+  def on_postgresql?
+    ActiveRecord::Base.connection.adapter_name.casecmp('postgresql').zero?
+  end
+end

data/db/migrate/20181206124952_migrate_non_exclusive_locks_to_links.foreman_tasks.rb

@@ -0,0 +1,14 @@
+class MigrateNonExclusiveLocksToLinks < ActiveRecord::Migration[5.0]
+  def up
+    execute <<-SQL
+      INSERT INTO foreman_tasks_links(task_id, resource_type, resource_id)
+      SELECT DISTINCT locks.task_id, locks.resource_type, locks.resource_id
+      FROM foreman_tasks_locks AS locks
+      LEFT JOIN foreman_tasks_links AS links
+        ON links.task_id = locks.task_id
+          AND links.resource_type = locks.resource_type
+          AND links.resource_id = locks.resource_id
+      WHERE locks.exclusive = FALSE AND links.task_id IS NULL;
+    SQL
+  end
+end

data/db/migrate/20181206131436_drop_old_locks.foreman_tasks.rb

@@ -0,0 +1,20 @@
+class DropOldLocks < ActiveRecord::Migration[5.0]
+  BATCH_SIZE = 10_000
+
+  # Delete all locks which are exclusive or have a stopped task or are orphaned
+  def up
+    scope = ForemanTasks::Lock.left_outer_joins(:task)
+    scope = scope.where(:exclusive => false)
+                 .or(scope.where("#{ForemanTasks::Task.table_name}.state" => ['stopped', nil]))
+    scope.limit(BATCH_SIZE).delete_all while scope.any?
+
+    # For each group of locks, where each lock has the same task_id, resource_type and resource_id
+    # return the highest id within the group, if there is more than 1 lock in the group
+    scope = ForemanTasks::Lock.select("MAX(id) as id")
+                              .group(:task_id, :resource_type, :resource_id)
+                              .having("count(*) > 1")
+
+    # Make sure there is at most one lock per task and resource
+    ForemanTasks::Lock.where(:id => scope.limit(BATCH_SIZE)).delete_all while scope.any?
+  end
+end

data/db/migrate/20181206131627_make_locks_exclusive.foreman_tasks.rb

@@ -0,0 +1,25 @@
+class MakeLocksExclusive < ActiveRecord::Migration[5.0]
+  BATCH_SIZE = 2
+
+  def up
+    change_table :foreman_tasks_locks do |t|
+      t.remove :exclusive
+      t.remove :name
+      t.remove_index :name => 'index_foreman_tasks_locks_on_resource_type_and_resource_id'
+      t.index [:resource_type, :resource_id], :unique => true
+    end
+  end
+
+  def down
+    change_table :foreman_tasks_locks do |t|
+      t.boolean :exclusive, index: true
+      t.string :name, index: true
+      t.remove_index :name => 'index_foreman_tasks_locks_on_resource_type_and_resource_id'
+      t.index [:resource_type, :resource_id]
+    end
+
+    scope = ForemanTasks::Lock.where(:name => nil)
+    while scope.limit(BATCH_SIZE).update_all(:name => 'lock') == BATCH_SIZE; end
+    change_column_null(:foreman_tasks_locks, :name, false)
+  end
+end

data/lib/foreman_tasks/cleaner.rb

@@ -103,6 +103,7 @@ module ForemanTasks
         end
       end
       delete_orphaned_locks
+      delete_orphaned_links
       delete_orphaned_dynflow_tasks
     end
 
@@ -156,6 +157,15 @@ module ForemanTasks
       end
     end
 
+    def delete_orphaned_links
+      orphaned_links = ForemanTasks::Link.left_outer_joins(:task).where(:'foreman_tasks_tasks.id' => nil)
+      with_noop(orphaned_links, 'orphaned task links') do |source, name|
+        with_batches(source, name) do |chunk|
+          ForemanTasks::Link.where(id: chunk.pluck(:id)).delete_all
+        end
+      end
+    end
+
     def delete_orphaned_dynflow_tasks
       with_noop(orphaned_dynflow_tasks, 'orphaned execution plans') do |source, name|
         with_batches(source, name) do |chunk|

data/lib/foreman_tasks/engine.rb

@@ -34,7 +34,7 @@ module ForemanTasks
 
     initializer 'foreman_tasks.register_plugin', :before => :finisher_hook do |_app|
       Foreman::Plugin.register :"foreman-tasks" do
-        requires_foreman '>= 2.2.0'
+        requires_foreman '>= 2.4.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 },
@@ -76,6 +76,9 @@ module ForemanTasks
 
         widget 'foreman_tasks/tasks/dashboard/tasks_status', :sizex => 6, :sizey => 1, :name => N_('Task Status')
         widget 'foreman_tasks/tasks/dashboard/latest_tasks_in_error_warning', :sizex => 6, :sizey => 1, :name => N_('Latest Warning/Error Tasks')
+
+        ForemanTasks.dynflow.eager_load_actions!
+        extend_observable_events(::Dynflow::Action.descendants.select { |klass| klass <= ::Actions::ObservableAction }.map(&:namespaced_event_names))
       end
     end
 
@@ -108,7 +111,7 @@ module ForemanTasks
       ForemanTasks.dynflow.require!
       ::ForemanTasks.dynflow.config.on_init(false) do |world|
         world.middleware.use Actions::Middleware::KeepCurrentTaxonomies
-        world.middleware.use Actions::Middleware::KeepCurrentUser
+        world.middleware.use Actions::Middleware::KeepCurrentUser, :before => ::Dynflow::Middleware::Common::Transaction
         world.middleware.use Actions::Middleware::KeepCurrentTimezone
         world.middleware.use Actions::Middleware::KeepCurrentRequestID
       end

data/lib/foreman_tasks/tasks/export_tasks.rake

@@ -252,7 +252,7 @@ namespace :foreman_tasks do
         renderer = TaskRender.new
         total = tasks.count
 
-        tasks.each_with_index do |task, count|
+        tasks.find_each.with_index do |task, count|
           File.open(File.join(tmp_dir, "#{task.id}.html"), 'w') { |file| file.write(PageHelper.pagify(renderer.render_task(task))) }
           puts "#{count + 1}/#{total}"
         end
@@ -264,7 +264,7 @@ namespace :foreman_tasks do
     elsif format == 'csv'
       CSV.open(export_filename, 'wb') do |csv|
         csv << %w[id state type label result parent_task_id started_at ended_at]
-        tasks.each do |task|
+        tasks.find_each do |task|
           csv << [task.id, task.state, task.type, task.label, task.result,
                   task.parent_task_id, task.started_at, task.ended_at]
         end

data/lib/foreman_tasks/version.rb

@@ -1,3 +1,3 @@
 module ForemanTasks
-  VERSION = '3.0.6'.freeze
+  VERSION = '4.0.0'.freeze
 end

data/package.json

@@ -23,7 +23,7 @@
     "url": "http://projects.theforeman.org/projects/foreman-tasks/issues"
   },
   "peerDependencies": {
-    "@theforeman/vendor": ">= 4.0.2"
+    "@theforeman/vendor": ">= 6.0.0"
   },
   "dependencies": {
     "c3": "^0.4.11",
@@ -32,11 +32,11 @@
   },
   "devDependencies": {
     "@babel/core": "^7.7.0",
-    "@theforeman/builder": "^4.0.2",
-    "@theforeman/eslint-plugin-foreman": "4.0.5",
-    "@theforeman/stories": "^4.0.2",
-    "@theforeman/test": "^4.0.2",
-    "@theforeman/vendor-dev": "^4.0.2",
+    "@theforeman/builder": "^6.0.0",
+    "@theforeman/eslint-plugin-foreman": "6.0.0",
+    "@theforeman/stories": "^6.0.0",
+    "@theforeman/test": "^6.0.0",
+    "@theforeman/vendor-dev": "^6.0.0",
     "babel-eslint": "^10.0.3",
     "eslint": "^6.7.2",
     "jed": "^1.1.1",

data/test/controllers/tasks_controller_test.rb

@@ -10,7 +10,7 @@ module ForemanTasks
       # rubocop:enable Naming/AccessorMethodName
 
       def linked_task(resource)
-        FactoryBot.create(:some_task).tap { |t| ForemanTasks::Lock.link!(resource, t.id) }
+        FactoryBot.create(:some_task).tap { |t| ForemanTasks::Link.link!(resource, t) }
       end
 
       def in_taxonomy_scope(organization, location = nil)

data/test/unit/actions/action_with_sub_plans_test.rb

@@ -34,8 +34,9 @@ module ForemanTasks
     describe Actions::ActionWithSubPlans do
       include ForemanTasks::TestHelpers::WithInThreadExecutor
 
+      let(:user) { FactoryBot.create(:user) }
+
       let(:task) do
-        user = FactoryBot.create(:user)
         triggered = ForemanTasks.trigger(ParentAction, user)
         raise triggered.error if triggered.respond_to?(:error)
         triggered.finished.wait(30)
@@ -49,7 +50,9 @@ module ForemanTasks
 
       specify "the locks of the sub-plan don't colide with the locks of its parent" do
         child_task = task.sub_tasks.first
-        assert(child_task.locks.any? { |lock| lock.name == 'write' }, "it's locks don't conflict with parent's")
+        assert_not(child_task.locks.any?, "the lock is ensured by the parent")
+        found = ForemanTasks::Link.for_resource(user).where(:task_id => child_task.id).any?
+        assert(found, "the action is linked properly")
       end
     end
   end

data/test/unit/cleaner_test.rb

@@ -60,18 +60,18 @@ class TasksTest < ActiveSupport::TestCase
                            task.started_at = task.ended_at = Time.zone.now
                            task.save
                          end]
-      lock_to_delete = tasks_to_delete.first.locks.create(:name => 'read', :resource => User.current)
+      link_to_delete = tasks_to_delete.first.links.create(:resource => User.current)
 
       tasks_to_keep = [FactoryBot.create(:dynflow_task, :product_create_task)]
-      lock_to_keep = tasks_to_keep.first.locks.create(:name => 'read', :resource => User.current)
+      link_to_keep = tasks_to_keep.first.links.create(:resource => User.current)
 
       cleaner.expects(:tasks_to_csv)
       cleaner.delete
       _(ForemanTasks::Task.where(id: tasks_to_delete)).must_be_empty
       _(ForemanTasks::Task.where(id: tasks_to_keep)).must_equal tasks_to_keep
 
-      _(ForemanTasks::Lock.find_by(id: lock_to_delete.id)).must_be_nil
-      _(ForemanTasks::Lock.find_by(id: lock_to_keep.id)).wont_be_nil
+      _(ForemanTasks::Link.find_by(id: link_to_delete.id)).must_be_nil
+      _(ForemanTasks::Link.find_by(id: link_to_keep.id)).wont_be_nil
     end
 
     it 'supports passing empty filter (just delete all)' do

data/test/unit/locking_test.rb

@@ -0,0 +1,85 @@
+require 'ostruct'
+require 'foreman_tasks_test_helper'
+
+module ForemanTasks
+  class LockTest < ::ActiveSupport::TestCase
+    describe ::ForemanTasks::Lock::LockConflict do
+      class FakeLockConflict < ForemanTasks::Lock::LockConflict
+        def _(val)
+          val.freeze
+        end
+      end
+
+      it 'does not modify frozen strings' do
+        required_lock = OpenStruct.new(:name => 'my_lock')
+        # Before #21770 the next line would raise
+        #   RuntimeError: can't modify frozen String
+        conflict = FakeLockConflict.new(required_lock, [])
+        assert conflict._('this should be frozen').frozen?
+      end
+    end
+
+    describe 'locking and linking' do
+      before { [Lock, Link].each(&:destroy_all) }
+      let(:task1) { FactoryBot.create(:some_task) }
+      let(:task2) { FactoryBot.create(:some_task) }
+      let(:resource) { FactoryBot.create(:user) }
+
+      describe Lock do
+        it 'can lock a resource for a single task' do
+          Lock.lock!(resource, task1)
+        end
+
+        it 'can lock a resource for a single task only once' do
+          Lock.lock!(resource, task1)
+          _(Lock.for_resource(resource).count).must_equal 1
+          Lock.lock!(resource, task1)
+          _(Lock.for_resource(resource).count).must_equal 1
+        end
+
+        it 'cannot lock a resource for multiple tasks' do
+          lock = Lock.lock!(resource, task1)
+          _(Lock.colliding_locks(resource, task2)).must_equal [lock]
+          assert_raises Lock::LockConflict do
+            Lock.lock!(resource, task2)
+          end
+        end
+
+        it 'raises LockConflict when enforced by db' do
+          lock = Lock.lock!(resource, task1)
+          Lock.any_instance
+              .expects(:colliding_locks).twice.returns([], [lock])
+          exception = assert_raises Lock::LockConflict do
+            Lock.lock!(resource, task2)
+          end
+          _(exception.message).must_match(/#{lock.task_id}/)
+        end
+
+        it 'creates a link when creating a lock for a resource' do
+          Lock.lock!(resource, task1)
+          link = Link.for_resource(resource).first
+          _(link.task_id).must_equal task1.id
+        end
+      end
+
+      describe Link do
+        it 'can link a resource to a single task' do
+          Link.link!(resource, task1)
+        end
+
+        it 'can link a resource for a single task only once' do
+          Link.link!(resource, task1)
+          _(Link.for_resource(resource).count).must_equal 1
+          Link.link!(resource, task1)
+          _(Link.for_resource(resource).count).must_equal 1
+        end
+
+        it 'can link a resource to multiple tasks' do
+          Link.link!(resource, task1)
+          Link.link!(resource, task2)
+          _(Link.for_resource(resource).count).must_equal 2
+        end
+      end
+    end
+  end
+end