dynflow 0.5.1 → 0.6.0

data/lib/dynflow/action.rb

@@ -81,6 +81,8 @@ module Dynflow
     attr_reader :world, :phase, :execution_plan_id, :id, :input,
                 :plan_step_id, :run_step_id, :finalize_step_id
 
+    middleware.use Action::Progress::Calculate
+
     def initialize(attributes, world)
       Type! attributes, Hash
 

data/lib/dynflow/action/polling.rb

@@ -6,44 +6,104 @@ module Dynflow
     def run(event = nil)
       case event
       when nil
-        self.external_task = invoke_external_task
-        suspend_and_ping
+        if external_task
+          resume_external_action
+        else
+          initiate_external_action
+        end
       when Poll
-        self.external_task = poll_external_task
-        suspend_and_ping unless done?
+        poll_external_task_with_rescue
       else
         raise "unrecognized event #{event}"
       end
     end
 
-    def external_task
+    def done?
       raise NotImplementedError
     end
 
-    def done?
+    def invoke_external_task
       raise NotImplementedError
     end
 
-    private
-
-    def invoke_external_task
+    def poll_external_task
       raise NotImplementedError
     end
 
+    # External task data. It should return nil when the task has not
+    # been triggered yet.
+    def external_task
+      output[:task]
+    end
+
     def external_task=(external_task_data)
-      raise NotImplementedError
+      output[:task] = external_task_data
     end
 
-    def poll_external_task
-      raise NotImplementedError
+    # What is the trend in waiting for next polling event. It allows
+    # to strart with frequent polling, but slow down once it's clear this
+    # task will take some time: the idea is we don't care that much in finishing
+    # few seconds sooner, when the task takes orders of minutes/hours. It allows
+    # not overwhelming the backend-servers with useless requests.
+    # By default, it switches to next interval after +attempts_before_next_interval+ number
+    # of attempts
+    def poll_intervals
+      [0.5, 1, 2, 4, 8, 16]
+    end
+
+    def attempts_before_next_interval
+      5
+    end
+
+    # Returns the time to wait between two polling intervals.
+    def poll_interval
+      interval_level = poll_attempts[:total]/attempts_before_next_interval
+      poll_intervals[interval_level] || poll_intervals.last
+    end
+
+    # How man times in row should we retry the polling before giving up
+    def poll_max_retries
+      3
+    end
+
+    def initiate_external_action
+      self.external_task = invoke_external_task
+      suspend_and_ping unless done?
+    end
+
+    def resume_external_action
+      poll_external_task_with_rescue
+    rescue
+      initiate_external_action
     end
 
     def suspend_and_ping
       suspend { |suspended_action| world.clock.ping suspended_action, poll_interval, Poll }
     end
 
-    def poll_interval
-      0.5
+    def poll_external_task_with_rescue
+      poll_attempts[:total] += 1
+      self.external_task = poll_external_task
+      poll_attempts[:failed] = 0
+      suspend_and_ping unless done?
+    rescue => error
+      poll_attempts[:failed] += 1
+      rescue_poll_external_task(error)
     end
+
+    def poll_attempts
+      output[:poll_attempts] ||= { total: 0, failed: 0 }
+    end
+
+    def rescue_poll_external_task(error)
+      if poll_attempts[:failed] < poll_max_retries
+        action_logger.warn("Polling failed, attempt no. #{poll_attempts[:failed]}, retrying in #{poll_interval}")
+        action_logger.warn(error)
+        suspend_and_ping
+      else
+        raise error
+      end
+    end
+
   end
 end

data/lib/dynflow/action/progress.rb

@@ -10,6 +10,37 @@ module Dynflow
   # the progress is 1 for success/skipped actions and 0 for errorneous ones.
   module Action::Progress
 
+    class Calculate < Middleware
+
+      def run(*args)
+        with_progress_calculation(*args) do
+          [action.run_progress, action.run_progress_weight]
+        end
+      end
+
+      def finalize(*args)
+        with_progress_calculation(*args) do
+          [action.finalize_progress, action.finalize_progress_weight]
+        end
+      end
+
+      protected
+
+      def with_progress_calculation(*args)
+        pass(*args)
+      ensure
+        begin
+          action.calculated_progress = yield
+        rescue => error
+          # we don't want progress calculation to cause fail of the whole process
+          # TODO: introduce post-execute state for handling issues with additional
+          # calculations after the step is run
+          action.action_logger.error('Error in progress calculation')
+          action.action_logger.error(error)
+        end
+      end
+    end
+
     def run_progress
       0.5
     end
