puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/lib/puppet/util/command_line.rb

@@ -14,6 +14,7 @@ require 'puppet/util'
 require "puppet/util/plugins"
 require "puppet/util/rubygems"
 require "puppet/util/limits"
+require 'puppet/util/colors'
 
 module Puppet
   module Util
@@ -125,9 +126,17 @@ module Puppet
           # ruby process, but that requires fixing (#17210, #12173, #8750). So for now
           # we try to restrict to only code that can be autoloaded from the node's
           # environment.
+
+          # PUP-2114 - at this point in the bootstrapping process we do not
+          # have an appropriate application-wide current_environment set.
+          # If we cannot find the configured environment, which may not exist,
+          # we do not attempt to add plugin directories to the load path.
+          #
           if @subcommand_name != 'master' and @subcommand_name != 'agent'
-            Puppet.lookup(:environments).get(Puppet[:environment]).each_plugin_directory do |dir|
-              $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
+            if configured_environment = Puppet.lookup(:environments).get(Puppet[:environment])
+              configured_environment.each_plugin_directory do |dir|
+                $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
+              end
             end
           end
 
@@ -152,13 +161,20 @@ module Puppet
 
       # @api private
       class NilSubcommand
+        include Puppet::Util::Colors
+
         def initialize(command_line)
           @command_line = command_line
         end
 
         def run
-          if @command_line.args.include? "--version" or @command_line.args.include? "-V"
+          args = @command_line.args
+          if args.include? "--version" or args.include? "-V"
             puts Puppet.version
+          elsif @command_line.subcommand_name.nil? && args.count > 0
+            # If the subcommand is truly nil and there is an arg, it's an option; print out the invalid option message
+            puts colorize(:hred, "Error: Could not parse application options: invalid option: #{args[0]}")
+            exit 1
           else
             puts "See 'puppet help' for help on available puppet subcommands"
           end
@@ -173,8 +189,9 @@ module Puppet
         end
 
         def run
-          puts "Error: Unknown Puppet subcommand '#{@subcommand_name}'"
+          puts colorize(:hred, "Error: Unknown Puppet subcommand '#{@subcommand_name}'")
           super
+          exit 1
         end
       end
     end

data/lib/puppet/util/execution.rb

@@ -1,3 +1,5 @@
+require 'puppet/file_system/uniquefile'
+
 module Puppet
   require 'rbconfig'
 
@@ -79,15 +81,18 @@ module Puppet::Util::Execution
       end
     end
 
-    if failonfail
-      unless $CHILD_STATUS == 0
-        raise Puppet::ExecutionFailure, output
-      end
+    if failonfail && exitstatus != 0
+      raise Puppet::ExecutionFailure, output
     end
 
     output
   end
 
+  def self.exitstatus
+    $CHILD_STATUS.exitstatus
+  end
+  private_class_method :exitstatus
+
   # 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)
@@ -164,37 +169,44 @@ module Puppet::Util::Execution
 
     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')
+    begin
+      stdin = File.open(options[:stdinfile] || null_file, 'r')
+      stdout = options[:squelch] ? File.open(null_file, 'w') : Puppet::FileSystem::Uniquefile.new('puppet')
+      stderr = options[:combine] ? stdout : File.open(null_file, 'w')
 
-    exec_args = [command, options, stdin, stdout, stderr]
+      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
-        Puppet::Util::Windows::Process.CloseHandle(process_info.process_handle)
-        Puppet::Util::Windows::Process.CloseHandle(process_info.thread_handle)
+      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
+          FFI::WIN32.CloseHandle(process_info.process_handle)
+          FFI::WIN32.CloseHandle(process_info.thread_handle)
+        end
       end
-    end
 
