puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/lib/puppet/util/command_line.rb

@@ -11,7 +11,6 @@ end
 
 require 'puppet'
 require 'puppet/util'
-require "puppet/util/plugins"
 require "puppet/util/rubygems"
 require "puppet/util/limits"
 require 'puppet/util/colors'
@@ -24,7 +23,7 @@ module Puppet
     class CommandLine
       include Puppet::Util::Limits
 
-      OPTION_OR_MANIFEST_FILE = /^-|\.pp$|\.rb$/
+      OPTION_OR_MANIFEST_FILE = /^-|\.pp$/
 
       # @param zero [String] the name of the executable
       # @param argv [Array<String>] the arguments passed on the command line
@@ -32,7 +31,6 @@ module Puppet
       def initialize(zero = $0, argv = ARGV, stdin = STDIN)
         @command = File.basename(zero, '.rb')
         @argv = argv
-        Puppet::Plugins.on_commandline_initialization(:command_line_object => self)
       end
 
       # @return [String] name of the subcommand is being executed
@@ -59,24 +57,6 @@ module Puppet
         end
       end
 
-      # @api private
-      # @deprecated
-      def self.available_subcommands
-        Puppet.deprecation_warning('Puppet::Util::CommandLine.available_subcommands is deprecated; please use Puppet::Application.available_application_names instead.')
-        Puppet::Application.available_application_names
-      end
-
-      # available_subcommands was previously an instance method, not a class
-      # method, and we have an unknown number of user-implemented applications
-      # that depend on that behaviour.  Forwarding allows us to preserve a
-      # backward compatible API. --daniel 2011-04-11
-      # @api private
-      # @deprecated
-      def available_subcommands
-        Puppet.deprecation_warning('Puppet::Util::CommandLine#available_subcommands is deprecated; please use Puppet::Application.available_application_names instead.')
-        Puppet::Application.available_application_names
-      end
-
       # Run the puppet subcommand. If the subcommand is determined to be an
       # external executable, this method will never return and the current
       # process will be replaced via {Kernel#exec}.
@@ -141,8 +121,6 @@ module Puppet
           end
 
           app = Puppet::Application.find(@subcommand_name).new(@command_line)
-          Puppet::Plugins.on_application_initialization(:application_object => @command_line)
-
           app.run
         end
       end

data/lib/puppet/util/errors.rb

@@ -14,7 +14,7 @@ module Puppet::Util::Errors
   # Add line and file info to the supplied exception if info is available from
   # this object, is appropriately populated and the supplied exception supports
   # it.  When other is supplied, the backtrace will be copied to the error
-  # object and the 'original' will be dropped from the error.
+  # object.
   #
   # @param error [Exception] exception that is populated with info
   # @param other [Exception] original exception, source of backtrace info
@@ -25,9 +25,7 @@ module Puppet::Util::Errors
     error.original ||= other if error.respond_to?(:original=)
 
     error.set_backtrace(other.backtrace) if other and other.respond_to?(:backtrace)
-    # It is not meaningful to keep the wrapped exception since its backtrace has already
-    # been adopted by the error. (The instance variable is private for good reasons).
-    error.instance_variable_set(:@original, nil)
+
     error
   end
 

data/lib/puppet/util/execution.rb

@@ -1,4 +1,3 @@
-require 'timeout'
 require 'puppet/file_system/uniquefile'
 
 module Puppet
@@ -116,8 +115,10 @@ module Puppet::Util::Execution
   # @param options [Hash] a Hash of options
   # @option options [Boolean]  :failonfail if this value is set to true, then this method will raise an error if the
   #   command is not executed successfully.
