libis-workflow 2.0.36 → 2.0.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 391021b367fd4a087777f80abc4cc98b7602ac012207155bec4bf0c2f1cd9f9f
-  data.tar.gz: 053a3ee71843fec6efcc98d0beb00dec6c5cd9c6a140b2e5f589384b9172e299
+  metadata.gz: d248c18f7b5ec05c2a28bd7121a31d6c9f3f00c73a4e688c7fe00b4fdf12dde8
+  data.tar.gz: cfd5c563241f5a7bf2a76c287f7411ef1b81e720fa29886594e39d8f66a195dc
 SHA512:
-  metadata.gz: 6ca558020759c70cb7acd8e0b241f08e6b17b0f391a9616c726760c9ea1ecd89cc6782b8a4570b826c9daef03be984b17a36c15ae15aa047b599f433b6c10445
-  data.tar.gz: 7b426682ab3e15e292215fda755307028d9a5c6abc4ca3facad3f619f46f53a4394b67c607c6bd362eac67edbb31e7d184cf5271af780e7f965f52b0737c5c9e
+  metadata.gz: 1103e4fdff7de541a410c065605c220fd9890a7e4b17cb38ea965f1bf3246d415f99c70f67a18ed604e9ad2a009c47a5d252edce46f5114d91057d4e2a1d771f
+  data.tar.gz: 0a30fa5acc5df9709ab742b5331e7a597b189ee563a0c08f12e072b72c6c748c85877d66f868554d6cc80c0ad5e23b1d663f0135e0fe184fd1b16be9a47fb93a

data/README.md

@@ -103,6 +103,8 @@ The ::Libis::Workflow::Task base class allready defines the following parameters
 * abort_recursion_on_failure: Stop processing items recursively if one item fails. Default: false
 * retry_count: Number of times to retry the task. Default: 0
 * retry_interval: Number of seconds to wait between retries. Default: 10
+* run_always: If set and true will cause the task to be always executed, even if previous tasks have failed or during
+  a retry if the task completed successfully before.
 
 If 'class' is not present, the default '::Libis::Workflow::TaskGroup' with the given name will be instantiated, which 
 performs each sub-task on the item.
@@ -114,6 +116,10 @@ the work item to process on. See the chapter on 'Tasks' below for more informati
 Note that a task with custom processing will not execute sub-tasks. If you configured a processing task with subtasks
 an exception will be thrown when trying to execute the job.
 
+The run_always option will only be evaluated within the current TaskGroup. This means that if the parent task was not
+configure with run_always set to true and the parent task completed successfully previously, the whole subtree of tasks
+will not be executed during a retry.
+
 ##### Input variable definition
 
 The input variables define parameters for the workflow. When a job is executed, it can provide values for any of these

data/lib/libis/workflow/base/job.rb

@@ -1,4 +1,5 @@
 require 'libis/tools/parameter'
+require 'libis/tools/extend/hash'
 
 module Libis
   module Workflow
@@ -44,6 +45,7 @@ module Libis
         end
 
         def configure(cfg = {})
+          cfg.key_symbols_to_strings!(recursive: true)
           self.name ||= ''
           self.description ||= ''
           self.input ||= {}

data/lib/libis/workflow/base/workflow.rb

@@ -76,6 +76,7 @@ module Libis
         end
 
         def configure(cfg)
+          cfg.key_symbols_to_strings!(recursive: true)
           self.name = cfg.delete('name') || self.class.name
           self.description = cfg.delete('description') || ''
           self.config['input'] = {}

data/lib/libis/workflow/task.rb

@@ -21,6 +21,7 @@ module Libis
       parameter abort_recursion_on_failure: false, description: 'Stop processing items recursively if one item fails.'
       parameter retry_count: 0, description: 'Number of times to retry the task if waiting for another process.'
       parameter retry_interval: 10, description: 'Number of seconds to wait between retries.'
+      parameter run_always: false, description: 'Always run this task, even if previous tasks have failed.'
 
       def self.task_classes
         # noinspection RubyArgCount
@@ -44,17 +45,19 @@ module Libis
         check_item_type ::Libis::Workflow::Base::WorkItem, item
         self.workitem = item
 
-        case action
-        when :retry
-          if item.check_status(:DONE, namepath)
-            debug 'Retry: skipping task %s because it has finished successfully.', item, namepath
-            return item
-          end
-        when :failed
-          return item
-        else
-          # type code here
-        end
+        # case action
+        # when :retry
+        #   if !parameter(:run_always) && item.check_status(:DONE, namepath)
+        #     debug 'Retry: skipping task %s because it has finished successfully.', item, namepath
+        #     return item
+        #   end
+        # when :failed
+        #   return item unless parameter(:run_always)
+        # else
+        #   # type code here
+        # end
+
+        return item if action == :failed && !parameter(:run_always)
 
         (parameter(:retry_count) + 1).times do
 
