dynflow 0.8.25 → 0.8.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: df86d8f76a1106ba36deefac06dbf223b7be53ac
-  data.tar.gz: b0e2c8049e5cb81b3d930002192f8d857418e264
+  metadata.gz: ab4978b454a2f7066506b1abcf644184fcb5542b
+  data.tar.gz: db7286bce7f99037e24df8dedc227a85026d1d77
 SHA512:
-  metadata.gz: 4559e454e25d46305c5438e0e9bdf68b23bca95a05e219cd727e839acedeec7037880d609683d598171b9f2d2df1e87937f697d4bc047a789ff424c39abe95dd
-  data.tar.gz: fdf35384c85d1d1d752ba05b94a14c24f73fb23b7398d5595cfd5199fcf881c3f12822363cb1d26656b8231a6ee184a648b7d8f0d0ca533b6556c8e6b3759286
+  metadata.gz: 8df6257ff673232080c2867715ee5605d07bd197e2a1f950ed3f13a2fc88f9f8ce3415d47c88b3ef88a4523a0c8e4ccf7f81b435e90b6d694e758335b0ebbeb9
+  data.tar.gz: bf75b46a23911444fd9cb087d7403a2ff79c20f83bd6f091502cacc2e6628211315465ccb9e5e9bfa04de65cfe020d79f1db8870e233dfb67defbcfdd9a049e0

data/examples/sub_plans.rb

@@ -1,5 +1,4 @@
 #!/usr/bin/env ruby
-
 example_description = <<DESC
   Sub Plans Example
   ===================
@@ -16,20 +15,44 @@ DESC
 require_relative 'example_helper'
 require_relative 'orchestrate_evented'
 
+COUNT = (ARGV[0] || 25).to_i
+
 class SubPlansExample < Dynflow::Action
   include Dynflow::Action::WithSubPlans
+  include Dynflow::Action::WithBulkSubPlans
 
   def create_sub_plans
-    10.times.map { |i| trigger(OrchestrateEvented::CreateMachine, "host-#{i}", 'web_server') }
+    current_batch.map { |i| trigger(OrchestrateEvented::CreateMachine, "host-#{i}", 'web_server') }
+  end
+
+  def batch_size
+    5
+  end
+
+  def batch(from, size)
+    COUNT.times.drop(from).take(size)
+  end
+
+  def total_count
+    COUNT
   end
 end
 
+class PollingSubPlansExample < SubPlansExample
+  include Dynflow::Action::WithPollingSubPlans
+end
+
 if $0 == __FILE__
-  triggered = ExampleHelper.world.trigger(SubPlansExample)
+  ExampleHelper.world.action_logger.level = Logger::INFO
+  ExampleHelper.world
+  t1 = ExampleHelper.world.trigger(SubPlansExample)
+  t2 = ExampleHelper.world.trigger(PollingSubPlansExample)
   puts example_description
   puts <<-MSG.gsub(/^.*\|/, '')
-    |  Execution plan #{triggered.id} with sub plans triggered
-    |  You can see the details at http://localhost:4567/#{triggered.id}
+    |  Execution plans #{t1.id} and #{t2.id} with sub plans triggered
+    |  You can see the details at
+    |    http://localhost:4567/#{t2.id}
+    |    http://localhost:4567/#{t1.id}
   MSG
 
   ExampleHelper.run_web_console

data/lib/dynflow/action.rb

@@ -23,6 +23,7 @@ module Dynflow
     require 'dynflow/action/cancellable'
     require 'dynflow/action/with_sub_plans'
     require 'dynflow/action/with_bulk_sub_plans'
+    require 'dynflow/action/with_polling_sub_plans'
 
     def self.all_children
       children.values.inject(children.values) do |children, child|

data/lib/dynflow/action/cancellable.rb

@@ -1,10 +1,14 @@
 module Dynflow
   module Action::Cancellable
     Cancel = Algebrick.atom
+    Abort  = Algebrick.atom
 
     def run(event = nil)
