puppet 2.7.26 → 3.0.0.rc4

data/lib/puppet/util/json_lockfile.rb

@@ -0,0 +1,41 @@
+require 'puppet/util/lockfile'
+
+# This class provides a simple API for managing a lock file
+# whose contents are a serialized JSON object.  In addition
+# to querying the basic state (#locked?) of the lock, managing
+# the lock (#lock, #unlock), the contents can be retrieved at
+# any time while the lock is held (#lock_data).  This can be
+# used to store structured data (state messages, etc.) about
+# the lock.
+#
+# @see Puppet::Util::Lockfile
+class Puppet::Util::JsonLockfile < Puppet::Util::Lockfile
+  # Lock the lockfile.  You may optionally pass a data object, which will be
+  # retrievable for the duration of time during which the file is locked.
+  #
+  # @param [Hash] lock_data an optional Hash of data to associate with the lock.
+  #   This may be used to store pids, descriptive messages, etc.  The
+  #   data may be retrieved at any time while the lock is held by
+  #   calling the #lock_data method. <b>NOTE</b> that the JSON serialization
+  #   does NOT support Symbol objects--if you pass them in, they will be
+  #   serialized as Strings, so you should plan accordingly.
+  # @return [boolean] true if lock is successfully acquired, false otherwise.
+  def lock(lock_data = nil)
+    return false if locked?
+
+    super(lock_data.to_pson)
+  end
+
+  # Retrieve the (optional) lock data that was specified at the time the file
+  #  was locked.
+  # @return [Object] the data object.  Remember that the serialization does not
+  #  support Symbol objects, so if your data Object originally contained symbols,
+  #  they will be converted to Strings.
+  def lock_data
+    return nil unless file_locked?
+    file_contents = super
+    return nil if file_contents.nil?
+    PSON.parse(file_contents)
+  end
+
+end

data/lib/puppet/util/ldap/connection.rb

@@ -1,6 +1,9 @@
 require 'puppet/util/ldap'
+require 'puppet/util/methodhelper'
 
 class Puppet::Util::Ldap::Connection
+  include Puppet::Util::MethodHelper
+
   attr_accessor :host, :port, :user, :password, :reset, :ssl
 
   attr_reader :connection
@@ -36,13 +39,7 @@ class Puppet::Util::Ldap::Connection
 
     @host, @port = host, port
 
-    options.each do |param, value|
-      begin
-        send(param.to_s + "=", value)
-      rescue
-        raise ArgumentError, "LDAP connections do not support #{param} parameters"
-      end
-    end
+    set_options(options)
   end
 
   # Create a per-connection unique name.

data/lib/puppet/util/lockfile.rb

@@ -0,0 +1,62 @@
+# This class provides a simple API for managing a lock file
+# whose contents are an (optional) String.  In addition
+# to querying the basic state (#locked?) of the lock, managing
+# the lock (#lock, #unlock), the contents can be retrieved at
+# any time while the lock is held (#lock_data).  This can be
+# used to store pids, messages, etc.
+#
+# @see Puppet::Util::JsonLockfile
+class Puppet::Util::Lockfile
+  attr_reader :file_path
+
+  def initialize(file_path)
+    @file_path = file_path
+  end
+
+  # Lock the lockfile.  You may optionally pass a data object, which will be
+  # retrievable for the duration of time during which the file is locked.
+  #
+  # @param [String] lock_data an optional String data object to associate
+  #   with the lock.  This may be used to store pids, descriptive messages,
+  #   etc.  The data may be retrieved at any time while the lock is held by
+  #   calling the #lock_data method.
+
+  # @return [boolean] true if lock is successfully acquired, false otherwise.
+  def lock(lock_data = nil)
+    return false if locked?
+
+    File.open(@file_path, 'w') { |fd| fd.print(lock_data) }
+    true
+  end
+
+  def unlock
+    if locked?
+      File.unlink(@file_path)
+      true
+    else
+      false
+    end
+  end
+
+  def locked?
+    # delegate logic to a more explicit private method
+    file_locked?
+  end
+
+  # Retrieve the (optional) lock data that was specified at the time the file
+  #  was locked.
+  # @return [String] the data object.
+  def lock_data
+    return File.read(@file_path) if file_locked?
+  end
+
+  # Private, internal utility method for encapsulating the logic about
+  #  whether or not the file is locked.  This method can be called
+  #  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?()
+    File.exists? @file_path
+  end
+  private :file_locked?
+end

data/lib/puppet/util/log.rb

@@ -135,7 +135,7 @@ class Puppet::Util::Log
       flushqueue
       @destinations[dest]
     rescue => detail
