chef 11.12.8 → 11.14.0.alpha.2

data/lib/chef/event_dispatch/base.rb

@@ -277,6 +277,20 @@ class Chef
       def resource_updated(resource, action)
       end
 
+      # A stream has opened.
+      def stream_opened(stream, options = {})
+      end
+
+      # A stream has closed.
+      def stream_closed(stream, options = {})
+      end
+
+      # A chunk of data from a stream.  The stream is managed by "stream," which
+      # can be any tag whatsoever.  Data in different "streams" may not be placed
+      # on the same line or even sent to the same console.
+      def stream_output(stream, output, options = {})
+      end
+
       # Called before handlers run
       def handlers_start(handler_count)
       end

data/lib/chef/event_dispatch/events_output_stream.rb

@@ -0,0 +1,29 @@
+class Chef
+  module EventDispatch
+    class EventsOutputStream
+      # This is a fake stream that connects to events.
+      #
+      # == Arguments
+      # events: the EventDispatch object to send data to (run_context.events)
+      # options is a hash with these possible options:
+      # - name: a string that identifies the stream to the user. Preferably short.
+
+      def initialize(events, options = {})
+        @events = events
+        @options = options
+        events.stream_opened(self, options)
+      end
+
+      attr_reader :options
+      attr_reader :events
+
+      def print(str)
+        events.stream_output(self, str, options)
+      end
+
+      def close
+        events.stream_closed(self, options)
+      end
+    end
+  end
+end

data/lib/chef/exceptions.rb

@@ -321,5 +321,13 @@ class Chef
         super "This functionality is not supported on platform #{platform}."
       end
     end
+
+    # Raised when Chef::Config[:run_lock_timeout] is set and some other client run fails
+    # to release the run lock becure Chef::Config[:run_lock_timeout] seconds pass.
+    class RunLockTimeout < RuntimeError
+      def initialize(duration, blocking_pid)
+        super "Unable to acquire lock. Waited #{duration} seconds for #{blocking_pid} to release."
+      end
+    end
   end
 end

data/lib/chef/formatters/base.rb

@@ -21,6 +21,7 @@ require 'chef/event_dispatch/base'
 require 'chef/formatters/error_inspectors'
 require 'chef/formatters/error_descriptor'
 require 'chef/formatters/error_mapper'
+require 'chef/formatters/indentable_output_stream'
 
 class Chef
 
@@ -56,47 +57,6 @@ class Chef
       formatter_class.new(out, err)
     end
 
-    # == Outputter
-    # Handles basic printing tasks like colorizing.
-    # --
-    # TODO: Duplicates functionality from knife, upfactor.
-    class Outputter
-
-      attr_reader :out
-      attr_reader :err
-
-      def initialize(out, err)
-        @out, @err = out, err
-      end
-
-      def highline
-        @highline ||= begin
-          require 'highline'
-          HighLine.new
-        end
-      end
-
-      def color(string, *colors)
-        if Chef::Config[:color]
-          @out.print highline.color(string, *colors)
-        else
-          @out.print string
-        end
-      end
-
-      alias :print :color
-
-      def puts(string, *colors)
-        if Chef::Config[:color]
-          @out.puts highline.color(string, *colors)
-        else
-          @out.puts string
-        end
-      end
-
-    end
-
-
     # == Formatters::Base
     # Base class that all formatters should inherit from.
     class Base < EventDispatch::Base
@@ -112,7 +72,7 @@ class Chef
       attr_reader :output
 
       def initialize(out, err)
-        @output = Outputter.new(out, err)
+        @output = IndentableOutputStream.new(out, err)
       end
 
       def puts(*args)
@@ -123,8 +83,20 @@ class Chef
         @output.print(*args)
       end
 
+      def puts_line(*args)
+        @output.puts_line(*args)
+      end
+
+      def start_line(*args)
+        @output.start_line(*args)
+      end
+
+      def indent_by(amount)
+        @output.indent += amount
+      end
+
       # Input: a Formatters::ErrorDescription object.
-      # Outputs error to SDOUT.
+      # Outputs error to STDOUT.
       def display_error(description)
         puts("")
         description.display(output)
@@ -237,7 +209,7 @@ class Chef
 
 
     # == NullFormatter
