dynflow 0.0.1 → 0.1.0

data/lib/dynflow/step.rb

@@ -0,0 +1,234 @@
+module Dynflow
+  class Step
+
+    class Reference
+
+      attr_reader :step, :field
+
+      def initialize(step, field)
+        unless %w[input output].include? field
+          raise "Unexpected reference field: #{field}. Only input and output allowed"
+        end
+        @step  = step
+        @field = field
+      end
+
+      def encode
+        unless @step.persistence
+          raise "Reference can't be serialized without persistence available"
+        end
+
+        {
+          'dynflow_step_persistence_id' => @step.persistence.persistence_id,
+          'field' => @field
+        }
+      end
+
+      def self.decode(data)
+        return nil unless data.is_a? Hash
+        return nil unless data.has_key?('dynflow_step_persistence_id')
+        persistence_id = data['dynflow_step_persistence_id']
+        self.new(Dynflow::Bus.persisted_step(persistence_id), data['field'])
+      end
+
+      def dereference
+        @step.send(@field)
+      end
+
+      def inspect
+        ret = "References "
+        ret << @step.class.name.split('::').last
+        ret << "/"
+        ret << @step.action_class.name
+        ret << "(#{@step.persistence.persistence_id})" if @step.persistence
+        ret << "/"
+        ret << @field
+        return ret
+      end
+
+    end
+
+    extend Forwardable
+
+    def_delegators :@data, '[]', '[]='
+
+    attr_accessor :status
+    attr_reader :data, :action_class
+
+    # persistent representation of the step
+    attr_accessor :persistence
+
+    def input
+      @data['input']
+    end
+
+    def input=(input)
+      @data['input'] = input
+    end
+
+    def output
+      @data['output']
+    end
+
+    def output=(output)
+      @data['output'] = output
+    end
+
+    def error
+      @data['error']
+    end
+
+    def error=(error)
+      @data['error'] = error
+    end
+
+    # get a fresh instance of action class for execution
+    def action
+      self.action_class.new(input, output)
+    end
+
+    def catch_errors
+      yield
+      self.status = 'success'
+      return true
+    rescue Exception => e
+      self.error = {
+        "exception" => e.class.name,
+        "message"   => e.message,
+        "backtrace"   => e.backtrace
+      }
+      self.status = 'error'
+      return false
+    end
+
+    def ==(other)
+      self.encode == other.encode
+    end
+
+    def self.decode(data)
+      ret = data['step_class'].constantize.allocate
+      ret.instance_variable_set("@action_class", data['action_class'].constantize)
+      ret.instance_variable_set("@status",       data['status'])
+      ret.instance_variable_set("@data",         decode_data(data['data']))
+      return ret
+    end
+
+    def encode
+      {
+        'step_class'   => self.class.name,
+        'action_class' => action_class.name,
+        'status'       => status,
+        'data'         => encoded_data
+      }
+    end
+
+    def self.decode_data(data)
+      walk(data) do |item|
+        Reference.decode(item)
+      end
+    end
+
+    # we need this to encode the reference correctly
+    def encoded_data
+      self.class.walk(data) do |item|
+        if item.is_a? Reference
+          item.encode
+        end
+      end
+    end
+
+    def replace_references!
+      @data = self.class.walk(data) do |item|
+        if item.is_a? Reference
+          if item.step.status == 'skipped' || item.step.status == 'error'
+            self.status = 'skipped'
+            item
+          else
+            item.dereference
+          end
+        end
+      end
+    end
+
+    # walks hash depth-first, yielding on every value
+    # if yield return non-false value, use that instead of original
+    # value in a resulting hash
+    def self.walk(data, &block)
+      if converted = (yield data)
+        return converted
+      end
+      case data
+      when Array
+        data.map { |d| walk(d, &block) }
+      when Hash
+        data.reduce({}) { |h, (k, v)| h.update(k => walk(v, &block)) }
+      else
+        data
+      end
+    end
+
+    def persist
+      if @persistence
+        @persistence.persist(self)
+      end
+    end
+
+    def persist_before_run
+      if @persistence
+        @persistence.before_run(self)
+      end
+    end
+
+    def persist_after_run
+      if @persistence
+        @persistence.after_run(self)
+      end
+    end
+
+    class Plan < Step
+
+      def initialize(action)
+        # we want to have the steps separated:
+        # not using the original action object
+        @action_class = action.class
+        self.status = 'finished' # default status
+        @data = {}.with_indifferent_access
+      end
+
+    end
+
+    class Run < Step
+
+      def initialize(action)
+        # we want to have the steps separated:
+        # not using the original action object
+        @action_class = action.class
+        self.status = 'pending' # default status
+        @data = {
+          'input'  => action.input,
+          'output' => action.output
+        }.with_indifferent_access
+      end
+
+    end
+
+    class Finalize < Step
+
+      def initialize(run_step)
+        # we want to have the steps separated:
+        # not using the original action object
+        @action_class = run_step.action_class
+        self.status = 'pending' # default status
+        if run_step.action.respond_to? :run
+          @data = {
+            'input' => Reference.new(run_step, 'input'),
+            'output' => Reference.new(run_step, 'output'),
+          }
+        else
+          @data = run_step.data
+        end
+      end
+
+    end
+  end
+end

