dynflow 1.8.1 → 1.8.3

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Dynflow
   module Debug
     module Telemetry
@@ -32,7 +33,7 @@ module Dynflow
 
         methods.each do |name|
           define_method(name) do |*args|
-            Dynflow::Telemetry.measure(:dynflow_persistence, :method => name, :world => @world.id) { super *args }
+            Dynflow::Telemetry.measure(:dynflow_persistence, :method => name, :world => @world.id) { super(*args) }
           end
         end
       end
@@ -40,4 +41,4 @@ module Dynflow
   end
 end
 
-::Dynflow::Persistence.send(:prepend, ::Dynflow::Debug::Persistence)
+::Dynflow::Persistence.prepend ::Dynflow::Debug::Persistence

data/lib/dynflow/delayed_executors/abstract.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
+
 module Dynflow
   module DelayedExecutors
     class Abstract
-
       attr_reader :core
 
       def initialize(world, options = {})
@@ -39,7 +39,6 @@ module Dynflow
       def core_class
         raise NotImplementedError
       end
-
     end
   end
 end

data/lib/dynflow/delayed_executors/abstract_core.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
+
 module Dynflow
   module DelayedExecutors
     class AbstractCore < Actor
-
       include Algebrick::TypeCheck
       attr_reader :world, :logger
 

data/lib/dynflow/delayed_executors/polling.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
+
 module Dynflow
   module DelayedExecutors
     class Polling < Abstract
-
       def core_class
         Dynflow::DelayedExecutors::PollingCore
       end
-
     end
 
     class PollingCore < AbstractCore

data/lib/dynflow/delayed_executors.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
+
 module Dynflow
   module DelayedExecutors
-
     require 'dynflow/delayed_executors/abstract'
     require 'dynflow/delayed_executors/abstract_core'
     require 'dynflow/delayed_executors/polling'
-
   end
 end

data/lib/dynflow/delayed_plan.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Dynflow
   class DelayedPlan < Serializable
-
     include Algebrick::TypeCheck
 
     attr_reader :execution_plan_uuid, :start_before
@@ -72,11 +72,11 @@ module Dynflow
     def self.new_from_hash(world, hash, *args)
       serializer = Utils.constantize(hash[:args_serializer]).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,
-               hash[:frozen] || false)
+        hash[:execution_plan_uuid],
+        string_to_time(hash[:start_at]),
+        string_to_time(hash[:start_before]),
+        serializer,
+        hash[:frozen] || false)
     rescue NameError => e
       error(e.message)
     end

data/lib/dynflow/director/execution_plan_manager.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Dynflow
   class Director
     class ExecutionPlanManager
@@ -118,7 +119,6 @@ module Dynflow
       def finish
         return no_work
       end
-
     end
   end
 end

data/lib/dynflow/director/flow_manager.rb

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

data/lib/dynflow/director/queue_hash.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Dynflow
   class Director
     class QueueHash
@@ -7,7 +8,7 @@ module Dynflow
       def initialize(key_type = Object, value_type = Object)
         @key_type = key_type
         @value_type = value_type
-        @stash     = Hash.new { |hash, key| hash[key] = [] }
+        @stash = Hash.new { |hash, key| hash[key] = [] }
       end
 
       def push(key, value)

data/lib/dynflow/director/running_steps_manager.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Dynflow
   class Director
     # Handles the events generated while running actions, makes sure
@@ -50,13 +51,13 @@ module Dynflow
           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) }
+              f.reject(UnprocessableEvent.new("Message dropped").tap { |e| e.set_backtrace(caller) })
             end
           end
           while (event = @events.shift(step.id))
             @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) }
+              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)

data/lib/dynflow/director/sequence_cursor.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
+
 module Dynflow
   class Director
     class SequenceCursor
-
       def initialize(flow_manager, sequence, parent_cursor = nil)
         @flow_manager    = flow_manager
         @sequence        = sequence
@@ -86,7 +86,6 @@ module Dynflow
           @todo << @flow_manager.execution_plan.steps[flow.step_id]
         end
       end
-
     end
   end
 end

data/lib/dynflow/director/sequential_manager.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Dynflow
   class Director
     class SequentialManager

data/lib/dynflow/director.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Dynflow
   # Director is responsible for telling what to do next when:
   #   * new execution starts