-    # Formatter that doesn't actually produce any ouput. You can use this to
+    # Formatter that doesn't actually produce any output. You can use this to
     # disable the use of output formatters.
     class NullFormatter < Base
 
@@ -247,4 +219,3 @@ class Chef
 
   end
 end
-

data/lib/chef/formatters/doc.rb

@@ -10,7 +10,6 @@ class Chef
 
       attr_reader :start_time, :end_time
       cli_name(:doc)
-      
 
       def initialize(out, err)
         super
@@ -26,7 +25,7 @@ class Chef
       end
 
       def run_start(version)
-        puts "Starting Chef Client, version #{version}"
+        puts_line "Starting Chef Client, version #{version}"
       end
 
       def total_resources
@@ -36,18 +35,18 @@ class Chef
       def run_completed(node)
         @end_time = Time.now
         if Chef::Config[:why_run]
-          puts "Chef Client finished, #{@updated_resources}/#{total_resources} resources would have been updated"
+          puts_line "Chef Client finished, #{@updated_resources}/#{total_resources} resources would have been updated"
         else
-          puts "Chef Client finished, #{@updated_resources}/#{total_resources} resources updated in #{elapsed_time} seconds"
+          puts_line "Chef Client finished, #{@updated_resources}/#{total_resources} resources updated in #{elapsed_time} seconds"
         end
       end
 
       def run_failed(exception)
         @end_time = Time.now
         if Chef::Config[:why_run]
-          puts "Chef Client failed. #{@updated_resources} resources would have been updated"
+          puts_line "Chef Client failed. #{@updated_resources} resources would have been updated"
         else
-          puts "Chef Client failed. #{@updated_resources} resources updated in #{elapsed_time} seconds"
+          puts_line "Chef Client failed. #{@updated_resources} resources updated in #{elapsed_time} seconds"
         end
       end
 
@@ -61,7 +60,7 @@ class Chef
 
       # About to attempt to register as +node_name+
       def registration_start(node_name, config)
-        puts "Creating a new client identity for #{node_name} using the validator key."
+        puts_line "Creating a new client identity for #{node_name} using the validator key."
       end
 
       def registration_completed
@@ -82,7 +81,7 @@ class Chef
 
       # Called before the cookbook collection is fetched from the server.
       def cookbook_resolution_start(expanded_run_list)
-        puts "resolving cookbooks for run list: #{expanded_run_list.inspect}"
+        puts_line "resolving cookbooks for run list: #{expanded_run_list.inspect}"
       end
 
       # Called when there is an error getting the cookbook collection from the
@@ -111,12 +110,13 @@ class Chef
 
       # Called before cookbook sync starts
       def cookbook_sync_start(cookbook_count)
-        puts "Synchronizing Cookbooks:"
+        puts_line "Synchronizing Cookbooks:"
+        indent
       end
 
       # Called when cookbook +cookbook_name+ has been sync'd
       def synchronized_cookbook(cookbook_name)
-        puts "  - #{cookbook_name}"
+        puts_line "- #{cookbook_name}"
       end
 
       # Called when an individual file in a cookbook has been updated
@@ -125,11 +125,12 @@ class Chef
 
       # Called after all cookbooks have been sync'd.
       def cookbook_sync_complete
+        unindent
       end
 
       # Called when cookbook loading starts.
       def library_load_start(file_count)
-        puts "Compiling Cookbooks..."
+        puts_line "Compiling Cookbooks..."
       end
 
       # Called after a file in a cookbook is loaded.
@@ -142,11 +143,12 @@ class Chef
 
       # Called before convergence starts
       def converge_start(run_context)
-        puts "Converging #{run_context.resource_collection.all_resources.size} resources"
+        puts_line "Converging #{run_context.resource_collection.all_resources.size} resources"
       end
 
       # Called when the converge phase is finished.
       def converge_complete
+        unindent if @current_recipe
       end
 
       # Called before action is executed on a resource.
@@ -157,12 +159,15 @@ class Chef
           resource_recipe = "<Dynamically Defined Resource>"
         end
 
