dynflow 0.8.3 → 0.8.4

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ODk3MTc2Nzc3ZDFmNTMwYTNiMDFjZmIyOWIxZjI5NTY4ZGRjNWE5MQ==
+    ZWZjMGI1OWM2ZWQ4N2JiNDM5MDVmMDA1NmJlODJiMmJmNzg1ZDRjOA==
   data.tar.gz: !binary |-
-    ZGVhZTBhMGZkNWFkYzcxNWZjY2I2MDNlM2ZiNzFlMmJkNGRhZTQ4NQ==
+    ZWFhMTBiOWU0NTVjZTEyMGM5NDlhYTY1NDg0ZDVjYjg5MzJhZDFhMg==
 SHA512:
   metadata.gz: !binary |-
-    ODBjYjZmNWNmODU5ZWE4Y2JiYTBjNmE4OTYyNWExNjc0ZTg2OGMxZDI5NjEw
-    ZDUyNWNiODgxNGE2NTBhYmU0ODdkM2QyNmU3ODdmMDRjZDY4Y2U0NDdjM2Y5
-    OWRhMGViNWMyMjk0YmM2N2U2ZjE0ZDFkZmY0NjAwNDg3MDk5M2E=
+    ZDI4ZGVlNjQ5NGZkZGFhY2I3ZTlmZmJkNjRiZTMzODVkMDYzODAwNWNkYzU5
+    OTFjNGRiNWZjYzAwOTdjNDc5ZDcxMjk2MWNlMWVlNzdiYzhlNDVmMWExYTFl
+    MWZjYTAxZjMwODY1NTM2MWZiODliZjU2OTI3NGIyZThkNGU4YTI=
   data.tar.gz: !binary |-
-    YmU2NGFlOWU3YWY1NGRhMjc0MDA3Yjg4OTU2OTY1NzAyNjNjZTY1YzUzN2Fl
-    MWIyNDlkYmM0ZDVkMjAxMTRmYjIwNDM3MjE2OTBkMGRmOGRiY2ExODY3YzQ2
-    NDQzNzZhYmRiNWM4ZTUyYmU5YzcwYzk2ZWZjM2JmYmZmYTYyMGY=
+    OGEwM2M2YzViODM3Njc2NTExNTE0ZTY5YjA1NjNiNzJhMzIwNDBiZmQ2MmY0
+    NTg1MTBiYzViYjRjYmQ2MzU3YTFhZTdhOWQzZWIxMDYyZDM0NjM4YTZjYjc2
+    YTQyZTU1MWQ0MzcxYjMwNmYwYTM1NmUyOTc0YWQwZjQ1ZTU0OWM=

data/doc/pages/source/documentation/index.md

@@ -235,7 +235,7 @@ TriggerResult = Algebrick.type do
   PlaningFailed   = type { fields! execution_plan_id: String, error: Exception }
   # Returned by #trigger when planning is successful but execution fails to start.
   ExecutionFailed = type { fields! execution_plan_id: String, error: Exception }
-  # Returned by #schedule when scheduling succeeded.
+  # Returned by #delay when scheduling succeeded.
   Scheduled       = type { fields! execution_plan_id: String }
   # Returned by #trigger when planning is successful, #future will resolve after
   # ExecutionPlan is executed.
@@ -273,19 +273,19 @@ end
 #### Scheduling
 
 Scheduling an action means setting it up to be triggered at set time in future.
-Any action can be scheduled by calling:
+Any action can be delayed by calling:
 
 ```ruby
-world_instance.schedule(AnAction,
-                        { start_at: Time.now + 360, start_before: Time.now + 400 },
-                        *args)
+world_instance.delay(AnAction,
+                     { start_at: Time.now + 360, start_before: Time.now + 400 },
+                     *args)
 ```
 
-This snippet of code would schedule `AnAction` with arguments `args` to be executed
+This snippet of code would delay `AnAction` with arguments `args` to be executed
 in the time interval between `start_at` and `start_before`. Setting `start_before` to `nil`