-    [stdin, stdout, stderr].each {|io| io.close rescue nil}
+      [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
+      # 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 Puppet::ExecutionFailure, "Execution of '#{str}' returned #{exit_status}: #{output.strip}"
+      if options[:failonfail] and exit_status != 0
+        raise Puppet::ExecutionFailure, "Execution of '#{str}' returned #{exit_status}: #{output.strip}"
+      end
+    ensure
+      if !options[:squelch] && stdout
+        # if we opened a temp file for stdout, we need to clean it up.
+        stdout.close!
+      end
     end
 
     Puppet::Util::Execution::ProcessOutput.new(output || '', exit_status)

data/lib/puppet/util/feature.rb

@@ -1,3 +1,5 @@
+require 'puppet'
+
 class Puppet::Util::Feature
   attr_reader :path
 
@@ -23,10 +25,19 @@ 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]
+      # we return a cached result if:
+      #  * if a block is given (and we just evaluated it above)
+      #  * if we already have a positive result
+      #  * if we've tested this feature before and it failed, but we're
+      #    configured to always cache
+      if block_given?     ||
+          @results[name]  ||
+          (@results.has_key?(name) and Puppet[:always_cache_features])
+        @results[name]
+      else
+        @results[name] = test(name, options)
+        @results[name]
+      end
     end
   end
 

data/lib/puppet/util/filetype.rb

@@ -78,9 +78,10 @@ class Puppet::Util::FileType
     @bucket ||= Puppet::Type.type(:filebucket).mkdefaultbucket.bucket
   end
 
-  def initialize(path)
+  def initialize(path, default_mode = nil)
     raise ArgumentError.new("Path is nil") if path.nil?
     @path = path
+    @default_mode = default_mode
   end
 
   # Arguments that will be passed to the execute method. Will set the uid
@@ -119,6 +120,7 @@ class Puppet::Util::FileType
     def write(text)
       tf = Tempfile.new("puppet")
       tf.print text; tf.flush
+      File.chmod(@default_mode, tf.path) if @default_mode
       FileUtils.cp(tf.path, @path)
       tf.close
       # If SELinux is present, we need to ensure the file has its expected context
@@ -134,7 +136,9 @@ class Puppet::Util::FileType
       @@tabs.clear
     end
 
-    def initialize(path)
+    def initialize(path, default_mode = nil)
+      # default_mode is meaningless for this filetype,
+      # supported only for compatibility with :flat
       super
       @@tabs[@path] ||= ""
     end

data/lib/puppet/util/http_proxy.rb

@@ -14,7 +14,7 @@ module Puppet::Util::HttpProxy
   def self.http_proxy_host
     env = self.http_proxy_env
 
-    if env and env.host then
+    if env and env.host
       return env.host
     end
 
@@ -28,11 +28,38 @@ module Puppet::Util::HttpProxy
   def self.http_proxy_port
     env = self.http_proxy_env
 
-    if env and env.port then
+    if env and env.port
       return env.port
     end
 
     return Puppet.settings[:http_proxy_port]
   end
 
+  def self.http_proxy_user
+    env = self.http_proxy_env
+
+    if env and env.user
+      return env.user
+    end
+
+    if Puppet.settings[:http_proxy_user] == 'none'
+      return nil
+    end
+
+    return Puppet.settings[:http_proxy_user]
+  end
+
+  def self.http_proxy_password
+    env = self.http_proxy_env
+
+    if env and env.password
+      return env.password
+    end
+
+    if Puppet.settings[:http_proxy_user] == 'none' or Puppet.settings[:http_proxy_password] == 'none'
+      return nil
+    end
+
+    return Puppet.settings[:http_proxy_password]
+  end
 end

data/lib/puppet/util/lockfile.rb

@@ -59,7 +59,7 @@ class Puppet::Util::Lockfile
   #  by other methods in this class without as much risk of accidentally
   #  being overridden by child classes.
   # @return [boolean] true if the file is locked, false if it is not.
-  def file_locked?()
+  def file_locked?
     Puppet::FileSystem.exist? @file_path
   end
   private :file_locked?

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

