dynflow 0.1.0 → 0.2.0

data/examples/events.rb

@@ -1,71 +0,0 @@
-# Shows how Dynflow can be used for events architecture: actions are
-# subscribed to an event. When the event is triggered all the
-# subscribed actions are preformed.
-
-$:.unshift(File.expand_path('../../lib', __FILE__))
-
-require 'dynflow'
-require 'pp'
-
-# this is an event that can be triggered.
-# it has an input format so that the interface is given
-# TODO: the validations are turned off right now
-class Click < Dynflow::Action
-  input_format do
-    param :x, Integer
-    param :y, Integer
-  end
-end
-
-# SayHello subscibes to the event: it's run when the event is triggered
-class SayHello < Dynflow::Action
-
-  def self.subscribe
-    Click
-  end
-
-  def run
-    puts "Hello World"
-  end
-end
-
-# we can subscribe more actions to an event
-class SayPosition < Dynflow::Action
-
-  def self.subscribe
-    Click
-  end
-
-  def run
-    puts "your position is [#{input['x']} - #{input['y']}]"
-  end
-
-end
-
-# we can even subscribe to an action that is subscribed to an event
-class SayGoodbye < Dynflow::Action
-
-  def self.subscribe
-    SayPosition
-  end
-
-  def run
-    puts "Good Bye"
-  end
-end
-
-Click.trigger('x' => 5, 'y' => 4)
-# gives us:
-# Hello World
-# your position is [5 - 4]
-# Good Bye
-
-pp Click.plan('x' => 5, 'y' => 4).actions
-# returns the execution plan for the event (nothing is triggered):
-# [
-# since the event is action as well, it could have a run method
-# [Click:       {"x"=>5, "y"=>4} ~> {},
-#  SayHello:    {"x"=>5, "y"=>4} ~> {},
-#  SayPosition: {"x"=>5, "y"=>4} ~> {},
-#  SayGoodbye:  {"x"=>5, "y"=>4} ~> {}]
-# ]

data/examples/workflow.rb

@@ -1,140 +0,0 @@
-# Shows how Dynflow can be used for dynamic workflow definition
-# and execution.
-# In a planning phase of an action, a sub-action can be planned as
-# well.
-
-
-$:.unshift(File.expand_path('../../lib', __FILE__))
-
-require 'dynflow'
-require 'pp'
-
-class Article < Struct.new(:title, :body, :color); end
-
-class Publish < Dynflow::Action
-  input_format do
-    param :title, Integer
-    param :body, Integer
-  end
-
-  # plan can take arbitrary arguments. The args are passed from the
-  # trigger method.
-  def plan(article)
-    # we can explicitly plan a subaction
-    plan_self 'title' => article.title, 'body' => article.body
-    plan_action Review, article
-  end
-
-  def run
-    puts 'Starting'
-  end
-
-  # after all actions are run, there is a finishing phase. All the
-  # actions with +finished+ action defined are called, passing all the
-  # performed actions (with inputs and outputs)
-  def finalize(outputs)
-    printer_action = outputs.find { |o| o.is_a? Print }
-    puts "Printer says '#{printer_action.output['message']}'"
-  end
-end
-
-class Review < Dynflow::Action
-
-  # the actions can provide an output for the finalizing phase
-  output_format do
-    param :rating, Integer
-  end
-
-  # the plan method takes the same arguments as the parent action
-  def plan(article)
-    # in the input attribute the input for the parent action is
-    # available
-    plan_self input
-  end
-
-  # if no plan method given, the input is the same as the action that
-  # triggered it
-  def run
-    puts "Reviewing #{input['title']}"
-    raise "Too Short" if input['body'].size < 6
-    output['rating'] = input['body'].size
-  end
-
-  def finalize(outputs)
-    # +input+ and +output+ attributes are available in the finalizing
-    # phase as well.
-    puts "The rating was #{output['rating']}"
-  end
-
-end
-
-class Print < Dynflow::Action
-
-  input_format do
-    param :title, Integer
-    param :body, Integer
-    param :color, :boolean
-  end
-
-  output_format do
-    param :message, String
-  end
-
-  # if needed, we can subscribe to an action instead of explicitly
-  # specifying it in the plan method. Suitable for plugin architecture.
-  def self.subscribe
-    Review # sucessful review means we can print
-  end
-
-  def plan(article)
-    plan_self input.merge('color' => article.color)
-  end
-
-  def run
-    if input['color']
-      puts "Printing in color"
-    else
-      puts "Printing blank&white"
-    end
-    output['message'] = "Here you are"
-  end
-end
-
-short_article = Article.new('Short', 'Short', false)
-long_article = Article.new('Long', 'This is long', false)
-colorful_article = Article.new('Long Color', 'This is long in color', true)
-
-pp Publish.plan(short_article).actions
-# the expanded workflow is:
-# [
-#  Publish: {"title"=>"Short", "body"=>"Short"} ~> {},
-#  Review:  {"title"=>"Short", "body"=>"Short"} ~> {},
-#  Print:   {"title"=>"Short", "body"=>"Short", "color"=>false} ~> {}
-# ]
-
-begin
-  Publish.trigger(short_article)
-rescue => e
-  puts e.message
-end
-# Produces:
-# Starting
-# Reviewing Short
-# Too Short
-
-Publish.trigger(long_article)
-# Produces:
-# Starting
-# Reviewing Long
-# Printing blank&white
-# Printer says 'Here you are'
-# The rating was 12
-
-
-Publish.trigger(colorful_article)
-# Produces:
-# Starting
-# Reviewing Long Color
-# Printing in color
-# Printer says 'Here you are'
-# The rating was 21

