dynflow 1.1.6 → 1.2.0.pre1

data/lib/dynflow/executors/parallel.rb

@@ -9,28 +9,28 @@ module Dynflow
         super(world)
         @core = Core.spawn name:        'parallel-executor-core',
                            args:        [world, heartbeat_interval, queues_options],
-                           initialized: @core_initialized = Concurrent.future
+                           initialized: @core_initialized = Concurrent::Promises.resolvable_future
       end
 
-      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)
         accepted = @core.ask([:handle_execution, execution_plan_id, finished])
         accepted.value! if wait_for_acceptance
         finished
       rescue Concurrent::Actor::ActorTerminated => error
         dynflow_error = Dynflow::Error.new('executor terminated')
-        finished.fail dynflow_error unless finished.completed?
+        finished.reject dynflow_error unless finished.resolved?
         raise dynflow_error
       rescue => e
-        finished.fail e unless finished.completed?
+        finished.reject e unless finished.resolved?
         raise e
       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)
         @core.ask([:handle_event, Director::Event[execution_plan_id, step_id, event, future]])
         future
       end
 
-      def terminate(future = Concurrent.future)
+      def terminate(future = Concurrent::Promises.resolvable_future)
         @core.tell([:start_termination, future])
         future
       end

data/lib/dynflow/executors/parallel/core.rb

@@ -62,7 +62,7 @@ module Dynflow
         def start_termination(*args)
           super
           logger.info 'shutting down Core ...'
-          @pools.values.each { |pool| pool.tell([:start_termination, Concurrent.future]) }
+          @pools.values.each { |pool| pool.tell([:start_termination, Concurrent::Promises.resolvable_future]) }
         end
 
         def finish_termination(pool_name)

data/lib/dynflow/rails/daemon.rb

@@ -36,7 +36,7 @@ module Dynflow
         if options[:memory_limit] && options[:memory_limit].to_i > 0
           ::Rails.application.dynflow.config.on_init do |world|
             memory_watcher = initialize_memory_watcher(world, options[:memory_limit], options)
-            world.terminated.on_completion do
+            world.terminated.on_resolution do
               STDOUT.puts("World has been terminated")
               memory_watcher = nil # the object can be disposed
             end

data/lib/dynflow/testing/dummy_executor.rb

@@ -8,7 +8,7 @@ module Dynflow
         @events_to_process = []
       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)
         @events_to_process << [execution_plan_id, step_id, event, future]
       end
 
@@ -17,7 +17,7 @@ module Dynflow
         events = @events_to_process.dup
         clear
         events.each do |execution_plan_id, step_id, event, future|
-          future.success true
+          future.fulfill true
           if event && world.action.state != :suspended
             return false
           end

data/lib/dynflow/testing/dummy_world.rb

@@ -30,7 +30,7 @@ module Dynflow
         []
       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)
         executor.event execution_plan_id, step_id, event, future
       end
 

data/lib/dynflow/testing/in_thread_executor.rb

@@ -7,7 +7,7 @@ module Dynflow
         @work_items = Queue.new
       end
 
-      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)
         feed_queue(@director.start_execution(execution_plan_id, finished))
         process_work_items
         finished
@@ -25,7 +25,7 @@ module Dynflow
         @director.work_finished(work_item)
       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)
         event = (Director::Event[execution_plan_id, step_id, event, future])
         @director.handle_event(event).each do |work_item|
           @work_items << work_item
@@ -41,11 +41,11 @@ module Dynflow
         work_items.each { |work_item| @work_items.push(work_item) }
       end
 
-      def terminate(future = Concurrent.future)
+      def terminate(future = Concurrent::Promises.resolvable_future)
         @director.terminate
-        future.success true
+        future.fulfill true
       rescue => e
-        future.fail e
+        future.reject e
       end
     end
   end

data/lib/dynflow/testing/in_thread_world.rb

@@ -43,21 +43,21 @@ module Dynflow
         @executor = InThreadExecutor.new(self)
       end
 
-      def execute(execution_plan_id, done = Concurrent.future)
+      def execute(execution_plan_id, done = Concurrent::Promises.resolvable_future)
         @executor.execute(execution_plan_id, done)
       end
 
-      def terminate(future = Concurrent.future)
+      def terminate(future = Concurrent::Promises.resolvable_future)
         run_before_termination_hooks
         @executor.terminate
         coordinator.delete_world(registered_world)
-        future.success true
-        @terminated.complete
+        future.fulfill true
+        @terminated.resolve
       rescue => e
-        future.fail e
+        future.reject e
       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)
         @executor.event(execution_plan_id, step_id, event, done)
       end
     end

