puppet 2.7.26 → 3.0.0.rc4

data/lib/puppet/util/config_timeout.rb

@@ -0,0 +1,24 @@
+module Puppet::Util::ConfigTimeout
+  # NOTE: in the future it might be a good idea to add an explicit "integer" type to
+  #  the settings types, in which case this would no longer be necessary.
+
+  # Get the value of puppet's "configtimeout" setting, as an integer.  Raise an
+  # ArgumentError if the setting does not contain a valid integer value.
+  # @return Puppet config timeout setting value, as an integer
+  def timeout_interval
+    timeout = Puppet[:configtimeout]
+    case timeout
+    when String
+      if timeout =~ /^\d+$/
+        timeout = Integer(timeout)
+      else
+        raise ArgumentError, "Configuration timeout must be an integer"
+      end
+    when Integer # nothing
+    else
+      raise ArgumentError, "Configuration timeout must be an integer"
+    end
+
+    timeout
+  end
+end

data/lib/puppet/util/constant_inflector.rb

@@ -1,15 +1,23 @@
 # Created on 2008-02-12
 # Copyright Luke Kanies
 
+# NOTE: I think it might be worth considering moving these methods directly into Puppet::Util.
+
 # A common module for converting between constants and
 # file names.
-module Puppet::Util::ConstantInflector
-  def file2constant(file)
-    # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
-    x = file.split("/").collect { |name| name.capitalize }.join("::").gsub(/_+(.)/) { |term| $1.capitalize }
-  end
+module Puppet
+  module Util
+    module ConstantInflector
+      def file2constant(file)
+        # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
+        x = file.split("/").collect { |name| name.capitalize }.join("::").gsub(/_+(.)/) { |term| $1.capitalize }
+      end
+      module_function :file2constant
 
-  def constant2file(constant)
-    constant.to_s.gsub(/([a-z])([A-Z])/) { |term| $1 + "_#{$2}" }.gsub("::", "/").downcase
+      def constant2file(constant)
+        constant.to_s.gsub(/([a-z])([A-Z])/) { |term| $1 + "_#{$2}" }.gsub("::", "/").downcase
+      end
+      module_function :constant2file
+    end
   end
 end

data/lib/puppet/util/diff.rb

@@ -2,7 +2,7 @@ require 'tempfile'
 
 # Provide a diff between two strings.
 module Puppet::Util::Diff
-  include Puppet::Util
+  include Puppet::Util::Execution
   require 'tempfile'
 
   def diff(old, new)
@@ -13,7 +13,7 @@ module Puppet::Util::Diff
       command << args
     end
     command << old << new
-    execute(command, :failonfail => false)
+    Puppet::Util::Execution.execute(command, :failonfail => false)
   end
 
   module_function :diff

data/lib/puppet/util/docs.rb

