dynflow 0.3.0 → 0.4.0

data/lib/dynflow/action/format.rb

@@ -14,12 +14,12 @@ module Dynflow
       when !block && @input_format_block
         return @input_format ||= Apipie::Params::Description.define(&@input_format_block)
       when block && @input_format_block
-        raise "The input_format has already been defined in #{self.action_class}"
+        raise "The input_format has already been defined in #{self.class}"
       when !block && !@input_format_block
         if superclass.respond_to? :input_format
           superclass.input_format
         else
-          raise "The input_format has not been defined yet in #{self.action_class}"
+          raise "The input_format has not been defined yet in #{self.class}"
         end
       end
     end
@@ -31,12 +31,12 @@ module Dynflow
       when !block && @output_format_block
         return @output_format ||= Apipie::Params::Description.define(&@output_format_block)
       when block && @output_format_block
-        raise "The output_format has already been defined in #{self.action_class}"
+        raise "The output_format has already been defined in #{self.class}"
       when !block && !@output_format_block
         if superclass.respond_to? :output_format
           superclass.output_format
         else
-          raise "The output_format has not been defined yet in #{self.action_class}"
+          raise "The output_format has not been defined yet in #{self.class}"
         end
       end
     end

data/lib/dynflow/action/progress.rb

@@ -33,13 +33,13 @@ module Dynflow
       when :success, :skipped
         1
       when :running, :suspended
-        case self
-        when Action::RunPhase
+        case phase
+        when Action::Run
           run_progress
-        when Action::FinalizePhase
+        when Action::Finalize
           finalize_progress
         else
-          raise "Calculating progress for this phase is not supported"
+          raise 'Calculating progress for this phase is not supported'
         end
       else
         0
@@ -47,13 +47,13 @@ module Dynflow
     end
 
     def progress_weight
-      case self
-      when Action::RunPhase
+      case phase
+      when Action::Run
         run_progress_weight
-      when Action::FinalizePhase
+      when Action::Finalize
         finalize_progress_weight
       else
-        raise "Calculating progress for this phase is not supported"
+        raise 'Calculating progress for this phase is not supported'
       end
     end
 

data/lib/dynflow/execution_plan.rb

@@ -96,6 +96,10 @@ module Dynflow
       result == :error
     end
 
+    def errors
+      steps.values.map(&:error).compact
+    end
+
     def generate_action_id
       @last_action_id ||= 0
       @last_action_id += 1
@@ -149,7 +153,7 @@ module Dynflow
     # FIND maybe move to persistence to let adapter to do it effectively?
     # @return [Array<Steps::Abstract>]
     def steps_to_skip(step)
-      dependent_steps = @steps.values.find_all do |s|
+      dependent_steps = steps.values.find_all do |s|
         next if s.is_a? Steps::PlanStep
         action = persistence.load_action(s)
         action.required_step_ids.include?(step.id)
@@ -199,14 +203,14 @@ module Dynflow
     end
 
     def add_run_step(action)
-      add_step(Steps::RunStep, action.action_class, action.id).tap do |step|
+      add_step(Steps::RunStep, action.class, action.id).tap do |step|
         @dependency_graph.add_dependencies(step, action)
         current_run_flow.add_and_resolve(@dependency_graph, Flows::Atom.new(step.id))
       end
     end
 
     def add_finalize_step(action)
-      add_step(Steps::FinalizeStep, action.action_class, action.id).tap do |step|
+      add_step(Steps::FinalizeStep, action.class, action.id).tap do |step|
         finalize_flow << Flows::Atom.new(step.id)
       end
     end
@@ -264,19 +268,14 @@ module Dynflow
     # @return [Array<Action::Presenter>] presenter of the actions
     # involved in the plan
     def actions
