puppet 0.22.4 → 0.23.0

data/lib/puppet/util.rb

@@ -295,72 +295,57 @@ module Util
         @@os ||= Facter.value(:operatingsystem)
         output = nil
         child_pid, child_status = nil
+        # There are problems with read blocking with badly behaved children
+        # read.partialread doesn't seem to capture either stdout or stderr
+        # We hack around this using a temporary file
+
         # 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
+        output_file="/dev/null"
+        if ! arguments[:squelch]
+            require "tempfile"
+            output_file = Tempfile.new("puppet")
+        end
+
+        child_pid = Kernel.fork
+        if child_pid
+            # Parent process executes this
+            child_status = Process.waitpid2(child_pid)[1]
         else
-            IO.popen("-") do |f|
-                if f
-                    # Parent process executes this
-                    output = f.read
+            # Child process executes this
+            begin
+                $stdin.reopen("/dev/null")
+                $stdout.reopen(output_file)
+                $stderr.reopen(output_file)
+                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
+                ENV['LANG'] = ENV['LC_ALL'] = ENV['LC_MESSAGES'] = ENV['LANGUAGE'] = 'C'
+                if command.is_a?(Array)
+                    Kernel.exec(*command)
                 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
+                    Kernel.exec(command)
+                end
+            rescue => detail
+                puts detail.to_s
+                exit!(1)
+            end # begin; rescue
+        end # if child_pid
+ 	
+        # read output in if required
+        if ! arguments[:squelch]
+            output = output_file.open.read
+            output_file.close
+            output_file.delete
+        end
 
         if arguments[:failonfail]
             unless child_status == 0
-                raise ExecutionFailure, "Execution of '%s' returned %s: %s" % [str, child_status.inspect, output]
+                raise ExecutionFailure, "Execution of '%s' returned %s: %s" % [str, child_status, output]
             end
         end
 
@@ -451,4 +436,4 @@ require 'puppet/util/logging'
 require 'puppet/util/package'
 require 'puppet/util/warnings'
 
-# $Id: util.rb 2427 2007-04-27 23:25:59Z luke $
+# $Id: util.rb 2605 2007-06-18 18:13:23Z luke $

data/lib/puppet/util/autoload.rb

@@ -18,14 +18,11 @@ class Puppet::Util::Autoload
 
     Puppet::Util.proxy self, :loaded, :clear
 
-    def handle_libdir
-        dir = Puppet[:libdir]
-
-        $: << dir unless $:.include?(dir)
-    end
-
     def initialize(obj, path, options = {})
         @path = path.to_s
+        if @path !~ /^\w/
+            raise ArgumentError, "Autoload paths cannot be fully qualified"
+        end
         @object = obj
 
         self.class[obj] = self
@@ -46,62 +43,77 @@ class Puppet::Util::Autoload
         @loaded = {}
     end
 
+    # Load a single plugin by name.
     def load(name)
-        name = symbolize(name)
-        handle_libdir()
-
-        path = File.join(@path, name.to_s + ".rb")
-
-        begin
-            Kernel.load path, @wrap
-            @loaded[name] = true
-            return true
-        rescue LoadError => detail
-            # I have no idea what's going on here, but different versions
-            # of ruby are raising different errors on missing files.
-            unless detail.to_s =~ /^no such file/i
-                warn "Could not autoload %s: %s" % [name, detail]
-                if Puppet[:trace]
-                    puts detail.backtrace
+        path = name.to_s + ".rb"
+
+        eachdir do |dir|
+            file = File.join(dir, path)
+            next unless FileTest.exists?(file)
+            begin
+                Kernel.load file, @wrap
+                name = symbolize(name)
+                @loaded[name] = true
+                return true
+            rescue LoadError => detail
+                # I have no idea what's going on here, but different versions
+                # of ruby are raising different errors on missing files.
+                unless detail.to_s =~ /^no such file/i
+                    warn "Could not autoload %s: %s" % [name, detail]
+                    if Puppet[:trace]
+                        puts detail.backtrace
+                    end
                 end
+                return false
             end
-            return false
         end
+        return false
     end
 
+    # Indicate whether the specfied plugin has been loaded.
     def loaded?(name)
-        name = symbolize(name)
-        @loaded[name]
+        @loaded[symbolize(name)]
     end
 
     def loadall
-        handle_libdir()
         # Load every instance of everything we can find.
