puppet-retrospec 0.7.0 → 0.7.2

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

@@ -0,0 +1,49 @@
+# A type of log destination.
+class Puppet::Util::Log::Destination
+  class << self
+    attr_accessor :name
+  end
+
+  def self.initvars
+    @matches = []
+  end
+
+  # Mark the things we're supposed to match.
+  def self.match(obj)
+    @matches ||= []
+    @matches << obj
+  end
+
+  # See whether we match a given thing.
+  def self.match?(obj)
+    # Convert single-word strings into symbols like :console and :syslog
+    if obj.is_a? String and obj =~ /^\w+$/
+      obj = obj.downcase.intern
+    end
+
+    @matches.each do |thing|
+      # Search for direct matches or class matches
+      return true if thing === obj or thing == obj.class.to_s
+    end
+    false
+  end
+
+  def name
+    if defined?(@name)
+      return @name
+    else
+      return self.class.name
+    end
+  end
+
+  # Set how to handle a message.
+  def self.sethandler(&block)
+    define_method(:handle, &block)
+  end
+
+  # Mark how to initialize our object.
+  def self.setinit(&block)
+    define_method(:initialize, &block)
+  end
+end
+

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

@@ -0,0 +1,232 @@
+Puppet::Util::Log.newdesttype :syslog do
+  def self.suitable?(obj)
+    Puppet.features.syslog?
+  end
+
+  def close
+    Syslog.close
+  end
+
+  def initialize
+    Syslog.close if Syslog.opened?
+    name = "puppet-#{Puppet.run_mode.name}"
+
+    options = Syslog::LOG_PID | Syslog::LOG_NDELAY
+
+    # XXX This should really be configurable.
+    str = Puppet[:syslogfacility]
+    begin
+      facility = Syslog.const_get("LOG_#{str.upcase}")
+    rescue NameError
+      raise Puppet::Error, "Invalid syslog facility #{str}", $!.backtrace
+    end
+
+    @syslog = Syslog.open(name, options, facility)
+  end
+
+  def handle(msg)
+    # XXX Syslog currently has a bug that makes it so you
+    # cannot log a message with a '%' in it.  So, we get rid
+    # of them.
+    if msg.source == "Puppet"
+      msg.to_s.split("\n").each do |line|
+        @syslog.send(msg.level, line.gsub("%", '%%'))
+      end
+    else
+      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
+
+Puppet::Util::Log.newdesttype :file do
+  require 'fileutils'
+
+  def self.match?(obj)
+    Puppet::Util.absolute_path?(obj)
+  end
+
+  def close
+    if defined?(@file)
+      @file.close
+      @file = nil
+    end
+  end
+
+  def flush
+    @file.flush if defined?(@file)
+  end
+
+  attr_accessor :autoflush
+
+  def initialize(path)
+    @name = path
+    # first make sure the directory exists
+    # We can't just use 'Config.use' here, because they've
+    # specified a "special" destination.
+    unless Puppet::FileSystem.exist?(Puppet::FileSystem.dir(path))
+      FileUtils.mkdir_p(File.dirname(path), :mode => 0755)
+      Puppet.info "Creating log directory #{File.dirname(path)}"
+    end
+
+    # create the log file, if it doesn't already exist
+    file = File.open(path, File::WRONLY|File::CREAT|File::APPEND)
+
+    # Give ownership to the user and group puppet will run as
+    begin
+      FileUtils.chown(Puppet[:user], Puppet[:group], path) unless Puppet::Util::Platform.windows?
+    rescue ArgumentError, Errno::EPERM
+      Puppet.err "Unable to set ownership of log file"
+    end
+
+    @file = file
+
+    @autoflush = Puppet[:autoflush]
+  end
+
+  def handle(msg)
+    @file.puts("#{msg.time} #{msg.source} (#{msg.level}): #{msg}")
+
+    @file.flush if @autoflush
+  end
+end
+
+Puppet::Util::Log.newdesttype :logstash_event do
+  require 'time'
+
+  def format(msg)
+    # logstash_event format is documented at
+    # https://logstash.jira.com/browse/LOGSTASH-675
+
+    data = {}
+    data = msg.to_hash
+    data['version'] = 1
+    data['@timestamp'] = data['time']
+    data.delete('time')
+
+    data
+  end
+
+  def handle(msg)
+    message = format(msg)
+    $stdout.puts message.to_pson
+  end
+end
+
+Puppet::Util::Log.newdesttype :console do
+  require 'puppet/util/colors'
+  include Puppet::Util::Colors
+
+  def initialize
+    # Flush output immediately.
+    $stderr.sync = true
+    $stdout.sync = true
+  end
+
+  def handle(msg)
+    levels = {
+      :emerg   => { :name => 'Emergency', :color => :hred,  :stream => $stderr },
+      :alert   => { :name => 'Alert',     :color => :hred,  :stream => $stderr },
+      :crit    => { :name => 'Critical',  :color => :hred,  :stream => $stderr },
+      :err     => { :name => 'Error',     :color => :hred,  :stream => $stderr },
+      :warning => { :name => 'Warning',   :color => :hred,  :stream => $stderr },
+
+      :notice  => { :name => 'Notice',    :color => :reset, :stream => $stdout },
+      :info    => { :name => 'Info',      :color => :green, :stream => $stdout },
+      :debug   => { :name => 'Debug',     :color => :cyan,  :stream => $stdout },
+    }
+
+    str = msg.respond_to?(:multiline) ? msg.multiline : msg.to_s
+    str = msg.source == "Puppet" ? str : "#{msg.source}: #{str}"
+
+    level = levels[msg.level]
+    level[:stream].puts colorize(level[:color], "#{level[:name]}: #{str}")
+  end
+end
+
+# Log to a transaction report.
+Puppet::Util::Log.newdesttype :report do
+  attr_reader :report
+
+  match "Puppet::Transaction::Report"
+
+  def initialize(report)
+    @report = report
+  end
+
+  def handle(msg)
+    @report << msg
+  end
+end
+
+# Log to an array, just for testing.
+module Puppet::Test
+  class LogCollector
+    def initialize(logs)
+      @logs = logs
+    end
+
+    def <<(value)
+      @logs << value
+    end
+  end
+end
+
+Puppet::Util::Log.newdesttype :array do
+  match "Puppet::Test::LogCollector"
+
+  def initialize(messages)
+    @messages = messages
+  end
+
+  def handle(msg)
+    @messages << msg
+  end
+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
+
+  def initialize
+    @eventlog = Win32::EventLog.open("Application")
+  end
+
+  def to_native(level)
+    case level
+    when :debug,:info,:notice
+      [self.class::EVENTLOG_INFORMATION_TYPE, 0x01]
+    when :warning
+      [self.class::EVENTLOG_WARNING_TYPE, 0x02]
+    when :err,:alert,:emerg,:crit
+      [self.class::EVENTLOG_ERROR_TYPE, 0x03]
+    end
+  end
+
+  def handle(msg)
+    native_type, native_id = to_native(msg.level)
+
+    @eventlog.report_event(
+      :source      => "Puppet",
+      :event_type  => native_type,
+      :event_id    => native_id,
+      :data        => (msg.source and msg.source != 'Puppet' ? "#{msg.source}: " : '') + msg.to_s
+    )
+  end
+
+  def close
+    if @eventlog
+      @eventlog.close
+      @eventlog = nil
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require 'puppet/util/logging'
+
+# Logging utility class that limits the frequency of identical log messages
+class Puppet::Util::Log::RateLimitedLogger
+  include Puppet::Util::Logging
+
+  def initialize(interval)
+    raise ArgumentError, "Logging rate-limit interval must be an integer" unless interval.is_a?(Integer)
+    @interval = interval
+    @log_record = {}
+  end
+
+  # Override the logging entry point to rate-limit it
+  def send_log(level, message)
+    Puppet::Util::Log.create({:level => level, :message => message}) if should_log?(level, message)
+  end
+
+  private
+
+  def should_log?(level, message)
+    # Initialize separate records for different levels, and only when needed
+    record = (@log_record[level] ||= {})
+    last_log = record[message]
+
+    # Skip logging if the time interval since the last logging hasn't elapsed yet
+    return false if last_log and within_interval?(last_log)
+
+    # Purge stale entries; do this after the interval check to reduce passes through the cache
+    record.delete_if { |key, time| !within_interval?(time) }
+
+    # Reset the beginning of the interval to the current time
+    record[message] = Time.now
+
+    true
+  end
+
+  def within_interval?(time)
+    time + @interval > Time.now
+  end
+end

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

