dynflow 0.1.0 → 0.2.0

data/lib/dynflow/action/format.rb

@@ -0,0 +1,46 @@
+module Dynflow
+
+  # Input/output format validation logic calling
+  # input_format/output_format with block acts as a setter for
+  # specifying the format. Without a block it acts as a getter
+  module Action::Format
+
+    # we don't evaluate tbe block immediatelly, but postpone it till all the
+    # action classes are loaded, because we can use them to reference output format
+    def input_format(&block)
+      case
+      when block && !@input_format_block
+        @input_format_block = block
+      when !block && @input_format_block
+        return @input_format ||= Apipie::Params::Description.define(&@input_format_block)
+      when block && @input_format_block
+        raise "The input_format has already been defined in #{self.action_class}"
+      when !block && !@input_format_block
+        if superclass.respond_to? :input_format
+          superclass.input_format
+        else
+          raise "The input_format has not been defined yet in #{self.action_class}"
+        end
+      end
+    end
+
+    def output_format(&block)
+      case
+      when block && !@output_format_block
+        @output_format_block = block
+      when !block && @output_format_block
+        return @output_format ||= Apipie::Params::Description.define(&@output_format_block)
+      when block && @output_format_block
+        raise "The output_format has already been defined in #{self.action_class}"
+      when !block && !@output_format_block
+        if superclass.respond_to? :output_format
+          superclass.output_format
+        else
+          raise "The output_format has not been defined yet in #{self.action_class}"
+        end
+      end
+    end
+
+  end
+end
+

data/lib/dynflow/action/missing.rb

@@ -0,0 +1,26 @@
+module Dynflow
+  # for cases the serialized action was renamed and it's not available
+  # in the code base anymore.
+  class Action::Missing < Dynflow::Action
+
+    def self.generate(action_name)
+      Class.new(self).tap do |klass|
+        klass.singleton_class.send(:define_method, :name) do
+          action_name
+        end
+      end
+    end
+
+    def plan(*args)
+      raise StandardError, "This action is not meant to be planned"
+    end
+
+    def run
+      raise StandardError, "This action is not meant to be run"
+    end
+
+    def finalize
+      raise StandardError, "This action is not meant to be finalized"
+    end
+  end
+end

data/lib/dynflow/action/plan_phase.rb

@@ -0,0 +1,85 @@
+module Dynflow
+  module Action::PlanPhase
+    attr_reader :execution_plan, :trigger
+
+    def self.included(base)
+      base.attr_indifferent_access_hash :input
+    end
+
+    def initialize(attributes, execution_plan, trigger)
+      super attributes, execution_plan.world
+      plan_step_id || raise(ArgumentError, 'missing plan_step_id')
+
+      self.input      = attributes[:input] || {}
+      @execution_plan = Type! execution_plan, ExecutionPlan
+      @plan_step_id   = plan_step_id
+      @trigger        = Type! trigger, Action, NilClass
+    end
+
+    def execute(*args)
+      self.state = :running
+      save_state
+      with_error_handling do
+        execution_plan.switch_flow(Flows::Concurrence.new([])) do
+          plan(*args)
+        end
+
+        subscribed_actions = world.subscribed_actions(self.action_class)
+        if subscribed_actions.any?
+          # we encapsulate the flow for this action into a concurrence and
+          # add the subscribed flows to it as well.
+          trigger_flow = execution_plan.current_run_flow.sub_flows.pop
+          execution_plan.switch_flow(Flows::Concurrence.new([trigger_flow].compact)) do
+            subscribed_actions.each do |action_class|
+              new_plan_step = execution_plan.add_plan_step(action_class, self)
+              new_plan_step.execute(execution_plan, self, *args)
+            end
+          end
+        end
+      end
+    end
+
+    def to_hash
+      super.merge recursive_to_hash(input: input)
+    end
+
+    # DSL for plan method
+
+    def concurrence(&block)
+      execution_plan.switch_flow(Flows::Concurrence.new([]), &block)
+    end
+
+    def sequence(&block)
+      execution_plan.switch_flow(Flows::Sequence.new([]), &block)
+    end
+
+    def plan_self(input)
+      @input = input.with_indifferent_access
+      if self.respond_to?(:run)
+        run_step          = execution_plan.add_run_step(self)
+        @run_step_id      = run_step.id
+        @output_reference = ExecutionPlan::OutputReference.new(run_step.id, id)
+      end
+
+      if self.respond_to?(:finalize)
+        finalize_step     = execution_plan.add_finalize_step(self)
+        @finalize_step_id = finalize_step.id
+      end
+
+      return self # to stay consistent with plan_action
+    end
+
+    def plan_action(action_class, *args)
+      execution_plan.add_plan_step(action_class, self).execute(execution_plan, nil, *args)
+    end
+
+    def output
+      unless @output_reference
+        raise 'plan_self has to be invoked before being able to reference the output'
+      end
+
+      return @output_reference
+    end
+
+  end
+end

