dynflow 1.3.0 → 1.4.0

data/lib/dynflow/connectors.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module Connectors
     require 'dynflow/connectors/abstract'

data/lib/dynflow/connectors/abstract.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module Connectors
     class Abstract

data/lib/dynflow/connectors/database.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module Connectors
     class Database < Abstract

data/lib/dynflow/connectors/direct.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module Connectors
     class Direct < Abstract

data/lib/dynflow/coordinator.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'dynflow/coordinator_adapters'
 
 module Dynflow

data/lib/dynflow/coordinator_adapters.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module CoordinatorAdapters
 

data/lib/dynflow/coordinator_adapters/abstract.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module CoordinatorAdapters
     class Abstract

data/lib/dynflow/coordinator_adapters/sequel.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module CoordinatorAdapters
     class Sequel < Abstract

data/lib/dynflow/dead_letter_silencer.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   class DeadLetterSilencer < Concurrent::Actor::DefaultDeadLetterHandler
     def initialize(matchers)
@@ -24,6 +25,7 @@ module Dynflow
       end
 
       def match?(dead_letter)
+        return unless dead_letter.sender.respond_to?(:actor_class)
         evaluate(dead_letter.sender.actor_class, @from) &&
           evaluate(dead_letter.message, @message) &&
           evaluate(dead_letter.address.actor_class, @to)

data/lib/dynflow/debug/telemetry/persistence.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module Debug
     module Telemetry

data/lib/dynflow/delayed_executors.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module DelayedExecutors
 

data/lib/dynflow/delayed_executors/abstract.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module DelayedExecutors
     class Abstract

data/lib/dynflow/delayed_executors/abstract_core.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module DelayedExecutors
     class AbstractCore < Actor

data/lib/dynflow/delayed_executors/polling.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module DelayedExecutors
     class Polling < Abstract

data/lib/dynflow/delayed_plan.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   class DelayedPlan < Serializable
 

data/lib/dynflow/director.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   # Director is responsible for telling what to do next when:
   #   * new execution starts
@@ -10,7 +11,8 @@ module Dynflow
     include Algebrick::TypeCheck
 
     Event = Algebrick.type do
-      fields! execution_plan_id: String,
+      fields! request_id:        String,
+              execution_plan_id: String,
               step_id:           Integer,
               event:             Object,
               result:            Concurrent::Promises::ResolvableFuture
@@ -18,57 +20,119 @@ module Dynflow
 
     UnprocessableEvent = Class.new(Dynflow::Error)
 
-    class WorkItem
-      attr_reader :execution_plan_id, :queue
+    class WorkItem < Serializable
+      attr_reader :execution_plan_id, :queue, :sender_orchestrator_id
 
-      def initialize(execution_plan_id, queue)
+      def initialize(execution_plan_id, queue, sender_orchestrator_id)
         @execution_plan_id = execution_plan_id
         @queue = queue
+        @sender_orchestrator_id = sender_orchestrator_id
+      end
+
+      def world
+        raise "World expected but not set for the work item #{self}" unless @world
+        @world
+      end
+
+      # the world to be used for execution purposes of the step. Setting it separately and explicitly
+      # as the world can't be serialized
+      def world=(world)
+        @world = world
       end
 
       def execute
         raise NotImplementedError
       end
+
+      def to_hash
+        { class: self.class.name,
+          execution_plan_id: execution_plan_id,
+          queue: queue,
+          sender_orchestrator_id: sender_orchestrator_id }
+      end
+
+      def self.new_from_hash(hash, *_args)
+        self.new(hash[:execution_plan_id], hash[:queue])
+      end
     end
 
     class StepWorkItem < WorkItem
       attr_reader :step
 
-      def initialize(execution_plan_id, step, queue)
-        super(execution_plan_id, queue)
+      def initialize(execution_plan_id, step, queue, sender_orchestrator_id)
+        super(execution_plan_id, queue, sender_orchestrator_id)
         @step = step
       end
 
       def execute
         @step.execute(nil)
       end
+
+      def to_hash
+        super.merge(step: step.to_hash)
+      end
+
+      def self.new_from_hash(hash, *_args)
+        self.new(hash[:execution_plan_id],
+                 Serializable.from_hash(hash[:step], hash[:execution_plan_id], Dynflow.process_world),
+                 hash[:queue],
+                 hash[:sender_orchestrator_id])
+      end
     end
 
     class EventWorkItem < StepWorkItem
-      attr_reader :event
+      attr_reader :event, :request_id
 
-      def initialize(execution_plan_id, step, event, queue)
-        super(execution_plan_id, step, queue)
+      def initialize(request_id, execution_plan_id, step, event, queue, sender_orchestrator_id)
+        super(execution_plan_id, step, queue, sender_orchestrator_id)
         @event = event
+        @request_id = request_id
       end
 
       def execute