@@ -189,6 +189,10 @@ Puppet::Util::Log.newdesttype :array do
 end
 
 Puppet::Util::Log.newdesttype :eventlog do
+  Puppet::Util::Log::DestEventlog::EVENTLOG_ERROR_TYPE       = 0x0001
+  Puppet::Util::Log::DestEventlog::EVENTLOG_WARNING_TYPE     = 0x0002
+  Puppet::Util::Log::DestEventlog::EVENTLOG_INFORMATION_TYPE = 0x0004
+
   def self.suitable?(obj)
     Puppet.features.eventlog?
   end
@@ -200,11 +204,11 @@ Puppet::Util::Log.newdesttype :eventlog do
   def to_native(level)
     case level
     when :debug,:info,:notice
-      [Win32::EventLog::INFO, 0x01]
+      [self.class::EVENTLOG_INFORMATION_TYPE, 0x01]
     when :warning
-      [Win32::EventLog::WARN, 0x02]
+      [self.class::EVENTLOG_WARNING_TYPE, 0x02]
     when :err,:alert,:emerg,:crit
-      [Win32::EventLog::ERROR, 0x03]
+      [self.class::EVENTLOG_ERROR_TYPE, 0x03]
     end
   end
 

data/lib/puppet/util/logging.rb

@@ -55,25 +55,40 @@ module Puppet::Util::Logging
 
   class DeprecationWarning < Exception; end
 
-  # Logs a warning indicating that the code path is deprecated.  Note that this
-  # method keeps track of the offending lines of code that triggered the
+  # Logs a warning indicating that the Ruby code path is deprecated.  Note that
+  # this method keeps track of the offending lines of code that triggered the
   # deprecation warning, and will only log a warning once per offending line of
   # code.  It will also stop logging deprecation warnings altogether after 100
-  # unique deprecation warnings have been logged.
+  # unique deprecation warnings have been logged.  Finally, if
+  # Puppet[:disable_warnings] includes 'deprecations', it will squelch all
+  # warning calls made via this method.
   #
-  # @param [String] message The message to log (logs via )
-  # @param [String] key Optional key to mark the message as unique. If not
+  # @param message [String] The message to log (logs via warning)
+  # @param key [String] Optional key to mark the message as unique. If not
   #   passed in, the originating call line will be used instead.
   def deprecation_warning(message, key = nil)
-    return if Puppet[:disable_warnings].include?('deprecations')
-    $deprecation_warnings ||= {}
-    if $deprecation_warnings.length < 100 then
-      key ||= (offender = get_deprecation_offender)
-      if (! $deprecation_warnings.has_key?(key)) then
-        $deprecation_warnings[key] = message
-        warning("#{message}\n   (at #{(offender || get_deprecation_offender).join('; ')})")
-      end
-    end
+    issue_deprecation_warning(message, key, nil, nil, true)
+  end
+
+  # Logs a warning whose origin comes from Puppet source rather than somewhere
+  # internal within Puppet.  Otherwise the same as deprecation_warning()
+  #
+  # @param message [String] The message to log (logs via warning)
+  # @param options [Hash]
+  # @option options [String] :file File we are warning from
+  # @option options [Integer] :line Line number we are warning from
+  # @option options [String] :key (:file + :line) Alternative key used to mark
+  #   warning as unique
+  #
+  # Either :file and :line and/or :key must be passed.
+  def puppet_deprecation_warning(message, options = {})
+    key = options[:key]
+    file = options[:file]
+    line = options[:line]
+    raise(Puppet::DevError, "Need either :file and :line, or :key") if (key.nil?) && (file.nil? || line.nil?)
+
+    key ||= "#{file}:#{line}"
+    issue_deprecation_warning(message, key, file, line, false)
   end
 
   def get_deprecation_offender()
@@ -128,6 +143,21 @@ module Puppet::Util::Logging
 
   private
 
