puppet 3.3.2 → 3.4.0.rc1

data/lib/puppet/util/autoload.rb

@@ -85,7 +85,7 @@ class Puppet::Util::Autoload
     # returns nil if no file is found
     def get_file(name, env=nil)
       name = name + '.rb' unless name =~ /\.rb$/
-      path = search_directories(env).find { |dir| File.exist?(File.join(dir, name)) }
+      path = search_directories(env).find { |dir| Puppet::FileSystem::File.exist?(File.join(dir, name)) }
       path and File.join(path, name)
     end
 
@@ -112,7 +112,7 @@ class Puppet::Util::Autoload
       # We're using a per-thread cache of module directories so that we don't
       # scan the filesystem each time we try to load something. This is reset
       # at the beginning of compilation and at the end of an agent run.
-      Thread.current[:env_module_directories] ||= {}
+      $env_module_directories ||= {}
 
 
       # This is a little bit of a hack.  Basically, the autoloader is being
@@ -136,7 +136,7 @@ class Puppet::Util::Autoload
       # --cprice 2012-03-16
       if Puppet.settings.app_defaults_initialized?
         # if the app defaults have been initialized then it should be safe to access the module path setting.
-        Thread.current[:env_module_directories][real_env] ||= real_env.modulepath.collect do |dir|
+        $env_module_directories[real_env] ||= real_env.modulepath.collect do |dir|
           Dir.entries(dir).reject { |f| f =~ /^\./ }.collect { |f| File.join(dir, f) }
         end.flatten.collect { |d| File.join(d, "lib") }.find_all do |d|
           FileTest.directory?(d)

data/lib/puppet/util/backups.rb

@@ -10,7 +10,7 @@ module Puppet::Util::Backups
 
     # let the path be specified
     file ||= self[:path]
-    return true unless FileTest.exists?(file)
+    return true unless Puppet::FileSystem::File.exist?(file)
 
     return(self.bucket ? perform_backup_with_bucket(file) : perform_backup_with_backuplocal(file, self[:backup]))
   end
@@ -19,7 +19,7 @@ module Puppet::Util::Backups
 
   def perform_backup_with_bucket(fileobj)
     file = (fileobj.class == String) ? fileobj : fileobj.name
-    case File.lstat(file).ftype
+    case Puppet::FileSystem::File.new(file).lstat.ftype
     when "directory"
       # we don't need to backup directories when recurse is on
       return true if self[:recurse]
@@ -58,7 +58,7 @@ module Puppet::Util::Backups
     end
 
     begin
-      stat = File.send(method, newfile)
+      stat = Puppet::FileSystem::File.new(newfile).send(method)
     rescue Errno::ENOENT
       return
     end
@@ -70,7 +70,7 @@ module Puppet::Util::Backups
     info "Removing old backup of type #{stat.ftype}"
 
     begin
-      File.unlink(newfile)
+      Puppet::FileSystem::File.unlink(newfile)
     rescue => detail
       message = "Could not remove old backup: #{detail}"
       self.log_exception(detail, message)

data/lib/puppet/util/cacher.rb

@@ -1,5 +1,3 @@
-require 'monitor'
-
 module Puppet::Util::Cacher
   # Our module has been extended in a class; we can only add the Instance methods,
   # which become *class* methods in the class.
@@ -33,10 +31,8 @@ module Puppet::Util::Cacher
 
       define_method(name.to_s + "=") do |value|
         # Make sure the cache timestamp is set
-        value_cache.synchronize do
-          value_cache[name] = value
-          set_expiration(name)
-        end
+        value_cache[name] = value
+        set_expiration(name)
       end
     end
 
@@ -55,13 +51,11 @@ module Puppet::Util::Cacher
     private
 
     def cached_value(name)
-      value_cache.synchronize do
-        if value_cache[name].nil? or expired_by_ttl?(name)
-          value_cache[name] = send("init_#{name}")
-          set_expiration(name)
-        end
-        value_cache[name]
+      if value_cache[name].nil? or expired_by_ttl?(name)
+        value_cache[name] = send("init_#{name}")
+        set_expiration(name)
       end
+      value_cache[name]
     end
 
     def expired_by_ttl?(name)
