puppet 2.7.19 → 2.7.20.rc1

data/lib/puppet/util/filetype.rb

@@ -19,12 +19,10 @@ class Puppet::Util::FileType
   def self.newfiletype(name, &block)
     @filetypes ||= {}
 
-
-          klass = genclass(
-        name,
+    klass = genclass(
+      name,
       :block => block,
       :prefix => "FileType",
-        
       :hash => @filetypes
     )
 
@@ -81,6 +79,17 @@ class Puppet::Util::FileType
     @path = path
   end
 
+  # Arguments that will be passed to the execute method. Will set the uid
+  # to the target user if the target user and the current user are not
+  # the same
+  def cronargs
+    if uid = Puppet::Util.uid(@path) and uid == Puppet::Util::SUIDManager.uid
+      {:failonfail => true, :combine => true}
+    else
+      {:failonfail => true, :combine => true, :uid => @path}
+    end
+  end
+
   # Operate on plain files.
   newfiletype(:flat) do
     # Back the file up before replacing it.
@@ -155,7 +164,7 @@ class Puppet::Util::FileType
       begin
         @uid = Puppet::Util.uid(user)
       rescue Puppet::Error => detail
-        raise Puppet::Error, "Could not retrieve user #{user}"
+        raise Puppet::Error, "Could not retrieve user #{user}: #{detail}", detail.backtrace
       end
 
       # XXX We have to have the user name, not the uid, because some
@@ -204,39 +213,41 @@ class Puppet::Util::FileType
   newfiletype(:suntab) do
     # Read a specific @path's cron tab.
     def read
-        output = Puppet::Util.execute(%w{crontab -l}, :uid => @path)
-        return "" if output.include?("can't open your crontab")
-        raise Puppet::Error, "User #{@path} not authorized to use cron" if output.include?("you are not authorized to use cron")
-        return output
+      Puppet::Util.execute(%w{crontab -l}, cronargs)
     rescue => detail
-        raise Puppet::Error, "Could not read crontab for #{@path}: #{detail}"
+      case detail.to_s
+      when /can't open your crontab/
+        return ""
+      when /you are not authorized to use cron/
+        raise Puppet::Error, "User #{@path} not authorized to use cron", detail.backtrace
+      else
+        raise Puppet::Error, "Could not read crontab for #{@path}: #{detail}", detail.backtrace
+      end
     end
 
     # Remove a specific @path's cron tab.
     def remove
-        Puppet::Util.execute(%w{crontab -r}, :uid => @path)
+      Puppet::Util.execute(%w{crontab -r}, cronargs)
     rescue => detail
-        raise Puppet::Error, "Could not remove crontab for #{@path}: #{detail}"
+      raise Puppet::Error, "Could not remove crontab for #{@path}: #{detail}", detail.backtrace
     end
 
     # Overwrite a specific @path's cron tab; must be passed the @path name
     # and the text with which to create the cron tab.
     def write(text)
-      puts text
-      output_file = Tempfile.new("puppet")
-      fh = output_file.open
-      fh.print text
-      fh.close
-
-      # We have to chown the stupid file to the user.
-      File.chown(Puppet::Util.uid(@path), nil, output_file.path)
-
+      output_file = Tempfile.new("puppet_suntab")
       begin
-        Puppet::Util.execute(["crontab", output_file.path], :uid => @path)
+        output_file.print text
+        output_file.close
+        # We have to chown the stupid file to the user.
+        File.chown(Puppet::Util.uid(@path), nil, output_file.path)
+        Puppet::Util.execute(["crontab", output_file.path], cronargs)
       rescue => detail
-        raise Puppet::Error, "Could not write crontab for #{@path}: #{detail}"
+        raise Puppet::Error, "Could not write crontab for #{@path}: #{detail}", detail.backtrace
+      ensure
+        output_file.close
+        output_file.unlink
       end
-      output_file.delete
     end
   end
 
@@ -244,37 +255,41 @@ class Puppet::Util::FileType
   newfiletype(:aixtab) do
     # Read a specific @path's cron tab.
     def read
-        output = Puppet::Util.execute(%w{crontab -l}, :uid => @path)
-        raise Puppet::Error, "User #{@path} not authorized to use cron" if output.include?("You are not authorized to use the cron command")
-        return output
+      Puppet::Util.execute(%w{crontab -l}, cronargs)
     rescue => detail
-        raise Puppet::Error, "Could not read crontab for #{@path}: #{detail}"
+      case detail.to_s
+      when /Cannot open a file in the .* directory/
+        return ""
+      when /You are not authorized to use the cron command/
+        raise Puppet::Error, "User #{@path} not authorized to use cron", detail.backtrace
+      else
+        raise Puppet::Error, "Could not read crontab for #{@path}: #{detail}", detail.backtrace
+      end
     end
 
     # Remove a specific @path's cron tab.
     def remove
-        Puppet::Util.execute(%w{crontab -r}, :uid => @path)
+      Puppet::Util.execute(%w{crontab -r}, cronargs)
     rescue => detail
-        raise Puppet::Error, "Could not remove crontab for #{@path}: #{detail}"
+      raise Puppet::Error, "Could not remove crontab for #{@path}: #{detail}", detail.backtrace
     end
 
     # Overwrite a specific @path's cron tab; must be passed the @path name
     # and the text with which to create the cron tab.
     def write(text)
-      output_file = Tempfile.new("puppet")
-      fh = output_file.open
-      fh.print text
-      fh.close
-
-      # We have to chown the stupid file to the user.
-      File.chown(Puppet::Util.uid(@path), nil, output_file.path)
+      output_file = Tempfile.new("puppet_aixtab")
 
       begin
-        Puppet::Util.execute(["crontab", output_file.path], :uid => @path)
+        output_file.print text
+        output_file.close
+        # We have to chown the stupid file to the user.
+        File.chown(Puppet::Util.uid(@path), nil, output_file.path)
+        Puppet::Util.execute(["crontab", output_file.path], cronargs)
       rescue => detail
-        raise Puppet::Error, "Could not write crontab for #{@path}: #{detail}"
+        raise Puppet::Error, "Could not write crontab for #{@path}: #{detail}", detail.backtrace
       ensure
-        output_file.delete
+        output_file.close
+        output_file.unlink
       end
     end
   end

data/lib/puppet/util/instance_loader.rb

@@ -8,14 +8,14 @@ module Puppet::Util::InstanceLoader
 
   # Are we instance-loading this type?
   def instance_loading?(type)
-    defined?(@autoloaders) and @autoloaders.include?(symbolize(type))
+    defined?(@autoloaders) and @autoloaders.include?(type.intern)
   end
 
   # Define a new type of autoloading.
   def instance_load(type, path, options = {})
     @autoloaders ||= {}
     @instances ||= {}
-    type = symbolize(type)
+    type = type.intern
     @instances[type] = {}
     @autoloaders[type] = Puppet::Util::Autoload.new(self, path, options)
 
@@ -52,17 +52,17 @@ module Puppet::Util::InstanceLoader
 
   # Return the instance hash for our type.
   def instance_hash(type)
-    @instances[symbolize(type)]
+    @instances[type.intern]
   end
 
   # Return the Autoload object for a given type.
   def instance_loader(type)
-    @autoloaders[symbolize(type)]
+    @autoloaders[type.intern]
   end
 
   # Retrieve an alread-loaded instance, or attempt to load our instance.
   def loaded_instance(type, name)
-    name = symbolize(name)
+    name = name.intern
     return nil unless instances = instance_hash(type)
     unless instances.include? name
       if instance_loader(type).load(name)

data/lib/puppet/util/instrumentation.rb

@@ -96,7 +96,7 @@ class Puppet::Util::Instrumentation
   # If no pattern is provided, then the listener will be called for every events
   def self.new_listener(name, options = {}, &block)
     Puppet.debug "new listener called #{name}"
-    name = symbolize(name)
+    name = name.intern
     listener = genclass(name, :hash => instance_hash(:listener), :block => block)
     listener.send(:define_method, :name) do
       name
@@ -144,15 +144,13 @@ class Puppet::Util::Instrumentation
 
   def self.[](key)
     synchronize {
-      key = symbolize(key)
-      @listeners[key]
+      @listeners[key.intern]
     }
   end
 
   def self.[]=(key, value)
     synchronize {
-      key = symbolize(key)
-      @listeners[key] = value
+      @listeners[key.intern] = value
       rehash
     }
   end

data/lib/puppet/util/log_paths.rb

@@ -2,9 +2,7 @@ module Puppet::Util::LogPaths
   # return the full path to us, for logging and rollback
   # some classes (e.g., FileTypeRecords) will have to override this
   def path
-    @path ||= pathbuilder
-
-    "/" + @path.join("/")
+    @path ||= '/' + pathbuilder.join('/')
   end
 
   def source_descriptors

data/lib/puppet/util/monkey_patches.rb

@@ -17,13 +17,13 @@ require "yaml"
 require "puppet/util/zaml.rb"
 
 class Symbol
-  def to_zaml(z)
-    z.emit("!ruby/sym ")
-    to_s.to_zaml(z)
-  end
   def <=> (other)
     self.to_s <=> other.to_s
-  end
+  end unless method_defined? '<=>'
+
+  def intern
+    self
+  end unless method_defined? 'intern'
 end
 
 [Object, Exception, Integer, Struct, Date, Time, Range, Regexp, Hash, Array, Float, String, FalseClass, TrueClass, Symbol, NilClass, Class].each { |cls|
@@ -91,6 +91,14 @@ if RUBY_VERSION == '1.8.1' || RUBY_VERSION == '1.8.2'
   }
 end
 
+class Fixnum
+  # Returns the int itself. This method is intended for compatibility to
+  # character constant in Ruby 1.9.  1.8.5 is missing it; add it.
+  def ord
+    self
+  end unless method_defined? 'ord'
+end
+
 class Array
   # Ruby < 1.8.7 doesn't have this method but we use it in tests
   def combination(num)
@@ -109,9 +117,27 @@ end
 
 
 class Symbol
-  def to_proc
-    Proc.new { |*args| args.shift.__send__(self, *args) }
-  end unless method_defined? :to_proc
+  # So, it turns out that one of the biggest memory allocation hot-spots in
+  # our code was using symbol-to-proc - because it allocated a new instance
+  # every time it was called, rather than caching.
+  #
+  # Changing this means we can see XX memory reduction...
+  if method_defined? :to_proc
+    alias __original_to_proc to_proc
+    def to_proc
+      @my_proc ||= __original_to_proc
+    end
+  else
+    def to_proc
+      @my_proc ||= Proc.new {|*args| args.shift.__send__(self, *args) }
+    end
+  end
+
+  # Defined in 1.9, absent in 1.8, and used for compatibility in various
+  # places, typically in third party gems.
+  def intern
+    return self
+  end unless method_defined? :intern
 end
 
 

data/lib/puppet/util/platform.rb

@@ -10,6 +10,13 @@ module Puppet
         !!File::ALT_SEPARATOR
       end
       module_function :windows?
+
+      def default_paths
+        return [] if windows?
+
+        %w{/usr/sbin /sbin}
+      end
+      module_function :default_paths
     end
   end
 end

data/lib/puppet/util/posix.rb

@@ -60,7 +60,7 @@ module Puppet::Util::POSIX
 
   # Determine what the field name is for users and groups.
   def idfield(space)
-    case Puppet::Util.symbolize(space)
+    case space.intern
     when :gr, :group; return :gid
     when :pw, :user, :passwd; return :uid
     else
@@ -70,7 +70,7 @@ module Puppet::Util::POSIX
 
   # Determine what the method is to get users and groups by id
   def methodbyid(space)
-    case Puppet::Util.symbolize(space)
+    case space.intern
     when :gr, :group; return :getgrgid
     when :pw, :user, :passwd; return :getpwuid
     else
@@ -80,7 +80,7 @@ module Puppet::Util::POSIX
 
   # Determine what the method is to get users and groups by name
   def methodbyname(space)
-    case Puppet::Util.symbolize(space)
+    case space.intern
     when :gr, :group; return :getgrnam
     when :pw, :user, :passwd; return :getpwnam
     else

data/lib/puppet/util/provider_features.rb

@@ -25,7 +25,7 @@ module Puppet::Util::ProviderFeatures
     end
 
     def initialize(name, docs, hash)
-      self.name = symbolize(name)
+      self.name = name.intern
       self.docs = docs
       hash = symbolize_options(hash)
       set_options(hash)
@@ -149,8 +149,7 @@ module Puppet::Util::ProviderFeatures
       @feature_module.send(:define_method, :has_features) do |*names|
         @declared_features ||= []
         names.each do |name|
-          name = symbolize(name)
-          @declared_features << name
+          @declared_features << name.intern
         end
       end
       # Aaah, grammatical correctness

data/lib/puppet/util/rdoc.rb

@@ -24,9 +24,10 @@ module Puppet::Util::RDoc
 
       # specify our own format & where to output
       options = [ "--fmt", "puppet",
-        "--quiet",
-        "--exclude", "/modules/[^/]*/files/.*\.pp$",
-        "--op", outputdir ]
+                  "--quiet",
+                  "--exclude", "/modules/[^/]*/files/.*$",
+                  "--exclude", "/modules/[^/]*/templates/.*$",
+                  "--op", outputdir ]
 
       options << "--force-update" if Options::OptionList.options.any? { |o| o[0] == "--force-update" }
       options += [ "--charset", charset] if charset