-        if resource_recipe != @current_recipe
-          puts "Recipe: #{resource_recipe}"
+        if resource_recipe != @current_recipe && !resource.enclosing_provider
+          unindent if @current_recipe
+          puts_line "Recipe: #{resource_recipe}"
           @current_recipe = resource_recipe
+          indent
         end
         # TODO: info about notifies
-        print "  * #{resource} action #{action}"
+        start_line "* #{resource} action #{action}", :stream => resource
+        indent
       end
 
       # Called when a resource fails, but will retry.
@@ -172,12 +177,14 @@ class Chef
       # Called when a resource fails and will not be retried.
       def resource_failed(resource, action, exception)
         super
+        unindent
       end
 
       # Called when a resource action has been skipped b/c of a conditional
       def resource_skipped(resource, action, conditional)
         # TODO: more info about conditional
-        puts " (skipped due to #{conditional.short_description})"
+        puts " (skipped due to #{conditional.short_description})", :stream => resource
+        unindent
       end
 
       # Called after #load_current_resource has run.
@@ -187,11 +194,13 @@ class Chef
       # Called when a resource has no converge actions, e.g., it was already correct.
       def resource_up_to_date(resource, action)
         @up_to_date_resources+= 1
-        puts " (up to date)"
+        puts " (up to date)", :stream => resource
+        unindent
       end
 
       def resource_bypassed(resource, action, provider)
-        puts " (Skipped: whyrun not supported by provider #{provider.class.name})"
+        puts " (Skipped: whyrun not supported by provider #{provider.class.name})", :stream => resource
+        unindent
       end
 
       def output_record(line)
@@ -207,12 +216,12 @@ class Chef
           next if line.nil?
           output_record line
           if line.kind_of? String
-            @output.color "\n    - #{prefix}#{line}", :green
+            start_line "- #{prefix}#{line}", :green
           elsif line.kind_of? Array
             # Expanded output - delta
             # @todo should we have a resource_update_delta callback?
             line.each do |detail|
-              @output.color "\n        #{detail}", :white
+              start_line detail, :white
             end
           end
         end
@@ -221,28 +230,36 @@ class Chef
       # Called after a resource has been completely converged.
       def resource_updated(resource, action)
         @updated_resources += 1
+        unindent
         puts "\n"
       end
 
       # Called when resource current state load is skipped due to the provider
       # not supporting whyrun mode.
       def resource_current_state_load_bypassed(resource, action, current_resource)
-        @output.color("\n    * Whyrun not supported for #{resource}, bypassing load.", :yellow)
+        puts_line("* Whyrun not supported for #{resource}, bypassing load.", :yellow)
+      end
+
+      def stream_output(stream, output, options = {})
+        print(output, { :stream => stream }.merge(options))
       end
 
       # Called before handlers run
       def handlers_start(handler_count)
-        puts "\nRunning handlers:"
+        puts ''
+        puts "Running handlers:"
+        indent
       end
 
       # Called after an individual handler has run
       def handler_executed(handler)
-        puts "  - #{handler.class.name}"
+        puts_line "- #{handler.class.name}"
       end
 
       # Called after all handlers have executed
       def handlers_completed
-        puts "Running handlers complete\n"
+        unindent
+        puts_line "Running handlers complete\n"
       end
 
       # Called when a provider makes an assumption after a failed assertion
@@ -250,7 +267,7 @@ class Chef
       def whyrun_assumption(action, resource, message)
         return unless message
         [ message ].flatten.each do |line|
-          @output.color("\n    * #{line}", :yellow)
+          start_line("* #{line}", :yellow)
         end
       end
 
@@ -259,9 +276,17 @@ class Chef
         return unless message
         color = Chef::Config[:why_run] ? :yellow : :red
         [ message ].flatten.each do |line|
-          @output.color("\n    * #{line}", color)
+          start_line("* #{line}", color)
         end
       end
+
+      def indent
+        indent_by(2)
+      end
+
+      def unindent
+        indent_by(-2)
+      end
     end
   end
 end

data/lib/chef/formatters/indentable_output_stream.rb