@@ -26,37 +57,7 @@ module Dynflow
       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 phase
-        when Action::Run
-          run_progress
-        when Action::Finalize
-          finalize_progress
-        else
-          raise 'Calculating progress for this phase is not supported'
-        end
-      else
-        0
-      end
-    end
-
-    def progress_weight
-      case phase
-      when Action::Run
-        run_progress_weight
-      when Action::Finalize
-        finalize_progress_weight
-      else
-        raise 'Calculating progress for this phase is not supported'
-      end
-    end
-
+    attr_accessor :calculated_progress
   end
 end
 

data/lib/dynflow/execution_plan.rb

@@ -37,7 +37,7 @@ module Dynflow
         steps = {},
         started_at = nil,
         ended_at = nil,
-        execution_time = 0.0,
+        execution_time = nil,
         real_time = 0.0)
 
       @id             = Type! id, String
@@ -48,8 +48,8 @@ module Dynflow
       @root_plan_step = root_plan_step
       @started_at     = Type! started_at, Time, NilClass
       @ended_at       = Type! ended_at, Time, NilClass
-      @execution_time = Type! execution_time, Float
-      @real_time      = Type! real_time, Float
+      @execution_time = Type! execution_time, Numeric, NilClass
+      @real_time      = Type! real_time, Numeric
 
       steps.all? do |k, v|
         Type! k, Integer
@@ -68,8 +68,9 @@ module Dynflow
       when :planning
         @started_at = Time.now
       when :stopped
-        @ended_at  = Time.now
-        @real_time = @ended_at - @started_at
+        @ended_at       = Time.now
+        @real_time      = @ended_at - @started_at
+        @execution_time = compute_execution_time
       else
         # ignore
       end
@@ -78,10 +79,6 @@ module Dynflow
       self.save
     end
 
-    def update_execution_time(execution_time)
-      @execution_time += execution_time
-    end
-
     def result
       all_steps = steps.values
       if all_steps.any? { |step| step.state == :error }
@@ -205,6 +202,7 @@ module Dynflow
 
     def add_run_step(action)
       add_step(Steps::RunStep, action.class, action.id).tap do |step|
+        step.progress_weight = action.run_progress_weight
         @dependency_graph.add_dependencies(step, action)
         current_run_flow.add_and_resolve(@dependency_graph, Flows::Atom.new(step.id))
       end
@@ -212,6 +210,7 @@ module Dynflow
 
     def add_finalize_step(action)
       add_step(Steps::FinalizeStep, action.class, action.id).tap do |step|
+        step.progress_weight = action.finalize_progress_weight
         finalize_flow << Flows::Atom.new(step.id)
       end
     end
@@ -252,14 +251,20 @@ module Dynflow
                hash[:real_time])
     end
 
+    def compute_execution_time
+      self.steps.values.reduce(0) do |execution_time, step|
+        execution_time + (step.execution_time || 0)
+      end
+    end
+
     # @return [0..1] the percentage of the progress. See Action::Progress for more
     # info
     def progress
       flow_step_ids         = run_flow.all_step_ids + finalize_flow.all_step_ids
       plan_done, plan_total = flow_step_ids.reduce([0.0, 0]) do |(done, total), step_id|
-        step_progress_done, step_progress_weight = self.steps[step_id].progress
-        [done + (step_progress_done * step_progress_weight),
-         total + step_progress_weight]
+        step = self.steps[step_id]
+        [done + (step.progress_done * step.progress_weight),
+         total + step.progress_weight]
       end
       plan_total > 0 ? (plan_done / plan_total) : 1
     end

data/lib/dynflow/execution_plan/steps/abstract.rb

@@ -18,7 +18,9 @@ module Dynflow
           started_at = nil,
           ended_at = nil,
           execution_time = 0.0,
-          real_time = 0.0)
+          real_time = 0.0,
+          progress_done = nil,
+          progress_weight = nil)
 
         @id                = id || raise(ArgumentError, 'missing id')
         @execution_plan_id = Type! execution_plan_id, String
@@ -26,8 +28,11 @@ module Dynflow
         @error             = Type! error, ExecutionPlan::Steps::Error, NilClass
         @started_at        = Type! started_at, Time, NilClass
         @ended_at          = Type! ended_at, Time, NilClass
