puppet 0.18.4 → 0.22.4

data/lib/puppet/util.rb

@@ -1,14 +1,17 @@
 # A module to collect utility functions.
 
 require 'sync'
-require 'puppet/lock'
+require 'puppet/external/lock'
 
 module Puppet
     # A command failed to execute.
-    class ExecutionFailure < RuntimeError
+    class ExecutionFailure < Puppet::Error
     end
 module Util
     require 'benchmark'
+    
+    require 'puppet/util/posix'
+    extend Puppet::Util::POSIX
 
     # Create a hash to store the different sync objects.
     @@syncresources = {}
@@ -19,98 +22,29 @@ module Util
         return @@syncresources[resource]
     end
 
-    # Execute a block as a given user or group
-    def self.asuser(user = nil, group = nil)
-        require 'etc'
-
-        uid = nil
-        gid = nil
-        olduid = nil
-        oldgid = nil
-
-        # If they're running as a normal user, then just execute as that same
-        # user.
-        unless Process.uid == 0
-            yield
-            return
-        end
-
-        begin
-            # the groupid, if we got passed a group
-            # The gid has to be changed first, because, well, otherwise we won't
-            # be able to
-            if group
-                if group.is_a? Integer
-                    gid = group
-                else
-                    gid = self.gid(group)
-                end
-
-                if gid
-                    if Process.gid != gid
-                        oldgid = Process.gid
-                        begin
-                            Process.egid = gid
-                        rescue => detail
-                            raise Puppet::Error, "Could not change GID: %s" % detail
-                        end
-                    end
-                else
-                    Puppet.warning "Could not retrieve GID for %s" % group
-                end
-            end
-
-            if user
-                if user.is_a? Integer
-                    uid = user
-                else
-                    uid = self.uid(user)
-                end
-                uid = self.uid(user)
-
-                if uid
-                    # Now change the uid
-                    if Process.uid != uid
-                        olduid = Process.uid
-                        begin
-                            Process.euid = uid
-                        rescue => detail
-                            raise Puppet::Error, "Could not change UID: %s" % detail
-                        end
-                    end
-                else
-                    Puppet.warning "Could not retrieve UID for %s" % user
-                end
-            end
-
-            retval = yield
-        ensure
-            if olduid
-                Process.euid = olduid
-            end
-
-            if oldgid
-                Process.egid = oldgid
-            end
-        end
-
-        return retval
-    end
-
     # Change the process to a different user
     def self.chuser
+        if Facter["operatingsystem"].value == "Darwin"
+            $stderr.puts "Ruby on darwin is broken; puppetmaster will not set its UID to 'puppet' and must run as root"
+            return
+        end
         if group = Puppet[:group]
             group = self.gid(group)
             unless group
                 raise Puppet::Error, "No such group %s" % Puppet[:group]
             end
-            unless Process.gid == group
+            unless Puppet::Util::SUIDManager.gid == group
                 begin
-                    Process.egid = group 
-                    Process.gid = group 
-                rescue
-                    $stderr.puts "could not change to group %s" % group
-                    exit(74)
+                    Puppet::Util::SUIDManager.egid = group 
+                    Puppet::Util::SUIDManager.gid = group 
+                rescue => detail
+                    Puppet.warning "could not change to group %s: %s" %
+                        [group.inspect, detail]
+                    $stderr.puts "could not change to group %s" % group.inspect
+
+                    # Don't exit on failed group changes, since it's
+                    # not fatal
+                    #exit(74)
                 end
             end
         end
@@ -120,10 +54,10 @@ module Util
             unless user
                 raise Puppet::Error, "No such user %s" % Puppet[:user]
             end
-            unless Process.uid == user
+            unless Puppet::Util::SUIDManager.uid == user
                 begin
-                    Process.euid = user 
-                    Process.uid = user 
+                    Puppet::Util::SUIDManager.uid = user 
+                    Puppet::Util::SUIDManager.euid = user 
                 rescue
                     $stderr.puts "could not change to user %s" % user
                     exit(74)