data/lib/dynflow/action/polling.rb

@@ -0,0 +1,49 @@
+module Dynflow
+  module Action::Polling
+
+    Poll = Algebrick.atom
+
+    def run(event = nil)
+      case event
+      when nil
+        self.external_task = invoke_external_task
+        suspend_and_ping
+      when Poll
+        self.external_task = poll_external_task
+        suspend_and_ping unless done?
+      else
+        raise "unrecognized event #{event}"
+      end
+    end
+
+    def external_task
+      raise NotImplementedError
+    end
+
+    def done?
+      raise NotImplementedError
+    end
+
+    private
+
+    def invoke_external_task
+      raise NotImplementedError
+    end
+
+    def external_task=(external_task_data)
+      raise NotImplementedError
+    end
+
+    def poll_external_task
+      raise NotImplementedError
+    end
+
+    def suspend_and_ping
+      suspend { |suspended_action| world.clock.ping suspended_action, poll_interval, Poll }
+    end
+
+    def poll_interval
+      0.5
+    end
+  end
+end

data/lib/dynflow/action/presenter.rb

@@ -0,0 +1,51 @@
+module Dynflow
+
+  # This module is used for providing access to the results of the
+  # action. It's used in ExecutionPlan#actions to provide access to
+  # data of the actions in the execution plan.
+  #
+  # It also defines helper methods to extract usable data from the action itself,
+  # as well as other actions involved in the execution plan. One action (usually the
+  # main trigger, can use them to collect data across the whole execution_plan)
+  module Action::Presenter
+
+    def self.included(base)
+      base.send(:attr_reader, :input)
+      base.send(:attr_reader, :output)
+      base.send(:attr_reader, :all_actions)
+    end
+
+    def self.load(execution_plan, action_id, involved_steps, all_actions)
+      persistence_adapter = execution_plan.world.persistence.adapter
+      attributes          = persistence_adapter.load_action(execution_plan.id,
+                                                            action_id)
+      raise ArgumentError, 'missing :class' unless attributes[:class]
+      Action.constantize(attributes[:class]).presenter.new(attributes,
+                                                           involved_steps,
+                                                           all_actions)
+    end
+
+    def to_hash
+      recursive_to_hash(action: action_class,
+                        input:  input,
+                        output: output)
+    end
+
+    # @param [Hash] attributes - the action attributes, usually loaded form persistence layer
+    # @param [Array<ExecutionPlan::Steps::AbstractStep> - steps that operate on top of the action
+    # @param [Array<Action::Presenter>] - array of all the actions involved in the execution plan
+    #                                     with this action. Allows to access data from other actions
+    def initialize(attributes, involved_steps, all_actions)
+      @execution_plan_id = attributes[:execution_plan_id] || raise(ArgumentError, 'missing execution_plan_id')
+      @id                = attributes[:id] || raise(ArgumentError, 'missing id')
+
+      # TODO: use the involved_steps to provide summary state and error for the action
+      @involved_steps    = involved_steps
+      @all_actions       = all_actions
+
+      indifferent_access_hash_variable_set :input, attributes[:input]
+      indifferent_access_hash_variable_set :output, attributes[:output] || {}
+    end
+
+  end
+end

data/lib/dynflow/action/progress.rb

@@ -0,0 +1,62 @@
+module Dynflow
+
+  # Methods for specifying the progress of the action
+  # the +*_progress+ methods should return number in 0..1.
+  # The weight is there to increase/decrease the portion of this task
+  # in the context of other tasks in execution plan. Normal action has
+  # weight 1.
+  #
+  # The +*_progress+ is run only when the action is in running/suspend state. Otherwise
+  # the progress is 1 for success/skipped actions and 0 for errorneous ones.
+  module Action::Progress
+
+    def run_progress
+      0.5
+    end
+
+    def run_progress_weight
+      1
+    end
+
+    def finalize_progress
+      0.5
+    end
+
+    def finalize_progress_weight
+      1
+    end
+
+    # this method is not intended to be overriden. Use +{run, finalize}_progress+
+    # variants instead
+    def progress_done
+      case self.state
+      when :success, :skipped
+        1
+      when :running, :suspended
+        case self
+        when Action::RunPhase
+          run_progress
+        when Action::FinalizePhase
+          finalize_progress
+        else
+          raise "Calculating progress for this phase is not supported"
+        end
+      else
+        0
+      end
+    end
+
+    def progress_weight
+      case self
+      when Action::RunPhase
+        run_progress_weight
+      when Action::FinalizePhase
+        finalize_progress_weight
+      else
+        raise "Calculating progress for this phase is not supported"
+      end
+    end
+
+  end
+end
+

data/lib/dynflow/action/run_phase.rb