-would schedule this action without the timeout limit.
+would delay execution of this action without the timeout limit.
 
-When an action is scheduled, an execution plan object is created with state set
+When an action is delayed, an execution plan object is created with state set
 to `scheduled`, but it doesn't run the the plan phase yet, the planning happens
 when the `start_at` time comes. If the planning doesn't happen in time
 (e.g. after `start_before`), the execution plan is marked as failed
@@ -293,12 +293,12 @@ when the `start_at` time comes. If the planning doesn't happen in time
 
 Since the `args` have to be saved, there must be a mechanism to safely serialize and deserialize them
 in order to make them survive being saved in a database. This is handled by a serializer.
-Different serializers can be set per action by overriding its `schedule` method.
+Different serializers can be set per action by overriding its `delay` method.
 
-Planning of the scheduled plans is handled by `Scheduler`, an object which
-periodically checks for scheduled execution plans and plans them. Scheduled execution
-plans don't do anything by themselves, they just wait to be picked up and planned by a Scheduler.
-It means that if no scheduler is present, their planning will be delayed until a scheduler
+Planning of the delayed plans is handled by `DelayedExecutor`, an object which
+periodically checks for delayed execution plans and plans them. Scheduled execution
+plans don't do anything by themselves, they just wait to be picked up and planned by a DelayedExecutor.
+It means that if no DelayedExecutor is present, their planning will be delayed until a scheduler
 is spawned.
 
 #### Plan phase