-      puts detail.backtrace if Puppet[:debug]
+      Puppet.log_exception(detail)
 
       # If this was our only destination, then add the console back in.
       newdestination(:console) if @destinations.empty? and (dest != :console and dest != "console")
@@ -170,6 +170,20 @@ class Puppet::Util::Log
     @queued.clear
   end
 
+  # Flush the logging queue.  If there are no destinations available,
+  #  adds in a console logger before flushing the queue.
+  # This is mainly intended to be used as a last-resort attempt
+  #  to ensure that logging messages are not thrown away before
+  #  the program is about to exit--most likely in a horrific
+  #  error scenario.
+  # @return nil
+  def Log.force_flushqueue()
+    if (@destinations.empty? and !(@queued.empty?))
+      newdestination(:console)
+    end
+    flushqueue
+  end
+
   def Log.sendlevel?(level)
     @levels.index(level) >= @loglevel
   end
@@ -206,12 +220,6 @@ class Puppet::Util::Log
     @levels.include?(level)
   end
 
-  def self.from_pson(data)
-    obj = allocate
-    obj.initialize_from_hash(data)
-    obj
-  end
-
   attr_accessor :time, :remote, :file, :line, :source
   attr_reader :level, :message
 
@@ -234,19 +242,6 @@ class Puppet::Util::Log
     Log.newmessage(self)
   end
 
-  def initialize_from_hash(data)
-    @level = data['level'].intern
-    @message = data['message']
-    @source = data['source']
-    @tags = data['tags']
-    @time = data['time']
-    if @time.is_a? String
-      @time = Time.parse(@time)
-    end
-    @file = data['file'] if data['file']
-    @line = data['line'] if data['line']
-  end
-
   def message=(msg)
     raise ArgumentError, "Puppet::Util::Log requires a message" unless msg
     @message = msg.to_s
@@ -254,6 +249,7 @@ class Puppet::Util::Log
 
   def level=(level)
     raise ArgumentError, "Puppet::Util::Log requires a log level" unless level
+    raise ArgumentError, "Puppet::Util::Log requires a symbol or string" unless level.respond_to? "to_sym"
     @level = level.to_sym
     raise ArgumentError, "Invalid log level #{@level}" unless self.class.validlevel?(@level)
 

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

@@ -9,8 +9,7 @@ Puppet::Util::Log.newdesttype :syslog do
 
   def initialize
     Syslog.close if Syslog.opened?
-    name = Puppet[:name]
-    name = "puppet-#{name}" unless name =~ /puppet/
+    name = "puppet-#{Puppet.run_mode.name}"
 
     options = Syslog::LOG_PID | Syslog::LOG_NDELAY
 
@@ -30,12 +29,16 @@ Puppet::Util::Log.newdesttype :syslog do
     # cannot log a message with a '%' in it.  So, we get rid
     # of them.
     if msg.source == "Puppet"
-      @syslog.send(msg.level, msg.to_s.gsub("%", '%%'))
+      msg.to_s.split("\n").each do |line|
+        @syslog.send(msg.level, line.gsub("%", '%%'))
+      end
     else
-      @syslog.send(msg.level, "(%s) %s" % [msg.source.to_s.gsub("%", ""),
-          msg.to_s.gsub("%", '%%')
-        ]
-      )
+      msg.to_s.split("\n").each do |line|
+        @syslog.send(msg.level, "(%s) %s" % [msg.source.to_s.gsub("%", ""),
+            line.gsub("%", '%%')
+          ]
+        )
+      end
     end
   end
 end
@@ -89,24 +92,6 @@ Puppet::Util::Log.newdesttype :console do
   require 'puppet/util/colors'
   include Puppet::Util::Colors
 
-  def initialize
-    # Flush output immediately.
-    $stdout.sync = true
-  end
-
-  def handle(msg)
-    if msg.source == "Puppet"
-      puts colorize(msg.level, "#{msg.level}: #{msg}")
-    else
-      puts colorize(msg.level, "#{msg.level}: #{msg.source}: #{msg}")
-    end
-  end
-end
-
-Puppet::Util::Log.newdesttype :telly_prototype_console do
-  require 'puppet/util/colors'
-  include Puppet::Util::Colors
-
   def initialize
     # Flush output immediately.
     $stderr.sync = true
@@ -123,6 +108,7 @@ Puppet::Util::Log.newdesttype :telly_prototype_console do
     }
 
     str = msg.respond_to?(:multiline) ? msg.multiline : msg.to_s
+    str = msg.source == "Puppet" ? str : "#{msg.source}: #{str}"
 
     case msg.level
     when *error_levels.keys
