dynflow 0.8.9 → 0.8.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bd41952d6800002a81136459150422a4e11d0c83
-  data.tar.gz: 23d4b25ffe9bbb6c33fe82f75710d43c13d59721
+  metadata.gz: bc004bca5a068a20db3c14f727b365b3ac8784b8
+  data.tar.gz: c1c95bbb21be8430e2da6f822d77262a0e7f769f
 SHA512:
-  metadata.gz: 6c149b85eed0f445780d0f6984cce4570cc52123a4cec9db787cf1e59826a762e2bcc05124bf71a260b6f5b51f15a21d492128631841debd125968cf79ac1ccc
-  data.tar.gz: b9029f1873ddfc2c78c0a5f7873dd3588ce7d74b27f02dde3d2fec848ec2f89422bc25ed5fe3980e7b14e6d43dcaa986d76a9f6b26aef94ca8a1d1afc1fe128e
+  metadata.gz: 47a908f6fc5b80265d708be96f452450b45de7b8f9f2b63f59e623b162a2f205eebe7d72807d9e09ee10030b3f717293050ab87920ab5e302e990175f0bb9b72
+  data.tar.gz: 0d166b88b31788c97bb9f8dabb1a94e4a351c9df0123a1777179f0fb4fd2bc681e9f467e2a2e01d36ed736d1d9e45233c1ae069291925ee1708a8e2d0ac95bea

data/.travis.yml

@@ -1,3 +1,4 @@
+sudo: false
 language:
   - ruby
 

data/Gemfile

@@ -3,7 +3,7 @@ source 'https://rubygems.org'
 gemspec
 
 group :concurrent_ruby_ext do
-  gem 'concurrent-ruby-ext', '~> 1.0.0'
+  gem 'concurrent-ruby-ext', '~> 1.0'
 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.0'
+  s.add_dependency "concurrent-ruby-edge", '~> 0.2'
   s.add_dependency "sequel"
 
   s.add_development_dependency "rack-test"

data/examples/example_helper.rb

@@ -8,6 +8,10 @@ class ExampleHelper
       @world ||= create_world
     end
 
+    def set_world(world)
+      @world = world
+    end
+
     def create_world
       config = Dynflow::Config.new
       config.persistence_adapter = persistence_adapter
@@ -31,7 +35,6 @@ class ExampleHelper
       Dynflow::LoggerAdapters::Simple.new $stderr, 4
     end
 
-
     def run_web_console(world = ExampleHelper.world)
       require 'dynflow/web'
       dynflow_console = Dynflow::Web.setup do

data/examples/future_execution.rb

@@ -12,15 +12,14 @@ class CustomPassedObject
 end
 
 class CustomPassedObjectSerializer < ::Dynflow::Serializers::Abstract
-  def serialize
-    object = args.first
+  def serialize(arg)
     # Serialized output can be anything that is representable as JSON: Array, Hash...
-    { :id => object.id, :name => object.name }
+    { :id => arg.id, :name => arg.name }
   end
 
-  def deserialize
+  def deserialize(arg)
     # Deserialized output must be an Array
-    [CustomPassedObject.new(serialized_args[:id], serialized_args[:name])]
+    CustomPassedObject.new(arg[:id], arg[:name])
   end
 end
 

data/examples/orchestrate.rb

@@ -145,6 +145,7 @@ module Orchestrate
 end
 
 if $0 == __FILE__
+  ExampleHelper.world.action_logger.level = Logger::INFO
   ExampleHelper.something_should_fail!
   ExampleHelper.world.trigger(Orchestrate::CreateInfrastructure)
   Thread.new do