@@ -1015,7 +1015,7 @@ client worlds: useful in production, see [develpment vs. production](#developmen
 client requests and other worlds
 1. **executor dispatcher** - responsible for getting requests from
 other worlds and sending the responses
-1. **scheduler** - responsible for planning and exectuion of scheduled tasks
+1. **delayed executor** - responsible for planning and exectuion of scheduled tasks
 
 {% plantuml %}
 

data/dynflow.gemspec

@@ -18,7 +18,6 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version = '>= 1.9.3'
 
-  s.add_dependency "activesupport"
   s.add_dependency "multi_json"
   s.add_dependency "apipie-params"
   s.add_dependency "algebrick", '~> 0.7.0'

data/examples/future_execution.rb

@@ -26,7 +26,7 @@ end
 
 class DelayedAction < Dynflow::Action
 
-  def schedule(schedule_options, *args)
+  def delay(delay_options, *args)
     CustomPassedObjectSerializer.new(args)
   end
 
@@ -49,9 +49,9 @@ if $0 == __FILE__
 
   object = CustomPassedObject.new(1, 'CPS')
 
-  past_plan = ExampleHelper.world.schedule(DelayedAction, { :start_at => past, :start_before => past }, object)
-  near_future_plan = ExampleHelper.world.schedule(DelayedAction, { :start_at => near_future, :start_before => future }, object)
-  future_plan = ExampleHelper.world.schedule(DelayedAction, { :start_at => future }, object)
+  past_plan = ExampleHelper.world.delay(DelayedAction, { :start_at => past, :start_before => past }, object)
+  near_future_plan = ExampleHelper.world.delay(DelayedAction, { :start_at => near_future, :start_before => future }, object)
+  future_plan = ExampleHelper.world.delay(DelayedAction, { :start_at => future }, object)
 
   puts <<-MSG.gsub(/^.*\|/, '')
     |
@@ -61,9 +61,9 @@ if $0 == __FILE__
     |  This example shows the future execution functionality of Dynflow, which allows to plan actions to be executed at set time.
     |
     |  Execution plans:
-    |    #{past_plan.id} is scheduled to execute before #{past} and should timeout on the first run of the scheduler.
-    |    #{near_future_plan.id} is scheduled to execute at #{near_future} and should run successfully.
-    |    #{future_plan.id} is scheduled to execute at #{future} and should run successfully.
+    |    #{past_plan.id} is "delayed" to execute before #{past} and should timeout on the first run of the scheduler.
+    |    #{near_future_plan.id} is delayed to execute at #{near_future} and should run successfully.
+    |    #{future_plan.id} is delayed to execute at #{future} and should run successfully.
     |
     |  Visit http://localhost:4567 to see their status.
     |

data/lib/dynflow.rb

@@ -2,7 +2,6 @@ require 'apipie-params'
 require 'algebrick'
 require 'thread'
 require 'set'
-require 'active_support/core_ext/hash/indifferent_access'
 require 'base64'
 require 'concurrent'
 require 'concurrent-edge'
@@ -22,6 +21,7 @@ module Dynflow
   class Error < StandardError
   end
 
+  require 'dynflow/utils'
   require 'dynflow/round_robin'
   require 'dynflow/actor'
   require 'dynflow/errors'
@@ -36,7 +36,7 @@ module Dynflow
   require 'dynflow/flows'
   require 'dynflow/execution_history'
   require 'dynflow/execution_plan'
-  require 'dynflow/scheduled_plan'
+  require 'dynflow/delayed_plan'
   require 'dynflow/action'
   require 'dynflow/executors'
   require 'dynflow/logger_adapters'
@@ -44,6 +44,6 @@ module Dynflow
   require 'dynflow/connectors'
   require 'dynflow/dispatcher'
   require 'dynflow/serializers'
-  require 'dynflow/schedulers'
+  require 'dynflow/delayed_executors'
   require 'dynflow/config'
 end

data/lib/dynflow/action.rb

@@ -1,5 +1,3 @@
-require 'active_support/inflector'
-
 module Dynflow
   class Action < Serializable
 
@@ -127,13 +125,13 @@ module Dynflow
     def input=(hash)
       Type! hash, Hash
       phase! Plan
-      @input = hash.with_indifferent_access
+      @input = Utils.indifferent_hash(hash)
     end
 
     def output=(hash)
       Type! hash, Hash
       phase! Run
-      @output = hash.with_indifferent_access
+      @output = Utlis.indifferent_hash(hash)
     end
 
     def output
@@ -282,10 +280,10 @@ module Dynflow
       recursion.(input)
     end
 
-    def execute_schedule(schedule_options, *args)
+    def execute_delay(delay_options, *args)
       with_error_handling(true) do
-        world.middleware.execute(:schedule, self, schedule_options, *args) do
-          @serializer = schedule(schedule_options, *args).tap do |serializer|
+        world.middleware.execute(:delay, self, delay_options, *args) do
+          @serializer = delay(delay_options, *args).tap do |serializer|
             serializer.perform_serialization!
           end
         end
@@ -293,7 +291,7 @@ module Dynflow
     end
 
     def serializer
-      raise "The action must be scheduled in order to access the serializer" if @serializer.nil?
+      raise "The action must be delayed in order to access the serializer" if @serializer.nil?
       @serializer
     end
 
@@ -313,7 +311,7 @@ module Dynflow
       @step.save
     end
 
-    def schedule(schedule_options, *args)
+    def delay(delay_options, *args)
       Serializers::Noop.new(args)
     end
 

data/lib/dynflow/action/with_sub_plans.rb

@@ -67,7 +67,8 @@ module Dynflow
     def wait_for_sub_plans(sub_plans)
       output.update(total_count: 0,
                     failed_count: 0,
-                    success_count: 0)
+                    success_count: 0,
+                    pending_count: 0)
 
       planned, failed = sub_plans.partition(&:planned?)
 
@@ -75,6 +76,7 @@ module Dynflow
 
       output[:total_count] = sub_plan_ids.size
       output[:failed_count] = failed.size
+      output[:pending_count] = planned.size
 
       if planned.any?
         notify_on_finish(planned)
@@ -123,6 +125,7 @@ module Dynflow
       else
         output[:failed_count] += 1
       end
+      output[:pending_count] -= 1
     end
 
     def done?
@@ -144,7 +147,8 @@ module Dynflow
     def recalculate_counts
       output.update(total_count: 0,
                     failed_count: 0,
-                    success_count: 0)
+                    success_count: 0,
+                    pending_count: 0)
       sub_plans.each do |sub_plan|
         output[:total_count] += 1
         if sub_plan.state == :stopped