data/lib/dynflow/version.rb

@@ -1,3 +1,3 @@
 module Dynflow
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/test/action_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 module Dynflow
-  class CloneRepo < Action
+  class ActionTest < Action
 
     output_format do
       param :id, String
@@ -13,11 +13,12 @@ module Dynflow
 
   end
 
-  class CloneRepoTest < ParticipantTestCase
+  describe 'running an action' do
 
-    def test_action
-      action = run_action(CloneRepo, {:name => "zoo"})
-      assert_equal(action.output['id'], "zoo")
+    it 'executed the run method storing results to output attribute'do
+      action = ActionTest.new('name' => 'zoo')
+      action.run
+      action.output.must_equal('id' => "zoo")
     end
 
   end

data/test/bus_test.rb

@@ -2,54 +2,149 @@ require 'test_helper'
 require 'set'
 
 module Dynflow
-  class BusTest < BusTestCase
-    class Promotion < Action
+  module BusTest
+    describe "bus" do
 
-      def plan(repo_names, package_names)
-        repo_names.each do |repo_name|
-          plan_action(CloneRepo, {'name' => repo_name})
-        end
+      class Promotion < Action
+
+        def plan(repo_names, package_names)
+          repo_names.each do |repo_name|
+            plan_action(CloneRepo, {'name' => repo_name})
+          end
 
-        package_names.each do |package_name|
-          plan_action(ClonePackage, {'name' => package_name})
+          package_names.each do |package_name|
+            plan_action(ClonePackage, {'name' => package_name})
+          end
         end
+
       end
 
-    end
+      class CloneRepo < Action
+
+        input_format do
+          param :name, String
+        end
+
+        output_format do
+          param :id, String
+        end
+
+        def plan(input)
+          raise 'Simulate error in plan phase' if input['name'] == 'fail_in_plan'
+          plan_self(input)
+        end
+
+        def run
+          raise 'Simulate error in execution phase' if input['name'] == 'fail_in_run'
+          output['id'] = input['name']
+        end
 
-    class CloneRepo < Action
+        def finalize(outputs)
+          raise 'Simulate error in finalize phase' if input['name'] == 'fail_in_finalize'
+        end
 
-      input_format do
-        param :name, String
       end
 
-      output_format do
-        param :id, String
+      it 'returns the execution plan obejct when triggering an action' do
+        Promotion.trigger(['sucess'], []).must_be_instance_of Dynflow::ExecutionPlan
       end
 
-      def run
-        output['id'] = input['name']
+      describe 'handling errros in plan phase' do
+
+        let(:failed_plan)   { Promotion.trigger(['fail_in_plan'], []) }
+        let(:failed_step) { failed_plan.plan_steps.last }
+
+        it 'marks the process as error' do
+          failed_plan.status.must_equal 'error'
+        end
+
+        it 'saves errors of actions' do
+          failed_step.status.must_equal "error"
+          expected_error = {
+            'exception' => 'RuntimeError',
+            'message'   => 'Simulate error in plan phase'
+          }
+          failed_step.error['exception'].must_equal expected_error['exception']
+          failed_step.error['message'].must_equal expected_error['message']
+          failed_step.error['backtrace'].must_be_instance_of Array
+        end
+
       end
 
-    end
+      describe 'handling errros in execution phase' do
 
-    def execution_plan
-      [
-       [CloneRepo, {'name' => 'zoo'}],
-       [CloneRepo, {'name' => 'foo'}],
-      ]
-    end
+        let(:failed_plan)   { Promotion.trigger(['fail_in_run'], []) }
+        let(:failed_step) { failed_plan.run_steps.first }
 
-    def test_optimistic_case
-      expect_input(CloneRepo, {'name' => 'zoo'}, {'id' => '123'})
-      expect_input(CloneRepo, {'name' => 'foo'}, {'id' => '456'})
-      first_action, second_action = assert_scenario
+        it 'pauses the process' do
+          failed_plan.status.must_equal 'paused'
+        end
 