@@ -64,7 +67,7 @@ module Libis
           # noinspection RubyScope
           case item.status(namepath)
           when :DONE
-            self.action = :run
+            # self.action = :run
             return item
           when :ASYNC_WAIT
             self.action = :retry
@@ -158,7 +161,7 @@ module Libis
       def run_item(item)
         @item_skipper = false
 
-        return item if item.status(namepath) == :DONE
+        return item if item.status(namepath) == :DONE && !parameter(:run_always)
 
         pre_process(item)
 

data/lib/libis/workflow/task_group.rb

@@ -39,14 +39,22 @@ module Libis
 
         status_count = Hash.new(0)
         item.status_progress(self.namepath, 0, tasks.count)
+        continue = true
         tasks.each_with_index do |task, i|
+          unless task.parameter(:run_always)
+            next unless continue
+            if  item.status(task.namepath) == :DONE && item.get_run.action == :retry
+              debug 'Retry: skipping task %s because it has finished successfully.', item, task.namepath
+              next
+            end
+          end
           info 'Running subtask (%d/%d): %s', item, i+1, tasks.size, task.name
           new_item = task.run item
           item = new_item if new_item.is_a?(Libis::Workflow::WorkItem)
           item.status_progress(self.namepath, i+1)
           item_status = item.status(task.namepath)
           status_count[item_status] += 1
-          break if parameter(:abort_on_failure) && item_status != :DONE
+          continue = false if parameter(:abort_on_failure) && item_status != :DONE
         end
 
         substatus_check(status_count, item, 'task')

data/lib/libis/workflow/version.rb

@@ -1,5 +1,5 @@
 module Libis
   module Workflow
-    VERSION = '2.0.36' unless const_defined? :VERSION # the guard is against a redefinition warning that happens on Travis
+    VERSION = '2.0.37' unless const_defined? :VERSION # the guard is against a redefinition warning that happens on Travis
   end
 end

data/libis-workflow.gemspec

@@ -32,6 +32,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec', '~> 3.1'
   spec.add_development_dependency 'simplecov', '~> 0.9'
   spec.add_development_dependency 'coveralls', '~> 0.7'
+  spec.add_development_dependency 'awesome_print'
 
   spec.add_runtime_dependency 'libis-tools', '~> 0.9'
   spec.add_runtime_dependency 'sidekiq', '~> 4.0'

data/spec/tasks/final_task.rb

@@ -0,0 +1,13 @@
+require 'libis/exceptions'
+require 'libis/workflow'
+
+class FinalTask < ::Libis::Workflow::Task
+
+  def process(item)
+    return unless item.is_a? TestFileItem
+
+    info "Final processing of #{item.name}"
+
+  end
+
+end

data/spec/tasks/processing_task.rb

@@ -0,0 +1,31 @@
+require 'libis/exceptions'
+require 'libis/workflow'
+
+class ProcessingTask < ::Libis::Workflow::Task
+
+  parameter config: 'success', constraint: %w'success async_halt fail error abort',
+            description: 'determines the outcome of the processing'
+
+  def process(item)
+    return unless item.is_a? TestFileItem
+
+    case parameter(:config).downcase.to_sym
+    when :success
+      info 'Task success'
+    when :async_halt
+      set_status(item, :ASYNC_HALT)
+      error "Task failed with async_halt status"
+    when :fail
+      set_status(item, :FAILED)
+      error "Task failed with failed status"
+    when :error
+      raise Libis::WorkflowError, "Task failed with WorkflowError exception"
+    when :abort
+      raise Libis::WorkflowAbort, "Task failed with WorkflowAbort exception"
+    else
+      info 'Task success'
+    end
+
+  end
+
+end

data/spec/workflow_spec.rb

@@ -1,11 +1,34 @@
 require_relative 'spec_helper'
 
 require 'stringio'
+require 'awesome_print'
 
-describe 'TestWorkflow' do
+basedir = File.absolute_path File.join(File.dirname(__FILE__))
+dirname = File.join(basedir, 'items')
 
-  basedir = File.absolute_path File.join(File.dirname(__FILE__))
-  dirname = File.join(basedir, 'items')
+def check_output(logoutput, sample_out)
+  sample_out = sample_out.lines.to_a.map {|x| x.strip}
+  output = logoutput.string.lines.to_a.map {|x| x[/(?<=\] ).*/].strip}
+
+  puts 'output:'
+  ap output
+
+  expect(output.size).to eq sample_out.size
+  output.each_with_index do |o, i|
+    expect(o).to eq sample_out[i]
+  end
+end
+
+def check_status_log(status_log, sample_status_log)
+  puts 'status_log:'
+  status_log.each { |e| ap e }
+  expect(status_log.size).to eq sample_status_log.size
+  sample_status_log.each_with_index do |h, i|
+    h.keys.each {|key| expect(status_log[i][key.to_s]).to eq h[key]}
+  end
+end
+
+context 'TestWorkflow' do
 
   before :each do
 