@@ -0,0 +1,181 @@
+# A module to make logging a bit easier.
+require 'puppet/util/log'
+require 'puppet/error'
+
+module Puppet::Util::Logging
+
+  def send_log(level, message)
+    Puppet::Util::Log.create({:level => level, :source => log_source, :message => message}.merge(log_metadata))
+  end
+
+  # Create a method for each log level.
+  Puppet::Util::Log.eachlevel do |level|
+    define_method(level) do |args|
+      args = args.join(" ") if args.is_a?(Array)
+      send_log(level, args)
+    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
+
+  # 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.  Finally, if
+  # Puppet[:disable_warnings] includes 'deprecations', it will squelch all
+  # warning calls made via this method.
+  #
+  # @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)
+    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()
+    # 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
+    if Puppet[:trace]
+      caller()[2..-1]
+    else
+      [caller()[2]]
+    end
+  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 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
+
+  def is_resource_parameter?
+    defined?(Puppet::Parameter) && is_a?(Puppet::Parameter)
+  end
+
+  def log_metadata
+    [:file, :line, :tags].inject({}) do |result, attr|
+      result[attr] = send(attr) if respond_to?(attr)
+      result
+    end
+  end
+
+  def log_source
+    # We need to guard the existence of the constants, since this module is used by the base Puppet module.
+    (is_resource? or is_resource_parameter?) and respond_to?(:path) and return path.to_s
+    to_s
+  end
+end