-      action_steps = Hash.new { |h, k| h[k] = [] }
-      all_actions  = []
-      steps.values.each do |step|
-        action_steps[step.action_id] << step
-      end
-      action_steps.each do |action_id, involved_steps|
-        action = Action::Presenter.load(self,
-                                        action_id,
-                                        involved_steps,
-                                        all_actions)
-        all_actions << action
+      @actions ||= begin
+        action_ids = steps.values.map(&:action_id).uniq
+        action_ids.map do |action_id|
+          attributes = world.persistence.adapter.load_action(id, action_id)
+          Action.from_hash(attributes.update(phase: Action::Present, execution_plan: self),
+                           world)
+        end
       end
-      return all_actions
     end
 
     private

data/lib/dynflow/execution_plan/output_reference.rb

@@ -1,51 +1,84 @@
 module Dynflow
   class ExecutionPlan::OutputReference < Serializable
+    include Algebrick::TypeCheck
 
-    attr_reader :step_id, :action_id, :subkeys
+    # dereferences all OutputReferences in Hash-Array structure
+    def self.dereference(object, persistence)
+      case object
+      when Hash
+        object.reduce(HashWithIndifferentAccess.new) do |h, (key, val)|
+          h.update(key => dereference(val, persistence))
+        end
+      when Array
+        object.map { |val| dereference(val, persistence) }
+      when self
+        object.dereference(persistence)
+      else
+        object
+      end
+    end
+
+    # dereferences all hashes representing OutputReferences in Hash-Array structure
+    def self.deserialize(value)
+      case value
+      when Hash
+        if value[:class] == self.to_s
+          new_from_hash(value)
+        else
+          value.reduce(HashWithIndifferentAccess.new) do |h, (key, val)|
+            h.update(key => deserialize(val))
+          end
+        end
+      when Array
+        value.map { |val| deserialize(val) }
+      else
+        value
+      end
+    end
+
+    attr_reader :execution_plan_id, :step_id, :action_id, :subkeys
 
-    def initialize(step_id, action_id, subkeys = [])
-      @step_id   = step_id
-      @action_id = action_id
-      @subkeys   = subkeys
+    def initialize(execution_plan_id, step_id, action_id, subkeys = [])
+      @execution_plan_id = Type! execution_plan_id, String
+      @step_id           = Type! step_id, Integer
+      @action_id         = Type! action_id, Integer
+      Type! subkeys, Array
+      @subkeys = subkeys.map { |v| Type!(v, String, Symbol).to_s }.freeze
     end
 
     def [](subkey)
-      return self.class.new(step_id, action_id, subkeys.dup << subkey)
+      self.class.new(execution_plan_id, step_id, action_id, subkeys + [subkey])
     end
 
     def to_hash
-      recursive_to_hash class:     self.class.to_s,
-                        step_id:   step_id,
-                        action_id: action_id,
-                        subkeys:   subkeys
+      recursive_to_hash class:             self.class.to_s,
+                        execution_plan_id: execution_plan_id,
+                        step_id:           step_id,
+                        action_id:         action_id,
+                        subkeys:           subkeys
     end
 
     def to_s
-      "Step(#{@step_id}).output".tap do |ret|
-        ret << @subkeys.map { |k| "[:#{k}]" }.join('') if @subkeys.any?
+      "Step(#{step_id}).output".tap do |ret|
+        ret << subkeys.map { |k| "[:#{k}]" }.join('') if subkeys.any?
       end
     end
 
     alias_method :inspect, :to_s
 
-    def dereference(persistence, execution_plan_id)
+    def dereference(persistence)
       action_data = persistence.adapter.load_action(execution_plan_id, action_id)
-      deref       = action_data[:output]
-      @subkeys.each do |subkey|
-        if deref.respond_to?(:[])
-          deref = deref[subkey]
-        else
-          raise "We were not able to dereference subkey #{@subkeys} from #{self.inspect}"
-        end
-      end
-      return deref
+      @subkeys.reduce(action_data[:output]) { |v, k| v.fetch k }
     end
 
     protected
 
     def self.new_from_hash(hash)
       check_class_matching hash
-      new(hash[:step_id], hash[:action_id], hash[:subkeys])
+      new(hash.fetch(:execution_plan_id),
+          hash.fetch(:step_id),
+          hash.fetch(:action_id),
+          hash.fetch(:subkeys))
     end
 
   end

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