-        $:.each do |dir|
-            fdir = File.join(dir, @path)
-            if FileTest.exists?(fdir) and FileTest.directory?(fdir)
-                Dir.glob("#{fdir}/*.rb").each do |file|
-                    # Load here, rather than require, so that facts
-                    # can be reloaded.  This has some short-comings, I
-                    # believe, but it works as long as real classes
-                    # aren't used.
-                    name = File.basename(file).sub(".rb", '').intern
-                    next if @loaded.include? name
-                    next if $".include?(File.join(@path, name.to_s + ".rb"))
-                    filepath = File.join(@path, name.to_s + ".rb")
-                    begin
-                        Kernel.require filepath
-                        @loaded[name] = true
-                    rescue => detail
-                        if Puppet[:trace]
-                            puts detail.backtrace
-                        end
-                        warn "Could not autoload %s: %s" % [file.inspect, detail]
+        eachdir do |dir|
+            Dir.glob("#{dir}/*.rb").each do |file|
+                # Load here, rather than require, so that facts
+                # can be reloaded.  This has some short-comings, I
+                # believe, but it works as long as real classes
+                # aren't used.
+                name = File.basename(file).sub(".rb", '').intern
+                next if @loaded.include? name
+                next if $".include?(File.join(@path, name.to_s + ".rb"))
+                filepath = File.join(@path, name.to_s + ".rb")
+                begin
+                    Kernel.require filepath
+                    @loaded[name] = true
+                rescue => detail
+                    if Puppet[:trace]
+                        puts detail.backtrace
                     end
+                    warn "Could not autoload %s: %s" % [file.inspect, detail]
                 end
             end
         end
     end
+
+    private
+
+    # Yield each subdir in turn.
+    def eachdir
+        searchpath.each do |dir|
+            subdir = File.join(dir, @path)
+            yield subdir if FileTest.directory?(subdir)
+        end
+    end
+
+    # The list of directories to search through for loadable plugins.
+    def searchpath
+        [Puppet[:libdir], $:].flatten
+    end
 end
 
-# $Id: autoload.rb 2178 2007-02-07 23:56:59Z luke $
+# $Id: autoload.rb 2518 2007-05-16 00:00:47Z luke $

data/lib/puppet/util/config.rb

@@ -167,7 +167,7 @@ class Puppet::Util::Config
 
     # Handle a command-line argument.
     def handlearg(opt, value = nil)
-        value = mungearg(value) if value
+        value = munge_value(value) if value
         str = opt.sub(/^--/,'')
         bool = true
         newstr = str.sub(/^no-/, '')
@@ -221,18 +221,6 @@ class Puppet::Util::Config
         end
     end
 