@@ -110,8 +110,7 @@ module Puppet::Util::Docs
       begin
         return text.gsub(/^#{indent}/,'')
       rescue => detail
-        puts detail.backtrace
-        puts detail
+        Puppet.log_exception(detail)
       end
     else
       return text

data/lib/puppet/util/errors.rb

@@ -7,10 +7,10 @@ module Puppet::Util::Errors
 
   # Add line and file info if available and appropriate.
   def adderrorcontext(error, other = nil)
-    error.line ||= self.line if self.respond_to?(:line) and self.line
-    error.file ||= self.file if self.respond_to?(:file) and self.file
+    error.line ||= self.line if error.respond_to?(:line=) and self.respond_to?(:line) and self.line
+    error.file ||= self.file if error.respond_to?(:file=) and self.respond_to?(:file) and self.file
 
-    error.set_backtrace other.backtrace if other and other.respond_to?(:backtrace)
+    error.set_backtrace(other.backtrace) if other and other.respond_to?(:backtrace)
 
     error
   end
@@ -60,4 +60,3 @@ module Puppet::Util::Errors
     raise error
   end
 end
-

data/lib/puppet/util/execution.rb

@@ -1,20 +1,245 @@
-module Puppet::Util::Execution
-  module_function
+module Puppet
+  require 'rbconfig'
 
-  # Run some code with a specific environment.  Resets the environment back to
-  # what it was at the end of the code.
-  def withenv(hash)
-    saved = ENV.to_hash
-    hash.each do |name, val|
-      ENV[name.to_s] = val
+  # A command failed to execute.
+  require 'puppet/error'
+  class ExecutionFailure < Puppet::Error
+  end
+
+module Util::Execution
+
+  # Execute the provided command with STDIN connected to a pipe, yielding the
+  # pipe object.  That allows data to be fed to that subprocess.
+  #
+  # The command can be a simple string, which is executed as-is, or an Array,
+  # which is treated as a set of command arguments to pass through.#
+  #
+  # In all cases this is passed directly to the shell, and STDOUT and STDERR
+  # are connected together during execution.
+  def self.execpipe(command, failonfail = true)
+    if respond_to? :debug
+      debug "Executing '#{command}'"
+    else
+      Puppet.debug "Executing '#{command}'"
     end
 
-    yield
-  ensure
-    ENV.clear
-    saved.each do |name, val|
-      ENV[name] = val
+    # 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.
+    #
+    # Having two spaces is really not a big drama, since this passes to the
+    # 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
+    output = open("| #{command_str} 2>&1") do |pipe|
+      yield pipe
     end
+
+    if failonfail
+      unless $CHILD_STATUS == 0
+        raise ExecutionFailure, output
+      end
+    end
+
+    output
   end
-end
 
+  def self.execfail(command, exception)
+    output = execute(command)
+    return output
+  rescue ExecutionFailure
+    raise exception, output
+  end
+
+
+
+  # Execute the desired command, and return the status and output.
+  # def execute(command, options)
+  # [command] an Array or String representing the command to execute. If it is
+  #   an Array the first element should be the executable and the rest of the
+  #   elements should be the individual arguments to that executable.
+  # [options] a Hash optionally containing any of the following keys:
+  #   :failonfail (default true) -- if this value is set to true, then this method will raise an error if the
+  #      command is not executed successfully.
+  #   :uid (default nil) -- the user id of the user that the process should be run as
+  #   :gid (default nil) -- the group id of the group that the process should be run as
+  #   :combine (default true) -- sets whether or not to combine stdout/stderr in the output
+  #   :stdinfile (default nil) -- sets a file that can be used for stdin. Passing a string for stdin is not currently
+  #      supported.
+  #   :squelch (default false) -- if true, ignore stdout / stderr completely
+  #   :override_locale (default true) -- by default (and if this option is set to true), we will temporarily override
+  #     the user/system locale to "C" (via environment variables LANG and LC_*) while we are executing the command.
+  #     This ensures that the output of the command will be formatted consistently, making it predictable for parsing.
+  #     Passing in a value of false for this option will allow the command to be executed using the user/system locale.
+  #   :custom_environment (default {}) -- a hash of key/value pairs to set as environment variables for the duration
+  #     of the command
+  def self.execute(command, options = {})
+    # specifying these here rather than in the method signature to allow callers to pass in a partial
+    # set of overrides without affecting the default values for options that they don't pass in
+    default_options = {
+        :failonfail => true,
+        :uid => nil,
+        :gid => nil,
+        :combine => true,
+        :stdinfile => nil,
+        :squelch => false,
+        :override_locale => true,
+        :custom_environment => {},
+    }
+
+    options = default_options.merge(options)
+
+    if command.is_a?(Array)
+      command = command.flatten.map(&:to_s)
+      str = command.join(" ")
+    elsif command.is_a?(String)
+      str = command
+    end
+
+    if respond_to? :debug
+      debug "Executing '#{str}'"
+    else
+      Puppet.debug "Executing '#{str}'"
+    end
+
+    null_file = Puppet.features.microsoft_windows? ? 'NUL' : '/dev/null'
+
+    stdin = File.open(options[:stdinfile] || null_file, 'r')
+    stdout = options[:squelch] ? File.open(null_file, 'w') : Tempfile.new('puppet')
+    stderr = options[:combine] ? stdout : File.open(null_file, 'w')
+
+    exec_args = [command, options, stdin, stdout, stderr]
+
+    if execution_stub = Puppet::Util::ExecutionStub.current_value
+      return execution_stub.call(*exec_args)
+    elsif Puppet.features.posix?
+      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
+        exit_status = Puppet::Util::Windows::Process.wait_process(process_info.process_handle)
+      ensure
+        Process.CloseHandle(process_info.process_handle)
+        Process.CloseHandle(process_info.thread_handle)
+      end
+    end
+
+    [stdin, stdout, stderr].each {|io| io.close rescue nil}
+
+    # read output in if required
+    unless options[:squelch]
+      output = wait_for_output(stdout)
+      Puppet.warning "Could not get output" unless output
+    end
+
+    if options[:failonfail] and exit_status != 0
+      raise ExecutionFailure, "Execution of '#{str}' returned #{exit_status}: #{output}"
+    end
+
+    output
+  end
+
+  # get 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)
+  def self.ruby_path()
+    File.join(RbConfig::CONFIG['bindir'],
+              RbConfig::CONFIG['ruby_install_name'] + RbConfig::CONFIG['EXEEXT']).
+      sub(/.*\s.*/m, '"\&"')
+  end
+
+  # Because some modules provide their own version of this method.
+  class << self
+    alias util_execute execute
+  end
+
+
+  # this is private method, see call to private_class_method after method definition
+  def self.execute_posix(command, options, stdin, stdout, stderr)
+    child_pid = Puppet::Util.safe_posix_fork(stdin, stdout, stderr) do
+
+      # We can't just call Array(command), and rely on it returning
+      # things like ['foo'], when passed ['foo'], because
+      # Array(command) will call command.to_a internally, which when
+      # given a string can end up doing Very Bad Things(TM), such as
+      # turning "/tmp/foo;\r\n /bin/echo" into ["/tmp/foo;\r\n", " /bin/echo"]
+      command = [command].flatten
+      Process.setsid
+      begin
+        Puppet::Util::SUIDManager.change_privileges(options[:uid], options[:gid], true)
+
+        # if the caller has requested that we override locale environment variables,
+        if (options[:override_locale]) then
+          # loop over them and clear them
+          Puppet::Util::POSIX::LOCALE_ENV_VARS.each { |name| ENV.delete(name) }
+          # set LANG and LC_ALL to 'C' so that the command will have consistent, predictable output
+          # it's OK to manipulate these directly rather than, e.g., via "withenv", because we are in
+          # a forked process.
+          ENV['LANG'] = 'C'
+          ENV['LC_ALL'] = 'C'
+        end
+
+        # unset all of the user-related environment variables so that different methods of starting puppet
+        # (automatic start during boot, via 'service', via /etc/init.d, etc.) won't have unexpected side
+        # effects relating to user / home dir environment vars.
+        # it's OK to manipulate these directly rather than, e.g., via "withenv", because we are in
+        # a forked process.
+        Puppet::Util::POSIX::USER_ENV_VARS.each { |name| ENV.delete(name) }
+
+        options[:custom_environment] ||= {}
+        Puppet::Util.withenv(options[:custom_environment]) do
+          Kernel.exec(*command)
+        end
+      rescue => detail
+        Puppet.log_exception(detail, "Could not execute posix command: #{detail}")
+        exit!(1)
+      end
+    end
+    child_pid
+  end
+  private_class_method :execute_posix
+
+
+  # this is private method, see call to private_class_method after method definition
+  def self.execute_windows(command, options, stdin, stdout, stderr)
+    command = command.map do |part|
+      part.include?(' ') ? %Q["#{part.gsub(/"/, '\"')}"] : part
+    end.join(" ") if command.is_a?(Array)
+
+    options[:custom_environment] ||= {}
+    Puppet::Util.withenv(options[:custom_environment]) do
+      Puppet::Util::Windows::Process.execute(command, options, stdin, stdout, stderr)
+    end
+  end
+  private_class_method :execute_windows
+
+
+  # this is private method, see call to private_class_method after method definition
+  def self.wait_for_output(stdout)
+    # Make sure the file's actually been written.  This is basically a race
+    # condition, and is probably a horrible way to handle it, but, well, oh
+    # well.
+    # (If this method were treated as private / inaccessible from outside of this file, we shouldn't have to worry
+    #  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)
+        stdout.open
+        begin
+          return stdout.read
+        ensure
+          stdout.close
+          stdout.unlink
+        end
+      else
+        time_to_sleep = try / 2.0
+        Puppet.warning "Waiting for output; will sleep #{time_to_sleep} seconds"
+        sleep(time_to_sleep)
+      end
+    end
+    nil
+  end
+  private_class_method :wait_for_output
+end
+end

