dynflow 0.0.1 → 0.1.0

data/Gemfile

@@ -1,9 +1,17 @@
 source 'https://rubygems.org'
 
-gem 'multi_json'
-gem 'activesupport'
-gem 'apipie-params', :git => '/home/inecas/Projects/apipie-params'
+gemspec
 
-group :development do
+group :development, :test do
   gem 'pry'
 end
+
+group :test do
+  gem 'database_cleaner'
+end
+
+group :engine do
+  gem "rails", "~> 3.2.8"
+  gem "jquery-rails"
+  gem "sqlite3"
+end

data/README.md

@@ -115,12 +115,12 @@ One can generate the execution plan for an action without actually
 running it:
 
 ```ruby
-pp Publish.plan(short_article)
+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}]
+#  Publish: {"title"=>"Short", "body"=>"Short"} ~> {},
+#  Review:  {"title"=>"Short", "body"=>"Short"} ~> {},
+#  Print:   {"title"=>"Short", "body"=>"Short", "color"=>false} ~> {}
 # ]
 ```
 

data/Rakefile

@@ -1,7 +1,15 @@
 require 'rake/testtask'
+require 'fileutils'
 
+desc "Generic tests"
 Rake::TestTask.new do |t|
   t.libs << 'lib' << 'test'
-  t.test_files = FileList['test/**/*_test.rb']
+  t.test_files = FileList['test/*_test.rb']
   t.verbose = true
 end
+
+namespace :test do
+  desc "All tests"
+  task :all => [:test] do
+  end
+end

data/dynflow.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |s|
   s.version     = Dynflow::VERSION
   s.authors     = ["Ivan Necas"]
   s.email       = ["inecas@redhat.com"]
-  s.homepage    = "http://github.com/iNecas/eventum"
+  s.homepage    = "http://github.com/iNecas/dynflow"
   s.summary     = "DYNamic workFLOW engine"
   s.description = "Generate and executed workflows dynamically based "+
                   "on input data and leave it open for others to jump into it as well"

data/examples/events.rb

@@ -60,12 +60,12 @@ Click.trigger('x' => 5, 'y' => 4)
 # your position is [5 - 4]
 # Good Bye
 
-pp Click.plan('x' => 5, 'y' => 4)
+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}]
+# [Click:       {"x"=>5, "y"=>4} ~> {},
+#  SayHello:    {"x"=>5, "y"=>4} ~> {},
+#  SayPosition: {"x"=>5, "y"=>4} ~> {},
+#  SayGoodbye:  {"x"=>5, "y"=>4} ~> {}]
 # ]

data/examples/workflow.rb

@@ -104,12 +104,12 @@ 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)
+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}]
+#  Publish: {"title"=>"Short", "body"=>"Short"} ~> {},
+#  Review:  {"title"=>"Short", "body"=>"Short"} ~> {},
+#  Print:   {"title"=>"Short", "body"=>"Short", "color"=>false} ~> {}
 # ]
 
 begin

data/lib/dynflow.rb

@@ -1,9 +1,9 @@
+require 'active_support/core_ext/hash/indifferent_access'
 require 'dynflow/logger'
-require 'dynflow/message'
+require 'dynflow/execution_plan'
 require 'dynflow/dispatcher'
 require 'dynflow/bus'
-require 'dynflow/orch_request'
-require 'dynflow/orch_response'
+require 'dynflow/step'
 require 'dynflow/action'
 
 module Dynflow

data/lib/dynflow/action.rb

@@ -1,11 +1,11 @@
 module Dynflow
-  class Action < Message
+  class Action
 
     # only for the planning phase: flag indicating that the action
     # was triggered from subscription. If so, the implicit plan
     # method uses the input of the parent action. Otherwise, the
     # argument the plan_action is used as default.
-    attr_accessor :from_subscription
+    attr_accessor :execution_plan, :from_subscription, :input, :output
 
     def self.inherited(child)
       self.actions << child
@@ -23,24 +23,22 @@ module Dynflow
       nil
     end
 
-    def initialize(input, output = {})
+    def initialize(input, output = nil)
       # for preparation phase
-      @execution_plan = []
+      @execution_plan = ExecutionPlan.new
 
-      output ||= {}
-      super('input' => input, 'output' => output)
+      @input = input
+      @output = output || {}
     end
 
-    def input
-      @data['input']
-    end
 
-    def input=(input)
-      @data['input'] = input
+    def ==(other)
+      [self.class.name, self.input, self.output] ==
+        [other.class.name, other.input, other.output]
     end
 
-    def output
-      @data['output']
+    def inspect
+      "#{self.class.name}: #{input.inspect} ~> #{output.inspect}"
     end
 
     # the block contains the expression in Apipie::Params::DSL