@@ -75,9 +76,9 @@ module Dynflow
 
       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])
+          Serializable.from_hash(hash[:step], hash[:execution_plan_id], Dynflow.process_world),
+          hash[:queue],
+          hash[:sender_orchestrator_id])
       end
     end
 
@@ -100,11 +101,11 @@ module Dynflow
 
       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])
+          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
 
@@ -301,16 +302,16 @@ module Dynflow
 
       if @execution_plan_managers[execution_plan_id]
         raise Dynflow::Error,
-              "cannot execute execution_plan_id:#{execution_plan_id} it's already running"
+          "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"
+          "cannot execute execution_plan_id:#{execution_plan_id} it's stopped"
       end
 
       @execution_plan_managers[execution_plan_id] =
-          ExecutionPlanManager.new(@world, execution_plan, finished)
+        ExecutionPlanManager.new(@world, execution_plan, finished)
     rescue Dynflow::Error => e
       finished.reject e
       nil

data/lib/dynflow/dispatcher/abstract.rb

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

data/lib/dynflow/dispatcher/client_dispatcher.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
+
 module Dynflow
   module Dispatcher
     class ClientDispatcher < Abstract
-
       TrackedRequest = Algebrick.type do
         fields! id: String, request: Request,
                 accepted: Concurrent::Promises::ResolvableFuture, finished: Concurrent::Promises::ResolvableFuture
@@ -134,16 +134,16 @@ module Dynflow
       def dispatch_request(request, client_world_id, request_id)
         ignore_unknown = false
         executor_id = match request,
-                            (on ~Execution | ~Planning do |execution|
-                               AnyExecutor
-                             end),
-                            (on ~Event do |event|
-                               ignore_unknown = event.optional
-                               find_executor(event.execution_plan_id)
-                             end),
-                            (on Ping.(~any, ~any) | Status.(~any, ~any) do |receiver_id, _|
-                               receiver_id
-                             end)
+          (on ~Execution | ~Planning do |execution|
+             AnyExecutor
+           end),
+          (on ~Event do |event|
+             ignore_unknown = event.optional
+             find_executor(event.execution_plan_id)
+           end),
+          (on Ping.(~any, ~any) | Status.(~any, ~any) do |receiver_id, _|
+             receiver_id
+           end)
         envelope = Envelope[request_id, client_world_id, executor_id, request]
         if Dispatcher::UnknownWorld === envelope.receiver_id
           raise Dynflow::Error, "Could not find an executor for #{envelope}" unless ignore_unknown
@@ -161,22 +161,22 @@ module Dynflow
       def dispatch_response(envelope)
         return unless @tracked_requests.key?(envelope.request_id)
         match envelope.message,
-              (on ~Accepted do
-                 @tracked_requests[envelope.request_id].accept!
-               end),
-              (on ~Failed do |msg|
-                 resolve_tracked_request(envelope.request_id, Dynflow::Error.new(msg.error))
-               end),
-              (on Done do
-                 resolve_tracked_request(envelope.request_id)
-               end),
-              (on Pong do
-                 add_ping_cache_record(envelope.sender_id)
-                 resolve_tracked_request(envelope.request_id)
-               end),
-              (on ExecutionStatus.(~any) do |steps|
-                 @tracked_requests.delete(envelope.request_id).success! steps
-               end)
+          (on ~Accepted do
+             @tracked_requests[envelope.request_id].accept!
+           end),
+          (on ~Failed do |msg|
+             resolve_tracked_request(envelope.request_id, Dynflow::Error.new(msg.error))
+           end),
+          (on Done do
+             resolve_tracked_request(envelope.request_id)
+           end),
+          (on Pong do
+             add_ping_cache_record(envelope.sender_id)
+             resolve_tracked_request(envelope.request_id)
+           end),
+          (on ExecutionStatus.(~any) do |steps|
+             @tracked_requests.delete(envelope.request_id).success! steps
+           end)
       end
 
       # Records when was the world with provided id last seen using a PingCache
@@ -233,12 +233,12 @@ module Dynflow
         else
           tracked_request = @tracked_requests[id]
           resolve_to = match tracked_request.request,
