puppet 0.25.5 → 2.6.0

data/lib/puppet/util/storage.rb

@@ -5,103 +5,92 @@ require 'puppet/util/file_locking'
 
 # a class for storing state
 class Puppet::Util::Storage
-    include Singleton
-    include Puppet::Util
-
-    def self.state
-        return @@state
+  include Singleton
+  include Puppet::Util
+
+  def self.state
+    @@state
+  end
+
+  def initialize
+    self.class.load
+  end
+
+  # Return a hash that will be stored to disk.  It's worth noting
+  # here that we use the object's full path, not just the name/type
+  # combination.  At the least, this is useful for those non-isomorphic
+  # types like exec, but it also means that if an object changes locations
+  # in the configuration it will lose its cache.
+  def self.cache(object)
+    if object.is_a?(Symbol)
+      name = object
+    else
+      name = object.to_s
     end
 
-    def initialize
-        self.class.load
-    end
+    @@state[name] ||= {}
+  end
 
-    # Return a hash that will be stored to disk.  It's worth noting
-    # here that we use the object's full path, not just the name/type
-    # combination.  At the least, this is useful for those non-isomorphic
-    # types like exec, but it also means that if an object changes locations
-    # in the configuration it will lose its cache.
-    def self.cache(object)
-        if object.is_a? Puppet::Type
-            # We used to store things by path, now we store them by ref.
-            # In oscar(0.20.0) this changed to using the ref.
-            if @@state.include?(object.path)
-                @@state[object.ref] = @@state[object.path]
-                @@state.delete(object.path)
-            end
-            name = object.ref
-        elsif object.is_a?(Symbol)
-            name = object
-        else
-            raise ArgumentError, "You can only cache information for Types and symbols"
-        end
-
-        return @@state[name] ||= {}
-    end
-
-    def self.clear
-        @@state.clear
-        Storage.init
-    end
-
-    def self.init
-        @@state = {}
-        @@splitchar = "\t"
-    end
+  def self.clear
+    @@state.clear
+    Storage.init
+  end
 
-    self.init
+  def self.init
+    @@state = {}
+    @@splitchar = "\t"
+  end
 
-    def self.load
-        Puppet.settings.use(:main) unless FileTest.directory?(Puppet[:statedir])
+  self.init
 
-        unless File.exists?(Puppet[:statefile])
-            unless defined? @@state and ! @@state.nil?
-                self.init
-            end
-            return
-        end
-        Puppet::Util.benchmark(:debug, "Loaded state") do
-            Puppet::Util::FileLocking.readlock(Puppet[:statefile]) do |file|
-                begin
-                    @@state = YAML.load(file)
-                rescue => detail
-                    Puppet.err "Checksumfile %s is corrupt (%s); replacing" %
-                        [Puppet[:statefile], detail]
-                    begin
-                        File.rename(Puppet[:statefile],
-                            Puppet[:statefile] + ".bad")
-                    rescue
-                        raise Puppet::Error,
-                            "Could not rename corrupt %s; remove manually" %
-                            Puppet[:statefile]
-                    end
-                end
-            end
-        end
+  def self.load
+    Puppet.settings.use(:main) unless FileTest.directory?(Puppet[:statedir])
 
-        unless @@state.is_a?(Hash)
-            Puppet.err "State got corrupted"
-            self.init
+    unless File.exists?(Puppet[:statefile])
+      self.init unless !@@state.nil?
+      return
+    end
+    unless File.file?(Puppet[:statefile])
+      Puppet.warning("Checksumfile #{Puppet[:statefile]} is not a file, ignoring")
+      return
+    end
+    Puppet::Util.benchmark(:debug, "Loaded state") do
+      Puppet::Util::FileLocking.readlock(Puppet[:statefile]) do |file|
+        begin
+          @@state = YAML.load(file)
+        rescue => detail
+          Puppet.err "Checksumfile #{Puppet[:statefile]} is corrupt (#{detail}); replacing"
+          begin
+            File.rename(Puppet[:statefile], Puppet[:statefile] + ".bad")
+          rescue
+            raise Puppet::Error,
+              "Could not rename corrupt #{Puppet[:statefile]}; remove manually"
+          end
         end
