puppet 5.3.3 → 5.3.4

data/lib/puppet/util/instance_loader.rb

@@ -67,9 +67,7 @@ module Puppet::Util::InstanceLoader
     unless instances.include? name
       if instance_loader(type).load(name)
         unless instances.include? name
-          Puppet.warning(
-            _("Loaded %{type} file for %{name} but %{type} was not defined") % { type: type, name: name }
-          )
+          Puppet.warning(_("Loaded %{type} file for %{name} but %{type} was not defined") % { type: type, name: name })
           return nil
         end
       else

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

@@ -44,7 +44,8 @@ class Puppet::Util::Ldap::Manager
   # Open, yield, and close the connection.  Cannot be left
   # open, at this point.
   def connect
-    raise ArgumentError, "You must pass a block to #connect" unless block_given?
+    #TRANSLATORS '#connect' is a method name and and should not be translated, 'block' refers to a Ruby code block
+    raise ArgumentError, _("You must pass a block to #connect") unless block_given?
 
     unless @connection
       if Puppet[:ldaptls]
@@ -85,7 +86,8 @@ class Puppet::Util::Ldap::Manager
 
   # Convert an ldap-style entry hash to a provider-style hash.
   def entry2provider(entry)
-    raise ArgumentError, "Could not get dn from ldap entry" unless entry["dn"]
+    #TRANSLATOR 'dn' refers to a 'distinguished name' in LDAP (Lightweight Directory Access Protocol) and they should not be translated
+    raise ArgumentError, _("Could not get dn from ldap entry") unless entry["dn"]
 
     # DN is always a single-entry array.  Strip off the bits before the
     # first comma, then the bits after the remaining equal sign.  This is the
@@ -137,7 +139,8 @@ class Puppet::Util::Ldap::Manager
 
       if generator.source
         unless value = values[generator.source]
-          raise ArgumentError, "#{generator.source} must be defined to generate #{generator.name}"
+          raise ArgumentError, _("%{source} must be defined to generate %{name}") %
+              { source: generator.source, name: generator.name }
         end
         result = generator.generate(value)
       else

data/lib/puppet/util/log.rb

@@ -63,7 +63,8 @@ class Puppet::Util::Log
     destinations.keys.each { |dest|
       close(dest)
     }
-    raise Puppet::DevError.new("Log.close_all failed to close #{@destinations.keys.inspect}") if !@destinations.empty?
+    #TRANSLATORS "Log.close_all" is a method name and should not be translated
+    raise Puppet::DevError.new(_("Log.close_all failed to close %{destinations}") % { destinations: @destinations.keys.inspect }) if !@destinations.empty?
   end
 
   # Flush any log destinations that support such operations.
@@ -82,8 +83,8 @@ class Puppet::Util::Log
   # 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])
+    raise Puppet::DevError, _("Logs require a level") unless hash.include?(:level)
+    raise Puppet::DevError, _("Invalid log level %{level}") % { level: hash[:level] } unless @levels.index(hash[:level])
     @levels.index(hash[:level]) >= @loglevel ? Puppet::Util::Log.new(hash) : nil
   end
 
@@ -105,7 +106,7 @@ class Puppet::Util::Log
   def Log.level=(level)
     level = level.intern unless level.is_a?(Symbol)
 
-    raise Puppet::DevError, "Invalid loglevel #{level}" unless @levels.include?(level)
+    raise Puppet::DevError, _("Invalid loglevel %{level}") % { level: level } unless @levels.include?(level)
 
     @loglevel = @levels.index(level)
 
@@ -132,7 +133,7 @@ class Puppet::Util::Log
       return
     end
 
-    raise Puppet::DevError, "Unknown destination type #{dest}" unless type
+    raise Puppet::DevError, _("Unknown destination type %{dest}") % { dest: dest} unless type
 
     begin
       if type.instance_method(:initialize).arity == 1
@@ -168,10 +169,11 @@ class Puppet::Util::Log
   def Log.coerce_string(str)
     return Puppet::Util::CharacterEncoding.convert_to_utf_8(str) if str.valid_encoding?
 
