dynflow 1.3.0 → 1.4.0

data/lib/dynflow/director/sequence_cursor.rb

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

data/lib/dynflow/director/sequential_manager.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   class Director
     class SequentialManager
@@ -30,13 +31,22 @@ module Dynflow
         @done = true
       end
 
+      def finalize_steps
+        execution_plan.finalize_flow.all_step_ids.map do |step_id|
+          execution_plan.steps[step_id]
+        end
+      end
+
       def reset_finalize_steps
-        execution_plan.finalize_flow.all_step_ids.each do |step_id|
-          step       = execution_plan.steps[step_id]
+        finalize_steps.each do |step|
           step.state = :pending if [:success, :error].include? step.state
         end
       end
 
+      def done!
+        @done = true
+      end
+
       def done?
         @done
       end

data/lib/dynflow/dispatcher.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
 module Dynflow
   module Dispatcher
     Request = Algebrick.type do
       Event = type do
         fields! execution_plan_id: String,
                 step_id:           Integer,
-                event:             Object
+                event:             Object,
+                time:              type { variants Time, NilClass }
       end
 
       Execution = type do
@@ -33,7 +35,7 @@ module Dynflow
     end
 
     Envelope = Algebrick.type do
-      fields! request_id: Integer,
+      fields! request_id: String,
               sender_id: String,
               receiver_id: type { variants String, AnyExecutor = atom, UnknownWorld = atom },
               message: type { variants Request, Response }

data/lib/dynflow/dispatcher/abstract.rb

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

data/lib/dynflow/dispatcher/client_dispatcher.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
 module Dynflow
   module Dispatcher
     class ClientDispatcher < Abstract
 
       TrackedRequest = Algebrick.type do
-        fields! id: Integer, request: Request,
+        fields! id: String, request: Request,
                 accepted: Concurrent::Promises::ResolvableFuture, finished: Concurrent::Promises::ResolvableFuture
       end
 
@@ -33,7 +34,7 @@ module Dynflow
       # or whether the Ping really needs to be sent.
       class PingCache
         # Format string used for formating and parsing times
-        TIME_FORMAT = '%Y-%m-%d %H:%M:%S.%L'.freeze
+        TIME_FORMAT = '%Y-%m-%d %H:%M:%S.%L'
         DEFAULT_MAX_AGE = 60
 
         # Formats time into a string
@@ -105,7 +106,7 @@ module Dynflow
       attr_reader :ping_cache
       def initialize(world, ping_cache_age)
         @world            = Type! world, World
-        @last_id          = 0
+        @last_id_suffix   = 0
         @tracked_requests = {}
         @terminated       = nil
         @ping_cache       = PingCache.new world, ping_cache_age
@@ -197,7 +198,8 @@ module Dynflow
       end
 
       def track_request(finished, request, timeout)
-        id = @last_id += 1
+        id_suffix = @last_id_suffix += 1
+        id = "#{@world.id}-#{id_suffix}"
         tracked_request = TrackedRequest[id, request, Concurrent::Promises.resolvable_future, finished]
         @tracked_requests[id] = tracked_request
         @world.clock.ping(self, timeout, [:timeout, id]) if timeout

data/lib/dynflow/dispatcher/executor_dispatcher.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module Dispatcher
     class ExecutorDispatcher < Abstract
@@ -50,7 +51,18 @@ module Dynflow
             respond(envelope, Failed[reason.to_s])
           end
         end
-        @world.executor.event(event_request.execution_plan_id, event_request.step_id, event_request.event, future)
+        if event_request.time.nil? || event_request.time < Time.now
+          @world.executor.event(envelope.request_id, event_request.execution_plan_id, event_request.step_id, event_request.event, future)
+        else
+          @world.clock.ping(
+            @world.executor,
+            event_request.time,
+            Director::Event[envelope.request_id, event_request.execution_plan_id, event_request.step_id, event_request.event, Concurrent::Promises.resolvable_future],
+            :delayed_event
+          )
+          # resolves the future right away - currently we do not wait for the clock ping
+          future.fulfill true
+        end
       rescue Dynflow::Error => e
         future.reject(e) if future && !future.resolved?
       end

data/lib/dynflow/errors.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module Errors
     class RescueError < StandardError; end

data/lib/dynflow/execution_history.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   class ExecutionHistory
     include Algebrick::TypeCheck

data/lib/dynflow/execution_plan.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'securerandom'
 
 module Dynflow
@@ -121,9 +122,9 @@ module Dynflow
       original = self.state
       case self.state = state
       when :planning
