dynflow 1.2.2 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ddba15f840b26c5148fcebf8a0b69ff22abc0bba1fe70d2fa02e32722003011b
-  data.tar.gz: 4c7c6a7c3d23e1e0684ef61fa44ccf1cd44ff76cfba9c0e8e3b0587b9674ffeb
+  metadata.gz: 403ea79d6ea134104cc54ccaca3edbdce414306b944ccd957f37421ef7070d65
+  data.tar.gz: 7361cc2b7e099d7b537738880dd4197034a7323b9e386c6e937518518931cadc
 SHA512:
-  metadata.gz: a5b836d767ef81131f217d82467d96410c63140bb38e247489b33b9386df2ddb30aff56da3b42bff216fd6a419f714176d0e111415e6793c3c534bdbfcbd6938
-  data.tar.gz: 01a74517eb6500b5e986759d017f2886c1a5032d81e026d1e41450033935dfab9c342bf4ced411da56b2cf3daefd79a82a1137d97030567bbcbe517a4e9599cb
+  metadata.gz: 0b8f9367989b27fc3a55294659441c3d0360ccc87d752cebd1f723d5a68400083ec0a0330a29811b868b87b459bf651a1c8fc3bce5c8399556cc26671c0c3d54
+  data.tar.gz: 95248248daebcf5d83b9be6bf3593a1ed55b41d5ef048180d30464091810d36361bdf3bdbc688f58625cdd6f5fdbb2a558fd1d8f56063b21cf65c8f03a8f8458

data/Gemfile

@@ -28,6 +28,10 @@ if RUBY_VERSION < "2.2.2"
   gem 'sinatra', '~> 1.4.8'
 end
 
+if RUBY_VERSION < '2.3.0'
+  gem 'i18n', '<= 1.5.1'
+end
+
 group :lint do
   gem 'rubocop', '0.39.0'
 end

data/lib/dynflow/action.rb

@@ -571,7 +571,15 @@ module Dynflow
     end
 
     def root_action?
-      @triggering_action.nil?
+      # in planning phase, the @triggered_action can be used to check whether the is root (the main action used
+      # to create the execution plan).
+      # For post-planning phases, the action is in root when either:
+      #   - the @caller_action_id is not set OR
+      #   - the @caller_action_id is set but the @caller_execution_plan_id is set as well
+      #     which means, the @caller_action_id is actually referencing different execution plan
+      #     and this action is creating a new execution plan, that's tracked as sub-plan
+      #     for the @caller_execution_plan_id
+      @triggering_action.nil? && (@caller_action_id.nil? || @caller_execution_plan_id)
     end
 
     # An action must be a singleton and have a singleton lock

data/lib/dynflow/delayed_plan.rb

@@ -34,15 +34,13 @@ module Dynflow
       execution_plan.root_plan_step.state = :error
       execution_plan.root_plan_step.error = ::Dynflow::ExecutionPlan::Steps::Error.new(message)
       execution_plan.root_plan_step.save
-      execution_plan.execution_history.add history_entry, @world.id unless history_entry.nil?
-      execution_plan.update_state :stopped
+      execution_plan.update_state :stopped, history_notice: history_entry
     end
 
     def cancel
       execution_plan.root_plan_step.state = :cancelled
       execution_plan.root_plan_step.save
-      execution_plan.execution_history.add "Delayed task cancelled", @world.id
-      execution_plan.update_state :stopped
+      execution_plan.update_state :stopped, history_notice: "Delayed task cancelled"
       @world.persistence.delete_delayed_plans(:execution_plan_uuid => @execution_plan_uuid)
       return true
     end

data/lib/dynflow/director.rb

@@ -187,7 +187,7 @@ module Dynflow
       if new_state == :running
         return manager.restart
       else
-        manager.execution_plan.state = new_state
+        manager.execution_plan.update_state(new_state)
         return false
       end
     end
@@ -217,20 +217,12 @@ module Dynflow
       case execution_plan.state
       when :running
         if execution_plan.error?
-          execution_plan.execution_history.add('pause execution', @world.id)
           execution_plan.update_state(:paused)
         elsif manager.done?
-          execution_plan.execution_history.add('finish execution', @world.id)
           execution_plan.update_state(:stopped)
         end
         # If the state is marked as running without errors but manager is not done,
         # we let the invalidation procedure to handle re-execution on other executor
-      when :paused
-        execution_plan.execution_history.add('pause execution', @world.id)
-        execution_plan.save
-      when :stopped
-        execution_plan.execution_history.add('finish execution', @world.id)
-        execution_plan.save
       end
     end
 

data/lib/dynflow/director/execution_plan_manager.rb

@@ -15,7 +15,6 @@ module Dynflow
         unless [:planned, :paused].include? execution_plan.state
           raise "execution_plan is not in pending or paused state, it's #{execution_plan.state}"
         end
-        execution_plan.execution_history.add('start execution', @world.id)
         execution_plan.update_state(:running)
       end
 

data/lib/dynflow/execution_plan.rb

@@ -110,7 +110,13 @@ module Dynflow
       @world.logger
     end
 
-    def update_state(state)
+    # @param state [Symbol] representing the new state
+    # @param history_notice [Symbol|string|false] should a note to execution_history be added as well?
+    #   Possible values:
+    #     - :auto (default) - the history notice will be added based on the new state
+    #     - string - custom history notice is added
+    #     - false - don't add any notice
+    def update_state(state, history_notice: :auto)
       hooks_to_run = [state]
       original = self.state
       case self.state = state
@@ -134,6 +140,7 @@ module Dynflow
       end
       logger.debug format('%13s %s    %9s >> %9s',
                           'ExecutionPlan', id, original, state)
+      add_history_notice(history_notice)
       self.save
       toggle_telemetry_state original == :pending ? nil : original.to_s,
                              self.state == :stopped ? nil : self.state.to_s
@@ -246,7 +253,6 @@ module Dynflow
     def delay(caller_action, action_class, delay_options, *args)
       save
       @root_plan_step = add_scheduling_step(action_class, caller_action)
