dynflow 1.6.11 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db2725603e440298025d434778ebf2e218e6c3e30fb7db07aaddea80648cbb2d
-  data.tar.gz: 4d8003de94bec301bd411c1c3ee92df9e1d10cc45bc36d4d843a75c2eb664171
+  metadata.gz: f067dee815c7352328f4a08c6cf7aa5f60c45e8c46ae0bb561ed3eff052a3f47
+  data.tar.gz: 37d1bf9a5bed948a9c0c966ac8649d6a1ba097801fcf3b3608a6f353e3b8cd14
 SHA512:
-  metadata.gz: ab0fa706aa8b41c1197aef44bf57a87f4e5c37d7d343a9ca7e83e20af8de89b4e0fb2e72e7a1b93fffa05ac3265c78a48d598d7b8e0292785cd2276057edd0f0
-  data.tar.gz: 07e82b78806a61511b0ddff0240dd596172dfe79735bc8b931d7972b4d322d29bca1686be8be0087a105171e7348c0ee24cfdb2b01cc1a8dcf8d97ad8b0134c8
+  metadata.gz: 3eb25b7a20ac5022e0f1f32062ac6d7445d5fbe2fb482e5d34278a402f49e5feb53e6a7116f5fb06b1758faa6ea253fdda496e76d94dac0a6e2e497653c98fe8
+  data.tar.gz: 242ade0c666d77988957f473ed76aebef323f985adaa4a851c0620c14768fc19db7ef0087d0ab2d2983059aa0fd671721d377dfb9531d00c8f5a4a9b6a8380d2

data/.github/workflows/ruby.yml

@@ -35,10 +35,9 @@ jobs:
       fail-fast: false
       matrix:
         ruby_version:
-          - 2.5.0
-          - 2.6.0
           - 2.7.0
           - 3.0.0
+          - 3.2.0
         concurrent_ruby_ext:
           - 'true'
           - 'false'
@@ -54,30 +53,23 @@ jobs:
           - db: sqlite3
             conn_string: sqlite:/
         exclude:
-          - db: mysql
-            ruby_version: 2.5.0
-          - db: mysql
-            ruby_version: 2.6.0
           - db: mysql
             ruby_version: 3.0.0
+          - db: mysql
+            ruby_version: 3.2.0
           - db: mysql
             concurrent_ruby_ext: 'true'
-          - db: sqlite3
-            ruby_version: 2.5.0
-          - db: sqlite3
-            ruby_version: 2.6.0
           - db: sqlite3
             ruby_version: 3.0.0
+          - db: sqlite3
+            ruby_version: 3.2.0
           - db: sqlite3
             concurrent_ruby_ext: 'true'
           - db: postgresql
-            ruby_version: 2.5.0
-            concurrent_ruby_ext: 'true'
-          - db: postgresql
-            ruby_version: 2.6.0
+            ruby_version: 3.0.0
             concurrent_ruby_ext: 'true'
           - db: postgresql
-            ruby_version: 3.0.0
+            ruby_version: 3.2.0
             concurrent_ruby_ext: 'true'
 
     services:

data/examples/sub_plans_v2.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+example_description = <<DESC
+  Sub Plans Example
+  ===================
+
+  This example shows, how to trigger the execution plans from within a
+  run method of some action and waing for them to finish.
+
+  This is useful, when doing bulk actions, where having one big
+  execution plan would not be effective, or in case all the data are
+  not available by the time of original action planning.
+
+DESC
+
+require_relative 'example_helper'
+require_relative 'orchestrate_evented'
+
+COUNT = (ARGV[0] || 25).to_i
+
+class Foo < Dynflow::Action
+  def plan
+    plan_self
+  end
+
+  def run(event = nil)
+    case event
+    when nil
+      rng = Random.new
+      plan_event(:ping, rng.rand(25) + 1)
+      suspend
+    when :ping
+      # Finish
+    end
+  end
+end
+
+class SubPlansExample < Dynflow::Action
+  include Dynflow::Action::V2::WithSubPlans
+
+  def initiate
+    limit_concurrency_level! 3
+    super
+  end
+
+  def create_sub_plans
+    current_batch.map { |i| trigger(Foo) }
+  end
+
+  def batch_size
+    15
+  end
+
+  def batch(from, size)
+    COUNT.times.drop(from).take(size)
+  end
+
+  def total_count
+    COUNT
+  end
+end
+
+if $0 == __FILE__
+  ExampleHelper.world.action_logger.level = Logger::DEBUG
+  ExampleHelper.world
+  t1 = ExampleHelper.world.trigger(SubPlansExample)
+  puts example_description
+  puts <<-MSG.gsub(/^.*\|/, '')
+    |  Execution plans #{t1.id} with sub plans triggered
+    |  You can see the details at
+    |    #{ExampleHelper::DYNFLOW_URL}/#{t1.id}
+  MSG
+
+  ExampleHelper.run_web_console
+end

