dynflow 1.1.2 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd598d9b0729e31768151b6079b88fad1fd1ee9336dae678f65abd2787aeec85
-  data.tar.gz: 305b54dde96ab5521e04cc1574f7169e46ea89b3fe0d4e0ae30f8a5b220a7d51
+  metadata.gz: f162fe5b456a60898fad5ea4f3eec20ee1301f4adc8e4939946b03962b0ce12d
+  data.tar.gz: 591f53a8eafe2f94f61c5988fdc02d39ee8405726522a458394cfaa5dd3a260e
 SHA512:
-  metadata.gz: f2f30544726a096da979f6f07d0b5ca9620cfbd9c99fd95092d132b3b9a7004447f3dc6aed28bf61df9db373970236ce83a43b1e60d2f623851dc951e441ce6e
-  data.tar.gz: cd392df7f4e7aba1f41ae7bb6c903347ae2505562b866150045f6689e7729c59ac712f972b3cfc0f754064b53895a8dd92c147d6037e9946fbcbf69cea468d62
+  metadata.gz: 41345060fa6037bd1d10f9f6c3515ffe495b131e71744a8820d112f0547f21426b3829de522d1d4571cc4beecfde12f350f080f83fa62ec1be67652a976ef49d
+  data.tar.gz: 7ecec4743683c885c4e98caf978d1cd75d0647da11d88baab5b051fffa0192ee727d6feef1d61fbc1906f874f412f5486a9eb516e5a7aeded9c343de2f6df25d

data/dynflow.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
   s.add_dependency "multi_json"
   s.add_dependency "apipie-params"
   s.add_dependency "algebrick", '~> 0.7.0'
-  s.add_dependency "concurrent-ruby", '~> 1.0'
+  s.add_dependency "concurrent-ruby", '~> 1.0.0'
   s.add_dependency "concurrent-ruby-edge", '~> 0.2.0'
   s.add_dependency "sequel", '>= 4.0.0'
 

data/lib/dynflow/coordinator.rb

@@ -251,6 +251,18 @@ module Dynflow
       def self.lock_id(action_class)
         'singleton-action:' + action_class
       end
+
+      def self.valid_owner_ids(coordinator)
+        lock_ids = coordinator.find_locks(:class => self.name).map(&:owner_id)
+        plans = coordinator.adapter.find_execution_plans(:uuid => lock_ids)
+        plans = Hash[*plans.map { |plan| [plan[:uuid], plan[:state]] }.flatten]
+        lock_ids.select { |id| plans.key?(id) && !%w(stopped paused).include?(plans[id]) }
+                .map { |id| 'execution-plan:' + id }
+      end
+
+      def self.valid_classes
+        [self]
+      end
     end
 
     class ExecutionLock < LockByWorld
@@ -367,7 +379,7 @@ module Dynflow
     end
 
     def clean_orphaned_locks
-      cleanup_classes = [LockByWorld]
+      cleanup_classes = [LockByWorld, SingletonActionLock]
       ret = []
       cleanup_classes.each do |cleanup_class|
         valid_owner_ids = cleanup_class.valid_owner_ids(self)

data/lib/dynflow/coordinator_adapters/abstract.rb

@@ -23,6 +23,10 @@ module Dynflow
       def find_records(record)
         raise NotImplementedError
       end
+
+      def find_execution_plans(filter_options)
+        raise NotImplementedError
+      end
     end
   end
 end

data/lib/dynflow/coordinator_adapters/sequel.rb

@@ -28,6 +28,10 @@ module Dynflow
       def find_records(filter_options)
         @sequel_adapter.find_coordinator_records(filters: filter_options)
       end
+
+      def find_execution_plans(filter_options)
+        @sequel_adapter.find_execution_plans(filters: filter_options)
+      end
     end
   end
 end

data/lib/dynflow/rails.rb

@@ -45,6 +45,7 @@ module Dynflow
             invalidated_worlds = world.perform_validity_checks
             world.auto_execute
             world.post_initialization if invalidated_worlds > 0
+            config.run_post_executor_init_hooks(world)
           end
         end
       end

data/lib/dynflow/rails/configuration.rb

@@ -39,8 +39,9 @@ module Dynflow
         self.lazy_initialization      = !::Rails.env.production?
         self.rake_tasks_with_executor = %w(db:migrate db:seed)
 
-        @on_init           = []
-        @on_executor_init  = []
+        @on_init            = []
+        @on_executor_init   = []
+        @post_executor_init = []
       end
 
       # Action related info such as exceptions raised inside the actions' methods
@@ -65,6 +66,14 @@ module Dynflow
         source.each { |init| init.call(world) }
       end
 
+      def post_executor_init(&block)
+        @post_executor_init << block
+      end
+
+      def run_post_executor_init_hooks(world)
+        @post_executor_init.each { |init| init.call(world) }
+      end
+
       def initialize_world(world_class = ::Dynflow::World)
         world_class.new(world_config)
       end

