dynflow 1.1.6 → 1.2.0.pre1

data/lib/dynflow/utils/priority_queue.rb

@@ -0,0 +1,64 @@
+module Dynflow
+  module Utils
+    # Heavily inspired by rubyworks/pqueue
+    class PriorityQueue
+      def initialize(&block) # :yields: a, b
+        @backing_store = []
+        @comparator = block || :<=>.to_proc
+      end
+
+      def size
+        @backing_store.size
+      end
+
+      def top
+        @backing_store.last
+      end
+
+      def push(element)
+        @backing_store << element
+        reposition_element(@backing_store.size - 1)
+      end
+
+      def pop
+        @backing_store.pop
+      end
+
+      def to_a
+        @backing_store
+      end
+
+      private
+
+      # The element at index k will be repositioned to its proper place.
+      def reposition_element(index)
+        return if size <= 1
+
+        element = @backing_store.delete_at(index)
+        index = binary_index(@backing_store, element)
+
+        @backing_store.insert(index, element)
+      end
+
+      # Find index where a new element should be inserted using binary search
+      def binary_index(array, target)
+        upper = array.size - 1
+        lower = 0
+
+        while upper >= lower
+          center = lower + (upper - lower) / 2
+
+          case @comparator.call(target, array[center])
+          when 0
+            return center
+          when 1
+            lower = center + 1
+          when -1
+            upper = center - 1
+          end
+        end
+        lower
+      end
+    end
+  end
+end

data/lib/dynflow/version.rb

@@ -1,3 +1,3 @@
 module Dynflow
-  VERSION = '1.1.6'.freeze
+  VERSION = '1.2.0.pre1'.freeze
 end

data/lib/dynflow/world.rb

@@ -21,8 +21,8 @@ module Dynflow
       Dynflow::Telemetry.register_metrics!
 
       @id                     = SecureRandom.uuid
-      @clock                  = spawn_and_wait(Clock, 'clock')
       @logger_adapter         = @config.logger_adapter
