puppet 0.18.4 → 0.22.4

data/lib/puppet/util/autoload.rb

@@ -0,0 +1,107 @@
+# Autoload paths, either based on names or all at once.
+class Puppet::Util::Autoload
+    include Puppet::Util
+
+    @autoloaders = {}
+
+    attr_accessor :object, :path, :objwarn, :wrap
+
+
+    class << self
+        attr_reader :autoloaders
+        private :autoloaders
+    end
+    Puppet::Util.classproxy self, :autoloaders, "[]", "[]=", :clear
+
+    attr_reader :loaded
+    private :loaded
+
+    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
+        @object = obj
+
+        self.class[obj] = self
+
+        options.each do |opt, value|
+            opt = opt.intern if opt.is_a? String
+            begin
+                self.send(opt.to_s + "=", value)
+            rescue NoMethodError
+                raise ArgumentError, "%s is not a valid option" % opt
+            end
+        end
+
+        unless defined? @wrap
+            @wrap = true
+        end
+
+        @loaded = {}
+    end
+
+    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
+                end
+            end
+            return false
+        end
+    end
+
+    def loaded?(name)
+        name = symbolize(name)
+        @loaded[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]
+                    end
+                end
+            end
+        end
+    end
+end
+
+# $Id: autoload.rb 2178 2007-02-07 23:56:59Z luke $

data/lib/puppet/util/classgen.rb