data/lib/dynflow/throttle_limiter.rb

@@ -39,7 +39,7 @@ module Dynflow
     private
 
     def spawn
-      Concurrent.future.tap do |initialized|
+      Concurrent::Promises.resolvable_future.tap do |initialized|
         @core = core_class.spawn(:name => 'throttle-limiter',
                                  :args => [@world],
                                  :initialized => initialized)
@@ -59,14 +59,14 @@ module Dynflow
 
       def handle_plans(parent_id, planned_ids, failed_ids)
         failed = failed_ids.map do |plan_id|
-          ::Dynflow::World::Triggered[plan_id, Concurrent.future].tap do |triggered|
+          ::Dynflow::World::Triggered[plan_id, Concurrent::Promises.resolvable_future].tap do |triggered|
             execute_triggered(triggered)
           end
         end
 
         planned_ids.map do |child_id|
-          ::Dynflow::World::Triggered[child_id, Concurrent.future].tap do |triggered|
-            triggered.future.on_completion! { self << [:release, parent_id] }
+          ::Dynflow::World::Triggered[child_id, Concurrent::Promises.resolvable_future].tap do |triggered|
+            triggered.future.on_resolution! { self << [:release, parent_id] }
             execute_triggered(triggered) if @semaphores[parent_id].wait(triggered)
           end
         end + failed
@@ -99,7 +99,7 @@ module Dynflow
           reason ||= 'The task was cancelled.'
           @semaphores[parent_id].waiting.each do |triggered|
             cancel_plan_id(triggered.execution_plan_id, reason)
-            triggered.future.fail(reason)
+            triggered.future.reject(reason)
           end
           finish(parent_id)
         end

data/lib/dynflow/utils.rb

@@ -1,6 +1,9 @@
 module Dynflow
   module Utils
 
+    require 'dynflow/utils/indifferent_hash'
+    require 'dynflow/utils/priority_queue'
+
     def self.validate_keys!(hash, *valid_keys)
       valid_keys.flatten!
       unexpected_options = hash.keys - valid_keys - valid_keys.map(&:to_s)
@@ -71,145 +74,5 @@ module Dynflow
         end
       end
     end
-
-    # Heaviliy inpired by ActiveSupport::HashWithIndifferentAccess,
-    # reasons we don't want to use the original implementation:
-    #   1. we don't want any core_ext extensions
-    #   2. some users are not happy about seeing the ActiveSupport as
-    #   our depednency
-    class IndifferentHash < Hash
-      def initialize(constructor = {})
-        if constructor.respond_to?(:to_hash)
-          super()
-          update(constructor)
-        else
-          super(constructor)
-        end
-      end
-
-      def default(key = nil)
-        if key.is_a?(Symbol) && include?(key = key.to_s)
-          self[key]
-        else
-          super
-        end
-      end
-
-      def self.[](*args)
-        new.merge!(Hash[*args])
-      end
-
-      alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
-      alias_method :regular_update, :update unless method_defined?(:regular_update)
-
-      def []=(key, value)
-        regular_writer(convert_key(key), convert_value(value, for: :assignment))
-      end
-
-      alias_method :store, :[]=
-
-      def update(other_hash)
-        if other_hash.is_a? IndifferentHash
-          super(other_hash)
-        else
-          other_hash.to_hash.each_pair do |key, value|
-            if block_given? && key?(key)
-              value = yield(convert_key(key), self[key], value)
-            end
-            regular_writer(convert_key(key), convert_value(value))
-          end
-          self
-        end
-      end
-
-      alias_method :merge!, :update
-
-      def key?(key)
-        super(convert_key(key))
-      end
-
-      alias_method :include?, :key?
-      alias_method :has_key?, :key?
-      alias_method :member?, :key?
-
-      def fetch(key, *extras)
-        super(convert_key(key), *extras)
-      end
-
-      def values_at(*indices)
-        indices.collect { |key| self[convert_key(key)] }
-      end
-
-      def dup
-        self.class.new(self).tap do |new_hash|
-          new_hash.default = default
-        end
-      end
-
-      def merge(hash, &block)
-        self.dup.update(hash, &block)
-      end
-
-      def reverse_merge(other_hash)
-        super(self.class.new_from_hash_copying_default(other_hash))
-      end
-
-      def reverse_merge!(other_hash)
-        replace(reverse_merge( other_hash ))
-      end
-
-      def replace(other_hash)
-        super(self.class.new_from_hash_copying_default(other_hash))
-      end
-
-      def delete(key)
-        super(convert_key(key))
-      end
-
-      def stringify_keys!; self end
-      def deep_stringify_keys!; self end
-      def stringify_keys; dup end
-      def deep_stringify_keys; dup end
-      def to_options!; self end
-
-      def select(*args, &block)
-        dup.tap { |hash| hash.select!(*args, &block) }
-      end
-
-      def reject(*args, &block)
-        dup.tap { |hash| hash.reject!(*args, &block) }
-      end
-
-      # Convert to a regular hash with string keys.
-      def to_hash
-        _new_hash = Hash.new(default)
-        each do |key, value|
-          _new_hash[key] = convert_value(value, for: :to_hash)
-        end
-        _new_hash
-      end
-
-      protected
-      def convert_key(key)
-        key.kind_of?(Symbol) ? key.to_s : key
-      end
-
-      def convert_value(value, options = {})
-        if value.is_a? Hash
-          if options[:for] == :to_hash
-            value.to_hash
-          else
-            Utils.indifferent_hash(value)
-          end
-        elsif value.is_a?(Array)
-          unless options[:for] == :assignment
-            value = value.dup
-          end
-          value.map! { |e| convert_value(e, options) }
-        else
-          value
-        end
-      end
-    end
   end
 end

