dynflow 1.8.1 → 1.8.3

data/lib/dynflow/world.rb

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 # frozen_string_literal: true
+
 require 'dynflow/world/invalidation'
 
 module Dynflow
@@ -9,10 +10,10 @@ module Dynflow
     include Invalidation
 
     attr_reader :id, :config, :client_dispatcher, :executor_dispatcher, :executor, :connector,
-                :transaction_adapter, :logger_adapter, :coordinator,
-                :persistence, :action_classes, :subscription_index,
-                :middleware, :auto_rescue, :clock, :meta, :delayed_executor, :auto_validity_check, :validity_check_timeout, :throttle_limiter,
-                :termination_timeout, :terminated, :dead_letter_handler, :execution_plan_cleaner
+      :transaction_adapter, :logger_adapter, :coordinator,
+      :persistence, :action_classes, :subscription_index,
+      :middleware, :auto_rescue, :clock, :meta, :delayed_executor, :auto_validity_check, :validity_check_timeout, :throttle_limiter,
+      :termination_timeout, :terminated, :dead_letter_handler, :execution_plan_cleaner
 
     def initialize(config)
       @config = Config::ForWorld.new(config, self)
@@ -27,14 +28,14 @@ module Dynflow
       @config.validate
       @transaction_adapter    = @config.transaction_adapter
       @persistence            = Persistence.new(self, @config.persistence_adapter,
-                                                :backup_deleted_plans => @config.backup_deleted_plans,
-                                                :backup_dir => @config.backup_dir)
+        :backup_deleted_plans => @config.backup_deleted_plans,
+        :backup_dir => @config.backup_dir)
       @coordinator            = Coordinator.new(@config.coordinator_adapter)
       if @config.executor
         @executor = Executors::Parallel.new(self,
-                                            executor_class: @config.executor,
-                                            heartbeat_interval: @config.executor_heartbeat_interval,
-                                            queues_options: @config.queues)
+          executor_class: @config.executor,
+          heartbeat_interval: @config.executor_heartbeat_interval,
+          queues_options: @config.queues)
       end
       @action_classes         = @config.action_classes
       @auto_rescue            = @config.auto_rescue
@@ -86,7 +87,7 @@ module Dynflow
     end
 
     def update_register
-      @meta                     ||= @config.meta
+      @meta ||= @config.meta
       @meta['queues']           = @config.queues if @executor
       @meta['delayed_executor'] = true if @delayed_executor
       @meta['execution_plan_cleaner'] = true if @execution_plan_cleaner
@@ -278,7 +279,7 @@ module Dynflow
     def auto_execute
       coordinator.acquire(Coordinator::AutoExecuteLock.new(self)) do
         planned_execution_plans =
-            self.persistence.find_execution_plans filters: { 'state' => %w(planned paused), 'result' => (ExecutionPlan.results - [:error]).map(&:to_s) }
+          self.persistence.find_execution_plans filters: { 'state' => %w(planned paused), 'result' => (ExecutionPlan.results - [:error]).map(&:to_s) }
         planned_execution_plans.map do |ep|
           if coordinator.find_locks(Dynflow::Coordinator::ExecutionLock.unique_filter(ep.id)).empty?
             execute(ep.id)
@@ -297,7 +298,7 @@ module Dynflow
       coordinator.acquire(lock_class.new(self)) if lock_class
       object.spawn.wait
       object
-    rescue Coordinator::LockError => e
+    rescue Coordinator::LockError
       nil
     end
 
@@ -361,12 +362,12 @@ module Dynflow
 
     def calculate_subscription_index
       @subscription_index =
-          action_classes.each_with_object(Hash.new { |h, k| h[k] = [] }) do |klass, index|
-            next unless klass.subscribe
-            Array(klass.subscribe).each do |subscribed_class|
-              index[Utils.constantize(subscribed_class.to_s)] << klass
-            end
-          end.tap { |o| o.freeze }
+        action_classes.each_with_object(Hash.new { |h, k| h[k] = [] }) do |klass, index|
+          next unless klass.subscribe
+          Array(klass.subscribe).each do |subscribed_class|
+            index[Utils.constantize(subscribed_class.to_s)] << klass
+          end
+        end.tap { |o| o.freeze }
     end
 
     def run_before_termination_hooks
@@ -388,6 +389,5 @@ module Dynflow
       initialized.wait
       return actor
     end
-
   end
 end

data/lib/dynflow.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 require 'apipie-params'
 require 'algebrick'
-require 'thread'
 require 'set'
 require 'base64'
 require 'concurrent'
