dynflow 1.1.6 → 1.2.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9117b88e2a562fc968ff4e9aa26ac35d2ac33fc0a519b81e4bc42d3f8b9139c1
-  data.tar.gz: d248a508d1e525745fedd29dbc1dce7b9b0ec1a4b1bb75ca43f12ee9f16189b6
+  metadata.gz: 6fcc2f12b17318ec09919aae5873ee7aa9e16ab3b6f96508b94c0cf8ae3d0a91
+  data.tar.gz: 9a71c09beb7ed1b0cf75ca858dfacc41ae4e33f5c2b82af142f1aac809b2b8f9
 SHA512:
-  metadata.gz: c17a37b38e654bc0db350c9c453e9badb34c3575c48c45e32760e093de79600d10768b66e4b6a70ba9975a1fa39a626d1b44d226a68676dd50a3ef5a2ac1f9a4
-  data.tar.gz: 24c700a6590beedff832767276ff48ad01d927620634a1ef0b36e2f5020733e518809ac114dbf1f281230e7a0bcdc4f88534c9ecb2bf39d0dc038539133c5631
+  metadata.gz: e48b378aacfd2a9cdd2c57a3759abe33ba22439615af459a0c779ddf448cfab5b7cf76de655d2450c2190e444fc2586578e86af465488bb0c622e7c94fd96cdb
+  data.tar.gz: 0d99ae6fb8f1d68d503610e49f69e1ce344129d0588e2ebe9a57bf3d540790d8f68229f0fa50b7aa1305d539f902c21dbf57ff96871ddaffadf37e56cbcf0924

data/Gemfile

@@ -3,7 +3,7 @@ source 'https://rubygems.org'
 gemspec
 
 group :concurrent_ruby_ext do
-  gem 'concurrent-ruby-ext', '= 1.0.3'
+  gem 'concurrent-ruby-ext', '~> 1.1.3'
 end
 
 group :pry do

data/dynflow.gemspec

@@ -21,8 +21,8 @@ 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.0'
-  s.add_dependency "concurrent-ruby-edge", '~> 0.2.0'
+  s.add_dependency "concurrent-ruby", '~> 1.1.3'
+  s.add_dependency "concurrent-ruby-edge", '~> 0.4.1'
   s.add_dependency "sequel", '>= 4.0.0'
 
   s.add_development_dependency "rake"

data/examples/clock_benchmark.rb

@@ -0,0 +1,35 @@
+require 'dynflow'
+require 'benchmark'
+
+class Receiver
+  def initialize(limit, future)
+    @limit = limit
+    @future = future
+    @counter = 0
+  end
+
+  def null
+    @counter += 1
+    @future.fulfill(true) if @counter >= @limit
+  end
+end
+
+def test_case(count)
+  future   = Concurrent::Promises.resolvable_future
+  clock    = Dynflow::Clock.spawn(:name => 'clock')
+  receiver = Receiver.new(count, future)
+
+  count.times do
+    clock.ping(receiver, 0, nil, :null)
+  end
+  future.wait
+end
+
+Benchmark.bm do |bm|
+  bm.report('   100') { test_case 100 }
+  bm.report('  1000') { test_case 1_000 }
+  bm.report('  5000') { test_case 5_000 }
+  bm.report(' 10000') { test_case 10_000 }
+  bm.report(' 50000') { test_case 50_000 }
+  bm.report('100000') { test_case 100_000 }
+end

data/examples/memory_limit_watcher.rb

@@ -32,7 +32,7 @@ if $0 == __FILE__
     config.exit_on_terminate = false
   end
 
-  world.terminated.on_completion do
+  world.terminated.on_resolution do
     puts '[world] The world has been terminated'
   end
 

data/lib/dynflow/action.rb

@@ -161,11 +161,11 @@ module Dynflow
     end
 
     def caller_action
-      plase! Present
+      phase! Present
       return nil if @caller_action_id
       return @caller_action if @caller_action
 
-      caller_execution_plan = if @caller_execution_plan_id == execution_plan.id
+      caller_execution_plan = if @caller_execution_plan_id.nil?
                                 execution_plan
                               else
                                 world.persistence.load_execution_plan(@caller_execution_plan_id)

data/lib/dynflow/action/suspended.rb

@@ -8,7 +8,7 @@ module Dynflow
       @step_id           = action.run_step_id
     end
 
-    def event(event, future = Concurrent.future)
+    def event(event, future = Concurrent::Promises.resolvable_future)
       @world.event execution_plan_id, step_id, event, future
     end
 

data/lib/dynflow/action/with_sub_plans.rb

