dynflow 0.1.0 → 0.2.0

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

@@ -0,0 +1,119 @@
+module Dynflow
+  module Executors
+    class Parallel < Abstract
+
+      # TODO add dynflow error handling to avoid getting stuck and report errors to the future
+      class Core < MicroActor
+        def initialize(world, pool_size)
+          super(world.logger, world, pool_size)
+        end
+
+        private
+
+        def delayed_initialize(world, pool_size)
+          @world                   = Type! world, World
+          @pool                    = Pool.new(self, pool_size, world.transaction_adapter)
+          @execution_plan_managers = {}
+        end
+
+        def on_message(message)
+          match message,
+                (on ~Execution do |(execution_plan_id, finished)|
+                  start_executing track_execution_plan(execution_plan_id, finished)
+                  true
+                end),
+                (on ~Event do |event|
+                  event(event)
+                end),
+                (on PoolDone.(~any) do |step|
+                  update_manager(step)
+                end)
+        end
+
+        def termination
+          logger.info 'shutting down Core ...'
+          try_to_terminate
+        end
+
+        # @return false on problem
+        def track_execution_plan(execution_plan_id, finished)
+          execution_plan = @world.persistence.load_execution_plan(execution_plan_id)
+
+          if terminating?
+            raise Dynflow::Error, "cannot accept execution_plan_id:#{execution_plan_id} core is terminating"
+          end
+
+          if @execution_plan_managers[execution_plan_id]
+            raise Dynflow::Error, "cannot execute execution_plan_id:#{execution_plan_id} it's already running"
+          end
+
+          if execution_plan.state == :stopped
+            raise Dynflow::Error, "cannot execute execution_plan_id:#{execution_plan_id} it's stopped"
+          end
+
+          @execution_plan_managers[execution_plan_id] =
+              ExecutionPlanManager.new(@world, execution_plan, finished)
+
+        rescue Dynflow::Error => e
+          finished.fail e
+          raise e
+        end
+
+        def start_executing(manager)
+          Type! manager, ExecutionPlanManager
+
+          next_work = manager.start
+          continue_manager manager, next_work
+        end
+
+        def update_manager(finished_work)
+          manager   = @execution_plan_managers[finished_work.execution_plan_id]
+          next_work = manager.what_is_next(finished_work)
+          continue_manager manager, next_work
+        end
+
+        def continue_manager(manager, next_work)
+          if manager.done?
+            loose_manager_and_set_future manager.execution_plan.id
+            try_to_terminate
+          else
+            feed_pool next_work
+          end
+        end
+
+        def feed_pool(work_items)
+          Type! work_items, Array, Work, NilClass
+          return if work_items.nil?
+          work_items = [work_items] if work_items.is_a? Work
+          work_items.all? { |i| Type! i, Work }
+          work_items.each { |new_work| @pool << new_work }
+        end
+
+        def loose_manager_and_set_future(execution_plan_id)
+          manager = @execution_plan_managers.delete(execution_plan_id)
+          manager.future.resolve manager.execution_plan
+        end
+
+        def event(event)
+          Type! event, Event
+          execution_plan_manager = @execution_plan_managers[event.execution_plan_id]
+          if execution_plan_manager
+            feed_pool execution_plan_manager.event(event)
+            true
+          else
+            logger.warn "dropping event #{event} - no manager for #{event.execution_plan_id}:#{event.step_id}"
+            event.result.fail UnprocessableEvent.new("no manager for #{event.execution_plan_id}:#{event.step_id}")
+          end
+        end
+
+        def try_to_terminate
+          if terminating? && @execution_plan_managers.empty?
+            @pool.ask(Terminate).wait
+            logger.info '... Core terminated.'
+            terminate!
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+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, 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.update_state(:running)
+        end
+
+        def start
+          raise "The future was already set" if @future.ready?
+          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,
+
+                Work::Step.(step: ~any) >-> step do
+                  suspended, work = @running_steps_manager.done(step)
+                  if suspended
+                    raise 'assert' unless compute_next_from_step.call(step).empty?
+                    work
+                  else
+                    execution_plan.update_execution_time step.execution_time
+                    compute_next_from_step.call step
+                  end
+                end,
+
+                Work::Event.(step: ~any) >-> step do
+                  suspended, work = @running_steps_manager.done(step)
+
+                  if suspended
+                    work
+                  else
+                    execution_plan.update_execution_time step.execution_time
+                    compute_next_from_step.call step
+                  end
+                end,
+
+                Work::Finalize >-> do
+                  raise unless @finalize_manager
+                  finish
+                end
+        end
+
+        def event(event)
+          Type! event, 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
+
+        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.update_state(execution_plan.error? ? :paused : :stopped)
+          return no_work
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+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)
+          execution_plan.steps[flow_step.id] = flow_step
+          # TODO can be probably disabled to improve performance, execution time will not be updated, maybe more - check
+          execution_plan.save
+          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/pool.rb

@@ -0,0 +1,102 @@
+module Dynflow
+  module Executors
+    class Parallel < Abstract
+      class Pool < MicroActor
+        class RoundRobin
+          def initialize
+            @data   = []
+            @cursor = 0
+          end
+
+          def add(item)
+            @data.push item
+            self
+          end
+
+          def delete(item)
+            @data.delete item
+            self
+          end
+
+          def next
+            @cursor = 0 if @cursor > @data.size-1
+            @data[@cursor].tap { @cursor += 1 }
+          end
+
+          def empty?
+            @data.empty?
+          end
+        end
+
+        class JobStorage
+          def initialize
+            @round_robin = RoundRobin.new
+            @jobs        = Hash.new { |h, k| h[k] = [] }
+          end
+
+          def add(work)
+            @round_robin.add work.execution_plan_id unless tracked?(work)
+            @jobs[work.execution_plan_id] << work
+          end
+
+          def pop
+            return nil if empty?
+            execution_plan_id = @round_robin.next
+            @jobs[execution_plan_id].shift.tap { delete execution_plan_id if @jobs[execution_plan_id].empty? }
+          end
+
+          def empty?
+            @jobs.empty?
+          end
+
+          private
+
+          def tracked?(work)
+            @jobs.has_key? work.execution_plan_id
+          end
+
+          def delete(execution_plan_id)
+            @round_robin.delete execution_plan_id
+            @jobs.delete execution_plan_id
+          end
+        end
+
+        def initialize(core, pool_size, transaction_adapter)
+          super(core.logger, core, pool_size, transaction_adapter)
+        end
+
+        private
+
+        def delayed_initialize(core, pool_size, transaction_adapter)
+          @core         = core
+          @pool_size    = pool_size
+          @free_workers = Array.new(pool_size) { Worker.new(self, transaction_adapter) }
+          @jobs         = JobStorage.new
+        end
+
+        def on_message(message)
+          match message,
+                ~Work >-> work do
+                  @jobs.add work
+                  distribute_jobs
+                end,
+                WorkerDone.(~any, ~any) >-> step, worker do
+                  @core << PoolDone[step]
+                  @free_workers << worker
+                  distribute_jobs
+                end
+        end
+
+        def termination
+          raise unless @free_workers.size == @pool_size
+          @free_workers.map { |worker| worker.ask(Terminate) }.each(&:wait)
+          super
+        end
+
+        def distribute_jobs
+          @free_workers.pop << @jobs.pop until @free_workers.empty? || @jobs.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+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 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.resolve 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
+
+        # @returns [Work, nil]
+        def event(event)
+          Type! event, 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