dynflow 0.8.16 → 0.8.17

data/test/support/code_workflow_example.rb

@@ -28,7 +28,7 @@ module Support
         triages   = all_planned_actions(Triage)
         assignees = triages.map do |triage|
           triage.output[:classification] &&
-              triage.output[:classification][:assignee]
+            triage.output[:classification][:assignee]
         end.compact.uniq
         { assignees: assignees }
       end

data/test/support/rescue_example.rb

@@ -97,6 +97,5 @@ module Support
 
     end
 
-
   end
 end

data/test/test_helper.rb

@@ -97,8 +97,8 @@ module WorldFactory
   end
 
   # The worlds created by this method are getting terminated after each test run
-  def self.create_world(&block)
-    Dynflow::World.new(test_world_config(&block)).tap do |world|
+  def self.create_world(klass = Dynflow::World, &block)
+    klass.new(test_world_config(&block)).tap do |world|
       created_worlds << world
     end
   end
@@ -194,7 +194,7 @@ module TestHelpers
       client_world.persistence.load_execution_plan(triggered.id).state == :running
     end
 
-    executor  = WorldFactory.created_worlds.find { |e| e.id == executor_id }
+    executor = WorldFactory.created_worlds.find { |e| e.id == executor_id }
     raise "Could not find an executor with id #{executor_id}" unless executor
     yield executor
     return triggered
@@ -214,10 +214,10 @@ module TestHelpers
     assert_equal :stopped, plan.state
     assert_equal :success, plan.result
     assert_equal plan.execution_history.map(&:name),
-        ['start execution',
-         'terminate execution',
-         'start execution',
-         'finish execution']
+                 ['start execution',
+                  'terminate execution',
+                  'start execution',
+                  'finish execution']
     refute_equal plan.execution_history.first.world_id, plan.execution_history.to_a.last.world_id
   end
 end
@@ -239,7 +239,7 @@ events_test = -> do
 
   Concurrent::Edge::Event.singleton_class.send :define_method, :new do |*args, &block|
     super(*args, &block).tap do |event|
-      event_creations[event.object_id]  = caller(4)
+      event_creations[event.object_id] = caller(4)
     end
   end
 
@@ -332,10 +332,7 @@ module PlanAssertions
   end
 
   def assert_planning_success(execution_plan)
-    plan_steps = execution_plan.steps.values.find_all do |step|
-      step.is_a? Dynflow::ExecutionPlan::Steps::PlanStep
-    end
-    plan_steps.all? { |plan_step| plan_step.state.must_equal :success, plan_step.error }
+    execution_plan.plan_steps.all? { |plan_step| plan_step.state.must_equal :success, plan_step.error }
   end
 
   def assert_run_flow(expected, execution_plan)

data/test/testing_test.rb

@@ -74,7 +74,6 @@ module Dynflow
 
         5.times { progress_action_time action }
 
-
         action.output.must_equal('task' => { 'progress' => 100, 'done' => true },
                                  'poll_attempts' => {'total' => 9, 'failed' => 0 })
         action.run_progress.must_equal 1
@@ -166,6 +165,79 @@ module Dynflow
         end
       end
     end
-  end
 
+    describe "in thread executor" do
+      let :world do
+        Dynflow::Testing::InThreadWorld.instance
+      end
+
+      let :issues_data do
+        [{ 'author' => 'Peter Smith', 'text' => 'Failing test' },
+         { 'author' => 'John Doe', 'text' => 'Internal server error' }]
+      end
+
+      let :failing_issues_data do
+        [{ 'author' => 'Peter Smith', 'text' => 'Failing test' },
+         { 'author' => 'John Doe', 'text' => 'trolling' }]
+      end
+
+      let :finalize_failing_issues_data do
+        [{ 'author' => 'Peter Smith', 'text' => 'Failing test' },
+         { 'author' => 'John Doe', 'text' => 'trolling in finalize' }]
+      end
+
+      let :execution_plan do
+        world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
+      end
+
+      let :failed_execution_plan do
+        plan = world.plan(Support::CodeWorkflowExample::IncomingIssues, failing_issues_data)
+        plan = world.execute(plan.id).value
+        plan.state.must_equal :paused
+        plan
+      end
+
+      let :polling_execution_plan do
+        world.plan(Support::DummyExample::Polling, { :external_task_id => '123' })
+      end
+
+      it "is able to execute plans inside the thread" do
+        world.execute(execution_plan.id).value.tap do |plan|
+          plan.state.must_equal :stopped
+        end
+      end
+
+      it "is able to handle errors in the plan" do
+        world.execute(failed_execution_plan.id).value.tap do |plan|
+          plan.state.must_equal :paused
+        end
+      end
+
+      it "is able to handle when events" do
+        world.execute(polling_execution_plan.id).value.tap do |plan|
+          plan.state.must_equal :stopped
+        end
+      end
+
+      describe 'auto rescue' do
+        let(:world) do
+          WorldFactory.create_world(Dynflow::Testing::InThreadWorld) do |config|
+            config.auto_rescue = true
+          end
+        end
+
+        describe 'of plan with skips' do
+          let :execution_plan do
+            plan = world.plan(Support::RescueExample::ComplexActionWithSkip, :error_on_run)
+            world.execute(plan.id).value
+          end
+
+          it 'skips the action and continues automatically' do
+            execution_plan.state.must_equal :stopped
+            execution_plan.result.must_equal :warning
+          end
+        end
+      end
+    end
+  end
 end

