puppet 0.25.5 → 2.6.0

data/lib/puppet/provider/confiner.rb

@@ -1,20 +1,16 @@
 require 'puppet/provider/confine_collection'
 
 module Puppet::Provider::Confiner
-    def confine(hash)
-        confine_collection.confine(hash)
-    end
+  def confine(hash)
+    confine_collection.confine(hash)
+  end
 
-    def confine_collection
-        unless defined?(@confine_collection)
-            @confine_collection = Puppet::Provider::ConfineCollection.new(self.to_s)
-        end
-        @confine_collection
-    end
+  def confine_collection
+    @confine_collection ||= Puppet::Provider::ConfineCollection.new(self.to_s)
+  end
 
-    # Check whether this implementation is suitable for our platform.
-    def suitable?(short = true)
-        return confine_collection.valid? if short
-        return confine_collection.summary
-    end
+  # Check whether this implementation is suitable for our platform.
+  def suitable?(short = true)
+    return(short ? confine_collection.valid? : confine_collection.summary)
+  end
 end

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

@@ -1,207 +1,206 @@
 require 'puppet/provider/parsedfile'
 
 tab = case Facter.value(:operatingsystem)
-    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
+  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
-    commands :crontab => "crontab"
+  commands :crontab => "crontab"
 
-    text_line :comment, :match => %r{^#}, :post_parse => proc { |record|
-        if record[:line] =~ /Puppet Name: (.+)\s*$/
-            record[:name] = $1
-        end
-    }
+  text_line :comment, :match => %r{^#}, :post_parse => proc { |record|
+    record[:name] = $1 if record[:line] =~ /Puppet Name: (.+)\s*$/
+  }
 
-    text_line :blank, :match => %r{^\s*$}
+  text_line :blank, :match => %r{^\s*$}
 
-    text_line :environment, :match => %r{^\w+=}
+  text_line :environment, :match => %r{^\w+=}
 
-    record_line :freebsd_special, :fields => %w{special command},
-        :match => %r{^@(\w+)\s+(.+)$}, :pre_gen => proc { |record|
-            record[:special] = "@" + record[:special]
-        }
+  record_line :freebsd_special, :fields => %w{special command},
+    :match => %r{^@(\w+)\s+(.+)$}, :pre_gen => proc { |record|
+      record[:special] = "@" + record[:special]
+    }
 
-    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 => "*"
+  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 => "*"
 
-    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(",")
-                end
-            end
+  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(",")
         end
+      end
+    end
 
-        # Join the fields back up based on ','.
-        def pre_gen(record)
-            numeric_fields.each do |field|
-                if vals = record[field] and vals.is_a?(Array)
-                    record[field] = vals.join(",")
-                end
-            end
+    # Join the fields back up based on ','.
+    def pre_gen(record)
+      numeric_fields.each do |field|
+        if vals = record[field] and vals.is_a?(Array)
+          record[field] = vals.join(",")
         end
+      end
+    end
 
 
-        # Add name and environments as necessary.
-        def to_line(record)
-            str = ""
-            if record[:name]
-                str = "# Puppet Name: %s\n" % record[:name]
-            end
-            if record[:environment] and record[:environment] != :absent and record[:environment] != [:absent]
-                record[:environment].each do |env|
-                    str += env + "\n"
-                end
-            end
-
-            if record[:special]
-                str += "@%s %s" % [record[:special], record[:command]]
-            else
-                str += join(record)
-            end
-            str
+    # 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
+      end
+
+      if record[:special]
+        str += "@#{record[:special]} #{record[:command]}"
+      else
+        str += join(record)
+      end
+      str
     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.
