dynflow 0.3.0 → 0.4.0

data/test/support/code_workflow_example.rb

@@ -24,7 +24,7 @@ module Support
       end
 
       def summary
-        triages   = all_actions.find_all do |action|
+        triages   = execution_plan.actions.find_all do |action|
           action.is_a? Triage
         end
         assignees = triages.map do |triage|
@@ -33,7 +33,6 @@ module Support
         end.compact.uniq
         { assignees: assignees }
       end
-
     end
 
     class Slow < Dynflow::Action
@@ -274,7 +273,7 @@ module Support
       end
 
       def poll_external_task
-        progress     = external_task[:progress]
+        progress     = external_task.fetch(:progress)
         new_progress = if progress == 30
                          if input[:text] =~ /cancel-external/
                            progress

data/test/test_helper.rb

@@ -28,7 +28,7 @@ class TestExecutionLog
   end
 
   def <<(action)
-    @log << [action.action_class, action.input]
+    @log << [action.class, action.input]
   end
 
   def log

data/test/testing_test.rb

@@ -14,7 +14,7 @@ module Dynflow
         action = create_and_plan_action CWE::DummyHeavyProgress, input
 
         action.must_be_kind_of CWE::DummyHeavyProgress
-        action.must_be_kind_of Action::PlanPhase
+        action.phase.must_equal Action::Plan
         action.input.must_equal input
         action.execution_plan.must_be_kind_of Testing::DummyExecutionPlan
         action.state.must_equal :success
@@ -29,7 +29,7 @@ module Dynflow
         action = run_action plan
 
         action.must_be_kind_of CWE::DummyHeavyProgress
-        action.must_be_kind_of Action::RunPhase
+        action.phase.must_equal Action::Run
         action.input.must_equal input
         action.world.must_equal plan.world
         action.run_step_id.wont_equal action.plan_step_id
@@ -67,7 +67,7 @@ module Dynflow
         action                = finalize_action run
 
         action.must_be_kind_of CWE::DummyHeavyProgress
-        action.must_be_kind_of Action::FinalizePhase
+        action.phase.must_equal Action::Finalize
         action.input.must_equal input
         action.output.must_equal run.output
         action.world.must_equal plan.world

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynflow
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-11 00:00:00.000000000 Z
+date: 2014-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -226,15 +226,10 @@ files:
 - lib/dynflow.rb
 - lib/dynflow/action.rb
 - lib/dynflow/action/cancellable_polling.rb
-- lib/dynflow/action/finalize_phase.rb
-- lib/dynflow/action/flow_phase.rb
 - lib/dynflow/action/format.rb
 - lib/dynflow/action/missing.rb
-- lib/dynflow/action/plan_phase.rb
 - lib/dynflow/action/polling.rb
-- lib/dynflow/action/presenter.rb
 - lib/dynflow/action/progress.rb
-- lib/dynflow/action/run_phase.rb
 - lib/dynflow/action/suspended.rb
 - lib/dynflow/clock.rb
 - lib/dynflow/daemon.rb
@@ -282,7 +277,6 @@ files:
 - lib/dynflow/logger_adapters/simple.rb
 - lib/dynflow/micro_actor.rb
 - lib/dynflow/middleware.rb
-- lib/dynflow/middleware/action.rb
 - lib/dynflow/middleware/register.rb
 - lib/dynflow/middleware/resolver.rb
 - lib/dynflow/middleware/stack.rb

data/lib/dynflow/action/finalize_phase.rb

@@ -1,20 +0,0 @@
-module Dynflow
-  module Action::FinalizePhase
-
-    def self.included(base)
-      base.send(:include, Action::FlowPhase)
-      base.send(:attr_reader, :output)
-    end
-
-    def execute
-      self.state = :running
-      save_state
-      with_error_handling do
-        world.middleware.execute(:finalize, self) do
-          finalize
-        end
-      end
-    end
-
-  end
-end

data/lib/dynflow/action/flow_phase.rb

@@ -1,44 +0,0 @@
-module Dynflow
-  module Action::FlowPhase
-
-    def self.included(base)
-      base.extend(ClassMethods)
-      base.send(:attr_reader, :input)
-    end
-
-    def initialize(attributes, world)
-      super attributes, world
-
-      indifferent_access_hash_variable_set :input, deserialize_references(attributes[:input])
-      indifferent_access_hash_variable_set :output, attributes[:output] || {}
-    end
-
-    def to_hash
-      super.merge recursive_to_hash(input:  input,
-                                    output: output)
-    end
-
-    def deserialize_references(value)
-      case value
-      when Hash
-        if value[:class] == "Dynflow::ExecutionPlan::OutputReference"
-          ExecutionPlan::OutputReference.new_from_hash(value)
-        else
-          value.reduce(HashWithIndifferentAccess.new) do |h, (key, val)|
-            h.update(key => deserialize_references(val))
-          end
-        end
-      when Array
-        value.map { |val| deserialize_references(val) }
-      else
-        value
-      end
-    end
-
-    module ClassMethods
-      def new_from_hash(hash, step, world)
-        new(hash.merge(step: step), world)
-      end
-    end
-  end
-end

data/lib/dynflow/action/plan_phase.rb