-    annotated_string = _("Received a Log attribute with invalid encoding:")
-    annotated_string << Puppet::Util::CharacterEncoding.convert_to_utf_8(str.dump) << "\n"
     # We only select the last 10 callers in the stack to avoid being spammy
-    annotated_string << _("Backtrace:") << "\n" << caller[0..10].join("\n")
+    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
   end
 
   public
@@ -357,15 +359,18 @@ class Puppet::Util::Log
   end
 
   def message=(msg)
-    raise ArgumentError, "Puppet::Util::Log requires a message" unless msg
+    #TRANSLATORS 'Puppet::Util::Log' refers to a Puppet source code class
+    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"
+    #TRANSLATORS 'Puppet::Util::Log' refers to a Puppet source code class
+    raise ArgumentError, _("Puppet::Util::Log requires a log level") unless level
+    #TRANSLATORS 'Puppet::Util::Log' refers to a Puppet source code class
+    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)
+    raise ArgumentError, _("Invalid log level %{level}") % { level: @level } unless self.class.validlevel?(@level)
 
     # Tag myself with my log level
     tag(level)
@@ -394,18 +399,8 @@ class Puppet::Util::Log
     # Issue based messages do not have details in the message. It
     # must be appended here
     unless issue_code.nil?
-      msg = _("Could not parse for environment %{env}: %{msg}") % { env: environment, msg: msg } unless environment.nil?
-      if file && line && pos
-        msg = _("%{msg} at %{file}:%{line}:%{pos}") % { msg: msg, file: file, line: line, pos: pos }
-      elsif file and line
-        msg = _("%{msg}  at %{file}:%{line}") % { msg: msg, file: file, line: line }
-      elsif line && pos
-        msg = _("%{msg}  at line %{line}:%{pos}") % { msg: msg, line: line, pos: pos }
-      elsif line
-        msg = _("%{msg}  at line %{line}") % { msg: msg, line: line }
-      elsif file
-        msg = _("%{msg}  in %{file}") % { msg: msg, file: file }
-      end
+      msg = _("Could not parse for environment %{environment}: %{msg}") % { environment: environment, msg: msg } unless environment.nil?
+      msg += Puppet::Util::Errors.error_location_with_space(file, line, pos)
       msg = _("%{msg} on node %{node}") % { msg: msg, node: node } unless node.nil?
       if @backtrace.is_a?(Array)
         msg += "\n"

data/lib/puppet/util/logging.rb

@@ -1,7 +1,6 @@
 # A module to make logging a bit easier.
 require 'puppet/util/log'
 require 'puppet/error'
-require 'puppet/util/multi_match.rb'
 
 require 'facter'
 
@@ -146,16 +145,12 @@ module Logging
     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?)
+    #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
-  MM = MultiMatch
-  FILE_AND_LINE = MM::TUPLE
-  FILE_NO_LINE  = MM.new(MM::NOT_NIL, nil).freeze
-  NO_FILE_LINE  = MM.new(nil, MM::NOT_NIL).freeze
-  SUPPRESS_FILE_LINE = MM.new(:default, :default).freeze
 
   # Logs a (non deprecation) warning once for a given key.
   #
@@ -175,19 +170,17 @@ module Logging
     if $unique_warnings.length < 100 then
       if (! $unique_warnings.has_key?(key)) then
         $unique_warnings[key] = message
-        call_trace =
-        case MM.new(file, line)
-        when SUPPRESS_FILE_LINE
-          ''
-        when FILE_AND_LINE
-          _("\n   (at %{file}:%{line})") % { file: file, line: line }
-        when FILE_NO_LINE
-          _("\n   (in %{file})") % { file: file }
-        when NO_FILE_LINE
-          _("\n   (in unknown file, line %{line})") % { line: line }
-        else
-          _("\n   (file & line not available)")
-        end
+        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
@@ -279,17 +272,17 @@ module Logging
   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
+    if $deprecation_warnings.length < 100
       key ||= (offender = get_deprecation_offender)
-      if (! $deprecation_warnings.has_key?(key)) then
+      unless $deprecation_warnings.has_key?(key)
         $deprecation_warnings[key] = message
         # split out to allow translation