@@ -145,6 +79,10 @@ module Util
     # tmp file.
     def self.writelock(file, mode = 0600)
         tmpfile = file + ".tmp"
+        unless FileTest.directory?(File.dirname(tmpfile))
+            raise Puppet::DevError, "Cannot create %s; directory %s does not exist" %
+                [file, File.dirname(file)]
+        end
         self.sync(file).synchronize(Sync::EX) do
             File.open(file, "w", mode) do |rf|
                 rf.lock_exclusive do |lrf|
@@ -162,114 +100,23 @@ module Util
         end
     end
 
-    # Get the GID of a given group, provided either a GID or a name
-    def self.gid(group)
-        if group =~ /^\d+$/
-            group = Integer(group)
-        end
-        unless group
-            raise Puppet::DevError, "Invalid group %s" % group.inspect
-        end
-        gid = nil
-        obj = nil
-
-        # We want to look the group up either way
-        if group.is_a?(Integer) 
-            # If this doesn't find anything
-            obj = Puppet.type(:group).find { |gobj|
-                gobj.should(:gid) == group ||
-                    gobj.is(:gid) == group
-            }
-
-            unless obj
-                begin
-                    gobj = Etc.getgrgid(group)
-                    gid = gobj.gid
-                rescue ArgumentError => detail
-                    # ignore it; we couldn't find the group
-                end
-            end
-        else
-            if obj = Puppet.type(:group)[group]
-                obj[:check] = [:gid]
-            else
-                obj = Puppet.type(:group).create(
-                    :name => group,
-                    :check => [:gid]
-                )
-            end
-            obj.retrieve
-        end
-        if obj
-            gid = obj.should(:gid) || obj.is(:gid)
-            if gid == :absent
-                gid = nil
-            end
-        end
-
-        return gid
-    end
-
-    # Get the UID of a given user, whether a UID or name is provided
-    def self.uid(user)
-        uid = nil
-        if user =~ /^\d+$/
-            user = Integer(user)
-        end
-
-        if user.is_a?(Integer)
-            # If this doesn't find anything
-            obj = Puppet.type(:user).find { |uobj|
-                uobj.should(:uid) == user ||
-                    uobj.is(:uid) == user
-            }
-
-            unless obj
-                begin
-                    uobj = Etc.getpwuid(user)
-                    uid = uobj.uid
-                rescue ArgumentError => detail
-                    # ignore it; we couldn't find the user
-                end
-            end
-        else
-            unless obj = Puppet.type(:user)[user]
-                obj = Puppet.type(:user).create(
-                    :name => user
-                )
-            end
-            obj[:check] = [:uid, :gid]
-        end
-
-        if obj
-            obj.retrieve
-            uid = obj.should(:uid) || obj.is(:uid)
-            if uid == :absent
-                uid = nil
-            end
-        end
-
-        return uid
-    end
-
-
     # Create instance methods for each of the log levels.  This allows
     # the messages to be a little richer.  Most classes will be calling this
     # method.
     def self.logmethods(klass, useself = true)