data/lib/puppet/util/execution_stub.rb

@@ -1,7 +1,7 @@
 module Puppet::Util
   class ExecutionStub
     class << self
-      # Set a stub block that Puppet::Util.execute() should invoke instead
+      # Set a stub block that Puppet::Util::Execution.execute() should invoke instead
       # of actually executing commands on the target machine.  Intended
       # for spec testing.
       #
@@ -12,7 +12,7 @@ module Puppet::Util
       end
 
       # Uninstall any execution stub, so that calls to
-      # Puppet::Util.execute() behave normally again.
+      # Puppet::Util::Execution.execute() behave normally again.
       def reset
         @value = nil
       end

data/lib/puppet/util/feature.rb

@@ -10,7 +10,7 @@ class Puppet::Util::Feature
   # successfully.
   def add(name, options = {})
     method = name.to_s + "?"
-    raise ArgumentError, "Feature #{name} is already defined" if self.class.respond_to?(method)
+    @results.delete(name)
 
     if block_given?
       begin
@@ -23,9 +23,7 @@ class Puppet::Util::Feature
     end
 
     meta_def(method) do
-      # Positive cache only, except blocks which are executed just once above
-      final = @results[name] || block_given?
-      @results[name] = test(name, options) unless final
+      @results[name] = test(name, options) unless @results.include?(name)
       @results[name]
     end
   end