-      assert_equal({'name' => 'zoo'}, first_action.input)
-      assert_equal({'id' => '123'},   first_action.output)
-      assert_equal({'name' => 'foo'}, second_action.input)
-      assert_equal({'id' => '456'},   second_action.output)
-    end
+        it 'saves errors of actions' do
+          failed_step.status.must_equal "error"
+          expected_error = {
+            'exception' => 'RuntimeError',
+            'message'   => 'Simulate error in execution phase'
+          }
+          failed_step.error['exception'].must_equal expected_error['exception']
+          failed_step.error['message'].must_equal expected_error['message']
+          failed_step.error['backtrace'].must_be_instance_of Array
+        end
 
+        it 'allows skipping the step' do
+          Dynflow::Bus.skip(failed_step)
+          Dynflow::Bus.resume(failed_plan)
+
+          failed_plan.status.must_equal 'finished'
+          failed_step.status.must_equal 'skipped'
+        end
+
+        it 'allows rerunning the step' do
+          failed_step.input['name'] = 'succeed'
+          Dynflow::Bus.resume(failed_plan)
+
+          failed_plan.status.must_equal 'finished'
+          failed_step.output.must_equal('id' => 'succeed')
+        end
+
+      end
+
+      describe 'handling errors in finalizatoin phase' do
+
+        let(:failed_plan)   { Promotion.trigger(['fail_in_finalize'], []) }
+        let(:failed_step) { failed_plan.finalize_steps.first }
+
+        it 'pauses the process' do
+          failed_plan.status.must_equal 'paused'
+        end
+
+        it 'saves errors of actions' do
+          expected_error = {
+            'exception' => 'RuntimeError',
+            'message'   => 'Simulate error in finalize phase'
+          }
+          failed_step.error['exception'].must_equal expected_error['exception']
+          failed_step.error['message'].must_equal expected_error['message']
+          failed_step.error['backtrace'].must_be_instance_of Array
+        end
+
+        it 'allows finishing a finalize phase' do
+          failed_step.input['name'] = 'succeed'
+          Dynflow::Bus.resume(failed_plan)
+
+          failed_plan.status.must_equal 'finished'
+        end
+
+        it 'allows skipping the step' do
+          Dynflow::Bus.skip(failed_step)
+          Dynflow::Bus.resume(failed_plan)
+
+          failed_plan.status.must_equal 'finished'
+          failed_step.status.must_equal 'skipped'
+        end
+
+      end
+
+    end
   end
 end

data/test/execution_plan_test.rb

@@ -0,0 +1,121 @@
+require 'test_helper'
+
+module Dynflow
+  module ExecutionPlanTest
+    describe ExecutionPlan do
+      class Promotion < Action
+
+        def plan(repo_names, package_names)
+          repo_names.each do |repo_name|
+            plan_action(CloneRepo, {'name' => repo_name})
+          end
+
+          package_names.each do |package_name|
+            plan_action(ClonePackage, {'name' => package_name})
+          end
+
+          plan_self('actions' => repo_names.size + package_names.size)
+        end
+
+        input_format do
+          param :actions, Integer
+        end
+
+        def run; end
+
+      end
+
+      class PromotionObserver < Action
+
+        def self.subscribe
+          Promotion
+        end
+
+        def run; end
+
+      end
+
+      class CloneRepo < Action
+
+        input_format do
+          param :name, String
+        end
+
+        output_format do
+          param :id, String
+        end
+
+        def run; end
+
+      end
+
+      class ClonePackage < Action
+
+        input_format do
+          param :name, String
+        end
+
+        output_format do
+          param :id, String
+        end
+
+        def run; end
+
+      end
+
+      class UpdateIndex < Action
+
+        def self.subscribe
+          ClonePackage
+        end
+
+        def plan(input)
+          plan_action(YetAnotherAction, {'hello' => 'world'})
+          super
+        end
+
+        output_format do
+          param :indexed_name, String
+        end
+
+        def run; end
+
+      end
+
+      class YetAnotherAction < Action
+
+        input_format do
+          param :name, String
+          param :hello, String
+        end
+
+        output_format do
+          param :hello, String
+        end
+
+        def plan(arg)
+          plan_self(input.merge(arg))
+        end
+
+        def run; end
+
+      end
+
+      it "builds the execution plan" do
+        execution_plan = Promotion.plan(['zoo', 'foo'], ['elephant'])
+        expected_plan_actions =
+          [
+           CloneRepo.new('name' => 'zoo'),
+           CloneRepo.new('name' => 'foo'),
+           ClonePackage.new('name' => 'elephant'),
+           YetAnotherAction.new('name' => 'elephant', 'hello' => 'world'),
+           UpdateIndex.new('name' => 'elephant'),
+           Promotion.new('actions' => 3) ,
+           PromotionObserver.new('actions' => 3)
+          ]
+        execution_plan.run_steps.map(&:action).must_equal expected_plan_actions
+      end
+
+    end
+  end
+end