data/web/views/plan_step.erb

@@ -4,6 +4,8 @@
       <span class="label label-<%= step_css_class(step) %>"><%= h("#{step.action_class}") %></span>
     </p>
     <div class="action">
+      <p><b>Started at:</b> <%= h(step.started_at) %></p>
+      <p><b>Ended at:</b> <%= h(step.ended_at) %> (duration <%= duration_to_s(step.real_time) %>)</p>
       <% action = step.action @plan %>
       <%= show_action_data("Input:", action.input) %>
       <%= step_error(step) %>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynflow
 version: !ruby/object:Gem::Version
-  version: 0.8.16
+  version: 0.8.17
 platform: ruby
 authors:
 - Ivan Necas
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-31 00:00:00.000000000 Z
+date: 2016-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -377,6 +377,13 @@ files:
 - lib/dynflow/delayed_executors/abstract_core.rb
 - lib/dynflow/delayed_executors/polling.rb
 - lib/dynflow/delayed_plan.rb
+- lib/dynflow/director.rb
+- lib/dynflow/director/execution_plan_manager.rb
+- lib/dynflow/director/flow_manager.rb
+- lib/dynflow/director/running_steps_manager.rb
+- lib/dynflow/director/sequence_cursor.rb
+- lib/dynflow/director/sequential_manager.rb
+- lib/dynflow/director/work_queue.rb
 - lib/dynflow/dispatcher.rb
 - lib/dynflow/dispatcher/abstract.rb
 - lib/dynflow/dispatcher/client_dispatcher.rb
@@ -397,13 +404,7 @@ files:
 - lib/dynflow/executors/abstract.rb
 - lib/dynflow/executors/parallel.rb
 - lib/dynflow/executors/parallel/core.rb
-- lib/dynflow/executors/parallel/execution_plan_manager.rb
-- lib/dynflow/executors/parallel/flow_manager.rb
 - lib/dynflow/executors/parallel/pool.rb
-- lib/dynflow/executors/parallel/running_steps_manager.rb
-- lib/dynflow/executors/parallel/sequence_cursor.rb
-- lib/dynflow/executors/parallel/sequential_manager.rb
-- lib/dynflow/executors/parallel/work_queue.rb
 - lib/dynflow/executors/parallel/worker.rb
 - lib/dynflow/flows.rb
 - lib/dynflow/flows/abstract.rb
@@ -457,6 +458,8 @@ files:
 - lib/dynflow/testing/dummy_step.rb
 - lib/dynflow/testing/dummy_world.rb
 - lib/dynflow/testing/factories.rb
+- lib/dynflow/testing/in_thread_executor.rb
+- lib/dynflow/testing/in_thread_world.rb
 - lib/dynflow/testing/managed_clock.rb
 - lib/dynflow/testing/mimic.rb
 - lib/dynflow/throttle_limiter.rb

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