@@ -0,0 +1,208 @@
+module Puppet
+    class ConstantAlreadyDefined < Error; end
+    class SubclassAlreadyDefined < Error; end
+end
+
+module Puppet::Util::ClassGen
+    include Puppet::Util::MethodHelper
+    include Puppet::Util
+
+    # Create a new subclass.  Valid options are:
+    # * <tt>:array</tt>: An array of existing classes.  If specified, the new
+    #   class is added to this array.
+    # * <tt>:attributes</tt>: A hash of attributes to set before the block is
+    #   evaluated.
+    # * <tt>:block</tt>: The block to evaluate in the context of the class.
+    #   You can also just pass the block normally, but it will still be evaluated
+    #   with <tt>class_eval</tt>.
+    # * <tt>:constant</tt>: What to set the constant as.  Defaults to the
+    #   capitalized name.
+    # * <tt>:hash</tt>: A hash of existing classes.  If specified, the new
+    #   class is added to this hash, and it is also used for overwrite tests.
+    # * <tt>:overwrite</tt>: Whether to overwrite an existing class.
+    # * <tt>:parent</tt>: The parent class for the generated class.  Defaults to
+    #   self.
+    # * <tt>:prefix</tt>: The constant prefix.  Default to nothing; if specified,
+    #   the capitalized name is appended and the result is set as the constant.
+    def genclass(name, options = {}, &block)
+        genthing(name, Class, options, block)
+    end
+
+    # Create a new module.  Valid options are:
+    # * <tt>:array</tt>: An array of existing classes.  If specified, the new
+    #   class is added to this array.
+    # * <tt>:attributes</tt>: A hash of attributes to set before the block is
+    #   evaluated.
+    # * <tt>:block</tt>: The block to evaluate in the context of the class.
+    #   You can also just pass the block normally, but it will still be evaluated
+    #   with <tt>class_eval</tt>.
+    # * <tt>:constant</tt>: What to set the constant as.  Defaults to the
+    #   capitalized name.
+    # * <tt>:hash</tt>: A hash of existing classes.  If specified, the new
+    #   class is added to this hash, and it is also used for overwrite tests.
+    # * <tt>:overwrite</tt>: Whether to overwrite an existing class.
+    # * <tt>:prefix</tt>: The constant prefix.  Default to nothing; if specified,
+    #   the capitalized name is appended and the result is set as the constant.
+    def genmodule(name, options = {}, &block)
+        genthing(name, Module, options, block)
+    end
+
+    # Remove an existing class
+    def rmclass(name, options)
+        options = symbolize_options(options)
+        const = genconst_string(name, options)
+        retval = false
+        if const_defined? const
+            remove_const(const)
+            retval = true
+        end
+
+        if hash = options[:hash] and hash.include? name
+            hash.delete(name)
+            retval = true
+        end
+
+        # Let them know whether we did actually delete a subclass.
+        return retval
+    end
+
+    private
+
+    # Generate the constant to create or remove.
+    def genconst_string(name, options)
+        unless const = options[:constant]
+            prefix = options[:prefix] || ""
+            const = prefix + name2const(name)
+        end
+
+        return const
+    end
+
+    # This does the actual work of creating our class or module.  It's just a
+    # slightly abstract version of genclass.
+    def genthing(name, type, options, block)
+        options = symbolize_options(options)
+
+        name = symbolize(name.to_s.downcase)
+
+        if type == Module
+            #evalmethod = :module_eval
+            evalmethod = :class_eval
+            # Create the class, with the correct name.
+            klass = Module.new do
+                class << self
+                    attr_reader :name
+                end
+                @name = name
+            end
+        else 
+            options[:parent] ||= self
+            evalmethod = :class_eval
+            # Create the class, with the correct name.
+            klass = Class.new(options[:parent]) do
+                @name = name
+            end
+        end
+
+        # Create the constant as appropriation.
+        handleclassconst(klass, name, options)
+
+        # Initialize any necessary variables.
+        initclass(klass, options)
+
+        block ||= options[:block]
+
+        # Evaluate the passed block if there is one.  This should usually
+        # define all of the work.
+        if block
+            klass.send(evalmethod, &block)
+        end
+
+        if klass.respond_to? :postinit
+            klass.postinit
+        end
+
+        # Store the class in hashes or arrays or whatever.
+        storeclass(klass, name, options)
+
+        return klass
+    end
+
+    # Handle the setting and/or removing of the associated constant.
+    def handleclassconst(klass, name, options)
+        const = genconst_string(name, options)
+
+        if const_defined? const
+            if options[:overwrite]
+                Puppet.info "Redefining %s in %s" % [name, self]
+                remove_const(const)
+            else
+                raise Puppet::ConstantAlreadyDefined,
+                    "Class %s is already defined in %s" % [const, self]
+            end
+        end
+        const_set(const, klass)
+
+        return const
+    end
+
+    # Perform the initializations on the class.
+    def initclass(klass, options)
+        if klass.respond_to? :initvars
+            klass.initvars
+        end
+
+        if attrs = options[:attributes]
+            attrs.each do |param, value|
+                method = param.to_s + "="
+                if klass.respond_to? method
+                    klass.send(method, value)
+                end
+            end
+        end
+
+        [:include, :extend].each do |method|
+            if set = options[method]
+                set = [set] unless set.is_a?(Array)
+                set.each do |mod|
+                    klass.send(method, mod)
+                end
+            end
+        end
+
+        if klass.respond_to? :preinit
+            klass.preinit
+        end
+    end
+
+    # Convert our name to a constant.
+    def name2const(name)
+        name.to_s.capitalize
+    end
+
+    # Store the class in the appropriate places.
+    def storeclass(klass, klassname, options)
+        if hash = options[:hash]
+            if hash.include? klassname and ! options[:overwrite]
+                raise Puppet::SubclassAlreadyDefined,
+                    "Already a generated class named %s" % klassname
+            end
+
+            hash[klassname] = klass
+        end
+
+        # If we were told to stick it in a hash, then do so
+        if array = options[:array]
+            if (klass.respond_to? :name and
+                            array.find { |c| c.name == klassname } and
+                            ! options[:overwrite])
+                raise Puppet::SubclassAlreadyDefined,
+                    "Already a generated class named %s" % klassname
+            end
+
+            array << klass
+        end
+    end
+end
+
+# $Id: classgen.rb 1856 2006-11-11 07:40:16Z luke $

