puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/lib/puppet/provider/aixobject.rb

@@ -90,7 +90,7 @@ class Puppet::Provider::AixObject < Puppet::Provider
       true
     elsif mapping[key][:method].nil?
       objectinfo[mapping[key][:key]] = value
-    elsif
+    else
       objectinfo[mapping[key][:key]] = method(mapping[key][:method]).call(value)
     end
 
@@ -117,7 +117,7 @@ class Puppet::Provider::AixObject < Puppet::Provider
     elsif mapping[key][:method].nil?
       new_key = mapping[key][:key]
       new_value = value
-    elsif
+    else
       new_key = mapping[key][:key]
       new_value = method(mapping[key][:method]).call(value)
     end

data/lib/puppet/provider/augeas/augeas.rb

@@ -39,6 +39,7 @@ Puppet::Type.type(:augeas).provide(:augeas) do
     "rm" => [ :path ],
     "clear" => [ :path ],
     "clearm" => [ :path, :string ],
+    "touch" => [ :path ],
     "mv" => [ :path, :path ],
     "insert" => [ :string, :string, :path ],
     "get" => [ :path, :comparator, :string ],
@@ -367,9 +368,7 @@ Puppet::Type.type(:augeas).provide(:augeas) do
           when "get"; return_value = process_get(cmd_array)
           when "match"; return_value = process_match(cmd_array)
           end
-        rescue SystemExit,NoMemoryError
-          raise
-        rescue Exception => e
+        rescue StandardError => e
           fail("Error sending command '#{command}' with params #{cmd_array[1..-1].inspect}/#{e.message}")
         end
       end
@@ -473,6 +472,12 @@ Puppet::Type.type(:augeas).provide(:augeas) do
             else
               fail("command '#{command}' not supported in installed version of ruby-augeas")
             end
+          when "touch"
+            debug("sending command '#{command}' (match, set) with params #{cmd_array.inspect}")
+            if aug.match(cmd_array[0]).empty?
+              rv = aug.clear(cmd_array[0])
+              fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (!rv)
+            end
           when "insert", "ins"
             label = cmd_array[0]
             where = cmd_array[1]
@@ -499,9 +504,7 @@ Puppet::Type.type(:augeas).provide(:augeas) do
             fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (rv == -1)
           else fail("Command '#{command}' is not supported")
         end
-      rescue SystemExit,NoMemoryError
-        raise
-      rescue Exception => e
+      rescue StandardError => e
         fail("Error sending command '#{command}' with params #{cmd_array.inspect}/#{e.message}")
       end
     end

data/lib/puppet/provider/command.rb

@@ -19,7 +19,7 @@ class Puppet::Provider::Command
   # @param args [Array<String>] Any command line arguments to pass to the executable
   # @return The output from the command
   def execute(*args)
-    resolved_executable = @resolver.which(@executable) or raise Puppet::Error, "Command #{@name} is missing"
+    resolved_executable = @resolver.which(@executable) or raise Puppet::MissingCommand, "Command #{@name} is missing"
     @executor.execute([resolved_executable] + args, @options)
   end
 end

data/lib/puppet/provider/cron/crontab.rb