data/lib/dynflow/bus.rb

@@ -1,168 +0,0 @@
-require 'active_support/inflector'
-require 'forwardable'
-module Dynflow
-  class Bus
-
-    class << self
-      extend Forwardable
-
-      def_delegators :impl, :trigger, :resume, :skip, :preview_execution_plan,
-        :persisted_plans, :persisted_plan, :persisted_step
-
-      def impl
-        @impl ||= Bus.new
-      end
-      attr_writer :impl
-    end
-
-    # Entry point for running an action
-    def trigger(action_class, *args)
-      execution_plan = nil
-      in_transaction_if_possible do
-        execution_plan = prepare_execution_plan(action_class, *args)
-        rollback_transaction if execution_plan.status == 'error'
-      end
-      persist_plan_if_possible(execution_plan)
-      unless execution_plan.status == 'error'
-        execute(execution_plan)
-      end
-      return execution_plan
-    end
-
-    def prepare_execution_plan(action_class, *args)
-      action_class.plan(*args)
-    end
-
-    # execution and finalizaition. Usable for resuming paused plan
-    # as well as starting from scratch
-    def execute(execution_plan)
-      run_execution_plan(execution_plan)
-      in_transaction_if_possible do
-        unless self.finalize(execution_plan)
-          rollback_transaction
-        end
-      end
-      execution_plan.persist(true)
-    end
-
-    alias_method :resume, :execute
-
-    def skip(step)
-      step.status = 'skipped'
-      step.persist
-    end
-
-    # return true if everyting worked fine
-    def finalize(execution_plan)
-      success = true
-      if execution_plan.run_steps.any? { |action| ['pending', 'error'].include?(action.status) }
-        success = false
-      else
-        execution_plan.finalize_steps.each(&:replace_references!)
-        execution_plan.finalize_steps.each do |step|
-          break unless success
-          next if %w[skipped].include?(step.status)
-
-          success = step.catch_errors do
-            step.action.finalize(execution_plan.run_steps)
-          end
-        end
-      end
-
-      if success
-        execution_plan.status = 'finished'
-      else
-        execution_plan.status = 'paused'
-      end
-      return success
-    end
-
-    # return true if the run phase finished successfully
-    def run_execution_plan(execution_plan)
-      success = true
-      execution_plan.run_steps.map do |step|
-        next step if !success || %w[skipped success].include?(step.status)
-        step.persist_before_run
-        success = step.catch_errors do
-          step.output = {}
-          step.action.run
-        end
-        step.persist_after_run
-        step
-      end
-      return success
-    end
-
-    def transaction_driver
-      nil
-    end
-
-    def in_transaction_if_possible
-      if transaction_driver
-        ret = nil
-        transaction_driver.transaction do
-          ret = yield
-        end
-        return ret
-      else
-        return yield
-      end
-    end
-
-    def rollback_transaction
-      transaction_driver.rollback if transaction_driver
-    end
-
-
-    def persistence_driver
-      nil
-    end
-
-    def persist_plan_if_possible(execution_plan)
-      if persistence_driver
-        persistence_driver.persist(execution_plan)
-      end
-    end
-
-    def persisted_plans(status = nil)
-      if persistence_driver
-        persistence_driver.persisted_plans(status)
-      else
-        []
-      end
-    end
-
-    def persisted_plan(persistence_id)
-      if persistence_driver
-        persistence_driver.persisted_plan(persistence_id)
-      end
-    end
-
-    def persisted_step(persistence_id)
-      if persistence_driver
-        persistence_driver.persisted_step(persistence_id)
-      end
-    end
-
-    # performs the planning phase of an action, but rollbacks any db
-    # changes done in this phase. Returns the resulting execution
-    # plan. Suitable for debugging.
-    def preview_execution_plan(action_class, *args)
-      unless transaction_driver
-        raise "Bus doesn't know how to run in transaction"
-      end
-
-      execution_plan = nil
-      transaction_driver.transaction do
-        execution_plan = prepare_execution_plan(action_class, *args)
-        transaction_driver.rollback
-      end
-      return execution_plan
-    end
-
-    def logger
-      @logger ||= Dynflow::Logger.new(self.class)
-    end
-
-  end
-end