@@ -180,8 +166,7 @@ Puppet::Util::Log.newdesttype :host do
         # Add the hostname to the source
         @driver.addlog(tmp)
       rescue => detail
-        puts detail.backtrace if Puppet[:trace]
-        Puppet.err detail
+        Puppet.log_exception(detail)
         Puppet::Util::Log.close(self)
       end
     end

data/lib/puppet/util/logging.rb

@@ -1,5 +1,6 @@
 # A module to make logging a bit easier.
 require 'puppet/util/log'
+require 'puppet/error'
 
 module Puppet::Util::Logging
 
@@ -15,17 +16,108 @@ module Puppet::Util::Logging
     end
   end
 
+  # Log an exception via Puppet.err.  Will also log the backtrace if Puppet[:trace] is set.
+  # Parameters:
+  # [exception] an Exception to log
+  # [message] an optional String overriding the message to be logged; by default, we log Exception.message.
+  #    If you pass a String here, your string will be logged instead.  You may also pass nil if you don't
+  #    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 = {})
+    err(format_exception(exception, message, Puppet[:trace] || options[:trace]))
+  end
+
+  def format_exception(exception, message = :default, trace = true)
+    arr = []
+    case message
+    when :default
+      arr << exception.message
+    when nil
+      # don't log anything if they passed a nil; they are just calling for the optional backtrace logging
+    else
+      arr << message
+    end
+
+    if trace and exception.backtrace
+      arr << Puppet::Util.pretty_backtrace(exception.backtrace)
+    end
+    if exception.respond_to?(:original) and exception.original
+      arr << "Wrapped exception:"
+      arr << format_exception(exception.original, :default, trace)
+    end
+    arr.flatten.join("\n")
+  end
+
+  def log_and_raise(exception, message)
+    log_exception(exception, message)
+    raise exception, message + "\n" + exception.to_s, exception.backtrace
+  end
+
+  class DeprecationWarning < Exception; end
+
+  # Log a warning indicating that the 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.
+  # Parameters:
+  # [message] The message to log (logs via )
   def deprecation_warning(message)
-    $deprecation_warnings ||= Hash.new(0)
-    if $deprecation_warnings.length < 100 and ($deprecation_warnings[message] += 1) == 1
-      warning message
+    $deprecation_warnings ||= {}
+    if $deprecation_warnings.length < 100 then
+      offender = get_deprecation_offender()
+      if (! $deprecation_warnings.has_key?(offender)) then
+        $deprecation_warnings[offender] = message
+        warning("#{message}\n   (at #{offender})")
+      end
     end
   end
 
+  def get_deprecation_offender()
+    # we have to put this in its own method to simplify testing; we need to be able to mock the offender results in
+    # order to test this class, and our framework does not appear to enjoy it if you try to mock Kernel.caller
+    #
+    # let's find the offending line;  we need to jump back up the stack a few steps to find the method that called
+    #  the deprecated method
+    caller()[2]
+  end
+
   def clear_deprecation_warnings
     $deprecation_warnings.clear if $deprecation_warnings
   end
 
+  # TODO: determine whether there might be a potential use for adding a puppet configuration option that would
+  # enable this deprecation logging.
+
+  # utility method that can be called, e.g., from spec_helper config.after, when tracking down calls to deprecated
+  # code.
+  # Parameters:
+  # [deprecations_file] relative or absolute path of a file to log the deprecations to
+  # [pattern] (default nil) if specified, will only log deprecations whose message matches the provided pattern
+  def log_deprecations_to_file(deprecations_file, pattern = nil)
+    # this method may get called lots and lots of times (e.g., from spec_helper config.after) without the global
+    # list of deprecation warnings being cleared out.  We don't want to keep logging the same offenders over and over,
+    # so, we need to keep track of what we've logged.
+    #
+    # It'd be nice if we could just clear out the list of deprecation warnings, but then the very next spec might
+    # find the same offender, and we'd end up logging it again.
+    $logged_deprecation_warnings ||= {}
+
+    File.open(deprecations_file, "a") do |f|
+      if ($deprecation_warnings) then
+        $deprecation_warnings.each do |offender, message|
+          if (! $logged_deprecation_warnings.has_key?(offender)) then
+            $logged_deprecation_warnings[offender] = true
+            if ((pattern.nil?) || (message =~ pattern)) then
+              f.puts(message)
+              f.puts(offender)
+              f.puts()
+            end
+          end
+        end
+      end
+    end
+  end
+
   private
 
   def is_resource?

data/lib/puppet/util/metric.rb

