dynflow 0.1.0 → 0.2.0

data/examples/web_console.rb

@@ -0,0 +1,29 @@
+# Demo for Dynflow web console
+# usage: ruby web_console.rb
+
+$:.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'dynflow'
+require_relative 'orchestrate'
+
+world = Dynflow::SimpleWorld.new
+
+require 'dynflow/web_console'
+dynflow_console = Dynflow::WebConsole.setup do
+  set :world, world
+end
+
+3.times do
+  Thread.new do
+    3.times do
+      world.trigger(Orchestrate::CreateInfrastructure)
+    end
+  end
+end
+
+puts <<MESSAGE
+=============================================
+  See the console at http://localhost:4567/
+=============================================
+MESSAGE
+dynflow_console.run!

data/lib/dynflow.rb

@@ -1,11 +1,32 @@
+require 'apipie-params'
+require 'algebrick'
+require 'thread'
+require 'set'
 require 'active_support/core_ext/hash/indifferent_access'
-require 'dynflow/logger'
-require 'dynflow/execution_plan'
-require 'dynflow/dispatcher'
-require 'dynflow/bus'
-require 'dynflow/step'
-require 'dynflow/action'
 
+# TODO validate in/output, also validate unknown keys
+# TODO performance testing, how many actions will it handle?
+# TODO profiling, find bottlenecks
 module Dynflow
 
+  class Error < StandardError
+  end
+
+  require 'dynflow/future'
+  require 'dynflow/micro_actor'
+  require 'dynflow/serializable'
+  require 'dynflow/clock'
+  require 'dynflow/stateful'
+  require 'dynflow/transaction_adapters'
+  require 'dynflow/persistence'
+  require 'dynflow/action'
+  require 'dynflow/flows'
+  require 'dynflow/execution_plan'
+  require 'dynflow/listeners'
+  require 'dynflow/executors'
+  require 'dynflow/logger_adapters'
+  require 'dynflow/world'
+  require 'dynflow/simple_world'
+  require 'dynflow/daemon'
+
 end

data/lib/dynflow/action.rb

@@ -1,130 +1,238 @@
+require 'active_support/inflector'
+
 module Dynflow
-  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 :execution_plan, :from_subscription, :input, :output
+  # TODO unify phases into one class, check what can be called in what phase at runtime
+  class Action < Serializable
+    include Algebrick::TypeCheck
+    include Algebrick::Matching
 
-    def self.inherited(child)
-      self.actions << child
+    require 'dynflow/action/format'
+    extend Format
+
+    require 'dynflow/action/progress'
+    include Progress
+
+    require 'dynflow/action/suspended'
+    require 'dynflow/action/missing'
+
+    require 'dynflow/action/plan_phase'
+    require 'dynflow/action/flow_phase'
+    require 'dynflow/action/run_phase'
+    require 'dynflow/action/finalize_phase'
+
+    require 'dynflow/action/presenter'
+    require 'dynflow/action/polling'
+    require 'dynflow/action/cancellable_polling'
+
+    # Override this to extend the phase classes
+    def self.phase_modules
+      { plan_phase:     [PlanPhase],
+        run_phase:      [RunPhase],
+        finalize_phase: [FinalizePhase],
+        presenter:      [Presenter] }.freeze
+    end
+
+    phase_modules.each do |phase_name, _|
+      define_singleton_method phase_name do
+        instance_variable_get :"@#{phase_name}" or
+            instance_variable_set :"@#{phase_name}", __send__("create_#{phase_name}")
+      end
+
+      define_singleton_method "create_#{phase_name}" do
+        generate_phase(*phase_modules[phase_name])
+      end
     end
 
-    def self.actions
-      @actions ||= []
+    def self.generate_phase(*modules)
+      Class.new(self) { modules.each { |m| include m } }
     end
 