+      @clock                  = spawn_and_wait(Clock, 'clock', logger)
       @config.validate
       @transaction_adapter    = @config.transaction_adapter
       @persistence            = Persistence.new(self, @config.persistence_adapter,
@@ -41,7 +41,7 @@ module Dynflow
       @auto_validity_check    = @config.auto_validity_check
       @validity_check_timeout = @config.validity_check_timeout
       @throttle_limiter       = @config.throttle_limiter
-      @terminated             = Concurrent.event
+      @terminated             = Concurrent::Promises.resolvable_event
       @termination_timeout    = @config.termination_timeout
       calculate_subscription_index
 
@@ -132,7 +132,7 @@ module Dynflow
       PlaningFailed   = type { fields! execution_plan_id: String, error: Exception }
       # Returned by #trigger when planning is successful, #future will resolve after
       # ExecutionPlan is executed.
-      Triggered       = type { fields! execution_plan_id: String, future: Concurrent::Edge::Future }
+      Triggered       = type { fields! execution_plan_id: String, future: Concurrent::Promises::ResolvableFuture }
 
       Scheduled       = type { fields! execution_plan_id: String }
 
@@ -176,7 +176,7 @@ module Dynflow
       planned = execution_plan.state == :planned
 
       if planned
-        done = execute(execution_plan.id, Concurrent.future)
+        done = execute(execution_plan.id, Concurrent::Promises.resolvable_future)
         Triggered[execution_plan.id, done]
       else
         PlaningFailed[execution_plan.id, execution_plan.errors.first.exception]
@@ -208,41 +208,41 @@ module Dynflow
       end
     end
 
-    # @return [Concurrent::Edge::Future] containing execution_plan when finished
+    # @return [Concurrent::Promises::ResolvableFuture] containing execution_plan when finished
     # raises when ExecutionPlan is not accepted for execution
-    def execute(execution_plan_id, done = Concurrent.future)
+    def execute(execution_plan_id, done = Concurrent::Promises.resolvable_future)
       publish_request(Dispatcher::Execution[execution_plan_id], done, true)
     end
 
-    def event(execution_plan_id, step_id, event, done = Concurrent.future)
+    def event(execution_plan_id, step_id, event, done = Concurrent::Promises.resolvable_future)
       publish_request(Dispatcher::Event[execution_plan_id, step_id, event], done, false)
     end
 
-    def ping(world_id, timeout, done = Concurrent.future)
+    def ping(world_id, timeout, done = Concurrent::Promises.resolvable_future)
       publish_request(Dispatcher::Ping[world_id, true], done, false, timeout)
     end
 
-    def ping_without_cache(world_id, timeout, done = Concurrent.future)
+    def ping_without_cache(world_id, timeout, done = Concurrent::Promises.resolvable_future)
       publish_request(Dispatcher::Ping[world_id, false], done, false, timeout)
     end
 
-    def get_execution_status(world_id, execution_plan_id, timeout, done = Concurrent.future)
+    def get_execution_status(world_id, execution_plan_id, timeout, done = Concurrent::Promises.resolvable_future)
       publish_request(Dispatcher::Status[world_id, execution_plan_id], done, false, timeout)
     end
 
     def publish_request(request, done, wait_for_accepted, timeout = nil)
-      accepted = Concurrent.future
+      accepted = Concurrent::Promises.resolvable_future
       accepted.rescue do |reason|
-        done.fail reason if reason
+        done.reject reason if reason
       end
       client_dispatcher.ask([:publish_request, done, request, timeout], accepted)
       accepted.wait if wait_for_accepted
       done
     rescue => e
-      accepted.fail e
+      accepted.reject e
     end
 
-    def terminate(future = Concurrent.future)
+    def terminate(future = Concurrent::Promises.resolvable_future)
       start_termination.tangle(future)
       future
     end
@@ -285,7 +285,7 @@ module Dynflow
     def start_termination
       @termination_barrier.synchronize do
         return @terminating if @terminating
-        termination_future ||= Concurrent.future do
+        termination_future ||= Concurrent::Promises.future do
           begin
             run_before_termination_hooks
 
@@ -304,13 +304,13 @@ module Dynflow
               executor.terminate.wait(termination_timeout)
 
               logger.info "start terminating executor dispatcher..."
-              executor_dispatcher_terminated = Concurrent.future
+              executor_dispatcher_terminated = Concurrent::Promises.resolvable_future
               executor_dispatcher.ask([:start_termination, executor_dispatcher_terminated])
               executor_dispatcher_terminated.wait(termination_timeout)
             end
 
             logger.info "start terminating client dispatcher..."
-            client_dispatcher_terminated = Concurrent.future
+            client_dispatcher_terminated = Concurrent::Promises.resolvable_future
             client_dispatcher.ask([:start_termination, client_dispatcher_terminated])
             client_dispatcher_terminated.wait(termination_timeout)
 
@@ -323,15 +323,15 @@ module Dynflow
             end
 
             coordinator.delete_world(registered_world)
-            @terminated.complete
+            @terminated.resolve
             true
           rescue => e
             logger.fatal(e)
           end
         end
-        @terminating = Concurrent.future do
+        @terminating = Concurrent::Promises.future do
           termination_future.wait(termination_timeout)
-        end.on_completion do
+        end.on_resolution do
           @terminated.complete
           Thread.new { Kernel.exit } if @exit_on_terminate.true?
         end
@@ -350,7 +350,7 @@ module Dynflow
 
     def run_before_termination_hooks
       until @before_termination_hooks.empty?
-        hook_run = Concurrent.future do
+        hook_run = Concurrent::Promises.future do
           begin
             @before_termination_hooks.pop.call
           rescue => e
@@ -362,7 +362,7 @@ module Dynflow
     end
 
     def spawn_and_wait(klass, name, *args)
-      initialized = Concurrent.future
+      initialized = Concurrent::Promises.resolvable_future
       actor = klass.spawn(name: name, args: args, initialized: initialized)
       initialized.wait
       return actor

data/lib/dynflow/world/invalidation.rb

@@ -118,7 +118,7 @@ module Dynflow
 
         results = {}
         world_checks.each do |world, check|
-          if check.success?
+          if check.fulfilled?
             result = :valid
           else
             if auto_invalidate

data/test/batch_sub_tasks_test.rb

@@ -68,7 +68,7 @@ module Dynflow
         FailureSimulator.wont_fail!
         plan = world.plan(ParentAction, 20)
         future = world.execute plan.id
-        wait_for { future.completed? }
+        wait_for { future.resolved? }
         plan = world.persistence.load_execution_plan(plan.id)
         action = plan.entry_action
 
@@ -79,7 +79,7 @@ module Dynflow
         FailureSimulator.should_fail!
         plan = world.plan(ParentAction, 20)
         future = world.execute plan.id
-        wait_for { future.completed? }
+        wait_for { future.resolved? }
         plan = world.persistence.load_execution_plan(plan.id)
         action = plan.entry_action
         action.output[:batch_count].must_equal 1
@@ -87,7 +87,7 @@ module Dynflow
 
         FailureSimulator.wont_fail!
         future = world.execute plan.id
-        wait_for { future.completed? }
+        wait_for { future.resolved? }
         action = future.value.entry_action
         future.value.state.must_equal :stopped
         action.output[:batch_count].must_equal (action.total_count / action.batch_size) + 1
@@ -98,7 +98,7 @@ module Dynflow
       it 'is controlled only by total_count and output[:planned_count]' do
         plan = world.plan(ParentAction, 10)
         future = world.execute plan.id
-        wait_for { future.completed? }
+        wait_for { future.resolved? }
         plan = world.persistence.load_execution_plan(plan.id)
         action = plan.entry_action
         action.send(:can_spawn_next_batch?).must_equal false

data/test/concurrency_control_test.rb

@@ -124,7 +124,7 @@ module Dynflow
         total = 10
         plan = world.plan(ParentAction, 10)
         future = world.execute plan.id
-        wait_for { future.completed? }
+        wait_for { future.resolved? }
         plan.sub_plans.all? { |sub| successful? sub }
         world.throttle_limiter.core.ask!(:running).must_equal [0]
       end
@@ -134,7 +134,7 @@ module Dynflow
         level = 4
         plan = world.plan(ParentAction, total, level)
         future = world.execute plan.id
-        wait_for { future.completed? }
+        wait_for { future.resolved? }
         world.throttle_limiter.core.ask!(:running).max.must_be :<=, level
       end
 
@@ -145,7 +145,7 @@ module Dynflow
           triggered = world.execute(plan.id)
           wait_for { plan.sub_plans_count == total }
           world.event(plan.id, plan.steps.values.last.id, ::Dynflow::Action::Cancellable::Cancel)
-          wait_for { triggered.completed? }
+          wait_for { triggered.resolved? }
           plan = world.persistence.load_execution_plan(plan.id)
           plan.entry_action.output[:failed_count].must_equal total
           world.throttle_limiter.core.ask!(:running).max.must_be :<=, 0
@@ -198,7 +198,7 @@ module Dynflow
           world.throttle_limiter.observe(plan.id).dup.each do |triggered|
             triggered.future.tap do |future|
               klok.progress
-              wait_for { future.completed? }
+              wait_for { future.resolved? }
             end
             finished += 1
             check_step(plan, total, finished)
@@ -217,7 +217,7 @@ module Dynflow
         time_span = 10
         plan = world.plan(ParentAction, total, level, time_span)
         future = world.execute(plan.id)
-        wait_for { future.completed? }
+        wait_for { future.resolved? }
         plan.sub_plans.all? { |sub| sub.result == :error }.must_equal true
       end
 
@@ -234,7 +234,7 @@ module Dynflow
           running.count.must_equal level
           world.throttle_limiter.observe(plan.id).length.must_equal (total - 1)
           4.times { klok.progress }
-          wait_for { future.completed? }
+          wait_for { future.resolved? }
           finished, stopped = plan.sub_plans.partition { |sub| successful? sub }
           finished.count.must_equal level
           stopped.count.must_equal (total - level)

data/test/daemon_test.rb

@@ -18,7 +18,7 @@ class DaemonTest < ActiveSupport::TestCase
     @dummy_world.stubs(:id => '123')
     @dummy_world.stubs(:auto_execute)
     @dummy_world.stubs(:perform_validity_checks => 0)
-    @event = Concurrent.event
+    @event = Concurrent::Promises.resolvable_event
     @dummy_world.stubs(:terminated).returns(@event)
     @world_class.stubs(:new).returns(@dummy_world)
     @dynflow = ::Dynflow::Rails.new(
@@ -38,7 +38,7 @@ class DaemonTest < ActiveSupport::TestCase
   end
 
   teardown do
-    @event.complete
+    @event.resolve
     @event.wait
   end
 

data/test/dispatcher_test.rb

@@ -40,7 +40,7 @@ module Dynflow
               step   = plan.steps.values.first
               future = client_world.event(plan.id, step.id, 'finish')
               future.wait
-              assert future.failed?
+              assert future.rejected?
             end
 
             it 'succeeds when executor acts as client' do
@@ -73,27 +73,27 @@ module Dynflow
           it 'succeeds when the world is available' do
             ping_response = client_world.ping(executor_world.id, 0.5)
             ping_response.wait
-            assert ping_response.success?
+            assert ping_response.fulfilled?
           end
 
           it 'succeeds when the world is available without cache' do
             ping_response = client_world.ping_without_cache(executor_world.id, 0.5)
             ping_response.wait
-            assert ping_response.success?
+            assert ping_response.fulfilled?
           end
 
           it 'time-outs when the world is not responding' do
             executor_world.terminate.wait
             ping_response = client_world.ping(executor_world.id, 0.5)
             ping_response.wait
-            assert ping_response.failed?
+            assert ping_response.rejected?
           end
 
           it 'time-outs when the world is not responding without cache' do
             executor_world.terminate.wait
             ping_response = client_world.ping_without_cache(executor_world.id, 0.5)
             ping_response.wait
-            assert ping_response.failed?
+            assert ping_response.rejected?
           end
 
           it 'caches the pings and pongs' do
@@ -121,7 +121,7 @@ module Dynflow
           executor_world_2.terminate.wait
           result = client_world.trigger(Support::DummyExample::Dummy)
           result.finished.wait
-          assert result.finished.failed?
+          assert result.finished.rejected?
           assert_match(/No executor available/, result.finished.reason.message)
         end
       end

data/test/execution_plan_test.rb

@@ -141,6 +141,17 @@ module Dynflow
 
       end
 
+      describe 'sub plans' do
+        let(:execution_plan) do
+          world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
+        end
+
+        it 'does not have itself as a sub plan' do
+          assert execution_plan.actions.count >= 2
+          execution_plan.sub_plans.must_be :empty?
+        end
+      end
+
       describe 'plan steps' do
         let :execution_plan do
           world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)

data/test/executor_test.rb

@@ -671,7 +671,7 @@ module Dynflow
         result = world.trigger(Support::DummyExample::Slow, 0.02)
         result.must_be :planned?
         result.finished.wait
-        assert result.finished.failed?
+        assert result.finished.rejected?
         result.finished.reason.must_be_kind_of Concurrent::Actor::ActorTerminated
       end
 

data/test/support/dummy_example.rb

@@ -143,7 +143,7 @@ module Support
                      world.clock.ping suspended_action, input[:timeout], "timeout"
                    end
 
-                   sub_plan.finished.on_success! { suspended_action << 'finish' }
+                   sub_plan.finished.on_fulfillment! { suspended_action << 'finish' }
                  end
                end),
               (on 'finish' do

data/test/test_helper.rb

@@ -25,8 +25,8 @@ Concurrent.disable_at_exit_handlers!
 class TestPause
 
   def self.setup
-    @pause = Concurrent.future
-    @ready = Concurrent.future
+    @pause = Concurrent::Promises.resolvable_future
+    @ready = Concurrent::Promises.resolvable_future
   end
 
   def self.teardown
@@ -38,10 +38,10 @@ class TestPause
   def self.pause
     if !@pause
       raise 'the TestPause class was not setup'
-    elsif @ready.completed?
+    elsif @ready.resolved?
       raise 'you can pause only once'
     else
-      @ready.success(true)
+      @ready.fulfill(true)
       @pause.wait
     end
   end
@@ -51,7 +51,7 @@ class TestPause
     if @pause
       @ready.wait # wait till we are paused
       yield
-      @pause.success(true) # resume the run
+      @pause.fulfill(true) # resume the run
     else
       raise 'the TestPause class was not setup'
     end
@@ -249,17 +249,17 @@ events_test = -> do
   event_creations  = {}
   non_ready_events = {}
 
-  Concurrent::Edge::Event.singleton_class.send :define_method, :new do |*args, &block|
+  Concurrent::Promises::Event.singleton_class.send :define_method, :new do |*args, &block|
     super(*args, &block).tap do |event|
       event_creations[event.object_id] = caller(4)
     end
   end
 
-  [Concurrent::Edge::Event, Concurrent::Edge::Future].each do |future_class|
-    original_complete_method = future_class.instance_method :complete_with
-    future_class.send :define_method, :complete_with do |*args|
+  [Concurrent::Promises::Event, Concurrent::Promises::ResolvableFuture].each do |future_class|
+    original_resolved_method = future_class.instance_method :resolve_with
+    future_class.send :define_method, :resolve_with do |*args|
       begin
-        original_complete_method.bind(self).call(*args)
+        original_resolved_method.bind(self).call(*args)
       ensure
         event_creations.delete(self.object_id)
       end
@@ -269,9 +269,9 @@ events_test = -> do
   MiniTest.after_run do
     Concurrent::Actor.root.ask!(:terminate!)
 
-    non_ready_events = ObjectSpace.each_object(Concurrent::Edge::Event).map do |event|
+    non_ready_events = ObjectSpace.each_object(Concurrent::Promises::Event).map do |event|
       event.wait(1)
-      unless event.completed?
+      unless event.resolved?
         event.object_id
       end
     end.compact
@@ -294,9 +294,9 @@ events_test = -> do
 
   # time out all futures by default
   default_timeout = 8
-  wait_method     = Concurrent::Edge::Event.instance_method(:wait)
+  wait_method     = Concurrent::Promises::AbstractEventFuture.instance_method(:wait)
 
-  Concurrent::Edge::Event.class_eval do
+  Concurrent::Promises::AbstractEventFuture.class_eval do
     define_method :wait do |timeout = nil|
       wait_method.bind(self).call(timeout || default_timeout)
     end
@@ -308,7 +308,7 @@ events_test.call
 
 class ConcurrentRunTester
   def initialize
-    @enter_future, @exit_future = Concurrent.future, Concurrent.future
+    @enter_future, @exit_future = Concurrent::Promises.resolvable_future, Concurrent::Promises.resolvable_future
   end
 
   def while_executing(&block)
@@ -319,12 +319,12 @@ class ConcurrentRunTester
   end
 
   def pause
-    @enter_future.success(true)
+    @enter_future.fulfill(true)
     @exit_future.wait(1)
   end
 
   def finish
-    @exit_future.success(true)
+    @exit_future.fulfill(true)
     @thread.join
   end
 end