puppet 5.3.4 → 6.29.0

data/lib/puppet/util/json_lockfile.rb

@@ -23,7 +23,7 @@ class Puppet::Util::JsonLockfile < Puppet::Util::Lockfile
   def lock(lock_data = nil)
     return false if locked?
 
-    super(lock_data.to_json)
+    super(Puppet::Util::Json.dump(lock_data))
   end
 
   # Retrieve the (optional) lock data that was specified at the time the file
@@ -35,8 +35,8 @@ class Puppet::Util::JsonLockfile < Puppet::Util::Lockfile
     return nil unless file_locked?
     file_contents = super
     return nil if file_contents.nil? or file_contents.empty?
-    JSON.parse(file_contents)
-  rescue JSON::ParserError => e
+    Puppet::Util::Json.load(file_contents)
+  rescue Puppet::Util::Json::ParseError
     Puppet.warning _("Unable to read lockfile data from %{path}: not in JSON") % { path: @file_path }
     nil
   end

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

@@ -1,9 +1,6 @@
 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
@@ -20,9 +17,11 @@ class Puppet::Util::Ldap::Connection
 
     options = {}
     options[:ssl] = ssl
-    if user = Puppet.settings[:ldapuser] and user != ""
+    user = Puppet.settings[:ldapuser]
+    if user && user != ""
       options[:user] = user
-      if pass = Puppet.settings[:ldappassword] and pass != ""
+      pass = Puppet.settings[:ldappassword]
+      if pass && pass != ""
         options[:password] = pass
       end
     end
@@ -34,12 +33,15 @@ class Puppet::Util::Ldap::Connection
     connection.unbind if connection.bound?
   end
 
-  def initialize(host, port, options = {})
+  def initialize(host, port, user: nil, password: nil, reset: nil, ssl: nil)
     raise Puppet::Error, _("Could not set up LDAP Connection: Missing ruby/ldap libraries") unless Puppet.features.ldap?
 
-    @host, @port = host, port
-
-    set_options(options)
+    @host = host
+    @port = port
+    @user = user
+    @password = password
+    @reset = reset
+    @ssl = ssl
   end
 
   # Create a per-connection unique name.

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

@@ -56,10 +56,12 @@ class Puppet::Util::Ldap::Manager
         ssl = false
       end
       options = {:ssl => ssl}
-      if user = Puppet[:ldapuser] and user != ""
+      user = Puppet[:ldapuser]
+      if user && user != ""
         options[:user] = user
       end
-      if password = Puppet[:ldappassword] and password != ""
+      password = Puppet[:ldappassword]
+      if password && password != ""
         options[:password] = password
       end
       @connection = Puppet::Util::Ldap::Connection.new(Puppet[:ldapserver], Puppet[:ldapport], options)
@@ -138,7 +140,8 @@ class Puppet::Util::Ldap::Manager
       next if values[generator.name]
 
       if generator.source
-        unless value = values[generator.source]
+        value = values[generator.source]
+        unless value
           raise ArgumentError, _("%{source} must be defined to generate %{name}") %
               { source: generator.source, name: generator.name }
         end

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

@@ -34,7 +34,7 @@ Puppet::Util::Log.newdesttype :syslog do
       end
     else
       msg.to_s.split("\n").each do |line|
