dynflow 0.6.2 → 0.7.0

data/lib/dynflow/execution_plan/steps/run_step.rb

@@ -4,18 +4,36 @@ module Dynflow
 
       def self.state_transitions
         @state_transitions ||= {
-            pending:   [:running, :skipped], # :skipped when it cannot be run because it depends on skipped step
+            pending:   [:running, :skipped], # :skipped when it cannot be run because it depends on skipping step
             running:   [:success, :error, :suspended],
             success:   [:suspended], # after not-done process_update
             suspended: [:running, :error], # process_update, e.g. error in setup_progress_updates
+            skipping:  [:error, :skipped], # waiting for the skip method to be called
             skipped:   [],
-            error:     [:skipped, :running]
+            error:     [:skipping, :running]
         }
       end
 
       def phase
         Action::Run
       end
+
+      def cancellable?
+        [:suspended, :running].include?(self.state) &&
+            self.action_class < Action::Cancellable
+      end
+
+      def mark_to_skip
+        case self.state
+        when :error
+          self.state = :skipping
+        when :pending
+          self.state = :skipped
+        else
+          raise "Skipping step in #{self.state} is not supported"
+        end
+        self.save
+      end
     end
   end
 end

data/lib/dynflow/executors/parallel/core.rb

@@ -14,6 +14,7 @@ module Dynflow
           @world                   = Type! world, World
           @pool                    = Pool.new(self, pool_size, world.transaction_adapter)
           @execution_plan_managers = {}
+          @plan_ids_in_rescue      = Set.new
         end
 
         def on_message(message)
@@ -77,13 +78,29 @@ module Dynflow
 
         def continue_manager(manager, next_work)
           if manager.done?
-            loose_manager_and_set_future manager.execution_plan.id
-            try_to_terminate
+            finish_plan manager.execution_plan.id
           else
             feed_pool next_work
           end
         end
 
+        def rescue?(manager)
+          @world.auto_rescue && manager.execution_plan.state == :paused &&
+              !@plan_ids_in_rescue.include?(manager.execution_plan.id)
+        end
+
+        def rescue!(manager)
+          # TODO: after moving to concurrent-ruby actors, there should be better place
+          # to put this logic of making sure we don't run rescues in endless loop
+          @plan_ids_in_rescue << manager.execution_plan.id
+          rescue_plan_id = manager.execution_plan.rescue_plan_id
+          if rescue_plan_id
+            self << Parallel::Execution[rescue_plan_id, manager.future]
+          else
+            set_future(manager)
+          end
+        end
+
         def feed_pool(work_items)
           Type! work_items, Array, Work, NilClass
           return if work_items.nil?
@@ -92,11 +109,22 @@ module Dynflow
           work_items.each { |new_work| @pool << new_work }
         end
 
-        def loose_manager_and_set_future(execution_plan_id)
+        def finish_plan(execution_plan_id)
           manager = @execution_plan_managers.delete(execution_plan_id)
+          if rescue?(manager)
+            rescue!(manager)
+          else
+            set_future(manager)
+          end
+        end
+
+        def set_future(manager)
+          @plan_ids_in_rescue.delete(manager.execution_plan.id)
           manager.future.resolve manager.execution_plan
+          try_to_terminate
         end
 
+
         def event(event)
           Type! event, Parallel::Event
           execution_plan_manager = @execution_plan_managers[event.execution_plan_id]

data/lib/dynflow/version.rb

@@ -1,3 +1,3 @@
 module Dynflow
-  VERSION = '0.6.2'
+  VERSION = '0.7.0'
 end

data/lib/dynflow/web_console.rb

@@ -95,7 +95,7 @@ module Dynflow
           classes << "success"
         when :error
           classes << "error"
-        when :skipped
+        when :skipped, :skipping
           classes << "skipped"
         end
         return classes.join(" ")
@@ -256,6 +256,7 @@ module Dynflow
 
     get('/:id') do |id|
       @plan = world.persistence.load_execution_plan(id)
+      @notice = params[:notice]
       erb :show
     end
 
@@ -282,5 +283,16 @@ module Dynflow
       end
     end
 
+    post('/:id/cancel/:step_id') do |id, step_id|
+      plan = world.persistence.load_execution_plan(id)
+      step = plan.steps[step_id.to_i]
+      if step.cancellable?
+        world.event(plan.id, step.id, Dynflow::Action::Cancellable::Cancel)
+        redirect(url "/#{plan.id}?notice=#{url_encode('The step was asked to cancel')}")
+      else
+        redirect(url "/#{plan.id}?notice=#{url_encode('The step does not support cancelling')}")
+      end
+    end
+
   end
 end

data/lib/dynflow/world.rb

@@ -3,7 +3,7 @@ module Dynflow
     include Algebrick::TypeCheck
 
     attr_reader :executor, :persistence, :transaction_adapter, :action_classes, :subscription_index,
