bolt 0.20.0 → 0.20.2

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

@@ -0,0 +1,258 @@
+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}") % { str: 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
+    @json = path.end_with?('.json') ? 1 : 0
+
+    # 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 %{dir}") % { dir: File.dirname(path) }
+    end
+
+    # create the log file, if it doesn't already exist
+    need_array_start = false
+    if @json == 1
+      need_array_start = true
+      if File.exists?(path)
+        sz = File.size(path)
+        need_array_start = sz == 0
+
+        # Assume that entries have been written and that a comma
+        # is needed before next entry
+        @json = 2 if sz > 2
+      end
+    end
+
+    file = File.open(path,  File::WRONLY|File::CREAT|File::APPEND)
+    file.puts('[') if need_array_start
+
+    # Give ownership to the user and group puppet will run as
+    if Puppet.features.root? && !Puppet::Util::Platform.windows?
+      begin
+        FileUtils.chown(Puppet[:user], Puppet[:group], path)
+      rescue ArgumentError, Errno::EPERM
+        Puppet.err _("Unable to set ownership to %{user}:%{group} for log file: %{path}") % { user: Puppet[:user], group: Puppet[:group], path: path }
+      end
+    end
+
+    @file = file
+
+    @autoflush = Puppet[:autoflush]
+  end
+
+  def handle(msg)
+    if @json > 0
+      @json > 1 ? @file.puts(',') : @json = 2
+      JSON.dump(msg.to_structured_hash, @file)
+    else
+      @file.puts("#{msg.time} #{msg.source} (#{msg.level}): #{msg}")
+    end
+
+    @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 = 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_json
+  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 => :hyellow,  :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
+  # Leaving these in for backwards compatibility - duplicates the same in
+  # Puppet::Util::Windows::EventLog
+  Puppet::Util::Log::DestEventlog::EVENTLOG_ERROR_TYPE       = 0x0001
+  Puppet::Util::Log::DestEventlog::EVENTLOG_WARNING_TYPE     = 0x0002
+  Puppet::Util::Log::DestEventlog::EVENTLOG_INFORMATION_TYPE = 0x0004
+  Puppet::Util::Log::DestEventlog::EVENTLOG_CHARACTER_LIMIT  = 31838
+
+  def self.suitable?(obj)
+    Puppet.features.microsoft_windows?
+  end
+
+  def initialize
+    @eventlog = Puppet::Util::Windows::EventLog.open("Puppet")
+  end
+
+  def to_native(level)
+    Puppet::Util::Windows::EventLog.to_native(level)
+  end
+
+  def handle(msg)
+    native_type, native_id = to_native(msg.level)
+
+    stringified_msg = msg.message.to_s
+    if stringified_msg.length > self.class::EVENTLOG_CHARACTER_LIMIT
+      warning = "...Message exceeds character length limit, truncating."
+      truncated_message_length = self.class::EVENTLOG_CHARACTER_LIMIT - warning.length
+      stringified_truncated_msg = stringified_msg[0..truncated_message_length]
+      stringified_truncated_msg << warning
+      msg.message = stringified_truncated_msg
+    end
+
+    @eventlog.report_event(
+      :event_type  => native_type,
+      :event_id    => native_id,
+      :data        => (msg.source && msg.source != 'Puppet' ? "#{msg.source}: " : '') + msg.to_s
+    )
+  end
+
+  def close
+    if @eventlog
+      @eventlog.close
+      @eventlog = nil
+    end
+  end
+end

data/vendored/puppet/lib/puppet/util/logging.rb