-        @syslog.send(msg.level, "(%s) %s" % [msg.source.to_s.gsub("%", ""),
+        @syslog.send(msg.level, "(%s) %s" % [msg.source.to_s.delete("%"),
             line.gsub("%", '%%')
           ]
         )
@@ -47,7 +47,7 @@ Puppet::Util::Log.newdesttype :file do
   require 'fileutils'
 
   def self.match?(obj)
-    Puppet::Util.absolute_path?(obj)
+    obj.is_a?(String) && Puppet::Util.absolute_path?(obj)
   end
 
   def close
@@ -66,6 +66,7 @@ Puppet::Util::Log.newdesttype :file do
   def initialize(path)
     @name = path
     @json = path.end_with?('.json') ? 1 : 0
+    @jsonl = path.end_with?('.jsonl')
 
     # first make sure the directory exists
     # We can't just use 'Config.use' here, because they've
@@ -77,9 +78,10 @@ Puppet::Util::Log.newdesttype :file do
 
     # create the log file, if it doesn't already exist
     need_array_start = false
+    file_exists = Puppet::FileSystem.exist?(path)
     if @json == 1
       need_array_start = true
-      if File.exists?(path)
+      if file_exists
         sz = File.size(path)
         need_array_start = sz == 0
 
@@ -89,18 +91,9 @@ Puppet::Util::Log.newdesttype :file do
       end
     end
 
-    file = File.open(path,  File::WRONLY|File::CREAT|File::APPEND)
+    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]
@@ -109,7 +102,9 @@ Puppet::Util::Log.newdesttype :file do
   def handle(msg)
     if @json > 0
       @json > 1 ? @file.puts(',') : @json = 2
-      JSON.dump(msg.to_structured_hash, @file)
+      @file.puts(Puppet::Util::Json.dump(msg.to_structured_hash))
+    elsif @jsonl
+      @file.puts(Puppet::Util::Json.dump(msg.to_structured_hash))
     else
       @file.puts("#{msg.time} #{msg.source} (#{msg.level}): #{msg}")
     end
@@ -125,7 +120,6 @@ Puppet::Util::Log.newdesttype :logstash_event do
     # 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']
@@ -136,7 +130,7 @@ Puppet::Util::Log.newdesttype :logstash_event do
 
   def handle(msg)
     message = format(msg)
-    $stdout.puts message.to_json
+    $stdout.puts Puppet::Util::Json.dump(message)
   end
 end
 
@@ -217,9 +211,10 @@ 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
+  Puppet::Util::Log::DestEventlog::EVENTLOG_CHARACTER_LIMIT  = 31838
 
   def self.suitable?(obj)
-    Puppet.features.microsoft_windows?
+    Puppet::Util::Platform.windows?
   end
 
   def initialize
@@ -233,6 +228,15 @@ Puppet::Util::Log.newdesttype :eventlog do
   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/lib/puppet/util/log.rb

@@ -2,7 +2,6 @@ require 'puppet/util/tagging'
 require 'puppet/util/classgen'
 require 'puppet/util/psych_support'
 require 'puppet/network/format_support'
-require 'facter'
 
 # 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
@@ -60,7 +59,7 @@ class Puppet::Util::Log
   end
 
   def self.close_all
-    destinations.keys.each { |dest|
+    @destinations.keys.each { |dest|
       close(dest)
     }
     #TRANSLATORS "Log.close_all" is a method name and should not be translated
@@ -106,12 +105,17 @@ class Puppet::Util::Log
   def Log.level=(level)
     level = level.intern unless level.is_a?(Symbol)
 
-    raise Puppet::DevError, _("Invalid loglevel %{level}") % { level: level } unless @levels.include?(level)
+    # loglevel is a 0-based index
+    loglevel = @levels.index(level)
+    raise Puppet::DevError, _("Invalid loglevel %{level}") % { level: level } unless loglevel
 
-    @loglevel = @levels.index(level)
+    return if @loglevel == loglevel
+
+    # loglevel changed
+    @loglevel = loglevel
 
     # Enable or disable Facter debugging
-    Facter.debugging(level == :debug) if Facter.respond_to? :debugging
+    Puppet.runtime[:facter].debugging(level == :debug)
   end
 
   def Log.levels
@@ -125,7 +129,7 @@ class Puppet::Util::Log
       return
     end
 
-    name, type = @desttypes.find do |name, klass|
+    _, type = @desttypes.find do |name, klass|
       klass.match?(dest)
     end
 
@@ -147,7 +151,12 @@ class Puppet::Util::Log
       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")
+      if destinations.empty? && dest.intern != :console
+        newdestination(:console)
+      end
+
+      # Re-raise (end exit Puppet) because we could not set up logging correctly.
+      raise detail
     end
   end
 
@@ -164,19 +173,16 @@ class Puppet::Util::Log
     end
   end
 
-  private
-  # produces UTF-8 strings or dumps strings when they cannot be re-encoded
   def Log.coerce_string(str)
     return Puppet::Util::CharacterEncoding.convert_to_utf_8(str) if str.valid_encoding?
 
     # We only select the last 10 callers in the stack to avoid being spammy
     message = _("Received a Log attribute with invalid encoding:%{log_message}") %
         { log_message: Puppet::Util::CharacterEncoding.convert_to_utf_8(str.dump)}
-    message += '\n' + _("Backtrace:\n%{backtrace}") % { backtrace: caller[0..10].join("\n") }
+    message += '\n' + _("Backtrace:\n%{backtrace}") % { backtrace: caller(1, 10).join("\n") }
     message
   end
-
-  public
+  private_class_method :coerce_string
 
   # 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
@@ -298,13 +304,15 @@ class Puppet::Util::Log
 
     @time = Time.now
 
-    if tags = args[:tags]
+    tags = args[:tags]
+    if tags
       tags.each { |t| self.tag(t) }
     end
 
     # Don't add these unless defined (preserve 3.x API as much as possible)
     [:file, :line, :pos, :issue_code, :environment, :node, :backtrace].each do |attr|
-      next unless value = args[attr]
+      value = args[attr]
+      next unless value
       send(attr.to_s + '=', value)
     end
 
@@ -322,7 +330,8 @@ class Puppet::Util::Log
     end
     # Don't add these unless defined (preserve 3.x API as much as possible)
     %w(file line pos issue_code environment node backtrace).each do |name|
-      next unless value = data[name]
+      value = data[name]
+      next unless value
       send(name + '=', value)
     end
   end
@@ -381,7 +390,7 @@ class Puppet::Util::Log
   def source=(source)
     if defined?(Puppet::Type) && source.is_a?(Puppet::Type)
       @source = source.path
-      source.tags.each { |t| tag(t) }
+      merge_tags_from(source)
       self.file = source.file
       self.line = source.line
     else
@@ -390,7 +399,7 @@ class Puppet::Util::Log
   end
 
   def to_report
-    "#{time} #{source} (#{level}): #{to_s}"
+    "#{time} #{source} (#{level}): #{self}"
   end
 
   def to_s

data/lib/puppet/util/logging.rb

@@ -2,8 +2,6 @@
 require 'puppet/util/log'
 require 'puppet/error'
 
-require 'facter'
-
 module Puppet::Util
 module Logging
 
@@ -48,13 +46,15 @@ module Logging
   #    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]
+    level = options[:level] || :err
+    combined_trace = Puppet[:trace] || options[:trace]
+    puppet_trace = Puppet[:puppet_trace] || options[:puppet_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)
+      backtrace = build_exception_trace(exception, combined_trace, puppet_trace)
       Puppet::Util::Log.create({
-          :level => options[:level] || :err,
+          :level => level,
           :source => log_source,
           :message => exception.basic_message,
           :issue_code => exception.issue_code,
@@ -66,28 +66,27 @@ module Logging
           :node => exception.node
         }.merge(log_metadata))
     else
-      err(format_exception(exception, message, trace))
+      send_log(level, format_exception(exception, message, combined_trace, puppet_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
+  def build_exception_trace(exception, combined_trace = true, puppet_trace = false)
+    built_trace = format_backtrace(exception, combined_trace, puppet_trace)
+
     if exception.respond_to?(:original)
       original =  exception.original
       unless original.nil?
-        arr << _('Wrapped exception:')
-        arr << original.message
-        build_exception_trace(arr, original, trace)
+        built_trace << _('Wrapped exception:')
+        built_trace << original.message
+        built_trace += build_exception_trace(original, combined_trace, puppet_trace)
       end
     end
+
+    built_trace
   end
   private :build_exception_trace
 
-  def format_exception(exception, message = :default, trace = true)
+  def format_exception(exception, message = :default, combined_trace = true, puppet_trace = false)
     arr = []
     case message
     when :default
@@ -98,16 +97,28 @@ module Logging
       arr << message
     end
 
-    if trace and exception.backtrace
-      arr << Puppet::Util.pretty_backtrace(exception.backtrace)
-    end
+    arr += format_backtrace(exception, combined_trace, puppet_trace)
+
     if exception.respond_to?(:original) and exception.original
       arr << _("Wrapped exception:")
-      arr << format_exception(exception.original, :default, trace)
+      arr << format_exception(exception.original, :default, combined_trace, puppet_trace)
     end
+
     arr.flatten.join("\n")
   end
 
+  def format_backtrace(exception, combined_trace, puppet_trace)
+    puppetstack = exception.respond_to?(:puppetstack) ? exception.puppetstack : []
+
+    if combined_trace and exception.backtrace
+      Puppet::Util.format_backtrace_array(exception.backtrace, puppetstack)
+    elsif puppet_trace && !puppetstack.empty?
+      Puppet::Util.format_backtrace_array(puppetstack)
+    else
+      []
+    end
+  end
+
   def log_and_raise(exception, message)
     log_exception(exception, message)
     raise exception, message + "\n" + exception.to_s, exception.backtrace
@@ -176,7 +187,7 @@ module Logging
                      else
                        error_location_str = Puppet::Util::Errors.error_location(file, line)
                        if error_location_str.empty?
-                         '\n   ' + _('(file & line not available)')
+                         "\n   " + _('(file & line not available)')
                        else
                          "\n   %{error_location}" % { error_location: error_location_str }
                        end
@@ -193,9 +204,9 @@ module Logging
     # 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]
+      caller(3)
     else
-      [caller()[2]]
+      [caller(3, 1).first]
     end
   end
 
@@ -241,29 +252,7 @@ module Logging
   # 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
+    Puppet.runtime[:facter]
     true
   end
 

data/lib/puppet/util/metric.rb

@@ -32,7 +32,8 @@ class Puppet::Util::Metric
 
   # Return a specific value
   def [](name)
-    if value = @values.find { |v| v[0] == name }
+    value = @values.find { |v| v[0] == name }
+    if value
       return value[2]
     else
       return 0
@@ -54,11 +55,11 @@ class Puppet::Util::Metric
   end
 
   def values
-    @values.sort { |a, b| a[1] <=> b[1] }
+    @values.sort_by { |a| a[1] }
   end
 
   # Convert a name into a label.
   def self.labelize(name)
-    name.to_s.capitalize.gsub("_", " ")
+    name.to_s.capitalize.tr("_", " ")
   end
 end

data/lib/puppet/util/monkey_patches.rb

@@ -1,3 +1,5 @@
+require 'puppet/util/platform'
+
 module Puppet::Util::MonkeyPatches
 end
 
@@ -28,35 +30,46 @@ class Object
 end
 
 # (#19151) Reject all SSLv2 ciphers and handshakes
-require 'openssl'
-class OpenSSL::SSL::SSLContext
-  if DEFAULT_PARAMS[:options]
-    DEFAULT_PARAMS[:options] |= OpenSSL::SSL::OP_NO_SSLv2 | OpenSSL::SSL::OP_NO_SSLv3
-  else
-    DEFAULT_PARAMS[:options] = OpenSSL::SSL::OP_NO_SSLv2 | OpenSSL::SSL::OP_NO_SSLv3
+require 'puppet/ssl/openssl_loader'
+unless Puppet::Util::Platform.jruby_fips?
+  unless defined?(OpenSSL::SSL::TLS1_VERSION)
+    module OpenSSL::SSL
+      # see https://github.com/ruby/ruby/commit/609103dbb5fb182eec12f052226c43e39b907682#diff-09f822c26289f5347111795ca22ed7ed1cfadd6ebd28f987991d1d414eef565aR2755-R2759
+      OpenSSL::SSL::TLS1_VERSION = 0x301
+    end
   end
-  if DEFAULT_PARAMS[:ciphers]
-    DEFAULT_PARAMS[:ciphers] << ':!SSLv2'
+
+  unless defined?(OpenSSL::X509::V_ERR_HOSTNAME_MISMATCH)
+    module OpenSSL::X509
+      OpenSSL::X509::V_ERR_HOSTNAME_MISMATCH = 0x3E
+    end
   end
 
-  alias __original_initialize initialize
-  private :__original_initialize
+  class OpenSSL::SSL::SSLContext
+    if DEFAULT_PARAMS[:options]
+      DEFAULT_PARAMS[:options] |= OpenSSL::SSL::OP_NO_SSLv2 | OpenSSL::SSL::OP_NO_SSLv3
+    else
+      DEFAULT_PARAMS[:options] = OpenSSL::SSL::OP_NO_SSLv2 | OpenSSL::SSL::OP_NO_SSLv3
+    end
+    if DEFAULT_PARAMS[:ciphers]
+      DEFAULT_PARAMS[:ciphers] << ':!SSLv2'
+    end
+
+    alias __original_initialize initialize
+    private :__original_initialize
 
-  def initialize(*args)
-    __original_initialize(*args)
-    params = {
-      :options => DEFAULT_PARAMS[:options],
-      :ciphers => DEFAULT_PARAMS[:ciphers],
-    }
-    set_params(params)
+    def initialize(*args)
+      __original_initialize(*args)
+      params = {
+        :options => DEFAULT_PARAMS[:options],
+        :ciphers => DEFAULT_PARAMS[:ciphers],
+      }
+      set_params(params)
+    end
   end
 end
 
-require 'puppet/util/platform'
 if Puppet::Util::Platform.windows?
-  require 'puppet/util/windows'
-  require 'openssl'
-
   class OpenSSL::X509::Store
     @puppet_certs_loaded = false
     alias __original_set_default_paths set_default_paths
@@ -69,8 +82,8 @@ if Puppet::Util::Platform.windows?
         Puppet::Util::Windows::RootCerts.instance.to_a.uniq { |cert| cert.to_der }.each do |x509|
           begin
             add_cert(x509)
-          rescue OpenSSL::X509::StoreError => e
-            warn "Failed to add #{x509.subject.to_s}"
+          rescue OpenSSL::X509::StoreError
+            warn "Failed to add #{x509.subject.to_utf8}"
           end
         end
       end
@@ -80,6 +93,46 @@ if Puppet::Util::Platform.windows?
   end
 end
 
+unless Puppet::Util::Platform.jruby_fips?
+  unless OpenSSL::X509::Name.instance_methods.include?(:to_utf8)
+    class OpenSSL::X509::Name
+      # https://github.com/openssl/openssl/blob/OpenSSL_1_1_0j/include/openssl/asn1.h#L362
+      ASN1_STRFLGS_ESC_MSB = 4
+
+      FLAGS = if RUBY_PLATFORM == 'java'
+                OpenSSL::X509::Name::RFC2253
+              else
+                OpenSSL::X509::Name::RFC2253 & ~ASN1_STRFLGS_ESC_MSB
+              end
+
+      def to_utf8
+        # https://github.com/ruby/ruby/blob/v2_5_5/ext/openssl/ossl_x509name.c#L317
+        str = to_s(FLAGS)
+        str.force_encoding(Encoding::UTF_8)
+      end
+    end
+  end
+end
+
+unless Puppet::Util::Platform.jruby_fips?
+  unless OpenSSL::PKey::EC.instance_methods.include?(:private?)
+    class OpenSSL::PKey::EC
+      # Added in ruby 2.4.0 in https://github.com/ruby/ruby/commit/7c971e61f04
+      alias :private? :private_key?
+    end
+  end
+
+  unless OpenSSL::PKey::EC.singleton_methods.include?(:generate)
+    class OpenSSL::PKey::EC
+      # Added in ruby 2.4.0 in https://github.com/ruby/ruby/commit/85500b66342
+      def self.generate(string)
+        ec = OpenSSL::PKey::EC.new(string)
+        ec.generate_key
+      end
+    end
+  end
+end
+
 # The Enumerable#uniq method was added in Ruby 2.4.0 (https://bugs.ruby-lang.org/issues/11090)
 # This is a backport to earlier Ruby versions.
 #

data/lib/puppet/util/network_device/base.rb

@@ -12,7 +12,7 @@ class Puppet::Util::NetworkDevice::Base
 
     @autoloader = Puppet::Util::Autoload.new(self, "puppet/util/network_device/transport")
 
-    if @autoloader.load(@url.scheme)
+    if @autoloader.load(@url.scheme, Puppet.lookup(:current_environment))
       @transport = Puppet::Util::NetworkDevice::Transport.const_get(@url.scheme.capitalize).new(options[:debug])
       @transport.host = @url.host
       @transport.port = @url.port || case @url.scheme ; when "ssh" ; 22 ; when "telnet" ; 23 ; end

data/lib/puppet/util/network_device/config.rb

@@ -71,13 +71,12 @@ class Puppet::Util::NetworkDevice::Config
             raise Puppet::Error, _("Invalid entry at %{error_location}: %{file_text}") %
                 { error_location: error_location_str, file_text: line }
           end
-          file_line_count += 1
         end
       end
-    rescue Errno::EACCES => detail
+    rescue Errno::EACCES
       Puppet.err _("Configuration error: Cannot read %{file}; cannot serve") % { file: @file }
       #raise Puppet::Error, "Cannot read #{@config}"
-    rescue Errno::ENOENT => detail
+    rescue Errno::ENOENT
       Puppet.err _("Configuration error: '%{file}' does not exit; cannot serve") % { file: @file }
     end