@@ -0,0 +1,165 @@
+class Chef
+  module Formatters
+    # Handles basic indentation and colorization tasks
+    class IndentableOutputStream
+
+      attr_reader :out
+      attr_reader :err
+      attr_accessor :indent
+      attr_reader :line_started
+      attr_accessor :current_stream
+      attr_reader :semaphore
+
+      def initialize(out, err)
+        @out, @err = out, err
+        @indent = 0
+        @line_started = false
+        @semaphore = Mutex.new
+      end
+
+      def highline
+        @highline ||= begin
+          require 'highline'
+          HighLine.new
+        end
+      end
+
+      # Print text.  This will start a new line and indent if necessary
+      # but will not terminate the line (future print and puts statements
+      # will start off where this print left off).
+      def color(string, *args)
+        print(string, from_args(args))
+      end
+
+      # Print the start of a new line.  This will terminate any existing lines and
+      # cause indentation but will not move to the next line yet (future 'print'
+      # and 'puts' statements will stay on this line).
+      def start_line(string, *args)
+        print(string, from_args(args, :start_line => true))
+      end
+
+      # Print a line.  This will continue from the last start_line or print,
+      # or start a new line and indent if necessary.
+      def puts(string, *args)
+        print(string, from_args(args, :end_line => true))
+      end
+
+      # Print an entire line from start to end.  This will terminate any existing
+      # lines and cause indentation.
+      def puts_line(string, *args)
+        print(string, from_args(args, :start_line => true, :end_line => true))
+      end
+
+      # Print a string.
+      #
+      # == Arguments
+      # string: string to print.
+      # options: a hash with these possible options:
+      # - :stream => OBJ: unique identifier for a stream. If two prints have
+      #           different streams, they will print on separate lines.
+      #           Otherwise, they will stay together.
+      # - :start_line => BOOLEAN: if true, print will begin on a blank (indented) line.
+      # - :end_line => BOOLEAN: if true, current line will be ended.
+      # - :name => STRING: a name to prefix in front of a stream. It will be printed
+      #           once (with the first line of the stream) and subsequent lines
+      #           will be indented to match.
+      #
+      # == Alternative
+      #
+      # You may also call print('string', :red) (a list of colors a la Highline.color)
+      def print(string, *args)
+        options = from_args(args)
+
+        # Make sure each line stays a unit even with threads sending output
+        semaphore.synchronize do
+          if should_start_line?(options)
+            move_to_next_line
+          end
+
+          print_string(string, options)
+
+          if should_end_line?(options)
+            move_to_next_line
+          end
+        end
+      end
+
+      private
+
+      def should_start_line?(options)
+        options[:start_line] || @current_stream != options[:stream]
+      end
+
+      def should_end_line?(options)
+        options[:end_line] && @line_started
+      end
+
+      def from_args(colors, merge_options = {})
+        if colors.size == 1 && colors[0].kind_of?(Hash)
+          merge_options.merge(colors[0])
+        else
+          merge_options.merge({ :colors => colors })
+        end
+      end
+
+      def print_string(string, options)
+        if string.empty?
+          if options[:end_line]
+            print_line('', options)
+          end
+        else
+          string.lines.each do |line|
+            print_line(line, options)
+          end
+        end
+      end
+
+      def print_line(line, options)
+        indent_line(options)
+
+        # Note that the next line will need to be started
+        if line[-1..-1] == "\n"
+          @line_started = false
+        end
+
+        if Chef::Config[:color] && options[:colors]
+          @out.print highline.color(line, *options[:colors])
+        else
+          @out.print line
+        end
+      end
+
+      def move_to_next_line
+        if @line_started
+          @out.puts ''
+          @line_started = false
+        end
+      end
+
+      def indent_line(options)
+        if !@line_started
+
+          # Print indents.  If there is a stream name, either print it (if we're
+          # switching streams) or print enough blanks to match
+          # the indents.
+          if options[:name]
+            if @current_stream != options[:stream]
+              @out.print "#{(' ' * indent)}[#{options[:name]}] "
+            else
+              @out.print ' ' * (indent + 3 + options[:name].size)
+            end
+          else
+            # Otherwise, just print indents.
+            @out.print ' ' * indent
+          end
+
+          if @current_stream != options[:stream]
+            @current_stream = options[:stream]
+          end
+
+          @line_started = true
+        end
+      end
+    end
+  end
+end