puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/util/libuser.conf

@@ -0,0 +1,15 @@
+[import]
+login_defs = /etc/login.defs
+default_useradd = /etc/default/useradd
+
+[defaults]
+crypt_style = md5
+modules = files shadow
+create_modules = files shadow
+
+[userdefaults]
+LU_USERNAME = %n
+LU_GIDNUMBER = %u
+
+[groupdefaults]
+LU_GROUPNAME = %n

data/vendor/gems/puppet-3.7.3/lib/puppet/util/libuser.rb

@@ -0,0 +1,12 @@
+module Puppet::Util::Libuser
+   def self.getconf
+     File.expand_path("../libuser.conf", __FILE__)
+   end
+
+   def self.getenv
+     newenv = {}
+     newenv['LIBUSER_CONF'] = getconf
+     newenv
+   end
+
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/util/limits.rb

@@ -0,0 +1,12 @@
+require 'puppet/util'
+
+module Puppet::Util::Limits
+  # @api private
+  def setpriority(priority)
+    return unless priority
+
+    Process.setpriority(0, Process.pid, priority)
+  rescue Errno::EACCES, NotImplementedError
+    Puppet.warning("Failed to set process priority to '#{priority}'")
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/util/lockfile.rb

@@ -0,0 +1,66 @@
+# 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)
+    begin
+      Puppet::FileSystem.exclusive_create(@file_path, nil) do |fd|
+        fd.print(lock_data)
+      end
+      true
+    rescue Errno::EEXIST
+      false
+    end
+  end
+
+  def unlock
+    if locked?
+      Puppet::FileSystem.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?
+    Puppet::FileSystem.exist? @file_path
+  end
+  private :file_locked?
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/util/log.rb