@@ -19,26 +42,26 @@ describe 'TestWorkflow' do
     end
   end
 
-  let(:logoutput) { ::Libis::Workflow::Config.logger.appenders.first.sio }
+  let(:logoutput) {::Libis::Workflow::Config.logger.appenders.first.sio}
 
   let(:workflow) {
     workflow = ::Libis::Workflow::Workflow.new
     workflow.configure(
-        'name' => 'TestWorkflow',
-        'description' => 'Workflow for testing',
-        'tasks' => [
-            {'class' => 'CollectFiles', 'recursive' => true},
+        name: 'TestWorkflow',
+        description: 'Workflow for testing',
+        tasks: [
+            {class: 'CollectFiles', recursive: true},
             {
-                'name' => 'ProcessFiles', 'recursive' => false,
-                'tasks' => [
-                    {'class' => 'ChecksumTester', 'recursive' => true},
-                    {'class' => 'CamelizeName', 'recursive' => true}
+                name: 'ProcessFiles', recursive: false,
+                tasks: [
+                    {class: 'ChecksumTester', recursive: true},
+                    {class: 'CamelizeName', :recursive => true}
                 ]
             }
         ],
-        'input' => {
-            'dirname' => {'default' => '.', 'propagate_to' => 'CollectFiles#location'},
-            'checksum_type' => {'default' => 'SHA1', 'propagate_to' => 'ChecksumTester'}
+        input: {
+            dirname: {default: '.', propagate_to: 'CollectFiles#location'},
+            checksum_type: {default: 'SHA1', propagate_to: 'ChecksumTester'}
         }
     )
     workflow
@@ -47,12 +70,12 @@ describe 'TestWorkflow' do
   let(:job) {
     job = ::Libis::Workflow::Job.new
     job.configure(
-        'name' => 'TestJob',
-        'description' => 'Job for testing',
-        'workflow' => workflow,
-        'run_object' => 'TestRun',
-        'input' => {'dirname' => dirname, 'checksum_type' => 'SHA256'},
-    )
+        name: 'TestJob',
+        description: 'Job for testing',
+        workflow: workflow,
+        run_object: 'TestRun',
+        input: {dirname: dirname, checksum_type: 'SHA256'},
+        )
     job
   }
 
@@ -81,8 +104,9 @@ describe 'TestWorkflow' do
   end
 
   it 'should return expected debug output' do
+    run = job.execute
 
-    sample_out = <<STR
+    check_output logoutput, <<STR
  INFO -- Run - TestRun : Ingest run started.
  INFO -- Run - TestRun : Running subtask (1/2): CollectFiles
 DEBUG -- CollectFiles - TestRun : Processing subitem (1/1): items
@@ -109,46 +133,559 @@ DEBUG -- ProcessFiles/CamelizeName - TestRun : 1 of 1 subitems passed
  INFO -- ProcessFiles - TestRun : Done
  INFO -- Run - TestRun : Done
 STR
-    sample_out = sample_out.lines.to_a
-
-    run = job.execute
-    output = logoutput.string.lines.to_a
-
-    # puts output
 
-    expect(output.size).to eq sample_out.size
-    output.each_with_index do |o, i|
-      expect(o[/(?<=\] ).*/].strip).to eq sample_out[i].strip
-    end
-
-    # run.status_log.each { |e| puts e }
-    expect(run.status_log.size).to eq 5
-    expect(run.items.first.status_log.size).to eq 3
-
-    [
+    check_status_log run.status_log, [
         {task: 'Run', status: :DONE, progress: 2, max: 2},
         {task: 'CollectFiles', status: :DONE, progress: 1, max: 1},
         {task: 'ProcessFiles', status: :DONE, progress: 2, max: 2},
         {task: 'ProcessFiles/ChecksumTester', status: :DONE, progress: 1, max: 1},
         {task: 'ProcessFiles/CamelizeName', status: :DONE, progress: 1, max: 1},
-    ].each_with_index do |h, i|
-      h.keys.each { |key| expect(run.status_log[i][key.to_s]).to eq h[key] }
-    end
+    ]
 
-    [
+    check_status_log run.items.first.status_log, [
         {task: 'CollectFiles', status: :DONE, progress: 3, max: 3},
         {task: 'ProcessFiles/ChecksumTester', status: :DONE, progress: 3, max: 3},
         {task: 'ProcessFiles/CamelizeName', status: :DONE, progress: 3, max: 3},
-    ].each_with_index do |h, i|
-      h.keys.each { |key| expect(run.items.first.status_log[i][key.to_s]).to eq h[key] }
-    end
+    ]
 
-    [
+    check_status_log run.items.first.items.first.status_log, [
         {task: 'CollectFiles', status: :DONE, progress: nil, max: nil},
         {task: 'ProcessFiles/ChecksumTester', status: :DONE, progress: nil, max: nil},
         {task: 'ProcessFiles/CamelizeName', status: :DONE, progress: nil, max: nil},
-    ].each_with_index do |h, i|
-      h.keys.each { |key| expect(run.items.first.first.status_log[i][key.to_s]).to eq h[key] }
+    ]
+
+  end
+
+end
+
+context 'Test run_always' do
+
+  before :each do
+
+    # noinspection RubyResolve
+    ::Libis::Workflow.configure do |cfg|
+      cfg.itemdir = dirname
+      cfg.taskdir = File.join(basedir, 'tasks')
+      cfg.workdir = File.join(basedir, 'work')
+      cfg.logger.appenders =
+          ::Logging::Appenders.string_io('StringIO', layout: ::Libis::Tools::Config.get_log_formatter)
+      cfg.logger.level = :INFO
+    end
+  end
+
+  let(:logoutput) {::Libis::Workflow::Config.logger.appenders.first.sio}
+
+  let(:workflow) {
+    workflow = ::Libis::Workflow::Workflow.new
+    workflow.configure(
+        name: 'TestRunAlways',
+        description: 'Workflow for testing run_always options',
+        tasks: [
+            {class: 'CollectFiles', recursive: true},
+            {class: 'ProcessingTask', recursive: true},
+            {class: 'FinalTask', recursive: true}
+        ],
+        input: {
+            dirname: {default: '.', propagate_to: 'CollectFiles#location'},
+            processing: {default: 'success', propagate_to: 'ProcessingTask#config'},
+            force_run: {default: false, propagate_to: 'FinalTask#run_always'}
+        }
+    )
+    workflow
+  }
+
+  let(:processing) {'success'}
+  let(:force_run) {false}
+
+  let(:job) {
+    job = ::Libis::Workflow::Job.new
+    job.configure(
+        name: 'TestJob',
+        description: 'Job for testing run_always',
+        workflow: workflow,
+        run_object: 'TestRun',
+        input: {dirname: dirname, processing: processing, force_run: force_run},
+        )
+    job
+  }
+
+  let(:run) {job.execute}
+
+  context 'without forcing final task' do
+    let(:force_run) {false}
+
+    context 'when processing successfully' do
+      let(:processing) {'success'}
+
+      it 'should run final task' do
+        run
+
+        check_output logoutput, <<STR
+ INFO -- Run - TestRun : Ingest run started.
+ INFO -- Run - TestRun : Running subtask (1/3): CollectFiles
+ INFO -- Run - TestRun : Running subtask (2/3): ProcessingTask
+ INFO -- ProcessingTask - TestRun : Task success
+ INFO -- ProcessingTask - TestRun : Task success
+ INFO -- ProcessingTask - TestRun : Task success
+ INFO -- Run - TestRun : Running subtask (3/3): FinalTask
+ INFO -- FinalTask - TestRun : Final processing of test_dir_item.rb
+ INFO -- FinalTask - TestRun : Final processing of test_file_item.rb
+ INFO -- FinalTask - TestRun : Final processing of test_run.rb
+ INFO -- Run - TestRun : Done
+STR
+
+        check_status_log run.status_log, [
+            {task: 'Run', status: :DONE, progress: 3, max: 3},
+            {task: 'CollectFiles', status: :DONE, progress: 1, max: 1},
+            {task: 'ProcessingTask', status: :DONE, progress: 1, max: 1},
+            {task: 'FinalTask', status: :DONE, progress: 1, max: 1},
+        ]
+
+        check_status_log run.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE, progress: 3, max: 3},
+            {task: 'ProcessingTask', status: :DONE, progress: 3, max: 3},
+            {task: 'FinalTask', status: :DONE, progress: 3, max: 3},
+        ]
+
+        check_status_log run.items.first.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE},
+            {task: 'ProcessingTask', status: :DONE},
+            {task: 'FinalTask', status: :DONE},
+        ]
+
+      end
+
+    end
+
+    context 'when stopped with async_halt' do
+      let(:processing) {'async_halt'}
+
+      it 'should not run final task' do
+        run
+
+        check_output logoutput, <<STR
+ INFO -- Run - TestRun : Ingest run started.
+ INFO -- Run - TestRun : Running subtask (1/3): CollectFiles
+ INFO -- Run - TestRun : Running subtask (2/3): ProcessingTask
+ERROR -- ProcessingTask - TestRun : Task failed with async_halt status
+ERROR -- ProcessingTask - TestRun : Task failed with async_halt status
+ERROR -- ProcessingTask - TestRun : Task failed with async_halt status
+ WARN -- ProcessingTask - items : 3 subitem(s) halted in async process
+ WARN -- ProcessingTask - TestRun : 1 subitem(s) halted in async process
+ WARN -- Run - TestRun : 1 subtask(s) halted in async process
+ INFO -- Run - TestRun : Waiting for halted async process
+STR
+
+        check_status_log run.status_log ,[
+            {task: 'Run', status: :ASYNC_HALT, progress: 2, max: 3},
+            {task: 'CollectFiles', status: :DONE, progress: 1, max: 1},
+            {task: 'ProcessingTask', status: :ASYNC_HALT, progress: 1, max: 1},
+        ]
+
+        check_status_log run.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE, progress: 3, max: 3},
+            {task: 'ProcessingTask', status: :ASYNC_HALT, progress: 3, max: 3},
+        ]
+
+        check_status_log run.items.first.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE},
+            {task: 'ProcessingTask', status: :ASYNC_HALT},
+        ]
+
+      end
+
+    end
+
+    context 'when stopped with fail' do
+      let(:processing) {'fail'}
+
+      it 'should not run final task' do
+        run
+
+        check_output logoutput, <<STR
+ INFO -- Run - TestRun : Ingest run started.
+ INFO -- Run - TestRun : Running subtask (1/3): CollectFiles
+ INFO -- Run - TestRun : Running subtask (2/3): ProcessingTask
+ERROR -- ProcessingTask - TestRun : Task failed with failed status
+ERROR -- ProcessingTask - TestRun : Task failed with failed status
+ERROR -- ProcessingTask - TestRun : Task failed with failed status
+ERROR -- ProcessingTask - items : 3 subitem(s) failed
+ERROR -- ProcessingTask - TestRun : 1 subitem(s) failed
+ERROR -- Run - TestRun : 1 subtask(s) failed
+ INFO -- Run - TestRun : Failed
+STR
+
+        check_status_log run.status_log, [
+            {task: 'Run', status: :FAILED, progress: 2, max: 3},
+            {task: 'CollectFiles', status: :DONE, progress: 1, max: 1},
+            {task: 'ProcessingTask', status: :FAILED, progress: 1, max: 1},
+        ]
+
+        check_status_log run.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE, progress: 3, max: 3},
+            {task: 'ProcessingTask', status: :FAILED, progress: 3, max: 3},
+        ]
+
+        check_status_log run.items.first.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE},
+            {task: 'ProcessingTask', status: :FAILED},
+        ]
+
+      end
+
+    end
+
+    context 'when stopped with error' do
+      let(:processing) {'error'}
+
+      it 'should not run final task' do
+        run
+
+        check_output logoutput, <<STR
+ INFO -- Run - TestRun : Ingest run started.
+ INFO -- Run - TestRun : Running subtask (1/3): CollectFiles
+ INFO -- Run - TestRun : Running subtask (2/3): ProcessingTask
+ERROR -- ProcessingTask - items/test_dir_item.rb : Error processing subitem (1/3): Task failed with WorkflowError exception
+ERROR -- ProcessingTask - items/test_file_item.rb : Error processing subitem (2/3): Task failed with WorkflowError exception
+ERROR -- ProcessingTask - items/test_run.rb : Error processing subitem (3/3): Task failed with WorkflowError exception
+ERROR -- ProcessingTask - items : 3 subitem(s) failed
+ERROR -- ProcessingTask - TestRun : 1 subitem(s) failed
+ERROR -- Run - TestRun : 1 subtask(s) failed
+ INFO -- Run - TestRun : Failed
+STR
+
+        check_status_log run.status_log, [
+            {task: 'Run', status: :FAILED, progress: 2, max: 3},
+            {task: 'CollectFiles', status: :DONE, progress: 1, max: 1},
+            {task: 'ProcessingTask', status: :FAILED, progress: 1, max: 1},
+        ]
+
+        check_status_log run.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE, progress: 3, max: 3},
+            {task: 'ProcessingTask', status: :FAILED, progress: 0, max: 3},
+        ]
+
+        check_status_log run.items.first.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE},
+            {task: 'ProcessingTask', status: :FAILED},
+        ]
+
+      end
+
+    end
+
+    context 'when stopped with abort' do
+      let(:processing) {'abort'}
+
+      it 'should not run final task' do
+        run
+
+        check_output logoutput, <<STR
+ INFO -- Run - TestRun : Ingest run started.
+ INFO -- Run - TestRun : Running subtask (1/3): CollectFiles
+ INFO -- Run - TestRun : Running subtask (2/3): ProcessingTask
+FATAL -- ProcessingTask - items/test_dir_item.rb : Fatal error processing subitem (1/3): Task failed with WorkflowAbort exception
+ERROR -- ProcessingTask - items : 1 subitem(s) failed
+ERROR -- ProcessingTask - TestRun : 1 subitem(s) failed
+ERROR -- Run - TestRun : 1 subtask(s) failed
+ INFO -- Run - TestRun : Failed
+STR
+
+        check_status_log run.status_log, [
+            {task: 'Run', status: :FAILED, progress: 2, max: 3},
+            {task: 'CollectFiles', status: :DONE, progress: 1, max: 1},
+            {task: 'ProcessingTask', status: :FAILED, progress: 1, max: 1},
+        ]
+
+        check_status_log run.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE, progress: 3, max: 3},
+            {task: 'ProcessingTask', status: :FAILED, progress: 0, max: 3},
+        ]
+
+        check_status_log run.items.first.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE},
+            {task: 'ProcessingTask', status: :FAILED},
+        ]
+
+      end
+
+    end
+
+  end
+
+  context 'with forcing final task' do
+    let(:force_run) {true}
+
+    context 'when processing successfully' do
+      let(:processing) {'success'}
+
+      it 'should run final task' do
+        run
+
+        check_output logoutput, <<STR
+ INFO -- Run - TestRun : Ingest run started.
+ INFO -- Run - TestRun : Running subtask (1/3): CollectFiles
+ INFO -- Run - TestRun : Running subtask (2/3): ProcessingTask
+ INFO -- ProcessingTask - TestRun : Task success
+ INFO -- ProcessingTask - TestRun : Task success
+ INFO -- ProcessingTask - TestRun : Task success
+ INFO -- Run - TestRun : Running subtask (3/3): FinalTask
+ INFO -- FinalTask - TestRun : Final processing of test_dir_item.rb
+ INFO -- FinalTask - TestRun : Final processing of test_file_item.rb
+ INFO -- FinalTask - TestRun : Final processing of test_run.rb
+ INFO -- Run - TestRun : Done
+STR
+
+        check_status_log run.status_log, [
+            {task: 'Run', status: :DONE, progress: 3, max: 3},
+            {task: 'CollectFiles', status: :DONE, progress: 1, max: 1},
+            {task: 'ProcessingTask', status: :DONE, progress: 1, max: 1},
+            {task: 'FinalTask', status: :DONE, progress: 1, max: 1},
+        ]
+
+        check_status_log run.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE, progress: 3, max: 3},
+            {task: 'ProcessingTask', status: :DONE, progress: 3, max: 3},
+            {task: 'FinalTask', status: :DONE, progress: 3, max: 3},
+        ]
+
+        check_status_log run.items.first.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE},
+            {task: 'ProcessingTask', status: :DONE},
+            {task: 'FinalTask', status: :DONE},
+        ]
+
+      end
+
+    end
+
+    context 'when stopped with async_halt' do
+      let(:processing) {'async_halt'}
+
+      it 'should run final task' do
+        run
+
+        check_output logoutput, <<STR
+ INFO -- Run - TestRun : Ingest run started.
+ INFO -- Run - TestRun : Running subtask (1/3): CollectFiles
+ INFO -- Run - TestRun : Running subtask (2/3): ProcessingTask
+ERROR -- ProcessingTask - TestRun : Task failed with async_halt status
+ERROR -- ProcessingTask - TestRun : Task failed with async_halt status
+ERROR -- ProcessingTask - TestRun : Task failed with async_halt status
+ WARN -- ProcessingTask - items : 3 subitem(s) halted in async process
+ WARN -- ProcessingTask - TestRun : 1 subitem(s) halted in async process
+ INFO -- Run - TestRun : Running subtask (3/3): FinalTask
+ INFO -- FinalTask - TestRun : Final processing of test_dir_item.rb
+ INFO -- FinalTask - TestRun : Final processing of test_file_item.rb
+ INFO -- FinalTask - TestRun : Final processing of test_run.rb
+ WARN -- Run - TestRun : 1 subtask(s) halted in async process
+ INFO -- Run - TestRun : Waiting for halted async process
+STR
+
+        check_status_log run.status_log, [
+            {task: 'Run', status: :ASYNC_HALT, progress: 3, max: 3},
+            {task: 'CollectFiles', status: :DONE, progress: 1, max: 1},
+            {task: 'ProcessingTask', status: :ASYNC_HALT, progress: 1, max: 1},
+            {task: 'FinalTask', status: :DONE, progress: 1, max: 1},
+        ]
+
+        check_status_log run.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE, progress: 3, max: 3},
+            {task: 'ProcessingTask', status: :ASYNC_HALT, progress: 3, max: 3},
+            {task: 'FinalTask', status: :DONE, progress: 3, max: 3},
+        ]
+
+        check_status_log run.items.first.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE},
+            {task: 'ProcessingTask', status: :ASYNC_HALT},
+            {task: 'FinalTask', status: :DONE},
+        ]
+
+      end
+
+    end
+
+    context 'when stopped with fail' do
+      let(:processing) {'fail'}
+
+      it 'should run final task' do
+        run
+
+        check_output logoutput, <<STR
+ INFO -- Run - TestRun : Ingest run started.
+ INFO -- Run - TestRun : Running subtask (1/3): CollectFiles
+ INFO -- Run - TestRun : Running subtask (2/3): ProcessingTask
+ERROR -- ProcessingTask - TestRun : Task failed with failed status
+ERROR -- ProcessingTask - TestRun : Task failed with failed status
+ERROR -- ProcessingTask - TestRun : Task failed with failed status
+ERROR -- ProcessingTask - items : 3 subitem(s) failed
+ERROR -- ProcessingTask - TestRun : 1 subitem(s) failed
+ INFO -- Run - TestRun : Running subtask (3/3): FinalTask
+ INFO -- FinalTask - TestRun : Final processing of test_dir_item.rb
+ INFO -- FinalTask - TestRun : Final processing of test_file_item.rb
+ INFO -- FinalTask - TestRun : Final processing of test_run.rb
+ERROR -- Run - TestRun : 1 subtask(s) failed
+ INFO -- Run - TestRun : Failed
+STR
+        check_status_log run.status_log, [
+            {task: 'Run', status: :FAILED, progress: 3, max: 3},
+            {task: 'CollectFiles', status: :DONE, progress: 1, max: 1},
+            {task: 'ProcessingTask', status: :FAILED, progress: 1, max: 1},
+            {task: 'FinalTask', status: :DONE, progress: 1, max: 1},
+        ]
+
+        check_status_log run.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE, progress: 3, max: 3},
+            {task: 'ProcessingTask', status: :FAILED, progress: 3, max: 3},
+            {task: 'FinalTask', status: :DONE, progress: 3, max: 3},
+        ]
+
+        check_status_log run.items.first.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE},
+            {task: 'ProcessingTask', status: :FAILED},
+            {task: 'FinalTask', status: :DONE},
+        ]
+
+      end
+
+      it 'should run final task during retry' do
+        run
+
+        logoutput.truncate(0)
+        run.run :retry
+
+        check_output logoutput, <<STR
+ INFO -- Run - TestRun : Ingest run started.
+ INFO -- Run - TestRun : Running subtask (2/3): ProcessingTask
+ERROR -- ProcessingTask - TestRun : Task failed with failed status
+ERROR -- ProcessingTask - TestRun : Task failed with failed status
+ERROR -- ProcessingTask - TestRun : Task failed with failed status
+ERROR -- ProcessingTask - items : 3 subitem(s) failed
+ERROR -- ProcessingTask - TestRun : 1 subitem(s) failed
+ INFO -- Run - TestRun : Running subtask (3/3): FinalTask
+ INFO -- FinalTask - TestRun : Final processing of test_dir_item.rb
+ INFO -- FinalTask - TestRun : Final processing of test_file_item.rb
+ INFO -- FinalTask - TestRun : Final processing of test_run.rb
+ERROR -- Run - TestRun : 1 subtask(s) failed
+ INFO -- Run - TestRun : Failed
+STR
+        check_status_log run.status_log, [
+            {task: 'Run', status: :FAILED, progress: 3, max: 3},
+            {task: 'CollectFiles', status: :DONE, progress: 1, max: 1},
+            {task: 'ProcessingTask', status: :FAILED, progress: 1, max: 1},
+            {task: 'FinalTask', status: :DONE, progress: 1, max: 1},
+            {task: 'Run', status: :FAILED, progress: 3, max: 3},
+            {task: 'ProcessingTask', status: :FAILED, progress: 1, max: 1},
+            {task: 'FinalTask', status: :DONE, progress: 1, max: 1},
+        ]
+
+        check_status_log run.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE, progress: 3, max: 3},
+            {task: 'ProcessingTask', status: :FAILED, progress: 3, max: 3},
+            {task: 'FinalTask', status: :DONE, progress: 3, max: 3},
+            {task: 'ProcessingTask', status: :FAILED, progress: 3, max: 3},
+            {task: 'FinalTask', status: :DONE, progress: 3, max: 3},
+        ]
+
+        check_status_log run.items.first.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE},
+            {task: 'ProcessingTask', status: :FAILED},
+            {task: 'FinalTask', status: :DONE},
+            {task: 'ProcessingTask', status: :FAILED},
+            {task: 'FinalTask', status: :DONE},
+        ]
+
+      end
+
+    end
+
+    context 'when stopped with error' do
+      let(:processing) {'error'}
+
+      it 'should run final task' do
+        run
+
+        check_output logoutput, <<STR
+ INFO -- Run - TestRun : Ingest run started.
+ INFO -- Run - TestRun : Running subtask (1/3): CollectFiles
+ INFO -- Run - TestRun : Running subtask (2/3): ProcessingTask
+ERROR -- ProcessingTask - items/test_dir_item.rb : Error processing subitem (1/3): Task failed with WorkflowError exception
+ERROR -- ProcessingTask - items/test_file_item.rb : Error processing subitem (2/3): Task failed with WorkflowError exception
+ERROR -- ProcessingTask - items/test_run.rb : Error processing subitem (3/3): Task failed with WorkflowError exception
+ERROR -- ProcessingTask - items : 3 subitem(s) failed
+ERROR -- ProcessingTask - TestRun : 1 subitem(s) failed
+ INFO -- Run - TestRun : Running subtask (3/3): FinalTask
+ INFO -- FinalTask - TestRun : Final processing of test_dir_item.rb
+ INFO -- FinalTask - TestRun : Final processing of test_file_item.rb
+ INFO -- FinalTask - TestRun : Final processing of test_run.rb
+ERROR -- Run - TestRun : 1 subtask(s) failed
+ INFO -- Run - TestRun : Failed
+STR
+        check_status_log run.status_log, [
+            {task: 'Run', status: :FAILED, progress: 3, max: 3},
+            {task: 'CollectFiles', status: :DONE, progress: 1, max: 1},
+            {task: 'ProcessingTask', status: :FAILED, progress: 1, max: 1},
+            {task: 'FinalTask', status: :DONE, progress: 1, max: 1},
+        ]
+
+        check_status_log run.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE, progress: 3, max: 3},
+            {task: 'ProcessingTask', status: :FAILED, progress: 0, max: 3},
+            {task: 'FinalTask', status: :DONE, progress: 3, max: 3},
+        ]
+
+        check_status_log run.items.first.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE},
+            {task: 'ProcessingTask', status: :FAILED},
+            {task: 'FinalTask', status: :DONE},
+        ]
+
+      end
+
+    end
+
+    context 'when stopped with abort' do
+      let(:processing) {'abort'}
+
+      it 'should run final task' do
+        run
+
+        check_output logoutput, <<STR
+ INFO -- Run - TestRun : Ingest run started.
+ INFO -- Run - TestRun : Running subtask (1/3): CollectFiles
+ INFO -- Run - TestRun : Running subtask (2/3): ProcessingTask
+FATAL -- ProcessingTask - items/test_dir_item.rb : Fatal error processing subitem (1/3): Task failed with WorkflowAbort exception
+ERROR -- ProcessingTask - items : 1 subitem(s) failed
+ERROR -- ProcessingTask - TestRun : 1 subitem(s) failed
+ INFO -- Run - TestRun : Running subtask (3/3): FinalTask
+ INFO -- FinalTask - TestRun : Final processing of test_dir_item.rb
+ INFO -- FinalTask - TestRun : Final processing of test_file_item.rb
+ INFO -- FinalTask - TestRun : Final processing of test_run.rb
+ERROR -- Run - TestRun : 1 subtask(s) failed
+ INFO -- Run - TestRun : Failed
+STR
+
+        check_status_log run.status_log, [
+            {task: 'Run', status: :FAILED, progress: 3, max: 3},
+            {task: 'CollectFiles', status: :DONE, progress: 1, max: 1},
+            {task: 'ProcessingTask', status: :FAILED, progress: 1, max: 1},
+            {task: 'FinalTask', status: :DONE, progress: 1, max: 1},
+        ]
+
+        check_status_log run.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE, progress: 3, max: 3},
+            {task: 'ProcessingTask', status: :FAILED, progress: 0, max: 3},
+            {task: 'FinalTask', status: :DONE, progress: 3, max: 3},
+        ]
+
+        check_status_log run.items.first.items.first.status_log, [
+            {task: 'CollectFiles', status: :DONE},
+            {task: 'ProcessingTask', status: :FAILED},
+            {task: 'FinalTask', status: :DONE},
+        ]
+
+      end
+
     end
 
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libis-workflow
 version: !ruby/object:Gem::Version
-  version: 2.0.36
+  version: 2.0.37
 platform: ruby
 authors:
 - Kris Dekeyser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-09 00:00:00.000000000 Z
+date: 2018-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: libis-tools
   requirement: !ruby/object:Gem::Requirement
@@ -170,6 +184,8 @@ files:
 - spec/tasks/camelize_name.rb
 - spec/tasks/checksum_tester.rb
 - spec/tasks/collect_files.rb
+- spec/tasks/final_task.rb
+- spec/tasks/processing_task.rb
 - spec/workflow_spec.rb
 homepage: https://github.com/Kris-LIBIS/workflow
 licenses:
@@ -205,4 +221,6 @@ test_files:
 - spec/tasks/camelize_name.rb
 - spec/tasks/checksum_tester.rb
 - spec/tasks/collect_files.rb
+- spec/tasks/final_task.rb
+- spec/tasks/processing_task.rb
 - spec/workflow_spec.rb