-        unknown = _('unknown')
-        call_trace = use_caller ?
-          (offender || get_deprecation_offender).join('; ') :
-          "#{file || unknown}:#{line || unknown}"
-        #TRANSLATORS error message with origin location
-        warning(_("%{message}\n   (at %{call_trace})") % { message: message, call_trace: call_trace })
+        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

data/lib/puppet/util/methodhelper.rb

@@ -13,7 +13,7 @@ module Puppet::Util::MethodHelper
       if respond_to? method
         self.send(method, value)
       else
-        raise ArgumentError, "Invalid parameter #{param} to object class #{self.class}"
+        raise ArgumentError, _("Invalid parameter %{parameter} to object class %{class_name}") % { parameter: param, class_name: self.class }
       end
     end
   end

data/lib/puppet/util/nagios_maker.rb

@@ -9,7 +9,7 @@ module Puppet::Util::NagiosMaker
     name = name.to_sym
     full_name = ("nagios_#{name}").to_sym
 
-    raise(Puppet::DevError, "No nagios type for #{name}") unless nagtype = Nagios::Base.type(name)
+    raise Puppet::DevError, _("No nagios type for %{name}") % { name: name } unless nagtype = Nagios::Base.type(name)
 
     type = Puppet::Type.newtype(full_name) do
 

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

@@ -39,34 +39,41 @@ class Puppet::Util::NetworkDevice::Config
     begin
       devices = {}
       device = nil
-      File.open(@file) { |f|
-        count = 1
-        f.each { |line|
+      File.open(@file) do |f|
+        file_line_count = 1
+        f.each do |line|
           case line
           when /^\s*#/ # skip comments
-            count += 1
+            file_line_count += 1
             next
           when /^\s*$/  # skip blank lines
-            count += 1
+            file_line_count += 1
             next
           when /^\[([\w.-]+)\]\s*$/ # [device.fqdn]
             name = $1
             name.chomp!
-            raise Puppet::Error, _("Duplicate device found at line %{count}, already found at %{line}") % { count: count, line: device.line } if devices.include?(name)
+            if devices.include?(name)
+              file_error_location = Puppet::Util::Errors.error_location(nil, file_line_count)
+              device_error_location = Puppet::Util::Errors.error_location(nil, device.line)
+              raise Puppet::Error, _("Duplicate device found at %{file_error_location}, already found at %{device_error_location}") %
+                  { file_error_location: file_error_location, device_error_location: device_error_location }
+            end
             device = OpenStruct.new
             device.name = name
-            device.line = count
+            device.line = file_line_count
             device.options = { :debug => false }
             Puppet.debug "found device: #{device.name} at #{device.line}"
             devices[name] = device
           when /^\s*(type|url|debug)(\s+(.+)\s*)*$/
-            parse_directive(device, $1, $3, count)
+            parse_directive(device, $1, $3, file_line_count)
           else
-            raise Puppet::Error, _("Invalid line %{count}: %{line}") % { count: count, line: line }
+            error_location_str = Puppet::Util::Errors.error_location(nil, file_line_count)
+            raise Puppet::Error, _("Invalid entry at %{error_location}: %{file_text}") %
+                { error_location: error_location_str, file_text: line }
           end
-          count += 1
-        }
-      }
+          file_line_count += 1
+        end
+      end
     rescue Errno::EACCES => detail
       Puppet.err _("Configuration error: Cannot read %{file}; cannot serve") % { file: @file }
       #raise Puppet::Error, "Cannot read #{@config}"
@@ -91,7 +98,8 @@ class Puppet::Util::NetworkDevice::Config
     when "debug"
       device.options[:debug] = true
     else
-      raise Puppet::Error, _("Invalid argument '%{var}' at line %{count}") % { var: var, count: count }
+      error_location_str = Puppet::Util::Errors.error_location(nil, count)
+      raise Puppet::Error, _("Invalid argument '%{var}' at %{error_location}") % { var: var, error_location: error_location_str }
     end
   end
 

data/lib/puppet/util/plist.rb

@@ -45,7 +45,9 @@ module Puppet::Util::Plist
                                                   {:failonfail => true, :combine => true})
           return parse_plist(plist)
         rescue Puppet::ExecutionFailure => detail