-                             (on Execution.(execution_plan_id: ~any) do |uuid|
-                                @world.persistence.load_execution_plan(uuid)
-                              end),
-                             (on Event | Ping do
-                                true
-                              end)
+            (on Execution.(execution_plan_id: ~any) do |uuid|
+               @world.persistence.load_execution_plan(uuid)
+             end),
+            (on Event | Ping do
+               true
+             end)
           @tracked_requests.delete(id).success! resolve_to
         end
       end

data/lib/dynflow/dispatcher/executor_dispatcher.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Dynflow
   module Dispatcher
     class ExecutorDispatcher < Abstract
@@ -9,10 +10,10 @@ module Dynflow
 
       def handle_request(envelope)
         match(envelope.message,
-              on(Planning) { perform_planning(envelope, envelope.message)},
-              on(Execution) { perform_execution(envelope, envelope.message) },
-              on(Event)     { perform_event(envelope, envelope.message) },
-              on(Status)    { get_execution_status(envelope, envelope.message) })
+          on(Planning) { perform_planning(envelope, envelope.message) },
+          on(Execution) { perform_execution(envelope, envelope.message) },
+          on(Event)     { perform_event(envelope, envelope.message) },
+          on(Status)    { get_execution_status(envelope, envelope.message) })
       end
 
       protected
@@ -61,13 +62,13 @@ module Dynflow
         end
         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,
-                                optional: event_request.optional)
+            optional: event_request.optional)
         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,
-                            event_request.optional],
+              event_request.optional],
             :delayed_event
           )
           # resolves the future right away - currently we do not wait for the clock ping

data/lib/dynflow/dispatcher.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Dynflow
   module Dispatcher
     Request = Algebrick.type do
@@ -33,10 +34,10 @@ module Dynflow
 
     Response = Algebrick.type do
       variants Accepted = atom,
-               Failed   = type { fields! error: String },
-               Done     = atom,
-               Pong     = atom,
-               ExecutionStatus = type { fields! execution_status: Hash }
+        Failed   = type { fields! error: String },
+        Done     = atom,
+        Pong     = atom,
+        ExecutionStatus = type { fields! execution_status: Hash }
     end
 
     Envelope = Algebrick.type do
@@ -49,9 +50,9 @@ module Dynflow
     module Envelope
       def build_response_envelope(response_message, sender)
         Envelope[self.request_id,
-                 sender.id,
-                 self.sender_id,
-                 response_message]
+          sender.id,
+          self.sender_id,
+          response_message]
       end
     end
 

data/lib/dynflow/errors.rb

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

data/lib/dynflow/execution_history.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Dynflow
   class ExecutionHistory
     include Algebrick::TypeCheck
@@ -35,7 +36,7 @@ module Dynflow
     end
 
     def inspect
-      "ExecutionHistory: #{ @events.inspect }"
+      "ExecutionHistory: #{@events.inspect}"
     end
 
     def self.new_from_hash(value)

data/lib/dynflow/execution_plan/dependency_graph.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Dynflow
   class ExecutionPlan::DependencyGraph
-
     def initialize
       @graph = Hash.new { |h, k| h[k] = Set.new }
     end
@@ -25,6 +25,5 @@ module Dynflow
     def unresolved?
       @graph.any? { |step_id, required_step_ids| required_step_ids.any? }
     end
-
   end
 end

data/lib/dynflow/execution_plan/hooks.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
+
 module Dynflow
   class ExecutionPlan
     module Hooks
-
       HOOK_KINDS = (ExecutionPlan.states + [:success, :failure]).freeze
 
       # A register holding information about hook classes and events

data/lib/dynflow/execution_plan/output_reference.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Dynflow
   class ExecutionPlan::OutputReference < Serializable
     include Algebrick::TypeCheck
@@ -77,10 +78,9 @@ module Dynflow
     def self.new_from_hash(hash)
       check_class_matching hash
       new(hash.fetch(:execution_plan_id),
-          hash.fetch(:step_id),
-          hash.fetch(:action_id),
-          hash.fetch(:subkeys))
+        hash.fetch(:step_id),
+        hash.fetch(:action_id),
+        hash.fetch(:subkeys))
     end
-
   end
 end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Dynflow
   module ExecutionPlan::Steps
     class Abstract < Serializable
