puppet 4.0.0 → 5.0.0

data/lib/puppet/provider/group/aix.rb

@@ -33,7 +33,7 @@ Puppet::Type.type(:group).provide :aix, :parent => Puppet::Provider::AixObject d
   # Valid attributes to be managed by this provider.
   # It is a list with of hash
   #  :aix_attr      AIX command attribute name
-  #  :puppet_prop   Puppet propertie name
+  #  :puppet_prop   Puppet property name
   #  :to            Method to adapt puppet property to aix command value. Optional.
   #  :from          Method to adapt aix command value to puppet property. Optional
   self.attribute_mapping = [
@@ -94,11 +94,11 @@ Puppet::Type.type(:group).provide :aix, :parent => Puppet::Provider::AixObject d
 
 
   #--------------
-  # Overwrite get_arguments to add the attributes arguments
+  # Overwrite get_arguments to add the attributes' arguments
   def get_arguments(key, value, mapping, objectinfo)
-    # In the case of attributes, return a list of key=vlaue
+    # In the case of attributes, return a list of key=value
     if key == :attributes
-      raise Puppet::Error, "Attributes must be a list of pairs key=value on #{@resource.class.name}[#{@resource.name}]" \
+      raise Puppet::Error, _("Attributes must be a list of pairs key=value on %{resource}[%{name}]") % { resource: @resource.class.name, name: @resource.name } \
         unless value and value.is_a? Hash
       return value.select { |k,v| true }.map { |pair| pair.join("=") }
     end
@@ -106,7 +106,7 @@ Puppet::Type.type(:group).provide :aix, :parent => Puppet::Provider::AixObject d
   end
 
   def filter_attributes(hash)
-    # Return only not managed attributtes.
+    # Return only not managed attributes.
     hash.select {
         |k,v| !self.class.attribute_mapping_from.include?(k) and
                 !self.class.attribute_ignore.include?(k)
@@ -127,7 +127,7 @@ Puppet::Type.type(:group).provide :aix, :parent => Puppet::Provider::AixObject d
       begin
         execute(cmd)
       rescue Puppet::ExecutionFailure  => detail
-        raise Puppet::Error, "Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}", detail.backtrace
+        raise Puppet::Error, _("Could not set %{param} on %{resource}[%{name}]: %{detail}") % { param: param, resource: @resource.class.name, name: @resource.name, detail: detail }, detail.backtrace
       end
     end
   end

data/lib/puppet/provider/group/directoryservice.rb

@@ -9,4 +9,14 @@ Puppet::Type.type(:group).provide :directoryservice, :parent => Puppet::Provider
   confine :operatingsystem => :darwin
   defaultfor :operatingsystem => :darwin
   has_feature :manages_members
+
+  def members_insync?(current, should)
+    return false unless current
+    if current == :absent
+      return should.empty?
+    else
+      return current.sort.uniq == should.sort.uniq
+    end
+  end
+
 end

data/lib/puppet/provider/group/groupadd.rb

@@ -10,7 +10,7 @@ Puppet::Type.type(:group).provide :groupadd, :parent => Puppet::Provider::NameSe
 
   has_feature :system_groups unless %w{HP-UX Solaris}.include? Facter.value(:operatingsystem)
 
-  verify :gid, "GID must be an integer" do |value|
+  verify :gid, _("GID must be an integer") do |value|
     value.is_a? Integer
   end
 
@@ -56,7 +56,7 @@ Puppet::Type.type(:group).provide :groupadd, :parent => Puppet::Provider::NameSe
     # using both useradd and luseradd
     if not @resource.allowdupe? and @resource.forcelocal?
        if @resource.should(:gid) and findgroup('gid', @resource.should(:gid).to_s)
-           raise(Puppet::Error, "GID #{@resource.should(:gid).to_s} already exists, use allowdupe to force group creation")
+           raise(Puppet::Error, _("GID %{resource} already exists, use allowdupe to force group creation") % { resource: @resource.should(:gid).to_s })
        end
     elsif @resource.allowdupe? and not @resource.forcelocal?
        return ["-o"]

data/lib/puppet/provider/group/pw.rb

@@ -7,10 +7,11 @@ Puppet::Type.type(:group).provide :pw, :parent => Puppet::Provider::NameService:
   has_features :manages_members
 
   defaultfor :operatingsystem => [:freebsd, :dragonfly]
+  confine    :operatingsystem => [:freebsd, :dragonfly]
 
   options :members, :flag => "-M", :method => :mem
 
-  verify :gid, "GID must be an integer" do |value|
+  verify :gid, _("GID must be an integer") do |value|
     value.is_a? Integer
   end
 

data/lib/puppet/provider/group/windows_adsi.rb

@@ -9,6 +9,11 @@ Puppet::Type.type(:group).provide :windows_adsi do
 
   has_features :manages_members
 
+  def initialize(value={})
+    super(value)
+    @deleted = false
+  end
+
   def members_insync?(current, should)
     return false unless current
 
@@ -17,18 +22,18 @@ Puppet::Type.type(:group).provide :windows_adsi do
 
     # Cannot use munge of the group property to canonicalize @should
     # since the default array_matching comparison is not commutative
-    should_empty = should.nil? or should.empty?
-
-    return false if current.empty? != should_empty
 
     # dupes automatically weeded out when hashes built
     current_users = Puppet::Util::Windows::ADSI::Group.name_sid_hash(current)
     specified_users = Puppet::Util::Windows::ADSI::Group.name_sid_hash(should)
 
+    current_sids = current_users.keys.to_a
+    specified_sids = specified_users.keys.to_a
+
     if @resource[:auth_membership]
-      current_users == specified_users
+      current_sids.sort == specified_sids.sort
     else
-      (specified_users.keys.to_a & current_users.keys.to_a) == specified_users.keys.to_a
+      (specified_sids & current_sids) == specified_sids
     end
   end
 
@@ -36,17 +41,26 @@ Puppet::Type.type(:group).provide :windows_adsi do
     return '' if users.nil? or !users.kind_of?(Array)
     users = users.map do |user_name|
       sid = Puppet::Util::Windows::SID.name_to_sid_object(user_name)
+      if !sid
+        resource.debug("#{user_name} (unresolvable to SID)")
+        next user_name
+      end
+
       if sid.account =~ /\\/
         account, _ = Puppet::Util::Windows::ADSI::User.parse_name(sid.account)
       else
         account = sid.account
       end
-      resource.debug("#{sid.domain}\\#{account} (#{sid.to_s})")
+      resource.debug("#{sid.domain}\\#{account} (#{sid.sid})")
       "#{sid.domain}\\#{account}"
     end
     return users.join(',')
   end
 
+  def member_valid?(user_name)
+    ! Puppet::Util::Windows::SID.name_to_sid_object(user_name).nil?
+  end
+
   def group
     @group ||= Puppet::Util::Windows::ADSI::Group.new(@resource[:name])
   end
@@ -72,11 +86,13 @@ Puppet::Type.type(:group).provide :windows_adsi do
 
   def delete
     Puppet::Util::Windows::ADSI::Group.delete(@resource[:name])
+
+    @deleted = true
   end
 
   # Only flush if we created or modified a group, not deleted
   def flush
-    @group.commit if @group
+    @group.commit if @group && !@deleted
   end
 
   def gid

data/lib/puppet/provider/host/parsed.rb

@@ -30,7 +30,7 @@ Puppet::Type.type(:host).provide(:parsed,:parent => Puppet::Provider::ParsedFile
     },
     :to_line  => proc { |hash|
       [:ip, :name].each do |n|
-        raise ArgumentError, "#{n} is a required attribute for hosts" unless hash[n] and hash[n] != :absent
+        raise ArgumentError, _("%{attr} is a required attribute for hosts") % { attr: n } unless hash[n] and hash[n] != :absent
       end
       str = "#{hash[:ip]}\t#{hash[:name]}"
       if hash.include? :host_aliases and !hash[:host_aliases].nil? and hash[:host_aliases] != :absent

data/lib/puppet/provider/macauthorization/macauthorization.rb

@@ -1,5 +1,5 @@
 require 'facter'
-require 'plist'
+require 'puppet/util/plist' if Puppet.features.cfpropertylist?
 require 'puppet'
 require 'tempfile'
 
@@ -12,6 +12,7 @@ Puppet::Type.type(:macauthorization).provide :macauthorization, :parent => Puppe
   commands :security => "/usr/bin/security"
 
   confine :operatingsystem => :darwin
+  confine :feature         => :cfpropertylist
 
   defaultfor :operatingsystem => :darwin
 
@@ -50,8 +51,8 @@ Puppet::Type.type(:macauthorization).provide :macauthorization, :parent => Puppe
     end
 
     def populate_rules_rights
-      auth_plist = Plist::parse_xml(AuthDB)
-      raise Puppet::Error.new("Cannot parse: #{AuthDB}") if not auth_plist
+      auth_plist = Puppet::Util::Plist.parse_plist(AuthDB)
+      raise Puppet::Error.new(_("Cannot parse: %{auth}") % { auth: AuthDB }) if not auth_plist
       self.rights = auth_plist["rights"].dup
       self.rules = auth_plist["rules"].dup
       self.parsed_auth_db = self.rights.dup
@@ -92,7 +93,7 @@ Puppet::Type.type(:macauthorization).provide :macauthorization, :parent => Puppe
     when :rule
       destroy_rule
     else
-      raise Puppet::Error.new("Must specify auth_type when destroying.")
+      raise Puppet::Error.new(_("Must specify auth_type when destroying."))
     end
   end
 
@@ -110,7 +111,7 @@ Puppet::Type.type(:macauthorization).provide :macauthorization, :parent => Puppe
       when :rule
         flush_rule
       else
-        raise Puppet::Error.new("flush requested for unknown type.")
+        raise Puppet::Error.new(_("flush requested for unknown type."))
       end
       @property_hash.clear
     end
@@ -124,14 +125,14 @@ Puppet::Type.type(:macauthorization).provide :macauthorization, :parent => Puppe
   end
 
   def destroy_rule
-    authdb = Plist::parse_xml(AuthDB)
+    authdb = Puppet::Util::Plist.parse_plist(AuthDB)
     authdb_rules = authdb["rules"].dup
     if authdb_rules[resource[:name]]
       begin
         authdb["rules"].delete(resource[:name])
-        Plist::Emit.save_plist(authdb, AuthDB)
+        Puppet::Util::Plist.write_plist_file(authdb, AuthDB)
       rescue Errno::EACCES => e
-        raise Puppet::Error.new("Error saving #{AuthDB}: #{e}", e)
+        raise Puppet::Error.new(_("Error saving %{auth}: %{error}") % { auth: AuthDB, error: e }, e)
       end
     end
   end
@@ -140,11 +141,11 @@ Puppet::Type.type(:macauthorization).provide :macauthorization, :parent => Puppe
     # first we re-read the right just to make sure we're in sync for
     # values that weren't specified in the manifest. As we're supplying
     # the whole plist when specifying the right it seems safest to be
-    # paranoid given the low cost of quering the db once more.
+    # paranoid given the low cost of querying the db once more.
     cmds = []
     cmds << :security << "authorizationdb" << "read" << resource[:name]
     output = execute(cmds, :failonfail => false, :combine => false)
-    current_values = Plist::parse_xml(output)
+    current_values = Puppet::Util::Plist.parse_plist(output)
     current_values ||= {}
     specified_values = convert_plist_to_native_attributes(@property_hash)
 
@@ -155,7 +156,7 @@ Puppet::Type.type(:macauthorization).provide :macauthorization, :parent => Puppe
   end
 
   def flush_rule
-    authdb = Plist::parse_xml(AuthDB)
+    authdb = Puppet::Util::Plist.parse_plist(AuthDB)
     authdb_rules = authdb["rules"].dup
     current_values = {}
     current_values = authdb_rules[resource[:name]] if authdb_rules[resource[:name]]
@@ -171,12 +172,12 @@ Puppet::Type.type(:macauthorization).provide :macauthorization, :parent => Puppe
     values = convert_plist_to_native_attributes(values)
     tmp = Tempfile.new('puppet_macauthorization')
     begin
-      Plist::Emit.save_plist(values, tmp.path)
+      Puppet::Util::Plist.write_plist_file(values, tmp.path)
       cmds = []
       cmds << :security << "authorizationdb" << "write" << name
       execute(cmds, :failonfail => false, :combine => false, :stdinfile => tmp.path.to_s)
     rescue Errno::EACCES => e
-      raise Puppet::Error.new("Cannot save right to #{tmp.path}: #{e}", e)
+      raise Puppet::Error.new(_("Cannot save right to %{path}: %{error}") % { path: tmp.path, error: e }, e)
     ensure
       tmp.close
       tmp.unlink
@@ -189,13 +190,13 @@ Puppet::Type.type(:macauthorization).provide :macauthorization, :parent => Puppe
     # support modifying rules at all so we have to twiddle the whole
     # plist... :( See Apple Bug #6386000
     values = convert_plist_to_native_attributes(values)
-    authdb = Plist::parse_xml(AuthDB)
+    authdb = Puppet::Util::Plist.parse_plist(AuthDB)
     authdb["rules"][name] = values
 
     begin
-      Plist::Emit.save_plist(authdb, AuthDB)
+      Puppet::Util::Plist.write_plist_file(authdb, AuthDB)
     rescue
-      raise Puppet::Error.new("Error writing to: #{AuthDB}")
+      raise Puppet::Error.new(_("Error writing to: %{auth_db}") % { auth_db: AuthDB })
     end
   end
 
@@ -228,7 +229,7 @@ Puppet::Type.type(:macauthorization).provide :macauthorization, :parent => Puppe
 
   def retrieve_value(resource_name, attribute)
     # We set boolean values to symbols when retrieving values
-    raise Puppet::Error.new("Cannot find #{resource_name} in auth db") if not self.class.parsed_auth_db.has_key?(resource_name)
+    raise Puppet::Error.new(_("Cannot find %{resource_name} in auth db") % { resource_name: resource_name }) if not self.class.parsed_auth_db.has_key?(resource_name)
 
     if PuppetToNativeAttributeMap.has_key?(attribute)
       native_attribute = PuppetToNativeAttributeMap[attribute]
@@ -283,10 +284,10 @@ Puppet::Type.type(:macauthorization).provide :macauthorization, :parent => Puppe
       elsif self.class.rules.has_key?(resource[:name])
         return :rule
       else
-        raise Puppet::Error.new("#{resource[:name]} is unknown type.")
+        raise Puppet::Error.new(_("%{resource} is unknown type.") % { resource: resource[:name] })
       end
     else
-      raise Puppet::Error.new("auth_type required for new resources.")
+      raise Puppet::Error.new(_("auth_type required for new resources."))
     end
   end
 

data/lib/puppet/provider/mailalias/aliases.rb

@@ -34,7 +34,7 @@ Puppet::Type.type(:mailalias).provide(
       if record[:recipient]
 	dest = record[:recipient].collect do |d|
 	  # Quote aliases that have non-alpha chars
-	  if d =~ /[^-\w@.]/
+	  if d =~ /[^-+\w@.]/
 	    '"%s"' % d
 	  else
 	    d

data/lib/puppet/provider/maillist/mailman.rb

@@ -52,12 +52,12 @@ Puppet::Type.type(:maillist).provide(:mailman) do
     if val = @resource[:admin]
       args << val
     else
-      raise ArgumentError, "Mailman lists require an administrator email address"
+      raise ArgumentError, _("Mailman lists require an administrator email address")
     end
     if val = @resource[:password]
       args << val
     else
-      raise ArgumentError, "Mailman lists require an administrator password"
+      raise ArgumentError, _("Mailman lists require an administrator password")
     end
     newlist(*args)
   end

data/lib/puppet/provider/mcx/mcxcontent.rb

@@ -36,7 +36,7 @@ Puppet::Type.type(:mcx).provide :mcxcontent, :parent => Puppet::Provider do
 
   def self.instances
     mcx_list = []
-    TypeMap.keys.each do |ds_type|
+    TypeMap.each_key do |ds_type|
       ds_path = "/Local/Default/#{TypeMap[ds_type]}"
       output = dscl 'localhost', '-list', ds_path
       member_list = output.split
@@ -116,7 +116,8 @@ Puppet::Type.type(:mcx).provide :mcxcontent, :parent => Puppet::Provider do
       dscl 'localhost', '-mcxdelete', ds_path
     end
 
-    tmp = Tempfile.new('puppet_mcx')
+    # val being passed in is resource[:content] which should be UTF-8
+    tmp = Tempfile.new('puppet_mcx', :encoding => Encoding::UTF_8)
     begin
       tmp << val
       tmp.flush
@@ -133,13 +134,13 @@ Puppet::Type.type(:mcx).provide :mcxcontent, :parent => Puppet::Provider do
     ds_type = name.split('/')[1]
     unless ds_type
       raise MCXContentProviderException,
-      "Coult not parse ds_type from resource name '#{name}'.  Specify with ds_type parameter."
+      _("Could not parse ds_type from resource name '%{name}'.  Specify with ds_type parameter.") % { name: name }
     end
     # De-pluralize and downcase.
     ds_type = ds_type.chop.downcase.to_sym
     unless TypeMap.key? ds_type
       raise MCXContentProviderException,
-      "Coult not parse ds_type from resource name '#{name}'.  Specify with ds_type parameter."
+      _("Could not parse ds_type from resource name '%{name}'.  Specify with ds_type parameter.") % { name: name }
     end
     ds_type
   end
@@ -149,7 +150,7 @@ Puppet::Type.type(:mcx).provide :mcxcontent, :parent => Puppet::Provider do
     ds_name = name.split('/')[2]
     unless ds_name
       raise MCXContentProviderException,
-      "Could not parse ds_name from resource name '#{name}'.  Specify with ds_name parameter."
+      _("Could not parse ds_name from resource name '%{name}'.  Specify with ds_name parameter.") % { name: name }
     end
     ds_name
   end

data/lib/puppet/provider/mount/parsed.rb

@@ -4,6 +4,7 @@ require 'puppet/provider/mount'
 fstab = nil
 case Facter.value(:osfamily)
 when "Solaris"; fstab = "/etc/vfstab"
+when "AIX"; fstab = "/etc/filesystems"
 else
   fstab = "/etc/fstab"
 end
@@ -25,7 +26,12 @@ Puppet::Type.type(:mount).provide(
     @fields = [:device, :name, :fstype, :options, :dump, :pass]
   end
 
-  text_line :comment, :match => /^\s*#/
+  if Facter.value(:osfamily) == "AIX"
+    # * is the comment character on AIX /etc/filesystems
+    text_line :comment, :match => /^\s*\*/
+  else
+    text_line :comment, :match => /^\s*#/
+  end
   text_line :blank, :match => /^\s*$/
 
   optional_fields  = @fields - [:device, :name, :blockdevice]
@@ -36,7 +42,160 @@ Puppet::Type.type(:mount).provide(
   field_pattern = '(\s*(?>\S+))'
   text_line :incomplete, :match => /^(?!#{field_pattern}{#{mandatory_fields.length}})/
 
-  record_line self.name, :fields => @fields, :separator => /\s+/, :joiner => "\t", :optional => optional_fields
+  case Facter.value(:osfamily)
+  when "AIX"
+    # The only field that is actually ordered is :name. See `man filesystems` on AIX
+    @fields = [:name, :account, :boot, :check, :dev, :free, :mount, :nodename,
+               :options, :quota, :size, :type, :vfs, :vol, :log]
+    self.line_separator = "\n"
+    # Override lines and use scan instead of split, because we DON'T want to
+    # remove the separators
+    def self.lines(text)
+      lines = text.split("\n")
+      filesystem_stanza = false
+      filesystem_index = 0
+      ret = Array.new
+      lines.each_with_index do |line,i|
+        if line.match(%r{^\S+:})
+          # Begin new filesystem stanza and save the index
+          ret[filesystem_index] = filesystem_stanza.join("\n") if filesystem_stanza
+          filesystem_stanza = Array(line)
+          filesystem_index = i
+          # Eat the preceding blank line
+          ret[i-1] = nil if i > 0 and ret[i-1] and ret[i-1].match(%r{^\s*$})
+          nil
+        elsif line.match(%r{^(\s*\*.*|\s*)$})
+          # Just a comment or blank line; add in place
+          ret[i] = line
+        else
+          # Non-comments or blank lines must be part of a stanza
+          filesystem_stanza << line
+        end
+      end
+      # Add the final stanza to the return
+      ret[filesystem_index] = filesystem_stanza.join("\n") if filesystem_stanza
+      ret = ret.compact.flatten
+      ret.reject { |line| line.match(/^\* HEADER/) }
+    end
+    def self.header
+      super.gsub(/^#/,'*')
+    end
+
+    record_line self.name,
+      :fields    => @fields,
+      :separator => /\n/,
+      :block_eval => :instance do
+
+      def post_parse(result)
+        property_map = {
+          :dev      => :device,
+          :nodename => :nodename,
+          :options  => :options,
+          :vfs      => :fstype,
+        }
+        # Result is modified in-place instead of being returned; icky!
+        memo = result.dup
+        result.clear
+        # Save the line for later, just in case it is unparsable
+        result[:line] = @fields.collect do |field|
+          memo[field] if memo[field] != :absent
+        end.compact.join("\n")
+        result[:record_type] = memo[:record_type]
+        special_options = Array.new
+        result[:name] = memo[:name].sub(%r{:\s*$},'').strip
+        memo.each do |_,k_v|
+          if k_v and k_v.is_a?(String) and k_v.match("=")
+            attr_name, attr_value = k_v.split("=",2).map(&:strip)
+            if attr_map_name = property_map[attr_name.to_sym]
+              # These are normal "options" options (see `man filesystems`)
+              result[attr_map_name] = attr_value
+            else
+              # These /etc/filesystem attributes have no mount resource simile,
+              # so are added to the "options" property for puppet's sake
+              special_options << "#{attr_name}=#{attr_value}"
+            end
+            if result[:nodename]
+              result[:device] = "#{result[:nodename]}:#{result[:device]}"
+              result.delete(:nodename)
+            end
+          end
+        end
+        result[:options] = [result[:options],special_options.sort].flatten.compact.join(',')
+        if ! result[:device]
+          result[:device] = :absent
+          #TRANSLATORS "prefetch" is a program name and should not be translated
+          Puppet.err _("Prefetch: Mount[%{name}]: Field 'device' is missing") % { name: result[:name] }
+        end
+        if ! result[:fstype]
+          result[:fstype] = :absent
+          #TRANSLATORS "prefetch" is a program name and should not be translated
+          Puppet.err _("Prefetch: Mount[%{name}]: Field 'fstype' is missing") % { name: result[:name] }
+        end
+      end
+      def to_line(result)
+        output = Array.new
+        output << "#{result[:name]}:"
+        if result[:device] and result[:device].match(%r{^/})
+          output << "\tdev\t\t= #{result[:device]}"
+        elsif result[:device] and result[:device] != :absent
+          if ! result[:device].match(%{^.+:/})
+            # Just skip this entry; it was malformed to begin with
+            Puppet.err _("Mount[%{name}]: Field 'device' must be in the format of <absolute path> or <host>:<absolute path>") % { name: result[:name] }
+            return result[:line]
+          end
+          nodename, path = result[:device].split(":")
+          output << "\tdev\t\t= #{path}"
+          output << "\tnodename\t= #{nodename}"
+        else
+          # Just skip this entry; it was malformed to begin with
+          Puppet.err _("Mount[%{name}]: Field 'device' is required") % { name: result[:name] }
+          return result[:line]
+        end
+        if result[:fstype] and result[:fstype] != :absent
+          output << "\tvfs\t\t= #{result[:fstype]}"
+        else
+          # Just skip this entry; it was malformed to begin with
+          Puppet.err _("Mount[%{name}]: Field 'device' is required") % { name: result[:name] }
+          return result[:line]
+        end
+        if result[:options]
+          options = result[:options].split(',')
+          special_options = options.select do |x|
+            x.match('=') and
+              ["account", "boot", "check", "free", "mount", "size", "type",
+               "vol", "log", "quota"].include? x.split('=').first
+          end
+          options = options - special_options
+          special_options.sort.each do |x|
+            k, v = x.split("=")
+            output << "\t#{k}\t\t= #{v}"
+          end
+          output << "\toptions\t\t= #{options.join(",")}" unless options.empty?
+        end
+        if result[:line] and result[:line].split("\n").sort == output.sort
+          return "\n#{result[:line]}"
+        else
+          return "\n#{output.join("\n")}"
+        end
+      end
+    end
+  else
+    record_line self.name, :fields => @fields, :separator => /\s+/, :joiner => "\t", :optional => optional_fields, :block_eval => :instance do
+      def pre_gen(record)
+        if !record[:options] || record[:options].empty?
+          if Facter.value(:kernel) == 'Linux'
+            record[:options] = 'defaults'
+          else
+            raise Puppet::Error, _("Mount[%{name}]: Field 'options' is required") % { name: record[:name] }
+          end
+        end
+        if !record[:fstype] || record[:fstype].empty?
+          raise Puppet::Error, _("Mount[%{name}]: Field 'fstype' is required") % { name: record[:name] }
+        end
+        record
+      end
+    end
+  end
 
   # Every entry in fstab is :unmounted until we can prove different
   def self.prefetch_hook(target_records)
@@ -109,7 +268,7 @@ Puppet::Type.type(:mount).provide(
       if match = regex.match(line) and name = match.captures.first
         instances << {:name => name, :mounted => :yes} # Only :name is important here
       else
-        raise Puppet::Error, "Could not understand line #{line} from mount output"
+        raise Puppet::Error, _("Could not understand line %{line} from mount output") % { line: line }
       end
     end
     instances

data/lib/puppet/provider/mount.rb

@@ -24,7 +24,8 @@ module Puppet::Provider::Mount
   end
 
   def remount
-    info "Remounting"
+    #TRANSLATORS refers to remounting a file system
+    info _("Remounting")
     if resource[:remounts] == :true
       mountcmd "-o", "remount", resource[:name]
     elsif ["FreeBSD", "DragonFly", "OpenBSD"].include?(Facter.value(:operatingsystem))

data/lib/puppet/provider/naginator.rb

@@ -23,7 +23,7 @@ class Puppet::Provider::Naginator < Puppet::Provider::ParsedFile
   def self.parse(text)
       Nagios::Parser.new.parse(text.gsub(NAME_STRING, "_naginator_name"))
   rescue => detail
-      raise Puppet::Error, "Could not parse configuration for #{resource_type.name}: #{detail}", detail.backtrace
+      raise Puppet::Error, _("Could not parse configuration for %{resource}: %{detail}") % { resource: resource_type.name, detail: detail }, detail.backtrace
   end
 
   def self.to_file(records)