dynflow 0.8.2 → 0.8.3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MGY3ZTU0Nzk1ZTJlMjQ3YzRjMTI4ZjkzYTNkODZhYWIzYzZhYzc4ZQ==
+    ODk3MTc2Nzc3ZDFmNTMwYTNiMDFjZmIyOWIxZjI5NTY4ZGRjNWE5MQ==
   data.tar.gz: !binary |-
-    NTU1MDY2YTBhNjk2Mjc2YjJkNDhkM2JhYzFjYzk1ODU3ZDUzNDc2OQ==
+    ZGVhZTBhMGZkNWFkYzcxNWZjY2I2MDNlM2ZiNzFlMmJkNGRhZTQ4NQ==
 SHA512:
   metadata.gz: !binary |-
-    ZDRiZmQ2ODQ1MjEyYThmMDg4YjkyNDE1Y2Q5MTI1OWNkMDNjODlmODE5ODlk
-    N2Q2NDQyNzYyNDQzOWFmZGRhMjZmYTEwYWM1YTkyZTdlMDExMWY0NmU4N2Zl
-    MzkxYjFlZDgxY2I1MWQ4ZjhhZTgxZDY4NTI3NmRkMTBhNDE5NzE=
+    ODBjYjZmNWNmODU5ZWE4Y2JiYTBjNmE4OTYyNWExNjc0ZTg2OGMxZDI5NjEw
+    ZDUyNWNiODgxNGE2NTBhYmU0ODdkM2QyNmU3ODdmMDRjZDY4Y2U0NDdjM2Y5
+    OWRhMGViNWMyMjk0YmM2N2U2ZjE0ZDFkZmY0NjAwNDg3MDk5M2E=
   data.tar.gz: !binary |-
-    MGQyNzY3Y2QwZTZhYTQwNGIwYzY4NzgyNzg3NjVhZTliMDBmZTNjMzBkNDc0
-    ZTRhMGZhNGJiODEwZjIzODNlMDczMmU0ZDNlNDIwYzQyZmJkMmUzNzhjNDQz
-    MDRmMzMxNzdmMWZhNWRlOWE4Yjk1Nzc5Njc2MjAyMmUwNzBhMzU=
+    YmU2NGFlOWU3YWY1NGRhMjc0MDA3Yjg4OTU2OTY1NzAyNjNjZTY1YzUzN2Fl
+    MWIyNDlkYmM0ZDVkMjAxMTRmYjIwNDM3MjE2OTBkMGRmOGRiY2ExODY3YzQ2
+    NDQzNzZhYmRiNWM4ZTUyYmU5YzcwYzk2ZWZjM2JmYmZmYTYyMGY=

data/examples/future_execution.rb

@@ -12,13 +12,13 @@ class CustomPassedObject
 end
 
 class CustomPassedObjectSerializer < ::Dynflow::Serializers::Abstract
-  def serialize(*args)
+  def serialize
     object = args.first
     # Serialized output can be anything that is representable as JSON: Array, Hash...
     { :id => object.id, :name => object.name }
   end
 
-  def deserialize(serialized_args)
+  def deserialize
     # Deserialized output must be an Array
     [CustomPassedObject.new(serialized_args[:id], serialized_args[:name])]
   end
@@ -27,7 +27,7 @@ end
 class DelayedAction < Dynflow::Action
 
   def schedule(schedule_options, *args)
-    CustomPassedObjectSerializer.new
+    CustomPassedObjectSerializer.new(args)
   end
 
   def plan(passed_object)

data/lib/dynflow/action.rb

@@ -283,8 +283,12 @@ module Dynflow
     end
 
     def execute_schedule(schedule_options, *args)
-      world.middleware.execute(:schedule, self, schedule_options, *args) do
-        @serializer = schedule(schedule_options, *args)
+      with_error_handling(true) do
+        world.middleware.execute(:schedule, self, schedule_options, *args) do
+          @serializer = schedule(schedule_options, *args).tap do |serializer|
+            serializer.perform_serialization!
+          end
+        end
       end
     end
 
@@ -310,7 +314,7 @@ module Dynflow
     end
 
     def schedule(schedule_options, *args)
-      Serializers::Noop.new
+      Serializers::Noop.new(args)
     end
 
     # @override to implement the action's *Plan phase* behaviour.