@@ -6,7 +7,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, :delayed_events
+        :ended_at, :execution_time, :real_time, :queue, :delayed_events
       attr_accessor :error
 
       # rubocop:disable Metrics/ParameterLists
@@ -37,7 +38,7 @@ module Dynflow
         @progress_done     = Type! progress_done, Numeric, NilClass
         @progress_weight   = Type! progress_weight, Numeric, NilClass
 
-        @queue             = Type! queue, Symbol, NilClass
+        @queue = Type! queue, Symbol, NilClass
 
         self.state = state.to_sym
 
@@ -144,25 +145,25 @@ module Dynflow
       def self.new_from_hash(hash, execution_plan_id, world)
         check_class_matching hash
         new(execution_plan_id,
-            hash[:id],
-            hash[:state],
-            Action.constantize(hash[:action_class]),
-            hash[:action_id],
-            hash_to_error(hash[:error]),
-            world,
-            string_to_time(hash[:started_at]),
-            string_to_time(hash[:ended_at]),
-            hash[:execution_time].to_f,
-            hash[:real_time].to_f,
-            hash[:progress_done].to_f,
-            hash[:progress_weight].to_f,
-            (hash[:queue] && hash[:queue].to_sym))
+          hash[:id],
+          hash[:state],
+          Action.constantize(hash[:action_class]),
+          hash[:action_id],
+          hash_to_error(hash[:error]),
+          world,
+          string_to_time(hash[:started_at]),
+          string_to_time(hash[:ended_at]),
+          hash[:execution_time].to_f,
+          hash[:real_time].to_f,
+          hash[:progress_done].to_f,
+          hash[:progress_weight].to_f,
+          (hash[:queue] && hash[:queue].to_sym))
       end
 
       private
 
       def with_meta_calculation(action, &block)
-        start       = Time.now.utc
+        start = Time.now.utc
         @started_at ||= start
         block.call
       ensure
@@ -186,12 +187,12 @@ module Dynflow
         Dynflow::Telemetry.with_instance do |t|
           if [:success, :skipped].include?(state)
             t.observe_histogram(:dynflow_step_real_time,
-                                real_time * 1000,
-                                :action => action_class.to_s, :phase => phase.to_s_humanized)
+              real_time * 1000,
+              :action => action_class.to_s, :phase => phase.to_s_humanized)
           end
           t.observe_histogram(:dynflow_step_execution_time,
-                              current_execution_time * 1000,
-                              :action => action_class.to_s, :phase => phase.to_s_humanized)
+            current_execution_time * 1000,
+            :action => action_class.to_s, :phase => phase.to_s_humanized)
         end
       end
     end

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
+
 module Dynflow
   module ExecutionPlan::Steps
     class AbstractFlowStep < Abstract
-
       # Method called when initializing the step to customize the behavior based on the
       # action definition during the planning phase
       def update_from_action(action)

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Dynflow
   module ExecutionPlan::Steps
     class Error < Serializable
@@ -11,12 +12,12 @@ module Dynflow
         case args.size
         when 1
           match obj = args.first,
-                (on String do
-                  super(StandardError, obj, caller, nil)
-                end),
-                (on Exception do
-                  super(obj.class, obj.message, obj.backtrace, obj)
-                end)
+            (on String do
+              super(StandardError, obj, caller, nil)
+            end),
+            (on Exception do
+              super(obj.class, obj.message, obj.backtrace, obj)
+            end)
         when 3, 4
           super(*args.values_at(0..3))
         else
@@ -49,9 +50,9 @@ module Dynflow
 
       def to_s
         format '%s (%s)\n%s',
-               (@exception || self).message,
-               (@exception ? @exception.class : exception_class),
-               (@exception || self).backtrace
+          (@exception || self).message,
+          (@exception ? @exception.class : exception_class),
+          (@exception || self).backtrace
       end
 
       def exception

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
+
 module Dynflow
   module ExecutionPlan::Steps
     class FinalizeStep < AbstractFlowStep
-
       def self.state_transitions
         @state_transitions ||= {
             pending:   [:running, :skipped], # :skipped when its run_step is skipped
@@ -27,7 +27,6 @@ module Dynflow
         self.state = :skipped
         self.save
       end
-
     end
   end
 end