@@ -171,7 +171,7 @@ module Dynflow
     def notify_on_finish(plans)
       suspend do |suspended_action|
         plans.each do |plan|
-          plan.finished.on_completion! do |success, value|
+          plan.finished.on_resolution! do |success, value|
             suspended_action << SubPlanFinished[plan.id, success && (value.result == :success)]
           end
         end

data/lib/dynflow/actor.rb

@@ -20,7 +20,7 @@ module Dynflow
         message, terminated_future = envelope
         if :start_termination == message
           context.start_termination(terminated_future)
-          envelope.future.success true if !envelope.future.nil?
+          envelope.future.fulfill true if !envelope.future.nil?
           Concurrent::Actor::Behaviour::MESSAGE_PROCESSED
         else
           pass envelope
@@ -35,7 +35,7 @@ module Dynflow
     end
 
     def finish_termination
-      @terminated.success(true)
+      @terminated.fulfill(true)
       reference.tell(:terminate!)
     end
 

data/lib/dynflow/actors/execution_plan_cleaner.rb

@@ -13,7 +13,7 @@ module Dynflow
       end
 
       def spawn
-        Concurrent.future.tap do |initialized|
+        Concurrent::Promises.resolvable_future.tap do |initialized|
           @core = core_class.spawn(:name => 'execution-plan-cleaner',
                                    :args => [@world, @options],
                                    :initialized => initialized)

data/lib/dynflow/clock.rb

@@ -1,6 +1,4 @@
 module Dynflow
-  require 'set'
-
   class Clock < Actor
 
     include Algebrick::Types
@@ -48,8 +46,9 @@ module Dynflow
                Pill = type { fields Float }
     end
 
-    def initialize
-      @timers        = SortedSet.new
+    def initialize(logger = nil)
+      @logger        = logger
+      @timers        = Utils::PriorityQueue.new { |a, b| b <=> a }
       @sleeping_pill = None
       @sleep_barrier = Mutex.new
       @sleeper       = Thread.new { sleeping }
@@ -72,7 +71,7 @@ module Dynflow
     end
 
     def add_timer(timer)
-      @timers.add timer
+      @timers.push timer
       if @timers.size == 1
         sleep_to timer
       else
@@ -84,13 +83,17 @@ module Dynflow
 
     def run_ready_timers
       while first_timer && first_timer.when <= Time.now
-        first_timer.apply
-        @timers.delete(first_timer)
+        begin
+          first_timer.apply
+        rescue => e
+          @logger && @logger.error("Failed to apply clock event #{first_timer}, exception: #{e}")
+        end
+        @timers.pop
       end
     end
 
     def first_timer
-      @timers.first
+      @timers.top
     end
 
     def wakeup

data/lib/dynflow/delayed_executors/abstract.rb

@@ -26,7 +26,7 @@ module Dynflow
       end
 
       def spawn
-        Concurrent.future.tap do |initialized|
+        Concurrent::Promises.resolvable_future.tap do |initialized|
           @core = core_class.spawn name: 'delayed-executor',
                                    args: [@world, @options],
                                    initialized: initialized

data/lib/dynflow/delayed_plan.rb

@@ -47,7 +47,7 @@ module Dynflow
       return true
     end
 
-    def execute(future = Concurrent.future)
+    def execute(future = Concurrent::Promises.resolvable_future)
       @world.execute(@execution_plan_uuid, future)
       ::Dynflow::World::Triggered[@execution_plan_uuid, future]
     end

data/lib/dynflow/director.rb

@@ -13,7 +13,7 @@ module Dynflow
       fields! execution_plan_id: String,
               step_id:           Integer,
               event:             Object,
-              result:            Concurrent::Edge::Future
+              result:            Concurrent::Promises::ResolvableFuture
     end
 
     UnprocessableEvent = Class.new(Dynflow::Error)
@@ -103,7 +103,7 @@ module Dynflow
         raise Dynflow::Error, "no manager for #{event.inspect}"
       end
     rescue Dynflow::Error => e
-      event.result.fail e.message
+      event.result.reject e.message
       raise e
     end
 
@@ -203,13 +203,13 @@ module Dynflow
       @execution_plan_managers[execution_plan_id] =
           ExecutionPlanManager.new(@world, execution_plan, finished)
     rescue Dynflow::Error => e
-      finished.fail e
+      finished.reject e
       nil
     end
 
     def set_future(manager)
       @rescued_steps.delete(manager.execution_plan.id)
-      manager.future.success manager.execution_plan
+      manager.future.fulfill manager.execution_plan
     end
   end
 end

data/lib/dynflow/director/execution_plan_manager.rb