-      if Cancel === event
+      case event
+      when Cancel
         cancel!
+      when Abort
+        abort!
       else
         super event
       end
@@ -13,5 +17,9 @@ module Dynflow
     def cancel!
       raise NotImplementedError
     end
+
+    def abort!
+      cancel!
+    end
   end
 end

data/lib/dynflow/action/with_bulk_sub_plans.rb

@@ -13,13 +13,21 @@ module Dynflow
 
     def run(event = nil)
       if event === PlanNextBatch
-        spawn_plans if can_spawn_next_batch?
-        suspend
+        if can_spawn_next_batch?
+          spawn_plans
+          suspend
+        else
+          on_planning_finished
+        end
       else
         super
       end
     end
 
+    def on_planning_finished
+      suspend
+    end
+
     def initiate
       output[:planned_count] = 0
       output[:total_count]   = total_count
@@ -62,7 +70,7 @@ module Dynflow
       suspended_action << PlanNextBatch
     end
 
-    def cancel!
+    def cancel!(force = false)
       # Count the not-yet-planned tasks as failed
       output[:failed_count] += total_count - output[:planned_count]
       if uses_concurrency_control
@@ -72,14 +80,17 @@ module Dynflow
         # Just stop the tasks which were not started yet
         sub_plans(:state => 'planned').each { |sub_plan| sub_plan.update_state(:stopped) }
       end
-      running = sub_plans(:state => 'running')
       # Pass the cancel event to running sub plans if they can be cancelled
-      running.each { |sub_plan| sub_plan.cancel! if sub_plan.cancellable? }
+      sub_plans(:state => 'running').each { |sub_plan| sub_plan.cancel(force) if sub_plan.cancellable? }
       suspend
     end
 
     private
 
+    def done?
+      !can_spawn_next_batch? && super
+    end
+
     def can_spawn_next_batch?
       total_count - output[:success_count] - output[:pending_count] - output[:failed_count] > 0
     end

data/lib/dynflow/action/with_polling_sub_plans.rb

@@ -0,0 +1,72 @@
+module Dynflow
+  module Action::WithPollingSubPlans
+
+    REFRESH_INTERVAL = 10
+    Poll = Algebrick.atom
+
+    def run(event = nil)
+      case event
+      when Poll
+        poll
+      else
+        super(event)
+      end
+    end
+
+    def poll
+      recalculate_counts
+      try_to_finish || suspend_and_ping
+    end
+
+    def initiate
+      ping suspended_action
+      super
+    end
+
+    def wait_for_sub_plans(sub_plans)
+      increase_counts(sub_plans.count, 0)
+      suspend
+    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
+        if self.is_a?(::Dynflow::Action::WithBulkSubPlans) && can_spawn_next_batch?
+          # Not everything was spawned
+          ping suspended_action
+          spawn_plans
+          suspend
+        else
+          poll
+        end
+      end
+    end
+
+    def notify_on_finish(_sub_plans)
+      suspend
+    end
+
+    def suspend_and_ping
+      suspend { |suspended_action| ping suspended_action }
+    end
+
+    def ping(suspended_action)
+      world.clock.ping suspended_action, REFRESH_INTERVAL, Poll
+    end
+
+    def recalculate_counts
+      total      = sub_plans.count
+      failed     = sub_plans('state' => %w(paused stopped), 'result' => 'error').count
+      success    = sub_plans('state' => 'stopped', 'result' => 'success').count
+      output.update(:total_count   => total - output.fetch(:resumed_count, 0),
+                    :pending_count => 0,
+                    :failed_count  => failed - output.fetch(:resumed_count, 0),
+                    :success_count => success)
+    end
+  end
+end

data/lib/dynflow/action/with_sub_plans.rb

@@ -22,6 +22,9 @@ module Dynflow
              end),
             (on Action::Cancellable::Cancel do
                cancel!
+             end),
+            (on Action::Cancellable::Abort do
+               abort!
              end)
     end
 