-                :logger_adapter, :options, :middleware
+                :logger_adapter, :options, :middleware, :auto_rescue
 
     def initialize(options_hash = {})
       @options             = default_options.merge options_hash
@@ -13,6 +13,7 @@ module Dynflow
       @persistence         = Persistence.new(self, persistence_adapter)
       @executor            = Type! option_val(:executor), Executors::Abstract
       @action_classes      = option_val(:action_classes)
+      @auto_rescue         = option_val(:auto_rescue)
       @middleware          = Middleware::World.new
       calculate_subscription_index
 
@@ -26,7 +27,8 @@ module Dynflow
       @default_options ||=
           { action_classes: Action.all_children,
             logger_adapter: LoggerAdapters::Simple.new,
-            executor:       -> world { Executors::Parallel.new(world, options[:pool_size]) } }
+            executor:       -> world { Executors::Parallel.new(world, options[:pool_size]) },
+            auto_rescue:    true }
     end
 
     def clock

data/test/execution_plan_test.rb

@@ -96,8 +96,8 @@ module Dynflow
             end
           end
 
-          it 'should be :success' do
-            execution_plan.result.must_equal :success
+          it 'should be :warning' do
+            execution_plan.result.must_equal :warning
           end
 
         end
@@ -246,6 +246,19 @@ module Dynflow
           end
         end
       end
+
+      describe ExecutionPlan::Steps::Error do
+
+        it "doesn't fail when deserializing with missing class" do
+          error = ExecutionPlan::Steps::Error.new_from_hash(exception_class: "RenamedError",
+                                                            message: "This errror is not longer here",
+                                                            backtrace: [])
+          error.exception_class.name.must_equal "RenamedError"
+          error.exception_class.to_s.must_equal "Dynflow::Errors::UnknownError[RenamedError]"
+          error.exception.inspect.must_equal "Dynflow::Errors::UnknownError[RenamedError]: This errror is not longer here"
+        end
+
+      end
     end
   end
 end

data/test/executor_test.rb

@@ -556,7 +556,7 @@ module Dynflow
 
             it "runs all pending steps except skipped" do
               resumed_execution_plan.state.must_equal :stopped
-              resumed_execution_plan.result.must_equal :success
+              resumed_execution_plan.result.must_equal :warning
 
               run_triages = TestExecutionLog.run.find_all do |action_class, input|
                 action_class == Support::CodeWorkflowExample::Triage

data/test/persistance_adapters_test.rb

@@ -103,7 +103,7 @@ module PersistenceAdapterTest
 
 end
 
-class SequelTest < MiniTest::Test
+class SequelTest < MiniTest::Spec
   include PersistenceAdapterTest
 
   def storage

data/test/rescue_test.rb

@@ -0,0 +1,164 @@
+require_relative 'test_helper'
+
+module Dynflow
+  module RescueTest
+    describe 'on error' do
+
+      Example = Support::RescueExample
+
+      include WorldInstance
+
+      def execute(*args)
+        plan = world.plan(*args)
+        raise plan.errors.first if plan.error?
+        world.execute(plan.id).value
+      end
+
+      let :rescued_plan do
+        execution_plan.rescue_from_error.value
+      end
+
+      describe 'of simple skippable action in run phase' do
+
+        let :execution_plan do
+          execute(Example::ActionWithSkip, 1, :error_on_run)
+        end
+
+        it 'suggests skipping the action' do
+          execution_plan.rescue_strategy.must_equal Action::Rescue::Skip
+        end
+
+        it 'skips the action and continues' do
+          rescued_plan.state.must_equal :stopped
+          rescued_plan.result.must_equal :warning
+          rescued_plan.entry_action.output[:message].
+              must_equal "skipped because some error as you wish"
+        end
+
+      end
+
+      describe 'of simple skippable action in finalize phase' do
+
+        let :execution_plan do
+          execute(Example::ActionWithSkip, 1, :error_on_finalize)
+        end
+
+        it 'suggests skipping the action' do
+          execution_plan.rescue_strategy.must_equal Action::Rescue::Skip
+        end
+
+        it 'skips the action and continues' do
+          rescued_plan.state.must_equal :stopped
+          rescued_plan.result.must_equal :warning
+          rescued_plan.entry_action.output[:message].must_equal "Been here"
+        end
+
+      end
+
+      describe 'of complex action with skips in run phase' do
+
+        let :execution_plan do
+          execute(Example::ComplexActionWithSkip, :error_on_run)
+        end
+
+        it 'suggests skipping the action' do
+          execution_plan.rescue_strategy.must_equal Action::Rescue::Skip
+        end
+
+        it 'skips the action and continues' do
+          rescued_plan.state.must_equal :stopped
+          rescued_plan.result.must_equal :warning
+          skipped_action = rescued_plan.actions.find do |action|
+            action.run_step && action.run_step.state == :skipped
+          end
+          skipped_action.output[:message].must_equal "skipped because some error as you wish"
+        end
+
+      end
+
+      describe 'of complex action with skips in finalize phase' do
+
+        let :execution_plan do
+          execute(Example::ComplexActionWithSkip, :error_on_finalize)
+        end
+
+        it 'suggests skipping the action' do
+          execution_plan.rescue_strategy.must_equal Action::Rescue::Skip
+        end
+
+        it 'skips the action and continues' do
+          rescued_plan.state.must_equal :stopped
+          rescued_plan.result.must_equal :warning
+          skipped_action = rescued_plan.actions.find do |action|
+            action.steps.find { |step| step && step.state == :skipped }
+          end
+          skipped_action.output[:message].must_equal "Been here"
+        end
+
+      end
+
+      describe 'of complex action without skips' do
+
+        let :execution_plan do
+          execute(Example::ComplexActionWithoutSkip, :error_on_run)
+        end
+
+        it 'suggests pausing the plan' do
+          execution_plan.rescue_strategy.must_equal Action::Rescue::Pause
+        end
+
+        it 'fails rescuing' do
+          lambda { rescued_plan }.must_raise Errors::RescueError
+        end
+
+      end
+
+      describe 'auto rescue' do
+
+        def world
+          @world ||= WorldInstance.create_world(auto_rescue: true)
+        end
+
+        describe 'of plan with skips' do
+
+           let :execution_plan do
+             execute(Example::ComplexActionWithSkip, :error_on_run)
+           end
+
+           it 'skips the action and continues automatically' do
+             execution_plan.state.must_equal :stopped
+             execution_plan.result.must_equal :warning
+           end
+
+        end
+
+        describe 'of plan faild on auto-rescue' do
+
+           let :execution_plan do
+             execute(Example::ActionWithSkip, 1, :error_on_skip)
+           end
+
+           it 'tryied to rescue only once' do
+             execution_plan.state.must_equal :paused
+             execution_plan.result.must_equal :error
+           end
+
+        end
+
+        describe 'of plan without skips' do
+
+          let :execution_plan do
+             execute(Example::ComplexActionWithoutSkip, :error_on_run)
+           end
+
+           it 'skips the action and continues automatically' do
+             execution_plan.state.must_equal :paused
+             execution_plan.result.must_equal :error
+           end
+
+        end
+
+      end
+    end
+  end
+end