-        @step.execute(@event.event)
+        @step.execute(@event)
+      end
+
+      def to_hash
+        super.merge(request_id: @request_id, event: Dynflow.serializer.dump(@event))
+      end
+
+      def self.new_from_hash(hash, *_args)
+        self.new(hash[:request_id],
+                 hash[:execution_plan_id],
+                 Serializable.from_hash(hash[:step], hash[:execution_plan_id], Dynflow.process_world),
+                 Dynflow.serializer.load(hash[:event]),
+                 hash[:queue],
+                 hash[:sender_orchestrator_id])
       end
     end
 
     class FinalizeWorkItem < WorkItem
-      def initialize(execution_plan_id, sequential_manager, queue)
-        super(execution_plan_id, queue)
-        @sequential_manager = sequential_manager
+      attr_reader :finalize_steps_data
+
+      # @param finalize_steps_data - used to pass the result steps from the worker back to orchestrator
+      def initialize(execution_plan_id, queue, sender_orchestrator_id, finalize_steps_data = nil)
+        super(execution_plan_id, queue, sender_orchestrator_id)
+        @finalize_steps_data = finalize_steps_data
       end
 
       def execute
-        @sequential_manager.finalize
+        execution_plan = world.persistence.load_execution_plan(execution_plan_id)
+        manager = Director::SequentialManager.new(world, execution_plan)
+        manager.finalize
+        @finalize_steps_data = manager.finalize_steps.map(&:to_hash)
+      end
+
+      def to_hash
+        super.merge(finalize_steps_data: @finalize_steps_data)
+      end
+
+      def self.new_from_hash(hash, *_args)
+        self.new(*hash.values_at(:execution_plan_id, :queue, :sender_orchestrator_id, :finalize_steps_data))
       end
     end
 
-    require 'dynflow/director/work_queue'
+    require 'dynflow/director/queue_hash'
     require 'dynflow/director/sequence_cursor'
     require 'dynflow/director/flow_manager'
     require 'dynflow/director/execution_plan_manager'
@@ -109,6 +173,7 @@ module Dynflow
 
     def work_finished(work)
       manager = @execution_plan_managers[work.execution_plan_id]
+      return [] unless manager # skip case when getting event from execution plan that is not running anymore
       unless_done(manager, manager.what_is_next(work))
     end
 

data/lib/dynflow/director/execution_plan_manager.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   class Director
     class ExecutionPlanManager
@@ -30,7 +31,7 @@ module Dynflow
       end
 
       def prepare_next_step(step)
-        StepWorkItem.new(execution_plan.id, step, step.queue).tap do |work|
+        StepWorkItem.new(execution_plan.id, step, step.queue, @world.id).tap do |work|
           @running_steps_manager.add(step, work)
         end
       end
@@ -42,13 +43,22 @@ module Dynflow
         case work
         when StepWorkItem
           step = work.step
-          execution_plan.steps[step.id] = step
+          update_steps([step])
           suspended, work = @running_steps_manager.done(step)
           work = compute_next_from_step(step) unless suspended
           work
         when FinalizeWorkItem
+          if work.finalize_steps_data
+            steps = work.finalize_steps_data.map do |step_data|
+              Serializable.from_hash(step_data, execution_plan.id, @world)
+            end
+            update_steps(steps)
+          end
           raise "Finalize work item without @finalize_manager ready" unless @finalize_manager
+          @finalize_manager.done!
           finish
+        else
+          raise "Unexpected work #{work}"
         end
       end
 
@@ -70,6 +80,10 @@ module Dynflow
 
       private
 
+      def update_steps(steps)
+        steps.each { |step| execution_plan.steps[step.id] = step }
+      end
+
       def compute_next_from_step(step)
         raise "run manager not set" unless @run_manager
         raise "run manager already done" if @run_manager.done?
@@ -98,7 +112,7 @@ module Dynflow
         return if execution_plan.finalize_flow.empty?
         raise 'finalize phase already started' if @finalize_manager
         @finalize_manager = SequentialManager.new(@world, execution_plan)
-        [FinalizeWorkItem.new(execution_plan.id, @finalize_manager, execution_plan.finalize_steps.first.queue)]
+        [FinalizeWorkItem.new(execution_plan.id, execution_plan.finalize_steps.first.queue, @world.id)]
       end
 
       def finish

data/lib/dynflow/director/flow_manager.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   class Director
     class FlowManager

data/lib/dynflow/director/{work_queue.rb → queue_hash.rb}

@@ -1,23 +1,24 @@
+# frozen_string_literal: true
 module Dynflow
   class Director
-    class WorkQueue
+    class QueueHash
       include Algebrick::TypeCheck
 