@@ -9,12 +9,6 @@ class Puppet::Util::Metric
 
   attr_writer :basedir
 
-  def self.from_pson(data)
-    metric = new(data['name'], data['label'])
-    metric.values = data['values']
-    metric
-  end
-
   # Return a specific value
   def [](name)
     if value = @values.find { |v| v[0] == name }

data/lib/puppet/util/monkey_patches.rb

@@ -1,5 +1,13 @@
-unless defined? JRUBY_VERSION
+require 'puppet/util'
+module Puppet::Util::MonkeyPatches
+end
+
+begin
   Process.maxgroups = 1024
+rescue Exception
+  # Actually, I just want to ignore it, since various platforms - JRuby,
+  # Windows, and so forth - don't support it, but only because it isn't a
+  # meaningful or implementable concept there.
 end
 
 module RDoc
@@ -57,23 +65,6 @@ class Object
   def daemonize
     raise NotImplementedError, "Kernel.daemonize is too dangerous, please don't try to use it."
   end
-
-  # The following code allows callers to make assertions that are only
-  # checked when the environment variable PUPPET_ENABLE_ASSERTIONS is
-  # set to a non-empty string.  For example:
-  #
-  #   assert_that { condition }
-  #   assert_that(message) { condition }
-  if ENV["PUPPET_ENABLE_ASSERTIONS"].to_s != ''
-    def assert_that(message = nil)
-      unless yield
-        raise Exception.new("Assertion failure: #{message}")
-      end
-    end
-  else
-    def assert_that(message = nil)
-    end
-  end
 end
 
 # Workaround for yaml_initialize, which isn't supported before Ruby
@@ -90,14 +81,6 @@ if RUBY_VERSION == '1.8.1' || RUBY_VERSION == '1.8.2'
   }
 end
 
-class Fixnum
-  # Returns the int itself. This method is intended for compatibility to
-  # character constant in Ruby 1.9.  1.8.5 is missing it; add it.
-  def ord
-    self
-  end unless method_defined? 'ord'
-end
-
 class Array
   # Ruby < 1.8.7 doesn't have this method but we use it in tests
   def combination(num)
@@ -112,6 +95,14 @@ class Array
   end unless method_defined? :combination
 
   alias :count :length unless method_defined? :count
+
+  # Ruby 1.8.5 lacks `drop`, which we don't want to lose.
+  def drop(n)
+    n = n.to_int
+    raise ArgumentError, "attempt to drop negative size" if n < 0
+
+    slice(n, length - n) or []
+  end unless method_defined? :drop
 end
 
 
@@ -139,20 +130,18 @@ class Symbol
   end unless method_defined? :intern
 end
 
-
 class String
-  def lines(separator = $/)
-    lines = split(separator)
-    block_given? and lines.each {|line| yield line }
-    lines
+  unless method_defined? :lines
+    require 'puppet/util/monkey_patches/lines'
+    include Puppet::Util::MonkeyPatches::Lines
   end
 end
 
+require 'fcntl'
 class IO
-  def lines(separator = $/)
-    lines = split(separator)
-    block_given? and lines.each {|line| yield line }
-    lines
+  unless method_defined? :lines
+    require 'puppet/util/monkey_patches/lines'
+    include Puppet::Util::MonkeyPatches::Lines
   end
 
   def self.binread(name, length = nil, offset = 0)
@@ -162,12 +151,32 @@ class IO
     end
   end unless singleton_methods.include?(:binread)
 
-  def self.binwrite(name, string, offset = 0)
-    File.open(name, 'wb') do |f|
-      f.write(offset > 0 ? string[offset..-1] : string)
+  def self.binwrite(name, string, offset = nil)
+    # Determine if we should truncate or not.  Since the truncate method on a
+    # file handle isn't implemented on all platforms, safer to do this in what
+    # looks like the libc / POSIX flag - which is usually pretty robust.
+    # --daniel 2012-03-11
+    mode = Fcntl::O_CREAT | Fcntl::O_WRONLY | (offset.nil? ? Fcntl::O_TRUNC : 0)
+
+    # We have to duplicate the mode because Ruby on Windows is a bit precious,
+    # and doesn't actually carry over the mode.  It won't work to just use
+    # open, either, because that doesn't like our system modes and the default
+    # open bits don't do what we need, which is awesome. --daniel 2012-03-30
+    IO.open(IO::sysopen(name, mode), mode) do |f|
+      # ...seek to our desired offset, then write the bytes.  Don't try to
+      # seek past the start of the file, eh, because who knows what platform
+      # would legitimately blow up if we did that.
+      #
+      # Double-check the positioning, too, since destroying data isn't my idea
+      # of a good time. --daniel 2012-03-11
+      target = [0, offset.to_i].max
+      unless (landed = f.sysseek(target, IO::SEEK_SET)) == target
+        raise "unable to seek to target offset #{target} in #{name}: got to #{landed}"
+      end
+
+      f.syswrite(string)
     end
   end unless singleton_methods.include?(:binwrite)