@@ -0,0 +1,343 @@
+require 'puppet/util/tagging'
+require 'puppet/util/classgen'
+require 'puppet/network/format_support'
+
+# 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
+# multiple destinations, one of which is a remote server.
+class Puppet::Util::Log
+  include Puppet::Util
+  extend Puppet::Util::ClassGen
+  include Puppet::Util::Tagging
+  include Puppet::Network::FormatSupport
+
+  @levels = [:debug,:info,:notice,:warning,:err,:alert,:emerg,:crit]
+  @loglevel = 2
+
+  @desttypes = {}
+
+  # Create a new destination type.
+  def self.newdesttype(name, options = {}, &block)
+
+    dest = genclass(
+      name,
+      :parent     => Puppet::Util::Log::Destination,
+      :prefix     => "Dest",
+      :block      => block,
+      :hash       => @desttypes,
+      :attributes => options
+    )
+    dest.match(dest.name)
+
+    dest
+  end
+
+  require 'puppet/util/log/destination'
+  require 'puppet/util/log/destinations'
+
+  @destinations = {}
+
+  @queued = []
+
+  class << self
+    include Puppet::Util
+    include Puppet::Util::ClassGen
+
+    attr_reader :desttypes
+  end
+
+  # Reset log to basics.  Basically just flushes and closes files and
+  # undefs other objects.
+  def Log.close(destination)
+    if @destinations.include?(destination)
+      @destinations[destination].flush if @destinations[destination].respond_to?(:flush)
+      @destinations[destination].close if @destinations[destination].respond_to?(:close)
+      @destinations.delete(destination)
+    end
+  end
+
+  def self.close_all
+    destinations.keys.each { |dest|
+      close(dest)
+    }
+    raise Puppet::DevError.new("Log.close_all failed to close #{@destinations.keys.inspect}") if !@destinations.empty?
+  end
+
+  # Flush any log destinations that support such operations.
+  def Log.flush
+    @destinations.each { |type, dest|
+      dest.flush if dest.respond_to?(:flush)
+    }
+  end
+
+  def Log.autoflush=(v)
+    @destinations.each do |type, dest|
+      dest.autoflush = v if dest.respond_to?(:autoflush=)
+    end
+  end
+
+  # Create a new log message.  The primary role of this method is to
+  # avoid creating log messages below the loglevel.
+  def Log.create(hash)
+    raise Puppet::DevError, "Logs require a level" unless hash.include?(:level)
+    raise Puppet::DevError, "Invalid log level #{hash[:level]}" unless @levels.index(hash[:level])
+    @levels.index(hash[:level]) >= @loglevel ? Puppet::Util::Log.new(hash) : nil
+  end
+
+  def Log.destinations
+    @destinations
+  end
+
+  # Yield each valid level in turn
+  def Log.eachlevel
+    @levels.each { |level| yield level }
+  end
+
+  # Return the current log level.
+  def Log.level
+    @levels[@loglevel]
+  end
+
+  # Set the current log level.
+  def Log.level=(level)
+    level = level.intern unless level.is_a?(Symbol)
+
+    raise Puppet::DevError, "Invalid loglevel #{level}" unless @levels.include?(level)
+
+    @loglevel = @levels.index(level)
+  end
+
+  def Log.levels
+    @levels.dup
+  end
+
+  # Create a new log destination.
+  def Log.newdestination(dest)
+    # Each destination can only occur once.
+    if @destinations.find { |name, obj| obj.name == dest }
+      return
+    end
+
+    name, type = @desttypes.find do |name, klass|
+      klass.match?(dest)
+    end
+
+    if type.respond_to?(:suitable?) and not type.suitable?(dest)
+      return
+    end
+
+    raise Puppet::DevError, "Unknown destination type #{dest}" unless type
+
+    begin
+      if type.instance_method(:initialize).arity == 1
+        @destinations[dest] = type.new(dest)
+      else
+        @destinations[dest] = type.new
+      end
+      flushqueue
+      @destinations[dest]
+    rescue => detail
+      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")
+    end
+  end
+
+  def Log.with_destination(destination, &block)
+    if @destinations.include?(destination)
+      yield
+    else
+      newdestination(destination)
+      begin
+        yield
+      ensure
+        close(destination)
+      end
+    end
+  end
+
+  # Route the actual message. FIXME There are lots of things this method
+  # should do, like caching and a bit more.  It's worth noting that there's
+  # a potential for a loop here, if the machine somehow gets the destination set as
+  # itself.
+  def Log.newmessage(msg)
+    return if @levels.index(msg.level) < @loglevel
+
+    queuemessage(msg) if @destinations.length == 0
+
+    @destinations.each do |name, dest|
+      dest.handle(msg)
+    end
+  end
+
+  def Log.queuemessage(msg)
+    @queued.push(msg)
+  end
+
+  def Log.flushqueue
+    return unless @destinations.size >= 1
+    @queued.each do |msg|
+      Log.newmessage(msg)
+    end
+    @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
+
+  # Reopen all of our logs.
+  def Log.reopen
+    Puppet.notice "Reopening log files"
+    types = @destinations.keys
+    @destinations.each { |type, dest|
+      dest.close if dest.respond_to?(:close)
+    }
+    @destinations.clear
+    # We need to make sure we always end up with some kind of destination
+    begin
+      types.each { |type|
+        Log.newdestination(type)
+      }
+    rescue => detail
+      if @destinations.empty?
+        Log.setup_default
+        Puppet.err detail.to_s
+      end
+    end
+  end
+
+  def self.setup_default
+    Log.newdestination(
+      (Puppet.features.syslog?   ? :syslog   :
+      (Puppet.features.eventlog? ? :eventlog : Puppet[:puppetdlog])))
+  end
+
+  # Is the passed level a valid log level?
+  def self.validlevel?(level)
+    @levels.include?(level)
+  end
+
+  def self.from_data_hash(data)
+    obj = allocate
+    obj.initialize_from_hash(data)
+    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, :source
+  attr_reader :level, :message
+
+  def initialize(args)
+    self.level = args[:level]
+    self.message = args[:message]
+    self.source = args[:source] || "Puppet"
+
+    @time = Time.now
+
+    if tags = args[:tags]
+      tags.each { |t| self.tag(t) }
+    end
+
+    [:file, :line].each do |attr|
+      next unless value = args[attr]
+      send(attr.to_s + "=", value)
+    end
+
+    Log.newmessage(self)
+  end
+
+  def initialize_from_hash(data)
+    @level = data['level'].intern
+    @message = data['message']
+    @source = data['source']
+    @tags = Puppet::Util::TagSet.new(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 to_hash
+    self.to_data_hash
+  end
+
+  def to_data_hash
+    {
+      'level' => @level,
+      'message' => @message,
+      'source' => @source,
+      'tags' => @tags,
+      'time' => @time.iso8601(9),
+      'file' => @file,
+      'line' => @line,
+    }
+  end
+
+  def to_pson(*args)
+    to_data_hash.to_pson(*args)
+  end
+
+  def message=(msg)
+    raise ArgumentError, "Puppet::Util::Log requires a message" unless msg
+    @message = msg.to_s
+  end
+
+  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)
+
+    # Tag myself with my log level
+    tag(level)
+  end
+
+  # 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 source.respond_to?(:path)
+      @source = source.path
+      source.tags.each { |t| tag(t) }
+      self.file = source.file
+      self.line = source.line
+    else
+      @source = source.to_s
+    end
+  end
+
+  def to_report
+    "#{time} #{source} (#{level}): #{to_s}"
+  end
+
+  def to_s
+    message
+  end
+
+end
+
+# This is for backward compatibility from when we changed the constant to Puppet::Util::Log
+# because the reports include the constant name.  Apparently the alias was created in
+# March 2007, should could probably be removed soon.
+Puppet::Log = Puppet::Util::Log