dynflow 0.7.9 → 0.8.0

data/lib/dynflow/serializer.rb

@@ -0,0 +1,46 @@
+require 'algebrick/serializer'
+
+module Dynflow
+  def self.serializer
+    @serializer ||= Serializer.new
+  end
+
+  class Serializer < Algebrick::Serializer
+
+    ARBITRARY_TYPE_KEY = :class
+    MARSHAL_KEY        = :marshaled
+
+    protected
+
+    def parse_other(other, options = {})
+      if Hash === other
+        if (marshal_value = other[MARSHAL_KEY] || other[MARSHAL_KEY.to_s])
+          return Marshal.load(Base64.strict_decode64(marshal_value))
+        end
+
+        if (type_name = other[ARBITRARY_TYPE_KEY] || other[ARBITRARY_TYPE_KEY.to_s])
+          type = type_name.constantize rescue nil
+          if type && type.respond_to?(:from_hash)
+            return type.from_hash other
+          end
+        end
+      end
+
+      return other
+    end
+
+    def generate_other(object, options = {})
+      hash = case
+             when object.respond_to?(:to_h)
+               object.to_h
+             when object.respond_to?(:to_hash)
+               object.to_hash
+             else
+               { ARBITRARY_TYPE_KEY => object.class.to_s,
+                 MARSHAL_KEY        => Base64.strict_encode64(Marshal.dump(object)) }
+             end
+      raise "Missing #{ARBITRARY_TYPE_KEY} key in #{hash.inspect}" unless hash.key?(ARBITRARY_TYPE_KEY)
+      hash
+    end
+  end
+end

data/lib/dynflow/testing/dummy_executor.rb

@@ -8,7 +8,7 @@ module Dynflow
         @events_to_process = []
       end
 
-      def event(execution_plan_id, step_id, event, future = Future.new)
+      def event(execution_plan_id, step_id, event, future = Concurrent.future)
         @events_to_process << [execution_plan_id, step_id, event, future]
       end
 
@@ -17,7 +17,7 @@ module Dynflow
         events = @events_to_process.dup
         clear
         events.each do |execution_plan_id, step_id, event, future|
-          future.resolve true
+          future.success true
           if event && world.action.state != :suspended
             return false
           end

data/lib/dynflow/testing/dummy_world.rb

@@ -30,7 +30,7 @@ module Dynflow
         []
       end
 
-      def event(execution_plan_id, step_id, event, future = Future.new)
+      def event(execution_plan_id, step_id, event, future = Concurrent.future)
         executor.event execution_plan_id, step_id, event, future
       end
 

data/lib/dynflow/transaction_adapters/abstract.rb

@@ -16,11 +16,6 @@ module Dynflow
       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

@@ -12,16 +12,6 @@ module Dynflow
       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/version.rb

@@ -1,3 +1,3 @@
 module Dynflow
-  VERSION = '0.7.9'
+  VERSION = '0.8.0'
 end

data/lib/dynflow/web.rb

@@ -0,0 +1,26 @@
+require 'dynflow'
+require 'pp'
+require 'sinatra/base'
+require 'yaml'
+
+module Dynflow
+  module Web
+
+    def self.setup(&block)
+      console = Sinatra.new(Web::Console) { instance_exec(&block)}
+      Rack::Builder.app do
+        run Rack::URLMap.new('/'        => console)
+      end
+    end
+
+    def self.web_dir(sub_dir)
+      web_dir = File.join(File.expand_path('../../../web', __FILE__))
+      File.join(web_dir, sub_dir)
+    end
+
+    require 'dynflow/web/filtering_helpers'
+    require 'dynflow/web/world_helpers'
+    require 'dynflow/web/console_helpers'
+    require 'dynflow/web/console'
+  end
+end

data/lib/dynflow/web/console.rb