@@ -153,12 +157,14 @@ module Dynflow
           else
             output[:success_count] += 1
           end
+        else
+          output[:pending_count] += 1
         end
       end
     end
 
     def counts_set?
-      output[:total_count] && output[:success_count] && output[:failed_count]
+      output[:total_count] && output[:success_count] && output[:failed_count] && output[:pending_count]
     end
 
     def check_for_errors!

data/lib/dynflow/config.rb

@@ -93,10 +93,10 @@ module Dynflow
       true
     end
 
-    config_attr :scheduler, Schedulers::Abstract, NilClass do |world|
+    config_attr :delayed_executor, DelayedExecutors::Abstract, NilClass do |world|
       options = { :poll_interval => 15,
                   :time_source => -> { Time.now.utc } }
-      Schedulers::Polling.new(world, options)
+      DelayedExecutors::Polling.new(world, options)
     end
 
     config_attr :action_classes do

data/lib/dynflow/coordinator.rb

@@ -41,7 +41,7 @@ module Dynflow
 
       def initialize(*args)
         @data ||= {}
-        @data = @data.merge(class: self.class.name).with_indifferent_access
+        @data = Utils.indifferent_hash(@data.merge(class: self.class.name))
       end
 
       def from_hash(hash)
@@ -157,10 +157,10 @@ module Dynflow
 
     end
 
-    class SchedulerLock < LockByWorld
+    class DelayedExecutorLock < LockByWorld
       def initialize(world)
         super
-        @data[:id] = "scheduler"
+        @data[:id] = "delayed-executor"
       end
     end
 

data/lib/dynflow/delayed_executors.rb

@@ -0,0 +1,9 @@
+module Dynflow
+  module DelayedExecutors
+
+    require 'dynflow/delayed_executors/abstract'
+    require 'dynflow/delayed_executors/abstract_core'
+    require 'dynflow/delayed_executors/polling'
+
+  end
+end

data/lib/dynflow/{schedulers → delayed_executors}/abstract.rb

@@ -1,5 +1,5 @@
 module Dynflow
-  module Schedulers
+  module DelayedExecutors
     class Abstract
 
       attr_reader :core
@@ -26,7 +26,7 @@ module Dynflow
 
       def spawn
         Concurrent.future.tap do |initialized|
-          @core = core_class.spawn name: 'scheduler',
+          @core = core_class.spawn name: 'delayed-executor',
                                    args: [@world, @options],
                                    initialized: initialized
         end
@@ -34,4 +34,4 @@ module Dynflow
 
     end
   end
-end
+end

data/lib/dynflow/{schedulers → delayed_executors}/abstract_core.rb

@@ -1,5 +1,5 @@
 module Dynflow
-  module Schedulers
+  module DelayedExecutors
     class AbstractCore < Actor
 
       include Algebrick::TypeCheck
@@ -19,7 +19,7 @@ module Dynflow
         @time_source = options.fetch(:time_source, -> { Time.now.utc })
       end
 
-      def check_schedule
+      def check_delayed_plans
         raise NotImplementedError
       end
 
@@ -29,9 +29,9 @@ module Dynflow
         @time_source.call()
       end
 
-      def scheduled_execution_plans(time)
+      def delayed_execution_plans(time)
         with_error_handling([]) do
-          world.persistence.find_past_scheduled_plans(time)
+          world.persistence.find_past_delayed_plans(time)
         end
       end
 
@@ -42,9 +42,9 @@ module Dynflow
         error_retval
       end
 
-      def process(scheduled_plans, check_time)
+      def process(delayed_plans, check_time)
         processed_plan_uuids = []
-        scheduled_plans.each do |plan|
+        delayed_plans.each do |plan|
           with_error_handling do
             if !plan.start_before.nil? && plan.start_before < check_time
               @logger.debug "Failing plan #{plan.execution_plan_uuid}"
@@ -57,7 +57,7 @@ module Dynflow
             processed_plan_uuids << plan.execution_plan_uuid
           end
         end
