puppet 0.9.2 → 0.13.0

data/lib/puppet/client/ca.rb

@@ -0,0 +1,17 @@
+class Puppet::Client::CAClient < Puppet::Client::ProxyClient
+    @drivername = :CA
+
+    # set up the appropriate interface methods
+    @handler = Puppet::Server::CA
+    self.mkmethods
+
+    def initialize(hash = {})
+        if hash.include?(:CA)
+            hash[:CA] = Puppet::Server::CA.new()
+        end
+
+        super(hash)
+    end
+end
+
+# $Id: ca.rb 848 2006-01-24 06:01:58Z luke $

data/lib/puppet/client/dipper.rb

@@ -0,0 +1,78 @@
+module Puppet
+    class Client
+        # The client class for filebuckets.
+        class Dipper < Puppet::Client
+            @drivername = :Bucket
+
+            def initialize(hash = {})
+                if hash.include?(:Path)
+                    bucket = Puppet::Server::FileBucket.new(
+                        :Bucket => hash[:Path]
+                    )
+                    hash.delete(:Path)
+                    hash[:Bucket] = bucket
+                end
+
+                super(hash)
+            end
+
+            def backup(file)
+                unless FileTest.exists?(file)
+                    raise(BucketError, "File %s does not exist" % file, caller)
+                end
+                contents = File.open(file) { |of| of.read }
+
+                string = Base64.encode64(contents)
+                #puts "string is created"
+
+                sum = @driver.addfile(string,file)
+                #puts "file %s is added" % file
+                return sum
+            end
+
+            def restore(file,sum)
+                restore = true
+                if FileTest.exists?(file)
+                    contents = File.open(file) { |of| of.read }
+
+                    cursum = Digest::MD5.hexdigest(contents)
+
+                    # if the checksum has changed...
+                    # this might be extra effort
+                    if cursum == sum
+                        restore = false
+                    end
+                end
+
+                if restore
+                    #puts "Restoring %s" % file
+                    if tmp = @driver.getfile(sum)
+                        newcontents = Base64.decode64(tmp)
+                        newsum = Digest::MD5.hexdigest(newcontents)
+                        changed = nil
+                        unless FileTest.writable?(file)
+                            changed = File.stat(file).mode
+                            File.chmod(changed | 0200, file)
+                        end
+                        File.open(file,File::WRONLY|File::TRUNC) { |of|
+                            of.print(newcontents)
+                        }
+                        if changed
+                            File.chmod(changed, file)
+                        end
+                    else
+                        Puppet.err "Could not find file with checksum %s" % sum
+                        return nil
+                    end
+                    #puts "Done"
+                    return newsum
+                else
+                    return nil
+                end
+
+            end
+        end
+    end
+end
+
+# $Id: dipper.rb 848 2006-01-24 06:01:58Z luke $

data/lib/puppet/client/file.rb

@@ -0,0 +1,20 @@
+class Puppet::Client::FileClient < Puppet::Client::ProxyClient
+    @drivername = :FileServer
+
+    # set up the appropriate interface methods
+    @handler = Puppet::Server::FileServer
+
+    self.mkmethods
+
+    def initialize(hash = {})
+        if hash.include?(:FileServer)
+            unless hash[:FileServer].is_a?(Puppet::Server::FileServer)
+                raise Puppet::DevError, "Must pass an actual FS object"
+            end
+        end
+
+        super(hash)
+    end
+end
+
+# $Id: file.rb 848 2006-01-24 06:01:58Z luke $

data/lib/puppet/client/log.rb

@@ -0,0 +1,17 @@
+class Puppet::Client::LogClient < Puppet::Client::ProxyClient
+    @drivername = :Logger
+
+    # set up the appropriate interface methods
+    @handler = Puppet::Server::Logger
+    self.mkmethods
+
+    def initialize(hash = {})
+        if hash.include?(:Logger)
+            hash[:Logger] = Puppet::Server::Logger.new()
+        end
+
+        super(hash)
+    end
+end
+
+# $Id: log.rb 848 2006-01-24 06:01:58Z luke $