@@ -0,0 +1,311 @@
+# A module to make logging a bit easier.
+require 'puppet/util/log'
+require 'puppet/error'
+
+require 'facter'
+
+module Puppet::Util
+module 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|
+    # handle debug a special way for performance reasons
+    next if level == :debug
+    define_method(level) do |args|
+      args = args.join(" ") if args.is_a?(Array)
+      send_log(level, args)
+    end
+  end
+
+  # Output a debug log message if debugging is on (but only then)
+  # If the output is anything except a static string, give the debug
+  # a block - it will be called with all other arguments, and is expected
+  # to return the single string result.
+  #
+  # Use a block at all times for increased performance.
+  #
+  # @example This takes 40% of the time compared to not using a block
+  #  Puppet.debug { "This is a string that interpolated #{x} and #{y} }"
+  #
+  def debug(*args)
+    return nil unless Puppet::Util::Log.level == :debug
+    if block_given?
+      send_log(:debug, yield(*args))
+    else
+      send_log(:debug, args.join(" "))
+    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 = {})
+    trace = Puppet[:trace] || options[:trace]
+    if message == :default && exception.is_a?(Puppet::ParseErrorWithIssue)
+      # Retain all detailed info and keep plain message and stacktrace separate
+      backtrace = []
+      build_exception_trace(backtrace, exception, trace)
+      Puppet::Util::Log.create({
+          :level => options[:level] || :err,
+          :source => log_source,
+          :message => exception.basic_message,
+          :issue_code => exception.issue_code,
+          :backtrace => backtrace.empty? ? nil : backtrace,
+          :file => exception.file,
+          :line => exception.line,
+          :pos => exception.pos,
+          :environment => exception.environment,
+          :node => exception.node
+        }.merge(log_metadata))
+    else
+      err(format_exception(exception, message, trace))
+    end
+  end
+
+  def build_exception_trace(arr, exception, trace = true)
+    if trace and exception.backtrace
+      exception.backtrace.each do |line|
+        arr << line =~ /^(.+):(\d+.*)$/ ? ("#{Pathname($1).realpath}:#{$2}" rescue line) : line
+      end
+    end
+    if exception.respond_to?(:original)
+      original =  exception.original
+      unless original.nil?
+        arr << _('Wrapped exception:')
+        arr << original.message
+        build_exception_trace(arr, original, trace)
+      end
+    end
+  end
+  private :build_exception_trace
+
+  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]
+    #TRANSLATORS the literals ":file", ":line", and ":key" should not be translated
+    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
+
+  # Logs a (non deprecation) warning once for a given key.
+  #
+  # @param kind [String] The kind of warning. The
+  #   kind must be one of the defined kinds for the Puppet[:disable_warnings] setting.
+  # @param message [String] The message to log (logs via warning)
+  # @param key [String] Key used to make this warning unique
+  # @param file [String,:default,nil] the File related to the warning
+  # @param line [Integer,:default,nil] the Line number related to the warning
+  #   warning as unique
+  # @param level [Symbol] log level to use, defaults to :warning
+  #
+  # Either :file and :line and/or :key must be passed.
+  def warn_once(kind, key, message, file = nil, line = nil, level = :warning)
+    return if Puppet[:disable_warnings].include?(kind)
+    $unique_warnings ||= {}
+    if $unique_warnings.length < 100 then
+      if (! $unique_warnings.has_key?(key)) then
+        $unique_warnings[key] = message
+        call_trace = if file == :default and line == :default
+                       # Suppress the file and line number output
+                       ''
+                     else
+                       error_location_str = Puppet::Util::Errors.error_location(file, line)
+                       if error_location_str.empty?
+                         '\n   ' + _('(file & line not available)')
+                       else
+                         "\n   %{error_location}" % { error_location: error_location_str }
+                       end
+                     end
+        send_log(level, "#{message}#{call_trace}")
+      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
+    if Puppet[:trace]
+      caller()[2..-1]
+    else
+      [caller()[2]]
+    end
+  end
+
+  def clear_deprecation_warnings
+    $unique_warnings.clear if $unique_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 ||= {}
+
+    # Deprecation messages are UTF-8 as they are produced by Ruby
+    Puppet::FileSystem.open(deprecations_file, nil, "a:UTF-8") 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
+
+  # Sets up Facter logging.
+  # This method causes Facter output to be forwarded to Puppet.
+  def self.setup_facter_logging!
+    # Only recent versions of Facter support this feature
+    return false unless Facter.respond_to? :on_message
+
+    # The current Facter log levels are: :trace, :debug, :info, :warn, :error, and :fatal.
+    # Convert to the corresponding levels in Puppet
+    Facter.on_message do |level, message|
+      case level
+      when :trace, :debug
+        level = :debug
+      when :info
+        # Same as Puppet
+      when :warn
+        level = :warning
+      when :error
+        level = :err
+      when :fatal
+        level = :crit
+      else
+        next
+      end
+      Puppet::Util::Log.create({:level => level, :source => 'Facter', :message => message})
+      nil
+    end
+    true
+  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
+      key ||= (offender = get_deprecation_offender)
+      unless $deprecation_warnings.has_key?(key)
+        $deprecation_warnings[key] = message
+        # split out to allow translation
+        call_trace = if use_caller
+                       _("(location: %{location})") % { location: (offender || get_deprecation_offender).join('; ') }
+                     else
+                       Puppet::Util::Errors.error_location_with_unknowns(file, line)
+                     end
+        warning("%{message}\n   %{call_trace}" % { message: message, call_trace: 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
+end