@@ -256,5 +256,42 @@ Puppet::Type.type(:cron).provide(:crontab, :parent => Puppet::Provider::ParsedFi
   def user
     @property_hash[:user] || @property_hash[:target]
   end
+
+  CRONTAB_DIR = case Facter.value("osfamily")
+  when "Debian", "HP-UX"
+    "/var/spool/cron/crontabs"
+  when /BSD/
+    "/var/cron/tabs"
+  when "Darwin"
+    "/usr/lib/cron/tabs/"
+  else
+    "/var/spool/cron"
+  end
+
+  # Yield the names of all crontab files stored on the local system.
+  #
+  # @note Ignores files that are not writable for the puppet process.
+  #
+  # @api private
+  def self.enumerate_crontabs
+    Puppet.debug "looking for crontabs in #{CRONTAB_DIR}"
+    return unless File.readable?(CRONTAB_DIR)
+    Dir.foreach(CRONTAB_DIR) do |file|
+      path = "#{CRONTAB_DIR}/#{file}"
+      yield(file) if File.file?(path) and File.writable?(path)
+    end
+  end
+
+
+  # Include all plausible crontab files on the system
+  # in the list of targets (#11383 / PUP-1381)
+  def self.targets(resources = nil)
+    targets = super(resources)
+    enumerate_crontabs do |target|
+      targets << target
+    end
+    targets.uniq
+  end
+
 end
 

data/lib/puppet/provider/exec.rb

@@ -47,26 +47,12 @@ class Puppet::Provider::Exec < Puppet::Provider
           end
         end
 
-        if Puppet.features.microsoft_windows?
-          exec_user = resource[:user]
-        # Etc.getpwuid() returns nil on Windows
-        elsif resource.current_username == resource[:user]
-          exec_user = nil
-        else
-          exec_user = resource[:user]
-        end
-
-        # 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
+        Timeout::timeout(resource[:timeout]) 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.
           output = Puppet::Util::Execution.execute(command, :failonfail => false, :combine => true,
-                                  :uid => exec_user, :gid => resource[:group],
+                                  :uid => resource[:user], :gid => resource[:group],
                                   :override_locale => false,
                                   :custom_environment => environment)
         end

data/lib/puppet/provider/file/posix.rb

@@ -118,7 +118,7 @@ Puppet::Type.type(:file).provide :posix do
 
   def mode
     if stat = resource.stat
-      return (stat.mode & 007777).to_s(8)
+      return (stat.mode & 007777).to_s(8).rjust(4, '0')
     else
       return :absent
     end

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

@@ -63,7 +63,7 @@ Puppet::Type.type(:file).provide :windows do
   def mode
     if resource.stat
       mode = get_mode(resource[:path])
-      mode ? mode.to_s(8) : :absent
+      mode ? mode.to_s(8).rjust(4, '0') : :absent
     else
       :absent
     end

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

@@ -111,7 +111,7 @@ Puppet::Type.type(:group).provide :aix, :parent => Puppet::Provider::AixObject d
         |k,v| !self.class.attribute_mapping_from.include?(k) and
                 !self.class.attribute_ignore.include?(k)
       }.inject({}) {
-        |hash, array| hash[array[0]] = array[1]; hash
+        |h, array| h[array[0]] = array[1]; h
       }
   end
 

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

@@ -7,7 +7,6 @@ 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,11 +9,6 @@ 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
 
@@ -22,6 +17,9 @@ 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)
@@ -30,7 +28,6 @@ Puppet::Type.type(:group).provide :windows_adsi do
     if @resource[:auth_membership]
       current_users == specified_users
     else
-      return true if specified_users.empty?
       (specified_users.keys.to_a & current_users.keys.to_a) == specified_users.keys.to_a
     end
   end
@@ -39,11 +36,6 @@ 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
@@ -55,10 +47,6 @@ Puppet::Type.type(:group).provide :windows_adsi do
     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
@@ -84,13 +72,11 @@ 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 && !@deleted
+    @group.commit if @group
   end
 
   def gid

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