data/lib/puppet/client/master.rb

@@ -0,0 +1,246 @@
+# The client for interacting with the puppetmaster config server.
+class Puppet::Client::MasterClient < Puppet::Client
+    @drivername = :Master
+
+    def self.facts
+        facts = {}
+        Facter.each { |name,fact|
+            facts[name] = fact.downcase
+        }
+
+        facts
+    end
+
+    # This method is how the client receives the tree of Transportable
+    # objects.  For now, just descend into the tree and perform and
+    # necessary manipulations.
+    def apply
+        Puppet.notice "Beginning configuration run"
+        dostorage()
+        unless defined? @objects
+            raise Puppet::Error, "Cannot apply; objects not defined"
+        end
+
+        #Puppet.err :yay
+        #p @objects
+        #Puppet.err :mark
+        #@objects = @objects.to_type
+        # this is a gross hack... but i don't see a good way around it
+        # set all of the variables to empty
+        Puppet::Transaction.init
+
+        # For now we just evaluate the top-level object, but eventually
+        # there will be schedules and such associated with each object,
+        # and probably with the container itself.
+        transaction = @objects.evaluate
+        #transaction = Puppet::Transaction.new(objects)
+        transaction.toplevel = true
+        begin
+            transaction.evaluate
+        rescue Puppet::Error => detail
+            Puppet.err "Could not apply complete configuration: %s" %
+                detail
+        rescue => detail
+            Puppet.err "Found a bug: %s" % detail
+            if Puppet[:debug]
+                puts detail.backtrace
+            end
+        ensure
+            Puppet::Storage.store
+        end
+        Puppet::Metric.gather
+        Puppet::Metric.tally
+        if Puppet[:rrdgraph] == true
+            Metric.store
+            Metric.graph
+        end
+        Puppet.notice "Finished configuration run"
+
+        return transaction
+    end
+
+    # Cache the config
+    def cache(text)
+        Puppet.info "Caching configuration at %s" % self.cachefile
+        confdir = File.dirname(Puppet[:localconfig])
+        unless FileTest.exists?(confdir)
+            Puppet.recmkdir(confdir, 0770)
+        end
+        File.open(self.cachefile + ".tmp", "w", 0660) { |f|
+            f.print text
+        }
+        File.rename(self.cachefile + ".tmp", self.cachefile)
+    end
+
+    def cachefile
+        unless defined? @cachefile
+            @cachefile = Puppet[:localconfig] + ".yaml"
+        end
+        @cachefile
+    end
+
+    # Initialize and load storage
+    def dostorage
+        begin
+            Puppet::Storage.init
+            Puppet::Storage.load
+        rescue => detail
+            Puppet.err "Corrupt state file %s: %s" % [Puppet[:statefile], detail]
+            begin
+                File.unlink(Puppet[:statefile])
+                retry
+            rescue => detail
+                raise Puppet::Error.new("Cannot remove %s: %s" %
+                    [Puppet[statefile], detail])
+            end
+        end
+    end
+
+    # Check whether our configuration is up to date
+    def fresh?
+        unless defined? @configstamp
+            return false
+        end
+
+        # We're willing to give a 2 second drift
+        if @driver.freshness - @configstamp < 1
+            return true
+        else
+            return false
+        end
+    end
+
+    # Retrieve the config from a remote server.  If this fails, then
+    # use the cached copy.
+    def getconfig
+        if self.fresh?
+            Puppet.info "Config is up to date"
+            return
+        end
+        Puppet.debug("getting config")
+        dostorage()
+
+        facts = self.class.facts
+
+        unless facts.length > 0
+            raise Puppet::ClientError.new(
+                "Could not retrieve any facts"
+            )
+        end
+
+        objects = nil
+        if @local
+            # If we're local, we don't have to do any of the conversion
+            # stuff.
+            objects = @driver.getconfig(facts, "yaml")
+            @configstamp = Time.now.to_i
+
+            if objects == ""
+                raise Puppet::Error, "Could not retrieve configuration"
+            end
+        else
+            textobjects = ""
+
+            textfacts = CGI.escape(YAML.dump(facts))
+
+            # error handling for this is done in the network client
+            begin
+                textobjects = @driver.getconfig(textfacts, "yaml")
+            rescue => detail
+                Puppet.err "Could not retrieve configuration: %s" % detail
+            end
+
+            fromcache = false
+            if textobjects == ""
+                textobjects = self.retrievecache
+                if textobjects == ""
+                    raise Puppet::Error.new(
+                        "Cannot connect to server and there is no cached configuration"
+                    )
+                end
+                Puppet.notice "Could not get config; using cached copy"
+                fromcache = true
+            end
+
+            begin
+                textobjects = CGI.unescape(textobjects)
+                @configstamp = Time.now.to_i
+            rescue => detail
+                raise Puppet::Error, "Could not CGI.unescape configuration"
+            end
+
+            if @cache and ! fromcache
+                self.cache(textobjects)
+            end
+
+            begin
+                objects = YAML.load(textobjects)
+            rescue => detail
+                raise Puppet::Error,
+                    "Could not understand configuration: %s" %
+                    detail.to_s
+            end
+        end
+
+        unless objects.is_a?(Puppet::TransBucket)
+            raise NetworkClientError,
+                "Invalid returned objects of type %s" % objects.class
+        end
+
+        if classes = objects.classes
+            self.setclasses(classes)
+        else
+            Puppet.info "No classes to store"
+        end
+
+        # Clear all existing objects, so we can recreate our stack.
+        if defined? @objects
+            Puppet::Type.allclear
+        end
+        @objects = nil
+
+        # First create the default scheduling objects
+        Puppet.type(:schedule).mkdefaultschedules
+
+        # Now convert the objects to real Puppet objects
+        @objects = objects.to_type
+
+        if @objects.nil?
+            raise Puppet::Error, "Configuration could not be processed"
+        end
+        #@objects = objects
+
+        # and perform any necessary final actions before we evaluate.
+        Puppet::Type.finalize
+
+        return @objects
+    end
+
+    # Retrieve the cached config
+    def retrievecache
+        if FileTest.exists?(self.cachefile)
+            return File.read(self.cachefile)
+        else
+            return ""
+        end
+    end
+
+    # The code that actually runs the configuration.  
+    def run
+        self.getconfig
+        self.apply
+    end
+
+    def setclasses(ary)
+        begin
+            File.open(Puppet[:classfile], "w") { |f|
+                f.puts ary.join("\n")
+            }
+        rescue => detail
+            Puppet.err "Could not create class file %s: %s" %
+                [Puppet[:classfile], detail]
+        end
+    end
+end
+
+# $Id: master.rb 872 2006-02-07 17:07:15Z luke $