@@ -9,7 +9,7 @@ module Dynflow
       def initialize(world, execution_plan, future)
         @world                 = Type! world, World
         @execution_plan        = Type! execution_plan, ExecutionPlan
-        @future                = Type! future, Concurrent::Edge::Future
+        @future                = Type! future, Concurrent::Promises::ResolvableFuture
         @running_steps_manager = RunningStepsManager.new(world)
 
         unless [:planned, :paused].include? execution_plan.state
@@ -20,7 +20,7 @@ module Dynflow
       end
 
       def start
-        raise "The future was already set" if @future.completed?
+        raise "The future was already set" if @future.resolved?
         start_run or start_finalize or finish
       end
 

data/lib/dynflow/director/running_steps_manager.rb

@@ -15,7 +15,7 @@ module Dynflow
         pending_work = @events.clear.values.flatten(1)
         pending_work.each do |w|
           if EventWorkItem === w
-            w.event.result.fail UnprocessableEvent.new("dropping due to termination")
+            w.event.result.reject UnprocessableEvent.new("dropping due to termination")
           end
         end
       end
@@ -32,7 +32,7 @@ module Dynflow
       def done(step)
         Type! step, ExecutionPlan::Steps::RunStep
         @events.shift(step.id).tap do |work|
-          work.event.result.success true if EventWorkItem === work
+          work.event.result.fulfill true if EventWorkItem === work
         end
 
         if step.state == :suspended
@@ -41,7 +41,7 @@ module Dynflow
           while (event = @events.shift(step.id))
             message = "step #{step.execution_plan_id}:#{step.id} dropping event #{event.event}"
             @world.logger.warn message
-            event.event.result.fail UnprocessableEvent.new(message).
+            event.event.result.reject UnprocessableEvent.new(message).
                 tap { |e| e.set_backtrace(caller) }
           end
           raise 'assert' unless @events.empty?(step.id)
@@ -64,7 +64,7 @@ module Dynflow
 
         step = @running_steps[event.step_id]
         unless step
-          event.result.fail UnprocessableEvent.new('step is not suspended, it cannot process events')
+          event.result.reject UnprocessableEvent.new('step is not suspended, it cannot process events')
           return next_work_items
         end
 

data/lib/dynflow/dispatcher/client_dispatcher.rb

@@ -4,24 +4,24 @@ module Dynflow
 
       TrackedRequest = Algebrick.type do
         fields! id: Integer, request: Request,
-                accepted: Concurrent::Edge::Future, finished: Concurrent::Edge::Future
+                accepted: Concurrent::Promises::ResolvableFuture, finished: Concurrent::Promises::ResolvableFuture
       end
 
       module TrackedRequest
         def accept!
-          accepted.success true unless accepted.completed?
+          accepted.fulfill true unless accepted.resolved?
           self
         end
 
         def fail!(error)
-          accepted.fail error unless accepted.completed?
-          finished.fail error
+          accepted.reject error unless accepted.resolved?
+          finished.reject error
           self
         end
 
         def success!(resolve_to)
-          accepted.success true unless accepted.completed?
-          finished.success(resolve_to)
+          accepted.fulfill true unless accepted.resolved?
+          finished.fulfill(resolve_to)
           self
         end
       end
@@ -198,7 +198,7 @@ module Dynflow
 
       def track_request(finished, request, timeout)
         id = @last_id += 1
-        tracked_request = TrackedRequest[id, request, Concurrent.future, finished]
+        tracked_request = TrackedRequest[id, request, Concurrent::Promises.resolvable_future, finished]
         @tracked_requests[id] = tracked_request
         @world.clock.ping(self, timeout, [:timeout, id]) if timeout
         yield tracked_request
@@ -208,13 +208,14 @@ module Dynflow
       end
 
       def reset_tracked_request(tracked_request)
-        if tracked_request.finished.completed?
+        if tracked_request.finished.resolved?
           raise Dynflow::Error.new('Can not reset resolved tracked request')
         end
-        unless tracked_request.accepted.completed?
+        unless tracked_request.accepted.resolved?
           tracked_request.accept! # otherwise nobody would set the accept future
         end
-        @tracked_requests[tracked_request.id] = TrackedRequest[tracked_request.id, tracked_request.request, Concurrent.future, tracked_request.finished]
+        future = Concurrent::Promises.resolvable_future
+        @tracked_requests[tracked_request.id] = TrackedRequest[tracked_request.id, tracked_request.request, future, tracked_request.finished]
       end
 
       def resolve_tracked_request(id, error = nil)
@@ -246,10 +247,10 @@ module Dynflow
         return yield unless request.use_cache
 
         if @ping_cache.fresh_record?(request.receiver_id)