@@ -62,12 +65,16 @@ module Dynflow
     def on_finish
     end
 
-    def cancel!
+    def cancel!(force = false)
       @world.throttle_limiter.cancel!(execution_plan_id)
-      sub_plans('state' => 'running').each(&:cancel)
+      sub_plans('state' => 'running').each { |sub_plan| sub_plan.cancel(force) }
       suspend
     end
 
+    def abort!
+      cancel! true
+    end
+
     # Helper for creating sub plans
     def trigger(*args)
       if uses_concurrency_control
@@ -146,8 +153,13 @@ module Dynflow
     end
 
     def sub_plans(filter = {})
-      @sub_plans ||= world.persistence.find_execution_plans(filters: { 'caller_execution_plan_id' => execution_plan_id,
-                                                                       'caller_action_id' => self.id }.merge(filter) )
+      filters = { 'caller_execution_plan_id' => execution_plan_id,
+                  'caller_action_id' => self.id }
+      if filter.empty?
+        @sub_plans ||= world.persistence.find_execution_plans(filters: filters)
+      else
+        world.persistence.find_execution_plans(filters: filters.merge(filter))
+      end
     end
 
     def notify_on_finish(plans)

data/lib/dynflow/config.rb

@@ -115,6 +115,14 @@ module Dynflow
       { 'hostname' => Socket.gethostname, 'pid' => Process.pid }
     end
 
+    config_attr :backup_deleted_plans, Algebrick::Types::Boolean do
+      false
+    end
+
+    config_attr :backup_dir, String, NilClass do
+      './backup'
+    end
+
     def validate(config_for_world)
       if defined? ::ActiveRecord::Base
         ar_pool_size = ::ActiveRecord::Base.connection_pool.instance_variable_get(:@size)

data/lib/dynflow/execution_plan.rb

@@ -260,12 +260,13 @@ module Dynflow
     # sends the cancel event to all currently running and cancellable steps.
     # if the plan is just scheduled, it cancels it (and returns an one-item
     # array with the future value of the cancel result)
-    def cancel
+    def cancel(force = false)
       if state == :scheduled
         [Concurrent.future.tap { |f| f.success delay_record.cancel }]
       else
+        event = force ? ::Dynflow::Action::Cancellable::Abort : ::Dynflow::Action::Cancellable::Cancel
         steps_to_cancel.map do |step|
-          world.event(id, step.id, ::Dynflow::Action::Cancellable::Cancel)
+          world.event(id, step.id, event)
         end
       end
     end

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

@@ -58,7 +58,7 @@ module Dynflow
         def on_message(message)
           super
         rescue Errors::PersistenceError => e
-          self.tell(:handle_persistence_error, e)
+          self.tell([:handle_persistence_error, e])
         end
 
         def feed_pool(work_items)

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

@@ -54,7 +54,7 @@ module Dynflow
         end
 
         def handle_persistence_error(error)
-          @executor_core.tell(:handle_persistence_error, error)
+          @executor_core.tell([:handle_persistence_error, error])
         end
 
         def start_termination(*args)

data/lib/dynflow/persistence.rb

@@ -8,10 +8,12 @@ module Dynflow
 
     attr_reader :adapter
 
-    def initialize(world, persistence_adapter)
+    def initialize(world, persistence_adapter, options = {})
       @world   = world
       @adapter = persistence_adapter
       @adapter.register_world(world)
+      @backup_deleted_plans = options.fetch(:backup_deleted_plans, false)
+      @backup_dir = options.fetch(:backup_dir, './backup')
     end
 
     def load_action(step)
@@ -38,8 +40,13 @@ module Dynflow
       end
     end
 
-    def delete_execution_plans(filters, batch_size = 1000)
-      adapter.delete_execution_plans(filters, batch_size)
+    def delete_execution_plans(filters, batch_size = 1000, enforce_backup_dir = nil)
+      backup_dir = enforce_backup_dir || current_backup_dir
+      adapter.delete_execution_plans(filters, batch_size, backup_dir)
+    end
+
+    def current_backup_dir
+      @backup_deleted_plans ? File.join(@backup_dir, Date.today.strftime('%Y%m%d')) : nil
     end
 
     def load_execution_plan(id)