@@ -1,87 +0,0 @@
-module Dynflow
-  module Action::PlanPhase
-    attr_reader :execution_plan, :trigger
-
-    def self.included(base)
-      base.attr_indifferent_access_hash :input
-    end
-
-    def initialize(attributes, execution_plan, trigger)
-      super attributes, execution_plan.world
-      plan_step_id || raise(ArgumentError, 'missing plan_step_id')
-
-      self.input      = attributes[:input] || {}
-      @execution_plan = Type! execution_plan, ExecutionPlan
-      @plan_step_id   = plan_step_id
-      @trigger        = Type! trigger, Action, NilClass
-    end
-
-    def execute(*args)
-      self.state = :running
-      save_state
-      with_error_handling do
-        concurrence do
-          world.middleware.execute(:plan, self, *args) do |*new_args|
-            plan(*new_args)
-          end
-        end
-
-        subscribed_actions = world.subscribed_actions(self.action_class)
-        if subscribed_actions.any?
-          # we encapsulate the flow for this action into a concurrence and
-          # add the subscribed flows to it as well.
-          trigger_flow = execution_plan.current_run_flow.sub_flows.pop
-          execution_plan.switch_flow(Flows::Concurrence.new([trigger_flow].compact)) do
-            subscribed_actions.each do |action_class|
-              new_plan_step = execution_plan.add_plan_step(action_class, self)
-              new_plan_step.execute(execution_plan, self, *args)
-            end
-          end
-        end
-      end
-    end
-
-    def to_hash
-      super.merge recursive_to_hash(input: input)
-    end
-
-    # DSL for plan method
-
-    def concurrence(&block)
-      execution_plan.switch_flow(Flows::Concurrence.new([]), &block)
-    end
-
-    def sequence(&block)
-      execution_plan.switch_flow(Flows::Sequence.new([]), &block)
-    end
-
-    def plan_self(input)
-      @input = input.with_indifferent_access
-      if self.respond_to?(:run)
-        run_step          = execution_plan.add_run_step(self)
-        @run_step_id      = run_step.id
-        @output_reference = ExecutionPlan::OutputReference.new(run_step.id, id)
-      end
-
-      if self.respond_to?(:finalize)
-        finalize_step     = execution_plan.add_finalize_step(self)
-        @finalize_step_id = finalize_step.id
-      end
-
-      return self # to stay consistent with plan_action
-    end
-
-    def plan_action(action_class, *args)
-      execution_plan.add_plan_step(action_class, self).execute(execution_plan, nil, *args)
-    end
-
-    def output
-      unless @output_reference
-        raise 'plan_self has to be invoked before being able to reference the output'
-      end
-
-      return @output_reference
-    end
-
-  end
-end

data/lib/dynflow/action/presenter.rb

@@ -1,51 +0,0 @@
-module Dynflow
-
-  # This module is used for providing access to the results of the
-  # action. It's used in ExecutionPlan#actions to provide access to
-  # data of the actions in the execution plan.
-  #
-  # It also defines helper methods to extract usable data from the action itself,
-  # as well as other actions involved in the execution plan. One action (usually the
-  # main trigger, can use them to collect data across the whole execution_plan)
-  module Action::Presenter
-
-    def self.included(base)
-      base.send(:attr_reader, :input)
-      base.send(:attr_reader, :output)
-      base.send(:attr_reader, :all_actions)
-    end
-
-    def self.load(execution_plan, action_id, involved_steps, all_actions)
-      persistence_adapter = execution_plan.world.persistence.adapter
-      attributes          = persistence_adapter.load_action(execution_plan.id,
-                                                            action_id)
-      raise ArgumentError, 'missing :class' unless attributes[:class]
-      Action.constantize(attributes[:class]).presenter.new(attributes,
-                                                           involved_steps,
-                                                           all_actions)
-    end
-
-    def to_hash
-      recursive_to_hash(action: action_class,
-                        input:  input,
-                        output: output)
-    end
-
-    # @param [Hash] attributes - the action attributes, usually loaded form persistence layer
-    # @param [Array<ExecutionPlan::Steps::AbstractStep> - steps that operate on top of the action
-    # @param [Array<Action::Presenter>] - array of all the actions involved in the execution plan
-    #                                     with this action. Allows to access data from other actions
-    def initialize(attributes, involved_steps, all_actions)
-      @execution_plan_id = attributes[:execution_plan_id] || raise(ArgumentError, 'missing execution_plan_id')
-      @id                = attributes[:id] || raise(ArgumentError, 'missing id')
-
-      # TODO: use the involved_steps to provide summary state and error for the action
-      @involved_steps    = involved_steps
-      @all_actions       = all_actions
-
-      indifferent_access_hash_variable_set :input, attributes[:input]
-      indifferent_access_hash_variable_set :output, attributes[:output] || {}
-    end
-
-  end
-end

data/lib/dynflow/action/run_phase.rb

@@ -1,45 +0,0 @@
-module Dynflow
-  module Action::RunPhase
-
-    def self.included(base)
-      base.send(:include, Action::FlowPhase)
-      base.attr_indifferent_access_hash :output
-    end
-
-    SUSPEND = Object.new
-
-    def execute(event)
-      @world.logger.debug "step #{execution_plan_id}:#{@step.id} got event #{event}" if event
-      case
-      when state == :running
-        raise NotImplementedError, 'recovery after restart is not implemented'
-
-      when [:pending, :error, :suspended].include?(state)
-        if [:pending, :error].include?(state) && event
-          raise 'event can be processed only when in suspended state'
-        end
-
-        self.state = :running
-        save_state
-        with_error_handling do
-          result = catch(SUSPEND) do
-            world.middleware.execute(:run, self, *Array(event)) { |*args| run(*args) }
-          end
-          if result == SUSPEND
-            self.state = :suspended
-          end
-        end
-
-      else
-        raise "wrong state #{state} when event:#{event}"
-      end
-    end
-
-    # DSL for run
-
-    def suspend(&block)
-      block.call Action::Suspended.new self if block
-      throw SUSPEND, SUSPEND
-    end
-  end
-end

data/lib/dynflow/middleware/action.rb

@@ -1,9 +0,0 @@
-module Dynflow
-  module Middleware::Action
-
-    def middleware
-      @middleware ||= Middleware::Register.new
-    end
-
-  end
-end