-
-        #Puppet.debug "Loaded state is %s" % @@state.inspect
+      end
     end
 
-    def self.stateinspect
-        @@state.inspect
+    unless @@state.is_a?(Hash)
+      Puppet.err "State got corrupted"
+      self.init
     end
 
-    def self.store
-        Puppet.debug "Storing state"
+    #Puppet.debug "Loaded state is #{@@state.inspect}"
+  end
 
-        unless FileTest.exist?(Puppet[:statefile])
-            Puppet.info "Creating state file %s" % Puppet[:statefile]
-        end
+  def self.stateinspect
+    @@state.inspect
+  end
 
-        Puppet::Util.benchmark(:debug, "Stored state") do
-            Puppet::Util::FileLocking.writelock(Puppet[:statefile], 0660) do |file|
-                file.print YAML.dump(@@state)
-            end
-        end
+  def self.store
+    Puppet.debug "Storing state"
+
+    Puppet.info "Creating state file #{Puppet[:statefile]}" unless FileTest.exist?(Puppet[:statefile])
+
+    Puppet::Util.benchmark(:debug, "Stored state") do
+      Puppet::Util::FileLocking.writelock(Puppet[:statefile], 0660) do |file|
+        file.print YAML.dump(@@state)
+      end
     end
+  end
 end

data/lib/puppet/util/subclass_loader.rb

@@ -4,86 +4,79 @@
 #
 # This module is currently used by network handlers and clients.
 module Puppet::Util::SubclassLoader
-    attr_accessor :loader, :classloader
+  attr_accessor :loader, :classloader
 
-    # Iterate over each of the subclasses.
-    def each
-        @subclasses ||= []
-        @subclasses.each { |c| yield c }
-    end
+  # Iterate over each of the subclasses.
+  def each
+    @subclasses ||= []
+    @subclasses.each { |c| yield c }
+  end
+
+  # The hook method that sets up subclass loading.  We need the name
+  # of the method to create and the path in which to look for them.
+  def handle_subclasses(name, path)
+    raise ArgumentError, "Must be a class to use SubclassLoader" unless self.is_a?(Class)
+    @subclasses = []
 
-    # The hook method that sets up subclass loading.  We need the name
-    # of the method to create and the path in which to look for them.
-    def handle_subclasses(name, path)
-        unless self.is_a?(Class)
-            raise ArgumentError, "Must be a class to use SubclassLoader"
-        end
-        @subclasses = []
-        @loader = Puppet::Util::Autoload.new(self,
-            path, :wrap => false
-        )
+          @loader = Puppet::Util::Autoload.new(
+        self,
+        
+      path, :wrap => false
+    )
 
-        @subclassname = name
+    @subclassname = name
 
-        @classloader = self
+    @classloader = self
 
-        # Now create a method for retrieving these subclasses by name.  Note
-        # that we're defining a class method here, not an instance.
-        meta_def(name) do |subname|
-            subname = subname.to_s.downcase
+    # Now create a method for retrieving these subclasses by name.  Note
+    # that we're defining a class method here, not an instance.
+    meta_def(name) do |subname|
+      subname = subname.to_s.downcase
 
-            unless c = @subclasses.find { |c| c.name.to_s.downcase == subname }
-                loader.load(subname)
-                c = @subclasses.find { |c| c.name.to_s.downcase == subname }
+      unless c = @subclasses.find { |c| c.name.to_s.downcase == subname }
+        loader.load(subname)
+        c = @subclasses.find { |c| c.name.to_s.downcase == subname }
 
-                # Now make the method that returns this subclass.  This way we
-                # normally avoid the method_missing method.
-                if c and ! respond_to?(subname)
-                    define_method(subname) { c }
-                end
-            end
-            return c
-        end
+        # Now make the method that returns this subclass.  This way we
+        # normally avoid the method_missing method.
+        define_method(subname) { c } if c and ! respond_to?(subname)
+      end
+      return c
     end
+  end
 
