puppet 3.1.1 → 3.2.0.rc1

data/lib/puppet/provider/aixobject.rb

@@ -1,6 +1,6 @@
 #
 # Common code for AIX providers. This class implements basic structure for
-# AIX resources. 
+# AIX resources.
 # Author::    Hector Rivas Gandara <keymon@gmail.com>
 #
 class Puppet::Provider::AixObject < Puppet::Provider
@@ -31,9 +31,9 @@ class Puppet::Provider::AixObject < Puppet::Provider
   # It is a list of hashes
   #  :aix_attr      AIX command attribute name
   #  :puppet_prop   Puppet propertie name
-  #  :to            Optional. Method name that adapts puppet property to aix command value. 
+  #  :to            Optional. Method name that adapts puppet property to aix command value.
   #  :from          Optional. Method to adapt aix command line value to puppet property. Optional
-  class << self 
+  class << self
     attr_accessor :attribute_mapping
   end
 
@@ -49,7 +49,7 @@ class Puppet::Provider::AixObject < Puppet::Provider
       }
     end
     @attribute_mapping_to
-  end    
+  end
 
   # Mapping from AIX attribute to Puppet property.
   def self.attribute_mapping_from
@@ -64,7 +64,7 @@ class Puppet::Provider::AixObject < Puppet::Provider
     end
     @attribute_mapping_from
   end
-  
+
   # This functions translates a key and value using the given mapping.
   # Mapping can be nil (no translation) or a hash with this format
   # {:key => new_key, :method => translate_method}
@@ -72,7 +72,7 @@ class Puppet::Provider::AixObject < Puppet::Provider
   def translate_attr(key, value, mapping)
     return [key, value] unless mapping
     return nil unless mapping[key]
-    
+
     if mapping[key][:method]
       new_value = method(mapping[key][:method]).call(value)
     else
@@ -80,7 +80,7 @@ class Puppet::Provider::AixObject < Puppet::Provider
     end
     [mapping[key][:key], new_value]
   end
-  
+
   # Loads an AIX attribute (key=value) and stores it in the given hash with
   # puppet semantics. It translates the pair using the given mapping.
   #
@@ -94,13 +94,13 @@ class Puppet::Provider::AixObject < Puppet::Provider
       true
     elsif mapping[key][:method].nil?
       objectinfo[mapping[key][:key]] = value
-    elsif 
+    elsif
       objectinfo[mapping[key][:key]] = method(mapping[key][:method]).call(value)
     end
-    
+
     return objectinfo
   end
-  
+
   # Gets the given command line argument for the given key and value,
   # using the given mapping to translate key and value.
   # All the objectinfo hash (@resource or @property_hash) is passed.
@@ -109,7 +109,7 @@ class Puppet::Provider::AixObject < Puppet::Provider
   # and default behaviour is return the arguments as key=value pairs.
   # Subclasses must reimplement this if more complex operations/arguments
   # are needed
-  # 
+  #
   def get_arguments(key, value, mapping, objectinfo)
     if mapping.nil?
       new_key = key
@@ -121,7 +121,7 @@ class Puppet::Provider::AixObject < Puppet::Provider
     elsif mapping[key][:method].nil?
       new_key = mapping[key][:key]
       new_value = value
-    elsif 
+    elsif
       new_key = mapping[key][:key]
       new_value = method(mapping[key][:method]).call(value)
     end
@@ -130,18 +130,18 @@ class Puppet::Provider::AixObject < Puppet::Provider
     new_value = Array(new_value).join(',')
 
     if new_key
-      return [ "#{new_key}=#{new_value}" ] 
+      return [ "#{new_key}=#{new_value}" ]
     else
       return []
     end
   end
-  
+
   # Convert the provider properties (hash) to AIX command arguments
   # (list of strings)
   # This function will translate each value/key and generate the argument using
   # the get_arguments function.
   def hash2args(hash, mapping=self.class.attribute_mapping_to)