data/lib/dynflow/action/v2/with_sub_plans.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module Dynflow::Action::V2
+  module WithSubPlans
+    include Dynflow::Action::Cancellable
+
+    DEFAULT_BATCH_SIZE = 100
+    DEFAULT_POLLING_INTERVAL = 15
+    Ping = Algebrick.atom
+
+    class SubtaskFailedException < RuntimeError
+      def backtrace
+        []
+      end
+    end
+
+    # Methods to be overridden
+    def create_sub_plans
+      raise NotImplementedError
+    end
+
+    # Should return the expected total count of tasks
+    def total_count
+      raise NotImplementedError
+    end
+
+    def batch_size
+      DEFAULT_BATCH_SIZE
+    end
+
+    # Should return a slice of size items starting from item with index from
+    def batch(from, size)
+      raise NotImplementedError
+    end
+
+    # Polling
+    def polling_interval
+      DEFAULT_POLLING_INTERVAL
+    end
+
+    # Callbacks
+    def on_finish
+    end
+
+    def on_planning_finished
+    end
+
+    def run(event = nil)
+      case event
+      when nil
+        if output[:total_count]
+          resume
+        else
+          initiate
+        end
+      when Ping
+        tick
+      when ::Dynflow::Action::Cancellable::Cancel
+        cancel!
+      when ::Dynflow::Action::Cancellable::Abort
+        abort!
+      end
+      try_to_finish || suspend_and_ping
+    end
+
+    def initiate
+      output[:planned_count] = 0
+      output[:cancelled_count] = 0
+      output[:total_count] = total_count
+      spawn_plans
+    end
+
+    def resume
+      if sub_plans.all? { |sub_plan| sub_plan.error_in_plan? }
+        output[:resumed_count] ||= 0
+        output[:resumed_count] += output[:failed_count]
+        # We're starting over and need to reset the counts
+        %w(total failed pending success).each { |key| output.delete("#{key}_count".to_sym) }
+        initiate
+      else
+        tick
+      end
+    end
+
+    def tick
+      recalculate_counts
+      spawn_plans if can_spawn_next_batch?
+    end
+
+    def suspend_and_ping
+      delay = (concurrency_limit.nil? || concurrency_limit_capacity > 0) && can_spawn_next_batch? ? nil : polling_interval
+      plan_event(Ping, delay)
+      suspend
+    end
+
+    def spawn_plans
+      sub_plans = create_sub_plans
+      sub_plans = Array[sub_plans] unless sub_plans.is_a? Array
+      increase_counts(sub_plans.count, 0)
+      on_planning_finished unless can_spawn_next_batch?
+    end
+
+    def increase_counts(planned, failed)
+      output[:planned_count] += planned + failed
+      output[:failed_count]  = output.fetch(:failed_count, 0) + failed
+      output[:pending_count] = output.fetch(:pending_count, 0) + planned
+      output[:success_count] ||= 0
+    end
+
+    def try_to_finish
+      return false unless done?
+
+      check_for_errors!
+      on_finish
+      true
+    end
+
+    def done?
+      return false if can_spawn_next_batch? || !counts_set?
+
+      total_count - output[:success_count] - output[:failed_count] - output[:cancelled_count] <= 0
+    end
+
+    def run_progress
+      return 0.1 unless counts_set? && total_count > 0
+
+      sum = output.values_at(:success_count, :cancelled_count, :failed_count).reduce(:+)
+      sum.to_f / total_count
+    end
+
+    def recalculate_counts
+      total   = total_count
+      failed  = sub_plans_count('state' => %w(paused stopped), 'result' => 'error')
+      success = sub_plans_count('state' => 'stopped', 'result' => 'success')
+      output.update(:pending_count => total - failed - success,
+                    :failed_count  => failed - output.fetch(:resumed_count, 0),
+                    :success_count => success)
+    end
+
+    def counts_set?
+      output[:total_count] && output[:success_count] && output[:failed_count] && output[:pending_count]
+    end
+
+    def check_for_errors!
+      raise SubtaskFailedException.new("A sub task failed") if output[:failed_count] > 0
+    end
+
+    # Helper for creating sub plans
+    def trigger(action_class, *args)
+      world.trigger { world.plan_with_options(action_class: action_class, args: args, caller_action: self) }
+    end
+
+    # Concurrency limitting
+    def limit_concurrency_level!(level)
+      input[:dynflow] ||= {}
+      input[:dynflow][:concurrency_limit] = level
+    end
+
+    def concurrency_limit
+      input[:dynflow] ||= {}
+      input[:dynflow][:concurrency_limit]
+    end
+
+    def concurrency_limit_capacity
+      if limit = concurrency_limit
+        return limit unless counts_set?
+        capacity = limit - (output[:planned_count] - (output[:success_count] + output[:failed_count]))
+        [0, capacity].max
+      end
+    end
+
+    # Cancellation handling
+    def cancel!(force = false)
+      # Count the not-yet-planned tasks as cancelled
+      output[:cancelled_count] = total_count - output[:planned_count]
+      # Pass the cancel event to running sub plans if they can be cancelled
+      sub_plans(:state => 'running').each { |sub_plan| sub_plan.cancel(force) if sub_plan.cancellable? }
+      suspend
+    end
+
+    def abort!
+      cancel! true
+    end
+
+    # Batching
+    # Returns the items in the current batch
+    def current_batch
+      start_position = output[:planned_count]
+      size = batch_size
+      size = concurrency_limit_capacity if concurrency_limit
+      size = start_position + size > total_count ? total_count - start_position : size
+      batch(start_position, size)
+    end
+
+    def can_spawn_next_batch?
+      remaining_count > 0
+    end
+
+    def remaining_count
+      total_count - output[:cancelled_count] - output[:planned_count]
+    end
+
+    private
+
+    # Sub-plan lookup
+    def sub_plan_filter
+      { 'caller_execution_plan_id' => execution_plan_id,
+        'caller_action_id' => self.id }
+    end
+
+    def sub_plans(filter = {})
+      world.persistence.find_execution_plans(filters: sub_plan_filter.merge(filter))
+    end
+
+    def sub_plans_count(filter = {})
+      world.persistence.find_execution_plan_counts(filters: sub_plan_filter.merge(filter))
+    end
+  end
+end