@@ -68,14 +66,25 @@ module Dynflow
     end
 
     def self.trigger(*args)
-      Dynflow::Bus.trigger(self.plan(*args))
+      Dynflow::Bus.trigger(self, *args)
     end
 
     def self.plan(*args)
       action = self.new({})
       yield action if block_given?
-      action.plan(*args)
-      action.add_subscriptions(*args)
+
+      plan_step = Step::Plan.new(action)
+      action.execution_plan.plan_steps << plan_step
+      plan_step.catch_errors do
+        action.plan(*args)
+      end
+
+      if action.execution_plan.failed_steps.any?
+        action.execution_plan.status = 'error'
+      else
+        action.add_subscriptions(*args)
+      end
+
       action.execution_plan
     end
 
@@ -95,7 +104,7 @@ module Dynflow
 
     def plan_self(input)
       self.input = input
-      @execution_plan << [self.class, input]
+      @execution_plan << self
     end
 
     def plan_action(action_class, *args)
@@ -114,7 +123,7 @@ module Dynflow
     end
 
     def validate!
-      self.clss.output_format.validate!(@data['output'])
+      self.clss.output_format.validate!(output)
     end
 
   end

data/lib/dynflow/bus.rb

@@ -6,51 +6,163 @@ module Dynflow
     class << self
       extend Forwardable
 
-      def_delegators :impl, :wait_for, :process, :trigger, :finalize
+      def_delegators :impl, :trigger, :resume, :skip, :preview_execution_plan,
+        :persisted_plans, :persisted_plan, :persisted_step
 
       def impl
-        @impl ||= Bus::MemoryBus.new
+        @impl ||= Bus.new
       end
       attr_writer :impl
     end
 
-    def finalize(outputs)
-      outputs.each do |action|
-        if action.respond_to?(:finalize)
-          action.finalize(outputs)
-        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 process(action_class, input, output = nil)
-      # TODO: here goes the message validation
-      action = action_class.new(input, output)
-      action.run if action.respond_to?(:run)
-      return action
+    def prepare_execution_plan(action_class, *args)
+      action_class.plan(*args)
     end
 
-    def wait_for(*args)
-      raise NotImplementedError, 'Abstract method'
+    # 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
 
-    def logger
-      @logger ||= Dynflow::Logger.new(self.class)
+    alias_method :resume, :execute
+
+    def skip(step)
+      step.status = 'skipped'
+      step.persist
     end
 
-    class MemoryBus < Bus
+    # 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
 
-      def initialize
-        super
+    # 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 trigger(execution_plan)
-        outputs = []
-        execution_plan.each do |(action_class, input)|
-          outputs << self.process(action_class, input)
+    def in_transaction_if_possible
+      if transaction_driver
+        ret = nil
+        transaction_driver.transaction do
+          ret = yield
         end
-        self.finalize(outputs)
+        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

@@ -21,7 +21,7 @@ module Dynflow
       def execution_plan_for(action, *plan_args)
         ordered_actions = subscribed_actions(action).sort_by(&:name)
 
-        execution_plan = []
+        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

data/lib/dynflow/execution_plan.rb

@@ -0,0 +1,56 @@
+require 'forwardable'
+
+module Dynflow
+  class ExecutionPlan
+
+    attr_reader :plan_steps, :run_steps, :finalize_steps
+
+    # allows storing and reloading the execution plan to something
+    # more persistent than memory
+    attr_accessor :persistence
+    # one of [new, running, paused, aborted, finished]
+    attr_accessor :status
+
+    extend Forwardable
+
+    def initialize(plan_steps = [], run_steps = [], finalize_steps = [])
+      @plan_steps = plan_steps
+      @run_steps = run_steps
+      @finalize_steps = finalize_steps
+      @status = 'new'
+    end
+
+    def steps
+      self.plan_steps + self.run_steps + self.finalize_steps
+    end
+
+    def failed_steps
+      self.steps.find_all { |step| step.status == 'error' }
+    end
+
+    def <<(action)
+      run_step = Step::Run.new(action)
+      @run_steps << run_step if action.respond_to? :run
+      @finalize_steps << Step::Finalize.new(run_step) if action.respond_to? :finalize
+    end
+
+    def concat(other)
+      self.plan_steps.concat(other.plan_steps)
+      self.run_steps.concat(other.run_steps)
+      self.finalize_steps.concat(other.finalize_steps)
+      self.status = other.status
+    end
+
+    # update the persistence based on the current status
+    def persist(include_steps = false)
+      if @persistence
+        @persistence.persist(self)
+
+        if include_steps
+          steps.each { |step| step.persist }
+        end
+      end
+    end
+
+  end
+end