@@ -74,7 +68,7 @@ module Puppet::Util::Cacher
     end
 
     def value_cache
-      @value_cache ||= {}.extend(MonitorMixin)
+      @value_cache ||= {}
     end
   end
 end

data/lib/puppet/util/checksums.rb

@@ -56,7 +56,7 @@ module Puppet::Util::Checksums
 
   # Return the :mtime timestamp of a file.
   def mtime_file(filename)
-    File.stat(filename).send(:mtime)
+    Puppet::FileSystem::File.new(filename).stat.send(:mtime)
   end
 
   # by definition this doesn't exist
@@ -102,7 +102,7 @@ module Puppet::Util::Checksums
 
   # Return the :ctime of a file.
   def ctime_file(filename)
-    File.stat(filename).send(:ctime)
+    Puppet::FileSystem::File.new(filename).stat.send(:ctime)
   end
 
   alias :ctime_stream :mtime_stream

data/lib/puppet/util/classgen.rb

@@ -1,3 +1,5 @@
+require 'puppet/util/methodhelper'
+
 module Puppet
   class ConstantAlreadyDefined < Error; end
   class SubclassAlreadyDefined < Error; end
@@ -67,7 +69,7 @@ module Puppet::Util::ClassGen
     options = symbolize_options(options)
     const = genconst_string(name, options)
     retval = false
-    if const_defined?(const)
+    if is_constant_defined?(const)
       remove_const(const)
       retval = true
     end

data/lib/puppet/util/colors.rb

@@ -82,6 +82,7 @@ module Puppet::Util::Colors
   if Puppet::Util::Platform.windows?
     # We're on windows, need win32console for color to work
     begin
+      require 'Win32API'
       require 'win32console'
       require 'windows/wide_string'
 

data/lib/puppet/util/command_line.rb

@@ -13,6 +13,7 @@ require 'puppet'
 require 'puppet/util'
 require "puppet/util/plugins"
 require "puppet/util/rubygems"
+require "puppet/util/limits"
 
 module Puppet
   module Util
@@ -20,6 +21,8 @@ module Puppet
     # is basically where the bootstrapping process / lifecycle of an app
     # begins.
     class CommandLine
+      include Puppet::Util::Limits
+
       OPTION_OR_MANIFEST_FILE = /^-|\.pp$|\.rb$/
 
       # @param zero [String] the name of the executable
@@ -83,6 +86,8 @@ module Puppet
           Puppet.initialize_settings(args)
         end
 
+        setpriority(Puppet[:priority])
+
         find_subcommand.run
       end
 

data/lib/puppet/util/docs.rb

@@ -20,10 +20,10 @@ module Puppet::Util::Docs
   def doc
     extra = methods.find_all { |m| m.to_s =~ /^dochook_.+/ }.sort.collect { |m|
       self.send(m)
-    }.delete_if {|r| r.nil? }.join("  ")
+    }.delete_if {|r| r.nil? }.collect {|r| "* #{r}"}.join("\n")
 
     if @doc
-      @doc + (extra.empty? ? '' : "\n\n" + extra)
+      scrub(@doc) + (extra.empty? ? '' : "\n\n#{extra}")
     else
       extra
     end
@@ -63,6 +63,7 @@ module Puppet::Util::Docs
     str + "\n"
   end
 
+  # There is nothing that would ever set this. It gets read in reference/type.rb, but will never have any value but nil.
   attr_reader :nodoc
   def nodoc?
     nodoc
@@ -89,33 +90,38 @@ module Puppet::Util::Docs
     str << "\n"
   end
 
-  # Handle the inline indentation in the docs.
+  # Strip indentation and trailing whitespace from embedded doc fragments.
+  #
+  # Multi-line doc fragments are sometimes indented in order to preserve the
+  # formatting of the code they're embedded in. Since indents are syntactic
+  # elements in Markdown, we need to make sure we remove any indent that was
+  # added solely to preserve surrounding code formatting, but LEAVE any indent
+  # that delineates a Markdown element (code blocks, multi-line bulleted list
+  # items). We can do this by removing the *least common indent* from each line.
+  #
+  # Least common indent is defined as follows:
+  #
+  # * Find the smallest amount of leading space on any line...
+  # * ...excluding the first line (which may have zero indent without affecting
+  #   the common indent)...
+  # * ...and excluding lines that consist solely of whitespace.
+  # * The least common indent may be a zero-length string, if the fragment is
+  #   not indented to match code.
+  # * If there are hard tabs for some dumb reason, we assume they're at least
+  #   consistent within this doc fragment.
+  #
+  # See tests in spec/unit/util/docs_spec.rb for examples.
   def scrub(text)