data/lib/dynflow/action/v2.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Dynflow
+  class Action
+    module V2
+      require 'dynflow/action/v2/with_sub_plans'
+    end
+  end
+end

data/lib/dynflow/action.rb

@@ -26,6 +26,7 @@ module Dynflow
     require 'dynflow/action/with_sub_plans'
     require 'dynflow/action/with_bulk_sub_plans'
     require 'dynflow/action/with_polling_sub_plans'
+    require 'dynflow/action/v2'
 
     def self.all_children
       children.values.inject(children.values) do |children, child|
@@ -179,6 +180,12 @@ module Dynflow
       @output_chunks ||= world.persistence.load_output_chunks(@execution_plan_id, @id)
     end
 
+    def drop_output_chunks!
+      @pending_output_chunks = []
+      @output_chunks = []
+      world.persistence.delete_output_chunks(@execution_plan_id, @id)
+    end
+
     def caller_action
       phase! Present
       return nil if @caller_action_id

data/lib/dynflow/persistence.rb

@@ -56,12 +56,20 @@ module Dynflow
       adapter.load_output_chunks(execution_plan_id, action_id)
     end
 
+    def delete_output_chunks(execution_plan_id, action_id)
+      adapter.delete_output_chunks(execution_plan_id, action_id)
+    end
+
     def find_execution_plans(options)
       adapter.find_execution_plans(options).map do |execution_plan_hash|
         ExecutionPlan.new_from_hash(execution_plan_hash, @world)
       end
     end
 