-    return "" unless hash 
+    return "" unless hash
     arg_list = []
     hash.each {|key, val|
       arg_list += self.get_arguments(key, val, mapping, hash)
@@ -151,8 +151,8 @@ class Puppet::Provider::AixObject < Puppet::Provider
 
   # Parse AIX command attributes from the output of an AIX command, that
   # which format is a list of space separated of key=value pairs:
-  # "uid=100 groups=a,b,c". 
-  # It returns an hash. 
+  # "uid=100 groups=a,b,c".
+  # It returns an hash.
   #
   # If a mapping is provided, the keys are translated as defined in the
   # mapping hash. And only values included in mapping will be added
@@ -163,7 +163,7 @@ class Puppet::Provider::AixObject < Puppet::Provider
     attrs = []
     if !str or (attrs = str.split()).empty?
       return nil
-    end 
+    end
 
     attrs.each { |i|
       if i.include? "=" # Ignore if it does not include '='
@@ -174,7 +174,7 @@ class Puppet::Provider::AixObject < Puppet::Provider
           continue
         end
         key = key_str.to_sym
-       
+
         properties = self.load_attribute(key, val, mapping, properties)
       end
     }
@@ -195,16 +195,15 @@ class Puppet::Provider::AixObject < Puppet::Provider
     attrs = []
     if !str or (attrs = str.split(':')).empty?
       return nil
-    end 
+    end
 
     attrs.each { |val|
       key = key_list.shift.downcase.to_sym
       properties = self.load_attribute(key, val, mapping, properties)
     }
     properties.empty? ? nil : properties
-    
   end
-  
+
   # Default parsing function for AIX commands.
   # It will choose the method depending of the first line.
   # For the colon separated list it will:
@@ -213,7 +212,7 @@ class Puppet::Provider::AixObject < Puppet::Provider
   def parse_command_output(output, mapping=self.class.attribute_mapping_from)
     lines = output.split("\n")
     # if it begins with #something:... is a colon separated list.
-    if lines[0] =~ /^#.*:/ 
+    if lines[0] =~ /^#.*:/
       self.parse_colon_list(lines[1], lines[0][1..-1].split(':'), mapping)
     else
       self.parse_attr_list(lines[0], mapping)
@@ -233,7 +232,7 @@ class Puppet::Provider::AixObject < Puppet::Provider
         @objectosinfo = self.parse_command_output(execute(self.lscmd), nil)
       rescue Puppet::ExecutionFailure => detail
         # Print error if needed. FIXME: Do not check the user here.
-        Puppet.debug "aix.getinfo(): Could not find #{@resource.class.name} #{@resource.name}: #{detail}" 
+        Puppet.debug "aix.getinfo(): Could not find #{@resource.class.name} #{@resource.name}: #{detail}"
       end
     end
     @objectinfo
@@ -252,17 +251,20 @@ class Puppet::Provider::AixObject < Puppet::Provider
   # List all elements of given type. It works for colon separated commands and
   # list commands.
   # It returns a list of names.
-  def list_all
+  def self.list_all
     names = []
     begin
-      output = execute(self.lsallcmd()).split('\n')
-      (output.select{ |l| l != /^#/ }).each { |v|
-        name = v.split(/[ :]/)
+      output = execute([self.command(:list), 'ALL'])
+
+      output = output.split("\n").select{ |line| line != /^#/ }
+
+      output.each do |line|
+        name = line.split(/[ :]/)[0]
         names << name if not name.empty?
-      }
+      end
     rescue Puppet::ExecutionFailure => detail
       # Print error if needed
-      Puppet.debug "aix.list_all(): Could not get all resources of type #{@resource.class.name}: #{detail}" 
+      Puppet.debug "aix.list_all(): Could not get all resources of type #{@resource.class.name}: #{detail}"
     end
     names
   end
@@ -271,7 +273,7 @@ class Puppet::Provider::AixObject < Puppet::Provider
   #-------------
   # Provider API
   # ------------
- 
+
   # Clear out the cached values.
   def flush
     @property_hash.clear if @property_hash
@@ -283,12 +285,12 @@ class Puppet::Provider::AixObject < Puppet::Provider
     !!getinfo(true) # !! => converts to bool
   end
 
-  # Return all existing instances  
+  # Return all existing instances
   # The method for returning a list of provider instances.  Note that it returns
   # providers, preferably with values already filled in, not resources.
   def self.instances
     objects=[]
-    self.list_all().each { |entry|
+    self.list_all.each { |entry|
       objects << new(:name => entry, :ensure => :present)
     }
     objects
@@ -319,7 +321,7 @@ class Puppet::Provider::AixObject < Puppet::Provider
     rescue Puppet::ExecutionFailure => detail
       raise Puppet::Error, "Could not create #{@resource.class.name} #{@resource.name}: #{detail}"
     end
-  end 
+  end
 
   # Delete this instance of the resource
   def delete
@@ -347,13 +349,13 @@ class Puppet::Provider::AixObject < Puppet::Provider
       define_method(prop.to_s + "=") { |*vals| set(prop, *vals) } unless public_method_defined?(prop.to_s + "=")
     end
   end
-  
+
   # Define the needed getters and setters as soon as we know the resource type
   def self.resource_type=(resource_type)
     super
     mk_resource_methods
   end
-  
+
   # Retrieve a specific value by name.
   def get(param)
     (hash = getinfo(false)) ? hash[param] : nil
@@ -362,15 +364,15 @@ class Puppet::Provider::AixObject < Puppet::Provider
   # Set a property.
   def set(param, value)
     @property_hash[param.intern] = value
-    
+
     if getinfo().nil?
-      # This is weird... 
+      # This is weird...
       raise Puppet::Error, "Trying to update parameter '#{param}' to '#{value}' for a resource that does not exists #{@resource.class.name} #{@resource.name}: #{detail}"
     end
     if value == getinfo()[param.to_sym]
       return
     end
-    
+
     #self.class.validate(param, value)
     if cmd = modifycmd({param =>value})
       begin
@@ -379,15 +381,14 @@ class Puppet::Provider::AixObject < Puppet::Provider
         raise Puppet::Error, "Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}"
       end
     end
-    
-    # Refresh de info.  
+
+    # Refresh de info.
     hash = getinfo(true)
   end
- 
+
   def initialize(resource)
     super
     @objectinfo = nil
     @objectosinfo = nil
-  end  
-
+  end
 end

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

@@ -171,7 +171,6 @@ Puppet::Type.type(:augeas).provide(:augeas) do
         aug.set("/augeas/load/Xfm/incl", resource[:incl])
         restricted = true
       elsif glob_avail and opt_ctx
-        restricted = true
         # Optimize loading if the context is given, requires the glob function
         # from Augeas 0.8.2 or up
         ctx_path = resource[:context].sub(/^\/files(.*?)\/?$/, '\1/')

data/lib/puppet/provider/confiner.rb

@@ -36,7 +36,7 @@ module Puppet::Provider::Confiner
   # Checks whether this implementation is suitable for the current platform (or returns a summary
   # of all confines if short == false).
   # @return [Boolean. Hash] Returns whether the confines are all valid (if short == true), or a hash of all confines
-  #   if short == false. 
+  #   if short == false.
   # @api public
   #
   def suitable?(short = true)

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

@@ -1,17 +1,6 @@
 require 'puppet/provider/parsedfile'
 
-tab = case Facter.value(:osfamily)
-  when "Solaris"
-    :suntab
-  when "AIX"
-    :aixtab
-  else
-    :crontab
-  end
-
-
-
-Puppet::Type.type(:cron).provide(:crontab, :parent => Puppet::Provider::ParsedFile, :default_target => ENV["USER"] || "root", :filetype => tab) do
+Puppet::Type.type(:cron).provide(:crontab, :parent => Puppet::Provider::ParsedFile, :default_target => ENV["USER"] || "root") do
   commands :crontab => "crontab"
 
   text_line :comment, :match => %r{^\s*#}, :post_parse => proc { |record|
@@ -22,58 +11,103 @@ Puppet::Type.type(:cron).provide(:crontab, :parent => Puppet::Provider::ParsedFi
 
   text_line :environment, :match => %r{^\s*\w+=}
 
-  record_line :freebsd_special, :fields => %w{special command},
-    :match => %r{^@(\w+)\s+(.+)$}, :pre_gen => proc { |record|
-      record[:special] = "@" + record[:special]
-    }
+  def self.filetype
+  tabname = case Facter.value(:osfamily)
+            when "Solaris"
+              :suntab
+            when "AIX"
+              :aixtab
+            else
+              :crontab
+            end
+
+    Puppet::Util::FileType.filetype(tabname)
+  end
 
-  crontab = record_line :crontab, :fields => %w{minute hour monthday month weekday command},
-    :match => %r{^\s*(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(.+)$},
-    :optional => %w{minute hour weekday month monthday}, :absent => "*"
+  self::TIME_FIELDS = [:minute, :hour, :monthday, :month, :weekday]
+
+  record_line :crontab,
+    :fields     => %w{time command},
+    :match      => %r{^\s*(@\w+|\S+\s+\S+\s+\S+\s+\S+\s+\S+)\s+(.+)$},
+    :absent     => '*',
+    :block_eval => :instance do
 
-  class << crontab
-    def numeric_fields
-      fields - [:command]
-    end
-    # Do some post-processing of the parsed record.  Basically just
-    # split the numeric fields on ','.
     def post_parse(record)
-      numeric_fields.each do |field|
-        if val = record[field] and val != :absent
-          record[field] = record[field].split(",")
+      time = record.delete(:time)
+      if match = /@(\S+)/.match(time)
+        # is there another way to access the constant?
+        Puppet::Type::Cron::ProviderCrontab::TIME_FIELDS.each { |f| record[f] = :absent }
+        record[:special] = match.captures[0]
+      elsif match = /(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)/.match(time)
+        record[:special] = :absent
+        Puppet::Type::Cron::ProviderCrontab::TIME_FIELDS.zip(match.captures).each do |field,value|
+          if value == self.absent
+            record[field] = :absent
+          else
+            record[field] = value.split(",")
+          end
         end
+      else
+        raise Puppet::Error, "Line got parsed as a crontab entry but cannot be handled. Please file a bug with the contents of your crontab"
       end
+      record
     end
 
-    # Join the fields back up based on ','.
     def pre_gen(record)
-      numeric_fields.each do |field|
+      if record[:special] and record[:special] != :absent
+        record[:special] = "@#{record[:special]}"
+      end
+
+      Puppet::Type::Cron::ProviderCrontab::TIME_FIELDS.each do |field|
         if vals = record[field] and vals.is_a?(Array)
           record[field] = vals.join(",")
         end
       end
+      record
     end
 
-
-    # Add name and environments as necessary.
     def to_line(record)
       str = ""
       str = "# Puppet Name: #{record[:name]}\n" if record[:name]
-      if record[:environment] and record[:environment] != :absent and record[:environment] != [:absent]
-        record[:environment].each do |env|
-          str += env + "\n"
-        end
+      if record[:environment] and record[:environment] != :absent
+        str += record[:environment].map {|line| "#{line}\n"}.join('')
       end
-
-      if record[:special]
-        str += "@#{record[:special]} #{record[:command]}"
+      if record[:special] and record[:special] != :absent
+        fields = [:special, :command]
       else
-        str += join(record)
+        fields = Puppet::Type::Cron::ProviderCrontab::TIME_FIELDS + [:command]
       end
+      str += record.values_at(*fields).map do |field|
+        if field.nil? or field == :absent
+          self.absent
+        else
+          field
+        end
+      end.join(self.joiner)
       str
     end
   end
 
+  # Look up a resource with a given name whose user matches a record target
+  #
+  # @api private
+  #
+  # @note This overrides the ParsedFile method for finding resources by name,
+  #   so that only records for a given user are matched to resources of the
+  #   same user so that orphaned records in other crontabs don't get falsely
+  #   matched (#2251)
+  #
+  # @param [Hash<Symbol, Object>] record
+  # @param [Array<Puppet::Resource>] resources
+  #
+  # @return [Puppet::Resource, nil] The resource if found, else nil
+  def self.resource_for_record(record, resources)
+    resource = super
+
+    if resource and record[:target] == resource[:user]
+      resource
+    end
+  end
 
   # Return the header placed at the top of each generated file, warning
   # users that modifying this file manually is probably a bad idea.
@@ -84,50 +118,52 @@ Puppet::Type.type(:cron).provide(:crontab, :parent => Puppet::Provider::ParsedFi
 # HEADER: not be deleted, as doing so could cause duplicate cron jobs.\n}
   end
 
+  # Regex for finding one vixie cron header.
+  def self.native_header_regex
+    /# DO NOT EDIT THIS FILE.*?Cron version.*?vixie.*?\n/m
+  end
+
+  # If a vixie cron header is found, it should be dropped, cron will insert
+  # a new one in any case, so we need to avoid duplicates.
+  def self.drop_native_header
+    true
+  end
+
   # See if we can match the record against an existing cron job.
   def self.match(record, resources)
+    # if the record is named, do not even bother (#19876)
+    return false if record[:name]
     resources.each do |name, resource|
       # Match the command first, since it's the most important one.
-      next unless record[:target] == resource.value(:target)
+      next unless record[:target] == resource[:target]
       next unless record[:command] == resource.value(:command)
 
-      # Then check the @special stuff
-      if record[:special]
-        next unless resource.value(:special) == record[:special]
-      end
+      # Now check the time fields
+      compare_fields = self::TIME_FIELDS + [:special]
 
-      # Then the normal fields.
       matched = true
-      record_type(record[:record_type]).fields.each do |field|
-        next if field == :command
-        next if field == :special
-        if record[field] and ! resource.value(field)
-          #Puppet.info "Cron is missing %s: %s and %s" %
-          #    [field, record[field].inspect, resource.value(field).inspect]
+      compare_fields.each do |field|
+        # If the resource does not manage a property (say monthday) it should
+        # always match. If it is the other way around (e.g. resource defines
+        # a should value for :special but the record does not have it, we do
+        # not match
+        next unless resource[field]
+        unless record.include?(field)
           matched = false
           break
         end
 
-        if ! record[field] and resource.value(field)
-          #Puppet.info "Hash is missing %s: %s and %s" %
-          #    [field, resource.value(field).inspect, record[field].inspect]
-          matched = false
-          break
+        if record_value = record[field] and resource_value = resource.value(field)
+          # The record translates '*' into absent in the post_parse hook and
+          # the resource type does exactly the opposite (alias :absent to *)
+          next if resource_value == '*' and record_value == :absent
+          next if resource_value == record_value
         end
-
-        # Yay differing definitions of absent.
-        next if (record[field] == :absent and resource.value(field) == "*")
-
-        # Everything should be in the form of arrays, not the normal text.
-        next if (record[field] == resource.value(field))
-        #Puppet.info "Did not match %s: %s vs %s" %
-        #    [field, resource.value(field).inspect, record[field].inspect]
-        matched = false
+        matched =false
         break
       end
       return resource if matched
     end
-
     false
   end
 
@@ -189,6 +225,10 @@ Puppet::Type.type(:cron).provide(:crontab, :parent => Puppet::Provider::ParsedFi
   end
 
   def user=(user)
+    # we have to mark the target as modified first, to make sure that if
+    # we move a cronjob from userA to userB, userA's crontab will also
+    # be rewritten
+    mark_target_modified
     @property_hash[:user] = user
     @property_hash[:target] = user
   end