-    # Add a new class to our list.  Note that this has to handle subclasses of
-    # subclasses, thus the reason we're keeping track of the @@classloader.
-    def inherited(sub)
-        @subclasses ||= []
-        sub.classloader = self.classloader
-        if self.classloader == self
-            @subclasses << sub
-        else
-            @classloader.inherited(sub)
-        end
+  # Add a new class to our list.  Note that this has to handle subclasses of
+  # subclasses, thus the reason we're keeping track of the @@classloader.
+  def inherited(sub)
+    @subclasses ||= []
+    sub.classloader = self.classloader
+    if self.classloader == self
+      @subclasses << sub
+    else
+      @classloader.inherited(sub)
     end
+  end
 
-    # See if we can load a class.
-    def method_missing(method, *args)
-        unless self == self.classloader
-            super
-        end
-        return nil unless defined? @subclassname
-        if c = self.send(@subclassname, method)
-            return c
-        else
-            return nil
-        end
+  # See if we can load a class.
+  def method_missing(method, *args)
+    unless self == self.classloader
+      super
     end
+    return nil unless defined?(@subclassname)
+    self.send(@subclassname, method) || nil
+  end
 
-    # Retrieve or calculate a name.
-    def name(dummy_argument=:work_arround_for_ruby_GC_bug)
-        unless defined? @name
-            @name = self.to_s.sub(/.+::/, '').intern
-        end
+  # Retrieve or calculate a name.
+  def name(dummy_argument=:work_arround_for_ruby_GC_bug)
+    @name ||= self.to_s.sub(/.+::/, '').intern
 
-        return @name
-    end
+    @name
+  end
 
-    # Provide a list of all subclasses.
-    def subclasses
-        @loader.loadall
-        @subclasses.collect { |klass| klass.name }
-    end
+  # Provide a list of all subclasses.
+  def subclasses
+    @loader.loadall
+    @subclasses.collect { |klass| klass.name }
+  end
 end
 

data/lib/puppet/util/suidmanager.rb

@@ -2,102 +2,105 @@ require 'puppet/util/warnings'
 require 'forwardable'
 
 module Puppet::Util::SUIDManager
-    include Puppet::Util::Warnings
-    extend Forwardable
+  include Puppet::Util::Warnings
+  extend Forwardable
 
-    # Note groups= is handled specially due to a bug in OS X 10.6
-    to_delegate_to_process = [ :euid=, :euid, :egid=, :egid,
-                               :uid=, :uid, :gid=, :gid, :groups ]
+  # Note groups= is handled specially due to a bug in OS X 10.6
+  to_delegate_to_process = [ :euid=, :euid, :egid=, :egid, :uid=, :uid, :gid=, :gid, :groups ]
 
-    to_delegate_to_process.each do |method|
-        def_delegator Process, method
-        module_function method
-    end
+  to_delegate_to_process.each do |method|
+    def_delegator Process, method
+    module_function method
+  end
 
-    def osx_maj_ver
-        return @osx_maj_ver unless @osx_maj_ver.nil?
-        require 'facter'
-        # 'kernel' is available without explicitly loading all facts
-        if Facter.value('kernel') != 'Darwin'
-          @osx_maj_ver = false
-          return @osx_maj_ver
-        end
-        # But 'macosx_productversion_major' requires it.
-        Facter.loadfacts
-        @osx_maj_ver = Facter.value('macosx_productversion_major')
-        return @osx_maj_ver
-    end
-    module_function :osx_maj_ver
-    
-    def groups=(grouplist)
-        if osx_maj_ver == '10.6'
-            return true
-        else
-            return Process.groups = grouplist
-        end
+  def osx_maj_ver
+    return @osx_maj_ver unless @osx_maj_ver.nil?
+    require 'facter'
+    # 'kernel' is available without explicitly loading all facts
+    if Facter.value('kernel') != 'Darwin'
+      @osx_maj_ver = false
+      return @osx_maj_ver
     end
-    module_function :groups=
+    # But 'macosx_productversion_major' requires it.
+    Facter.loadfacts
+    @osx_maj_ver = Facter.value('macosx_productversion_major')
+  end
+  module_function :osx_maj_ver
 
-    if Facter['kernel'].value == 'Darwin'
-        # Cannot change real UID on Darwin so we set euid
-        alias :uid :euid
-        alias :gid :egid
+  def groups=(grouplist)
+    if osx_maj_ver == '10.6'
+      return true
+    else
+      return Process.groups = grouplist
     end