data/lib/dynflow/rails/daemon.rb

@@ -142,12 +142,12 @@ module Dynflow
 
       def log_memory_limit_exceeded(current_memory, memory_limit)
         message = "Memory level exceeded, registered #{current_memory} bytes, which is greater than #{memory_limit} limit."
-        world.dynflow_logger.error(message)
+        world.logger.error(message)
       end
 
       def log_memory_within_limit(current_memory, memory_limit)
         message = "Memory level OK, registered #{current_memory} bytes, which is less than #{memory_limit} limit."
-        world.dynflow_logger.debug(message)
+        world.logger.debug(message)
       end
 
       private

data/lib/dynflow/testing/assertions.rb

@@ -4,7 +4,7 @@ module Dynflow
       # assert that +assert_actioned_plan+ was planned by +action+ with arguments +plan_input+
       # alternatively plan-input can be asserted with +block+
       def assert_action_planned_with(action, planned_action_class, *plan_input, &block)
-        found_classes = assert_action_planed(action, planned_action_class)
+        found_classes = assert_action_planned(action, planned_action_class)
         found         = found_classes.select do |a|
           if plan_input.empty?
             block.call a.plan_input

data/lib/dynflow/version.rb

@@ -1,3 +1,3 @@
 module Dynflow
-  VERSION = '1.1.2'.freeze
+  VERSION = '1.1.3'.freeze
 end

data/lib/dynflow/world/invalidation.rb

@@ -82,13 +82,13 @@ module Dynflow
             logger.error "unexpected error when invalidating execution plan #{execution_lock.execution_plan_id}, skipping"
           end
           coordinator.release(execution_lock)
-          coordinator.release_by_owner(execution_lock.execution_plan_id)
+          coordinator.release_by_owner(execution_lock.id)
           return
         end
         unless plan.valid?
           logger.error "invalid plan #{plan.id}, skipping"
           coordinator.release(execution_lock)
-          coordinator.release_by_owner(execution_lock.execution_plan_id)
+          coordinator.release_by_owner(execution_lock.id)
           return
         end
         yield plan

data/test/abnormal_states_recovery_test.rb

@@ -122,6 +122,20 @@ module Dynflow
                               "unlock world-invalidation:#{executor_world.id}"]
             client_world.coordinator.adapter.lock_log.must_equal(expected_locks)
           end
+
+          it 'releases singleton locks belonging to missing execution plan' do
+            execution_plan_id = 'missing'
+            action_class = 'ActionClass'
+            locks = [Coordinator::ExecutionLock.new(executor_world, "missing", nil, nil),
+                     Coordinator::SingletonActionLock.new(action_class, execution_plan_id)]
+            locks.each { |lock| executor_world.coordinator.acquire lock }
+            client_world.invalidate(executor_world.registered_world)
+            expected_locks = ["lock world-invalidation:#{executor_world.id}",
+                              "unlock execution-plan:#{execution_plan_id}",
+                              "unlock singleton-action:#{action_class}",
+                              "unlock world-invalidation:#{executor_world.id}"]
+            client_world.coordinator.adapter.lock_log.must_equal(expected_locks)
+          end
         end
       end
 
@@ -291,6 +305,37 @@ module Dynflow
             invalid_locks.wont_include(valid_lock)
           end
         end
+
+        describe 'with singleton action locks' do
+          def plan_in_state(state)
+            plan = executor_world.persistence.load_execution_plan(trigger_waiting_action.id)
+            step = plan.steps.values.last
+            wait_for do
+              executor_world.persistence.load_step(step.execution_plan_id, step.id, executor_world).state == :suspended
+            end
+            plan.state = state if plan.state != state
+            plan.save
+            plan
+          end
+
+          let(:valid_plan) { plan_in_state :running }
+          let(:invalid_plan) { plan_in_state :stopped }
+          let(:valid_lock)    { Coordinator::SingletonActionLock.new('MyClass1', valid_plan.id) }
+          let(:invalid_lock)  { Coordinator::SingletonActionLock.new('MyClass2', 'plan-id') }
+          let(:invalid_lock2) { Coordinator::SingletonActionLock.new('MyClass3', invalid_plan.id) }
+
+          it 'unlocks orphaned singleton action locks' do
+            executor_world
+            client_world.coordinator.acquire(valid_lock)
+            client_world.coordinator.acquire(invalid_lock)
+            client_world.coordinator.acquire(invalid_lock2)
+            invalid_locks = client_world.coordinator.clean_orphaned_locks
+            # It must invalidate locks which are missing or in paused/stopped
+            invalid_locks.must_include(invalid_lock)
+            invalid_locks.must_include(invalid_lock2)
+            invalid_locks.wont_include(valid_lock)
+          end
+        end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynflow
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.3
 platform: ruby
 authors:
 - Ivan Necas
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-05 00:00:00.000000000 Z
+date: 2018-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -59,14 +59,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby-edge
   requirement: !ruby/object:Gem::Requirement