-        @started_at = Time.now
+        @started_at = Time.now.utc
       when :stopped
-        @ended_at       = Time.now
+        @ended_at       = Time.now.utc
         @real_time      = @ended_at - @started_at unless @started_at.nil?
         @execution_time = compute_execution_time
         key = failure? ? :failure : :success

data/lib/dynflow/execution_plan/dependency_graph.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   class ExecutionPlan::DependencyGraph
 

data/lib/dynflow/execution_plan/hooks.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   class ExecutionPlan
     module Hooks

data/lib/dynflow/execution_plan/output_reference.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   class ExecutionPlan::OutputReference < Serializable
     include Algebrick::TypeCheck
@@ -59,7 +60,7 @@ module Dynflow
     end
 
     def to_s
-      "Step(#{step_id}).output".tap do |ret|
+      "Step(#{step_id}).output".dup.tap do |ret|
         ret << subkeys.map { |k| "[:#{k}]" }.join('') if subkeys.any?
       end
     end

data/lib/dynflow/execution_plan/steps.rb

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

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module ExecutionPlan::Steps
     class Abstract < Serializable
@@ -5,7 +6,7 @@ module Dynflow
       include Stateful
 
       attr_reader :execution_plan_id, :id, :state, :action_class, :action_id, :world, :started_at,
-                  :ended_at, :execution_time, :real_time, :queue
+                  :ended_at, :execution_time, :real_time, :queue, :delayed_events
       attr_accessor :error
 
       # rubocop:disable Metrics/ParameterLists
@@ -47,6 +48,10 @@ module Dynflow
       end
       # rubocop:enable Metrics/ParameterLists
 
+      def ==(other)
+        other.class == self.class && other.execution_plan_id == self.execution_plan_id && other.id == self.id
+      end
+
       def action_logger
         @world.action_logger
       end
@@ -63,8 +68,8 @@ module Dynflow
         world.persistence
       end
 
-      def save
-        persistence.save_step(self)
+      def save(conditions = {})
+        persistence.save_step(self, conditions)
       end
 
       def self.states
@@ -157,12 +162,12 @@ module Dynflow
       private
 
       def with_meta_calculation(action, &block)
-        start       = Time.now
+        start       = Time.now.utc
         @started_at ||= start
         block.call
       ensure
         calculate_progress(action)
-        @ended_at = Time.now
+        @ended_at = Time.now.utc
         current_execution_time = @ended_at - start
         @execution_time += current_execution_time
         @real_time       = @ended_at - @started_at

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module ExecutionPlan::Steps
     class AbstractFlowStep < Abstract
@@ -15,6 +16,7 @@ module Dynflow
         open_action do |action|
           with_meta_calculation(action) do
             action.execute(*args)
+            @delayed_events = action.delayed_events
           end
         end
       end

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

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

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module ExecutionPlan::Steps
     class FinalizeStep < AbstractFlowStep

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module ExecutionPlan::Steps
     class PlanStep < Abstract

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module ExecutionPlan::Steps
     class RunStep < AbstractFlowStep

data/lib/dynflow/executors.rb

@@ -1,7 +1,7 @@
+# frozen_string_literal: true
 module Dynflow
   module Executors
 