-          Puppet.warning(_("Cannot read file %{file_path}; Puppet is skipping it.\n") % { file_path: file_path } + _("Details: %{detail}") % { detail: detail })
+          message = _("Cannot read file %{file_path}; Puppet is skipping it.") % { file_path: file_path }
+          message += '\n' + _("Details: %{detail}") % { detail: detail }
+          Puppet.warning(message)
         end
       end
       return nil

data/lib/puppet/util/posix.rb

@@ -17,7 +17,7 @@ module Puppet::Util::POSIX
   # method search_posix_field in the gid and uid methods if a sanity check
   # fails
   def get_posix_field(space, field, id)
-    raise Puppet::DevError, "Did not get id from caller" unless id
+    raise Puppet::DevError, _("Did not get id from caller") unless id
 
     if id.is_a?(Integer)
       if id > Puppet[:maximum_uid].to_i

data/lib/puppet/util/provider_features.rb

@@ -63,7 +63,7 @@ module Puppet::Util::ProviderFeatures
   # @todo How methods that determine if the feature is present are specified.
   def feature(name, docs, hash = {})
     @features ||= {}
-    raise(Puppet::DevError, "Feature #{name} is already defined") if @features.include?(name)
+    raise Puppet::DevError, _("Feature %{name} is already defined") % { name: name } if @features.include?(name)
     begin
       obj = ProviderFeature.new(name, docs, hash)
       @features[obj.name] = obj

data/lib/puppet/util/rdoc/generators/puppet_generator.rb

@@ -245,7 +245,7 @@ module Generators
       end
     end
 
-    def gen_composite_index(collection, template, filename)\
+    def gen_composite_index(collection, template, filename)
       return if Puppet::FileSystem.exist?(filename)
 
       template = TemplatePage.new(RDoc::Page::FR_INDEX_BODY, template)

data/lib/puppet/util/reference.rb

@@ -13,8 +13,7 @@ class Puppet::Util::Reference
   instance_load(:reference, 'puppet/reference')
 
   def self.footer
-    #TRANSLATORS message accompanied by date of generation
-    "\n\n----------------\n\n*" + _("This page autogenerated on ") + "#{Time.now}*\n"
+    "\n\n----------------\n\n" + _("*This page autogenerated on %{current_time}*\n") % { current_time: Time.now.to_s }
   end
 
   def self.modes
@@ -113,7 +112,7 @@ class Puppet::Util::Reference
     # First the header
     text = markdown_header(@title, 1)
     #TRANSLATORS message accompanied by date of generation
-    text << _("\n\n**This page is autogenerated; any changes will get overwritten** *(last generated on ") + "#{Time.now.to_s})*\n\n"
+    text << _("\n\n**This page is autogenerated; any changes will get overwritten** *(last generated on %{current_time})*\n\n") % { current_time: Time.now.to_s }
 
     text << @header
 

data/lib/puppet/util/selinux.rb

@@ -240,7 +240,7 @@ module Puppet::Util::SELinux
     # while we try and figure out what file-system the target lives on.
     path = Pathname(path).cleanpath
     unless path.absolute?
-      raise Puppet::DevError, "got a relative path in SELinux find_fs: #{path}"
+      raise Puppet::DevError, _("got a relative path in SELinux find_fs: %{path}") % { path: path }
     end
 
     # Now, walk up the tree until we find a match for that path in the hash.

data/lib/puppet/util/storage.rb

@@ -53,7 +53,7 @@ class Puppet::Util::Storage
       Puppet.warning(_("Checksumfile %{filename} is not a file, ignoring") % { filename: filename })
       return
     end
-    Puppet::Util.benchmark(:debug, "Loaded state") do
+    Puppet::Util.benchmark(:debug, "Loaded state in %{seconds} seconds") do
       begin
         @@state = Puppet::Util::Yaml.load_file(filename)
       rescue Puppet::Util::Yaml::YamlLoadError => detail
@@ -82,7 +82,7 @@ class Puppet::Util::Storage
 
     Puppet.info _("Creating state file %{file}") % { file: Puppet[:statefile] } unless Puppet::FileSystem.exist?(Puppet[:statefile])
 