@@ -0,0 +1,108 @@
+
+module Dynflow
+  module Web
+    class Console < Sinatra::Base
+
+      set :public_folder, Web.web_dir('assets')
+      set :views, Web.web_dir('views')
+      set :per_page, 10
+
+      helpers ERB::Util
+      helpers Web::FilteringHelpers
+      helpers Web::WorldHelpers
+      helpers Web::ConsoleHelpers
+
+      get('/') do
+        options = find_execution_plans_options
+        @plans = world.persistence.find_execution_plans(options)
+        erb :index
+      end
+
+      get('/:execution_plan_id/actions/:action_id/sub_plans') do |execution_plan_id, action_id|
+        options = find_execution_plans_options(true)
+        options[:filters].update('caller_execution_plan_id' => execution_plan_id,
+                                 'caller_action_id' => action_id)
+        @plans = world.persistence.find_execution_plans(options)
+        erb :index
+      end
+
+      get('/status') do
+        # TODO: create a separate page for the overall status, linking
+        # to the more detailed pages
+        redirect to '/worlds'
+      end
+
+      get('/worlds') do
+        @worlds = world.coordinator.find_worlds
+        erb :worlds
+      end
+
+      post('/worlds/:id/ping') do |id|
+        timeout = 5
+        ping_response = world.ping(id, timeout).wait
+        if ping_response.failed?
+          response = "failed: #{ping_response.reason.message}"
+          inactive_world_id = id
+        else
+          response = 'pong'
+        end
+        redirect(url "/worlds?notice=#{url_encode(response)}&inactive_world_id=#{inactive_world_id}")
+      end
+
+      post('/worlds/:id/invalidate') do |id|
+        invalidated_world = world.coordinator.find_worlds(false, id: id).first
+        unless invalidated_world
+          response = "World #{id} not found"
+        else
+          begin
+            world.invalidate(invalidated_world)
+            response = "World #{invalidated_world.id} invalidated"
+          rescue => e
+            response = "World invalidation failed: #{e.message}"
+          end
+        end
+        redirect(url "/worlds?notice=#{url_encode(response)}")
+      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
+
+      post('/:id/cancel/:step_id') do |id, step_id|
+        plan = world.persistence.load_execution_plan(id)
+        step = plan.steps[step_id.to_i]
+        if step.cancellable?
+          world.event(plan.id, step.id, Dynflow::Action::Cancellable::Cancel)
+          redirect(url "/#{plan.id}?notice=#{url_encode('The step was asked to cancel')}")
+        else
+          redirect(url "/#{plan.id}?notice=#{url_encode('The step does not support cancelling')}")
+        end
+      end
+
+    end
+  end
+end

data/lib/dynflow/web/console_helpers.rb

@@ -0,0 +1,158 @@
+module Dynflow
+  module Web
+    module ConsoleHelpers
+      def prettify_value(value)
+        YAML.dump(value)
+      end
+
+      def prettyprint(value)
+        value = prettyprint_references(value)
+        if value
+          pretty_value = prettify_value(value)
+            <<-HTML
+              <pre class="prettyprint lang-yaml">#{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 duration_to_s(duration)
+        h("%0.2fs" % duration)
+      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_world(world_id)
+        if registered_world = world.coordinator.find_worlds(false, id: world_id).first
+          "%{world_id} %{world_meta}" % { world_id: world_id, world_meta: registered_world.meta.inspect }
+        else
+          world_id
+        end
+      end
+
+      def show_action_data(label, value)
+        value_html = prettyprint(value)
+        if !value_html.empty?
+            <<-HTML
+              <p>
+                <b>#{h(label)}</b>
+            #{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, :skipping
+          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(step)
+        if step.state == :error
+          100 # we want to show the red bar in full width
+        else
+          step.progress_done * 100
+        end
+      end
+
+      def step(step_id)
+        @plan.steps[step_id]
+      end
+
+      def updated_url(new_params)
+        url(request.path_info + "?" + Rack::Utils.build_nested_query(params.merge(new_params.stringify_keys)))
+      end
+
+      def paginated_url(delta)
+        h(updated_url(page: [0, page + delta].max.to_s))
+      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 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
+  end
+end

data/lib/dynflow/web/filtering_helpers.rb

@@ -0,0 +1,85 @@
+module Dynflow
+  module Web
+    module FilteringHelpers
+      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(show_all = false)
+        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')
+          excluded_states = show_all ? [] : ['stopped']
+          filters = { 'state' => ExecutionPlan.states.map(&:to_s) - excluded_states }          
+        else
+          filters = {}
+        end
+        @filtering_options = { filters: filters }.with_indifferent_access
+        return @filtering_options
+      end
+
+      def find_execution_plans_options(show_all = false)
+        options = HashWithIndifferentAccess.new
+        options.merge!(filtering_options(show_all))
+        options.merge!(pagination_options)
+        options.merge!(ordering_options)
+      end
+
+      def paginate?
+        world.persistence.adapter.pagination?
+      end
+
+      def page
+        (params[:page] || 0).to_i
+      end
+
+      def per_page
+        (params[:per_page] || 10).to_i
+      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 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
+    end
+  end
+end