data/lib/puppet/util/fileparsing.rb

@@ -223,7 +223,7 @@ module Puppet::Util::FileParsing
       if val = parse_line(line)
         val
       else
-        error = Puppet::Error.new("Could not parse line #{line.inspect}")
+        error = Puppet::ResourceError.new("Could not parse line #{line.inspect}")
         error.line = count
         raise error
       end

data/lib/puppet/util/filetype.rb

@@ -43,8 +43,9 @@ class Puppet::Util::FileType
         rescue Puppet::Error => detail
           raise
         rescue => detail
-          puts detail.backtrace if Puppet[:trace]
-          raise Puppet::Error, "#{self.class} could not read #{@path}: #{detail}"
+          message = "#{self.class} could not read #{@path}: #{detail}"
+          Puppet.log_exception(detail, message)
+          raise Puppet::Error, message
         end
       end
 
@@ -58,8 +59,9 @@ class Puppet::Util::FileType
         rescue Puppet::Error => detail
           raise
         rescue => detail
-          puts detail.backtrace if Puppet[:debug]
-          raise Puppet::Error, "#{self.class} could not write #{@path}: #{detail}"
+          message = "#{self.class} could not write #{@path}: #{detail}"
+          Puppet.log_exception(detail, message)
+          raise Puppet::Error, message
         end
       end
     end
@@ -213,7 +215,7 @@ class Puppet::Util::FileType
   newfiletype(:suntab) do
     # Read a specific @path's cron tab.
     def read
-      Puppet::Util.execute(%w{crontab -l}, cronargs)
+      Puppet::Util::Execution.execute(%w{crontab -l}, cronargs)
     rescue => detail
       case detail.to_s
       when /can't open your crontab/
@@ -227,7 +229,7 @@ class Puppet::Util::FileType
 
     # Remove a specific @path's cron tab.
     def remove
-      Puppet::Util.execute(%w{crontab -r}, cronargs)
+      Puppet::Util::Execution.execute(%w{crontab -r}, cronargs)
     rescue => detail
       raise Puppet::Error, "Could not remove crontab for #{@path}: #{detail}", detail.backtrace
     end
@@ -241,7 +243,7 @@ class Puppet::Util::FileType
         output_file.close
         # We have to chown the stupid file to the user.
         File.chown(Puppet::Util.uid(@path), nil, output_file.path)
-        Puppet::Util.execute(["crontab", output_file.path], cronargs)
+        Puppet::Util::Execution.execute(["crontab", output_file.path], cronargs)
       rescue => detail
         raise Puppet::Error, "Could not write crontab for #{@path}: #{detail}", detail.backtrace
       ensure
@@ -255,7 +257,7 @@ class Puppet::Util::FileType
   newfiletype(:aixtab) do
     # Read a specific @path's cron tab.
     def read
-      Puppet::Util.execute(%w{crontab -l}, cronargs)
+      Puppet::Util::Execution.execute(%w{crontab -l}, cronargs)
     rescue => detail
       case detail.to_s
       when /Cannot open a file in the .* directory/
@@ -269,7 +271,7 @@ class Puppet::Util::FileType
 
     # Remove a specific @path's cron tab.
     def remove
-      Puppet::Util.execute(%w{crontab -r}, cronargs)
+      Puppet::Util::Execution.execute(%w{crontab -r}, cronargs)
     rescue => detail
       raise Puppet::Error, "Could not remove crontab for #{@path}: #{detail}", detail.backtrace
     end
@@ -284,7 +286,7 @@ class Puppet::Util::FileType
         output_file.close
         # We have to chown the stupid file to the user.
         File.chown(Puppet::Util.uid(@path), nil, output_file.path)
-        Puppet::Util.execute(["crontab", output_file.path], cronargs)
+        Puppet::Util::Execution.execute(["crontab", output_file.path], cronargs)
       rescue => detail
         raise Puppet::Error, "Could not write crontab for #{@path}: #{detail}", detail.backtrace
       ensure