@@ -0,0 +1,43 @@
+module Dynflow
+  module Action::RunPhase
+
+    def self.included(base)
+      base.send(:include, Action::FlowPhase)
+      base.attr_indifferent_access_hash :output
+    end
+
+    SUSPEND = Object.new
+
+    def execute(event)
+      @world.logger.debug "step #{execution_plan_id}:#{@step.id} got event #{event}" if event
+      case
+      when state == :running
+        raise NotImplementedError, 'recovery after restart is not implemented'
+
+      when [:pending, :error, :suspended].include?(state)
+        if [:pending, :error].include?(state) && event
+          raise 'event can be processed only when in suspended state'
+        end
+
+        self.state = :running
+        save_state
+        with_error_handling do
+          result = catch(SUSPEND) { event ? run(event) : run }
+          if result == SUSPEND
+            self.state = :suspended
+          end
+        end
+
+      else
+        raise "wrong state #{state} when event:#{event}"
+      end
+    end
+
+    # DSL for run
+
+    def suspend(&block)
+      block.call Action::Suspended.new self if block
+      throw SUSPEND, SUSPEND
+    end
+  end
+end

data/lib/dynflow/action/suspended.rb

@@ -0,0 +1,21 @@
+module Dynflow
+  class Action::Suspended
+    attr_reader :execution_plan_id, :step_id
+
+    def initialize(action)
+      @world             = action.world
+      @execution_plan_id = action.execution_plan_id
+      @step_id           = action.run_step_id
+    end
+
+    def event(event, future = Future.new)
+      @world.event execution_plan_id, step_id, event, future
+    end
+
+    def <<(event)
+      event event
+    end
+
+    alias_method :ask, :event
+  end
+end

data/lib/dynflow/clock.rb

@@ -0,0 +1,133 @@
+module Dynflow
+  require 'set'
+
+  class Clock < MicroActor
+
+    include Algebrick::Types
+
+    Tick  = Algebrick.atom
+    Timer = Algebrick.type do
+      fields! who:   Object, # to ping back
+              when:  Time, # to deliver
+              what:  Maybe[Object], # to send
+              where: Symbol # it should be delivered, which method
+    end
+
+    module Timer
+      def self.[](*fields)
+        super(*fields).tap { |v| Match! v.who, -> who { who.respond_to? v.where } }
+      end
+
+      include Comparable
+
+      def <=>(other)
+        Type! other, self.class
+        self.when <=> other.when
+      end
+
+      def apply
+        if Algebrick::Some[Object] === what
+          who.send where, what.value
+        else
+          who.send where
+        end
+      end
+    end
+
+    Pills = Algebrick.type do
+      variants None = atom,
+               Took = atom,
+               Pill = type { fields Float }
+    end
+
+    def ping(who, time, with_what = nil, where = :<<)
+      Type! time, Time, Numeric
+      time  = Time.now + time if time.is_a? Numeric
+      timer = Timer[who, time, with_what.nil? ? None : Some[Object][with_what], where]
+      if terminated?
+        Thread.new do
+          sleep [timer.when - Time.now, 0].max
+          timer.apply
+        end
+      else
+        self << timer
+      end
+    end
+
+    private
+
+    def delayed_initialize
+      @timers        = SortedSet.new
+      @sleeping_pill = None
+      @sleep_barrier = Mutex.new
+      @sleeper       = Thread.new { sleeping }
+      Thread.pass until @sleep_barrier.locked? || @sleeper.status == 'sleep'
+    end
+
+    def termination
+      @sleeper.kill
+      super
+    end
+
+    def on_message(message)
+      match message,
+            Tick >-> do
+              run_ready_timers
+              sleep_to first_timer
+            end,
+            ~Timer >-> timer do
+              @timers.add timer
+              if @timers.size == 1
+                sleep_to timer
+              else
+                wakeup if timer == first_timer
+              end
+            end
+    end
+
+    def run_ready_timers
+      while first_timer && first_timer.when <= Time.now
+        first_timer.apply
+        @timers.delete(first_timer)
+      end
+    end
+
+    def first_timer
+      @timers.first
+    end
+
+    def wakeup
+      while @sleep_barrier.synchronize { Pill === @sleeping_pill }
+        Thread.pass
+      end
+      @sleep_barrier.synchronize do
+        @sleeper.wakeup if Took === @sleeping_pill
+      end
+    end
+
+    def sleep_to(timer)
+      return unless timer
+      sec = [timer.when - Time.now, 0.0].max
+      @sleep_barrier.synchronize do
+        @sleeping_pill = Pill[sec]
+        @sleeper.wakeup
+      end
+    end
+
+    def sleeping
+      @sleep_barrier.synchronize do
+        loop do
+          @sleeping_pill = None
+          @sleep_barrier.sleep
+          pill           = @sleeping_pill
+          @sleeping_pill = Took
+          @sleep_barrier.sleep pill.value
+          self << Tick
+        end
+      end
+    end
+
+  end
+end
+
+