data/lib/puppet/{config.rb → util/config.rb}

@@ -2,10 +2,10 @@ require 'puppet'
 require 'sync'
 require 'puppet/transportable'
 
-module Puppet
 # The class for handling configuration files.
-class Config
+class Puppet::Util::Config
     include Enumerable
+    include Puppet::Util
 
     @@sync = Sync.new
 
@@ -17,14 +17,20 @@ class Config
 
         # Yay, recursion.
         self.reparse() unless param == :filetimeout
-        if @config.include?(param)
-            if @config[param]
-                val = @config[param].value
-                return val
+
+        # Cache the returned values; this method was taking close to
+        # 10% of the compile time.
+        unless @returned[param]
+            if @config.include?(param)
+                if @config[param]
+                    @returned[param] = @config[param].value
+                end
+            else
+                raise ArgumentError, "Undefined configuration parameter '%s'" % param
             end
-        else
-            raise ArgumentError, "Undefined configuration parameter '%s'" % param
         end
+
+        return @returned[param]
     end
 
     # Set a config value.  This doesn't set the defaults, it sets the value itself.
@@ -33,12 +39,15 @@ class Config
             param = symbolize(param)
             unless @config.include?(param)
                 raise Puppet::Error,
-                    "Unknown configuration parameter %s" % param.inspect
+                    "Attempt to assign a value to unknown configuration parameter %s" % param.inspect
             end
             unless @order.include?(param)
                 @order << param
             end
             @config[param].value = value
+            if @returned.include?(param)
+                @returned.delete(param)
+            end
         end
 
         return value
@@ -85,7 +94,9 @@ class Config
             trans.evaluate
             comp.remove
         rescue => detail
+            if Puppet[:trace]
                 puts detail.backtrace
+            end
             Puppet.err "Could not configure myself: %s" % detail
         end
     end
@@ -107,6 +118,7 @@ class Config
                 obj.clear
             end
         }
+        @returned.clear
 
         # Don't clear the 'used' in this case, since it's a config file reparse,
         # and we want to retain this info.
@@ -117,6 +129,7 @@ class Config
 
     # This is mostly just used for testing.
     def clearused
+        @returned.clear
         @used = []
     end
 
@@ -188,6 +201,7 @@ class Config
         @config = {}
 
         @created = []
+        @returned = {}
     end
 
     # Make a directory with the appropriate user, group, and mode
@@ -201,7 +215,7 @@ class Config
             raise ArgumentError, "Default %s is not a file" % default
         end
 
-        Puppet::Util.asuser(obj.owner, obj.group) do
+        Puppet::Util::SUIDManager.asuser(obj.owner, obj.group) do
             mode = obj.mode || 0750
             Dir.mkdir(obj.value, mode)
         end
@@ -215,7 +229,7 @@ class Config
             when /^true$/i: true
             when /^\d+$/i: Integer(value)
             else