+    def find_execution_plan_statuses(options)
+      adapter.find_execution_plan_statuses(options)
+    end
+
     def find_execution_plan_counts(options)
       adapter.find_execution_plan_counts(options)
     end

data/lib/dynflow/persistence_adapters/abstract.rb

@@ -46,6 +46,10 @@ module Dynflow
         filter(:execution_plan, options[:filters]).count
       end
 
+      def find_execution_plan_statuses(options)
+        raise NotImplementedError
+      end
+
       # @param filters [Hash{ String => Object }] filters to determine
       #   what to delete
       # @param batch_size the size of the chunks to iterate over when
@@ -104,6 +108,18 @@ module Dynflow
         raise NotImplementedError
       end
 
+      def save_output_chunks(execution_plan_id, action_id, chunks)
+        raise NotImplementedError
+      end
+
+      def load_output_chunks(execution_plan_id, action_id)
+        raise NotImplementedError
+      end
+
+      def delete_output_chunks(execution_plan_id, action_id)
+        raise NotImplementedError
+      end
+
       # for debug purposes
       def to_hash
         raise NotImplementedError

data/lib/dynflow/persistence_adapters/sequel.rb

@@ -78,6 +78,16 @@ module Dynflow
         filter(:execution_plan, table(:execution_plan), options[:filters]).count
       end
 
+      def find_execution_plan_statuses(options)
+        plans = filter(:execution_plan, table(:execution_plan), options[:filters])
+                  .select(:uuid, :state, :result)
+
+        plans.each_with_object({}) do |current, acc|
+          uuid = current.delete(:uuid)
+          acc[uuid] = current
+        end
+      end
+
       def delete_execution_plans(filters, batch_size = 1000, backup_dir = nil)
         count = 0
         filter(:execution_plan, table(:execution_plan), filters).each_slice(batch_size) do |plans|
@@ -190,6 +200,10 @@ module Dynflow
         load_records :output_chunk, { execution_plan_uuid: execution_plan_id, action_id: action_id }, [:timestamp, :kind, :chunk]
       end
 
+      def delete_output_chunks(execution_plan_id, action_id)
+        filter(:output_chunk, table(:output_chunk), { execution_plan_uuid: execution_plan_id, action_id: action_id }).delete
+      end
+
       def connector_feature!
         unless @additional_responsibilities[:connector]
           raise "The sequel persistence adapter connector feature used but not enabled in additional_features"

data/lib/dynflow/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Dynflow
-  VERSION = '1.6.11'
+  VERSION = '1.8.0'
 end

data/test/action_test.rb

@@ -889,5 +889,48 @@ module Dynflow
         end
       end
     end
+
+    describe 'output chunks' do
+      include ::Dynflow::Testing::Factories
+
+      class OutputChunkAction < ::Dynflow::Action
+        def run(event = nil)
+          output[:counter] ||= 0
+          case event
+          when nil
+            output_chunk("Chunk #{output[:counter]}")
+            output[:counter] += 1
+            suspend
+          when :exit
+            return
+          end
+        end
+
+        def finalize
+          drop_output_chunks!
+        end
+      end
+
+      it 'collects and drops output chunks' do
+        action = create_and_plan_action(OutputChunkAction)
+        _(action.pending_output_chunks).must_equal nil
+
+        action = run_action(action)
+        _(action.pending_output_chunks.count).must_equal 1
+
+        action = run_action(action)
+        _(action.pending_output_chunks.count).must_equal 2
+
+        action = run_action(action, :exit)
+        _(action.pending_output_chunks.count).must_equal 2
+
+        persistence = mock()
+        persistence.expects(:delete_output_chunks).with(action.execution_plan_id, action.id)
+        action.world.stubs(:persistence).returns(persistence)
+
+        action = finalize_action(action)
+        _(action.pending_output_chunks.count).must_equal 0
+      end
+    end
   end
 end