-  # @option options [Integer, String] :uid (nil) the user id of the user that the process should be run as
-  # @option options [Integer, String] :gid (nil) the group id of the group that the process should be run as
+  # @option options [Integer, String] :uid (nil) the user id of the user that the process should be run as. Will be ignored if the
+  #   user id matches the effective user id of the current process.
+  # @option options [Integer, String] :gid (nil) the group id of the group that the process should be run as. Will be ignored if the
+  #   group id matches the effective group id of the current process.
   # @option options [Boolean] :combine sets whether or not to combine stdout/stderr in the output
   # @option options [String] :stdinfile (nil) sets a file that can be used for stdin. Passing a string for stdin is not currently
   #   supported.
@@ -162,10 +163,21 @@ module Puppet::Util::Execution
       str = command
     end
 
+    user_log_s = ''
+    if options[:uid]
+      user_log_s << " uid=#{options[:uid]}"
+    end
+    if options[:gid]
+      user_log_s << " gid=#{options[:gid]}"
+    end
+    if user_log_s != ''
+      user_log_s.prepend(' with')
+    end
+
     if respond_to? :debug
-      debug "Executing '#{str}'"
+      debug "Executing#{user_log_s}: '#{str}'"
     else
-      Puppet.debug "Executing '#{str}'"
+      Puppet.debug "Executing#{user_log_s}: '#{str}'"
     end
 
     null_file = Puppet.features.microsoft_windows? ? 'NUL' : '/dev/null'
@@ -180,23 +192,8 @@ module Puppet::Util::Execution
       if execution_stub = Puppet::Util::ExecutionStub.current_value
         return execution_stub.call(*exec_args)
       elsif Puppet.features.posix?
-        child_pid = nil
-        begin
-          child_pid = execute_posix(*exec_args)
-          exit_status = Process.waitpid2(child_pid).last.exitstatus
-          child_pid = nil
-        rescue Timeout::Error => e
-          # NOTE: For Ruby 2.1+, an explicit Timeout::Error class has to be
-          # passed to Timeout.timeout in order for there to be something for
-          # this block to rescue.
-          unless child_pid.nil?
-            Process.kill(:TERM, child_pid)
-            # Spawn a thread to reap the process if it dies.
-            Thread.new { Process.waitpid(child_pid) }
-          end
-
-          raise e
-        end
+        child_pid = execute_posix(*exec_args)
+        exit_status = Process.waitpid2(child_pid).last.exitstatus
       elsif Puppet.features.microsoft_windows?
         process_info = execute_windows(*exec_args)
         begin

data/lib/puppet/util/feature.rb

@@ -17,7 +17,7 @@ class Puppet::Util::Feature
     if block_given?
       begin
         result = yield
-      rescue Exception => detail
+      rescue StandardError,ScriptError => detail
         warn "Failed to load feature test for #{name}: #{detail}"
         result = false
       end
@@ -86,9 +86,7 @@ class Puppet::Util::Feature
 
     begin
       require lib
-    rescue SystemExit,NoMemoryError
-      raise
-    rescue Exception
+    rescue ScriptError
       Puppet.debug "Failed to load library '#{lib}' for feature '#{name}'"
       return false
     end

data/lib/puppet/util/fileparsing.rb

@@ -214,8 +214,9 @@ module Puppet::Util::FileParsing
 
   # Split text into separate lines using the record separator.
   def lines(text)