-
 end
 
 class Range
@@ -196,6 +205,59 @@ module Kernel
   end unless method_defined?(:tap)
 end
 
+
+########################################################################
+# The return type of `instance_variables` changes between Ruby 1.8 and 1.9
+# releases; it used to return an array of strings in the form "@foo", but
+# now returns an array of symbols in the form :@foo.
+#
+# Nothing else in the stack cares which form you get - you can pass the
+# string or symbol to things like `instance_variable_set` and they will work
+# transparently.
+#
+# Having the same form in all releases of Puppet is a win, though, so we
+# pick a unification and enforce than on all releases.  That way developers
+# who do set math on them (eg: for YAML rendering) don't have to handle the
+# distinction themselves.
+#
+# In the sane tradition, we bring older releases into conformance with newer
+# releases, so we return symbols rather than strings, to be more like the
+# future versions of Ruby are.
+#
+# We also carefully support reloading, by only wrapping when we don't
+# already have the original version of the method aliased away somewhere.
+if RUBY_VERSION[0,3] == '1.8'
+  unless Object.respond_to?(:puppet_original_instance_variables)
+
+    # Add our wrapper to the method.
+    class Object
+      alias :puppet_original_instance_variables :instance_variables
+
+      def instance_variables
+        puppet_original_instance_variables.map(&:to_sym)
+      end
+    end
+
+    # The one place that Ruby 1.8 assumes something about the return format of
+    # the `instance_variables` method is actually kind of odd, because it uses
+    # eval to get at instance variables of another object.
+    #
+    # This takes the original code and applies replaces instance_eval with
+    # instance_variable_get through it.  All other bugs in the original (such
+    # as equality depending on the instance variables having the same order
+    # without any promise from the runtime) are preserved. --daniel 2012-03-11
+    require 'resolv'
+    class Resolv::DNS::Resource
+      def ==(other) # :nodoc:
+        return self.class == other.class &&
+          self.instance_variables == other.instance_variables &&
+          self.instance_variables.collect {|name| self.instance_variable_get name} ==
+          other.instance_variables.collect {|name| other.instance_variable_get name}
+      end
+    end
+  end
+end
+
 # The mv method in Ruby 1.8.5 can't mv directories across devices
 # File.rename causes "Invalid cross-device link", which is rescued, but in Ruby
 # 1.8.5 it tries to recover with a copy and unlink, but the unlink causes the
@@ -240,46 +302,3 @@ if RUBY_VERSION == '1.8.5'
     module_function :move
   end
 end
-
-# (#19151) Reject all SSLv2 ciphers and handshakes
-require 'openssl'
-class OpenSSL::SSL::SSLContext
-  if match = /^1\.8\.(\d+)/.match(RUBY_VERSION)
-    older_than_187 = match[1].to_i < 7
-  else
-    older_than_187 = false
-  end
-
-  alias __original_initialize initialize
-  private :__original_initialize
-
-  if older_than_187
-    def initialize(*args)
-      __original_initialize(*args)
-      if bitmask = self.options
-        self.options = bitmask | OpenSSL::SSL::OP_NO_SSLv2
-      else
-        self.options = OpenSSL::SSL::OP_NO_SSLv2
-      end
-      # These are the default ciphers in recent MRI versions.  See
-      # https://github.com/ruby/ruby/blob/v1_9_3_392/ext/openssl/lib/openssl/ssl-internal.rb#L26
-      self.ciphers = "ALL:!ADH:!EXPORT:!SSLv2:RC4+RSA:+HIGH:+MEDIUM:+LOW"
-    end
-  else
-    if DEFAULT_PARAMS[:options]
-      DEFAULT_PARAMS[:options] |= OpenSSL::SSL::OP_NO_SSLv2
-    else
-      DEFAULT_PARAMS[:options] = OpenSSL::SSL::OP_NO_SSLv2
-    end
-    DEFAULT_PARAMS[:ciphers] << ':!SSLv2'
-
-    def initialize(*args)
-      __original_initialize(*args)
-      params = {
-        :options => DEFAULT_PARAMS[:options],
-        :ciphers => DEFAULT_PARAMS[:ciphers],
-      }
-      set_params(params)
-    end
-  end
-end