data/test/persistence_test.rb

@@ -159,6 +159,46 @@ module Dynflow
           end
         end
 
+        describe '#def find_execution_plan_statuses' do
+          before do
+            # the tests expect clean field
+            adapter.delete_execution_plans({})
+          end
+
+          it 'supports filtering' do
+            prepare_and_save_plans
+            if adapter.ordering_by.include?('state')
+              loaded_plans = adapter.find_execution_plan_statuses(filters: { label: ['test1'] })
+              _(loaded_plans).must_equal({ 'plan1' => { state: 'paused', result: nil} })
+
+              loaded_plans = adapter.find_execution_plan_statuses(filters: { state: ['paused'] })
+              _(loaded_plans).must_equal({"plan1"=>{:state=>"paused", :result=>nil},
+                                          "plan3"=>{:state=>"paused", :result=>nil},
+                                          "plan4"=>{:state=>"paused", :result=>nil}})
+
+              loaded_plans = adapter.find_execution_plan_statuses(filters: { state: ['stopped'] })
+              _(loaded_plans).must_equal({"plan2"=>{:state=>"stopped", :result=>nil}})
+
+              loaded_plans = adapter.find_execution_plan_statuses(filters: { state: [] })
+              _(loaded_plans).must_equal({})
+
+              loaded_plans = adapter.find_execution_plan_statuses(filters: { state: ['stopped', 'paused'] })
+              _(loaded_plans).must_equal({"plan1"=>{:state=>"paused", :result=>nil},
+                                          "plan2"=>{:state=>"stopped", :result=>nil},
+                                          "plan3"=>{:state=>"paused", :result=>nil}, "plan4"=>{:state=>"paused", :result=>nil}})
+
+              loaded_plans = adapter.find_execution_plan_statuses(filters: { 'state' => ['stopped', 'paused'] })
+              _(loaded_plans).must_equal({"plan1"=>{:state=>"paused", :result=>nil},
+                                          "plan2"=>{:state=>"stopped", :result=>nil},
+                                          "plan3"=>{:state=>"paused", :result=>nil},
+                                          "plan4"=>{:state=>"paused", :result=>nil}})
+
+              loaded_plans = adapter.find_execution_plan_statuses(filters: { label: ['test1'], :delayed => true })
+              _(loaded_plans).must_equal({})
+            end
+          end
+        end
+
         describe '#def find_execution_plan_counts' do
           before do
             # the tests expect clean field
@@ -331,6 +371,20 @@ module Dynflow
             _(plans.first[:execution_plan_uuid]).must_equal 'plan1'
           end
         end
+
+        describe '#delete_output_chunks' do
+          it 'deletes output chunks' do
+            prepare_plans_with_actions
+
+            adapter.save_output_chunks('plan1', 1, [{chunk: "Hello", timestamp: Time.now}, {chunk: "Bye", timestamp: Time.now}])
+            chunks = adapter.load_output_chunks('plan1', 1)
+            _(chunks.length).must_equal 2
+            deleted = adapter.delete_output_chunks('plan1', 1)
+            _(deleted).must_equal 2
+            chunks = adapter.load_output_chunks('plan1', 1)
+            _(chunks.length).must_equal 0
+          end
+        end
       end
 
       describe Dynflow::PersistenceAdapters::Sequel do