-        Puppet::Log.eachlevel { |level|
+        Puppet::Util::Log.eachlevel { |level|
             klass.send(:define_method, level, proc { |args|
                 if args.is_a?(Array)
                     args = args.join(" ")
                 end
                 if useself
-                    Puppet::Log.create(
+                    Puppet::Util::Log.create(
                         :level => level,
                         :source => self,
                         :message => args
                     )
                 else
-                    Puppet::Log.create(
+                    Puppet::Util::Log.create(
                         :level => level,
                         :message => args
                     )
@@ -278,6 +125,29 @@ module Util
         }
     end
 
+    # Proxy a bunch of methods to another object.
+    def self.classproxy(klass, objmethod, *methods)
+        classobj = class << klass; self; end
+        methods.each do |method|
+            classobj.send(:define_method, method) do |*args|
+                obj = self.send(objmethod)
+
+                obj.send(method, *args)
+            end
+        end
+    end
+
+    # Proxy a bunch of methods to another object.
+    def self.proxy(klass, objmethod, *methods)
+        methods.each do |method|
+            klass.send(:define_method, method) do |*args|
+                obj = self.send(objmethod)
+
+                obj.send(method, *args)
+            end
+        end
+    end
+
     # XXX this should all be done using puppet objects, not using
     # normal mkdir
     def self.recmkdir(dir,mode = 0755)
@@ -301,15 +171,6 @@ module Util
         end
     end
 
-    def self.symbolize(value)
-        case value
-        when String: value = value.intern
-        when Symbol: value
-        else
-            raise ArgumentError, "'%s' must be a string or symbol" % value
-        end
-    end
-
     # Execute a given chunk of code with a new umask.
     def self.withumask(mask)
         cur = File.umask(mask)
@@ -327,14 +188,17 @@ module Util
         object = nil
 
         if args.empty?
-            object = Puppet
+            if respond_to?(level)
+                object = self
+            else
+                object = Puppet
+            end
         else
             object = args.pop
         end
 
         unless level
-            puts caller.join("\n")
-            raise Puppet::DevError, "Failed to provide level"
+            raise Puppet::DevError, "Failed to provide level to :benchmark"
         end
 
         unless object.respond_to? level
@@ -342,7 +206,7 @@ module Util
         end
 
         # Only benchmark if our log level is high enough
-        if Puppet::Log.sendlevel?(level)
+        if level != :none and Puppet::Util::Log.sendlevel?(level)
             result = nil
             seconds = Benchmark.realtime {
                 yield
@@ -354,14 +218,35 @@ module Util
         end
     end
 
-    # Execute the desired command, and return the status and output.
-    def execute(command, failonfail = true)
+    def binary(bin)
+        if bin =~ /^\//
+            if FileTest.exists? bin
+                return bin
+            else
+                return nil
+            end
+        else
+            ENV['PATH'].split(":").each do |dir|
+                if FileTest.exists? File.join(dir, bin)
+                    return File.join(dir, bin)
+                end
+            end
+            return nil
+        end
+    end
+    module_function :binary
+
+    # Execute the provided command in a pipe, yielding the pipe object.
+    def execpipe(command, failonfail = true)
         if respond_to? :debug
             debug "Executing '%s'" % command
         else
             Puppet.debug "Executing '%s'" % command
         end
-        output = %x{#{command} 2>&1}
+
+        output = open("| #{command} 2>&1") do |pipe|
+            yield pipe
+        end
 
         if failonfail
             unless $? == 0
@@ -372,6 +257,118 @@ module Util
         return output
     end
 
+    def execfail(command, exception)
+        begin
+            output = execute(command)
+            return output
+        rescue ExecutionFailure
+            raise exception, output
+        end
+    end
+
+    # Execute the desired command, and return the status and output.
+    # def execute(command, failonfail = true, uid = nil, gid = nil)
+    def execute(command, arguments = {:failonfail => true})
+        if command.is_a?(Array)
+            command = command.flatten.collect { |i| i.to_s }
+            str = command.join(" ")
+        else
+            # We require an array here so we know where we're incorrectly
+            # using a string instead of an array.  Once everything is
+            # switched to an array, we might relax this requirement.
+            raise ArgumentError, "Must pass an array to execute()"
+        end
+
+        if respond_to? :debug
+            debug "Executing '%s'" % str
+        else
+            Puppet.debug "Executing '%s'" % str
+        end
+        
+        if arguments[:uid]
+            arguments[:uid] = Puppet::Util::SUIDManager.convert_xid(:uid, arguments[:uid])
+        end
+        if arguments[:gid]
+            arguments[:gid] = Puppet::Util::SUIDManager.convert_xid(:gid, arguments[:gid])
+        end
+        
+        @@os ||= Facter.value(:operatingsystem)
+        output = nil
+        child_pid, child_status = nil
+        # The idea here is to avoid IO#read whenever possible.
+        if arguments[:squelch]
+            child_pid = Kernel.fork
+            if child_pid
+                # Parent process executes this
+                child_status = Process.waitpid2(child_pid)[1]
+            else
+                # Child process executes this
+                begin
+                    $stdin.reopen("/dev/null")
+                    $stdout.reopen("/dev/null")
+                    $stderr.reopen("/dev/null")
+                    if arguments[:gid]
+                        Process.egid = arguments[:gid]
+                        Process.gid = arguments[:gid] unless @@os == "Darwin"
+                    end
+                    if arguments[:uid]
+                        Process.euid = arguments[:uid]
+                        Process.uid = arguments[:uid] unless @@os == "Darwin"
+                    end
+                    if command.is_a?(Array)
+                        Kernel.exec(*command)
+                    else
+                        Kernel.exec(command)
+                    end
+                rescue => detail
+                    puts detail.to_s
+                    exit!(1)
+                end # begin; rescue
+            end # if child_pid; else
+        else
+            IO.popen("-") do |f|
+                if f
+                    # Parent process executes this
+                    output = f.read
+                else
+                    # Parent process executes this
+                    begin
+                        $stdin.reopen("/dev/null")
+                        $stderr.close
+                        $stderr = $stdout.dup
+                        if arguments[:gid]
+                            Process.egid = arguments[:gid]
+                            Process.gid = arguments[:gid] unless @@os == "Darwin"
+                        end
+                        if arguments[:uid]
+                            Process.euid = arguments[:uid]
+                            Process.uid = arguments[:uid] unless @@os == "Darwin"
+                        end
+                        if command.is_a?(Array)
+                            Kernel.exec(*command)
+                        else
+                            Kernel.exec(command)
+                        end
+                    rescue => detail
+                        puts detail.to_s
+                        exit!(1)
+                    end # begin; rescue
+                end # if f; else
+            end # IO.popen do |f|
+            child_status = $?
+        end # if arguments[:squelch]; else
+
+        if arguments[:failonfail]
+            unless child_status == 0
+                raise ExecutionFailure, "Execution of '%s' returned %s: %s" % [str, child_status.inspect, output]
+            end
+        end
+
+        return output
+    end
+
+    module_function :execute
+
     # Create an exclusive lock.
     def threadlock(resource, type = Sync::EX)
         Puppet::Util.sync(resource).synchronize(type) do
@@ -400,6 +397,37 @@ module Util
         end
     end
 
+    def symbolize(value)
+        if value.respond_to? :intern
+            value.intern
+        else
+            value
+        end
+    end
+
+    def symbolizehash(hash)
+        newhash = {}
+        hash.each do |name, val|
+            if name.is_a? String
+                newhash[name.intern] = val
+            else
+                newhash[name] = val
+            end
+        end
+    end
+
+    def symbolizehash!(hash)
+        hash.each do |name, val|
+            if name.is_a? String
+                hash[name.intern] = val
+                hash.delete(name)
+            end
+        end
+
+        return hash
+    end
+    module_function :symbolize, :symbolizehash, :symbolizehash!
+
     # Just benchmark, with no logging.
     def thinmark
         seconds = Benchmark.realtime {
@@ -409,8 +437,18 @@ module Util
         return seconds
     end
 
-    module_function :memory
+    module_function :memory, :thinmark
 end
 end
 
-# $Id: util.rb 1346 2006-06-30 20:41:41Z luke $
+require 'puppet/util/errors'
+require 'puppet/util/methodhelper'
+require 'puppet/util/metaid'
+require 'puppet/util/classgen'
+require 'puppet/util/docs'
+require 'puppet/util/execution'
+require 'puppet/util/logging'
+require 'puppet/util/package'
+require 'puppet/util/warnings'
+
+# $Id: util.rb 2427 2007-04-27 23:25:59Z luke $