dynflow 0.1.0 → 0.2.0

data/lib/dynflow/testing/dummy_executor.rb

@@ -0,0 +1,29 @@
+module Dynflow
+  module Testing
+    class DummyExecutor
+      attr_reader :world
+
+      def initialize(world)
+        @world             = world
+        @events_to_process = []
+      end
+
+      def event(execution_plan_id, step_id, event, future = Future.new)
+        @events_to_process << [execution_plan_id, step_id, event, future]
+      end
+
+      def progress
+        events = @events_to_process.dup
+        clear
+        events.each do |execution_plan_id, step_id, event, future|
+          future.resolve true
+          world.action.execute event
+        end
+      end
+
+      def clear
+        @events_to_process.clear
+      end
+    end
+  end
+end

data/lib/dynflow/testing/dummy_planned_action.rb

@@ -0,0 +1,18 @@
+module Dynflow
+  module Testing
+    class DummyPlannedAction
+      attr_accessor :output, :plan_input
+      include Mimic
+
+      def initialize(klass)
+        mimic! klass
+        @output = ExecutionPlan::OutputReference.new(Testing.get_id, Testing.get_id)
+      end
+
+      def execute(execution_plan, event, *args)
+        @plan_input = args
+        self
+      end
+    end
+  end
+end

data/lib/dynflow/testing/dummy_step.rb

@@ -0,0 +1,19 @@
+module Dynflow
+  module Testing
+    class DummyStep
+      extend Mimic
+      mimic! ExecutionPlan::Steps::Abstract
+
+      attr_accessor :state, :error
+      attr_reader :id
+
+      def initialize
+        @state = :pending
+        @id    = Testing.get_id
+      end
+
+      def save
+      end
+    end
+  end
+end

data/lib/dynflow/testing/dummy_world.rb

@@ -0,0 +1,33 @@
+module Dynflow
+  module Testing
+    class DummyWorld
+      extend Mimic
+      mimic! World
+
+      attr_reader :clock, :executor
+      attr_accessor :action
+
+      def initialize
+        @logger_adapter = Testing.logger_adapter
+        @clock          = ManagedClock.new
+        @executor       = DummyExecutor.new(self)
+      end
+
+      def action_logger
+        @logger_adapter.action_logger
+      end
+
+      def logger
+        @logger_adapter.dynflow_logger
+      end
+
+      def subscribed_actions(klass)
+        []
+      end
+
+      def event(execution_plan_id, step_id, event, future = Future.new)
+        executor.event execution_plan_id, step_id, event, future
+      end
+    end
+  end
+end

data/lib/dynflow/testing/factories.rb

@@ -0,0 +1,83 @@
+module Dynflow
+  module Testing
+    module Factories
+      include Algebrick::TypeCheck
+
+      # @return [Action::PlanPhase]
+      def create_action(action_class, trigger = nil)
+        execution_plan = DummyExecutionPlan.new
+        step           = DummyStep.new
+        action_class.plan_phase.new(
+            { step:              DummyStep.new,
+              execution_plan_id: execution_plan.id,
+              id:                Testing.get_id,
+              plan_step_id:      step.id },
+            execution_plan, trigger)
+      end
+
+      # @return [Action::PlanPhase]
+      def plan_action(plan_action, *args, &block)
+        Type! plan_action, Dynflow::Action::PlanPhase
+
+        plan_action.execute *args, &block
+        raise plan_action.error if plan_action.error
+        plan_action
+      end
+
+      def create_and_plan_action(action_class, *args, &block)
+        plan_action create_action(action_class), *args, &block
+      end
+
+      # @return [Action::RunPhase]
+      def run_action(plan_action, event = nil, &stubbing)
+        Type! plan_action, Dynflow::Action::PlanPhase, Dynflow::Action::RunPhase
+        step       = DummyStep.new
+        run_action = if Dynflow::Action::PlanPhase === plan_action
+                       plan_action.action_class.run_phase.new(
+                           { step:              step,
+                             execution_plan_id: plan_action.execution_plan_id,
+                             id:                plan_action.id,
+                             plan_step_id:      plan_action.plan_step_id,
+                             run_step_id:       step.id,
+                             input:             plan_action.input },
+                           plan_action.world)
+
+                     else
+                       plan_action
+                     end
+
+        run_action.world.action ||= run_action
+        run_action.world.clock.clear
+        stubbing.call run_action if stubbing
+        run_action.execute event
+        raise run_action.error if run_action.error
+        run_action
+      end
+
+      # @return [Action::FinalizePhase]
+      def finalize_action(run_action, &stubbing)
+        Type! run_action, Dynflow::Action::RunPhase
+        step            = DummyStep.new
+        finalize_action = run_action.action_class.finalize_phase.new(
+            { step:              step,
+              execution_plan_id: run_action.execution_plan_id,
+              id:                run_action.id,
+              plan_step_id:      run_action.plan_step_id,
+              run_step_id:       run_action.run_step_id,
+              finalize_step_id:  step.id,
+              input:             run_action.input },
+            run_action.world)
+
+        stubbing.call finalize_action if stubbing
+        finalize_action.execute
+        finalize_action
+      end
+
+      def progress_action_time action
+        Type! action, Dynflow::Action::RunPhase
+        action.world.clock.progress
+        action.world.executor.progress
+      end
+    end
+  end
+end