-        @execution_time    = Type! execution_time, Float
-        @real_time         = Type! real_time, Float
+        @execution_time    = Type! execution_time, Numeric
+        @real_time         = Type! real_time, Numeric
+
+        @progress_done     = Type! progress_done, Numeric, NilClass
+        @progress_weight   = Type! progress_weight, Numeric, NilClass
 
         self.state = state.to_sym
 
@@ -76,16 +81,31 @@ module Dynflow
                           started_at:        time_to_str(started_at),
                           ended_at:          time_to_str(ended_at),
                           execution_time:    execution_time,
-                          real_time:         real_time
+                          real_time:         real_time,
+                          progress_done:     progress_done,
+                          progress_weight:   progress_weight
+      end
+
+      def progress_done
+        default_progress_done || @progress_done || 0
       end
 
-      # @return [Array<[0..100], Fixnum>] the percentage of the step progress
-      # and the weight - how time-consuming the task is comparing the others.
-      # @see [Action::Progress] for more details
-      def progress
-        raise NotImplementedError, "Expected to be implemented in RunStep and FinalizeStep"
+      # in specific states it's clear what progress the step is in
+      def default_progress_done
+        case self.state
+        when :success, :skipped
+          1
+        when :pending
+          0
+        end
       end
 
+      def progress_weight
+        @progress_weight || 0 # 0 means not calculated yet
+      end
+
+      attr_writer :progress_weight # to allow setting the weight from planning
+
       # @return [Action] in presentation mode, intended for retrieving: progress information,
       # details, human outputs, etc.
       def action(execution_plan)
@@ -108,16 +128,19 @@ module Dynflow
             string_to_time(hash[:started_at]),
             string_to_time(hash[:ended_at]),
             hash[:execution_time],
-            hash[:real_time]
+            hash[:real_time],
+            hash[:progress_done],
+            hash[:progress_weight]
       end
 
       private
 
-      def with_time_calculation(&block)
+      def with_meta_calculation(action, &block)
         start       = Time.now
         @started_at ||= start
         block.call
       ensure
+        @progress_done, @progress_weight = action.calculated_progress
         @ended_at       = Time.now
         @execution_time += @ended_at - start
         @real_time      = @ended_at - @started_at

data/lib/dynflow/execution_plan/steps/abstract_flow_step.rb

@@ -5,7 +5,7 @@ module Dynflow
       def execute(*args)
         return self if [:skipped, :success].include? self.state
         open_action do |action|
-          with_time_calculation do
+          with_meta_calculation(action) do
             action.execute(*args)
           end
         end
@@ -15,11 +15,6 @@ module Dynflow
         self.class.from_hash(to_hash, execution_plan_id, world)
       end
 
-      def progress
-        action = persistence.load_action(self)
-        [action.progress_done, action.progress_weight]
-      end
-
       private
 
       def open_action

data/lib/dynflow/execution_plan/steps/plan_step.rb

@@ -50,12 +50,10 @@ module Dynflow
         action     = action_class.new(attributes, execution_plan.world)
         persistence.save_action(execution_plan_id, action)
 
-        with_time_calculation do
+        with_meta_calculation(action) do
           action.execute(*args)
         end
 
-        execution_plan.update_execution_time execution_time
-
         persistence.save_action(execution_plan_id, action)
         return action
       end

data/lib/dynflow/executors/parallel/execution_plan_manager.rb

@@ -51,15 +51,8 @@ module Dynflow
                    execution_plan.steps[step.id] = step
                    suspended, work = @running_steps_manager.done(step)
                    unless suspended
-                     execution_plan.update_execution_time step.execution_time
                      work = compute_next_from_step.call step
                    end
-                   # TODO: can be probably disabled to improve
-                   # performance, execution time will not be updated,
-                   # maybe more - check on the other side, it allows
-                   # us to use persistence adapter for hooking into
-                   # the running process.
-                   execution_plan.save
                    work
                  end),
                 (on Work::Finalize do

data/lib/dynflow/executors/parallel/sequential_manager.rb

@@ -70,8 +70,6 @@ module Dynflow
 
       def run_step(step)
         step.execute
-        execution_plan.update_execution_time step.execution_time
-        execution_plan.save
         return step.state != :error
       end
 

data/lib/dynflow/persistence_adapters/sequel.rb

@@ -25,7 +25,7 @@ module Dynflow
 
       META_DATA = { execution_plan: %w(state result started_at ended_at real_time execution_time),
                     action:         [],
-                    step:           %w(state started_at ended_at real_time execution_time action_id) }
+                    step:           %w(state started_at ended_at real_time execution_time action_id progress_done progress_weight) }
 
       def initialize(db_path)
         @db = initialize_db db_path