-    # Stupid markdown
-    #text = text.gsub("<%=", "&lt;%=")
-    # For text with no carriage returns, there's nothing to do.
-    return text if text !~ /\n/
-    indent = nil
-
-    # If we can match an indentation, then just remove that same level of
-    # indent from every line.  However, ignore any indentation on the
-    # first line, since that can be inconsistent.
-    text = text.lstrip
-    text.gsub!(/^([\t]+)/) { |s| " "*8*s.length; } # Expand leading tabs
-    # Find first non-empty line after the first line:
-    line2start = (text =~ /(\n?\s*\n)/)
-    line2start += $1.length
-    if (text[line2start..-1] =~ /^([ ]+)\S/) == 0
-      indent = Regexp.quote($1)
-      begin
-        return text.gsub(/^#{indent}/,'')
-      rescue => detail
-        Puppet.log_exception(detail)
-      end
-    else
-      return text
+    # One-liners are easy!
+    return text.strip if text !~ /\n/
+    excluding_first_line = text.partition("\n").last
+    indent = excluding_first_line.scan(/^[ \t]*(?=\S)/).min || '' # prevent nil
+    # Clean hanging indent, if any
+    if indent.length > 0
+      text = text.gsub(/^#{indent}/, '')
     end
-
+    # Clean trailing space
+    text.lines.map{|line|line.rstrip}.join("\n").rstrip
   end
 
   module_function :scrub

data/lib/puppet/util/execution.rb

@@ -1,15 +1,33 @@
 module Puppet
   require 'rbconfig'
 
-  # A command failed to execute.
   require 'puppet/error'
+  # A command failed to execute.
+  # @api public
   class ExecutionFailure < Puppet::Error
   end
+end
 
 # This module defines methods for execution of system commands. It is intented for inclusion
 # in classes that needs to execute system commands.
 # @api public
-module Util::Execution
+module Puppet::Util::Execution
+
+  # This is the full output from a process. The object itself (a String) is the
+  # stdout of the process.
+  #
+  # @api public
+  class ProcessOutput < String
+    # @return [Integer] The exit status of the process
+    # @api public
+    attr_reader :exitstatus
+
+    # @api private
+    def initialize(value,exitstatus)
+      super(value)
+      @exitstatus = exitstatus
+    end
+  end
 
   # Executes the provided command with STDIN connected to a pipe, yielding the
   # pipe object.
@@ -27,17 +45,12 @@ module Util::Execution
   # @yield [pipe] to a block executing a subprocess
   # @yieldparam pipe [IO] the opened pipe
   # @yieldreturn [String] the output to return
-  # @raise [ExecutionFailure] if the executed chiled process did not exit with status == 0 and `failonfail` is
+  # @raise [Puppet::ExecutionFailure] if the executed chiled process did not exit with status == 0 and `failonfail` is
   #   `true`.
   # @return [String] a string with the output from the subprocess executed by the given block
+  # @api public
   #
   def self.execpipe(command, failonfail = true)
-    if respond_to? :debug
-      debug "Executing '#{command}'"
-    else
-      Puppet.debug "Executing '#{command}'"
-    end
-
     # Paste together an array with spaces.  We used to paste directly
     # together, no spaces, which made for odd invocations; the user had to
     # include whitespace between arguments.
@@ -46,13 +59,20 @@ module Util::Execution
     # shell anyhow, while no spaces makes for a small developer cost every
     # time this is invoked. --daniel 2012-02-13
     command_str = command.respond_to?(:join) ? command.join(' ') : command
+
+    if respond_to? :debug
+      debug "Executing '#{command_str}'"
+    else
+      Puppet.debug "Executing '#{command_str}'"
+    end
+
     output = open("| #{command_str} 2>&1") do |pipe|
       yield pipe
     end
 
     if failonfail
       unless $CHILD_STATUS == 0
-        raise ExecutionFailure, output
+        raise Puppet::ExecutionFailure, output
       end
     end
 
@@ -62,10 +82,11 @@ module Util::Execution
   # Wraps execution of {execute} with mapping of exception to given exception (and output as argument).
   # @raise [exception] under same conditions as {execute}, but raises the given `exception` with the output as argument
   # @return (see execute)
+  # @api public
   def self.execfail(command, exception)
     output = execute(command)
     return output
-  rescue ExecutionFailure
+  rescue Puppet::ExecutionFailure
     raise exception, output
   end
 
@@ -80,8 +101,8 @@ module 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 [?] :uid (nil) the user id of the user that the process should be run as
-  # @option options [?] :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
+  # @option options [Integer, String] :gid (nil) the group id of the group that the process should be run as
   # @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.
@@ -92,13 +113,16 @@ module Util::Execution
   #   Passing in a value of false for this option will allow the command to be executed using the user/system locale.
   # @option options [Hash<{String => String}>] :custom_environment ({}) a hash of key/value pairs to set as environment variables for the duration
   #   of the command.
-  # @return [String] output as specified by options
+  # @return [Puppet::Util::Execution::ProcessOutput] output as specified by options
+  # @raise [Puppet::ExecutionFailure] if the executed chiled process did not exit with status == 0 and `failonfail` is
+  #   `true`.
   # @note Unfortunately, the default behavior for failonfail and combine (since
   #   0.22.4 and 0.24.7, respectively) depend on whether options are specified
   #   or not. If specified, then failonfail and combine default to false (even
   #   when the options specified are neither failonfail nor combine). If no
   #   options are specified, then failonfail and combine default to true.
   # @comment See commits efe9a833c and d32d7f30
+  # @api public
   #
   def self.execute(command, options = NoOptionsSpecified)
     # specifying these here rather than in the method signature to allow callers to pass in a partial
@@ -161,15 +185,16 @@ module Util::Execution
     end
 
     if options[:failonfail] and exit_status != 0
-      raise ExecutionFailure, "Execution of '#{str}' returned #{exit_status}: #{output}"
+      raise Puppet::ExecutionFailure, "Execution of '#{str}' returned #{exit_status}: #{output}"
     end
 
-    output
+    Puppet::Util::Execution::ProcessOutput.new(output || '', exit_status)
   end
 
   # Returns the path to the ruby executable (available via Config object, even if
   # it's not in the PATH... so this is slightly safer than just using Puppet::Util.which)
   # @return [String] the path to the Ruby executable
+  # @api private
   #
   def self.ruby_path()
     File.join(RbConfig::CONFIG['bindir'],
@@ -261,7 +286,7 @@ module Util::Execution
     #  about a race condition because all of the places that we call this from are preceded by a call to "waitpid2",
     #  meaning that the processes responsible for writing the file have completed before we get here.)
     2.times do |try|
-      if File.exists?(stdout.path)
+      if Puppet::FileSystem::File.exist?(stdout.path)
         stdout.open
         begin
           return stdout.read
@@ -279,4 +304,3 @@ module Util::Execution
   end
   private_class_method :wait_for_output
 end
-end

data/lib/puppet/util/filetype.rb

@@ -98,12 +98,12 @@ class Puppet::Util::FileType
   newfiletype(:flat) do
     # Back the file up before replacing it.
     def backup
-      bucket.backup(@path) if File.exists?(@path)
+      bucket.backup(@path) if Puppet::FileSystem::File.exist?(@path)
     end
 
     # Read the file.
     def read
-      if File.exist?(@path)
+      if Puppet::FileSystem::File.exist?(@path)
         File.read(@path)
       else
         return nil
@@ -112,7 +112,7 @@ class Puppet::Util::FileType
 
     # Remove the file.
     def remove
-      File.unlink(@path) if File.exist?(@path)
+      Puppet::FileSystem::File.unlink(@path) if Puppet::FileSystem::File.exist?(@path)
     end
 
     # Overwrite the file.

data/lib/puppet/util/instance_loader.rb

@@ -42,9 +42,9 @@ module Puppet::Util::InstanceLoader
     # Use this method so they all get loaded
     loaded_instances(type).sort { |a,b| a.to_s <=> b.to_s }.each do |name|
       mod = self.loaded_instance(name)
-      docs += "#{name}\n#{"-" * name.to_s.length}\n"
+      docs << "#{name}\n#{"-" * name.to_s.length}\n"
 
-      docs += Puppet::Util::Docs.scrub(mod.doc) + "\n\n"
+      docs << Puppet::Util::Docs.scrub(mod.doc) << "\n\n"
     end
 
     docs

data/lib/puppet/util/instrumentation.rb

@@ -5,7 +5,6 @@ require 'puppet/util/instance_loader'
 class Puppet::Util::Instrumentation
   extend Puppet::Util::ClassGen
   extend Puppet::Util::InstanceLoader
-  extend MonitorMixin
 
   # we're using a ruby lazy autoloader to prevent a loop when requiring listeners
   # since this class sets up an indirection which is also used in Puppet::Indirector::Indirection
@@ -71,11 +70,9 @@ class Puppet::Util::Instrumentation
   end
 
   def self.each_listener(label)
-    synchronize {
-      @listeners_of[label] ||= @listeners.select do |k,l|
-        l.listen_to?(label)
-      end
-    }.each do |l|
+    @listeners_of[label] ||= @listeners.select do |k,l|
+      l.listen_to?(label)
+    end.each do |l|
       yield l
     end
   end
@@ -105,67 +102,51 @@ class Puppet::Util::Instrumentation
   end
 
   def self.subscribe(listener, label_pattern, event)
-    synchronize {
-      raise "Listener #{listener.name} is already subscribed" if @listeners.include?(listener.name)
-      Puppet.debug "registering instrumentation listener #{listener.name}"
-      @listeners[listener.name] = Listener.new(listener, label_pattern, event)
-      listener.subscribed if listener.respond_to?(:subscribed)
-      rehash
-    }
+    raise "Listener #{listener.name} is already subscribed" if @listeners.include?(listener.name)
+    Puppet.debug "registering instrumentation listener #{listener.name}"
+    @listeners[listener.name] = Listener.new(listener, label_pattern, event)
+    listener.subscribed if listener.respond_to?(:subscribed)
+    rehash
   end
 
   def self.unsubscribe(listener)
-    synchronize {
-      Puppet.warning("#{listener.name} hasn't been registered but asked to be unregistered") unless @listeners.include?(listener.name)
-      Puppet.info "unregistering instrumentation listener #{listener.name}"
-      @listeners.delete(listener.name)
-      listener.unsubscribed if listener.respond_to?(:unsubscribed)
-      rehash
-    }
+    Puppet.warning("#{listener.name} hasn't been registered but asked to be unregistered") unless @listeners.include?(listener.name)
+    Puppet.info "unregistering instrumentation listener #{listener.name}"
+    @listeners.delete(listener.name)
+    listener.unsubscribed if listener.respond_to?(:unsubscribed)
+    rehash
   end
 
   def self.init
     # let's init our probe indirection
     require 'puppet/util/instrumentation/indirection_probe'
-    synchronize {
-      @listeners ||= {}
-      @listeners_of ||= {}
-      instance_loader(:listener).loadall
-    }
+    @listeners ||= {}
+    @listeners_of ||= {}
+    instance_loader(:listener).loadall
   end
 
   def self.clear
-    synchronize {
-      @listeners = {}
-      @listeners_of = {}
-      @id = 0
-    }
+    @listeners = {}
+    @listeners_of = {}
+    @id = 0
   end
 
   def self.[](key)
-    synchronize {
-      @listeners[key.intern]
-    }
+    @listeners[key.intern]
   end
 
   def self.[]=(key, value)
-    synchronize {
-      @listeners[key.intern] = value
-      rehash
-    }
+    @listeners[key.intern] = value
+    rehash
   end
 
   private
 
-  # should be called only under the guard
-  # self.synchronize
   def self.rehash
     @listeners_of = {}
   end
 
   def self.next_id
-    synchronize {
-      @id = (@id || 0) + 1
-    }
+    @id = (@id || 0) + 1
   end
 end