puppet 4.0.0 → 4.9.1

data/lib/puppet/provider/exec/windows.rb

@@ -45,7 +45,7 @@ Puppet::Type.type(:exec).provide :windows, :parent => Puppet::Provider::Exec do
     end
 
     if resource[:path]
-      Puppet::Util.withenv :PATH => resource[:path].join(File::PATH_SEPARATOR) do
+      Puppet::Util.withenv( {'PATH' => resource[:path].join(File::PATH_SEPARATOR)}, :windows) do
         return if which(exe)
       end
     end

data/lib/puppet/provider/exec.rb

@@ -47,7 +47,12 @@ class Puppet::Provider::Exec < Puppet::Provider
           end
         end
 
-        Timeout::timeout(resource[:timeout]) do
+        # Ruby 2.1 and later interrupt execution in a way that bypasses error
+        # handling by default. Passing Timeout::Error causes an exception to be
+        # raised that can be rescued inside of the block by cleanup routines.
+        #
+        # This is backwards compatible all the way to Ruby 1.8.7.
+        Timeout::timeout(resource[:timeout], Timeout::Error) do
           # note that we are passing "false" for the "override_locale" parameter, which ensures that the user's
           # default/system locale will be respected.  Callers may override this behavior by setting locale-related
           # environment variables (LANG, LC_ALL, etc.) in their 'environment' configuration.

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,9 +94,9 @@ 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}]" \
         unless value and value.is_a? Hash
@@ -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)

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/pw.rb

@@ -7,6 +7,7 @@ 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
 

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/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,7 +51,7 @@ Puppet::Type.type(:macauthorization).provide :macauthorization, :parent => Puppe
     end
 
     def populate_rules_rights
-      auth_plist = Plist::parse_xml(AuthDB)
+      auth_plist = Puppet::Util::Plist.parse_plist(AuthDB)
       raise Puppet::Error.new("Cannot parse: #{AuthDB}") if not auth_plist
       self.rights = auth_plist["rights"].dup
       self.rules = auth_plist["rules"].dup
@@ -124,12 +125,12 @@ 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)
       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,7 +172,7 @@ 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)
@@ -189,11 +190,11 @@ 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}")
     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/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."
     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."
     end
     ds_type
   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,158 @@ 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
+          Puppet.err "Prefetch: Mount[#{result[:name]}]: Field 'device' is missing"
+        end
+        if ! result[:fstype]
+          result[:fstype] = :absent
+          Puppet.err "Prefetch: Mount[#{result[:name]}]: Field 'fstype' is missing"
+        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[#{result[:name]}]: Field 'device' must be in the format of <absolute path> or <host>:<absolute path>"
+            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[#{result[:name]}]: Field 'device' is required"
+          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[#{result[:name]}]: Field 'device' is required"
+          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[#{record[:name]}]: Field 'options' is required"
+          end
+        end
+        if !record[:fstype] || record[:fstype].empty?
+          raise Puppet::Error, "Mount[#{record[:name]}]: Field 'fstype' is required"
+        end
+        record
+      end
+    end
+  end
 
   # Every entry in fstab is :unmounted until we can prove different
   def self.prefetch_hook(target_records)