@@ -17,10 +17,10 @@ Puppet::Type.type(:host).provide(:parsed,:parent => Puppet::Provider::ParsedFile
 
   text_line :comment, :match => /^#/
   text_line :blank, :match => /^\s*$/
-
+  hosts_pattern = '^([0-9a-f:]\S+)\s+([^#\s+]\S+)\s*(.*?)?(?:\s*#\s*(.*))?$'
   record_line :parsed, :fields => %w{ip name host_aliases comment},
     :optional => %w{host_aliases comment},
-    :match    => /^(\S+)\s+(\S+)\s*(.*?)?(?:\s*#\s*(.*))?$/,
+    :match    => /#{hosts_pattern}/,
     :post_parse => proc { |hash|
       # An absent comment should match "comment => ''"
       hash[:comment] = '' if hash[:comment].nil? or hash[:comment] == :absent
@@ -41,4 +41,6 @@ Puppet::Type.type(:host).provide(:parsed,:parent => Puppet::Provider::ParsedFile
       end
       str
     }
+
+  text_line :incomplete, :match => /(?! (#{hosts_pattern}))/
 end

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

@@ -10,21 +10,9 @@ Puppet::Type.type(:macauthorization).provide :macauthorization, :parent => Puppe
   "
 
   commands :security => "/usr/bin/security"
-  commands :sw_vers => "/usr/bin/sw_vers"
 
   confine :operatingsystem => :darwin
 
-  # This should be confined based on macosx_productversion
-  # but puppet resource doesn't make the facts available and
-  # that interface is heavily used with this provider.
-  if Puppet::FileSystem.exist?("/usr/bin/sw_vers")
-    product_version = sw_vers "-productVersion"
-
-    confine :true => unless /^10\.[0-4]/.match(product_version)
-      true
-    end
-  end
-
   defaultfor :operatingsystem => :darwin
 
   AuthDB = "/etc/authorization"

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

@@ -11,28 +11,39 @@ Puppet::Type.type(:mailalias).provide(
 
   record_line :aliases, :fields => %w{name recipient}, :separator => /\s*:\s*/, :block_eval => :instance do
     def post_parse(record)
-      record[:recipient] = record[:recipient].split(/\s*,\s*/).collect { |d| d.gsub(/^['"]|['"]$/, '') }
+      if record[:recipient]
+	record[:recipient] = record[:recipient].split(/\s*,\s*/).collect { |d| d.gsub(/^['"]|['"]$/, '') }
+      end
       record
     end
 
     def process(line)
       ret = {}
-      records = line.split(':',2)
+      records = line.split(':',4)
       ret[:name] = records[0].strip
-      ret[:recipient] = records[1].strip
+      if records.length == 4 and records[2].strip == 'include'
+	ret[:file] = records[3].strip
+      else
+	records = line.split(':',2)
+	ret[:recipient] = records[1].strip
+      end
       ret
     end
 
     def to_line(record)
-      dest = record[:recipient].collect do |d|
-        # Quote aliases that have non-alpha chars
-        if d =~ /[^-\w@.]/
-          '"%s"' % d
-        else
-          d
-        end
-      end.join(",")
-      "#{record[:name]}: #{dest}"
+      if record[:recipient]
+	dest = record[:recipient].collect do |d|
+	  # Quote aliases that have non-alpha chars
+	  if d =~ /[^-\w@.]/
+	    '"%s"' % d
+	  else
+	    d
+	  end
+	end.join(",")
+	"#{record[:name]}: #{dest}"
+      elsif record[:file]
+	"#{record[:name]}: :include: #{record[:file]}"
+      end
     end
   end
 end

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

@@ -4,7 +4,6 @@ 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
@@ -26,12 +25,7 @@ Puppet::Type.type(:mount).provide(
     @fields = [:device, :name, :fstype, :options, :dump, :pass]
   end
 
-  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 :comment, :match => /^\s*#/
   text_line :blank, :match => /^\s*$/
 
   optional_fields  = @fields - [:device, :name, :blockdevice]
@@ -42,144 +36,7 @@ Puppet::Type.type(:mount).provide(
   field_pattern = '(\s*(?>\S+))'
   text_line :incomplete, :match => /^(?!#{field_pattern}{#{mandatory_fields.length}})/
 
-  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 preceeding 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
-  end
+  record_line self.name, :fields => @fields, :separator => /\s+/, :joiner => "\t", :optional => optional_fields
 
   # Every entry in fstab is :unmounted until we can prove different
   def self.prefetch_hook(target_records)