data/lib/dynflow/dispatcher.rb

@@ -1,36 +0,0 @@
-module Dynflow
-  class Dispatcher
-    class << self
-      def finalizers
-        @finalizers ||= Hash.new { |h, k| h[k] = [] }
-      end
-
-      def subscribed_actions(action)
-        Action.actions.find_all do |sub_action|
-          case sub_action.subscribe
-          when Hash
-            sub_action.subscribe.keys.include?(action.class)
-          when Array
-            sub_action.subscribe.include?(action.class)
-          else
-            sub_action.subscribe == action.class
-          end
-        end
-      end
-
-      def execution_plan_for(action, *plan_args)
-        ordered_actions = subscribed_actions(action).sort_by(&:name)
-
-        execution_plan = ExecutionPlan.new
-        ordered_actions.each do |action_class|
-          sub_action_plan = action_class.plan(*plan_args) do |sub_action|
-            sub_action.input = action.input
-            sub_action.from_subscription = true
-          end
-          execution_plan.concat(sub_action_plan)
-        end
-        return execution_plan
-      end
-    end
-  end
-end

data/lib/dynflow/logger.rb

@@ -1,34 +0,0 @@
-require 'forwardable'
-require 'logger'
-
-module Dynflow
-  class Logger
-    extend Forwardable
-
-    def_delegators :@impl, :debug, :info, :warn; :error
-
-    class DummyLogger < ::Logger
-      def initialize(identifier)
-        super(nil)
-      end
-    end
-
-
-    def initialize(identifier, impl = nil)
-      @impl = self.class.logger_class.new(identifier)
-    end
-
-    class << self
-
-      def logger_class
-        unless @logger_class
-          @logger_class ||= DummyLogger
-        end
-        return @logger_class
-      end
-
-      attr_writer :logger_class
-    end
-
-  end
-end