-      def initialize(key_type = Object, work_type = Object)
-        @key_type  = key_type
-        @work_type = work_type
+      def initialize(key_type = Object, value_type = Object)
+        @key_type = key_type
+        @value_type = value_type
         @stash     = Hash.new { |hash, key| hash[key] = [] }
       end
 
-      def push(key, work)
+      def push(key, value)
         Type! key, @key_type
-        Type! work, @work_type
-        @stash[key].push work
+        Type! value, @value_type
+        @stash[key].push value
       end
 
       def shift(key)
         return nil unless present? key
-        @stash[key].shift.tap { |work| @stash.delete(key) if @stash[key].empty? }
+        @stash[key].shift.tap { @stash.delete(key) if @stash[key].empty? }
       end
 
       def present?(key)

data/lib/dynflow/director/running_steps_manager.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   class Director
     # Handles the events generated while running actions, makes sure
@@ -8,11 +9,16 @@ module Dynflow
       def initialize(world)
         @world         = Type! world, World
         @running_steps = {}
-        @events        = WorkQueue.new(Integer, WorkItem)
+        # enqueued work items by step id
+        @work_items    = QueueHash.new(Integer, WorkItem)
+        # enqueued events by step id - we delay creating work items from events until execution time
+        # to handle potential updates of the step object (that is part of the event)
+        @events        = QueueHash.new(Integer, Director::Event)
+        @events_by_request_id = {}
       end
 
       def terminate
-        pending_work = @events.clear.values.flatten(1)
+        pending_work = @work_items.clear.values.flatten(1)
         pending_work.each do |w|
           if EventWorkItem === w
             w.event.result.reject UnprocessableEvent.new("dropping due to termination")
@@ -24,27 +30,38 @@ module Dynflow
         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)
+        @work_items.push(step.id, work)
         self
       end
 
       # @returns [TrueClass|FalseClass, Array<WorkItem>]
       def done(step)
         Type! step, ExecutionPlan::Steps::RunStep
-        @events.shift(step.id).tap do |work|
-          work.event.result.fulfill true if EventWorkItem === work
+        # update the step based on the latest finished work
+        @running_steps[step.id] = step
+
+        @work_items.shift(step.id).tap do |work|
+          finish_event_result(work) { |f| f.fulfill true }
         end
 
         if step.state == :suspended
-          return true, [@events.first(step.id)].compact
+          return true, [create_next_event_work_item(step)].compact
         else
+          while (work = @work_items.shift(step.id))
+            @world.logger.debug "step #{step.execution_plan_id}:#{step.id} dropping event #{work.request_id}/#{work.event}"
+            finish_event_result(work) do |f|
+              f.reject UnprocessableEvent.new("Message dropped").tap { |e| e.set_backtrace(caller) }
+            end
+          end
           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.reject UnprocessableEvent.new(message).
-                tap { |e| e.set_backtrace(caller) }
+            @world.logger.debug "step #{step.execution_plan_id}:#{step.id} dropping event #{event.request_id}/#{event}"
+            if event.result
+              event.result.reject UnprocessableEvent.new("Message dropped").tap { |e| e.set_backtrace(caller) }
+            end
+          end
+          unless @work_items.empty?(step.id) && @events.empty?(step.id)
+            raise "Unexpected item in @work_items (#{@work_items.inspect}) or @events (#{@events.inspect})"
           end
-          raise 'assert' unless @events.empty?(step.id)
           @running_steps.delete(step.id)
           return false, []
         end
@@ -60,19 +77,39 @@ module Dynflow
       # @returns [Array<WorkItem>]
       def event(event)
         Type! event, Event
-        next_work_items = []
 
         step = @running_steps[event.step_id]
         unless step
           event.result.reject UnprocessableEvent.new('step is not suspended, it cannot process events')
-          return next_work_items
+          return []
         end
 
-        can_run_event = @events.empty?(step.id)
-        work          = EventWorkItem.new(event.execution_plan_id, step, event, step.queue)
-        @events.push(step.id, work)
-        next_work_items << work if can_run_event
-        next_work_items
+        can_run_event = @work_items.empty?(step.id)
+        @events_by_request_id[event.request_id] = event
+        @events.push(step.id, event)
+        if can_run_event
+          [create_next_event_work_item(step)]
+        else
+          []
+        end
+      end
+
+      # turns the first event from the queue to the next work item to work on
+      def create_next_event_work_item(step)
+        event = @events.shift(step.id)
+        return unless event
+        work = EventWorkItem.new(event.request_id, event.execution_plan_id, step, event.event, step.queue, @world.id)
+        @work_items.push(step.id, work)
+        work
+      end
+
+      # @yield [Concurrent.resolvable_future] in case the work item has an result future assigned
+      # and deletes the tracked event
+      def finish_event_result(work_item)
+        return unless EventWorkItem === work_item
+        if event = @events_by_request_id.delete(work_item.request_id)
+          yield event.result if event.result
+        end
       end
     end
   end