data/lib/puppet/client/proxy.rb

@@ -0,0 +1,27 @@
+# unlike the other client classes (again, this design sucks) this class
+# is basically just a proxy class -- it calls its methods on the driver
+# and that's about it
+class Puppet::Client::ProxyClient < Puppet::Client
+    def self.mkmethods
+        interface = @handler.interface
+        namespace = interface.prefix
+
+        interface.methods.each { |ary|
+            method = ary[0]
+            Puppet.debug "%s: defining %s.%s" % [self, namespace, method]
+            self.send(:define_method,method) { |*args|
+                begin
+                    @driver.send(method, *args)
+                rescue XMLRPC::FaultException => detail
+                    #Puppet.err "Could not call %s.%s: %s" %
+                    #    [namespace, method, detail.faultString]
+                    #raise NetworkClientError,
+                    #    "XMLRPC Error: %s" % detail.faultString
+                    raise NetworkClientError, detail.faultString
+                end
+            }
+        }
+    end
+end
+
+# $Id: proxy.rb 848 2006-01-24 06:01:58Z luke $

data/lib/puppet/client/status.rb

@@ -0,0 +1,7 @@
+class Puppet::Client::StatusClient < Puppet::Client::ProxyClient
+    # set up the appropriate interface methods
+    @handler = Puppet::Server::ServerStatus
+    self.mkmethods
+end
+
+# $Id: status.rb 848 2006-01-24 06:01:58Z luke $