-    def self.header
+  # Return the header placed at the top of each generated file, warning
+  # users that modifying this file manually is probably a bad idea.
+  def self.header
 %{# HEADER: This file was autogenerated at #{Time.now} by puppet.
 # HEADER: While it can still be managed manually, it is definitely not recommended.
 # HEADER: Note particularly that the comments starting with 'Puppet Name' should
 # HEADER: not be deleted, as doing so could cause duplicate cron jobs.\n}
-    end
-
-    # See if we can match the record against an existing cron job.
-    def self.match(record, resources)
-        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[:command] == resource.value(:command)
-
-            # Then check the @special stuff
-            if record[:special]
-                next unless resource.value(:special) == record[:special]
-            end
-
-            # 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]
-                    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
-                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
-                break
-            end
-            return resource if matched
+  end
+
+  # See if we can match the record against an existing cron job.
+  def self.match(record, resources)
+    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[:command] == resource.value(:command)
+
+      # Then check the @special stuff
+      if record[:special]
+        next unless resource.value(:special) == record[:special]
+      end
+
+      # 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]
+          matched = false
+          break
         end
 
-        return false
-    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
+        end
 
-    # Collapse name and env records.
-    def self.prefetch_hook(records)
-        name = nil
-        envs = nil
-        result = records.each { |record|
-            case record[:record_type]
-            when :comment
-                if record[:name]
-                    name = record[:name]
-                    record[:skip] = true
-
-                    # Start collecting env values
-                    envs = []
-                end
-            when :environment
-                # If we're collecting env values (meaning we're in a named cronjob),
-                # store the line and skip the record.
-                if envs
-                    envs << record[:line]
-                    record[:skip] = true
-                end
-            when :blank
-                # nothing
-            else
-                if name
-                    record[:name] = name
-                    name = nil
-                end
-                if envs.nil? or envs.empty?
-                    record[:environment] = :absent
-                else
-                    # Collect all of the environment lines, and mark the records to be skipped,
-                    # since their data is included in our crontab record.
-                    record[:environment] = envs
-
-                    # And turn off env collection again
-                    envs = nil
-                end
-            end
-        }.reject { |record| record[:skip] }
-        result
+        # 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
+        break
+      end
+      return resource if matched
     end
 
-    def self.to_file(records)
-        text = super
-        # Apparently Freebsd will "helpfully" add a new TZ line to every
-        # single cron line, but not in all cases (e.g., it doesn't do it
-        # on my machine).  This is my attempt to fix it so the TZ lines don't
-        # multiply.
-        if text =~ /(^TZ=.+\n)/
-            tz = $1
-            text.sub!(tz, '')
-            text = tz + text
+    false
+  end
+
+  # Collapse name and env records.
+  def self.prefetch_hook(records)
+    name = nil
+    envs = nil
+    result = records.each { |record|
+      case record[:record_type]
+      when :comment
+        if record[:name]
+          name = record[:name]
+          record[:skip] = true
+
+          # Start collecting env values
+          envs = []
+        end
+      when :environment
+        # If we're collecting env values (meaning we're in a named cronjob),
+        # store the line and skip the record.
+        if envs
+          envs << record[:line]
+          record[:skip] = true
         end
-        return text
+      when :blank
+        # nothing
+      else
+        if name
+          record[:name] = name
+          name = nil
+        end
+        if envs.nil? or envs.empty?
+          record[:environment] = :absent
+        else
+          # Collect all of the environment lines, and mark the records to be skipped,
+          # since their data is included in our crontab record.
+          record[:environment] = envs
+
+          # And turn off env collection again
+          envs = nil
+        end
+      end
+    }.reject { |record| record[:skip] }
+    result
+  end
+
+  def self.to_file(records)
+    text = super
+    # Apparently Freebsd will "helpfully" add a new TZ line to every
+    # single cron line, but not in all cases (e.g., it doesn't do it
+    # on my machine).  This is my attempt to fix it so the TZ lines don't
+    # multiply.
+    if text =~ /(^TZ=.+\n)/
+      tz = $1
+      text.sub!(tz, '')
+      text = tz + text
     end
+    text
+  end
 
-    def user=(user)
-        @property_hash[:user] = user
-        @property_hash[:target] = user
-    end
+  def user=(user)
+    @property_hash[:user] = user
+    @property_hash[:target] = user
+  end
 
-    def user
-        @property_hash[:user] || @property_hash[:target]
-    end
+  def user
+    @property_hash[:user] || @property_hash[:target]
+  end
 end
 

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

@@ -0,0 +1,99 @@
+Puppet::Type.type(:file).provide :posix do
+  desc "Uses POSIX functionality to manage file's users and rights."
+
+  confine :feature => :posix
+
+  include Puppet::Util::POSIX
+  include Puppet::Util::Warnings
+
+  require 'etc'
+
+  def id2name(id)
+    return id.to_s if id.is_a?(Symbol)
+    return nil if id > Puppet[:maximum_uid].to_i
+
+    begin
+      user = Etc.getpwuid(id)
+    rescue TypeError
+      return nil
+    rescue ArgumentError
+      return nil
+    end
+
+    if user.uid == ""
+      return nil
+    else
+      return user.name
+    end
+  end
+
+  def insync?(current, should)
+    return true unless should
+
+    should.each do |value|
+      if value =~ /^\d+$/
+        uid = Integer(value)
+      elsif value.is_a?(String)
+        fail "Could not find user #{value}" unless uid = uid(value)
+      else
+        uid = value
+      end
+
+      return true if uid == current
+    end
+
+    unless Puppet.features.root?
+      warnonce "Cannot manage ownership unless running as root"
+      return true
+    end
+
+    false
+  end
+
+  # Determine if the user is valid, and if so, return the UID
+  def validuser?(value)
+    Integer(value) rescue uid(value) || false
+  end
+
+  def retrieve(resource)
+    unless stat = resource.stat(false)
+      return :absent
+    end
+
+    currentvalue = stat.uid
+
+    # On OS X, files that are owned by -2 get returned as really
+    # large UIDs instead of negative ones.  This isn't a Ruby bug,
+    # it's an OS X bug, since it shows up in perl, too.
+    if currentvalue > Puppet[:maximum_uid].to_i
+      self.warning "Apparently using negative UID (#{currentvalue}) on a platform that does not consistently handle them"
+      currentvalue = :silly
+    end
+
+    currentvalue
+  end
+
+  def sync(path, links, should)
+    # Set our method appropriately, depending on links.
+    if links == :manage
+      method = :lchown
+    else
+      method = :chown
+    end
+
+    uid = nil
+    should.each do |user|
+      break if uid = validuser?(user)
+    end
+
+    raise Puppet::Error, "Could not find user(s) #{should.join(",")}" unless uid
+
+    begin
+      File.send(method, uid, nil, path)
+    rescue => detail
+      raise Puppet::Error, "Failed to set owner to '#{uid}': #{detail}"
+    end
+
+    :file_changed
+  end
+end