dynflow 0.6.2 → 0.7.0

data/examples/remote_executor.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require_relative 'example_helper'
+require 'tmpdir'
+
+class SampleAction < Dynflow::Action
+  def plan
+    number = rand(1e10)
+    puts "Plannin action: #{number}"
+    plan_self(number: number)
+  end
+
+  def run
+    puts "Running action: #{input[:number]}"
+  end
+end
+
+class RemoteExecutorExample
+  class << self
+
+    def run_server
+      world               = ExampleHelper.create_world(persistence_adapter: persistence_adapter)
+      listener            = Dynflow::Listeners::Socket.new world, socket
+
+      Thread.new { Dynflow::Daemon.new(listener, world).run }
+      ExampleHelper.run_web_console(world)
+    ensure
+      File.delete(db_path)
+    end
+
+    def run_client
+      executor = ->(world) { Dynflow::Executors::RemoteViaSocket.new(world, socket) }
+      world    = ExampleHelper.create_world(persistence_adapter: persistence_adapter,
+                                            executor:            executor)
+
+      loop do
+        world.trigger(SampleAction).finished.wait
+        sleep 0.5
+      end
+    end
+
+    def socket
+      File.join(Dir.tmpdir, 'dynflow_socket')
+    end
+
+    def persistence_adapter
+      Dynflow::PersistenceAdapters::Sequel.new "sqlite://#{db_path}"
+    end
+
+    def db_path
+      File.expand_path("../remote_executor_db.sqlite", __FILE__)
+    end
+
+  end
+end
+
+command = ARGV.first || 'server'
+
+if $0 == __FILE__
+  case command
+  when 'server'
+    puts <<MSG
+The server is starting…. You can send the work to it by running:
+
+   #{$0} client
+
+MSG
+   RemoteExecutorExample.run_server
+  when 'client'
+    RemoteExecutorExample.run_client
+  else
+    puts "Unknown command #{comment}"
+    exit 1
+  end
+end

data/lib/dynflow.rb

@@ -14,6 +14,7 @@ module Dynflow
   class Error < StandardError
   end
 
+  require 'dynflow/errors'
   require 'dynflow/future'
   require 'dynflow/micro_actor'
   require 'dynflow/serializable'

data/lib/dynflow/action.rb

@@ -9,16 +9,19 @@ module Dynflow
     include Algebrick::Matching
 
     require 'dynflow/action/format'
-    extend Format
+    extend Action::Format
 
     require 'dynflow/action/progress'
-    include Progress
+    include Action::Progress
+
+    require 'dynflow/action/rescue'
+    include Action::Rescue
 
     require 'dynflow/action/suspended'
     require 'dynflow/action/missing'
 
     require 'dynflow/action/polling'
-    require 'dynflow/action/cancellable_polling'
+    require 'dynflow/action/cancellable'
 
     def self.all_children
       children.values.inject(children.values) do |children, child|
@@ -56,6 +59,7 @@ module Dynflow
       end
       variants Executable, Present = atom
     end
+    Skip    = Algebrick.atom
 
     module Executable
       def execute_method_name
@@ -165,7 +169,7 @@ module Dynflow
       phase! Present
       plan_step.
           planned_steps(execution_plan).
-          map { |s| s.action execution_plan }.
+          map { |s| s.action(execution_plan) }.
           select { |a| a.is_a?(filter) }
     end
 
@@ -290,6 +294,10 @@ module Dynflow
     end
     remove_method :finalize
 
+    def run_accepts_events?
+      method(:run).arity != 0
+    end
+
     def self.new_from_hash(hash, world)
       new(hash, world)
     end
@@ -347,7 +355,7 @@ module Dynflow
     end
 
     def with_error_handling(&block)
-      raise "wrong state #{self.state}" unless self.state == :running
+      raise "wrong state #{self.state}" unless [:skipping, :running].include?(self.state)
 
       begin
         catch(ERROR) { block.call }
@@ -360,6 +368,8 @@ module Dynflow
       case self.state
       when :running
         self.state = :success
+      when :skipping
+        self.state = :skipped
       when :suspended, :error
       else
         raise "wrong state #{self.state}"
@@ -412,19 +422,25 @@ module Dynflow
       when state == :running
         raise NotImplementedError, 'recovery after restart is not implemented'
 