data/lib/puppet/config.rb

@@ -1,17 +1,183 @@
-module Puppet # :nodoc:
+module Puppet
 # The class for handling configuration files.
-class Config < Hash
-    # Slight override, since we can't seem to have a subclass where all instances
-    # have the same default block.
-    def [](section)
-        unless self.has_key?(section)
-            self[section] = {}
+class Config
+    include Enumerable
+
+    # Retrieve a config value
+    def [](param)
+        param = convert(param)
+        if @config.include?(param)
+            if @config[param]
+                val = @config[param].value
+                return val
+            end
+        else
+            raise ArgumentError, "Invalid argument %s" % param
+        end
+    end
+
+    # Set a config value.  This doesn't set the defaults, it sets the value itself.
+    def []=(param, value)
+        param = convert(param)
+        unless @config.include?(param)
+            raise Puppet::Error, "Unknown configuration parameter %s" % param.inspect
+        end
+        unless @order.include?(param)
+            @order << param
+        end
+        @config[param].value = value
+    end
+
+    # A simplified equality operator.
+    def ==(other)
+        self.each { |myname, myobj|
+            unless other[myname] == myobj.value
+                return false
+            end
+        }
+
+        return true
+    end
+
+    # Generate the list of valid arguments, in a format that GetoptLong can
+    # understand, and add them to the passed option list.
+    def addargs(options)
+        require 'getoptlong'
+        # Add all of the config parameters as valid options.
+        self.each { |param, obj|
+            if self.boolean?(param)
+                options << ["--#{param}", GetoptLong::NO_ARGUMENT]
+                options << ["--no-#{param}", GetoptLong::NO_ARGUMENT]
+            else
+                options << ["--#{param}", GetoptLong::REQUIRED_ARGUMENT]
+            end
+        }
+
+        return options
+    end
+
+    # Turn the config into a transaction and apply it
+    def apply
+        trans = self.to_transportable
+        begin
+            comp = trans.to_type
+            trans = comp.evaluate
+            trans.evaluate
+            comp.remove
+        rescue => detail
+                puts detail.backtrace
+            Puppet.err "Could not configure myself: %s" % detail
         end
-        super
     end
 