-        world.persistence.delete_scheduled_plans(:execution_plan_uuid => processed_plan_uuids) unless processed_plan_uuids.empty?
+        world.persistence.delete_delayed_plans(:execution_plan_uuid => processed_plan_uuids) unless processed_plan_uuids.empty?
       end
 
     end

data/lib/dynflow/{schedulers → delayed_executors}/polling.rb

@@ -1,9 +1,9 @@
 module Dynflow
-  module Schedulers
+  module DelayedExecutors
     class Polling < Abstract
 
       def core_class
-        Dynflow::Schedulers::PollingCore
+        Dynflow::DelayedExecutors::PollingCore
       end
 
     end
@@ -17,15 +17,15 @@ module Dynflow
       end
 
       def start
-        check_schedule
+        check_delayed_plans
       end
 
-      def check_schedule
+      def check_delayed_plans
         check_time = time
-        plans = scheduled_execution_plans(check_time)
+        plans = delayed_execution_plans(check_time)
         process plans, check_time
 
-        world.clock.ping(self, poll_interval, :check_schedule)
+        world.clock.ping(self, poll_interval, :check_delayed_plans)
       end
     end
   end

data/lib/dynflow/{scheduled_plan.rb → delayed_plan.rb}

@@ -1,5 +1,5 @@
 module Dynflow
-  class ScheduledPlan < Serializable
+  class DelayedPlan < Serializable
 
     include Algebrick::TypeCheck
 
@@ -37,8 +37,8 @@ module Dynflow
     end
 
     def cancel
-      error("Scheduled task cancelled", "Scheduled task cancelled")
-      @world.persistence.delete_scheduled_plans(:execution_plan_uuid => execution_plan.id)
+      error("Delayed task cancelled", "Delayed task cancelled")
+      @world.persistence.delete_delayed_plans(:execution_plan_uuid => execution_plan.id)
       return true
     end
 
@@ -56,7 +56,7 @@ module Dynflow
 
     # @api private
     def self.new_from_hash(world, hash, *args)
-      serializer = hash[:args_serializer].constantize.new(nil, hash[:serialized_args])
+      serializer = Utils.constantize(hash[:args_serializer]).new(nil, hash[:serialized_args])
       self.new(world,
                hash[:execution_plan_uuid],
                string_to_time(hash[:start_at]),

data/lib/dynflow/execution_plan.rb

@@ -152,23 +152,23 @@ module Dynflow
       @last_step_id += 1
     end
 
-    def schedule(action_class, schedule_options, *args)
+    def delay(action_class, delay_options, *args)
       save
       @root_plan_step = add_scheduling_step(action_class)
-      execution_history.add("schedule", @world.id)
-      serializer = root_plan_step.schedule(schedule_options, args)
-      scheduled_plan = ScheduledPlan.new(@world,
+      execution_history.add("delay", @world.id)
+      serializer = root_plan_step.delay(delay_options, args)
+      delayed_plan = DelayedPlan.new(@world,
                                          id,
-                                         schedule_options[:start_at],
-                                         schedule_options.fetch(:start_before, nil),
+                                         delay_options[:start_at],
+                                         delay_options.fetch(:start_before, nil),
                                          serializer)
-      persistence.save_scheduled_plan(scheduled_plan)
+      persistence.save_delayed_plan(delayed_plan)
     ensure
       update_state(error? ? :stopped : :scheduled)
     end
 
-    def schedule_record
-      @schedule_record ||= persistence.load_scheduled_plan(id)
+    def delay_record
+      @delay_record ||= persistence.load_delayed_plan(id)
     end
 
     def prepare(action_class, options = {})
@@ -208,7 +208,7 @@ module Dynflow
     # array with the future value of the cancel result)
     def cancel
       if state == :scheduled
-        [Concurrent.future.tap { |f| f.success schedule_record.cancel }]
+        [Concurrent.future.tap { |f| f.success delay_record.cancel }]
       else
         steps_to_cancel.map do |step|
           world.event(id, step.id, ::Dynflow::Action::Cancellable::Cancel)