dynflow 0.1.0 → 0.2.0

data/lib/dynflow/step.rb

@@ -1,234 +0,0 @@
-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/test/bus_test.rb

@@ -1,150 +0,0 @@
-require 'test_helper'
-require 'set'
-
-module Dynflow
-  module BusTest
-    describe "bus" 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
-        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
-
-        def finalize(outputs)
-          raise 'Simulate error in finalize phase' if input['name'] == 'fail_in_finalize'
-        end
-
-      end
-
-      it 'returns the execution plan obejct when triggering an action' do
-        Promotion.trigger(['sucess'], []).must_be_instance_of Dynflow::ExecutionPlan
-      end
-
-      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
-
-      describe 'handling errros in execution phase' do
-
-        let(:failed_plan)   { Promotion.trigger(['fail_in_run'], []) }
-        let(:failed_step) { failed_plan.run_steps.first }
-
-        it 'pauses the process' do
-          failed_plan.status.must_equal 'paused'
-        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