data/lib/dynflow/testing/managed_clock.rb

@@ -0,0 +1,23 @@
+module Dynflow
+  module Testing
+    class ManagedClock
+      def initialize
+        @pings_to_process = []
+      end
+
+      def ping(who, time, with_what = nil, where = :<<)
+        @pings_to_process << [who, [where, with_what].compact]
+      end
+
+      def progress
+        copy = @pings_to_process.dup
+        clear
+        copy.each { |who, args| who.send *args }
+      end
+
+      def clear
+        @pings_to_process.clear
+      end
+    end
+  end
+end

data/lib/dynflow/testing/mimic.rb

@@ -0,0 +1,38 @@
+module Dynflow
+  module Testing
+
+    # when extended into Class or an_object it makes all instances of the class or the object
+    # mimic the supplied types. It does so by hooking into kind_of? method.
+    # @example
+    #   m = mock('product')
+    #   m.is_a? ::Product # => false
+    #   m.extend Mimic
+    #   m.mimic! ::Product
+    #   m.is_a? ::Product # => true
+    module Mimic
+      class ::Module
+        def ===(v)
+          v.kind_of? self
+        end
+      end
+
+      def mimic!(*types)
+        define =-> _ do
+          define_method :kind_of? do |type|
+            types.any? { |t| t <= type } || super(type)
+          end
+
+          alias_method :is_a?, :kind_of?
+        end
+
+        if self.kind_of? ::Class
+          self.class_eval &define
+        else
+          self.singleton_class.class_eval &define
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/dynflow/transaction_adapters.rb

@@ -0,0 +1,9 @@
+module Dynflow
+  module TransactionAdapters
+
+    require 'dynflow/transaction_adapters/abstract'
+    require 'dynflow/transaction_adapters/none'
+    require 'dynflow/transaction_adapters/active_record'
+
+  end
+end

data/lib/dynflow/transaction_adapters/abstract.rb

@@ -0,0 +1,26 @@
+module Dynflow
+  module TransactionAdapters
+    class Abstract
+      # start transaction around +block+
+      def transaction(&block)
+        raise NotImplementedError
+      end
+
+      # rollback the transaction
+      def rollback
+        raise NotImplementedError
+      end
+
+      # Called on each thread after work is done.
+      # E.g. it's used to checkin ActiveRecord connections back to pool.
+      def cleanup
+        # override if needed
+      end
+
+      # Called after World instantiation, it can be used to check Dynflow configuration etc.
+      def check(world)
+        # override if needed
+      end
+    end
+  end
+end

data/lib/dynflow/transaction_adapters/active_record.rb

@@ -0,0 +1,27 @@
+module Dynflow
+  module TransactionAdapters
+    class ActiveRecord < Abstract
+      def transaction(&block)
+        ::ActiveRecord::Base.transaction(&block)
+      end
+
+      def rollback
+        raise ::ActiveRecord::Rollback
+      end
+
+      def cleanup
+        ::ActiveRecord::Base.clear_active_connections!
+      end
+
+      def check(world)
+        # missing reader in ConnectionPool
+        ar_pool_size = ::ActiveRecord::Base.connection_pool.instance_variable_get(:@size)
+        if (world.options[:pool_size] / 2.0) > ar_pool_size
+          world.logger.warn 'Consider increasing ActiveRecord::Base.connection_pool size, ' +
+                                "it's #{ar_pool_size} but there is #{world.options[:pool_size]} " +
+                                'threads in Dynflow pool.'
+        end
+      end
+    end
+  end
+end