data/lib/dynflow/persistence_adapters/abstract.rb

@@ -43,7 +43,9 @@ module Dynflow
       #   what to delete
       # @param batch_size the size of the chunks to iterate over when
       #   performing the deletion
-      def delete_execution_plans(filters, batch_size = 1000)
+      # @param backup_dir where the backup of deleted plans will be created.
+      #   Set to nil for no backup
+      def delete_execution_plans(filters, batch_size = 1000, backup_dir = nil)
         raise NotImplementedError
       end
 

data/lib/dynflow/persistence_adapters/sequel.rb

@@ -1,5 +1,7 @@
 require 'sequel'
 require 'multi_json'
+require 'fileutils'
+require 'csv'
 
 module Dynflow
   module PersistenceAdapters
@@ -58,15 +60,24 @@ module Dynflow
         data_set.all.map { |record| load_data(record) }
       end
 
-      def delete_execution_plans(filters, batch_size = 1000)
+      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|
           uuids = plans.map { |p| p.fetch(:uuid) }
           @db.transaction do
             table(:delayed).where(execution_plan_uuid: uuids).delete
-            table(:step).where(execution_plan_uuid: uuids).delete
-            table(:action).where(execution_plan_uuid: uuids).delete
-            count += table(:execution_plan).where(uuid: uuids).delete
+
+            steps = table(:step).where(execution_plan_uuid: uuids)
+            backup_to_csv(steps, backup_dir, 'steps.csv') if backup_dir
+            steps.delete
+
+            actions = table(:action).where(execution_plan_uuid: uuids)
+            backup_to_csv(actions, backup_dir, 'actions.csv') if backup_dir
+            actions.delete
+
+            execution_plans = table(:execution_plan).where(uuid: uuids)
+            backup_to_csv(execution_plans, backup_dir, 'execution_plans.csv') if backup_dir
+            count += execution_plans.delete
           end
         end
         return count
@@ -270,6 +281,24 @@ module Dynflow
         Utils.indifferent_hash(MultiJson.load(record[:data]))
       end
 
+      def ensure_backup_dir(backup_dir)
+        FileUtils.mkdir_p(backup_dir) unless File.directory?(backup_dir)
+      end
+
+      def backup_to_csv(dataset, backup_dir, file_name)
+        ensure_backup_dir(backup_dir)
+        csv_file = File.join(backup_dir, file_name)
+        appending = File.exist?(csv_file)
+        columns = dataset.columns
+        File.open(csv_file, 'a') do |csv|
+          csv << columns.to_csv unless appending
+          dataset.each do |row|
+            csv << columns.collect { |col| row[col] }.to_csv
+          end
+        end
+        dataset
+      end
+
       def delete(what, condition)
         table(what).where(Utils.symbolize_keys(condition)).delete
       end

data/lib/dynflow/version.rb

@@ -1,3 +1,3 @@
 module Dynflow
-  VERSION = '0.8.25'
+  VERSION = '0.8.26'
 end

data/lib/dynflow/world.rb

@@ -17,7 +17,9 @@ module Dynflow
       @logger_adapter         = config_for_world.logger_adapter
       config_for_world.validate
       @transaction_adapter    = config_for_world.transaction_adapter
-      @persistence            = Persistence.new(self, config_for_world.persistence_adapter)
+      @persistence            = Persistence.new(self, config_for_world.persistence_adapter,
+                                                :backup_deleted_plans => config_for_world.backup_deleted_plans,
+                                                :backup_dir => config_for_world.backup_dir)
       @coordinator            = Coordinator.new(config_for_world.coordinator_adapter)
       @executor               = config_for_world.executor
       @action_classes         = config_for_world.action_classes

data/test/action_test.rb