-    require 'dynflow/executors/abstract'
     require 'dynflow/executors/parallel'
 
     # Every time we run a code that can be defined outside of Dynflow,

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+module Dynflow
+  module Executors
+    module Abstract
+      class Core < Actor
+        attr_reader :logger
+
+        def initialize(world, heartbeat_interval, queues_options)
+          @logger         = world.logger
+          @world          = Type! world, World
+          @pools          = {}
+          @terminated     = nil
+          @director       = Director.new(@world)
+          @heartbeat_interval = heartbeat_interval
+          @queues_options = queues_options
+
+          schedule_heartbeat
+        end
+
+        def handle_execution(execution_plan_id, finished)
+          if terminating?
+            raise Dynflow::Error,
+                  "cannot accept execution_plan_id:#{execution_plan_id} core is terminating"
+          end
+
+          handle_work(@director.start_execution(execution_plan_id, finished))
+        end
+
+        def handle_event(event)
+          Type! event, Director::Event
+          if terminating?
+            raise Dynflow::Error,
+                  "cannot accept event: #{event} core is terminating"
+          end
+          handle_work(@director.handle_event(event))
+        end
+
+        def plan_events(delayed_events)
+          delayed_events.each do |event|
+            @world.plan_event(event.execution_plan_id, event.step_id, event.event, event.time)
+          end
+        end
+
+        def work_finished(work, delayed_events = nil)
+          handle_work(@director.work_finished(work))
+          plan_events(delayed_events) if delayed_events
+        end
+
+        def handle_persistence_error(error, work = nil)
+          logger.error "PersistenceError in executor"
+          logger.error error
+          @director.work_failed(work) if work
+          if error.is_a? Errors::FatalPersistenceError
+            logger.fatal "Terminating"
+            @world.terminate
+          end
+        end
+
+        def start_termination(*args)
+          logger.info 'shutting down Core ...'
+          super
+        end
+
+        def finish_termination
+          @director.terminate
+          logger.info '... Dynflow core terminated.'
+          super()
+        end
+
+        def dead_letter_routing
+          @world.dead_letter_handler
+        end
+
+        def execution_status(execution_plan_id = nil)
+          {}
+        end
+
+        def heartbeat
+          @logger.debug('Executor heartbeat')
+          record = @world.coordinator.find_records(:id => @world.id,
+                                                   :class => ['Dynflow::Coordinator::ExecutorWorld', 'Dynflow::Coordinator::ClientWorld']).first
+          unless record
+            logger.error(%{Executor's world record for #{@world.id} missing: terminating})
+            @world.terminate
+            return
+          end
+
+          record.data[:meta].update(:last_seen => Dynflow::Dispatcher::ClientDispatcher::PingCache.format_time)
+          @world.coordinator.update_record(record)
+          schedule_heartbeat
+        end
+
+        private
+
+        def suggest_queue(work_item)
+          queue = work_item.queue
+          unless @queues_options.key?(queue)
+            logger.debug("Pool is not available for queue #{queue}, falling back to #{fallback_queue}")
+            queue = fallback_queue
+          end
+          queue
+        end
+
+        def fallback_queue
+          :default
+        end
+
+        def schedule_heartbeat
+          @world.clock.ping(self, @heartbeat_interval, :heartbeat)
+        end
+
+        def on_message(message)
+          super
+        rescue Errors::PersistenceError => e
+          handle_persistence_error(e)
+        end
+
+        def handle_work(work_items)
+          return if terminating?
+          return if work_items.nil?
+          work_items = [work_items] if work_items.is_a? Director::WorkItem
+          work_items.all? { |i| Type! i, Director::WorkItem }
+          feed_pool(work_items)
+        end
+
+        def feed_pool(work_items)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/dynflow/executors/parallel.rb

@@ -1,15 +1,23 @@
+# frozen_string_literal: true
 module Dynflow
   module Executors
-    class Parallel < Abstract
+    class Parallel
+      require 'dynflow/executors/abstract/core'
       require 'dynflow/executors/parallel/core'
-      require 'dynflow/executors/parallel/pool'
-      require 'dynflow/executors/parallel/worker'
-
-      def initialize(world, heartbeat_interval, queues_options = { :default => { :pool_size => 5 }})
-        super(world)
-        @core = Core.spawn name:        'parallel-executor-core',
-                           args:        [world, heartbeat_interval, queues_options],
-                           initialized: @core_initialized = Concurrent::Promises.resolvable_future
+      # only load Sidekiq pieces when run in Sidekiq runtime (and the Sidekiq module is already loaded)
+      require 'dynflow/executors/sidekiq/core' if defined? ::Sidekiq
+
+      attr_reader :core
+
+      def initialize(world,
+                     executor_class:,
+                     heartbeat_interval:,
+                     queues_options: { :default => { :pool_size => 5 }})
+        @world  = world
+        @logger = world.logger
+        @core = executor_class.spawn name:        'parallel-executor-core',
+                                     args:        [world, heartbeat_interval, queues_options],
+                                     initialized: @core_initialized = Concurrent::Promises.resolvable_future
       end
 
       def execute(execution_plan_id, finished = Concurrent::Promises.resolvable_future, wait_for_acceptance = true)
@@ -25,11 +33,16 @@ module Dynflow
         raise e
       end
 
-      def event(execution_plan_id, step_id, event, future = Concurrent::Promises.resolvable_future)
-        @core.ask([:handle_event, Director::Event[execution_plan_id, step_id, event, future]])
+      def event(request_id, execution_plan_id, step_id, event, future = nil)
+        @core.ask([:handle_event, Director::Event[request_id, execution_plan_id, step_id, event, future]])
         future
       end
 
+      def delayed_event(director_event)
+        @core.ask([:handle_event, director_event])
+        director_event.result
+      end
+
       def terminate(future = Concurrent::Promises.resolvable_future)
         @core.tell([:start_termination, future])
         future