@@ -25,7 +25,7 @@ module Dynflow
     # @return [Dynflow::World, nil]
     def process_world
       return @process_world if defined? @process_world
-      @process_world = Sidekiq.options[:dynflow_world]
+      @process_world = Sidekiq.configure_server { |c| c.options[:dynflow_world] }
       raise "process world is not set" unless @process_world
       @process_world
     end
@@ -79,10 +79,7 @@ module Dynflow
 
     class Railtie < ::Rails::Railtie
       config.before_initialize do
-        ::ActiveJob::QueueAdapters.send(
-          :include,
-          Dynflow::ActiveJob::QueueAdapters
-        )
+        ::ActiveJob::QueueAdapters.include Dynflow::ActiveJob::QueueAdapters
       end
     end
   end

data/test/abnormal_states_recovery_test.rb

@@ -1,13 +1,12 @@
 # -*- coding: utf-8 -*-
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'ostruct'
 
 module Dynflow
   module ConsistencyCheckTest
-
     describe "consistency check" do
-
       include TestHelpers
 
       def with_invalidation_while_executing(finish)
@@ -43,7 +42,6 @@ module Dynflow
       let(:client_world_2) { create_world(false) }
 
       describe "for plans assigned to invalid world" do
-
         before do
           # mention the executors to make sure they are initialized
           [executor_world, executor_world_2]
@@ -187,7 +185,6 @@ module Dynflow
       end
 
       describe 'auto execute' do
-
         before do
           client_world.persistence.delete_execution_plans({})
         end
@@ -273,10 +270,10 @@ module Dynflow
           end
 
           it 'by default, the auto_validity_check is enabled only for executor words' do
-            client_world_config = Config::ForWorld.new(Config.new.tap { |c| c.executor = false }, create_world )
+            client_world_config = Config::ForWorld.new(Config.new.tap { |c| c.executor = false }, create_world)
             _(client_world_config.auto_validity_check).must_equal false
 
-            executor_world_config = Config::ForWorld.new(Config.new.tap { |c| c.executor = Executors::Parallel::Core }, create_world )
+            executor_world_config = Config::ForWorld.new(Config.new.tap { |c| c.executor = Executors::Parallel::Core }, create_world)
             _(executor_world_config.auto_validity_check).must_equal true
           end
 
@@ -304,7 +301,7 @@ module Dynflow
             _(client_world.coordinator.find_worlds(false, id: [invalid_world.id, invalid_world_2.id]).size).must_equal 2
 
             results = client_world.worlds_validity_check(true, :id => invalid_world.id)
-            _(results).must_equal(invalid_world.id =>  :invalidated)
+            _(results).must_equal(invalid_world.id => :invalidated)
             _(client_world.coordinator.find_worlds(false, id: [invalid_world.id, invalid_world_2.id]).size).must_equal 1
           end
         end
@@ -382,4 +379,3 @@ module Dynflow
     end
   end
 end
-

data/test/action_test.rb

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'mocha/minitest'
 
 module Dynflow
   describe 'action' do
-
     let(:world) { WorldFactory.create_world }
 
     describe Action::Missing do