@@ -371,10 +371,56 @@ module Dynflow
           if FailureSimulator.fail_in_child_run
             raise "Fail in child run"
           end
-          if input[:suspend] && !(event == Dynflow::Action::Cancellable::Cancel)
+          if event == Dynflow::Action::Cancellable::Abort
+            output[:aborted] = true
+          end
+          if input[:suspend] && !cancel_event?(event)
             suspend
           end
         end
+
+        def cancel_event?(event)
+          event == Dynflow::Action::Cancellable::Cancel ||
+            event == Dynflow::Action::Cancellable::Abort
+        end
+      end
+
+      class PollingParentAction < ParentAction
+        include ::Dynflow::Action::WithPollingSubPlans
+      end
+
+      class PollingBulkParentAction < ParentAction
+        include ::Dynflow::Action::WithBulkSubPlans
+        include ::Dynflow::Action::WithPollingSubPlans
+
+        def poll
+          output[:poll] += 1
+          super
+        end
+
+        def on_planning_finished
+          output[:poll] = 0
+          output[:planning_finished] ||= 0
+          output[:planning_finished] += 1
+          super
+        end
+
+        def total_count
+          input[:count]
+        end
+
+        def batch_size
+          1
+        end
+
+        def create_sub_plans
+          current_batch.map { trigger(ChildAction, suspend: input[:suspend]) }
+        end
+
+        def batch(from, size)
+          total_count.times.drop(from).take(size)
+        end
+
       end
 
       let(:execution_plan) { world.trigger(ParentAction, count: 2).finished.value }
@@ -442,6 +488,96 @@ module Dynflow
           resumed_plan.state.must_equal :stopped
           resumed_plan.result.must_equal :success
         end
+
+        describe ::Dynflow::Action::WithPollingSubPlans do
+          include TestHelpers
+
+          let(:clock) { Dynflow::Testing::ManagedClock.new }
+          let(:polling_plan) { world.trigger(PollingParentAction, count: 2).finished.value }
+
+          specify "by default, when no sub plans were planned successfully, it calls create_sub_plans again" do
+            world.stub(:clock, clock) do
+              total = 2
+              FailureSimulator.fail_in_child_plan = true
+              triggered_plan = world.trigger(PollingParentAction, count: total)
+              polling_plan = world.persistence.load_execution_plan(triggered_plan.id)
+
+              wait_for do # Waiting for the sub plans to be spawned
+                polling_plan = world.persistence.load_execution_plan(triggered_plan.id)
+                polling_plan.sub_plans.count == total
+              end
+
+              # Moving the clock to make the parent check on sub plans
+              clock.pending_pings.count.must_equal 1
+              clock.progress
+
+              wait_for do # Waiting for the parent to realise the sub plans failed
+                polling_plan = world.persistence.load_execution_plan(triggered_plan.id)
+                polling_plan.state == :paused
+              end
+
+              FailureSimulator.fail_in_child_plan = false
+
+              world.execute(polling_plan.id) # The actual resume
+
+              wait_for do # Waiting for new generation of sub plans to be spawned
+                polling_plan.sub_plans.count == 2 * total
+              end
+
+              # Move the clock again
+              clock.pending_pings.count.must_equal 1
+              clock.progress
+
+              wait_for do # Waiting for everything to finish successfully
+                polling_plan = world.persistence.load_execution_plan(triggered_plan.id)
+                polling_plan.state == :stopped && polling_plan.result == :success
+              end
+            end
+          end
+
+          specify "by default it starts polling again" do
+            world.stub(:clock, clock) do
+              total = 2
+              FailureSimulator.fail_in_child_run = true
+              triggered_plan = world.trigger(PollingParentAction, count: total)
+              polling_plan = world.persistence.load_execution_plan(triggered_plan.id)
+
+              wait_for do # Waiting for the sub plans to be spawned
+                polling_plan = world.persistence.load_execution_plan(triggered_plan.id)
+                polling_plan.sub_plans.count == total &&
+                  polling_plan.sub_plans.all? { |sub| sub.state == :paused }
+              end
+
+              # Moving the clock to make the parent check on sub plans
+              clock.pending_pings.count.must_equal 1
+              clock.progress
+              clock.pending_pings.count.must_equal 0
+
+              wait_for do # Waiting for the parent to realise the sub plans failed
+                polling_plan = world.persistence.load_execution_plan(triggered_plan.id)
+                polling_plan.state == :paused
+              end
+
+              FailureSimulator.fail_in_child_run = false
+
+              # Resume the sub plans
+              polling_plan.sub_plans.each do |sub|
+                world.execute(sub.id)
+              end
+
+              wait_for do # Waiting for the child tasks to finish
+                polling_plan.sub_plans.all? { |sub| sub.state == :stopped }
+              end
+
+              world.execute(polling_plan.id) # The actual resume
+
+              wait_for do # Waiting for everything to finish successfully
+                polling_plan = world.persistence.load_execution_plan(triggered_plan.id)
+                polling_plan.state == :stopped && polling_plan.result == :success
+              end
+            end
+          end
+        end
       end
 
       describe 'cancelling' do