-    Puppet::Util.benchmark(:debug, "Stored state") do
+    Puppet::Util.benchmark(:debug, "Stored state in %{seconds} seconds") do
       Puppet::Util::Yaml.dump(@@state, Puppet[:statefile])
     end
   end

data/lib/puppet/util/windows/eventlog.rb

@@ -31,7 +31,8 @@ class Puppet::Util::Windows::EventLog
   def initialize(source_name = 'Puppet')
     @eventlog_handle = RegisterEventSourceW(FFI::Pointer::NULL, wide_string(source_name))
     if @eventlog_handle == NULL_HANDLE
-      raise EventLogError.new("RegisterEventSourceW failed to open Windows eventlog", FFI.errno)
+      #TRANSLATORS 'Windows' is the operating system and 'RegisterEventSourceW' is a API call and should not be translated
+      raise EventLogError.new(_("RegisterEventSourceW failed to open Windows eventlog"), FFI.errno)
     end
   end
 
@@ -55,7 +56,9 @@ class Puppet::Util::Windows::EventLog
   # @return [void]
   # @api public
   def report_event(args = {})
-    raise ArgumentError, "data must be a string, not #{args[:data].class}" unless args[:data].is_a?(String)
+    unless args[:data].is_a?(String)
+      raise ArgumentError, _("data must be a string, not %{class_name}") % { class_name: args[:data].class }
+    end
     from_string_to_wide_string(args[:data]) do |message_ptr|
       FFI::MemoryPointer.new(:pointer) do |message_array_ptr|
         message_array_ptr.write_pointer(message_ptr)
@@ -69,7 +72,8 @@ class Puppet::Util::Windows::EventLog
           num_strings, raw_data_size, message_array_ptr, raw_data)
 
         if report_result == WIN32_FALSE
-          raise EventLogError.new("ReportEventW failed to report event to Windows eventlog", FFI.errno)
+          #TRANSLATORS 'Windows' is the operating system and 'ReportEventW' is a API call and should not be translated
+          raise EventLogError.new(_("ReportEventW failed to report event to Windows eventlog"), FFI.errno)
         end
       end
     end
@@ -92,7 +96,7 @@ class Puppet::Util::Windows::EventLog
       when :err,:alert,:emerg,:crit
         [EVENTLOG_ERROR_TYPE, 0x03]
       else
-        raise ArgumentError, "Invalid log level #{level}"
+        raise ArgumentError, _("Invalid log level %{level}") % { level: level }
       end
     end
   end
@@ -110,7 +114,8 @@ class Puppet::Util::Windows::EventLog
   else
     class EventLogError < RuntimeError
       def initialize(msg, code)
-        super(msg + " (Win32 error: #{code})")
+        #TRANSLATORS 'Win32' is the Windows API and should not be translated
+        super(msg + ' ' + _("(Win32 error: %{detail})") % { detail: code})
       end
     end
   end

data/lib/puppet/util/windows/file.rb

@@ -111,11 +111,15 @@ module Puppet::Util::Windows::File
 
       # return true if path exists and it's not a symlink
       # Other file attributes are ignored. https://msdn.microsoft.com/en-us/library/windows/desktop/gg258117(v=vs.85).aspx
-      return true if (result & FILE_ATTRIBUTE_REPARSE_POINT) != FILE_ATTRIBUTE_REPARSE_POINT
-
-      # walk the symlink and try again...
-      seen_paths << path.downcase
-      path = readlink(path)
+      reparse_point = (result & FILE_ATTRIBUTE_REPARSE_POINT) == FILE_ATTRIBUTE_REPARSE_POINT
+      if reparse_point && symlink_reparse_point?(path)
+        # walk the symlink and try again...
+        seen_paths << path.downcase
+        path = readlink(path)
+      else
+        # file was found and its not a symlink
+        return true
+      end
     end
 
     false
@@ -177,6 +181,18 @@ module Puppet::Util::Windows::File
         "#{flags_and_attributes.to_s(8)}, #{template_file_handle})")
   end
 
