dynflow 0.7.6 → 0.7.7

data/lib/dynflow/execution_plan.rb

@@ -97,6 +97,10 @@ module Dynflow
       result == :error
     end
 
+    def error_in_plan?
+      steps_in_state(:error).any? { |step| step.is_a? Steps::PlanStep }
+    end
+
     def errors
       steps.values.map(&:error).compact
     end
@@ -105,6 +109,10 @@ module Dynflow
       Type! entry_action.rescue_strategy, Action::Rescue::Strategy
     end
 
+    def sub_plans
+      persistence.find_execution_plans(filters: { 'caller_execution_plan_id' => self.id })
+    end
+
     def rescue_plan_id
       case rescue_strategy
       when Action::Rescue::Pause
@@ -141,9 +149,12 @@ module Dynflow
       @last_step_id += 1
     end
 
-    def prepare(action_class)
+    def prepare(action_class, options = {})
+      options = options.dup
+      caller_action = Type! options.delete(:caller_action), Dynflow::Action, NilClass
+      raise "Unexpected options #{options.keys.inspect}" unless options.empty?
       save
-      @root_plan_step = add_plan_step(action_class)
+      @root_plan_step = add_plan_step(action_class, caller_action)
       @root_plan_step.save
     end
 
@@ -226,9 +237,13 @@ module Dynflow
       current_run_flow.add_and_resolve(@dependency_graph, new_flow) if current_run_flow
     end
 
-    def add_plan_step(action_class, planned_by = nil)
-      add_step(Steps::PlanStep, action_class, generate_action_id, planned_by && planned_by.plan_step_id).tap do |step|
-        step.initialize_action
+    def add_plan_step(action_class, caller_action = nil)
+      add_step(Steps::PlanStep, action_class, generate_action_id).tap do |step|
+        # TODO: to be removed and preferred by the caller_action
+        if caller_action && caller_action.execution_plan_id == self.id
+          @steps[caller_action.plan_step_id].children << step.id
+        end
+        step.initialize_action(caller_action)
       end
     end
 
@@ -312,13 +327,17 @@ module Dynflow
       end
     end
 
+    def caller_execution_plan_id
+      entry_action.caller_execution_plan_id
+    end
+
     private
 
     def persistence
       world.persistence
     end
 
-    def add_step(step_class, action_class, action_id, planned_by_step_id = nil)
+    def add_step(step_class, action_class, action_id)
       step_class.new(self.id,
                      self.generate_step_id,
                      :pending,
@@ -327,7 +346,6 @@ module Dynflow
                      nil,
                      world).tap do |new_step|
         @steps[new_step.id] = new_step
-        @steps[planned_by_step_id].children << new_step.id if planned_by_step_id
       end
     end
 

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

@@ -113,8 +113,7 @@ module Dynflow
       # @return [Action] in presentation mode, intended for retrieving: progress information,
       # details, human outputs, etc.
       def action(execution_plan)
-        attributes = world.persistence.adapter.load_action(execution_plan_id, action_id)
-        Action.from_hash(attributes.update(phase: Action::Present, execution_plan: execution_plan), world)
+        world.persistence.load_action_for_presentation(execution_plan, action_id)
       end
 
       def skippable?
@@ -125,6 +124,10 @@ module Dynflow
         false
       end
 
+      def with_sub_plans?
+        false
+      end
+
       protected
 
       def self.new_from_hash(hash, execution_plan_id, world)

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

@@ -76,14 +76,18 @@ module Dynflow
             hash[:children]
       end
 
-      def initialize_action
+      def initialize_action(caller_action)
         attributes = { execution_plan_id: execution_plan_id,
                        id:                action_id,
                        step:              self,
                        plan_step_id:      self.id,
                        run_step_id:       nil,
                        finalize_step_id:  nil,
-                       phase:             phase}
+                       phase:             phase }
+        if caller_action
+          attributes.update(caller_execution_plan_id: caller_action.execution_plan_id,
+                            caller_action_id:         caller_action.id)
+        end
         @action = action_class.new(attributes, world)
         persistence.save_action(execution_plan_id, @action)
         @action

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