@@ -460,6 +596,81 @@ module Dynflow
           triggered_plan.finished.value.state.must_equal :stopped
           triggered_plan.finished.value.result.must_equal :success
         end
+
+        it "sends the abort event to all actions that are running and support cancelling" do
+          triggered_plan = world.trigger(ParentAction, count: 2, suspend: true)
+          plan = wait_for do
+            plan = world.persistence.load_execution_plan(triggered_plan.id)
+            if plan.cancellable?
+              plan
+            end
+          end
+          plan.cancel true
+          triggered_plan.finished.wait
+          triggered_plan.finished.value.state.must_equal :stopped
+          triggered_plan.finished.value.result.must_equal :success
+          plan.sub_plans.each do |sub_plan|
+            sub_plan.entry_action.output[:aborted].must_equal true
+          end
+        end
+      end
+
+      describe ::Dynflow::Action::WithPollingSubPlans do
+        include TestHelpers
+
+        let(:clock) { Dynflow::Testing::ManagedClock.new }
+
+        specify 'polls for sub plans state' do
+          world.stub :clock, clock do
+            total = 2
+            triggered_plan = world.trigger(PollingParentAction, count: total)
+            plan = world.persistence.load_execution_plan(triggered_plan.id)
+            plan.state.must_equal :planned
+            clock.pending_pings.count.must_equal 0
+            wait_for do
+              plan.sub_plans.count == total &&
+                plan.sub_plans.all? { |sub| sub.result == :success }
+            end
+            clock.pending_pings.count.must_equal 1
+            clock.progress
+            wait_for do
+              plan = world.persistence.load_execution_plan(triggered_plan.id)
+              plan.state == :stopped
+            end
+            clock.pending_pings.count.must_equal 0
+          end
+        end
+
+        specify 'starts polling for sub plans at the beginning' do
+          world.stub :clock, clock do
+            total = 2
+            triggered_plan = world.trigger(PollingBulkParentAction, count: total)
+            plan = world.persistence.load_execution_plan(triggered_plan.id)
+            assert_nil plan.entry_action.output[:planning_finished]
+            clock.pending_pings.count.must_equal 0
+            wait_for do
+              plan = world.persistence.load_execution_plan(triggered_plan.id)
+              plan.entry_action.output[:planning_finished] == 1
+            end
+            # Poll was set during #initiate
+            clock.pending_pings.count.must_equal 1
+
+            # Wait for the sub plans to finish
+            wait_for do
+              plan.sub_plans.count == total &&
+                plan.sub_plans.all? { |sub| sub.result == :success }
+            end
+
+            # Poll again
+            clock.progress
+            wait_for do
+              plan = world.persistence.load_execution_plan(triggered_plan.id)
+              plan.state == :stopped
+            end
+            plan.entry_action.output[:poll].must_equal 1
+            clock.pending_pings.count.must_equal 0
+          end
+        end
       end
     end
   end