-
       let :action_data do
         { class:             'RenamedAction',
           id:                1,
@@ -32,7 +31,6 @@ module Dynflow
     end
 
     describe 'children' do
-
       smart_action_class   = Class.new(Dynflow::Action)
       smarter_action_class = Class.new(smart_action_class)
 
@@ -50,7 +48,6 @@ module Dynflow
     end
 
     describe Action::Present do
-
       let :execution_plan do
         result = world.trigger(Support::CodeWorkflowExample::IncomingIssues, issues_data)
         _(result).must_be :planned?
@@ -74,7 +71,6 @@ module Dynflow
     end
 
     describe 'serialization' do
-
       include Testing
 
       it 'fails when input is not serializable' do
@@ -196,10 +192,9 @@ module Dynflow
       end
 
       class TestPollingAction < Dynflow::Action
-
         class Config
           attr_accessor :external_service, :poll_max_retries,
-                        :poll_intervals, :attempts_before_next_interval
+            :poll_intervals, :attempts_before_next_interval
 
           def initialize
             @external_service              = ExternalService.new
@@ -383,7 +378,6 @@ module Dynflow
     end
 
     describe Action::WithSubPlans do
-
       class FailureSimulator
         class << self
           attr_accessor :fail_in_child_plan, :fail_in_child_run
@@ -399,7 +393,6 @@ module Dynflow
       end
 
       class ParentAction < Dynflow::Action
-
         include Dynflow::Action::WithSubPlans
 
         def plan(*_)
@@ -413,7 +406,7 @@ module Dynflow
 
         def resume(*args)
           output[:custom_resume] = true
-          super *args
+          super(*args)
         end
       end
 
@@ -481,7 +474,6 @@ module Dynflow
         def batch(from, size)
           total_count.times.drop(from).take(size)
         end
-
       end
 
       let(:execution_plan) { world.trigger(ParentAction, count: 2).finished.value }
@@ -506,7 +498,7 @@ module Dynflow
       end
 
       specify "it saves the information about number for sub plans in the output" do
-        _(execution_plan.entry_action.output).must_equal('total_count'   => 2,
+        _(execution_plan.entry_action.output).must_equal('total_count' => 2,
                                                       'failed_count'  => 0,
                                                       'success_count' => 2,
                                                       'pending_count' => 0)
@@ -514,7 +506,7 @@ module Dynflow
 
       specify "when a sub plan fails, the caller action fails as well" do
         FailureSimulator.fail_in_child_run = true
-        _(execution_plan.entry_action.output).must_equal('total_count'   => 2,
+        _(execution_plan.entry_action.output).must_equal('total_count' => 2,
                                                       'failed_count'  => 2,
                                                       'success_count' => 0,
                                                       'pending_count' => 0)
@@ -789,7 +781,7 @@ module Dynflow
             plan = world.plan(SingletonAction)
             _(plan.state).must_equal :planned
             lock_filter = ::Dynflow::Coordinator::SingletonActionLock
-                            .unique_filter plan.entry_action.class.name
+                          .unique_filter plan.entry_action.class.name
             _(world.coordinator.find_locks(lock_filter).count).must_equal 1
             plan = world.execute(plan.id).wait!.value
             _(plan.state).must_equal :stopped
@@ -801,7 +793,7 @@ module Dynflow
             plan = world.plan(SingletonActionWithFinalize)
             _(plan.state).must_equal :planned
             lock_filter = ::Dynflow::Coordinator::SingletonActionLock
-                              .unique_filter plan.entry_action.class.name
+                          .unique_filter plan.entry_action.class.name
             _(world.coordinator.find_locks(lock_filter).count).must_equal 1
             plan = world.execute(plan.id).wait!.value
             _(plan.state).must_equal :stopped
@@ -813,7 +805,7 @@ module Dynflow
             plan = world.plan(SuspendedSingletonAction)
             _(plan.state).must_equal :planned
             lock_filter = ::Dynflow::Coordinator::SingletonActionLock
-                              .unique_filter plan.entry_action.class.name
+                          .unique_filter plan.entry_action.class.name
             _(world.coordinator.find_locks(lock_filter).count).must_equal 1
             future = world.execute(plan.id)
             wait_for do
@@ -859,7 +851,7 @@ module Dynflow
 
             # The lock was released when plan3 stopped
             lock_filter = ::Dynflow::Coordinator::SingletonActionLock
-                              .unique_filter plan3.entry_action.class.name
+                          .unique_filter plan3.entry_action.class.name
             _(world.coordinator.find_locks(lock_filter)).must_be :empty?
           end
 
@@ -868,7 +860,7 @@ module Dynflow
             plan1 = world.plan(BadAction, true)
             _(plan1.state).must_equal :planned
             lock_filter = ::Dynflow::Coordinator::SingletonActionLock
-                              .unique_filter plan1.entry_action.class.name
+                          .unique_filter plan1.entry_action.class.name
             _(world.coordinator.find_locks(lock_filter).count).must_equal 0
             plan2 = world.plan(BadAction, false)
             _(plan2.state).must_equal :planned

data/test/activejob_adapter_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'active_job'
 require 'dynflow/active_job/queue_adapter'
@@ -21,7 +22,7 @@ module Dynflow
     end
 
     before(:all) do
-      ::ActiveJob::QueueAdapters.send(:include, ::Dynflow::ActiveJob::QueueAdapters)
+      ::ActiveJob::QueueAdapters.include ::Dynflow::ActiveJob::QueueAdapters
       ::ActiveJob::Base.queue_adapter = :dynflow
       dynflow_mock = Minitest::Mock.new
       dynflow_mock.expect(:world, world)
@@ -71,4 +72,3 @@ module Dynflow
     end
   end
 end
-

data/test/batch_sub_tasks_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 
 module Dynflow
@@ -109,7 +110,6 @@ module Dynflow
         _(action.send(:can_spawn_next_batch?)).must_equal false
         _(action.current_batch).must_be :empty?
       end
-
     end
   end
 end

data/test/clock_test.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'logger'
 
 clock_class = Dynflow::Clock
 
 describe clock_class do
-
   let(:clock) { clock_class.spawn 'clock' }
 
   it 'refuses who without #<< method' do
@@ -48,7 +48,6 @@ describe clock_class do
         assert_equal (0...times).to_a, Array.new(times) { q.pop }.sort
       end
     end
-    threads.each &:join
+    threads.each(&:join)
   end
-
 end

data/test/concurrency_control_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 
 module Dynflow
@@ -81,8 +82,8 @@ module Dynflow
       end
 
       def check_step(plan, total, finished)
-        _(world.throttle_limiter.observe(plan.id).length).must_equal (total - finished)
-        _(plan.sub_plans.select { |sub| planned? sub }.count).must_equal (total - finished)
+        _(world.throttle_limiter.observe(plan.id).length).must_equal(total - finished)
+        _(plan.sub_plans.select { |sub| planned? sub }.count).must_equal(total - finished)
         _(plan.sub_plans.select { |sub| successful? sub }.count).must_equal finished
       end
 
@@ -95,14 +96,12 @@ module Dynflow
       end
 
       class LoggingThrottleLimiter < Dynflow::ThrottleLimiter
-
         class LoggingCore < Dynflow::ThrottleLimiter::Core
-
           attr_reader :running
 
           def initialize(*args)
             @running = [0]
-            super *args
+            super(*args)
           end
 
           def release(*args)
@@ -233,12 +232,12 @@ module Dynflow
           planned, running = plan.sub_plans.partition { |sub| planned? sub }
           _(planned.count).must_equal total - level
           _(running.count).must_equal level
-          _(world.throttle_limiter.observe(plan.id).length).must_equal (total - 1)
+          _(world.throttle_limiter.observe(plan.id).length).must_equal(total - 1)
           4.times { klok.progress }
           wait_for { future.resolved? }
           finished, stopped = plan.sub_plans.partition { |sub| successful? sub }
           _(finished.count).must_equal level
-          _(stopped.count).must_equal (total - level)
+          _(stopped.count).must_equal(total - level)
         end
       end
     end

data/test/coordinator_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'fileutils'
 

data/test/daemon_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'test_helper'
 require 'active_support'
 require 'mocha/minitest'
@@ -34,8 +35,8 @@ class DaemonTest < ActiveSupport::TestCase
     @daemon.stubs(:sleep).returns(true) # don't pause the execution
     @current_folder = File.expand_path('../support/rails/', __FILE__)
     ::ActiveRecord::Base.configurations = { 'development' => {} }
-    ::Dynflow::Rails::Configuration.any_instance.stubs(:initialize_persistence).
-      returns(WorldFactory.persistence_adapter)
+    ::Dynflow::Rails::Configuration.any_instance.stubs(:initialize_persistence)
+                                   .returns(WorldFactory.persistence_adapter)
   end
 
   teardown do

data/test/dead_letter_silencer_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'ostruct'
 
@@ -12,7 +13,7 @@ module Dynflow
 
       it 'is started for each world' do
         _(world.dead_letter_handler.actor_class)
-             .must_equal ::Dynflow::DeadLetterSilencer
+          .must_equal ::Dynflow::DeadLetterSilencer
       end
 
       describe ::Dynflow::DeadLetterSilencer::Matcher do

data/test/dispatcher_test.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 
 module Dynflow
   module DispatcherTest
     describe "dispatcher" do
-
       include TestHelpers
 
       let(:persistence_adapter) { WorldFactory.persistence_adapter }
@@ -27,8 +27,8 @@ module Dynflow
             it 'succeeds when expected' do
               result = client_world.trigger(Support::DummyExample::DeprecatedEventedAction, :timeout => 3)
               step = wait_for do
-                client_world.persistence.load_execution_plan(result.id).
-                    steps_in_state(:suspended).first
+                client_world.persistence.load_execution_plan(result.id)
+                            .steps_in_state(:suspended).first
               end
               client_world.event(step.execution_plan_id, step.id, 'finish')
               plan = result.finished.value
@@ -53,7 +53,7 @@ module Dynflow
             it 'does not error on dispatching an optional event' do
               request = client_world.event('123', 1, nil, optional: true)
               request.wait(20)
-              assert_match /Could not find an executor for optional .*, discarding/, request.reason.message
+              assert_match(/Could not find an executor for optional .*, discarding/, request.reason.message)
             end
           end
         end
@@ -72,7 +72,6 @@ module Dynflow
             assert_plan_reexecuted(plan)
           end
         end
-
       end
 
       def self.supports_ping_pong

data/test/execution_plan_cleaner_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'mocha/minitest'
 

data/test/execution_plan_hooks_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 
 module Dynflow