@@ -23,6 +23,10 @@ module Dynflow
             self.action_class < Action::Cancellable
       end
 
+      def with_sub_plans?
+        self.action_class < Action::WithSubPlans
+      end
+
       def mark_to_skip
         case self.state
         when :error

data/lib/dynflow/persistence.rb

@@ -19,6 +19,11 @@ module Dynflow
       return Action.from_hash(attributes, step.world)
     end
 
+    def load_action_for_presentation(execution_plan, action_id)
+      attributes = adapter.load_action(execution_plan.id, action_id)
+      Action.from_hash(attributes.update(phase: Action::Present, execution_plan: execution_plan), @world)
+    end
+
     def save_action(execution_plan_id, action)
       adapter.save_action(execution_plan_id, action.id, action.to_hash)
     end

data/lib/dynflow/persistence_adapters/sequel.rb

@@ -27,7 +27,7 @@ module Dynflow
       end
 
       META_DATA = { execution_plan: %w(state result started_at ended_at real_time execution_time),
-                    action:         [],
+                    action:         %w(caller_execution_plan_id caller_action_id),
                     step:           %w(state started_at ended_at real_time execution_time action_id progress_done progress_weight) }
 
       def initialize(config)
@@ -151,8 +151,18 @@ module Dynflow
       def filter(data_set, options)
         filters = Type! options[:filters], NilClass, Hash
         return data_set if filters.nil?
+        unknown = filters.keys - META_DATA.fetch(:execution_plan) - %w[caller_execution_plan_id caller_action_id]
 
-        unless (unknown = filters.keys - META_DATA.fetch(:execution_plan)).empty?
+        if filters.key?('caller_action_id') && !filters.key?('caller_execution_plan_id')
+          raise ArgumentError, "caller_action_id given but caller_execution_plan_id missing"
+        end
+
+        if filters.key?('caller_execution_plan_id')
+          data_set = data_set.join_table(:inner, TABLES[:action], :execution_plan_uuid => :uuid).
+              select_all(TABLES[:execution_plan]).distinct
+        end
+
+        unless (unknown).empty?
           raise ArgumentError, "unkown columns: #{unknown.inspect}"
         end
 

data/lib/dynflow/persistence_adapters/sequel_migrations/003_parent_action.rb

@@ -0,0 +1,9 @@
+Sequel.migration do
+  change do
+    alter_table(:dynflow_actions) do
+      add_column :caller_execution_plan_id, String, fixed: true, size: 36
+      add_column :caller_action_id, Fixnum
+      add_index [:caller_execution_plan_id, :caller_action_id]
+    end
+  end
+end

data/lib/dynflow/version.rb

@@ -1,3 +1,3 @@
 module Dynflow
-  VERSION = '0.7.6'
+  VERSION = '0.7.7'
 end

data/lib/dynflow/web_console.rb

@@ -143,7 +143,7 @@ module Dynflow
       end
 
       def updated_url(new_params)
-        url("?" + Rack::Utils.build_nested_query(params.merge(new_params.stringify_keys)))
+        url(request.path_info + "?" + Rack::Utils.build_nested_query(params.merge(new_params.stringify_keys)))
       end
 
       def paginated_url(delta)
@@ -211,7 +211,7 @@ module Dynflow
         end
       end
 
-      def filtering_options
+      def filtering_options(show_all = false)
         return @filtering_options if @filtering_options
 
         if params[:filters]
@@ -223,7 +223,8 @@ module Dynflow
 
           filters = params[:filters]
         elsif supported_filter?('state')
-          filters = { 'state' => ExecutionPlan.states.map(&:to_s) - ['stopped'] }
+          excluded_states = show_all ? [] : ['stopped']
+          filters = { 'state' => ExecutionPlan.states.map(&:to_s) - excluded_states }
         else
           filters = {}
         end