-          future.success(true)
+          future.fulfill(true)
         else
           if @ping_cache.executor?(request.receiver_id)
-            future.fail
+            future.reject
           else
             yield
           end

data/lib/dynflow/dispatcher/executor_dispatcher.rb

@@ -29,7 +29,7 @@ module Dynflow
         @world.executor.execute(execution.execution_plan_id, future)
         respond(envelope, Accepted)
       rescue Dynflow::Error => e
-        future.fail(e) if future && !future.completed?
+        future.reject(e) if future && !future.resolved?
         respond(envelope, Failed[e.message])
       end
 
@@ -52,7 +52,7 @@ module Dynflow
         end
         @world.executor.event(event_request.execution_plan_id, event_request.step_id, event_request.event, future)
       rescue Dynflow::Error => e
-        future.fail(e) if future && !future.completed?
+        future.reject(e) if future && !future.resolved?
       end
 
       def start_termination(*args)
@@ -60,7 +60,7 @@ module Dynflow
         if @current_futures.empty?
           reference.tell(:finish_termination)
         else
-          Concurrent.zip(*@current_futures).then { reference.tell(:finish_termination) }
+          Concurrent::Promises.zip_futures(*@current_futures).then { reference.tell(:finish_termination) }
         end
       end
 
@@ -78,13 +78,13 @@ module Dynflow
 
       def on_finish
         raise "Dispatcher terminating: no new work can be started" if terminating?
-        future = Concurrent.future
+        future = Concurrent::Promises.resolvable_future
         callbacks_future = (yield future).rescue { |reason| @world.logger.error("Unexpected fail on future #{reason}") }
         # we track currently running futures to make sure to not
         # terminate until the execution is finished (including
         # cleaning of locks etc)
         @current_futures << callbacks_future
-        callbacks_future.on_completion! { reference.tell([:finish_execution, callbacks_future]) }
+        callbacks_future.on_resolution! { reference.tell([:finish_execution, callbacks_future]) }
         return future
       end
 

data/lib/dynflow/execution_plan.rb

@@ -305,7 +305,7 @@ module Dynflow
     # array with the future value of the cancel result)
     def cancel(force = false)
       if state == :scheduled
-        [Concurrent.future.tap { |f| f.success delay_record.cancel }]
+        [Concurrent::Promises.resolvable_future.tap { |f| f.fulfill delay_record.cancel }]
       else
         event = force ? ::Dynflow::Action::Cancellable::Abort : ::Dynflow::Action::Cancellable::Cancel
         steps_to_cancel.map do |step|

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

@@ -98,8 +98,10 @@ module Dynflow
                        finalize_step_id:  nil,
                        phase:             phase }
         if caller_action
-          attributes.update(caller_execution_plan_id: caller_action.execution_plan_id,
-                            caller_action_id:         caller_action.id)
+          if caller_action.execution_plan_id != execution_plan_id
+            attributes.update(caller_execution_plan_id: caller_action.execution_plan_id)
+          end
+          attributes.update(caller_action_id: caller_action.id)
         end
         @action = action_class.new(attributes, world)
         persistence.save_action(execution_plan_id, @action)

data/lib/dynflow/executors/abstract.rb

@@ -10,20 +10,20 @@ module Dynflow
       end
 
       # @param execution_plan_id [String] id of execution plan
-      # @param finished [Concurrent::Edge::Future]
+      # @param finished [Concurrent::Promises::ResolvableFuture]
       # @param wait_for_acceptance [TrueClass|FalseClass] should the executor confirm receiving
       # the event, disable if calling executor from within executor
-      # @return [Concurrent::Edge::Future]
+      # @return [Concurrent::Promises::ResolvableFuture]
       # @raise when execution_plan_id is not accepted
-      def execute(execution_plan_id, finished = Concurrent.future, wait_for_acceptance = true)
+      def execute(execution_plan_id, finished = Concurrent::Promises.resolvable_future, wait_for_acceptance = true)
         raise NotImplementedError
       end
 
-      def event(execution_plan_id, step_id, event, future = Concurrent.future)
+      def event(execution_plan_id, step_id, event, future = Concurrent::Promises.resolvable_future)
         raise NotImplementedError
       end
 
-      def terminate(future = Concurrent.future)
+      def terminate(future = Concurrent::Promises.resolvable_future)
         raise NotImplementedError
       end
 
@@ -31,7 +31,7 @@ module Dynflow
         raise NotImplementedError
       end
 
-      # @return [Concurrent::Edge::Future]
+      # @return [Concurrent::Promises::ResolvableFuture]
       def initialized
         raise NotImplementedError
       end