@@ -1,111 +0,0 @@
-module Dynflow
-  module Executors
-    class Parallel < Abstract
-      class ExecutionPlanManager
-        include Algebrick::TypeCheck
-        include Algebrick::Matching
-
-        attr_reader :execution_plan, :future
-
-        def initialize(world, execution_plan, future)
-          @world                 = Type! world, World
-          @execution_plan        = Type! execution_plan, ExecutionPlan
-          @future                = Type! future, Concurrent::Edge::Future
-          @running_steps_manager = RunningStepsManager.new(world)
-
-          unless [:planned, :paused].include? execution_plan.state
-            raise "execution_plan is not in pending or paused state, it's #{execution_plan.state}"
-          end
-          execution_plan.execution_history.add('start execution', @world.id)
-          execution_plan.update_state(:running)
-        end
-
-        def start
-          raise "The future was already set" if @future.completed?
-          start_run or start_finalize or finish
-        end
-
-        def prepare_next_step(step)
-          Work::Step[step, execution_plan.id].tap do |work|
-            @running_steps_manager.add(step, work)
-          end
-        end
-
-        # @return [Array<Work>] of Work items to continue with
-        def what_is_next(work)
-          Type! work, Work
-
-          compute_next_from_step =-> step do
-            raise unless @run_manager
-            raise if @run_manager.done?
-
-            next_steps = @run_manager.what_is_next(step)
-            if @run_manager.done?
-              start_finalize or finish
-            else
-              next_steps.map { |s| prepare_next_step(s) }
-            end
-          end
-
-          match(work,
-                (on Work::Step.(step: ~any) | Work::Event.(step: ~any) do |step|
-                   execution_plan.steps[step.id] = step
-                   suspended, work = @running_steps_manager.done(step)
-                   unless suspended
-                     work = compute_next_from_step.call step
-                   end
-                   work
-                 end),
-                (on Work::Finalize do
-                   raise unless @finalize_manager
-                   finish
-                 end))
-        end
-
-        def event(event)
-          Type! event, Parallel::Event
-          raise unless event.execution_plan_id == @execution_plan.id
-          @running_steps_manager.event(event)
-        end
-
-        def done?
-          (!@run_manager || @run_manager.done?) && (!@finalize_manager || @finalize_manager.done?)
-        end
-
-        def terminate
-          @running_steps_manager.terminate
-        end
-
-        private
-
-        def no_work
-          raise "No work but not done" unless done?
-          []
-        end
-
-        def start_run
-          unless execution_plan.run_flow.empty?
-            raise 'run phase already started' if @run_manager
-            @run_manager = FlowManager.new(execution_plan, execution_plan.run_flow)
-            @run_manager.start.map { |s| prepare_next_step(s) }.tap { |a| raise if a.empty? }
-          end
-        end
-
-        def start_finalize
-          unless execution_plan.finalize_flow.empty?
-            raise 'finalize phase already started' if @finalize_manager
-            @finalize_manager = SequentialManager.new(@world, execution_plan)
-            Work::Finalize[@finalize_manager, execution_plan.id]
-          end
-        end
-
-        def finish
-          execution_plan.execution_history.add('finish execution', @world.id)
-          @execution_plan.update_state(execution_plan.error? ? :paused : :stopped)
-          return no_work
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-module Dynflow
-  module Executors
-    class Parallel < Abstract
-      class FlowManager
-        include Algebrick::TypeCheck
-
-        attr_reader :execution_plan, :cursor_index
-
-        def initialize(execution_plan, flow)
-          @execution_plan = Type! execution_plan, ExecutionPlan
-          @flow           = flow
-          @cursor_index   = {}
-          @cursor         = build_root_cursor
-        end
-
-        def done?
-          @cursor.done?
-        end
-
-        # @return [Set] of steps to continue with
-        def what_is_next(flow_step)
-          return [] if flow_step.state == :suspended
-
-          success = flow_step.state != :error
-          return cursor_index[flow_step.id].what_is_next(flow_step, success)
-        end
-
-        # @return [Set] of steps to continue with
-        def start
-          return @cursor.what_is_next.tap do |steps|
-            raise 'invalid state' if steps.empty? && !done?
-          end
-        end
-
-        private
-
-        def build_root_cursor
-          # the root cursor has to always run against sequence
-          sequence = @flow.is_a?(Flows::Sequence) ? @flow : Flows::Sequence.new([@flow])
-          return SequenceCursor.new(self, sequence, nil)
-        end
-      end
-    end
-  end
-end

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

@@ -1,81 +0,0 @@
-module Dynflow
-  module Executors
-    class Parallel < Abstract
-
-      # Handles the events generated while running actions, makes sure
-      # the events are sent to the action only when in suspended state
-      class RunningStepsManager
-        include Algebrick::TypeCheck
-
-        def initialize(world)
-          @world         = Type! world, World
-          @running_steps = {}
-          @events        = WorkQueue.new(Integer, Work)
-        end
-
-        def terminate
-          pending_work = @events.clear.values.flatten(1)
-          pending_work.each do |w|
-            if Work::Event === w
-              w.event.result.fail UnprocessableEvent.new("dropping due to termination")
-            end
-          end
-        end
-
-        def add(step, work)
-          Type! step, ExecutionPlan::Steps::RunStep
-          @running_steps[step.id] = step
-          # we make sure not to run any event when the step is still being executed
-          @events.push(step.id, work)
-          self
-        end
-
-        # @returns [Work, nil]
-        def done(step)
-          Type! step, ExecutionPlan::Steps::RunStep
-          @events.shift(step.id).tap do |work|
-            work.event.result.success true if Work::Event === work
-          end
-
-          if step.state == :suspended
-            return true, @events.first(step.id)
-          else
-            while (event = @events.shift(step.id))
-              message = "step #{step.execution_plan_id}:#{step.id} dropping event #{event.event}"
-              @world.logger.warn message
-              event.event.result.fail UnprocessableEvent.new(message).
-                                          tap { |e| e.set_backtrace(caller) }
-            end
-            raise 'assert' unless @events.empty?(step.id)
-            @running_steps.delete(step.id)
-            return false, nil
-          end
-        end
-
-        def try_to_terminate
-          @running_steps.delete_if do |_, step|
-            step.state != :running
-          end
-          return @running_steps.empty?
-        end
-
-        # @returns [Work, nil]
-        def event(event)
-          Type! event, Parallel::Event
-
-          step = @running_steps[event.step_id]
-          unless step
-            event.result.fail UnprocessableEvent.new(
-                                  'step is not suspended, it cannot process events')
-            return nil
-          end
-
-          can_run_event = @events.empty?(step.id)
-          work          = Work::Event[step, event.execution_plan_id, event]
-          @events.push(step.id, work)
-          work if can_run_event
-        end
-      end
-    end
-  end
-end