data/test/execution_plan_test.rb

@@ -300,6 +300,20 @@ module Dynflow
           cancel_events.each(&:wait)
           finished.wait
         end
+
+        it 'force cancels' do
+          finished = world.execute(execution_plan.id)
+          plan = wait_for do
+            plan = world.persistence.load_execution_plan(execution_plan.id)
+            if plan.cancellable?
+              plan
+            end
+          end
+          cancel_events = plan.cancel true
+          cancel_events.size.must_equal 1
+          cancel_events.each(&:wait)
+          finished.wait
+        end
       end
 
       describe 'accessing actions results' do

data/test/persistence_test.rb

@@ -1,4 +1,5 @@
 require_relative 'test_helper'
+require 'tmpdir'
 
 module Dynflow
   module PersistenceTest
@@ -154,6 +155,22 @@ module Dynflow
             adapter.load_execution_plan('plan2') # nothing raised
             -> { adapter.load_execution_plan('plan3') }.must_raise KeyError
           end
+
+          it 'creates backup dir and produce backup including steps and actions' do
+            prepare_plans_with_steps
+            Dir.mktmpdir do |backup_dir|
+              adapter.delete_execution_plans({'uuid' => 'plan1'}, 100, backup_dir).must_equal 1
+              plans = CSV.read(backup_dir + "/execution_plans.csv", :headers => true)
+              assert_equal 1, plans.count
+              assert_equal 'plan1', plans.first.to_hash['uuid']
+              actions = CSV.read(backup_dir + "/actions.csv", :headers => true)
+              assert_equal 1, actions.count
+              assert_equal 'plan1', actions.first.to_hash['execution_plan_uuid']
+              steps = CSV.read(backup_dir +"/steps.csv", :headers => true)
+              assert_equal 1, steps.count
+              assert_equal 'plan1', steps.first.to_hash['execution_plan_uuid']
+            end
+          end
         end
 
         describe '#load_action and #save_action' do

data/test/test_helper.rb

@@ -82,16 +82,18 @@ module WorldFactory
   end
 
   def self.test_world_config
-    config                     = Dynflow::Config.new
-    config.persistence_adapter = persistence_adapter
-    config.logger_adapter      = logger_adapter
-    config.coordinator_adapter = coordinator_adapter
-    config.delayed_executor    = nil
-    config.auto_rescue         = false
-    config.auto_validity_check = false
-    config.exit_on_terminate   = false
-    config.auto_execute        = false
-    config.auto_terminate      = false
+    config                      = Dynflow::Config.new
+    config.persistence_adapter  = persistence_adapter
+    config.logger_adapter       = logger_adapter
+    config.coordinator_adapter  = coordinator_adapter
+    config.delayed_executor     = nil
+    config.auto_rescue          = false
+    config.auto_validity_check  = false
+    config.exit_on_terminate    = false
+    config.auto_execute         = false
+    config.auto_terminate       = false
+    config.backup_deleted_plans = false
+    config.backup_dir           = nil
     yield config if block_given?
     return config
   end

data/web/assets/images/logo-square.png

@@ -0,0 +1 @@
+web/assets/images/../../../doc/pages/source/images/logo-square.png

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynflow
 version: !ruby/object:Gem::Version
-  version: 0.8.25
+  version: 0.8.26
 platform: ruby
 authors:
 - Ivan Necas
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-19 00:00:00.000000000 Z
+date: 2017-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -390,6 +390,7 @@ files:
 - lib/dynflow/action/suspended.rb
 - lib/dynflow/action/timeouts.rb
 - lib/dynflow/action/with_bulk_sub_plans.rb
+- lib/dynflow/action/with_polling_sub_plans.rb
 - lib/dynflow/action/with_sub_plans.rb
 - lib/dynflow/active_job/queue_adapter.rb
 - lib/dynflow/actor.rb
@@ -589,7 +590,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: DYNamic workFLOW engine