@@ -411,7 +415,7 @@ module Dynflow
     end
 
     def with_error_handling(propagate_error = nil, &block)
-      raise "wrong state #{self.state}" unless [:skipping, :running].include?(self.state)
+      raise "wrong state #{self.state}" unless [:scheduling, :skipping, :running].include?(self.state)
 
       begin
         catch(ERROR) { block.call }
@@ -422,6 +426,8 @@ module Dynflow
       end
 
       case self.state
+      when :scheduling
+        self.state = :pending
       when :running
         self.state = :success
       when :skipping

data/lib/dynflow/action/cancellable.rb

@@ -11,7 +11,7 @@ module Dynflow
     end
 
     def cancel!
-      NotImplementedError
+      raise NotImplementedError
     end
   end
 end

data/lib/dynflow/action/with_sub_plans.rb

@@ -1,5 +1,7 @@
 module Dynflow
   module Action::WithSubPlans
+    include Dynflow::Action::Cancellable
+
     SubPlanFinished = Algebrick.type do
       fields! :execution_plan_id => String,
               :success           => type { variants TrueClass, FalseClass }
@@ -17,6 +19,9 @@ module Dynflow
             (on SubPlanFinished do
               mark_as_done(event.execution_plan_id, event.success)
               try_to_finish or suspend
+             end),
+            (on Action::Cancellable::Cancel do
+               cancel!
              end)
     end
 
@@ -49,6 +54,11 @@ module Dynflow
     def on_finish
     end
 
+    def cancel!
+      sub_plans('state' => 'running').each(&:cancel)
+      suspend
+    end
+
     # Helper for creating sub plans
     def trigger(*args)
       world.trigger { world.plan_with_caller(self, *args) }
@@ -92,9 +102,9 @@ module Dynflow
       end
     end
 
-    def sub_plans
+    def sub_plans(filter = {})
       @sub_plans ||= world.persistence.find_execution_plans(filters: { 'caller_execution_plan_id' => execution_plan_id,
-                                                                       'caller_action_id' => self.id } )
+                                                                       'caller_action_id' => self.id }.merge(filter) )
     end
 
     def notify_on_finish(plans)

data/lib/dynflow/execution_plan.rb

@@ -20,7 +20,7 @@ module Dynflow
     end
 
     def self.state_transitions