data/lib/dynflow/persistence_adapters/sequel_migrations/002_incremental_progress.rb

@@ -0,0 +1,8 @@
+Sequel.migration do
+  change do
+    alter_table(:dynflow_steps) do
+      add_column :progress_done, Float
+      add_column :progress_weight, Float
+    end
+  end
+end

data/lib/dynflow/testing.rb

@@ -3,7 +3,7 @@ module Dynflow
     extend Algebrick::TypeCheck
 
     def self.logger_adapter
-      @logger_adapter ||= LoggerAdapters::Simple.new $stdout, 0
+      @logger_adapter || LoggerAdapters::Simple.new($stdout, 1)
     end
 
     def self.logger_adapter=(adapter)

data/lib/dynflow/testing/managed_clock.rb

@@ -1,22 +1,38 @@
 module Dynflow
   module Testing
     class ManagedClock
+
+      attr_reader :pending_pings
+
+      include Algebrick::Types
+      Timer = Algebrick.type do
+        fields! who:   Object, # to ping back
+                when:  type { variants Time, Numeric }, # to deliver
+                what:  Maybe[Object], # to send
+                where: Symbol # it should be delivered, which method
+      end
+
+      module Timer
+        include Clock::Timer
+      end
+
       def initialize
-        @pings_to_process = []
+        @pending_pings = []
       end
 
       def ping(who, time, with_what = nil, where = :<<)
-        @pings_to_process << [who, [where, with_what].compact]
+        with = with_what.nil? ? None : Some[Object][with_what]
+        @pending_pings << Timer[who, time, with, where]
       end
 
       def progress
-        copy = @pings_to_process.dup
+        copy = @pending_pings.dup
         clear
-        copy.each { |who, args| who.send *args }
+        copy.each { |ping| ping.apply }
       end
 
       def clear
-        @pings_to_process.clear
+        @pending_pings.clear
       end
     end
   end

data/lib/dynflow/version.rb

@@ -1,3 +1,3 @@
 module Dynflow
-  VERSION = '0.5.1'
+  VERSION = '0.6.0'
 end

data/lib/dynflow/web_console.rb

@@ -126,11 +126,11 @@ module Dynflow
         end
       end
 
-      def progress_width(action)
-        if action.state == :error
+      def progress_width(step)
+        if step.state == :error
           100 # we want to show the red bar in full width
         else
-          action.progress_done * 100
+          step.progress_done * 100
         end
       end
 

data/test/action_test.rb

@@ -91,5 +91,166 @@ module Dynflow
       end
     end
 