-    # Convert arguments appropriately.
-    def mungearg(value)
-        # Handle different data types correctly
-        return case value
-            when /^false$/i: false
-            when /^true$/i: true
-            when /^\d+$/i: Integer(value)
-            else
-                value.gsub(/^["']|["']$/,'').sub(/\s+$/, '')
-        end
-    end
-
     # Return all of the parameters associated with a given section.
     def params(section)
         section = section.intern if section.is_a? String
@@ -243,8 +231,24 @@ class Puppet::Util::Config
         }
     end
 
-    # Parse a configuration file.
+    # Parse the configuration file.
     def parse(file)
+        configmap = parse_file(file)
+
+        # We know we want the 'main' section
+        if main = configmap[:main]
+            set_parameter_hash(main)
+        end
+
+        # Otherwise, we only want our named section
+        if @config.include?(:name) and named = configmap[symbolize(self[:name])]
+            set_parameter_hash(named)
+        end
+    end
+
+    # Parse the configuration file.  As of May 2007, this is a backward-compatibility method and
+    # will be deprecated soon.
+    def old_parse(file)
         text = nil
 
         if file.is_a? Puppet::Util::LoadedFile
@@ -253,8 +257,8 @@ class Puppet::Util::Config
             @file = Puppet::Util::LoadedFile.new(file)
         end
 
-        # Create a timer so that this.
-        settimer()
+        # Don't create a timer for the old style parsing.
+        # settimer()
 
         begin
             text = File.read(@file.file)
@@ -284,7 +288,7 @@ class Puppet::Util::Config
                 if var == :mode
                     value = $2
                 else
-                    value = mungearg($2)
+                    value = munge_value($2)
                 end
 
                 # Only warn if we don't know what this config var is.  This
@@ -706,6 +710,144 @@ Generated on #{Time.now}.
         end
     end
 
+    private
+
+    # Extra extra setting information for files.
+    def extract_fileinfo(string)
+        paramregex = %r{(\w+)\s*=\s*([\w\d]+)}
+        result = {}
+        string.scan(/\{\s*([^}]+)\s*\}/) do
+            params = $1
+            params.split(/\s*,\s*/).each do |str|
+                if str =~ /^\s*(\w+)\s*=\s*([\w\w]+)\s*$/
+                    param, value = $1.intern, $2
+                    result[param] = value
+                    unless [:owner, :mode, :group].include?(param)
+                        raise Puppet::Error, "Invalid file option '%s'" % param
+                    end
+
+                    if param == :mode and value !~ /^\d+$/
+                        raise Puppet::Error, "File modes must be numbers"
+                    end
+                else
+                    raise Puppet::Error, "Could not parse '%s'" % string
+                end
+            end
+
+            return result
+        end
+
+        return nil
+    end
+
+    # Convert arguments into booleans, integers, or whatever.
+    def munge_value(value)
+        # Handle different data types correctly
+        return case value
+            when /^false$/i: false
+            when /^true$/i: true
+            when /^\d+$/i: Integer(value)
+            else
+                value.gsub(/^["']|["']$/,'').sub(/\s+$/, '')
+        end
+    end
+
+    # This is an abstract method that just turns a file in to a hash of hashes.
+    # We mostly need this for backward compatibility -- as of May 2007 we need to
+    # support parsing old files with any section, or new files with just two
+    # valid sections.
+    def parse_file(file)
+        text = nil
+
+        if file.is_a? Puppet::Util::LoadedFile
+            @file = file
+        else
+            @file = Puppet::Util::LoadedFile.new(file)
+        end
+
+        # Create a timer so that this file will get checked automatically
+        # and reparsed if necessary.
+        settimer()
+
+        begin
+            text = File.read(@file.file)
+        rescue Errno::ENOENT
+            raise Puppet::Error, "No such file %s" % file
+        rescue Errno::EACCES
+            raise Puppet::Error, "Permission denied to file %s" % file
+        end
+
+        result = Hash.new { |names, name|
+            names[name] = {}
+        }
+
+        count = 0
+
+        # Default to 'main' for the section.
+        section = :main
+        result[section][:_meta] = {}
+        text.split(/\n/).each { |line|
+            count += 1
+            case line
+            when /^\[(\w+)\]$/:
+                section = $1.intern # Section names
+                # Add a meta section
+                result[section][:_meta] ||= {}
+            when /^\s*#/: next # Skip comments
+            when /^\s*$/: next # Skip blanks
+            when /^\s*(\w+)\s*=\s*(.+)$/: # settings
+                var = $1.intern
+
+                # We don't want to munge modes, because they're specified in octal, so we'll
+                # just leave them as a String, since Puppet handles that case correctly.
+                if var == :mode
+                    value = $2
+                else
+                    value = munge_value($2)
+                end
+
+                # Check to see if this is a file argument and it has extra options
+                begin
+                    if value.is_a?(String) and options = extract_fileinfo(value)
+                        result[section][:_meta][var] = options
+                    end
+                    result[section][var] = value
+                rescue Puppet::Error => detail
+                    detail.file = file
+                    detail.line = line
+                    raise
+                end
+            else
+                error = Puppet::Error.new("Could not match line %s" % line)
+                error.file = file
+                error.line = line
+                raise error
+            end
+        }
+
+        return result
+    end
+
+    # Take all members of a hash and assign their values appropriately.
+    def set_parameter_hash(params)
+        params.each do |param, value|
+            next if param == :_meta
+            unless @config.include?(param)
+                Puppet.warning "Discarded unknown configuration parameter %s" % param
+                next
+            end
+            self[param] = value
+        end
+
+        if meta = params[:_meta]
+            meta.each do |var, values|
+                values.each do |param, value|
+                    @config[var].send(param.to_s + "=", value)
+                end
+            end
+        end
+    end
+
     # The base element type.
     class CElement
         attr_accessor :name, :section, :default, :parent, :setbycli
@@ -964,4 +1106,4 @@ Generated on #{Time.now}.
     end
 end
 
-# $Id: config.rb 2272 2007-03-08 17:07:35Z luke $
+# $Id: config.rb 2464 2007-05-06 05:42:53Z luke $