+    def self.phase?
+      [PlanPhase, RunPhase, FinalizePhase, Presenter].any? { |phase| self < phase }
+    end
+
+    def self.all_children
+      #noinspection RubyArgCount
+      children.
+          inject(children) { |children, child| children + child.all_children }.
+          select { |ch| !ch.phase? }
+    end
+
+    # FIND define subscriptions in world independent on action's classes,
+    #   limited only by in/output formats
+    # @return [nil, Class] a child of Action
     def self.subscribe
       nil
     end
 
-    def self.require
-      nil
+    def self.attr_indifferent_access_hash(*names)
+      attr_reader(*names)
+      names.each do |name|
+        define_method("#{name}=") { |v| indifferent_access_hash_variable_set name, v }
+      end
     end
 
-    def initialize(input, output = nil)
-      # for preparation phase
-      @execution_plan = ExecutionPlan.new
+    def indifferent_access_hash_variable_set(name, value)
+      Type! value, Hash
+      instance_variable_set :"@#{name}", value.with_indifferent_access
+    end
 
-      @input = input
-      @output = output || {}
+    def self.from_hash(hash, phase, *args)
+      check_class_key_present hash
+      raise ArgumentError, "unknown phase '#{phase}'" unless [:plan_phase, :run_phase, :finalize_phase].include? phase
+      Action.constantize(hash[:class]).send(phase).new_from_hash(hash, *args)
     end
 
+    attr_reader :world, :execution_plan_id, :id, :plan_step_id, :run_step_id, :finalize_step_id
 
-    def ==(other)
-      [self.class.name, self.input, self.output] ==
-        [other.class.name, other.input, other.output]
-    end
+    def initialize(attributes, world)
+      raise "It's not expected to initialize this class directly, use phases." unless self.class.phase?
+
+      Type! attributes, Hash
 
-    def inspect
-      "#{self.class.name}: #{input.inspect} ~> #{output.inspect}"
+      @world             = Type! world, World
+      @step              = Type! attributes[:step], ExecutionPlan::Steps::Abstract
+      @execution_plan_id = attributes[:execution_plan_id] || raise(ArgumentError, 'missing execution_plan_id')
+      @id                = attributes[:id] || raise(ArgumentError, 'missing id')
+      @plan_step_id      = attributes[:plan_step_id]
+      @run_step_id       = attributes[:run_step_id]
+      @finalize_step_id  = attributes[:finalize_step_id]
     end
 
-    # the block contains the expression in Apipie::Params::DSL
-    # describing the format of message
-    def self.input_format(&block)
-      if block
-        @input_format_block = block
-      elsif @input_format_block
-        @input_format ||= Apipie::Params::Description.define(&@input_format_block)
+    def self.action_class
+      # superclass because we run this from the phases of action class
+      if phase?
+        superclass
       else
-        nil
+        self
       end
     end
 
-    # the block contains the expression in Apipie::Params::DSL
-    # describing the format of message
-    def self.output_format(&block)
-      if block
-        @output_format_block = block
-      elsif @output_format_block
-        @output_format ||= Apipie::Params::Description.define(&@output_format_block)
-      else
-        nil
-      end
+    def self.constantize(action_name)
+      action_name.constantize
+    rescue NameError
+      Action::Missing.generate(action_name)
     end
 
-    def self.trigger(*args)
-      Dynflow::Bus.trigger(self, *args)
+    def action_logger
+      world.action_logger
     end
 
-    def self.plan(*args)
-      action = self.new({})
-      yield action if block_given?
+    def action_class
+      self.class.action_class
+    end
 
-      plan_step = Step::Plan.new(action)
-      action.execution_plan.plan_steps << plan_step
-      plan_step.catch_errors do
-        action.plan(*args)
-      end
+    def to_hash
+      recursive_to_hash class:             action_class.name,
+                        execution_plan_id: execution_plan_id,
+                        id:                id,
+                        plan_step_id:      plan_step_id,
+                        run_step_id:       run_step_id,
+                        finalize_step_id:  finalize_step_id
+    end
 