+    describe 'polling action' do
+      CWE = Support::CodeWorkflowExample
+      include Dynflow::Testing
+
+      class ExternalService
+        def invoke(args)
+          reset!
+        end
+
+        def poll(id)
+          raise 'fail' if @current_state[:failing]
+          @current_state[:progress] += 10
+          return @current_state
+        end
+
+        def reset!
+          @current_state = { task_id: 123, progress: 0 }
+        end
+
+        def will_fail
+          @current_state[:failing] = true
+        end
+
+        def wont_fail
+          @current_state.delete(:failing)
+        end
+      end
+
+      class TestPollingAction < Dynflow::Action
+
+        class Config
+          attr_accessor :external_service, :poll_max_retries,
+              :poll_intervals, :attempts_before_next_interval
+
+          def initialize
+            @external_service              = ExternalService.new
+            @poll_max_retries              = 2
+            @poll_intervals                = [0.5, 1]
+            @attempts_before_next_interval = 2
+          end
+        end
+
+        include Dynflow::Action::Polling
+
+        def invoke_external_task
+          external_service.invoke(input[:task_args])
+        end
+
+        def poll_external_task
+          external_service.poll(external_task[:task_id])
+        end
+
+        def done?
+          external_task && external_task[:progress] >= 100
+        end
+
+        def poll_max_retries
+          self.class.config.poll_max_retries
+        end
+
+        def poll_intervals
+          self.class.config.poll_intervals
+        end
+
+        def attempts_before_next_interval
+          self.class.config.attempts_before_next_interval
+        end
+
+        class << self
+          def config
+            @config ||= Config.new
+          end
+
+          attr_writer :config
+        end
+
+        def external_service
+          self.class.config.external_service
+        end
+      end
+
+      let(:plan) do
+        create_and_plan_action TestPollingAction, { task_args: 'do something' }
+      end
+
+      before do
+        TestPollingAction.config = TestPollingAction::Config.new
+      end
+
+      def next_ping(action)
+        action.world.clock.pending_pings.first
+      end
+
+      it 'initiates the external task' do
+        action   = run_action plan
+
+        action.output[:task][:task_id].must_equal 123
+      end
+
+      it 'polls till the task is done' do
+        action   = run_action plan
+
+        9.times { progress_action_time action }
+        action.done?.must_equal false
+        next_ping(action).wont_be_nil
+        action.state.must_equal :suspended
+
+        progress_action_time action
+        action.done?.must_equal true
+        next_ping(action).must_be_nil
+        action.state.must_equal :success
+      end
+
+      it 'tries to poll for the old task when resuming' do
+        action   = run_action plan
+        action.output[:task][:progress].must_equal 0
+        run_action action
+        action.output[:task][:progress].must_equal 10
+      end
+
+      it 'invokes the external task again when polling on the old one fails' do
+        action   = run_action plan
+        action.world.action_logger.level = 3
+        action.external_service.will_fail
+        action.output[:task][:progress].must_equal 0
+        run_action action
+        action.output[:task][:progress].must_equal 0
+      end
+
+      it 'tolerates some failure while polling' do
+        action   = run_action plan
+        action.external_service.will_fail
+        action.world.action_logger.level = 4
+
+        TestPollingAction.config.poll_max_retries = 3
+        (1..2).each do |attempt|
+          progress_action_time action
+          action.poll_attempts[:failed].must_equal attempt
+          next_ping(action).wont_be_nil
+          action.state.must_equal :suspended
+        end
+
+        progress_action_time action
+        action.poll_attempts[:failed].must_equal 3
+        next_ping(action).must_be_nil
+        action.state.must_equal :error
+      end
+
+      it 'allows increasing poll interval in a time' do
+        TestPollingAction.config.poll_intervals = [1, 2]
+        TestPollingAction.config.attempts_before_next_interval = 1
+
+        action   = run_action plan
+        next_ping(action).when.must_equal 1
+        progress_action_time action
+        next_ping(action).when.must_equal 2
+        progress_action_time action
+        next_ping(action).when.must_equal 2
+      end
+
+    end
   end
 end

data/test/executor_test.rb

@@ -203,8 +203,8 @@ module Dynflow
                   result.result.must_equal :success
                   result.state.must_equal :stopped
                   action = world.persistence.load_action result.steps[2]
-                  action.output[:progress].must_equal 30
-                  action.output[:cancelled].must_equal true
+                  action.output[:task][:progress].must_equal 30
+                  action.output[:task][:cancelled].must_equal true
                 end
               end
 
@@ -219,7 +219,7 @@ module Dynflow
                   step = result.steps[2]
                   step.error.message.must_equal 'action cancelled'
                   action = world.persistence.load_action step
-                  action.output[:progress].must_equal 30
+                  action.output[:task][:progress].must_equal 30
                 end
               end
 
@@ -241,8 +241,8 @@ module Dynflow
                     result.result.must_equal :success
                     result.state.must_equal :stopped
                     action = world.persistence.load_action result.steps[2]
-                    action.output[:progress].must_be :<=, 30
-                    action.output[:cancelled].must_equal true
+                    action.output[:task][:progress].must_be :<=, 30
+                    action.output[:task][:cancelled].must_equal true
                   end
                 end
               end

data/test/support/code_workflow_example.rb

@@ -290,22 +290,14 @@ module Support
 
       def cancel_external_task
         if input[:text] !~ /cancel-fail/
-          { cancelled: true }
+          external_task.merge(cancelled: true)
         else
           error! 'action cancelled'
         end
       end
 
-      def external_task=(external_task_data)
-        self.output.update external_task_data
-      end
-
-      def external_task
-        output
-      end
-
       def done?
-        external_task[:progress] >= 100
+        external_task && external_task[:progress] >= 100
       end
 
       def poll_interval
@@ -313,7 +305,7 @@ module Support
       end
 
       def run_progress
-        output[:progress].to_f / 100
+        external_task && external_task[:progress].to_f / 100
       end
     end
 
@@ -325,14 +317,6 @@ module Support
         { progress: 0, done: false }
       end
 