-    def initialize(file)
+    # Is our parameter a boolean parameter?
+    def boolean?(param)
+        param = convert(param)
+        if @config.include?(param) and @config[param].kind_of? CBoolean
+            return true
+        else
+            return false
+        end
+    end
+
+    # Remove all set values.
+    def clear
+        @config.each { |name, obj|
+            obj.clear
+        }
+    end
+
+    def convert(param)
+        case param
+        when String: return param.intern
+        when Symbol: return param
+        else
+            raise ArgumentError, "Invalid param type %s" % param.class
+        end
+    end
+
+    def each
+        @order.each { |name|
+            if @config.include?(name)
+                yield name, @config[name]
+            else
+                raise Puppet::DevError, "%s is in the order but does not exist" % name
+            end
+        }
+    end
+
+    # Iterate over each section name.
+    def eachsection
+        yielded = []
+        @order.each { |name|
+            if @config.include?(name)
+                section = @config[name].section
+                unless yielded.include? section
+                    yield section
+                    yielded << section
+                end
+            else
+                raise Puppet::DevError, "%s is in the order but does not exist" % name
+            end
+        }
+    end
+
+    # Return an object by name.
+    def element(param)
+        param = convert(param)
+        @config[param]
+    end
+
+    # Handle a command-line argument.
+    def handlearg(opt, value = nil)
+        if value == "true"
+            value = true
+        end
+        if value == "false"
+            value = false
+        end
+        str = opt.sub(/^--/,'')
+        bool = true
+        newstr = str.sub(/^no-/, '')
+        if newstr != str
+            str = newstr
+            bool = false
+        end
+        if self.valid?(str)
+            if self.boolean?(str)
+                self[str] = bool
+            else
+                self[str] = value
+            end
+
+            # Mark that this was set on the cli, so it's not overridden if the config
+            # gets reread.
+            @config[str.intern].setbycli = true
+        else
+            raise ArgumentError, "Invalid argument %s" % opt
+        end
+    end
+
+    # Create a new config object
+    def initialize
+        @order = []
+        @config = {}
+    end
+
+    # Return all of the parameters associated with a given section.
+    def params(section)
+        section = section.intern if section.is_a? String
+        @config.find_all { |name, obj|
+            obj.section == section
+        }.collect { |name, obj|
+            name
+        }
+    end
+
+    # Parse a configuration file.
+    def parse(file)
         text = nil
+        @file = file
 
         begin
             text = File.read(file)
@@ -29,21 +195,405 @@ class Config < Hash
         }
 
         section = "puppet"
+        metas = %w{owner group mode}
+        values = Hash.new { |hash, key| hash[key] = {} }
         text.split(/\n/).each { |line|
             case line
             when /^\[(\w+)\]$/: section = $1 # Section names
             when /^\s*#/: next # Skip comments
             when /^\s*$/: next # Skip blanks
-            when /^\s*(\w+)\s+(.+)$/: # settings
-                var = $1
+            when /^\s*(\w+)\s*=\s*(.+)$/: # settings
+                var = $1.intern
                 value = $2
-                self[section][var] = value
+
+                # Mmm, "special" attributes
+                if metas.include?(var.to_s)
+                    unless values.include?(section)
+                        values[section] = {}
+                    end
+                    values[section][var.to_s] = value
+                    next
+                end
+
+                # Don't override set parameters, since the file is parsed
+                # after cli arguments are handled.
+                unless @config.include?(var) and @config[var].setbycli
+                    Puppet.debug "%s: Setting %s to '%s'" % [section, var, value]
+                    self[var] = value
+                end
+                @config[var].section = section
+
+                metas.each { |meta|
+                    if values[section][meta]
+                        if @config[var].respond_to?(meta + "=")
+                            @config[var].send(meta + "=", values[section][meta])
+                        end
+                    end
+                }
             else
                 raise Puppet::Error, "Could not match line %s" % line
             end
         }
     end