-      if action.execution_plan.failed_steps.any?
-        action.execution_plan.status = 'error'
-      else
-        action.add_subscriptions(*args)
-      end
+    # @api private
+    # @return [Array<Fixnum>] - ids of steps referenced from action
+    def required_step_ids(value = self.input)
+      ret = case value
+            when Hash
+              value.values.map { |val| required_step_ids(val) }
+            when Array
+              value.map { |val| required_step_ids(val) }
+            when ExecutionPlan::OutputReference
+              value.step_id
+            else
+              # no reference hidden in this arg
+            end
+      return Array(ret).flatten.compact
+    end
 
-      action.execution_plan
+    def state
+      @step.state
     end
 
-    # for subscribed actions: by default take the input of the
-    # subscribed action
+    def error
+      @step.error
+    end
+
+    protected
+
+    def state=(state)
+      @world.logger.debug "step #{execution_plan_id}:#{@step.id} #{self.state} >> #{state}"
+      @step.state = state
+    end
+
+    def save_state
+      @step.save
+    end
+
+    # @override
     def plan(*args)
-      if from_subscription
+      if trigger
         # if the action is triggered by subscription, by default use the
-        # input of parent action
-        plan_self(self.input)
+        # input of parent action.
+        # should be replaced by referencing the input from input format
+        plan_self(input.merge(trigger.input))
       else
         # in this case, the action was triggered by plan_action. Use
         # the argument specified there.
-        plan_self(args.first)
+        plan_self(*args)
       end
+      self
     end
 
-    def plan_self(input)
-      self.input = input
-      @execution_plan << self
+    def self.new_from_hash(hash, world)
+      new(hash, world)
     end
 
-    def plan_action(action_class, *args)
-      sub_action_plan = action_class.plan(*args) do |action|
-        action.input = self.input
-      end
-      @execution_plan.concat(sub_action_plan)
+    private
+
+    ERRORING = Object.new
+
+    # DSL to terminate action execution and set it to error
+    def error!(error)
+      set_error(error)
+      throw ERRORING
     end
 
-    def add_subscriptions(*plan_args)
-      @execution_plan.concat(Dispatcher.execution_plan_for(self, *plan_args))
+    def with_error_handling(&block)
+      raise "wrong state #{self.state}" unless self.state == :running
+
+      begin
+        catch(ERRORING) { block.call }
+      rescue Exception => error
+        set_error(error)
+        # reraise low-level exceptions
+        raise error unless Type? error, StandardError, ScriptError
+      end
+
+      case self.state
+      when :running
+        self.state = :success
+      when :suspended, :error
+      else
+        raise "wrong state #{self.state}"
+      end
     end
 
-    def execution_plan
-      @execution_plan
+    def set_error(error)
+      Type! error, Exception, String
+      action_logger.error error
+      self.state  = :error
+      @step.error = if error.is_a?(String)
+                      ExecutionPlan::Steps::Error.new(nil, error, nil)
+                    else
+                      ExecutionPlan::Steps::Error.new(error.class.name, error.message, error.backtrace)
+                    end
     end
 
-    def validate!
-      self.clss.output_format.validate!(output)
+    def self.inherited(child)
+      children << child
     end
 
+    def self.children
+      @children ||= []
+    end
   end
 end

data/lib/dynflow/action/cancellable_polling.rb

@@ -0,0 +1,18 @@
+module Dynflow
+  module Action::CancellablePolling
+    include Action::Polling
+    Cancel = Algebrick.atom
+
+    def run(event = nil)
+      if Cancel === event
+        self.external_task = cancel_external_task
+      else
+        super event
+      end
+    end
+
+    def cancel_external_task
+      NotImplementedError
+    end
+  end
+end

data/lib/dynflow/action/finalize_phase.rb

@@ -0,0 +1,18 @@
+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
+        finalize
+      end
+    end
+
+  end
+end

data/lib/dynflow/action/flow_phase.rb

@@ -0,0 +1,44 @@
+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