@@ -231,6 +232,13 @@ module Dynflow
         return @filtering_options
       end
 
+      def find_execution_plans_options(show_all = false)
+        options = HashWithIndifferentAccess.new
+        options.merge!(filtering_options(show_all))
+        options.merge!(pagination_options)
+        options.merge!(ordering_options)
+      end
+
       def filter_checkbox(field, values)
         out        = "<p>#{field}: %s</p>"
         checkboxes = values.map do |value|
@@ -245,15 +253,21 @@ module Dynflow
     end
 
     get('/') do
-      options = HashWithIndifferentAccess.new
-      options.merge!(filtering_options)
-      options.merge!(pagination_options)
-      options.merge!(ordering_options)
+      options = find_execution_plans_options
 
       @plans = world.persistence.find_execution_plans(options)
       erb :index
     end
 
+    get('/:execution_plan_id/actions/:action_id/sub_plans') do |execution_plan_id, action_id|
+      options = find_execution_plans_options(true)
+      options[:filters].update('caller_execution_plan_id' => execution_plan_id,
+                               'caller_action_id' => action_id)
+      @plans = world.persistence.find_execution_plans(options)
+      erb :index
+    end
+
+
     get('/:id') do |id|
       @plan = world.persistence.load_execution_plan(id)
       @notice = params[:notice]

data/lib/dynflow/world.rb

@@ -91,8 +91,14 @@ module Dynflow
 
     # @return [TriggerResult]
     # blocks until action_class is planned
-    def trigger(action_class, *args)
-      execution_plan = plan(action_class, *args)
+    # if no arguments given, the plan is expected to be returned by a block
+    def trigger(action_class = nil, *args, &block)
+      if action_class.nil?
+        raise 'Neither action_class nor a block given' if block.nil?
+        execution_plan = block.call(self)
+      else
+        execution_plan = plan(action_class, *args)
+      end
       planned        = execution_plan.state == :planned
 
       if planned
@@ -107,7 +113,14 @@ module Dynflow
     end
 
     def event(execution_plan_id, step_id, event, future = Future.new)
+      # we do this to avoid unresolved future when getting into
+      # the executor mailbox right at the termination.
+      # TODO: concurrent-ruby dead letter routing should make this
+      # more elegant
+      raise Dynflow::Error, "terminating world is not accepting events" if terminating?
       executor.event execution_plan_id, step_id, event, future
+    rescue => e
+      future.fail e
     end
 
     def plan(action_class, *args)
@@ -117,6 +130,13 @@ module Dynflow
       end
     end
 
+    def plan_with_caller(caller_action, action_class, *args)
+      ExecutionPlan.new(self).tap do |execution_plan|
+        execution_plan.prepare(action_class, caller_action: caller_action)
+        execution_plan.plan(*args)
+      end
+    end
+
     # @return [Future] containing execution_plan when finished
     # raises when ExecutionPlan is not accepted for execution
     def execute(execution_plan_id, finished = Future.new)
@@ -138,6 +158,10 @@ module Dynflow
       Future.join([@executor_terminated, @clock_terminated], future)
     end
 
+    def terminating?
+      !!@executor_terminated
+    end
+
     # Detects execution plans that are marked as running but no executor
     # handles them (probably result of non-standard executor termination)
     #

data/test/action_test.rb

@@ -252,5 +252,112 @@ module Dynflow
       end
 
     end