@@ -31,9 +31,7 @@ module Dynflow
 
         self.state = state.to_sym
 
-        Type! action_class, Class
-        raise ArgumentError, 'action_class is not an child of Action' unless action_class < Action
-        raise ArgumentError, 'action_class must not be phase' if action_class.phase?
+        Child! action_class, Action
         @action_class = action_class
 
         @action_id = action_id || raise(ArgumentError, 'missing action_id')

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

@@ -5,7 +5,6 @@ module Dynflow
       def execute(*args)
         return self if [:skipped, :success].include? self.state
         open_action do |action|
-          action.indifferent_access_hash_variable_set :input, dereference(action.input)
           with_time_calculation do
             action.execute(*args)
           end
@@ -16,7 +15,6 @@ module Dynflow
         self.class.from_hash(to_hash, execution_plan_id, world)
       end
 
-
       def progress
         action = persistence.load_action(self)
         [action.progress_done, action.progress_weight]
@@ -32,21 +30,6 @@ module Dynflow
 
         return self
       end
-
-      def dereference(input)
-        case input
-        when Hash
-          input.reduce(HashWithIndifferentAccess.new) do |h, (key, val)|
-            h.update(key => dereference(val))
-          end
-        when Array
-          input.map { |val| dereference(val) }
-        when ExecutionPlan::OutputReference
-          input.dereference(persistence, execution_plan_id)
-        else
-          input
-        end
-      end
     end
   end
 end

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

@@ -1,32 +1,56 @@
 module Dynflow
   module ExecutionPlan::Steps
     class Error < Serializable
+      extend Algebrick::Matching
+      include Algebrick::TypeCheck
 
       attr_reader :exception_class, :message, :backtrace
 
-      def initialize(exception_class, message, backtrace)
-        @exception_class = exception_class
-        @message         = message
-        @backtrace       = backtrace
+      def self.new(*args)
+        case args.size
+        when 1
+          match obj = args.first,
+                (on String do
+                  super(StandardError, obj, caller, nil)
+                end),
+                (on Exception do
+                  super(obj.class, obj.message, obj.backtrace, obj)
+                end)
+        when 3, 4
+          super(*args.values_at(0..3))
+        else
+          raise ArgumentError, "wrong number of arguments #{args}"
+        end
+      end
+
+      def initialize(exception_class, message, backtrace, exception)
+        @exception_class = Child! exception_class, Exception
+        @message         = Type! message, String
+        @backtrace       = Type! backtrace, Array
+        @exception       = Type! exception, Exception, NilClass
       end
 
       def self.new_from_hash(hash)
-        self.new(hash[:exception_class], hash[:message], hash[:backtrace])
+        self.new(hash[:exception_class].constantize, hash[:message], hash[:backtrace], nil)
       end
 
       def to_hash
-        { class:           self.class.name,
-          exception_class: exception_class,
-          message:         message,
-          backtrace:       backtrace }
+        recursive_to_hash class:           self.class.name,
+                          exception_class: exception_class.to_s,
+                          message:         message,
+                          backtrace:       backtrace
       end
 
       def to_s
-        "#{message} (#{exception_class})\n#{(backtrace || []).join("\n")}"
+        format '%s (%s)\n%s',
+               (@exception || self).message,
+               (@exception ? @exception.class : exception_class),
+               (@exception || self).backtrace
       end
 
       def exception
-        exception_class.constantize.exception(message).tap { |e| e.set_backtrace backtrace }
+        @exception ||
+            exception_class.exception(message).tap { |e| e.set_backtrace backtrace }
       end
     end
   end

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

@@ -15,7 +15,7 @@ module Dynflow
 
 
       def phase
-        :finalize_phase
+        Action::Finalize
       end
 
     end

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

@@ -24,7 +24,7 @@ module Dynflow
       end
 
       def phase
-        :plan_phase
+        Action::Plan
       end
 
       def to_hash