+  end
+  module_function :groups=
 
-    # Runs block setting uid and gid if provided then restoring original ids
-    def asuser(new_uid=nil, new_gid=nil)
-        return yield unless Process.uid == 0
-        # We set both because some programs like to drop privs, i.e. bash.
-        old_uid, old_gid = self.uid, self.gid
-        old_euid, old_egid = self.euid, self.egid
-        old_groups = self.groups
-        begin
-            self.egid = convert_xid :gid, new_gid if new_gid
-            self.initgroups(convert_xid(:uid, new_uid)) if new_uid
-            self.euid = convert_xid :uid, new_uid if new_uid
-
-            yield
-        ensure
-            self.euid, self.egid = old_euid, old_egid
-            self.groups = old_groups
-        end
-    end
-    module_function :asuser
-
-    # Make sure the passed argument is a number.
-    def convert_xid(type, id)
-        map = {:gid => :group, :uid => :user}
-        raise ArgumentError, "Invalid id type %s" % type unless map.include?(type)
-        ret = Puppet::Util.send(type, id)
-        if ret == nil
-          raise Puppet::Error, "Invalid %s: %s" % [map[type], id]
-        end
-        return ret
+  if Facter['kernel'].value == 'Darwin'
+    # Cannot change real UID on Darwin so we set euid
+    alias :uid :euid
+    alias :gid :egid
+  end
+
+  def self.root?
+    Process.uid == 0
+  end
+
+  # Runs block setting uid and gid if provided then restoring original ids
+  def asuser(new_uid=nil, new_gid=nil)
+    return yield if Puppet.features.microsoft_windows? or !root?
+
+    # We set both because some programs like to drop privs, i.e. bash.
+    old_uid, old_gid = self.uid, self.gid
+    old_euid, old_egid = self.euid, self.egid
+    old_groups = self.groups
+    begin
+      self.egid = convert_xid :gid, new_gid if new_gid
+      self.initgroups(convert_xid(:uid, new_uid)) if new_uid
+      self.euid = convert_xid :uid, new_uid if new_uid
+
+      yield
+    ensure
+      self.euid, self.egid = old_euid, old_egid
+      self.groups = old_groups
     end
-    module_function :convert_xid
+  end
+  module_function :asuser
 
-    # Initialize supplementary groups
-    def initgroups(user)
-        require 'etc'
-        Process.initgroups(Etc.getpwuid(user).name, Process.gid)
+  # Make sure the passed argument is a number.
+  def convert_xid(type, id)
+    map = {:gid => :group, :uid => :user}
+    raise ArgumentError, "Invalid id type #{type}" unless map.include?(type)
+    ret = Puppet::Util.send(type, id)
+    if ret == nil
+      raise Puppet::Error, "Invalid #{map[type]}: #{id}"
     end
+    ret
+  end
+  module_function :convert_xid
 
-    module_function :initgroups
+  # Initialize supplementary groups
+  def initgroups(user)
+    require 'etc'
+    Process.initgroups(Etc.getpwuid(user).name, Process.gid)
+  end
 
-    def run_and_capture(command, new_uid=nil, new_gid=nil)
-        output = Puppet::Util.execute(command, :failonfail => false, :uid => new_uid, :gid => new_gid)
-        [output, $?.dup]
-    end
-    module_function :run_and_capture
-
-    def system(command, new_uid=nil, new_gid=nil)
-        status = nil
-        asuser(new_uid, new_gid) do
-            Kernel.system(command)
-            status = $?.dup
-        end
-        status
+  module_function :initgroups
+
+  def run_and_capture(command, new_uid=nil, new_gid=nil)
+    output = Puppet::Util.execute(command, :failonfail => false, :uid => new_uid, :gid => new_gid)
+    [output, $CHILD_STATUS.dup]
+  end
+  module_function :run_and_capture
+
+  def system(command, new_uid=nil, new_gid=nil)
+    status = nil
+    asuser(new_uid, new_gid) do
+      Kernel.system(command)
+      status = $CHILD_STATUS.dup
     end
-    module_function :system
+    status
+  end
+  module_function :system
 end