+  def issue_deprecation_warning(message, key, file, line, use_caller)
+    return if Puppet[:disable_warnings].include?('deprecations')
+    $deprecation_warnings ||= {}
+    if $deprecation_warnings.length < 100 then
+      key ||= (offender = get_deprecation_offender)
+      if (! $deprecation_warnings.has_key?(key)) then
+        $deprecation_warnings[key] = message
+        call_trace = use_caller ?
+          (offender || get_deprecation_offender).join('; ') :
+          "#{file || 'unknown'}:#{line || 'unknown'}"
+        warning("#{message}\n   (at #{call_trace})")
+      end
+    end
+  end
+
   def is_resource?
     defined?(Puppet::Type) && is_a?(Puppet::Type)
   end

data/lib/puppet/util/pidlock.rb

@@ -22,7 +22,7 @@ class Puppet::Util::Pidlock
     @lockfile.lock(Process.pid)
   end
 
-  def unlock()
+  def unlock
     if mine?
       return @lockfile.unlock
     else
@@ -31,7 +31,12 @@ class Puppet::Util::Pidlock
   end
 
   def lock_pid
-    @lockfile.lock_data.to_i
+    pid = @lockfile.lock_data
+    begin
+      Integer(pid)
+    rescue ArgumentError, TypeError
+      nil
+    end
   end
 
   def file_path
@@ -39,11 +44,12 @@ class Puppet::Util::Pidlock
   end
 
   def clear_if_stale
-    return if lock_pid.nil?
+    return @lockfile.unlock if lock_pid.nil?
 
     errors = [Errno::ESRCH]
-    # Process::Error can only happen, and is only defined, on Windows
-    errors << Process::Error if defined? Process::Error
+    # Win32::Process now throws SystemCallError. Since this could be
+    # defined anywhere, only add when on Windows.
+    errors << SystemCallError if Puppet::Util::Platform.windows?
 
     begin
       Process.kill(0, lock_pid)

data/lib/puppet/util/posix.rb

@@ -98,49 +98,39 @@ module Puppet::Util::POSIX
     end
   end
 
-  # Get the GID of a given group, provided either a GID or a name
+  # Get the GID
   def gid(group)
-    begin
-      group = Integer(group)
-    rescue ArgumentError
-      # pass
-    end
-    if group.is_a?(Integer)
-      return nil unless name = get_posix_field(:group, :name, group)
-      gid = get_posix_field(:group, :gid, name)
-      check_value = gid
-    else
-      return nil unless gid = get_posix_field(:group, :gid, group)
-      name = get_posix_field(:group, :name, gid)
-      check_value = name
-    end
-    if check_value != group
-      return search_posix_field(:group, :gid, group)
-    else
-      return gid
-    end
+      get_posix_value(:group, :gid, group)
   end
 
-  # Get the UID of a given user, whether a UID or name is provided
+  # Get the UID
   def uid(user)
+      get_posix_value(:passwd, :uid, user)
+  end
+
+  private
+
+  # Get the specified id_field of a given field (user or group), 
+  # whether an ID name is provided
+  def get_posix_value(location, id_field, field)
     begin
-      user = Integer(user)
+      field = Integer(field)
     rescue ArgumentError
       # pass
     end
-    if user.is_a?(Integer)
-      return nil unless name = get_posix_field(:passwd, :name, user)
-      uid = get_posix_field(:passwd, :uid, name)
-      check_value = uid
+    if field.is_a?(Integer)
+      return nil unless name = get_posix_field(location, :name, field)
+      id = get_posix_field(location, id_field, name)
+      check_value = id
     else
-      return nil unless uid = get_posix_field(:passwd, :uid, user)
-      name = get_posix_field(:passwd, :name, uid)
+      return nil unless id = get_posix_field(location, id_field, field)
+      name = get_posix_field(location, :name, id)
       check_value = name
     end
-    if check_value != user
-      return search_posix_field(:passwd, :uid, user)
+    if check_value != field
+      return search_posix_field(location, id_field, field)
     else
-      return uid
+      return id
     end
   end
 end