-                value.gsub(/^["']|["']$/,'')
+                value.gsub(/^["']|["']$/,'').sub(/\s+$/, '')
         end
     end
 
@@ -233,10 +247,10 @@ class Config
     def parse(file)
         text = nil
 
-        if file.is_a? Puppet::ParsedFile
+        if file.is_a? Puppet::Util::LoadedFile
             @file = file
         else
-            @file = Puppet::ParsedFile.new(file)
+            @file = Puppet::Util::LoadedFile.new(file)
         end
 
         # Create a timer so that this.
@@ -267,7 +281,18 @@ class Config
             when /^\s*$/: next # Skip blanks
             when /^\s*(\w+)\s*=\s*(.+)$/: # settings
                 var = $1.intern
-                value = mungearg($2)
+                if var == :mode
+                    value = $2
+                else
+                    value = mungearg($2)
+                end
+
+                # Only warn if we don't know what this config var is.  This
+                # prevents exceptions later on.
+                unless @config.include?(var) or metas.include?(var.to_s)
+                    Puppet.warning "Discarded unknown configuration parameter %s" % var.inspect
+                    next # Skip this line.
+                end
 
                 # Mmm, "special" attributes
                 if metas.include?(var.to_s)
@@ -276,12 +301,9 @@ class Config
                     end
                     values[section][var.to_s] = value
 
-                    # Do some annoying skullduggery here.  This is so that
-                    # the group can be set in the config file.  The problem
-                    # is that we're using the word 'group' twice, which is
-                    # confusing.
-                    if var == :group and section == Puppet.name and @config.include?(:group)
-                        @config[:group].value = value
+                    # If the parameter is valid, then set it.
+                    if section == Puppet[:name] and @config.include?(var)
+                        @config[var].value = value
                     end
                     next
                 end
@@ -384,37 +406,52 @@ class Config
     def section_to_transportable(section, done = nil, includefiles = true)
         done ||= Hash.new { |hash, key| hash[key] = {} }
         objects = []
-        persection(section) { |obj|
+        persection(section) do |obj|
             if @config[:mkusers] and @config[:mkusers].value
-                [:owner, :group].each { |attr|
+                [:owner, :group].each do |attr|
                     type = nil
                     if attr == :owner
                         type = :user
                     else
                         type = attr
                     end
+                    # If a user and/or group is set, then make sure we're
+                    # managing that object
                     if obj.respond_to? attr and name = obj.send(attr)
-                        # Skip owners and groups we've already done, but tag them with
-                        # our section if necessary
+                        # Skip root or wheel
+                        next if %w{root wheel}.include?(name.to_s)
+
+                        # Skip owners and groups we've already done, but tag
+                        # them with our section if necessary
                         if done[type].include?(name)
                             tags = done[type][name].tags
                             unless tags.include?(section)
                                 done[type][name].tags = tags << section
                             end
                         elsif newobj = Puppet::Type.type(type)[name]
-                            unless newobj.state(:ensure)
+                            unless newobj.property(:ensure)
                                 newobj[:ensure] = "present"
                             end
                             newobj.tag(section)
+                            if type == :user
+                                newobj[:comment] ||= "%s user" % name
+                            end
                         else
-                            newobj = TransObject.new(name, type.to_s)
+                            newobj = Puppet::TransObject.new(name, type.to_s)
                             newobj.tags = ["puppet", "configuration", section]
                             newobj[:ensure] = "present"
+                            if type == :user
+                                newobj[:comment] ||= "%s user" % name
+                            end
+                            # Set the group appropriately for the user
+                            if type == :user
+                                newobj[:gid] = Puppet[:group]
+                            end
                             done[type][name] = newobj
                             objects << newobj
                         end
                     end
-                }
+                end
             end
 
             if obj.respond_to? :to_transportable
@@ -431,7 +468,7 @@ class Config
                     end
                 end
             end
-        }
+        end
 
         bucket = Puppet::TransBucket.new
         bucket.type = section
@@ -475,15 +512,6 @@ class Config
         end
     end
 
-    def symbolize(param)
-        case param
-        when String: return param.intern
-        when Symbol: return param
-        else
-            raise ArgumentError, "Invalid param type %s" % param.class
-        end
-    end
-
     # Convert our list of objects into a component that can be applied.
     def to_component
         transport = self.to_transportable
@@ -492,7 +520,7 @@ class Config
 
     # Convert our list of objects into a configuration file.
     def to_config
-        str = %{The configuration file for #{Puppet.name}.  Note that this file
+        str = %{The configuration file for #{Puppet[:name]}.  Note that this file
 is likely to have unused configuration parameters in it; any parameter that's
 valid anywhere in Puppet can be in any config file, even if it's not used.
 
@@ -588,6 +616,8 @@ Generated on #{Time.now}.
                 Puppet[:tags] = ""
             end
             trans = objects.evaluate
+            trans.ignoretags = true
+            trans.configurator = true
             trans.evaluate
             if tags
                 Puppet[:tags] = tags
@@ -620,12 +650,12 @@ Generated on #{Time.now}.
         end
 
         chown = nil
-        if Process.uid == 0
+        if Puppet::Util::SUIDManager.uid == 0
             chown = [obj.owner, obj.group]
         else
             chown = [nil, nil]
         end
-        Puppet::Util.asuser(*chown) do
+        Puppet::Util::SUIDManager.asuser(*chown) do
             mode = obj.mode || 0640
 
             if args.empty?
@@ -653,13 +683,13 @@ Generated on #{Time.now}.
         end
 
         chown = nil
-        if Process.uid == 0
+        if Puppet::Util::SUIDManager.uid == 0
             chown = [obj.owner, obj.group]
         else
             chown = [nil, nil]
         end
 
-        Puppet::Util.asuser(*chown) do
+        Puppet::Util::SUIDManager.asuser(*chown) do
             mode = obj.mode || 0640
             if args.empty?
                 args << "w"
@@ -686,27 +716,30 @@ Generated on #{Time.now}.
             @value = nil
         end
 
+        # Do variable interpolation on the value.
         def convert(value)
             return value unless value
             return value unless value.is_a? String
-            if value =~ /\$(\w+)/
-                parent = $1
-                if pval = @parent[parent]
-                    newval = value.to_s.sub(/\$#{parent.to_s}/, pval.to_s)
-                    #return File.join(newval.split("/"))
-                    return newval
+            newval = value.gsub(/\$(\w+)|\$\{(\w+)\}/) do |value|
+                varname = $2 || $1
+                if pval = @parent[varname]
+                    pval
                 else
                     raise Puppet::DevError, "Could not find value for %s" % parent
                 end
-            else
-                return value
             end
+
+            return newval
         end
 
         def desc=(value)
             @desc = value.gsub(/^\s*/, '')
         end
 
+        def hook=(block)
+            meta_def :handle, &block
+        end
+
         # Create the new element.  Pretty much just sets the name.
         def initialize(args = {})
             if args.include?(:parent)
@@ -721,6 +754,10 @@ Generated on #{Time.now}.
 
                 self.send(method, value)
             end
+
+            unless self.desc
+                raise ArgumentError, "You must provide a description for the %s config option" % self.name
+            end
         end
 
         def iscreated
@@ -791,11 +828,16 @@ Generated on #{Time.now}.
             if respond_to?(:validate)
                 validate(value)
             end
+
             if respond_to?(:munge)
                 @value = munge(value)
             else
                 @value = value
             end
+
+            if respond_to?(:handle)
+                handle(@value)
+            end
         end
     end
 
@@ -864,12 +906,14 @@ Generated on #{Time.now}.
             end
             [:mode].each { |var|
                 if value = self.send(var)
-                    obj[var] = "%o" % value
+                    # Don't both converting the mode, since the file type
+                    # can handle it any old way.
+                    obj[var] = value
                 end
             }
 
             # Only chown or chgrp when root
-            if Process.uid == 0
+            if Puppet::Util::SUIDManager.uid == 0
                 [:group, :owner].each { |var|
                     if value = self.send(var)
                         obj[var] = value
@@ -879,6 +923,11 @@ Generated on #{Time.now}.
 
             # And set the loglevel to debug for everything
             obj[:loglevel] = "debug"
+            
+            # We're not actually modifying any files here, and if we allow a
+            # filebucket to get used here we get into an infinite recursion
+            # trying to set the filebucket up.
+            obj[:backup] = false
 
             if self.section
                 obj.tags += ["puppet", "configuration", self.section, self.name]
@@ -914,6 +963,5 @@ Generated on #{Time.now}.
         end
     end
 end
-end
 
-# $Id: config.rb 1421 2006-07-21 23:12:51Z luke $
+# $Id: config.rb 2272 2007-03-08 17:07:35Z luke $