-      when [:pending, :error, :suspended].include?(state)
-        if [:pending, :error].include?(state) && event
+      when [:pending, :error, :skipping, :suspended].include?(state)
+        if event && state != :suspended
           raise 'event can be processed only when in suspended state'
         end
 
-        self.state = :running
+        self.state = :running unless self.state == :skipping
         save_state
         with_error_handling do
-          result = catch(SUSPEND) do
-            world.middleware.execute(:run, self, *[event].compact) { |*args| run(*args) }
-          end
-          if result == SUSPEND
-            self.state = :suspended
+          event = Skip if state == :skipping
+
+          # we run the Skip event only when the run accepts events
+          if event != Skip || run_accepts_events?
+            result = catch(SUSPEND) do
+              world.middleware.execute(:run, self, *[event].compact) do |*args|
+                run(*args)
+              end
+            end
+
+            self.state = :suspended if result == SUSPEND
           end
 
           check_serializable :output

data/lib/dynflow/action/{cancellable_polling.rb → cancellable.rb}

@@ -1,17 +1,16 @@
 module Dynflow
-  module Action::CancellablePolling
-    include Action::Polling
+  module Action::Cancellable
     Cancel = Algebrick.atom
 
     def run(event = nil)
       if Cancel === event
-        self.external_task = cancel_external_task
+        cancel!
       else
         super event
       end
     end
 
-    def cancel_external_task
+    def cancel!
       NotImplementedError
     end
   end

data/lib/dynflow/action/rescue.rb

@@ -0,0 +1,59 @@
+module Dynflow
+  module Action::Rescue
+
+    Strategy = Algebrick.type do
+      variants Skip = atom, Pause = atom
+    end
+
+    SuggestedStrategy = Algebrick.type do
+      fields! action:   Action,
+              strategy: Strategy
+    end
+
+    # What strategy should be used for rescuing from error in
+    # the action or its sub actions
+    #
+    # @return Strategy
+    #
+    # When determining the strategy, the algorithm starts from the
+    # entry action that by default takes the strategy from #rescue_strategy_for_self
+    # and #rescue_strategy_for_planned_actions and combines them together.
+    def rescue_strategy
+      suggested_strategies = []
+
+      if self.steps.compact.any? { |step| step.state == :error }
+        suggested_strategies << SuggestedStrategy[self, rescue_strategy_for_self]
+      end
+
+      self.planned_actions.each do |planned_action|
+        suggested_strategies << SuggestedStrategy[planned_action, rescue_strategy_for_planned_action(planned_action)]
+      end
+
+      combine_suggested_strategies(suggested_strategies)
+    end
+
+    # Override when another strategy should be used for rescuing from
+    # error on the action
+    def rescue_strategy_for_self
+      return Pause
+    end
+
+    # Override when the action should override the rescue
+    # strategy of an action it planned
+    def rescue_strategy_for_planned_action(action)
+      action.rescue_strategy
+    end
+
+    # Override when different appraoch should be taken for combining
+    # the suggested strategies
+    def combine_suggested_strategies(suggested_strategies)
+      if suggested_strategies.empty? ||
+            suggested_strategies.all? { |suggested_strategy| suggested_strategy.strategy == Skip }
+        return Skip
+      else
+        return Pause
+      end
+    end
+  end
+end
+

data/lib/dynflow/errors.rb

@@ -0,0 +1,28 @@
+module Dynflow
+  module Errors
+    class RescueError < StandardError; end
+
+    # placeholder in case the deserialized error is no longer available
+    class UnknownError < StandardError
+      def self.for_exception_class(class_name)
+        Class.new(self) do
+          define_singleton_method :name do
+            class_name
+          end
+        end
+      end
+
+      def self.inspect
+        "#{UnknownError.name}[#{name}]"
+      end
+
+      def self.to_s
+        inspect
+      end
+
+      def inspect
+        "#{self.class.inspect}: #{message}"
+      end
+    end
+  end
+end

data/lib/dynflow/execution_plan.rb

@@ -4,6 +4,7 @@ module Dynflow
 
   # TODO extract planning logic to an extra class ExecutionPlanner
   class ExecutionPlan < Serializable
+
     include Algebrick::TypeCheck
     include Stateful
 
@@ -83,7 +84,9 @@ module Dynflow
       all_steps = steps.values
       if all_steps.any? { |step| step.state == :error }
         return :error
-      elsif all_steps.all? { |step| [:success, :skipped].include?(step.state) }
+      elsif all_steps.any? { |step| [:skipping, :skipped].include?(step.state) }
+        return :warning
+      elsif all_steps.all? { |step| step.state == :success }
         return :success
       else
         return :pending
@@ -98,6 +101,36 @@ module Dynflow
       steps.values.map(&:error).compact
     end
 
+    def rescue_strategy
+      Type! entry_action.rescue_strategy, Action::Rescue::Strategy
+    end
+
+    def rescue_plan_id
+      case rescue_strategy
+      when Action::Rescue::Pause
+        nil
+      when Action::Rescue::Skip
+        failed_steps.each { |step| self.skip(step) }
+        self.id
+      end
+    end
+
+    def failed_steps
+      steps_in_state(:error)
+    end
+
+    def steps_in_state(*states)
+      self.steps.values.find_all {|step| states.include?(step.state) }
+    end
+
+    def rescue_from_error
+      if rescue_plan_id = self.rescue_plan_id
+        @world.execute(rescue_plan_id)
+      else
+        raise Errors::RescueError, 'Unable to rescue from the error'
+      end
+    end
+
     def generate_action_id
       @last_action_id ||= 0
       @last_action_id += 1
@@ -137,11 +170,7 @@ module Dynflow
     end
 
     def skip(step)
-      raise "plan step can't be skipped" if step.is_a? Steps::PlanStep
-      steps_to_skip = steps_to_skip(step).each do |s|
-        s.state = :skipped
-        s.save
-      end
+      steps_to_skip = steps_to_skip(step).each(&:mark_to_skip)
       self.save
       return steps_to_skip
     end
@@ -269,12 +298,14 @@ module Dynflow
       plan_total > 0 ? (plan_done / plan_total) : 1
     end
 
-    # @return [Array<Action>] actions in Present phase, consider using
-    # Steps::Abstract#action instead
+    def entry_action
+      @entry_action ||= root_plan_step.action(self)
+    end
+
+    # @return [Array<Action>] actions in Present phase
     def actions
       @actions ||= begin
-        action_ids = steps.reduce({}) { |h, (_, s)| h.update s.action_id => s }
-        action_ids.map { |_, step| step.action self }
+        [entry_action] + entry_action.all_planned_actions
       end
     end
 

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

@@ -50,6 +50,10 @@ module Dynflow
         raise NotImplementedError
       end
 
+      def mark_to_skip
+        raise NotImplementedError
+      end
+
       def persistence
         world.persistence
       end
@@ -59,7 +63,7 @@ module Dynflow
       end
 
       def self.states
-        @states ||= [:pending, :running, :success, :suspended, :skipped, :error]
+        @states ||= [:pending, :running, :success, :suspended, :skipping, :skipped, :error]
       end
 
       def execute(*args)
@@ -110,8 +114,15 @@ module Dynflow
       # details, human outputs, etc.
       def action(execution_plan)
         attributes = world.persistence.adapter.load_action(execution_plan_id, action_id)
-        Action.from_hash(attributes.update(phase: Action::Present, execution_plan: execution_plan),
-                         world)
+        Action.from_hash(attributes.update(phase: Action::Present, execution_plan: execution_plan), world)
+      end
+
+      def skippable?
+        self.state == :error
+      end
+
+      def cancellable?
+        false
       end
 
       protected

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

@@ -31,7 +31,12 @@ module Dynflow
       end
 
       def self.new_from_hash(hash)
-        self.new(hash[:exception_class].constantize, hash[:message], hash[:backtrace], nil)
+        exception_class = begin
+                            hash[:exception_class].constantize
+                          rescue NameError
+                            Errors::UnknownError.for_exception_class(hash[:exception_class])
+                          end
+        self.new(exception_class, hash[:message], hash[:backtrace], nil)
       end
 
       def to_hash

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

@@ -18,6 +18,11 @@ module Dynflow
         Action::Finalize
       end
 
+      def mark_to_skip
+        self.state = :skipped
+        self.save
+      end
+
     end
   end
 end