@@ -37,8 +37,13 @@ module Dynflow
         attributes = { execution_plan_id: execution_plan.id,
                        id:                action_id,
                        step:              self,
-                       plan_step_id:      self.id }
-        action     = action_class.plan_phase.new(attributes, execution_plan, trigger)
+                       plan_step_id:      self.id,
+                       run_step_id:       nil,
+                       finalize_step_id:  nil,
+                       phase:             phase,
+                       execution_plan:    execution_plan,
+                       trigger:           trigger }
+        action     = action_class.new(attributes, execution_plan.world)
         persistence.save_action(execution_plan_id, action)
 
         with_time_calculation do

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

@@ -14,7 +14,7 @@ module Dynflow
       end
 
       def phase
-        :run_phase
+        Action::Run
       end
     end
   end

data/lib/dynflow/listeners/socket.rb

@@ -1,7 +1,6 @@
 module Dynflow
   module Listeners
     class Socket < Abstract
-      # TODO terminate when exiting
       include Listeners::Serialization
       include Algebrick::Matching
 

data/lib/dynflow/middleware.rb

@@ -2,7 +2,6 @@ module Dynflow
   class Middleware
     require 'dynflow/middleware/register'
     require 'dynflow/middleware/world'
-    require 'dynflow/middleware/action'
     require 'dynflow/middleware/resolver'
     require 'dynflow/middleware/stack'
 

data/lib/dynflow/middleware/world.rb

@@ -20,7 +20,7 @@ module Dynflow
         action_class = action_or_class
       elsif Type? action_or_class, Dynflow::Action
         action = action_or_class
-        action_class = action.action_class
+        action_class = action.class
       else
         Algebrick::TypeCheck.error action_or_class, 'is not instance or child class', Dynflow::Action
       end

data/lib/dynflow/persistence.rb

@@ -14,11 +14,8 @@ module Dynflow
     def load_action(step)
       attributes = adapter.
           load_action(step.execution_plan_id, step.action_id).
-          update(step: step)
-      return Action.from_hash(attributes,
-                              step.phase,
-                              step,
-                              step.world)
+          update(step: step, phase: step.phase)
+      return Action.from_hash(attributes, step.world)
     end
 
     def save_action(execution_plan_id, action)

data/lib/dynflow/serializable.rb

@@ -2,7 +2,7 @@ module Dynflow
   class Serializable
     def self.from_hash(hash, *args)
       check_class_key_present hash
-      hash[:class].constantize.new_from_hash(hash, *args)
+      constantize(hash[:class]).new_from_hash(hash, *args)
     end
 
     def to_hash
@@ -26,26 +26,39 @@ module Dynflow
       raise ArgumentError, 'missing :class' unless hash[:class]
     end
 
+    def self.constantize(action_name)
+      action_name.constantize
+    end
+
     private_class_method :check_class_matching, :check_class_key_present
 
     private
 
-    def recursive_to_hash(value)
-      case value
-      when Numeric, String, Symbol, TrueClass, FalseClass, NilClass
-        value
-      when Array
-        value.map { |v| recursive_to_hash v }
-      when Hash
-        value.inject({}) { |h, (k, v)| h.update k => recursive_to_hash(v) }
+    # recursively traverses hash-array structure and converts all to hashes
+    # accepts more hashes which are then merged
+    def recursive_to_hash(*values)
+      if values.size == 1
+        value = values.first
+        case value
+        when Numeric, String, Symbol, TrueClass, FalseClass, NilClass
+          value
+        when Array
+          value.map { |v| recursive_to_hash v }
+        when Hash
+          value.inject({}) { |h, (k, v)| h.update k => recursive_to_hash(v) }
+        else
+          value.to_hash
+        end
       else
-        value.to_hash
+        values.all? { |v| Type! v, Hash, NilClass }
+        recursive_to_hash(values.compact.reduce { |h, v| h.merge v })
       end
     end
 
     def self.string_to_time(string)
       return if string.nil?
-      _, year, month, day, hour, min, sec = */(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/.match(string)
+      _, year, month, day, hour, min, sec =
+          */(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/.match(string)
       Time.new(year.to_i, month.to_i, day.to_i, hour.to_i, min.to_i, sec.to_i)
     end