-      def external_task=(external_task_data)
-        self.output.update external_task_data
-      end
-
-      def external_task
-        output
-      end
-
       def poll_external_task
         if input[:text] == 'troll progress' && !output[:trolled]
           output[:trolled] = true
@@ -340,15 +324,15 @@ module Support
         end
 
         if input[:text] =~ /pause in progress (\d+)/
-          TestPause.pause if output[:progress] == $1.to_i
+          TestPause.pause if external_task[:progress] == $1.to_i
         end
 
-        progress = output[:progress] + 10
+        progress = external_task[:progress] + 10
         { progress: progress, done: progress >= 100 }
       end
 
       def done?
-        external_task[:progress] >= 100
+        external_task && external_task[:progress] >= 100
       end
 
       def poll_interval
@@ -356,7 +340,7 @@ module Support
       end
 
       def run_progress
-        output[:progress].to_f / 100
+        external_task && external_task[:progress].to_f / 100
       end
     end
 

data/test/test_helper.rb

@@ -17,8 +17,6 @@ require 'pry'
 require 'support/code_workflow_example'
 require 'support/middleware_example'
 
-Dynflow::Testing.logger_adapter.level = 1
-
 class TestExecutionLog
 
   include Enumerable

data/test/testing_test.rb

@@ -45,7 +45,6 @@ module Dynflow
         action.world.must_equal plan.world
         action.run_step_id.wont_equal action.plan_step_id
         action.state.must_equal :success
-        action.progress_done.must_equal 1
       end
 
       specify '#run_action with suspend' do
@@ -53,21 +52,26 @@ module Dynflow
         plan   = create_and_plan_action CWE::DummySuspended, input
         action = run_action plan
 
-        action.output.must_equal 'progress' => 0, 'done' => false
-        action.progress_done.must_equal 0
+        action.output.must_equal 'task' => { 'progress' => 0, 'done' => false }
+        action.run_progress.must_equal 0
 
         3.times { progress_action_time action }
-        action.output.must_equal 'progress' => 30, 'done' => false
-        action.progress_done.must_equal 0.3
+        action.output.must_equal('task' => { 'progress' => 30, 'done' => false } ,
+                                 'poll_attempts' => {'total' => 2, 'failed'=> 0 })
+        action.run_progress.must_equal 0.3
 
         run_action action, Dynflow::Action::Polling::Poll
         run_action action, Dynflow::Action::Polling::Poll
-        action.output.must_equal 'progress' => 50, 'done' => false
-        action.progress_done.must_equal 0.5
+        action.output.must_equal('task' => { 'progress' => 50, 'done' => false },
+                                 'poll_attempts' => {'total' => 4, 'failed' => 0 })
+        action.run_progress.must_equal 0.5
 
         5.times { progress_action_time action }
-        action.output.must_equal 'progress' => 100, 'done' => true
-        action.progress_done.must_equal 1
+
+
+        action.output.must_equal('task' => { 'progress' => 100, 'done' => true },
+                                 'poll_attempts' => {'total' => 9, 'failed' => 0 })
+        action.run_progress.must_equal 1
       end
 
       specify '#finalize_action' do
@@ -84,7 +88,6 @@ module Dynflow
         action.world.must_equal plan.world
         action.finalize_step_id.wont_equal action.run_step_id
         action.state.must_equal :success
-        action.progress_done.must_equal 1
 
         $dummy_heavy_progress.must_equal 'dummy_heavy_progress'
       end

data/web/views/flow_step.erb

@@ -1,7 +1,7 @@
 <% action = load_action(step) %>
 
 <% if flow.is_a? Dynflow::Flows::Atom %>
-   <div class="<%= h(atom_css_classes(flow)) %>" style=" width: <%= progress_width(action) %>%;"></div>
+   <div class="<%= h(atom_css_classes(flow)) %>" style=" width: <%= progress_width(step) %>%;"></div>
 <% end %>
 
 <span class="step-label">

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynflow
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-13 00:00:00.000000000 Z
+date: 2014-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -286,6 +286,7 @@ files:
 - lib/dynflow/persistence_adapters/abstract.rb
 - lib/dynflow/persistence_adapters/sequel.rb
 - lib/dynflow/persistence_adapters/sequel_migrations/001_initial.rb
+- lib/dynflow/persistence_adapters/sequel_migrations/002_incremental_progress.rb
 - lib/dynflow/serializable.rb
 - lib/dynflow/simple_world.rb
 - lib/dynflow/stateful.rb