-      @state_transitions ||= { pending:  [:scheduled, :planning],
+      @state_transitions ||= { pending:  [:stopped, :scheduled, :planning],
                                scheduled: [:planning, :stopped],
                                planning: [:planned, :stopped],
                                planned:  [:running],
@@ -152,11 +152,19 @@ module Dynflow
       @last_step_id += 1
     end
 
-    def schedule(action_class, options, schedule_options, *args)
-      prepare(action_class, options)
+    def schedule(action_class, schedule_options, *args)
+      save
+      @root_plan_step = add_scheduling_step(action_class)
       execution_history.add("schedule", @world.id)
-      update_state :scheduled
-      entry_action.execute_schedule(schedule_options, args)
+      serializer = root_plan_step.schedule(schedule_options, args)
+      scheduled_plan = ScheduledPlan.new(@world,
+                                         id,
+                                         schedule_options[:start_at],
+                                         schedule_options.fetch(:start_before, nil),
+                                         serializer)
+      persistence.save_scheduled_plan(scheduled_plan)
+    ensure
+      update_state(error? ? :stopped : :scheduled)
     end
 
     def schedule_record
@@ -195,6 +203,31 @@ module Dynflow
       update_state(error? ? :stopped : :planned)
     end
 
+    # 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
+      if state == :scheduled
+        [Concurrent.future.tap { |f| f.success schedule_record.cancel }]
+      else
+        steps_to_cancel.map do |step|
+          world.event(id, step.id, ::Dynflow::Action::Cancellable::Cancel)
+        end
+      end
+    end
+
+    def cancellable?
+      return true if state == :scheduled
+      return false unless state == :running
+      steps_to_cancel.any?
+    end
+
+    def steps_to_cancel
+      steps_in_state(:running, :suspended).find_all do |step|
+        step.action(self).is_a?(::Dynflow::Action::Cancellable)
+      end
+    end
+
     def skip(step)
       steps_to_skip = steps_to_skip(step).each(&:mark_to_skip)
       self.save
@@ -251,6 +284,12 @@ module Dynflow
       current_run_flow.add_and_resolve(@dependency_graph, new_flow) if current_run_flow
     end
 
+    def add_scheduling_step(action_class)
+      add_step(Steps::PlanStep, action_class, generate_action_id, :scheduling).tap do |step|
+        step.initialize_action
+      end
+    end
+
     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
@@ -323,6 +362,7 @@ module Dynflow
     # @return [0..1] the percentage of the progress. See Action::Progress for more
     # info
     def progress
+      return 0 if [:pending, :planning, :scheduled].include?(state)
       flow_step_ids         = run_flow.all_step_ids + finalize_flow.all_step_ids
       plan_done, plan_total = flow_step_ids.reduce([0.0, 0]) do |(done, total), step_id|
         step = self.steps[step_id]
@@ -353,10 +393,10 @@ module Dynflow
       world.persistence
     end
 
-    def add_step(step_class, action_class, action_id)
+    def add_step(step_class, action_class, action_id, state = :pending)
       step_class.new(self.id,
                      self.generate_step_id,
-                     :pending,
+                     state,
                      action_class,
                      action_id,
                      nil,

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

@@ -63,7 +63,7 @@ module Dynflow
       end
 
       def self.states
-        @states ||= [:pending, :running, :success, :suspended, :skipping, :skipped, :error]
+        @states ||= [:scheduling, :pending, :running, :success, :suspended, :skipping, :skipped, :error]
       end
 
       def execute(*args)

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

@@ -35,6 +35,13 @@ module Dynflow
         super.merge recursive_to_hash(:children => children)
       end
 
+      def schedule(schedule_options, args)
+        @action.execute_schedule(schedule_options, *args)
+        @action.serializer
+      ensure
+        save
+      end
+
       # @return [Action]
       def execute(execution_plan, trigger, from_subscription, *args)
         unless @action
@@ -51,12 +58,13 @@ module Dynflow
       end
 
       def self.state_transitions
-        @state_transitions ||= { pending:   [:running, :error],
-                                 running:   [:success, :error],
-                                 success:   [],
-                                 suspended: [],
-                                 skipped:   [],
-                                 error:     [] }
+        @state_transitions ||= { scheduling: [:pending, :error],
+                                 pending:    [:running, :error],
+                                 running:    [:success, :error],
+                                 success:    [],
+                                 suspended:  [],
+                                 skipped:    [],
+                                 error:      [] }
       end
 
 
@@ -80,7 +88,7 @@ module Dynflow
         @action = @world.persistence.load_action(self)
       end
 
-      def initialize_action(caller_action)
+      def initialize_action(caller_action = nil)
         attributes = { execution_plan_id: execution_plan_id,
                        id:                action_id,
                        step:              self,

data/lib/dynflow/persistence.rb

@@ -65,6 +65,7 @@ module Dynflow
 
     def load_scheduled_plan(execution_plan_id)
       hash = adapter.load_scheduled_plan(execution_plan_id)
+      return nil unless hash
       ScheduledPlan.new_from_hash(@world, hash)
     end
 

data/lib/dynflow/persistence_adapters/sequel.rb

@@ -63,6 +63,7 @@ module Dynflow
         filter(:execution_plan, table(:execution_plan), filters).each_slice(batch_size) do |plans|
           uuids = plans.map { |p| p.fetch(:uuid) }
           @db.transaction do
+            table(:scheduled).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
@@ -100,6 +101,8 @@ module Dynflow
 
       def load_scheduled_plan(execution_plan_id)
         load :scheduled, execution_plan_uuid: execution_plan_id
+      rescue KeyError
+        return nil
       end
 
       def save_scheduled_plan(execution_plan_id, value)

data/lib/dynflow/scheduled_plan.rb

@@ -3,14 +3,13 @@ module Dynflow
 
     include Algebrick::TypeCheck
 
-    attr_reader :execution_plan_uuid, :start_at, :start_before, :args
+    attr_reader :execution_plan_uuid, :start_at, :start_before
 
-    def initialize(world, execution_plan_uuid, start_at, start_before, args = [], args_serializer = nil)
+    def initialize(world, execution_plan_uuid, start_at, start_before, args_serializer)
       @world               = Type! world, World
       @execution_plan_uuid = Type! execution_plan_uuid, String
       @start_at            = Type! start_at, Time
       @start_before        = Type! start_before, Time, NilClass
-      @args                = Type! args, Array
       @args_serializer     = Type! args_serializer, Serializers::Abstract
     end
 
@@ -22,7 +21,7 @@ module Dynflow
       execution_plan.root_plan_step.load_action
       execution_plan.generate_action_id
       execution_plan.generate_step_id
-      execution_plan.plan(*@args)
+      execution_plan.plan(*@args_serializer.perform_deserialization!)
     end
 
     def timeout
@@ -37,6 +36,12 @@ module Dynflow
       execution_plan.update_state :stopped
     end
 
+    def cancel
+      error("Scheduled task cancelled", "Scheduled task cancelled")
+      @world.persistence.delete_scheduled_plans(:execution_plan_uuid => execution_plan.id)
+      return true
+    end
+
     def execute
       @world.execute(execution_plan.id)
     end
@@ -45,18 +50,17 @@ module Dynflow
        recursive_to_hash :execution_plan_uuid => @execution_plan_uuid,
                          :start_at            => time_to_str(@start_at),
                          :start_before        => time_to_str(@start_before),
-                         :args                => @args_serializer.serialize(*@args),
+                         :serialized_args     => @args_serializer.serialized_args,
                          :args_serializer     => @args_serializer.class.name
     end
 
     # @api private
     def self.new_from_hash(world, hash, *args)
-      serializer = hash[:args_serializer].constantize.new
+      serializer = hash[:args_serializer].constantize.new(nil, hash[:serialized_args])
       self.new(world,
                hash[:execution_plan_uuid],
                string_to_time(hash[:start_at]),
                string_to_time(hash[:start_before]),
-               serializer.deserialize(hash[:args]),
                serializer)
     rescue NameError => e
       error(e.message)

data/lib/dynflow/serializers/abstract.rb

@@ -2,11 +2,37 @@ module Dynflow
   module Serializers
     class Abstract
 
-      def serialize(*args)
+      attr_reader :args, :serialized_args
+
+      def initialize(args, serialized_args = nil)
+        @args = args
+        @serialized_args = serialized_args
+      end
+
+      def args
+        raise "@args not set" if @args.nil?
+        return @args
+      end
+
+      def serialized_args
+        raise "@serialized_args not set" if @serialized_args.nil?
+        return @serialized_args
+      end
+
+      def perform_serialization!
+        @serialized_args = serialize
+      end
+
+      def perform_deserialization!
+        raise "@serialized_args not set" if @serialized_args.nil?
+        @args = deserialize
+      end
+
+      def serialize
         raise NotImplementedError
       end
 
-      def deserialize(serialized_args)
+      def deserialize
         raise NotImplementedError
       end
 

data/lib/dynflow/serializers/noop.rb

@@ -2,11 +2,11 @@ module Dynflow
   module Serializers
     class Noop < Abstract
 
-      def serialize(*args)
+      def serialize
         args
       end
 
-      def deserialize(serialized_args)
+      def deserialize
         serialized_args
       end
 

data/lib/dynflow/version.rb

@@ -1,3 +1,3 @@
 module Dynflow
-  VERSION = '0.8.2'
+  VERSION = '0.8.3'
 end

data/lib/dynflow/web/console.rb

@@ -64,6 +64,16 @@ module Dynflow
         end
       end
 
+      post('/:id/cancel') do |id|
+        plan = world.persistence.load_execution_plan(id)
+        cancel_events = plan.cancel
+        if cancel_events.empty?
+          redirect(url "/#{plan.id}?notice=#{url_encode('Not possible to cancel at the moment')}")
+        else
+          redirect(url "/#{plan.id}?notice=#{url_encode("The cancel event has been propagated")}")
+        end
+      end
+
       post('/:id/skip/:step_id') do |id, step_id|
         plan = world.persistence.load_execution_plan(id)
         step = plan.steps[step_id.to_i]

data/lib/dynflow/web/console_helpers.rb

@@ -114,7 +114,7 @@ module Dynflow
         when :success
           "success"
         when :error
-          "important"
+          "danger"
         else
           "default"
         end

data/lib/dynflow/world.rb

@@ -149,14 +149,7 @@ module Dynflow
     def schedule(action_class, schedule_options, *args)
       raise 'No action_class given' if action_class.nil?
       execution_plan = ExecutionPlan.new self
-      execution_plan.schedule(action_class, {}, schedule_options, *args)
-      scheduled_plan = ScheduledPlan.new(self,
-                                         execution_plan.id,
-                                         schedule_options[:start_at],
-                                         schedule_options.fetch(:start_before, nil),
-                                         args,
-                                         execution_plan.entry_action.serializer)
-      persistence.save_scheduled_plan(scheduled_plan)
+      execution_plan.schedule(action_class, schedule_options, *args)
       Scheduled[execution_plan.id]
     end
 

data/test/action_test.rb

@@ -348,7 +348,7 @@ module Dynflow
         include Dynflow::Action::WithSubPlans
 
         def create_sub_plans
-          input[:count].times.map{ trigger(ChildAction) }
+          input[:count].times.map { trigger(ChildAction, suspend: input[:suspend]) }
         end
 
         def resume
@@ -358,17 +358,22 @@ module Dynflow
       end
 
       class ChildAction < Dynflow::Action
-        def plan
+        include Dynflow::Action::Cancellable
+
+        def plan(input)
           if FailureSimulator.fail_in_child_plan
             raise "Fail in child plan"
           end
           super
         end
 
-        def run
+        def run(event = nil)
           if FailureSimulator.fail_in_child_run
             raise "Fail in child run"
           end
+          if input[:suspend] && !(event == Dynflow::Action::Cancellable::Cancel)
+            suspend
+          end
         end
       end
 
@@ -436,6 +441,24 @@ module Dynflow
           resumed_plan.result.must_equal :success
         end
       end
+
+      describe 'cancelling' do
+        include TestHelpers
+
+        it "sends the cancel 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
+          triggered_plan.finished.wait
+          triggered_plan.finished.value.state.must_equal :stopped
+          triggered_plan.finished.value.result.must_equal :success
+        end
+     end
     end
   end
 end

data/test/execution_plan_test.rb

@@ -245,6 +245,28 @@ module Dynflow
         end
       end
 
+      describe '#cancel' do
+        include TestHelpers
+
+        let :execution_plan do
+          world.plan(Support::CodeWorkflowExample::CancelableSuspended, { text: 'cancel-external' })
+        end
+
+        it '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
+          cancel_events.size.must_equal 1
+          cancel_events.each(&:wait)
+          finished.wait
+        end
+      end
+
       describe 'accessing actions results' do
         let :execution_plan do
           world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)

data/test/future_execution_test.rb

@@ -10,11 +10,12 @@ module Dynflow
       describe 'action scheduling' do
 
         before do
+          @start_at = Time.now.utc + 180
           world.persistence.delete_scheduled_plans(:execution_plan_uuid => [])
         end
 
         let(:world) { WorldFactory.create_world }
-        let(:plan) do
+        let(:scheduled_plan) do
           scheduled = world.schedule(::Support::DummyExample::Dummy, { :start_at => @start_at })
           scheduled.must_be :scheduled?
           world.persistence.load_scheduled_plan(scheduled.execution_plan_id)
@@ -22,32 +23,53 @@ module Dynflow
         let(:history_names) do
           ->(execution_plan) { execution_plan.execution_history.map(&:name) }
         end
-        let(:execution_plan) { plan.execution_plan }
+        let(:execution_plan) { scheduled_plan.execution_plan }
+
+        it 'returns the progress as 0' do
+          execution_plan.progress.must_equal 0
+        end
+
+        it 'marks the plan as failed when issues in serialied phase' do
+          world.persistence.delete_execution_plans({})
+          e = proc { world.schedule(::Support::DummyExample::DummyCustomScheduleSerializer, { :start_at => @start_at }, :fail) }.must_raise RuntimeError
+          e.message.must_equal 'Enforced serializer failure'
+          plan = world.persistence.find_execution_plans(page: 0, per_page: 1, order_by: :ended_at, desc: true).first
+          plan.state.must_equal :stopped
+          plan.result.must_equal :error
+        end
 
         it 'schedules the action' do
-          @start_at = Time.now.utc + 180
           execution_plan.steps.count.must_equal 1
-          plan.start_at.inspect.must_equal (@start_at).inspect
+          scheduled_plan.start_at.inspect.must_equal (@start_at).inspect
           history_names.call(execution_plan).must_equal ['schedule']
         end
 
+        it 'allows cancelling the scheduled plan' do
+          execution_plan.state.must_equal :scheduled
+          execution_plan.cancellable?.must_equal true
+          execution_plan.cancel.each(&:wait)
+          execution_plan = world.persistence.load_execution_plan(self.execution_plan.id)
+          execution_plan.state.must_equal :stopped
+          execution_plan.result.must_equal :error
+          execution_plan.schedule_record.must_equal nil
+        end
+
         it 'finds scheduled plans' do
           @start_at = Time.now.utc - 100
-          plan
+          scheduled_plan
           past_scheduled_plans = world.persistence.find_past_scheduled_plans(@start_at + 10)
           past_scheduled_plans.length.must_equal 1
           past_scheduled_plans.first.execution_plan_uuid.must_equal execution_plan.id
         end
 
         it 'scheduled plans can be planned and executed' do
-          @start_at = Time.now.utc + 180
           execution_plan.state.must_equal :scheduled
-          plan.plan
+          scheduled_plan.plan
           execution_plan.state.must_equal :planned
           execution_plan.result.must_equal :pending
           assert_planning_success execution_plan
           history_names.call(execution_plan).must_equal ['schedule']
-          executed = plan.execute
+          executed = scheduled_plan.execute
           executed.wait
           executed.value.state.must_equal :stopped
           executed.value.result.must_equal :success
@@ -55,8 +77,7 @@ module Dynflow
         end
 
         it 'expired plans can be failed' do
-          @start_at = Time.now.utc + 180
-          plan.timeout
+          scheduled_plan.timeout
           execution_plan.state.must_equal :stopped
           execution_plan.result.must_equal :error
           execution_plan.errors.first.message.must_match /could not be started before set time/
@@ -97,10 +118,15 @@ module Dynflow
         let(:save_and_load) do
           ->(thing) { MultiJson.load(MultiJson.dump(thing)) }
         end
+
         let(:simulated_use) do
           lambda do |serializer_class, input|
-            serializer = serializer_class.new
-            serializer.deserialize(save_and_load.call(serializer.serialize *input))
+            serializer = serializer_class.new(input)
+            serializer.perform_serialization!
+            serialized_args = save_and_load.call(serializer.serialized_args)
+            serializer = serializer_class.new(nil, serialized_args)
+            serializer.perform_deserialization!
+            serializer.args
           end
         end
 

data/test/support/dummy_example.rb

@@ -6,6 +6,26 @@ module Support
       def run; end
     end
 
+    class MySerializer < Dynflow::Serializers::Abstract
+      def serialize
+        if args.first == :fail
+          raise 'Enforced serializer failure'
+        end
+        args
+      end
+
+      def deserialize
+        serialized_args
+      end
+    end
+
+    class DummyCustomScheduleSerializer < Dynflow::Action
+      def schedule(schedule_options, *args)
+        MySerializer.new(args)
+      end
+      def run; end
+    end
+
     class FailingDummy < Dynflow::Action
       def run; raise 'error'; end
     end

data/test/support/middleware_example.rb

@@ -80,7 +80,7 @@ module Support
 
       def schedule(schedule_options, *args)
         log 'schedule'
-        Dynflow::Serializers::Noop.new
+        Dynflow::Serializers::Noop.new(args)
       end
 
       def plan(input)

data/test/test_helper.rb

@@ -20,7 +20,7 @@ require 'support/rescue_example'
 require 'support/dummy_example'
 require 'support/test_execution_log'
 
-Concurrent.disable_executor_auto_termination!
+Concurrent.disable_at_exit_handlers!
 
 # To be able to stop a process in some step and perform assertions while paused
 class TestPause

data/web/views/show.erb

@@ -4,6 +4,9 @@
   <% if @plan.state == :paused %>
     <a href="<%= url("/#{@plan.id}/resume") %>" class="postlink">Resume</a>
   <% end %>
+  <% if @plan.cancellable? %>
+    <a href="<%= url("/#{@plan.id}/cancel") %>" class="postlink">Cancel</a>
+  <% end %>
 </p>
 
 <p>
@@ -11,7 +14,7 @@
   <%= h(@plan.result) %>
 </p>
 
-<% if @plan.state == :scheduled %>
+<% if @plan.state == :scheduled && @plan.schedule_record %>
   <p>
     <b>Start at:</b>
     <%= h(@plan.schedule_record.start_at) %>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynflow
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.8.3
 platform: ruby
 authors:
 - Ivan Necas
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-31 00:00:00.000000000 Z
+date: 2015-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport