bosh_cli 1.2200.0 → 1.2291.0

data/lib/cli/task_tracking.rb

@@ -4,8 +4,9 @@ end
 
 require 'cli/task_tracking/task_tracker'
 require 'cli/task_tracking/total_duration'
+require 'cli/task_tracking/smart_whitespace_printer'
 require 'cli/task_tracking/task_log_renderer'
 require 'cli/task_tracking/null_task_log_renderer'
-require 'cli/task_tracking/stage_progress_bar'
 require 'cli/task_tracking/stage_collection'
+require 'cli/task_tracking/stage_collection_presenter'
 require 'cli/task_tracking/event_log_renderer'

data/lib/cli/task_tracking/event_log_renderer.rb

@@ -1,3 +1,6 @@
+require 'forwardable'
+require 'json'
+
 module Bosh::Cli::TaskTracking
   class EventLogRenderer < TaskLogRenderer
     class InvalidEvent < StandardError; end
@@ -5,382 +8,101 @@ module Bosh::Cli::TaskTracking
     extend Forwardable
     def_delegators :@total_duration, :duration, :duration_known?, :started_at, :finished_at
 
-    attr_reader :current_stage
-    attr_reader :events_count
+    def initialize
+      super
 
-    def initialize(options={})
+      @printer = SmartWhitespacePrinter.new
       @total_duration = TotalDuration.new
-      @lock = Monitor.new
-      @events_count = 0
-      @seen_stages = Set.new
-      @out = Bosh::Cli::Config.output || $stdout
-      @out.sync = true
-      @buffer = StringIO.new
-      @progress_bars = {}
-      @pos = 0
-      @time_adjustment = 0
-      @stages_without_progress_bar = options[:stages_without_progress_bar] || []
-    end
-
-    def add_output(output)
-      output.to_s.split("\n").each { |line| add_event(line) }
-    end
-
-    def add_event(event_line)
-      event = parse_event(event_line)
-
-      @lock.synchronize do
-        if event['type'] == 'deprecation'
-          @buffer.puts("Deprecation: #{event['message']}".make_red)
-          return
-        end
-
-        # Handling the special "error" event
-        if event['error']
-          done_with_stage if @current_stage
-          add_error(event)
-          return
-        end
 
-        if can_handle_event_without_progress_bar?(event)
-          if @current_stage
-            done_with_stage
-            @current_stage = nil
-            @buffer.print "\n"
-          end
-          handle_event_without_progress_bar(event)
-          return
-        end
+      presenter = StageCollectionPresenter.new(@printer)
 
-        # One way to handle old stages is to prevent them
-        # from appearing on screen altogether. That means
-        # that we can always render the current stage only
-        # and that simplifies housekeeping around progress
-        # bars and messages. However we could always support
-        # resuming the older stages rendering if we feel
-        # that it's valuable.
-
-        tags = event['tags'].is_a?(Array) ? event['tags'] : []
-        stage_header = event['stage']
-
-        if tags.size > 0
-          stage_header += ' ' + tags.sort.join(', ').make_green
-        end
+      @stage_collection = StageCollection.new(
+        stage_started:  presenter.method(:start_stage),
+        stage_finished: presenter.method(:finish_stage),
+        stage_failed:   presenter.method(:fail_stage),
 
-        unless @seen_stages.include?(stage_header)
-          done_with_stage if @current_stage
-          begin_stage(event, stage_header)
-        end
-
-        if @current_stage == stage_header
-          append_event(event)
-        end
-      end
-
-    rescue InvalidEvent => e
-      # Swallow for the moment
-    end
-
-    def begin_stage(event, header)
-      @current_stage = header
-      @seen_stages << @current_stage
-
-      @stage_start_time = Time.at(event['time']) rescue Time.now
-      @local_start_time = adjusted_time(@stage_start_time)
-
-      @tasks = {}
-      @done_tasks = []
-
-      @eta = nil
-      @stage_has_error = false # Error flag
-      # Tracks max_in_flight best guess
-      @tasks_batch_size = 0
-      @batches_count = 0
-
-      # Running average of task completion time
-      @running_avg = 0
-
-      append_stage_header
-    end
-
-    def render
-      @lock.synchronize do
-        @buffer.seek(@pos)
-        output = @buffer.read
-        @out.print output
-        @pos = @buffer.tell
-        output
-      end
+        task_started:   presenter.method(:start_task),
+        task_finished:  presenter.method(:finish_task),
+        task_failed:    presenter.method(:fail_task),
+      )
     end
 
-    def add_error(event)
-      error = event['error'] || {}
-      code = error['code']
-      message = error['message']
-
-      error = 'Error'
-      error += " #{code}" if code
-      error += ": #{message}" if message
-
-      @buffer.puts("\n" + error.make_red)
-    end
+    alias_method :add_raw_output, :add_output
 
-    def refresh
-      # This is primarily used to refresh timer
-      # without advancing rendering buffer
-      @lock.synchronize do
-        if @in_progress
-          progress_bar.label = time_with_eta(Time.now - @local_start_time, @eta)
-          progress_bar.refresh
+    def add_output(output)
+      output.to_s.split("\n").each do |line|
+        begin
+          event = parse_event(line)
+          add_event(event) if event
+        rescue InvalidEvent => e
+          @printer.print(:line_around, "Received invalid event: #{e.message}".make_red)
         end
-        render
       end
+
+      add_raw_output(@printer.output)
     end
 
     def finish(state)
-      return if @events_count == 0
-
-      @lock.synchronize do
-        @done = true
-        done_with_stage(state)
-        render
-      end
+      @printer.finish
+      add_raw_output(@printer.output)
+      super
     end
 
     private
 
-    def append_stage_header
-      @buffer.print "\n#{@current_stage}\n"
-    end
-
-    def done_with_stage(state = nil)
-      return unless @in_progress
-
-      if @last_event
-        completion_time = Time.at(@last_event['time']) rescue Time.now
-      else
-        completion_time = Time.now
-      end
-
-      if state.nil?
-        state = @stage_has_error ? 'error' : 'done'
-      end
-
-      case state.to_s
-      when 'done'
-        progress_bar.title = 'Done'.make_green
-        progress_bar.finished_steps = progress_bar.total
-      when 'error'
-        progress_bar.title = 'Error'.make_red
-      else
-        progress_bar.title = 'Not done'.make_yellow
-      end
-
-      progress_bar.bar_visible = false
-      progress_bar.label = format_time(completion_time - @stage_start_time)
-      progress_bar.refresh
-      @buffer.print "\n"
-      @in_progress = false
-    end
-
-    def progress_bar
-      @progress_bars[@current_stage] ||= StageProgressBar.new(@buffer)
-    end
-
-    # We have to trust the first event in each stage
-    # to have correct "total" and "current" fields.
-    def append_event(event)
-      validate_event(event)
-
-      progress = 0
-      total = event['total'].to_i
-
-      if event['state'] == 'started'
-        task = Task.new(event['task'])
-      else
-        task = @tasks[event['index']]
-      end
-
-      event_data = event['data'] || {}
-      # Ignoring out-of-order events
-      return if task.nil?
-
-      @events_count += 1
-      @last_event = event
-
-      case event['state']
-      when 'started'
-        @total_duration.started_at = event['time']
-
-        begin
-          task.start_time = Time.at(event['time'])
-        rescue
-          task.start_time = Time.now
-        end
-
-        task.progress = 0
-
-        @tasks[event['index']] = task
-
-        if @tasks.size > @tasks_batch_size
-          # Heuristics here: we assume that local maximum of
-          # tasks number is a "max_in_flight" value and batches count
-          # should only be recalculated once we refresh this maximum.
-          # It's unlikely that the first task in a batch will be finished
-          # before the last one is started so @done_tasks is expected
-          # to only have canaries.
-          @tasks_batch_size = @tasks.size
-          @non_canary_event_start_time = task.start_time
-          @batches_count = ((total - @done_tasks.size) / @tasks_batch_size.to_f).ceil
-        end
-
-      when 'finished', 'failed'
-        @tasks.delete(event['index'])
-        @done_tasks << task
-
-        @total_duration.finished_at = event['time']
-
-        begin
-          task.finish_time = Time.at(event['time'])
-        rescue
-          task.finish_time = Time.now
-        end
-
-        task_time = task.finish_time - task.start_time
-
-        n_done_tasks = @done_tasks.size.to_f
-        @running_avg = @running_avg * (n_done_tasks - 1) / n_done_tasks + task_time.to_f / n_done_tasks
-
-        progress = 1
-        progress_bar.finished_steps += 1
-        progress_bar.label = time_with_eta(task_time, @eta)
-        progress_bar.clear_line
-
-        task_name = task.name.to_s
-        if task_name !~ /^[A-Z]{2}/
-          task_name = task_name[0..0].to_s.downcase + task_name[1..-1].to_s
-        end
+    def parse_event(event_line)
+      return if event_line.start_with?('#')
 
-        if event['state'] == 'failed'
-          status = [task_name.make_red, event_data['error']].compact.join(': ')
-          @stage_has_error = true
-        else
-          status = task_name.make_yellow
+      JSON.parse(event_line).tap do |result|
+        unless result.kind_of?(Hash)
+          raise InvalidEvent, "Hash expected, #{result.class} given"
         end
-        @buffer.puts("  #{status} (#{format_time(task_time)})")
-
-      when 'in_progress'
-        progress = [event['progress'].to_f / 100, 1].min
       end
 
-      if @batches_count > 0 && @non_canary_event_start_time
-        @eta = adjusted_time(@non_canary_event_start_time + @running_avg * @batches_count)
-      end
-
-      progress_bar_gain = progress - task.progress
-      task.progress = progress
-
-      progress_bar.total = total
-      progress_bar.title = @tasks.values.map { |t| t.name }.sort.join(', ')
-
-      progress_bar.current += progress_bar_gain
-      progress_bar.refresh
-
-      @in_progress = true
+    rescue JSON::JSONError => e
+      raise InvalidEvent, "Invalid JSON: #{e.message}"
     end
 
-    def parse_event(event_line)
-      event = JSON.parse(event_line)
-      unless event.kind_of?(Hash)
-        raise InvalidEvent, "Hash expected, #{event.class} given"
-      end
-      event
-    rescue JSON::JSONError
-      raise InvalidEvent, 'Cannot parse event, invalid JSON'
-    end
+    def add_event(event)
+      @total_duration.started_at = event['time']
+      @total_duration.finished_at = event['time']
 
-    def validate_event(event)
-      unless event['time'] && event['stage'] && event['task'] &&
-        event['index'] && event['total'] && event['state']
-        raise InvalidEvent, 'Invalid event structure: stage, time, task, ' +
-          'index, total, state are all required'
+      if event['type'] == 'deprecation'
+        show_deprecation(event)
+      elsif event['error']
+        show_error(event)
+      else
+        show_stage_or_task(event)
       end
     end
 
-    def time_with_eta(time, eta)
-      time_fmt = format_time(time)
-      eta_fmt = eta && eta > Time.now ? format_time(eta - Time.now) : '--:--:--'
-      "#{time_fmt}  ETA: #{eta_fmt}"
-    end
-
-    def adjusted_time(time)
-      time + @time_adjustment.to_f
+    def show_deprecation(event)
+      msg = "Deprecation: #{event['message']}"
+      @printer.print(:line_around, msg.make_red)
     end
 
-    def can_handle_event_without_progress_bar?(event)
-      @stages_without_progress_bar.include?(event['stage'])
-    end
-
-    def handle_event_without_progress_bar(event)
-      @total_duration.started_at = event['time']
-      @total_duration.finished_at = event['time']
-      stage_collection.update_with_event(event)
-    end
-
-    def stage_collection
-      @stage_collection ||= StageCollection.new(
-        stage_started: ->(stage){
-          @buffer.print("  Started #{header_for_stage(stage)}\n")
-        },
-        stage_finished: ->(stage){
-          duration = stage.duration ? " (#{format_time(stage.duration)})" : ''
-          @buffer.print("     Done #{header_for_stage(stage)}#{duration}\n\n")
-        },
-        stage_failed: ->(stage){
-          duration = stage.duration ? " (#{format_time(stage.duration)})" : ''
-          @buffer.print("   Failed #{header_for_stage(stage)}#{duration}\n")
-        },
-
-        task_started: ->(task){
-          @buffer.print("  Started #{header_for_task(task)}\n")
-        },
-        task_finished: ->(task){
-          duration = task.duration ? " (#{format_time(task.duration)})" : ''
-          @buffer.print("     Done #{header_for_task(task)}#{duration}\n")
-        },
-        task_failed: ->(task){
-          error_msg = task.error
-          error_msg = ": #{error_msg.make_red}" if error_msg
-          duration = task.duration ? " (#{format_time(task.duration)})" : ''
-          @buffer.print("   Failed #{header_for_task(task)}#{duration}#{error_msg}\n")
-        },
-      )
-    end
+    def show_error(event)
+      error   = event['error'] || {}
+      code    = error['code']
+      message = error['message']
 
-    def header_for_stage(stage)
-      tags = stage.tags
-      tags_str = tags.size > 0 ? ' ' + tags.sort.join(', ').make_green : ''
-      "#{stage.name.downcase}#{tags_str}"
-    end
+      msg  = 'Error'
+      msg += " #{code}" if code
+      msg += ": #{message}" if message
 
-    def header_for_task(task)
-      tags = task.stage.tags
-      tags_str = tags.size > 0 ? ' ' + tags.sort.join(', ').make_green : ''
-      "#{task.stage.name.downcase}#{tags_str}: #{task.name}"
+      @printer.print(:line_around, msg.make_red)
     end
 
-    class Task
-      attr_accessor :name
-      attr_accessor :progress
-      attr_accessor :start_time
-      attr_accessor :finish_time
+    REQUIRED_STAGE_EVENT_KEYS = %w(time stage task index total state).freeze
 
-      def initialize(name)
-        @name = name
-        @progress = 0
-        @start_time = nil
-        @finish_time = nil
+    def show_stage_or_task(event)
+      REQUIRED_STAGE_EVENT_KEYS.each do |key|
+        unless event.has_key?(key)
+          raise InvalidEvent, "Missing event key: #{key}"
+        end
       end
+
+      @stage_collection.update_with_event(event)
     end
   end
 end

data/lib/cli/task_tracking/smart_whitespace_printer.rb

@@ -0,0 +1,56 @@
+require 'stringio'
+
+module Bosh::Cli::TaskTracking
+  class SmartWhitespacePrinter
+    VALID_SEPARATORS = [:line_around, :line_before, :before, :none].freeze
+
+    SPACE_BETWEEN_LAST_SEP_AND_SEP = {
+      [:line_around, :line_around] => "\n\n",
+      [:line_around, :line_before] => "\n\n",
+      [:line_around, :before] => "\n\n",
+      [:line_around, :none]   => "\n\n",
+
+      [:line_before, :line_around] => "\n\n",
+      [:line_before, :line_before] => "\n\n",
+      [:line_before, :before] => "\n",
+      [:line_before, :none]   => nil,
+
+      [:before, :line_around] => "\n\n",
+      [:before, :line_before] => "\n\n",
+      [:before, :before] => "\n",
+      [:before, :none]   => nil,
+
+      [:none, :line_around] => "\n\n",
+      [:none, :line_before] => "\n\n",
+      [:none, :before] => "\n",
+      [:none, :none]   => nil,
+    }.freeze
+
+    def initialize
+      @buffer = StringIO.new
+      @last_sep = :start
+    end
+
+    def print(separator, msg)
+      unless VALID_SEPARATORS.include?(separator)
+        raise ArgumentError, "Unknown separator #{separator.inspect}"
+      end
+
+      space = SPACE_BETWEEN_LAST_SEP_AND_SEP[[@last_sep, separator]]
+      @buffer.print(space) if space
+
+      @last_sep = separator
+      @buffer.print(msg)
+    end
+
+    def output
+      @buffer.string.tap { @buffer.string = '' }
+    end
+
+    def finish
+      if VALID_SEPARATORS.include?(@last_sep)
+        @buffer.print("\n")
+      end
+    end
+  end
+end

data/lib/cli/task_tracking/stage_collection.rb

@@ -9,7 +9,7 @@ module Bosh::Cli::TaskTracking
 
     def update_with_event(event)
       new_stage = Stage.new(event['stage'], event['tags'], event['total'], @callbacks)
-      unless found_stage = @stages.find { |s| s.name == new_stage.name && s.tags == new_stage.tags }
+      unless found_stage = @stages.find { |s| s == new_stage }
         found_stage = new_stage
         @stages << new_stage
       end
@@ -31,14 +31,14 @@ module Bosh::Cli::TaskTracking
 
     def update_with_event(event)
       new_task = Task.new(self, event['task'], event['progress'], @callbacks)
-      unless found_task = @tasks.find { |t| t.name == new_task.name }
+      unless found_task = @tasks.find { |s| s == new_task }
         found_task = new_task
         @tasks << new_task
       end
-      fire_started_callback(event)
+      fire_started_callback if started?
       found_task.update_with_event(event)
-      fire_finished_callback(event)
-      fire_failed_callback(event)
+      fire_finished_callback if finished?(event)
+      fire_failed_callback if failed?(event)
       found_task
     end
 
@@ -55,28 +55,59 @@ module Bosh::Cli::TaskTracking
       total_duration.duration
     end
 
+    def similar?(other)
+      return false unless other.is_a?(Stage)
+      name == other.name
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Stage)
+      [name, tags, total] == [other.name, other.tags, other.total]
+    end
+
     private
 
-    def fire_started_callback(event)
-      if event['state'] == 'started' && event['index'] == 1
-        callback = @callbacks[:stage_started]
-        callback.call(self) if callback
-      end
+    def fire_started_callback
+      callback = @callbacks[:stage_started]
+      callback.call(self) if callback
     end
 
-    def fire_finished_callback(event)
-      if event['state'] == 'finished' && ((event['index'] == event['total']) || event['total'].nil?)
-        callback = @callbacks[:stage_finished]
-        callback.call(self) if callback
-      end
+    def fire_finished_callback
+      callback = @callbacks[:stage_finished]
+      callback.call(self) if callback
     end
 
-    def fire_failed_callback(event)
-      if event['state'] == 'failed'
-        # If there are multiple failures do we need to only fire on the first one?
-        callback = @callbacks[:stage_failed]
-        callback.call(self) if callback
-      end
+    def fire_failed_callback
+      callback = @callbacks[:stage_failed]
+      callback.call(self) if callback
+    end
+
+    def started?
+      @started = true if !@started
+    end
+
+    def finished?(event)
+      seen_all_tasks?(event) && all_tasks_finished?
+    end
+
+    def failed?(event)
+      seen_all_tasks?(event) && all_tasks_done? && any_tasks_failed?
+    end
+
+    def all_tasks_done?
+      tasks.all? { |t| t.done? }
+    end
+
+    def all_tasks_finished?
+      tasks.all? { |t| t.finished? }
+    end
+
+    def any_tasks_failed?
+      tasks.any? { |t| t.failed? }
+    end
+
+    def seen_all_tasks?(event)
+      tasks.size == event['total'] || event['total'].nil?
     end
   end
 
@@ -105,6 +136,23 @@ module Bosh::Cli::TaskTracking
       call_state_callback
     end
 
+    def ==(other)
+      return false unless other.is_a?(Task)
+      [stage, name] == [other.stage, other.name]
+    end
+
+    def done?
+      %w(failed finished).include?(@state)
+    end
+
+    def failed?
+      @state == 'failed'
+    end
+
+    def finished?
+      @state == 'finished'
+    end
+
     private
 
     def call_state_callback

data/lib/cli/task_tracking/stage_collection_presenter.rb

@@ -0,0 +1,111 @@
+module Bosh::Cli::TaskTracking
+  class StageCollectionPresenter
+    JUSTIFY = 9
+
+    def initialize(printer)
+      @printer = printer
+      @last_stage = nil
+      @last_task = nil
+    end
+
+    def start_stage(stage)
+      msg_new_line = "  Started #{header_for_stage(stage)}"
+
+      # Assume that duplicate start events are never received
+      if stage.similar?(@last_stage)
+        @printer.print(:before, msg_new_line)
+      else
+        @printer.print(:line_before, msg_new_line)
+      end
+
+      @last_stage = stage
+      @last_task = nil
+    end
+
+    def finish_stage(stage)
+      end_stage(stage, 'Done')
+    end
+
+    def fail_stage(stage)
+      end_stage(stage, 'Failed')
+    end
+
+    def end_stage(stage, prefix_msg)
+      duration = duration_str(stage)
+      msg = "#{prefix_msg.rjust(JUSTIFY)} #{header_for_stage(stage)}#{duration}"
+
+      if stage == @last_stage
+        if stage.total == 1
+          # end_task added inline end message
+        else
+          @printer.print(:before, msg)
+        end
+      else
+        @printer.print(:line_before, msg)
+      end
+
+      @last_stage = stage
+      @last_task = nil
+    end
+
+    def start_task(task)
+      msg = "  Started #{full_header_for_task(task)}"
+
+      if task.stage == @last_stage && task.stage.total == 1
+        @printer.print(:none, " > #{task.name.make_green}")
+      elsif task.stage.similar?(@last_stage)
+        @printer.print(:before, msg)
+      else
+        @printer.print(:line_before, msg)
+      end
+
+      @last_stage = task.stage
+      @last_task = task
+    end
+
+    def finish_task(task)
+      end_task(task, 'Done', nil)
+    end
+
+    def fail_task(task)
+      error_msg = task.error
+      error_msg = ": #{error_msg.make_red}" if error_msg
+
+      end_task(task, 'Failed', error_msg)
+    end
+
+    def end_task(task, prefix_msg, suffix_msg)
+      duration = duration_str(task)
+      msg = "#{prefix_msg.rjust(JUSTIFY)} #{full_header_for_task(task)}#{suffix_msg}#{duration}"
+
+      if task == @last_task
+        @printer.print(:none, ". #{prefix_msg}#{suffix_msg}#{duration}")
+      elsif task.stage.similar?(@last_stage)
+        @printer.print(:before, msg)
+      else
+        @printer.print(:line_before, msg)
+      end
+
+      @last_stage = task.stage
+      @last_task = task
+    end
+
+    private
+
+    def header_for_stage(stage)
+      "#{stage.name.downcase}#{tags_for_stage(stage)}"
+    end
+
+    def full_header_for_task(task)
+      "#{task.stage.name.downcase}#{tags_for_stage(task.stage)} > #{task.name.make_green}"
+    end
+
+    def tags_for_stage(stage)
+      stage.tags.size > 0 ? ' ' + stage.tags.sort.join(', ').make_green : ''
+    end
+
+    def duration_str(stage_or_task)
+      stage_or_task.duration ? " (#{format_time(stage_or_task.duration)})" : ''
+    end
+  end
+end

data/lib/cli/task_tracking/task_log_renderer.rb

@@ -1,20 +1,8 @@
 module Bosh::Cli::TaskTracking
   class TaskLogRenderer
-    EVENT_LOG_STAGES_WITHOUT_PROGRESS_BAR = [
-      'Preparing DNS',
-      'Creating bound missing VMs',
-      'Binding instance VMs',
-      'Updating job',
-      'Deleting unneeded instances',
-      'Running errand',
-      'Deleting instances',
-      'Refilling resource pools',
-    ]
-
     def self.create_for_log_type(log_type)
       if log_type == 'event'
-        EventLogRenderer.new(stages_without_progress_bar:
-          EVENT_LOG_STAGES_WITHOUT_PROGRESS_BAR)
+        EventLogRenderer.new
       elsif log_type == 'result' || log_type == 'none'
         NullTaskLogRenderer.new
       else
@@ -28,16 +16,12 @@ module Bosh::Cli::TaskTracking
     def initialize
       @out = Bosh::Cli::Config.output || $stdout
       @out.sync = true
-      @lock = Mutex.new
       @output = ''
+
       @time_adjustment = 0
       @duration = nil
     end
 
-    def duration_known?
-      false
-    end
-
     def add_output(output)
       @output = output
     end
@@ -49,7 +33,10 @@ module Bosh::Cli::TaskTracking
 
     def finish(state)
       refresh
-      @done = true
+    end
+
+    def duration_known?
+      false
     end
   end
 end

data/lib/cli/version.rb

@@ -1,5 +1,5 @@
 module Bosh
   module Cli
-    VERSION = '1.2200.0'
+    VERSION = '1.2291.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bosh_cli
 version: !ruby/object:Gem::Version
-  version: 1.2200.0
+  version: 1.2291.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-14 00:00:00.000000000 Z
+date: 2014-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bosh_common
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.2200.0
+        version: 1.2291.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.2200.0
+        version: 1.2291.0
 - !ruby/object:Gem::Dependency
   name: json_pure
   requirement: !ruby/object:Gem::Requirement
@@ -114,7 +114,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.2200.0
+        version: 1.2291.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -122,7 +122,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.2200.0
+        version: 1.2291.0
 - !ruby/object:Gem::Dependency
   name: net-ssh
   requirement: !ruby/object:Gem::Requirement
@@ -269,7 +269,7 @@ dependencies:
         version: '0'
 description: ! 'BOSH CLI
 
-  87cbf9'
+  51a1bb'
 email: support@cloudfoundry.com
 executables:
 - bosh
@@ -346,8 +346,9 @@ files:
 - lib/cli/task_tracking.rb
 - lib/cli/task_tracking/event_log_renderer.rb
 - lib/cli/task_tracking/null_task_log_renderer.rb
+- lib/cli/task_tracking/smart_whitespace_printer.rb
 - lib/cli/task_tracking/stage_collection.rb
-- lib/cli/task_tracking/stage_progress_bar.rb
+- lib/cli/task_tracking/stage_collection_presenter.rb
 - lib/cli/task_tracking/task_log_renderer.rb
 - lib/cli/task_tracking/task_tracker.rb
 - lib/cli/task_tracking/total_duration.rb
@@ -379,7 +380,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1307915788410922984
+      hash: -3167564348924441903
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23

data/lib/cli/task_tracking/stage_progress_bar.rb

@@ -1,59 +0,0 @@
-module Bosh::Cli::TaskTracking
-  class StageProgressBar
-    attr_accessor :total
-    attr_accessor :title
-    attr_accessor :current
-    attr_accessor :label
-    attr_accessor :bar_visible
-    attr_accessor :finished_steps
-    attr_accessor :terminal_width
-
-    def initialize(output)
-      @output = output
-      @current = 0
-      @total = 100
-      @bar_visible = true
-      @finished_steps = 0
-      @filler = 'o'
-      @terminal_width = calculate_terminal_width
-      @bar_width = (0.24 * @terminal_width).to_i # characters
-    end
-
-    def refresh
-      clear_line
-      bar_repr = @bar_visible ? bar : ''
-      title_width = (0.35 * @terminal_width).to_i
-      title = @title.truncate(title_width).ljust(title_width)
-      @output.print "#{title} #{bar_repr} #{@finished_steps}/#{@total}"
-      @output.print " #{@label}" if @label
-    end
-
-    def bar
-      n_fillers = @total == 0 ? 0 : [(@bar_width *
-        (@current.to_f / @total.to_f)).floor, 0].max
-
-      fillers = "#{@filler}" * n_fillers
-      spaces = ' ' * [(@bar_width - n_fillers), 0].max
-      "|#{fillers}#{spaces}|"
-    end
-
-    def clear_line
-      @output.print("\r")
-      @output.print(' ' * @terminal_width)
-      @output.print("\r")
-    end
-
-    def calculate_terminal_width
-      if ENV['COLUMNS'].to_s =~ /^\d+$/
-        ENV['COLUMNS'].to_i
-      elsif !ENV['TERM'].blank?
-        width = `tput cols`
-        $?.exitstatus == 0 ? [width.to_i, 100].min : 80
-      else
-        80
-      end
-    rescue
-      80
-    end
-  end
-end