-      execution_history.add("delay", @world.id)
       serializer = root_plan_step.delay(delay_options, args)
       delayed_plan = DelayedPlan.new(@world,
                                      id,
@@ -563,6 +569,22 @@ module Dynflow
       { :world => @world.id, :action => @label }
     end
 
+    def add_history_notice(history_notice)
+      if history_notice == :auto
+        history_notice = case state
+                         when :running
+                           'start execution'
+                         when :paused
+                           'pause execution'
+                         when :stopped
+                           'finish execution'
+                         when :scheduled
+                           'delay'
+                         end
+      end
+      execution_history.add(history_notice, @world.id) if history_notice
+    end
+
     private_class_method :steps_from_hash
   end
   # rubocop:enable Metrics/ClassLength

data/lib/dynflow/logger_adapters/formatters/abstract.rb

@@ -7,7 +7,7 @@ module Dynflow
         end
 
         [:fatal, :error, :warn, :info, :debug].each do |method|
-          define_method method do |message, &block|
+          define_method method do |message = nil, &block|
             if block
               @base.send method, &-> { format(block.call) }
             else

data/lib/dynflow/logger_adapters/simple.rb

@@ -41,7 +41,7 @@ module Dynflow
         end
 
         { fatal: 4, error: 3, warn: 2, info: 1, debug: 0 }.each do |method, level|
-          define_method method do |message, &block|
+          define_method method do |message = nil, &block|
             @logger.add level, message, @prog_name, &block
           end
         end

data/lib/dynflow/version.rb

@@ -1,3 +1,3 @@
 module Dynflow
-  VERSION = '1.2.2'.freeze
+  VERSION = '1.2.3'.freeze
 end

data/lib/dynflow/world/invalidation.rb

@@ -33,8 +33,6 @@ module Dynflow
       # @return [void]
       def invalidate_execution_lock(execution_lock)
         with_valid_execution_plan_for_lock(execution_lock) do |plan|
-          plan.execution_history.add('terminate execution', execution_lock.world_id)
-
           plan.steps.values.each do |step|
             if step.state == :running
               step.error = ExecutionPlan::Steps::Error.new("Abnormal termination (previous state: #{step.state})")
@@ -43,7 +41,8 @@ module Dynflow
             end
           end
 
-          plan.update_state(:paused) if plan.state == :running
+          plan.execution_history.add('terminate execution', execution_lock.world_id)
+          plan.update_state(:paused, history_notice: false) if plan.state == :running
           plan.save
           coordinator.release(execution_lock)
 

data/test/action_test.rb

@@ -344,10 +344,19 @@ module Dynflow
         end
       end
 
+      class DummyAction < Dynflow::Action
+        def run; end
+      end
+
       class ParentAction < Dynflow::Action
 
         include Dynflow::Action::WithSubPlans
 
+        def plan(*_)
+          super
+          plan_action(DummyAction, {})
+        end
+
         def create_sub_plans
           input[:count].times.map { trigger(ChildAction, suspend: input[:suspend]) }
         end
@@ -365,6 +374,7 @@ module Dynflow
           if FailureSimulator.fail_in_child_plan
             raise "Fail in child plan"
           end
+          plan_action(DummyAction, {})
           super
         end
 
@@ -437,6 +447,14 @@ module Dynflow
         sub_plans.each { |sub_plan| sub_plan.caller_execution_plan_id.must_equal execution_plan.id }
       end
 
+      specify "the parent and sub-plan actions return root_action? properly" do
+        assert execution_plan.actions.first.send(:root_action?), 'main action of parent task should be considered a root_action?'
+        refute execution_plan.actions.last.send(:root_action?), 'sub action of parent task should not be considered a root_action?'
+        sub_plan = execution_plan.sub_plans.first
+        assert sub_plan.actions.first.send(:root_action?), 'main action of sub-task should be considered a root_action?'
+        refute sub_plan.actions.last.send(:root_action?), 'sub action of sub-task should not be considered a root_action?'
+      end
+
       specify "it saves the information about number for sub plans in the output" do
         execution_plan.entry_action.output.must_equal('total_count'   => 2,
                                                       'failed_count'  => 0,

data/test/execution_plan_hooks_test.rb

@@ -9,16 +9,19 @@ module Dynflow
 
       class Flag
         class << self
+          attr_accessor :raised_count
+
           def raise!
-            @raised = true
+            self.raised_count ||= 0
+            self.raised_count += 1
           end
 
           def raised?
-            @raised
+            raised_count > 0
           end
 
           def lower!
-            @raised = false
+            self.raised_count = 0
           end
         end
       end
@@ -32,6 +35,10 @@ module Dynflow
           Flag.raise!
           raise "A controlled failure"
         end
+
+        def raise_flag_root_only(_execution_plan)
+          Flag.raise! if root_action?
+        end
       end
 
       class ActionWithHooks < ::Dynflow::Action
@@ -46,12 +53,39 @@ module Dynflow
         execution_plan_hooks.use :controlled_failure, :on => :stopped
       end
 
+      class RootOnlyAction < ::Dynflow::Action
+        include FlagHook
+
+        execution_plan_hooks.use :raise_flag_root_only, :on => :stopped
+      end
+
+      class ComposedAction < RootOnlyAction
+        def plan
+          plan_action(RootOnlyAction)
+          plan_action(RootOnlyAction)
+        end
+      end
+
       class ActionOnFailure < ::Dynflow::Action
         include FlagHook
 
         execution_plan_hooks.use :raise_flag, :on => :failure
       end
 
+      class ActionOnPause < ::Dynflow::Action
+        include FlagHook
+
+        def run
+          error!("pause")
+        end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Pause
+        end
+
+        execution_plan_hooks.use :raise_flag, :on => :paused
+      end
+
       class Inherited < ActionWithHooks; end
       class Overriden < ActionWithHooks
         execution_plan_hooks.do_not_use :raise_flag
@@ -67,6 +101,28 @@ module Dynflow
         assert Flag.raised?
       end
 
+      it 'runs the on_pause hook' do
+        refute Flag.raised?
+        plan = world.trigger(ActionOnPause)
+        plan.finished.wait!
+        assert Flag.raised?
+      end
+
+      describe 'with auto_rescue' do
+        let(:world) do
+          WorldFactory.create_world do |config|
+            config.auto_rescue = true
+          end
+        end
+
+        it 'runs the on_pause hook' do
+          refute Flag.raised?
+          plan = world.trigger(ActionOnPause)
+          plan.finished.wait!
+          assert Flag.raised?
+        end
+      end
+
       it 'runs the on_failure hook on cancel' do
         refute Flag.raised?
         @start_at = Time.now.utc + 180
@@ -97,6 +153,13 @@ module Dynflow
         plan.finished.wait!
         refute Flag.raised?
       end
+
+      it 'can determine in side the hook, whether the hook is running for root action or sub-action' do
+        refute Flag.raised?
+        plan = world.trigger(ComposedAction)
+        plan.finished.wait!
+        Flag.raised_count.must_equal 1
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynflow
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.2.3
 platform: ruby
 authors:
 - Ivan Necas
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-27 00:00:00.000000000 Z
+date: 2019-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json