+
+    describe Action::WithSubPlans do
+
+      class FailureSimulator
+        class << self
+          attr_accessor :fail_in_child_plan, :fail_in_child_run
+
+          def reset!
+            self.fail_in_child_plan = self.fail_in_child_run = false
+          end
+        end
+      end
+
+      class ParentAction < Dynflow::Action
+
+        include Dynflow::Action::WithSubPlans
+
+        def create_sub_plans
+          input[:count].times.map{ trigger(ChildAction) }
+        end
+
+        def resume
+          output[:custom_resume] = true
+          super
+        end
+      end
+
+      class ChildAction < Dynflow::Action
+        def plan
+          if FailureSimulator.fail_in_child_plan
+            raise "Fail in child plan"
+          end
+          super
+        end
+
+        def run
+          if FailureSimulator.fail_in_child_run
+            raise "Fail in child run"
+          end
+        end
+      end
+
+      let(:execution_plan) { world.trigger(ParentAction, count: 2).finished.value }
+
+      before do
+        FailureSimulator.reset!
+      end
+
+      specify "the sub-plan stores the information about its parent" do
+        sub_plans = execution_plan.sub_plans
+        sub_plans.size.must_equal 2
+        sub_plans.each { |sub_plan| sub_plan.caller_execution_plan_id.must_equal execution_plan.id }
+      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,
+                                                      'success_count' => 2)
+      end
+
+      specify "when a sub plan fails, the caller action fails as well" do
+        FailureSimulator.fail_in_child_run = true
+        execution_plan.entry_action.output.must_equal('total_count'   => 2,
+                                                      'failed_count'  => 2,
+                                                      'success_count' => 0)
+        execution_plan.state.must_equal :paused
+        execution_plan.result.must_equal :error
+      end
+
+      describe 'resuming' do
+        specify "resuming the action depends on the resume method definition" do
+          FailureSimulator.fail_in_child_plan = true
+          execution_plan.state.must_equal :paused
+          FailureSimulator.fail_in_child_plan = false
+          resumed_plan = world.execute(execution_plan.id).value
+          resumed_plan.entry_action.output[:custom_resume].must_equal true
+        end
+
+        specify "by default, when no sub plans were planned successfully, it call create_sub_plans again" do
+          FailureSimulator.fail_in_child_plan = true
+          execution_plan.state.must_equal :paused
+          FailureSimulator.fail_in_child_plan = false
+          resumed_plan = world.execute(execution_plan.id).value
+          resumed_plan.state.must_equal :stopped
+          resumed_plan.result.must_equal :success
+        end
+
+        specify "by default, when any sub-plan was planned, it succeeds only when the sub-plans were already finished" do
+          FailureSimulator.fail_in_child_run = true
+          execution_plan.state.must_equal :paused
+          sub_plans = execution_plan.sub_plans
+
+          FailureSimulator.fail_in_child_run = false
+          resumed_plan = world.execute(execution_plan.id).value
+          resumed_plan.state.must_equal :paused
+
+          world.execute(sub_plans.first.id).wait
+          resumed_plan = world.execute(execution_plan.id).value
+          resumed_plan.state.must_equal :paused
+
+          sub_plans.drop(1).each { |sub_plan| world.execute(sub_plan.id).wait }
+          resumed_plan = world.execute(execution_plan.id).value
+          resumed_plan.state.must_equal :stopped
+          resumed_plan.result.must_equal :success
+        end
+      end
+    end
   end
 end

data/test/persistance_adapters_test.rb

@@ -87,13 +87,13 @@ module PersistenceAdapterTest
              real_time: 0.0, execution_time: 0.0 }
     storage.save_execution_plan('plan1', plan)
 
-    action = { id: 1 }
+    action = { id: 1, caller_execution_plan_id: nil, caller_action_id: nil }
     -> { storage.load_action('plan1', 1) }.must_raise KeyError
 
     storage.save_action('plan1', 1, action)
     storage.load_action('plan1', 1)[:id].must_equal 1
     storage.load_action('plan1', 1)['id'].must_equal 1
-    storage.load_action('plan1', 1).keys.size.must_equal 1
+    storage.load_action('plan1', 1).keys.must_equal %w[id caller_execution_plan_id caller_action_id]
 
     storage.save_action('plan1', 1, nil)
     -> { storage.load_action('plan1', 1) }.must_raise KeyError