data/examples/sub_plan_concurrency_control.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+example_description = <<DESC
+  Sub-plan Concurrency Control Example
+  ====================================
+
+  This example shows, how an action with sub-plans can be used
+  to control concurrency level and tasks distribution over time.
+
+  This is useful, when doing resource-intensive bulk actions,
+  where running all actions at once would drain the system's resources.
+
+DESC
+
+require_relative 'example_helper'
+
+class CostyAction < Dynflow::Action
+
+  SleepTime = 10
+
+  def plan(number)
+    action_logger.info("#{number} PLAN")
+    plan_self(:number => number)
+  end
+
+  def run(event = nil)
+    unless output.key? :slept
+      output[:slept] = true
+      suspend do |suspended_action|
+        action_logger.info("#{input[:number]} SLEEP")
+        world.clock.ping(suspended_action, SleepTime)
+      end
+    end
+  end
+
+  def finalize
+    action_logger.info("#{input[:number]} DONE")
+  end
+end
+
+
+class ConcurrencyControlExample < Dynflow::Action
+  include Dynflow::Action::WithSubPlans
+
+  ConcurrencyLevel = 2
+  RunWithin = 2 * 60
+  
+  def plan(count)
+    limit_concurrency_level(ConcurrencyLevel)
+    distribute_over_time(RunWithin)
+    super(:count => count)
+  end
+
+  def create_sub_plans
+    sleep 1
+    input[:count].times.map { |i| trigger(CostyAction, i) }
+  end
+end
+
+if $0 == __FILE__
+  ExampleHelper.world.action_logger.level = Logger::INFO
+  triggered = ExampleHelper.world.trigger(ConcurrencyControlExample, 10)
+  puts example_description
+  puts <<-MSG.gsub(/^.*\|/, '')
+    |  Execution plan #{triggered.id} with 10 sub plans triggered
+    |  You can see the details at http://localhost:4567/#{triggered.id}/actions/1/sub_plans
+    |  Or simply watch in the console that there are never more than #{ConcurrencyControlExample::ConcurrencyLevel} running at the same time.
+    |
+    |  The tasks are distributed over #{ConcurrencyControlExample::RunWithin} seconds.
+  MSG
+
+  ExampleHelper.run_web_console
+end

data/lib/dynflow.rb

@@ -45,5 +45,7 @@ module Dynflow
   require 'dynflow/dispatcher'
   require 'dynflow/serializers'
   require 'dynflow/delayed_executors'
+  require 'dynflow/semaphores'
+  require 'dynflow/throttle_limiter'
   require 'dynflow/config'
 end

data/lib/dynflow/action/with_sub_plans.rb