-    # Remove any trailing separators, and then split based on them
-    text.sub(/#{self.line_separator}\Q/,'').split(self.line_separator)
+    # NOTE: We do not have to remove trailing separators because split will ignore
+    # them by default (unless you pass -1 as a second parameter)
+    text.split(self.line_separator)
   end
 
   # Split a bunch of text into lines and then parse them individually.

data/lib/puppet/util/log.rb

@@ -1,6 +1,7 @@
 require 'puppet/util/tagging'
 require 'puppet/util/classgen'
 require 'puppet/network/format_support'
+require 'facter'
 
 # Pass feedback to the user.  Log levels are modeled after syslog's, and it is
 # expected that that will be the most common log destination.  Supports
@@ -105,6 +106,9 @@ class Puppet::Util::Log
     raise Puppet::DevError, "Invalid loglevel #{level}" unless @levels.include?(level)
 
     @loglevel = @levels.index(level)
+
+    # Enable or disable Facter debugging
+    Facter.debugging(level == :debug) if Facter.respond_to? :debugging
   end
 
   def Log.levels
@@ -239,12 +243,7 @@ class Puppet::Util::Log
     obj
   end
 
-  def self.from_pson(data)
-    Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
-    self.from_data_hash(data)
-  end
-
-  attr_accessor :time, :remote, :file, :line, :pos, :source, :issue_code, :environment, :node, :backtrace
+  attr_accessor :time, :remote, :file, :line, :source
   attr_reader :level, :message
 
   def initialize(args)
@@ -258,10 +257,9 @@ class Puppet::Util::Log
       tags.each { |t| self.tag(t) }
     end
 
-    # Don't add these unless defined (preserve 3.x API as much as possible)
-    [:file, :line, :pos, :issue_code, :environment, :node, :backtrace].each do |attr|
+    [:file, :line].each do |attr|
       next unless value = args[attr]
-      send(attr.to_s + '=', value)
+      send(attr.to_s + "=", value)
     end
 
     Log.newmessage(self)
@@ -276,11 +274,8 @@ class Puppet::Util::Log
     if @time.is_a? String
       @time = Time.parse(@time)
     end
-    # Don't add these unless defined (preserve 3.x API as much as possible)
-    %w(file line pos issue_code environment node backtrace).each do |name|
-      next unless value = data[name]
-      send(name + '=', value)
-    end
+    @file = data['file'] if data['file']
+    @line = data['line'] if data['line']
   end
 
   def to_hash
@@ -290,30 +285,15 @@ class Puppet::Util::Log
   def to_data_hash
     {
       'level' => @level,
-      'message' => to_s,
+      'message' => @message,
       'source' => @source,
-      'tags' => @tags.to_a,
+      'tags' => @tags,
       'time' => @time.iso8601(9),
       'file' => @file,
       'line' => @line,
     }
   end
 
-  def to_structured_hash
-    hash = {
-      'level' => @level,
-      'message' => @message,
-      'source' => @source,
-      'tags' => @tags.to_a,
-      'time' => @time.iso8601(9),
-    }
-    %w(file line pos issue_code environment node backtrace).each do |name|
-      attr_name = "@#{name}"
-      hash[name] = instance_variable_get(attr_name) if instance_variable_defined?(attr_name)
-    end
-    hash
-  end
-
   def to_pson(*args)
     to_data_hash.to_pson(*args)
   end
@@ -336,7 +316,7 @@ class Puppet::Util::Log
   # If they pass a source in to us, we make sure it is a string, and
   # we retrieve any tags we can.
   def source=(source)
-    if defined?(Puppet::Type) && source.is_a?(Puppet::Type)
+    if source.respond_to?(:path)
       @source = source.path
       source.tags.each { |t| tag(t) }
       self.file = source.file
@@ -351,30 +331,7 @@ class Puppet::Util::Log
   end
 
   def to_s
-    msg = message
-
-    # Issue based messages do not have details in the message. It
-    # must be appended here
-    unless issue_code.nil?
-      msg = "Could not parse for environment #{environment}: #{msg}" unless environment.nil?
-      if file && line && pos
-        msg = "#{msg} at #{file}:#{line}:#{pos}"
-      elsif file and line
-        msg = "#{msg}  at #{file}:#{line}"
-      elsif line && pos
-        msg = "#{msg}  at line #{line}:#{pos}"
-      elsif line
-        msg = "#{msg}  at line #{line}"
-      elsif file
-        msg = "#{msg}  in #{file}"
-      end
-      msg = "#{msg} on node #{node}" unless node.nil?
-      if @backtrace.is_a?(Array)
-        msg += "\n"
-        msg += @backtrace.join("\n")
-      end
-    end
-    msg
+    message
   end
 
 end

data/lib/puppet/util/log/destinations.rb

@@ -65,8 +65,6 @@ Puppet::Util::Log.newdesttype :file do
 
   def initialize(path)
     @name = path
-    @json = path.end_with?('.json') ? 1 : 0
-
     # first make sure the directory exists
     # We can't just use 'Config.use' here, because they've
     # specified a "special" destination.
@@ -76,27 +74,15 @@ Puppet::Util::Log.newdesttype :file do
     end
 
     # create the log file, if it doesn't already exist
-    need_array_start = false
-    if @json == 1
-      need_array_start = true
-      if File.exists?(path)
-        sz = File.size(path)
-        need_array_start = sz == 0
-
-        # Assume that entries have been written and that a comma
-        # is needed before next entry
-        @json = 2 if sz > 2
-      end
-    end
-
-    file = File.open(path,  File::WRONLY|File::CREAT|File::APPEND)
-    file.puts('[') if need_array_start
+    file = File.open(path, File::WRONLY|File::CREAT|File::APPEND)
 
     # Give ownership to the user and group puppet will run as
-    begin
-      FileUtils.chown(Puppet[:user], Puppet[:group], path) unless Puppet::Util::Platform.windows?
-    rescue ArgumentError, Errno::EPERM
-      Puppet.err "Unable to set ownership of log file"
+    if Puppet.features.root? && !Puppet::Util::Platform.windows?
+      begin
+        FileUtils.chown(Puppet[:user], Puppet[:group], path)
+      rescue ArgumentError, Errno::EPERM
+        Puppet.err "Unable to set ownership to #{Puppet[:user]}:#{Puppet[:group]} for log file: #{path}"
+      end
     end
 
     @file = file
@@ -105,12 +91,7 @@ Puppet::Util::Log.newdesttype :file do
   end
 
   def handle(msg)
-    if @json > 0
-      @json > 1 ? @file.puts(',') : @json = 2
-      JSON.dump(msg.to_structured_hash, @file)
-    else
-      @file.puts("#{msg.time} #{msg.source} (#{msg.level}): #{msg}")
-    end
+    @file.puts("#{msg.time} #{msg.source} (#{msg.level}): #{msg}")
 
     @file.flush if @autoflush
   end
@@ -150,15 +131,15 @@ Puppet::Util::Log.newdesttype :console do
 
   def handle(msg)
     levels = {
-      :emerg   => { :name => 'Emergency', :color => :hred,  :stream => $stderr },
-      :alert   => { :name => 'Alert',     :color => :hred,  :stream => $stderr },
-      :crit    => { :name => 'Critical',  :color => :hred,  :stream => $stderr },
-      :err     => { :name => 'Error',     :color => :hred,  :stream => $stderr },
-      :warning => { :name => 'Warning',   :color => :hred,  :stream => $stderr },
-
-      :notice  => { :name => 'Notice',    :color => :reset, :stream => $stdout },
-      :info    => { :name => 'Info',      :color => :green, :stream => $stdout },
-      :debug   => { :name => 'Debug',     :color => :cyan,  :stream => $stdout },
+      :emerg   => { :name => 'Emergency', :color => :hred,     :stream => $stderr },
+      :alert   => { :name => 'Alert',     :color => :hred,     :stream => $stderr },
+      :crit    => { :name => 'Critical',  :color => :hred,     :stream => $stderr },
+      :err     => { :name => 'Error',     :color => :hred,     :stream => $stderr },
+      :warning => { :name => 'Warning',   :color => :hyellow,  :stream => $stderr },
+
+      :notice  => { :name => 'Notice',    :color => :reset,    :stream => $stdout },
+      :info    => { :name => 'Info',      :color => :green,    :stream => $stdout },
+      :debug   => { :name => 'Debug',     :color => :cyan,     :stream => $stdout },
     }
 
     str = msg.respond_to?(:multiline) ? msg.multiline : msg.to_s

data/lib/puppet/util/logging.rb

@@ -1,6 +1,7 @@
 # A module to make logging a bit easier.
 require 'puppet/util/log'
 require 'puppet/error'
+require 'facter'
 
 module Puppet::Util::Logging
 
@@ -10,12 +11,33 @@ module Puppet::Util::Logging
 
   # Create a method for each log level.
   Puppet::Util::Log.eachlevel do |level|
+    # handle debug a special way for performance reasons
+    next if level == :debug
     define_method(level) do |args|
       args = args.join(" ") if args.is_a?(Array)
       send_log(level, args)
     end
   end
 
+  # Output a debug log message if debugging is on (but only then)
+  # If the output is anything except a static string, give the debug
+  # a block - it will be called with all other arguments, and is expected
+  # to return the single string result.
+  #
+  # Use a block at all times for increased performance.
+  #
+  # @example This takes 40% of the time compared to not using a block
+  #  Puppet.debug { "This is a string that interpolated #{x} and #{y} }"
+  #
+  def debug(*args)
+    return nil unless Puppet::Util::Log.level == :debug
+    if block_given?
+      send_log(:debug, yield(*args))
+    else
+      send_log(:debug, args.join(" "))
+    end
+  end
+
   # Log an exception via Puppet.err.  Will also log the backtrace if Puppet[:trace] is set.
   # Parameters:
   # [exception] an Exception to log
@@ -24,44 +46,8 @@ module Puppet::Util::Logging
   #    wish to log a message at all; in this case it is likely that you are only calling this method in order
   #    to take advantage of the backtrace logging.
   def log_exception(exception, message = :default, options = {})
-    trace = Puppet[:trace] || options[:trace]
-    if message == :default && exception.is_a?(Puppet::ParseErrorWithIssue)
-      # Retain all detailed info and keep plain message and stacktrace separate
-      backtrace = []
-      build_exception_trace(backtrace, exception, trace)
-      Puppet::Util::Log.create({
-          :level => :err,
-          :source => log_source,
-          :message => exception.basic_message,
-          :issue_code => exception.issue_code,
-          :backtrace => backtrace.empty? ? nil : backtrace,
-          :file => exception.file,
-          :line => exception.line,
-          :pos => exception.pos,
-          :environment => exception.environment,
-          :node => exception.node
-        }.merge(log_metadata))
-    else
-      err(format_exception(exception, message, trace))
-    end
-  end
-
-  def build_exception_trace(arr, exception, trace = true)
-    if trace and exception.backtrace
-      exception.backtrace.each do |line|
-        arr << line =~ /^(.+):(\d+.*)$/ ? ("#{Pathname($1).realpath}:#{$2}" rescue line) : line
-      end
-    end
-    if exception.respond_to?(:original)
-      original =  exception.original
-      unless original.nil?
-        arr << 'Wrapped exception:'
-        arr << original.message
-        build_exception_trace(arr, original, trace)
-      end
-    end
+    err(format_exception(exception, message, Puppet[:trace] || options[:trace]))
   end
-  private :build_exception_trace
 
   def format_exception(exception, message = :default, trace = true)
     arr = []
@@ -177,6 +163,35 @@ module Puppet::Util::Logging
     end
   end
 
+  # Sets up Facter logging.
+  # This method causes Facter output to be forwarded to Puppet.
+  def self.setup_facter_logging!
+    # Only recent versions of Facter support this feature
+    return false unless Facter.respond_to? :on_message
+
+    # The current Facter log levels are: :trace, :debug, :info, :warn, :error, and :fatal.
+    # Convert to the corresponding levels in Puppet
+    Facter.on_message do |level, message|
+      case level
+      when :trace, :debug
+        level = :debug
+      when :info
+        # Same as Puppet
+      when :warn
+        level = :warning
+      when :error
+        level = :err
+      when :fatal
+        level = :crit
+      else
+        next
+      end
+      Puppet::Util::Log.create({:level => level, :source => 'Facter', :message => message})
+      nil
+    end
+    true
+  end
+
   private
 
   def issue_deprecation_warning(message, key, file, line, use_caller)