data/lib/puppet/util/reference.rb

@@ -20,7 +20,7 @@ class Puppet::Util::Reference
 
   def self.newreference(name, options = {}, &block)
     ref = self.new(name, options, &block)
-    instance_hash(:reference)[symbolize(name)] = ref
+    instance_hash(:reference)[name.intern] = ref
 
     ref
   end

data/lib/puppet/util/selinux.rb

@@ -136,6 +136,21 @@ module Puppet::Util::SELinux
     nil
   end
 
+  ########################################################################
+  # Internal helper methods from here on in, kids.  Don't fiddle.
+  private
+
+  # Check filesystem a path resides on for SELinux support against
+  # whitelist of known-good filesystems.
+  # Returns true if the filesystem can support SELinux labels and
+  # false if not.
+  def selinux_label_support?(file)
+    fstype = find_fs(file)
+    return false if fstype.nil?
+    filesystems = ['ext2', 'ext3', 'ext4', 'gfs', 'gfs2', 'xfs', 'jfs']
+    filesystems.include?(fstype)
+  end
+
   # Internal helper function to read and parse /proc/mounts
   def read_mounts
     mounts = ""
@@ -171,46 +186,26 @@ module Puppet::Util::SELinux
     mntpoint
   end
 
-  def realpath(path)
-    path, rest = Pathname.new(path), []
-    path, rest = path.dirname, [path.basename] + rest while ! path.exist?
-    File.join( path.realpath, *rest )
-  end
-
-  def parent_directory(path)
-    Pathname.new(path).dirname.to_s
-  end
-
-  # Internal helper function to return which type of filesystem a
-  # given file path resides on
+  # Internal helper function to return which type of filesystem a given file
+  # path resides on
   def find_fs(path)