data/test/support/code_workflow_example.rb

@@ -263,9 +263,10 @@ module Support
     end
 
     class CancelableSuspended < Dynflow::Action
-      include Dynflow::Action::CancellablePolling
+      include Dynflow::Action::Polling
+      include Dynflow::Action::Cancellable
 
-      Cancel = Dynflow::Action::CancellablePolling::Cancel
+      Cancel = Dynflow::Action::Cancellable::Cancel
 
       def invoke_external_task
         { progress: 0 }
@@ -288,9 +289,9 @@ module Support
         { progress: new_progress }
       end
 
-      def cancel_external_task
+      def cancel!
         if input[:text] !~ /cancel-fail/
-          external_task.merge(cancelled: true)
+          self.external_task = external_task.merge(cancelled: true)
         else
           error! 'action cancelled'
         end

data/test/support/rescue_example.rb

@@ -0,0 +1,73 @@
+require 'logger'
+
+module Support
+  module RescueExample
+
+    class ComplexActionWithSkip < Dynflow::Action
+
+      def plan(error_state)
+        sequence do
+          concurrence do
+            plan_action(ActionWithSkip, 3, :success)
+            plan_action(ActionWithSkip, 4, error_state)
+          end
+          plan_action(ActionWithSkip, 5, :success)
+        end
+      end
+    end
+
+    class ComplexActionWithoutSkip < ComplexActionWithSkip
+
+      def rescue_strategy_for_planned_action(action)
+        # enforce pause even when error on skipable action
+        Dynflow::Action::Rescue::Pause
+      end
+
+    end
+
+    class AbstractAction < Dynflow::Action
+
+      def plan(identifier, desired_state)
+        plan_self(identifier: identifier, desired_state: desired_state)
+      end
+
+      def run
+        case input[:desired_state].to_sym
+        when :success, :error_on_finalize
+          output[:message] = 'Been here'
+        when :error_on_run, :error_on_skip
+          raise 'some error as you wish'
+        when :pending
+          raise 'we were not supposed to get here'
+        else
+          raise "unkown desired state #{input[:desired_state]}"
+        end
+      end
+
+      def finalize
+        case input[:desired_state].to_sym
+        when :error_on_finalize, :error_on_skip
+          raise 'some error as you wish'
+        end
+      end
+
+    end
+
+    class ActionWithSkip < AbstractAction
+
+      def run(event = nil)
+        if event === Dynflow::Action::Skip
+          output[:message] = "skipped because #{self.error.message}"
+          raise 'we failed on skip as well' if input[:desired_state].to_sym == :error_on_skip
+        else
+          super()
+        end
+      end
+
+      def rescue_strategy_for_self
+        Dynflow::Action::Rescue::Skip
+      end
+
+    end
+  end
+end