data/lib/dynflow/transaction_adapters/none.rb

@@ -0,0 +1,12 @@
+module Dynflow
+  module TransactionAdapters
+    class None < Abstract
+      def transaction(&block)
+        block.call
+      end
+
+      def rollback
+      end
+    end
+  end
+end

data/lib/dynflow/version.rb

@@ -1,3 +1,3 @@
 module Dynflow
-  VERSION = "0.1.0"
+  VERSION = '0.2.0'
 end

data/lib/dynflow/web_console.rb

@@ -0,0 +1,277 @@
+require 'dynflow'
+require 'pp'
+require 'sinatra'
+
+module Dynflow
+  class WebConsole < Sinatra::Base
+
+    def self.setup(&block)
+      Sinatra.new(self) do
+        instance_exec(&block)
+      end
+    end
+
+    web_dir = File.join(File.expand_path('../../../web', __FILE__))
+
+    set :public_folder, File.join(web_dir, 'assets')
+    set :views, File.join(web_dir, 'views')
+    set :per_page, 10
+
+    helpers ERB::Util
+
+    helpers do
+      def world
+        settings.world
+      end
+
+      def prettyprint(value)
+        value = prettyprint_references(value)
+        if value
+          pretty_value = value.pretty_inspect
+          <<-HTML
+            <pre class="prettyprint">#{h(pretty_value)}</pre>
+          HTML
+        else
+          ""
+        end
+      end
+
+      def prettyprint_references(value)
+        case value
+        when Hash
+          value.reduce({}) do |h, (key, val)|
+            h.update(key => prettyprint_references(val))
+          end
+        when Array
+          value.map { |val| prettyprint_references(val) }
+        when ExecutionPlan::OutputReference
+          value.inspect
+        else
+          value
+        end
+      end
+
+      def load_action(step)
+        world.persistence.load_action(step)
+      end
+
+      def step_error(step)
+        if step.error
+          ['<pre>',
+           "#{h(step.error.message)} (#{h(step.error.exception_class)})\n",
+           h(step.error.backtrace.join("\n")),
+           '</pre>'].join
+        end
+      end
+
+      def show_action_data(label, value)
+        value_html = prettyprint(value)
+        if !value_html.empty?
+          <<-HTML
+            <p>
+              #{h(label)}
+          #{value_html}
+            </p>
+          HTML
+        else
+          ""
+        end
+      end
+
+      def atom_css_classes(atom)
+        classes = ["atom"]
+        step    = @plan.steps[atom.step_id]
+        case step.state
+        when :success
+          classes << "success"
+        when :error
+          classes << "error"
+        when :skipped
+          classes << "skipped"
+        end
+        return classes.join(" ")
+      end
+
+      def flow_css_classes(flow, sub_flow = nil)
+        classes = []
+        case flow
+        when Flows::Sequence
+          classes << "sequence"
+        when Flows::Concurrence
+          classes << "concurrence"
+        when Flows::Atom
+          classes << atom_css_classes(flow)
+        else
+          raise "Unknown run plan #{run_plan.inspect}"
+        end
+        classes << atom_css_classes(sub_flow) if sub_flow.is_a? Flows::Atom
+        return classes.join(" ")
+      end
+
+      def step_css_class(step)
+        case step.state
+        when :success
+          "success"
+        when :error
+          "important"
+        end
+      end
+
+      def progress_width(action)
+        if action.state == :error
+          100 # we want to show the red bar in full width
+        else
+          action.progress_done * 100
+        end
+      end
+
+      def step(step_id)
+        @plan.steps[step_id]
+      end
+
+      def paginate?
+        world.persistence.adapter.pagination?
+      end
+
+      def updated_url(new_params)
+        url("?" + Rack::Utils.build_query(params.merge(new_params.stringify_keys)))
+      end
+
+      def paginated_url(delta)
+        h(updated_url(page: [0, page + delta].max))
+      end
+
+      def pagination_options
+        if paginate?
+          { page: page, per_page: per_page }
+        else
+          if params[:page] || params[:per_page]
+            halt 400, "The persistence doesn't support pagination"
+          end
+          return {}
+        end
+      end
+
+      def page
+        (params[:page] || 0).to_i
+      end
+
+      def per_page
+        (params[:per_page] || 10).to_i
+      end
+
+      def supported_ordering?(ord_attr)
+        world.persistence.adapter.ordering_by.any? do |attr|
+          attr.to_s == ord_attr.to_s
+        end
+      end
+
+      def ordering_options
+        return @ordering_options if @ordering_options
+
+        if params[:order_by]
+          unless supported_ordering?(params[:order_by])
+            halt 400, "Unsupported ordering"
+          end
+          @ordering_options = { order_by: params[:order_by],
+                                desc:     (params[:desc] == 'true') }
+        elsif supported_ordering?('started_at')
+          @ordering_options = { order_by: 'started_at', desc: true }
+        else
+          @ordering_options = {}
+        end
+        return @ordering_options
+      end
+
+      def order_link(attr, label)
+        return h(label) unless supported_ordering?(attr)
+        new_ordering_options = { order_by: attr.to_s,
+                                 desc:     false }
+        arrow                = ""
+        if ordering_options[:order_by].to_s == attr.to_s
+          arrow                       = ordering_options[:desc] ? "&#9660;" : "&#9650;"
+          new_ordering_options[:desc] = !ordering_options[:desc]
+        end
+        url = updated_url(new_ordering_options)
+        return %{<a href="#{url}"> #{arrow} #{h(label)}</a>}
+      end
+
+      def supported_filter?(filter_attr)
+        world.persistence.adapter.filtering_by.any? do |attr|
+          attr.to_s == filter_attr.to_s
+        end
+      end
+
+      def filtering_options
+        return @filtering_options if @filtering_options
+
+        if params[:filters]
+          params[:filters].map do |key, value|
+            unless supported_filter?(key)
+              halt 400, "Unsupported ordering"
+            end
+          end
+
+          filters = params[:filters]
+        elsif supported_filter?('state')
+          filters = { 'state' => ExecutionPlan.states.map(&:to_s) - ['stopped'] }
+        else
+          filters = {}
+        end
+        @filtering_options = { filters: filters }.with_indifferent_access
+        return @filtering_options
+      end
+
+      def filter_checkbox(field, values)
+        out        = "<p>#{field}: %s</p>"
+        checkboxes = values.map do |value|
+          field_filter = filtering_options[:filters][field]
+          checked      = field_filter && field_filter.include?(value)
+          %{<input type="checkbox" name="filters[#{field}][]" value="#{value}" #{ "checked" if checked }/>#{value}}
+        end.join(' ')
+        out        %= checkboxes
+        return out
+      end
+
+    end
+
+    get('/') do
+      options = HashWithIndifferentAccess.new
+      options.merge!(filtering_options)
+      options.merge!(pagination_options)
+      options.merge!(ordering_options)
+
+      @plans = world.persistence.find_execution_plans(options)
+      erb :index
+    end
+
+    get('/:id') do |id|
+      @plan = world.persistence.load_execution_plan(id)
+      erb :show
+    end
+
+    post('/:id/resume') do |id|
+      plan = world.persistence.load_execution_plan(id)
+      if plan.state != :paused
+        redirect(url "/#{plan.id}?notice=#{url_encode('The exeuction has to be paused to be able to resume')}")
+      else
+        world.execute(plan.id)
+        redirect(url "/#{plan.id}?notice=#{url_encode('The execution was resumed')}")
+      end
+    end
+
+    post('/:id/skip/:step_id') do |id, step_id|
+      plan = world.persistence.load_execution_plan(id)
+      step = plan.steps[step_id.to_i]
+      if plan.state != :paused
+        redirect(url "/#{plan.id}?notice=#{url_encode('The exeuction has to be paused to be able to skip')}")
+      elsif step.state != :error
+        redirect(url "/#{plan.id}?notice=#{url_encode('The step has to be failed to be able to skip')}")
+      else
+        plan.skip(step)
+        redirect(url "/#{plan.id}")
+      end
+    end
+
+  end
+end