+  IO_REPARSE_TAG_MOUNT_POINT  = 0xA0000003
+  IO_REPARSE_TAG_HSM          = 0xC0000004
+  IO_REPARSE_TAG_HSM2         = 0x80000006
+  IO_REPARSE_TAG_SIS          = 0x80000007
+  IO_REPARSE_TAG_WIM          = 0x80000008
+  IO_REPARSE_TAG_CSV          = 0x80000009
+  IO_REPARSE_TAG_DFS          = 0x8000000A
+  IO_REPARSE_TAG_SYMLINK      = 0xA000000C
+  IO_REPARSE_TAG_DFSR         = 0x80000012
+  IO_REPARSE_TAG_DEDUP        = 0x80000013
+  IO_REPARSE_TAG_NFS          = 0x80000014
+
   def self.get_reparse_point_data(handle, &block)
     # must be multiple of 1024, min 10240
     FFI::MemoryPointer.new(MAXIMUM_REPARSE_DATA_BUFFER_SIZE) do |reparse_data_buffer_ptr|
@@ -184,11 +200,11 @@ module Puppet::Util::Windows::File
 
       reparse_tag = reparse_data_buffer_ptr.read_win32_ulong
       buffer_type = case reparse_tag
-      when 0xA000000C
+      when IO_REPARSE_TAG_SYMLINK
         SYMLINK_REPARSE_DATA_BUFFER
-      when 0xA0000003
+      when IO_REPARSE_TAG_MOUNT_POINT
         MOUNT_POINT_REPARSE_DATA_BUFFER
-      when 0x80000014
+      when IO_REPARSE_TAG_NFS
         raise Puppet::Util::Windows::Error.new("Retrieving NFS reparse point data is unsupported")
       else
         raise Puppet::Util::Windows::Error.new("DeviceIoControl(#{handle}, " +
@@ -202,6 +218,20 @@ module Puppet::Util::Windows::File
     nil
   end
 
+  def self.get_reparse_point_tag(handle)
+    reparse_tag = nil
+
+    # must be multiple of 1024, min 10240
+    FFI::MemoryPointer.new(MAXIMUM_REPARSE_DATA_BUFFER_SIZE) do |reparse_data_buffer_ptr|
+      device_io_control(handle, FSCTL_GET_REPARSE_POINT, nil, reparse_data_buffer_ptr)
+
+      # DWORD ReparseTag is the first member of the struct
+      reparse_tag = reparse_data_buffer_ptr.read_win32_ulong
+    end
+
+    reparse_tag
+  end
+
   def self.device_io_control(handle, io_control_code, in_buffer = nil, out_buffer = nil)
     if out_buffer.nil?
       raise Puppet::Util::Windows::Error.new(_("out_buffer is required"))
@@ -229,12 +259,18 @@ module Puppet::Util::Windows::File
   end
 
   FILE_ATTRIBUTE_REPARSE_POINT = 0x400
-  def symlink?(file_name)
+  def reparse_point?(file_name)
     attributes = get_attributes(file_name, false)
 
     return false if (attributes == INVALID_FILE_ATTRIBUTES)
     (attributes & FILE_ATTRIBUTE_REPARSE_POINT) == FILE_ATTRIBUTE_REPARSE_POINT
   end
+  module_function :reparse_point?
+
+  def symlink?(file_name)
+    # Puppet currently only handles mount point and symlink reparse points, ignores others
+    reparse_point?(file_name) && symlink_reparse_point?(file_name)
+  end
   module_function :symlink?
 
   GENERIC_READ                  = 0x80000000
@@ -375,6 +411,22 @@ module Puppet::Util::Windows::File
     path
   end
 
+  # these reparse point types are the only ones Puppet currently understands
+  # so rather than raising an exception in readlink, prefer to not consider
+  # the path a symlink when stat'ing later
+  def self.symlink_reparse_point?(path)
+    symlink = false
+
+    open_symlink(path) do |handle|
+      symlink = [
+        IO_REPARSE_TAG_SYMLINK,
+        IO_REPARSE_TAG_MOUNT_POINT
+      ].include?(get_reparse_point_tag(handle))
+    end
+
+    symlink
+  end
+
   ffi_convention :stdcall
 
   # https://msdn.microsoft.com/en-us/library/windows/desktop/aa365512(v=vs.85).aspx