data/test/v2_sub_plans_test.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+require_relative 'test_helper'
+require 'mocha/minitest'
+
+module Dynflow
+  module V2SubPlansTest
+    describe 'V2 sub-plans' do
+      include PlanAssertions
+      include Dynflow::Testing::Assertions
+      include Dynflow::Testing::Factories
+      include TestHelpers
+
+      let(:world) { WorldFactory.create_world }
+
+      class ChildAction < ::Dynflow::Action
+        def run
+        end
+      end
+
+      class ParentAction < ::Dynflow::Action
+        include Dynflow::Action::V2::WithSubPlans
+
+        def plan(count, concurrency_level = nil)
+          limit_concurrency_level!(concurrency_level) if concurrency_level
+          plan_self :count => count
+        end
+
+        def create_sub_plans
+          output[:batch_count] ||= 0
+          output[:batch_count] += 1
+          current_batch.map { |i| trigger(ChildAction) }
+        end
+
+        def batch(from, size)
+          (1..total_count).to_a.slice(from, size)
+        end
+
+        def batch_size
+          5
+        end
+
+        def total_count
+          input[:count]
+        end
+      end
+
+      describe 'normal operation' do
+        it 'spawns all sub-plans in one go with high-enough batch size and polls until they are done' do
+          action = create_and_plan_action ParentAction, 3
+          action.world.expects(:trigger).times(3)
+          action = run_action action
+          _(action.output['total_count']).must_equal 3
+          _(action.output['planned_count']).must_equal 3
+          _(action.output['pending_count']).must_equal 3
+
+          ping = action.world.clock.pending_pings.first
+          _(ping.what.value.event).must_equal Dynflow::Action::V2::WithSubPlans::Ping
+          _(ping.when).must_be_within_delta(Time.now + action.polling_interval, 1)
+          persistence = mock()
+          persistence.stubs(:find_execution_plan_counts).returns(0)
+          action.world.stubs(:persistence).returns(persistence)
+
+          action.world.clock.progress
+          action.world.executor.progress
+          ping = action.world.clock.pending_pings.first
+          _(ping.what.value.event).must_equal Dynflow::Action::V2::WithSubPlans::Ping
+          _(ping.when).must_be_within_delta(Time.now + action.polling_interval * 2, 1)
+
+          persistence = mock()
+          persistence.stubs(:find_execution_plan_counts).returns(0).then.returns(3)
+          action.world.stubs(:persistence).returns(persistence)
+          action.world.clock.progress
+          action.world.executor.progress
+
+          _(action.state).must_equal :success
+          _(action.done?).must_equal true
+        end
+
+        it 'spawns sub-plans in multiple batches and polls until they are done' do
+          action = create_and_plan_action ParentAction, 7
+          action.world.expects(:trigger).times(5)
+          action = run_action action
+          _(action.output['total_count']).must_equal 7
+          _(action.output['planned_count']).must_equal 5
+          _(action.output['pending_count']).must_equal 5
+
+          _(action.world.clock.pending_pings).must_be :empty?
+          _, _, event, * = action.world.executor.events_to_process.first
+          _(event).must_equal Dynflow::Action::V2::WithSubPlans::Ping
+          persistence = mock()
+          # Simulate 3 finished
+          persistence.stubs(:find_execution_plan_counts).returns(0).then.returns(3)
+          action.world.stubs(:persistence).returns(persistence)
+
+          action.world.expects(:trigger).times(2)
+          action.world.executor.progress
+
+          ping = action.world.clock.pending_pings.first
+          _(ping.what.value.event).must_equal Dynflow::Action::V2::WithSubPlans::Ping
+          _(ping.when).must_be_within_delta(Time.now + action.polling_interval, 1)
+
+          persistence.stubs(:find_execution_plan_counts).returns(0).then.returns(7)
+          action.world.stubs(:persistence).returns(persistence)
+          action.world.clock.progress
+          action.world.executor.progress
+
+          _(action.state).must_equal :success
+          _(action.done?).must_equal true
+        end
+      end
+
+      describe 'with concurrency control' do
+        include Dynflow::Testing
+
+        it 'allows storage and retrieval' do
+          action = create_and_plan_action ParentAction, 0
+          action = run_action action
+          _(action.concurrency_limit).must_be_nil
+          _(action.concurrency_limit_capacity).must_be_nil
+
+          action = create_and_plan_action ParentAction, 0, 1
+          action = run_action action
+
+          _(action.input['dynflow']['concurrency_limit']).must_equal 1
+          _(action.concurrency_limit).must_equal 1
+          _(action.concurrency_limit_capacity).must_equal 1
+        end
+
+        it 'reduces the batch size to fit within the concurrency limit' do
+          action = create_and_plan_action ParentAction, 5, 2
+
+          # Plan first 2 sub-plans
+          action.world.expects(:trigger).times(2)
+
+          action = run_action action
+          _(action.output['total_count']).must_equal 5
+          _(action.output['planned_count']).must_equal 2
+          _(action.output['pending_count']).must_equal 2
+          _(action.concurrency_limit_capacity).must_equal 0
+          _(action.output['batch_count']).must_equal 1
+
+          ping = action.world.clock.pending_pings.first
+          _(ping.what.value.event).must_equal Dynflow::Action::V2::WithSubPlans::Ping
+          _(ping.when).must_be_within_delta(Time.now + action.polling_interval, 1)
+          persistence = mock()
+          # Simulate 1 sub-plan finished
+          persistence.stubs(:find_execution_plan_counts).returns(0).then.returns(1)
+          action.world.stubs(:persistence).returns(persistence)
+
+          # Only 1 sub-plans fits into the capacity
+          action.world.expects(:trigger).times(1)
+          action.world.clock.progress
+          action.world.executor.progress
+
+          _(action.output['planned_count']).must_equal 3
+
+          persistence = mock()
+          persistence.stubs(:find_execution_plan_counts).returns(0).then.returns(2)
+          action.world.stubs(:persistence).returns(persistence)
+          action.world.expects(:trigger).times(1)
+          action.world.clock.progress
+          action.world.executor.progress
+
+          _(action.output['planned_count']).must_equal 4
+
+          persistence = mock()
+          persistence.stubs(:find_execution_plan_counts).returns(0).then.returns(4)
+          action.world.stubs(:persistence).returns(persistence)
+          action.world.expects(:trigger).times(1)
+          action.world.clock.progress
+          action.world.executor.progress
+
+          _(action.output['planned_count']).must_equal 5
+          _(action.concurrency_limit_capacity).must_equal 1
+
+          persistence = mock()
+          persistence.stubs(:find_execution_plan_counts).returns(0).then.returns(5)
+          action.world.stubs(:persistence).returns(persistence)
+          action.world.expects(:trigger).never
+          action.world.clock.progress
+          action.world.executor.progress
+          _(action.state).must_equal :success
+          _(action.done?).must_equal true
+          _(action.concurrency_limit_capacity).must_equal 2
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: dynflow
 version: !ruby/object:Gem::Version