+
+    # Create a new element.  The value is passed in because it's used to determine
+    # what kind of element we're creating, but the value itself might be either
+    # a default or a value, so we can't actually assign it.
+    def newelement(param, desc, value)
+        param = convert(param)
+        mod = nil
+        case value
+        when true, false, "true", "false":
+            mod = CBoolean
+        when /^\$/, /^\//:
+            mod = CFile
+        when String, Integer, Float: # nothing
+        else
+            raise Puppet::Error, "Invalid value '%s' for %s" % [value, param]
+        end
+        element = CElement.new(param, desc)
+        element.parent = self
+        if mod
+            element.extend(mod)
+        end
+
+        @order << param
+
+        return element
+    end
+
+    # Iterate across all of the objects in a given section.
+    def persection(section)
+        self.each { |name, obj|
+            if obj.section == section
+                yield obj
+            end
+        }
+    end
+
+    # Get a list of objects per section
+    def sectionlist
+        sectionlist = []
+        self.each { |name, obj|
+            section = obj.section || "puppet"
+            sections[section] ||= []
+            unless sectionlist.include?(section)
+                sectionlist << section
+            end
+            sections[section] << obj
+        }
+
+        return sectionlist, sections
+    end
+
+    # Convert a single section into transportable objects.
+    def section_to_transportable(section, done)
+        objects = []
+        persection(section) { |obj|
+            [:owner, :group].each { |type|
+                if obj.respond_to? type and val = obj.send(type)
+                    # Skip owners and groups we've already done, but tag them with
+                    # our section if necessary
+                    if done[type].include?(val)
+                        next unless defined? @section and @section
+
+                        tags = done[type][val].tags
+                        unless tags.include?(@section)
+                            done[type][val].tags = tags << @section
+                        end
+                    else
+                        newobj = TransObject.new(val, type.to_s)
+                        newobj[:ensure] = "exists"
+                        done[type] << newobj
+                    end
+                end
+            }
+
+            if obj.respond_to? :to_transportable
+                unless done[:file].include? obj.value
+                    trans = obj.to_transportable
+                    # transportable could return nil
+                    next unless trans
+                    objects << trans
+                    done[:file] << obj.value
+                end
+            end
+        }
+
+        bucket = Puppet::TransBucket.new
+        bucket.autoname = true
+        bucket.name = "autosection-%s" % bucket.object_id
+        bucket.type = section
+        bucket.push(*objects)
+        bucket.keyword = "class"
+
+        return bucket
+    end
+
+    # Set a bunch of defaults in a given section.  The sections are actually pretty
+    # pointless, but they help break things up a bit, anyway.
+    def setdefaults(section, *defs)
+        section = section.intern unless section.is_a? Symbol
+        #hash.each { |param, value|
+        defs.each { |param, value, desc|
+            param = convert(param)
+            if @config.include?(param) and @config[param].default
+                raise Puppet::Error, "Default %s is already defined" % param
+            end
+            unless @config.include?(param)
+                @config[param] = newelement(param, desc, value)
+            end
+            @config[param].default = value
+            @config[param].section = section
+        }
+    end
+
+    # Convert our list of objects into a component that can be applied.
+    def to_component
+        transport = self.to_transportable
+        return transport.to_type
+    end
+
+    # Convert our list of objects into a configuration file.
+    def to_config
+        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.
+
+Every section can specify three special parameters: owner, group, and mode.
+These parameters affect the required permissions of any files specified after
+their specification.  Puppet will sometimes use these parameters to check its
+own configured state, so they can be used to make Puppet a bit more self-managing.
+
+Note also that the section names are entirely for human-level organizational
+purposes; they don't provide separate namespaces.  All parameters are in a
+single namespace.
+
+Generated on #{Time.now}.
+
+}.gsub(/^/, "# ")
+
+        eachsection do |section|
+            str += "[#{section}]\n"
+            persection(section) do |obj|
+                str += obj.to_config + "\n"
+            end
+        end
+
+        return str
+    end
+
+    # Convert our configuration into a list of transportable objects.
+    def to_transportable
+        done = {
+            :owner => [],
+            :group => [],
+            :file => []
+        }
+
+        topbucket = Puppet::TransBucket.new
+        if defined? @file and @file
+            topbucket.name = @file
+        else
+            topbucket.name = "configtop"
+        end
+        topbucket.type = "puppetconfig"
+        topbucket.top = true
+        topbucket.autoname = true
+
+        # Now iterate over each section
+        eachsection do |section|
+            topbucket.push section_to_transportable(section, done)
+        end
+
+        topbucket
+    end
+
+    # Convert to a parseable manifest
+    def to_manifest
+        transport = self.to_transportable
+
+        manifest = transport.to_manifest + "\n"
+        eachsection { |section|
+            manifest += "include #{section}\n"
+        }
+
+        return manifest
+    end
+
+    def valid?(param)
+        param = convert(param)
+        @config.has_key?(param)
+    end
+
+    # The base element type.
+    class CElement
+        attr_accessor :name, :section, :default, :parent, :desc, :setbycli
+
+        # Unset any set value.
+        def clear
+            @value = nil
+        end
+
+        # Create the new element.  Pretty much just sets the name.
+        def initialize(name, desc, value = nil)
+            @name = name
+            @desc = desc.gsub(/^\s*/, '')
+            if value
+                @value = value
+            end
+        end
+
+        def set?
+            if defined? @value and ! @value.nil?
+                return true
+            else
+                return false
+            end
+        end
+
+        # Convert the object to a config statement.
+        def to_config
+            str = @desc.gsub(/^/, "# ") + "\n"
+
+            # Add in a statement about the default.
+            if defined? @default and @default
+                str += "# The default value is '%s'.\n" % @default
+            end
+
+            line = "%s = %s" % [@name, self.value]
+
+            # If the value has not been overridden, then print it out commented
+            # and unconverted, so it's clear that that's the default and how it
+            # works.
+            if defined? @value and ! @value.nil?
+                line = "%s = %s" % [@name, self.value]
+            else
+                line = "# %s = %s" % [@name, @default]
+            end
+
+            str += line + "\n"
+
+            str.gsub(/^/, "    ")
+        end
+
+        # Retrieves the value, or if it's not set, retrieves the default.
+        def value
+            retval = nil
+            if defined? @value and ! @value.nil?
+                retval = @value
+            elsif defined? @default
+                retval = @default
+            else
+                return nil
+            end
+
+            if respond_to?(:convert)
+                return convert(retval)
+            else
+                return retval
+            end
+        end
+
+        # Set the value.
+        def value=(value)
+            if respond_to?(:validate)
+                validate(value)
+            end
+            if respond_to?(:munge)
+                @value = munge(value)
+            else
+                @value = value
+            end
+        end
+    end
+
+    # A file.
+    module CFile
+        attr_accessor :owner, :group, :mode
+
+        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.sub(/\$#{parent}/, pval)
+                    return File.join(newval.split("/"))
+                else
+                    raise Puppet::DevError, "Could not find value for %s" % parent
+                end
+            else
+                return value
+            end
+        end
+
+        # Set the type appropriately.  Yep, a hack.  This supports either naming
+        # the variable 'dir', or adding a slash at the end.
+        def munge(value)
+            if value.to_s =~ /\/$/
+                @type = :directory
+                return value.sub(/\/$/, '')
+            end
+            return value
+        end
+
+        # Return the appropriate type.
+        def type
+            value = self.value
+            if @name.to_s =~ /dir/
+                return :directory
+            elsif value.to_s =~ /\/$/
+                return :directory
+            elsif value.is_a? String
+                return :file
+            else
+                return nil
+            end
+        end
+
+        # Convert the object to a TransObject instance.
+        def to_transportable
+            type = self.type
+            return nil unless type
+            obj = Puppet::TransObject.new(self.value, "file")
+            obj[:ensure] = type
+            [:owner, :group, :mode].each { |var|
+                if value = self.send(var)
+                    obj[var] = value
+                end
+            }
+            if self.section
+                obj.tags = ["puppet", "configuration", self.section]
+            end
+            obj
+        end
+
+        # Make sure any provided variables look up to something.
+        def validate(value)
+            return true unless value.is_a? String
+            value.scan(/\$(\w+)/) { |name|
+                name = name[0]
+                unless @parent[name]
+                    raise Puppet::Error, "'%s' is unset" % name
+                end
+            }
+        end
+    end
+
+    # A simple boolean.
+    module CBoolean
+        def munge(value)
+            case value
+            when true, "true": return true
+            when false, "false": return false
+            else
+                raise Puppet::Error, "Invalid value '%s' for %s" %
+                    [value.inspect, @name]
+            end
+        end
+    end
 end
 end
 
-# $Id: config.rb 738 2005-10-31 22:50:09Z luke $
+# $Id: config.rb 873 2006-02-07 23:12:33Z luke $