-    unless mnts = read_mounts
-      return nil
+    return nil unless mounts = read_mounts
+
+    # cleanpath eliminates useless parts of the path (like '.', or '..', or
+    # multiple slashes), without touching the filesystem, and without
+    # following symbolic links.  This gives the right (logical) tree to follow
+    # while we try and figure out what file-system the target lives on.
+    path = Pathname(path).cleanpath
+    unless path.absolute?
+      raise Puppet::DevError, "got a relative path in SELinux find_fs: #{path}"
     end
 
-    # For a given file:
-    # Check if the filename is in the data structure;
-    #   return the fstype if it is.
-    # Just in case: return something if you're down to "/" or ""
-    # Remove the last slash and everything after it,
-    #   and repeat with that as the file for the next loop through.
-    path = realpath(path)
-    while not path.empty?
-      return mnts[path] if mnts.has_key?(path)
-      path = parent_directory(path)
+    # Now, walk up the tree until we find a match for that path in the hash.
+    path.ascend do |segment|
+      return mounts[segment.to_s] if mounts.has_key?(segment.to_s)
     end
-    mnts['/']
-  end
 
-  # Check filesystem a path resides on for SELinux support against
-  # whitelist of known-good filesystems.
-  # Returns true if the filesystem can support SELinux labels and
-  # false if not.
-  def selinux_label_support?(file)
-    fstype = find_fs(file)
-    return false if fstype.nil?
-    filesystems = ['ext2', 'ext3', 'ext4', 'gfs', 'gfs2', 'xfs', 'jfs']
-    filesystems.include?(fstype)
+    # Should never be reached...
+    return mounts['/']
   end
-
 end