data/lib/dynflow/utils/indifferent_hash.rb

@@ -0,0 +1,143 @@
+module Dynflow
+  module Utils
+    # Heavily inpired by ActiveSupport::HashWithIndifferentAccess,
+    # reasons we don't want to use the original implementation:
+    #   1. we don't want any core_ext extensions
+    #   2. some users are not happy about seeing the ActiveSupport as
+    #   our depednency
+    class IndifferentHash < Hash
+      def initialize(constructor = {})
+        if constructor.respond_to?(:to_hash)
+          super()
+          update(constructor)
+        else
+          super(constructor)
+        end
+      end
+
+      def default(key = nil)
+        if key.is_a?(Symbol) && include?(key = key.to_s)
+          self[key]
+        else
+          super
+        end
+      end
+
+      def self.[](*args)
+        new.merge!(Hash[*args])
+      end
+
+      alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+      alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+      def []=(key, value)
+        regular_writer(convert_key(key), convert_value(value, for: :assignment))
+      end
+
+      alias_method :store, :[]=
+
+      def update(other_hash)
+        if other_hash.is_a? IndifferentHash
+          super(other_hash)
+        else
+          other_hash.to_hash.each_pair do |key, value|
+            if block_given? && key?(key)
+              value = yield(convert_key(key), self[key], value)
+            end
+            regular_writer(convert_key(key), convert_value(value))
+          end
+          self
+        end
+      end
+
+      alias_method :merge!, :update
+
+      def key?(key)
+        super(convert_key(key))
+      end
+
+      alias_method :include?, :key?
+      alias_method :has_key?, :key?
+      alias_method :member?, :key?
+
+      def fetch(key, *extras)
+        super(convert_key(key), *extras)
+      end
+
+      def values_at(*indices)
+        indices.collect { |key| self[convert_key(key)] }
+      end
+
+      def dup
+        self.class.new(self).tap do |new_hash|
+          new_hash.default = default
+        end
+      end
+
+      def merge(hash, &block)
+        self.dup.update(hash, &block)
+      end
+
+      def reverse_merge(other_hash)
+        super(self.class.new_from_hash_copying_default(other_hash))
+      end
+
+      def reverse_merge!(other_hash)
+        replace(reverse_merge( other_hash ))
+      end
+
+      def replace(other_hash)
+        super(self.class.new_from_hash_copying_default(other_hash))
+      end
+
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      def stringify_keys!; self end
+      def deep_stringify_keys!; self end
+      def stringify_keys; dup end
+      def deep_stringify_keys; dup end
+      def to_options!; self end
+
+      def select(*args, &block)
+        dup.tap { |hash| hash.select!(*args, &block) }
+      end
+
+      def reject(*args, &block)
+        dup.tap { |hash| hash.reject!(*args, &block) }
+      end
+
+      # Convert to a regular hash with string keys.
+      def to_hash
+        _new_hash = Hash.new(default)
+        each do |key, value|
+          _new_hash[key] = convert_value(value, for: :to_hash)
+        end
+        _new_hash
+      end
+
+      protected
+      def convert_key(key)
+        key.kind_of?(Symbol) ? key.to_s : key
+      end
+
+      def convert_value(value, options = {})
+        if value.is_a? Hash
+          if options[:for] == :to_hash
+            value.to_hash
+          else
+            Utils.indifferent_hash(value)
+          end
+        elsif value.is_a?(Array)
+          unless options[:for] == :assignment
+            value = value.dup
+          end
+          value.map! { |e| convert_value(e, options) }
+        else
+          value
+        end
+      end
+    end
+  end
+end