-  version: 1.6.11
+  version: 1.8.0
 platform: ruby
 authors:
 - Ivan Necas
 - Petr Chalupa
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-05-09 00:00:00.000000000 Z
+date: 2023-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -419,6 +419,7 @@ files:
 - examples/singletons.rb
 - examples/sub_plan_concurrency_control.rb
 - examples/sub_plans.rb
+- examples/sub_plans_v2.rb
 - examples/termination.rb
 - extras/expand/Dockerfile
 - extras/expand/README.md
@@ -437,6 +438,8 @@ files:
 - lib/dynflow/action/singleton.rb
 - lib/dynflow/action/suspended.rb
 - lib/dynflow/action/timeouts.rb
+- lib/dynflow/action/v2.rb
+- lib/dynflow/action/v2/with_sub_plans.rb
 - lib/dynflow/action/with_bulk_sub_plans.rb
 - lib/dynflow/action/with_polling_sub_plans.rb
 - lib/dynflow/action/with_sub_plans.rb
@@ -632,6 +635,7 @@ files:
 - test/test_helper.rb
 - test/testing_test.rb
 - test/utils_test.rb
+- test/v2_sub_plans_test.rb
 - test/web_console_test.rb
 - test/world_test.rb
 - web/assets/images/logo-square.png
@@ -663,7 +667,7 @@ homepage: https://github.com/Dynflow/dynflow
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -678,8 +682,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.12
-signing_key:
+rubygems_version: 3.1.6
+signing_key: 
 specification_version: 4
 summary: DYNamic workFLOW engine
 test_files:
@@ -716,5 +720,6 @@ test_files:
 - test/test_helper.rb
 - test/testing_test.rb
 - test/utils_test.rb
+- test/v2_sub_plans_test.rb
 - test/web_console_test.rb
 - test/world_test.rb