@@ -17,8 +17,8 @@ module Dynflow
                end
              end),
             (on SubPlanFinished do
-              mark_as_done(event.execution_plan_id, event.success)
-              try_to_finish or suspend
+               mark_as_done(event.execution_plan_id, event.success)
+               try_to_finish or suspend
              end),
             (on Action::Cancellable::Cancel do
                cancel!
@@ -28,7 +28,15 @@ module Dynflow
     def initiate
       sub_plans = create_sub_plans
       sub_plans = Array[sub_plans] unless sub_plans.is_a? Array
-      wait_for_sub_plans(sub_plans)
+      if uses_concurrency_control
+        planned, failed = sub_plans.partition { |plan| plan.state == :planned }
+        calculate_time_distribution sub_plans.count
+        sub_plans = world.throttle_limiter.handle_plans!(execution_plan_id,
+                                                         planned.map(&:id),
+                                                         failed.map(&:id),
+                                                         input[:concurrency_control])
+      end
+      wait_for_sub_plans sub_plans
     end
 
     # @abstract when the logic for the initiation of the subtasks
@@ -55,13 +63,40 @@ module Dynflow
     end
 
     def cancel!
+      @world.throttle_limiter.cancel!(execution_plan_id)
       sub_plans('state' => 'running').each(&:cancel)
       suspend
     end
 
     # Helper for creating sub plans
     def trigger(*args)
-      world.trigger { world.plan_with_caller(self, *args) }
+      if uses_concurrency_control
+        world.plan_with_caller(self, *args)
+      else
+        world.trigger { world.plan_with_caller(self, *args) }
+      end
+    end
+
+    def limit_concurrency_level(level)
+      input[:concurrency_control] ||= {}
+      input[:concurrency_control][:level] = ::Dynflow::Semaphores::Stateful.new(level).to_hash
+    end
+
+    def calculate_time_distribution(count)
+      time = input[:concurrency_control][:time]
+      unless time.nil? || time.is_a?(Hash)
+        # Assume concurrency level 1 unless stated otherwise
+        level = input[:concurrency_control].fetch(:level, {}).fetch(:free, 1)
+        semaphore = ::Dynflow::Semaphores::Stateful.new(nil, level,
+                                                        :interval => time.to_f / (count * level),
+                                                        :time_span => time)
+        input[:concurrency_control][:time] = semaphore.to_hash
+      end
+    end
+
+    def distribute_over_time(time_span)
+      input[:concurrency_control] ||= {}
+      input[:concurrency_control][:time] = time_span
     end
 
     def wait_for_sub_plans(sub_plans)
@@ -171,5 +206,8 @@ module Dynflow
       fail "A sub task failed" if output[:failed_count] > 0
     end
 
+    def uses_concurrency_control
+      @uses_concurrency_control = input.key? :concurrency_control
+    end
   end
 end

data/lib/dynflow/config.rb

@@ -65,6 +65,10 @@ module Dynflow
       Executors::Parallel.new(world, config.pool_size)
     end
 
+    config_attr :executor_semaphore, Semaphores::Abstract, FalseClass do |world, config|
+      Semaphores::Dummy.new
+    end
+
     config_attr :connector, Connectors::Abstract do |world|
       Connectors::Direct.new(world)
     end
@@ -99,6 +103,10 @@ module Dynflow
       DelayedExecutors::Polling.new(world, options)
     end
 
+    config_attr :throttle_limiter, ::Dynflow::ThrottleLimiter do |world|
+      ::Dynflow::ThrottleLimiter.new(world)
+    end
+
     config_attr :action_classes do
       Action.all_children
     end

data/lib/dynflow/delayed_plan.rb

@@ -8,7 +8,7 @@ module Dynflow
     def initialize(world, execution_plan_uuid, start_at, start_before, args_serializer)
       @world               = Type! world, World
       @execution_plan_uuid = Type! execution_plan_uuid, String
-      @start_at            = Type! start_at, Time
+      @start_at            = Type! start_at, Time, NilClass
       @start_before        = Type! start_before, Time, NilClass
       @args_serializer     = Type! args_serializer, Serializers::Abstract
     end
@@ -42,8 +42,9 @@ module Dynflow
       return true
     end
 
-    def execute
-      @world.execute(execution_plan.id)
+    def execute(future = Concurrent.future)
+      @world.execute(execution_plan.id, future)
+      ::Dynflow::World::Triggered[execution_plan.id, future]
     end
 
     def to_hash

data/lib/dynflow/dispatcher/executor_dispatcher.rb

@@ -1,7 +1,7 @@
 module Dynflow
   module Dispatcher
     class ExecutorDispatcher < Abstract
-      def initialize(world)
+      def initialize(world, semaphore)
         @world        = Type! world, World
         @current_futures = Set.new
       end
@@ -19,12 +19,7 @@ module Dynflow
         execution_lock = Coordinator::ExecutionLock.new(@world, execution.execution_plan_id, envelope.sender_id, envelope.request_id)
         future = on_finish do |f|
           f.then do |plan|
-            if plan.state == :running
-              @world.invalidate_execution_lock(execution_lock)
-            else
-              @world.coordinator.release(execution_lock)
-              respond(envelope, Done)
-            end
+            when_done(plan, envelope, execution, execution_lock)
           end.rescue do |reason|
             @world.coordinator.release(execution_lock)
             respond(envelope, Failed[reason.to_s])
@@ -37,6 +32,15 @@ module Dynflow
         respond(envelope, Failed[e.message])
       end
 
+      def when_done(plan, envelope, execution, execution_lock)
+        if plan.state == :running
+          @world.invalidate_execution_lock(execution_lock)
+        else
+          @world.coordinator.release(execution_lock)
+          respond(envelope, Done)
+        end
+      end
+
       def perform_event(envelope, event_request)
         future = on_finish do |f|
           f.then do

data/lib/dynflow/execution_plan.rb

@@ -23,7 +23,7 @@ module Dynflow
       @state_transitions ||= { pending:  [:stopped, :scheduled, :planning],
                                scheduled: [:planning, :stopped],
                                planning: [:planned, :stopped],
-                               planned:  [:running],
+                               planned:  [:running, :stopped],
                                running:  [:paused, :stopped],
                                paused:   [:running],
                                stopped:  [] }
@@ -152,9 +152,9 @@ module Dynflow
       @last_step_id += 1
     end
 
-    def delay(action_class, delay_options, *args)
+    def delay(caller_action, action_class, delay_options, *args)
       save
-      @root_plan_step = add_scheduling_step(action_class)
+      @root_plan_step = add_scheduling_step(action_class, caller_action)
       execution_history.add("delay", @world.id)
       serializer = root_plan_step.delay(delay_options, args)
       delayed_plan = DelayedPlan.new(@world,
@@ -280,9 +280,9 @@ module Dynflow
       current_run_flow.add_and_resolve(@dependency_graph, new_flow) if current_run_flow
     end
 
-    def add_scheduling_step(action_class)
+    def add_scheduling_step(action_class, caller_action = nil)
       add_step(Steps::PlanStep, action_class, generate_action_id, :scheduling).tap do |step|
-        step.initialize_action
+        step.initialize_action(caller_action)
       end
     end
 

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

@@ -4,7 +4,7 @@ module Dynflow
 
       def self.state_transitions
         @state_transitions ||= {
-            pending:   [:running, :skipped], # :skipped when it cannot be run because it depends on skipping step
+            pending:   [:running, :skipped, :error], # :skipped when it cannot be run because it depends on skipping step
             running:   [:success, :error, :suspended],
             success:   [:suspended], # after not-done process_update
             suspended: [:running, :error], # process_update, e.g. error in setup_progress_updates

data/lib/dynflow/semaphores.rb

@@ -0,0 +1,8 @@
+module Dynflow
+  module Semaphores
+    require 'dynflow/semaphores/abstract'
+    require 'dynflow/semaphores/stateful'
+    require 'dynflow/semaphores/aggregating'
+    require 'dynflow/semaphores/dummy'
+  end
+end

data/lib/dynflow/semaphores/abstract.rb

@@ -0,0 +1,46 @@
+module Dynflow
+  module Semaphores
+    class Abstract
+
+      # Tries to get ticket from the semaphore
+      # Returns true if thing got a ticket
+      # Rturns false otherwise and puts the thing into the semaphore's queue
+      def wait(thing)
+        raise NotImplementedError
+      end
+
+      # Gets first object from the queue
+      def get_waiting
+        raise NotImplementedError
+      end
+
+      # Checks if there are objects in the queue
+      def has_waiting?
+        raise NotImpelementedError
+      end
+
+      # Returns n tickets to the semaphore
+      def release(n = 1)
+        raise NotImplementedError
+      end
+
+      # Saves the semaphore's state to some persistent storage
+      def save
+        raise NotImplementedError
+      end
+
+      # Tries to get n tickets
+      # Returns n if the semaphore has free >= n
+      # Returns free if n > free
+      def get(n = 1)
+        raise NotImplementedErrorn
+      end
+
+      # Requests all tickets
+      # Returns all free tickets from the semaphore
+      def drain
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/dynflow/semaphores/aggregating.rb

@@ -0,0 +1,63 @@
+module Dynflow
+  module Semaphores
+    class Aggregating < Abstract
+
+      attr_reader :children, :waiting
+
+      def initialize(children)
+        @children = children
+        @waiting  = []
+      end
+
+      def wait(thing)
+        if get > 0
+          true
+        else
+          @waiting << thing
+          false
+        end
+      end
+
+      def get_waiting
+        @waiting.shift
+      end
+
+      def has_waiting?
+        !@waiting.empty?
+      end
+
+      def save
+        @children.values.each(&:save)
+      end
+
+      def get(n = 1)
+        available = free
+        if n > available
+          drain
+        else
+          @children.values.each { |child| child.get n }
+          n
+        end
+      end
+
+      def drain
+        available = free
+        @children.values.each { |child| child.get available }
+        available
+      end
+
+      def free
+        @children.values.map(&:free).reduce { |acc, cur| cur < acc ? cur : acc }
+      end
+
+      def release(n = 1, key = nil)
+        if key.nil?
+          @children.values.each { |child| child.release n }
+        else
+          @children[key].release n
+        end
+      end
+
+    end
+  end
+end