puppet 0.22.4 → 0.23.0

data/install.rb

@@ -30,7 +30,7 @@
 # 5) Install all library files ending in .rb from lib/ into Ruby's
 #    site_lib/version directory.
 #
-# $Id: install.rb 1479 2006-08-21 23:04:32Z luke $
+# $Id: install.rb 2580 2007-06-14 06:11:46Z luke $
 #++
 
 require 'rbconfig'
@@ -61,13 +61,14 @@ def glob(list)
 end
 
 # Set these values to what you want installed.
-bins  = glob(%w{bin/**/*})
-rdoc  = glob(%w{bin/**/* lib/**/*.rb README README-library CHANGELOG TODO Install}).reject { |e| e=~ /\.(bat|cmd)$/ }
-ri    = glob(%w(bin/**/*.rb lib/**/*.rb)).reject { |e| e=~ /\.(bat|cmd)$/ }
+sbins = glob(%w{sbin/*})
+bins  = glob(%w{bin/*})
+rdoc  = glob(%w{bin/* sbin/* lib/**/*.rb README README-library CHANGELOG TODO Install}).reject { |e| e=~ /\.(bat|cmd)$/ }
+ri    = glob(%w(bin/*.rb sbin/* lib/**/*.rb)).reject { |e| e=~ /\.(bat|cmd)$/ }
 libs  = glob(%w{lib/**/*.rb})
 tests = glob(%w{tests/**/*.rb})
 
-def do_bins(bins, target, strip = 'bin/')
+def do_bins(bins, target, strip = 's?bin/')
   bins.each do |bf|
     obf = bf.gsub(/#{strip}/, '')
     install_binfile(bf, obf, target)
@@ -145,37 +146,41 @@ def prepare_installation
     opts.parse!
   end
 
-  bds = [".", ENV['TMP'], ENV['TEMP']]
+  tmpdirs = [".", ENV['TMP'], ENV['TEMP'], "/tmp", "/var/tmp"]
 
   version = [Config::CONFIG["MAJOR"], Config::CONFIG["MINOR"]].join(".")
-  ld = File.join(Config::CONFIG["libdir"], "ruby", version)
-
-  sd = Config::CONFIG["sitelibdir"]
-  if sd.nil?
-    sd = $:.find { |x| x =~ /site_ruby/ }
-    if sd.nil?
-      sd = File.join(ld, "site_ruby")
-    elsif sd !~ Regexp.quote(version)
-      sd = File.join(sd, version)
+  libdir = File.join(Config::CONFIG["libdir"], "ruby", version)
+
+  sitelibdir = Config::CONFIG["sitelibdir"]
+  if sitelibdir.nil?
+    sitelibdir = $:.find { |x| x =~ /site_ruby/ }
+    if sitelibdir.nil?
+      sitelibdir = File.join(libdir, "site_ruby")
+    elsif sitelibdir !~ Regexp.quote(version)
+      sitelibdir = File.join(sitelibdir, version)
     end
   end
 
   if (destdir = ENV['DESTDIR'])
-    bd = "#{destdir}#{Config::CONFIG['bindir']}"
-    sd = "#{destdir}#{sd}"
-    bds << bd
-
-    FileUtils.makedirs(bd)
-    FileUtils.makedirs(sd)
+    bindir = "#{destdir}#{Config::CONFIG['bindir']}"
+    sbindir = "#{destdir}#{Config::CONFIG['sbindir']}"
+    sitelibdir = "#{destdir}#{sitelibdir}"
+    tmpdirs << bindir
+
+    FileUtils.makedirs(bindir)
+    FileUtils.makedirs(sbindir)
+    FileUtils.makedirs(sitelibdir)
   else
-    bd = Config::CONFIG['bindir']
-    bds << Config::CONFIG['bindir']
+    bindir = Config::CONFIG['bindir']
+    sbindir = Config::CONFIG['sbindir']
+    tmpdirs << Config::CONFIG['bindir']
   end
 
-  InstallOptions.bin_dirs = bds.compact
-  InstallOptions.site_dir = sd
-  InstallOptions.bin_dir  = bd
-  InstallOptions.lib_dir  = ld
+  InstallOptions.tmp_dirs = tmpdirs.compact
+  InstallOptions.site_dir = sitelibdir
+  InstallOptions.bin_dir  = bindir
+  InstallOptions.sbin_dir = sbindir
+  InstallOptions.lib_dir  = libdir
 end
 
 ##
@@ -236,7 +241,7 @@ end
 # windows, we add an '.rb' extension and let file associations do their stuff.
 def install_binfile(from, op_file, target)
   tmp_dir = nil
-  InstallOptions.bin_dirs.each do |t|
+  InstallOptions.tmp_dirs.each do |t|
     if File.directory?(t) and File.writable?(t)
       tmp_dir = t
       break
@@ -251,11 +256,15 @@ def install_binfile(from, op_file, target)
     File.open(tmp_file, "w") do |op|
       ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
       op.puts "#!#{ruby}"
-      op.write ip.read
+      contents = ip.readlines
+      if contents[0] =~ /^#!/
+          contents.shift
+      end
+      op.write contents.join()
     end
   end
 
-  if Config::CONFIG["target_os"] =~ /win/io
+  if Config::CONFIG["target_os"] =~ /win/io and Config::CONFIG["target_os"] !~ /darwin/io
     installed_wrapper = false
 
     if File.exists?("#{from}.bat")
@@ -280,7 +289,6 @@ def install_binfile(from, op_file, target)
       installed_wrapper = true
     end
   end
-  p target
   FileUtils.install(tmp_file, File.join(target, op_file), :mode => 0755, :verbose => true)
   File.unlink(tmp_file)
 end
@@ -302,5 +310,6 @@ prepare_installation
 run_tests(tests) if InstallOptions.tests
 #build_rdoc(rdoc) if InstallOptions.rdoc
 #build_ri(ri) if InstallOptions.ri
+do_bins(sbins, InstallOptions.sbin_dir)
 do_bins(bins, InstallOptions.bin_dir)
 do_libs(libs)

data/lib/puppet.rb

@@ -1,3 +1,9 @@
+# Try to load rubygems.  Hey rubygems, I hate you.
+begin
+    require 'rubygems'
+rescue LoadError
+end
+
 # see the bottom of the file for further inclusions
 require 'singleton'
 require 'facter'
@@ -19,7 +25,7 @@ require 'puppet/util/suidmanager'
 # it's also a place to find top-level commands like 'debug'
 
 module Puppet
-    PUPPETVERSION = '0.22.4'
+    PUPPETVERSION = '0.23.0'
 
     def Puppet.version
         return PUPPETVERSION
@@ -128,10 +134,22 @@ module Puppet
                 end
             elsif val =~ /,/
                 val.split(/\s*,\s*/).sort.each do |v|
-                    puts "%s = %s" % [v, Puppet[v]]
+                    if Puppet.config.include?(v)
+                        puts "%s = %s" % [v, Puppet[v]]
+                    else
+                        puts "invalid parameter: %s" % v
+                        exit(1)
+                    end
                 end
             else
-                puts Puppet[val]
+                val.split(/\s*,\s*/).sort.each do |v|
+                    if Puppet.config.include?(v)
+                        puts Puppet[val]
+                    else
+                        puts "invalid parameter: %s" % v
+                        exit(1)
+                    end
+                end
             end
             exit(0)
         end
@@ -184,6 +202,23 @@ module Puppet
         timer
     end
 
+    # Parse the config file for this process.
+    def self.parse_config(oldconfig = nil)
+        # First look for the old configuration file.
+        oldconfig ||= File.join(Puppet[:confdir], Puppet[:name].to_s + ".conf")
+        if FileTest.exists?(oldconfig) and Puppet[:name] != "puppet"
+            Puppet.warning "Individual config files are deprecated; remove %s and use puppet.conf" % oldconfig
+            Puppet.config.old_parse(oldconfig)
+            return
+        end
+
+        # Now check for the normal config.
+        if Puppet[:config] and File.exists? Puppet[:config]
+            Puppet.debug "Parsing %s" % Puppet[:config]
+            Puppet.config.parse(Puppet[:config])
+        end
+    end
+
     # Relaunch the executable.
     def self.restart
         command = $0 + " " + self.args.join(" ")
@@ -393,4 +428,4 @@ if Puppet[:storeconfigs]
     require 'puppet/rails'
 end
 
-# $Id: puppet.rb 2446 2007-05-01 03:52:33Z luke $
+# $Id: puppet.rb 2631 2007-06-19 23:12:23Z luke $

data/lib/puppet/config_stores/rest.rb

@@ -0,0 +1,60 @@
+Puppet::Util::ConfigStore.newstore(:rest) do
+    desc "Store client configurations via a REST web service."
+
+    require 'net/http'
+ 
+    # Get a client's config. (called in collector?)
+    def get(client, config)
+        # Assuming this comes in as Puppet::Parser objects
+        # we may need way to choose which transport data type we use.
+       
+        # hmm.. is this even useful for stored configs? I suppose there could
+        # be scenarios where it'd be cool, like ralsh or something.
+    end
+
+    def initialize
+        @host = Puppet[:puppetstorehost]
+        @port = Puppet[:puppetstoreport]
+
+	# Not sure if this is bad idea to share.
+        @http = Net::HTTP.new(@host, @port)
+    end
+
+    # Store config to the web service. (called in getconfig?)
+    def store(client, config)
+        # Probably store as yaml...
+        puppetstore = Thread.new do
+            benchmark(:notice, "Stored configuration for %s" % client) do
+                begin
+		    # config should come from elsewhere; probably in getconfig I assume.
+                    # should probably allow a config option for the serialization type.
+                    yaml = YAML.dump(config)
+                    url = "/collector/create"
+                    @http.post(url, yaml, { 'Content-Type' => 'text/yaml' })
+                rescue => detail
+                    Puppet.err("ERROR: storeconfig failed: ", detail.to_s)
+                end
+            end
+        end
+        puppetstore.run
+    end
+
+    # Rough first try... assuming the calling method handles the data type conversion
+    # Can we use a thread here? Probably needs to be the caller's thread.
+    def collect_exported(client, conditions)
+        begin
+            # Gotta be a better way... seems goofy to me.
+            # maybe using a nested rails rest route...
+           
+            # filterhost so we don't get exported resources for the current client
+            url = "/resources?restype=exported&filterhost=#{client}"
+            conditions.each_pair {|k,v| url << "&#{k}=#{v}"}
+            res = @http.get(url)
+        rescue => detail
+            Puppet.err("ERROR: collect_exported failed: ", detail.to_s)
+        end
+
+        return res.body unless !res.is_a?(Net::HTTPOK)
+    end
+
+end

data/lib/puppet/configuration.rb

@@ -5,6 +5,7 @@ module Puppet
     conf = nil
     var = nil
     name = $0.gsub(/.+#{File::SEPARATOR}/,'').sub(/\.rb$/, '')
+
     if name != "puppetmasterd" and Puppet::Util::SUIDManager.uid != 0
         conf = File.expand_path("~/.puppet")
         var = File.expand_path("~/.puppet/var")
@@ -14,7 +15,7 @@ module Puppet
         var = "/var/puppet"
     end
 
-    self.setdefaults(:puppet,
+    self.setdefaults(:main,
         :confdir => [conf, "The main Puppet configuration directory.  The default for this parameter is calculated based on the user.  If the process
         is runnig as root or the user that ``puppetmasterd`` is supposed to run as, it defaults to a system directory, but if it's running as any other user,
         it defaults to being in ``~``."],
@@ -33,7 +34,7 @@ module Puppet
     else
         logopts = ["$vardir/log", "The Puppet log directory."]
     end
-    setdefaults(:puppet, :logdir => logopts)
+    setdefaults(:main, :logdir => logopts)
     
     # This name hackery is necessary so that the rundir is set reasonably during
     # unit tests.
@@ -43,7 +44,7 @@ module Puppet
         rundir = "$vardir/run"
     end
 
-    self.setdefaults(:puppet,
+    self.setdefaults(:main,
         :trace => [false, "Whether to print stack traces on some errors"],
         :autoflush => [false, "Whether log files should always flush to disk."],
         :syslogfacility => ["daemon", "What syslog facility to use when logging to
@@ -124,9 +125,141 @@ module Puppet
         ]
     )
 
+    hostname = Facter["hostname"].value
+    domain = Facter["domain"].value
+    if domain and domain != ""
+        fqdn = [hostname, domain].join(".")
+    else
+        fqdn = hostname
+    end
+
+    Puppet.setdefaults(:ssl,
+        :certname => [fqdn, "The name to use when handling certificates.  Defaults
+            to the fully qualified domain name."],
+        :certdir => ["$ssldir/certs", "The certificate directory."],
+        :publickeydir => ["$ssldir/public_keys", "The public key directory."],
+        :privatekeydir => { :default => "$ssldir/private_keys",
+            :mode => 0750,
+            :desc => "The private key directory."
+        },
+        :privatedir => { :default => "$ssldir/private",
+            :mode => 0750,
+            :desc => "Where the client stores private certificate information."
+        },
+        :passfile => { :default => "$privatedir/password",
+            :mode => 0640,
+            :desc => "Where puppetd stores the password for its private key.
+                Generally unused."
+        },
+        :hostcsr => { :default => "$ssldir/csr_$certname.pem",
+            :mode => 0644,
+            :desc => "Where individual hosts store and look for their certificates."
+        },
+        :hostcert => { :default => "$certdir/$certname.pem",
+            :mode => 0644,
+            :desc => "Where individual hosts store and look for their certificates."
+        },
+        :hostprivkey => { :default => "$privatekeydir/$certname.pem",
+            :mode => 0600,
+            :desc => "Where individual hosts store and look for their private key."
+        },
+        :hostpubkey => { :default => "$publickeydir/$certname.pem",
+            :mode => 0644,
+            :desc => "Where individual hosts store and look for their public key."
+        },
+        :localcacert => { :default => "$certdir/ca.pem",
+            :mode => 0644,
+            :desc => "Where each client stores the CA certificate."
+        }
+    )
+
+    setdefaults(:ca,
+        :cadir => {  :default => "$ssldir/ca",
+            :owner => "$user",
+            :group => "$group",
+            :mode => 0770,
+            :desc => "The root directory for the certificate authority."
+        },
+        :cacert => { :default => "$cadir/ca_crt.pem",
+            :owner => "$user",
+            :group => "$group",
+            :mode => 0660,
+            :desc => "The CA certificate."
+        },
+        :cakey => { :default => "$cadir/ca_key.pem",
+            :owner => "$user",
+            :group => "$group",
+            :mode => 0660,
+            :desc => "The CA private key."
+        },
+        :capub => { :default => "$cadir/ca_pub.pem",
+            :owner => "$user",
+            :group => "$group",
+            :desc => "The CA public key."
+        },
+        :cacrl => { :default => "$cadir/ca_crl.pem",
+            :owner => "$user",
+            :group => "$group",
+            :mode => 0664,
+            :desc => "The certificate revocation list (CRL) for the CA. Set this to 'none' if you do not want to use a CRL."
+        },
+        :caprivatedir => { :default => "$cadir/private",
+            :owner => "$user",
+            :group => "$group",
+            :mode => 0770,
+            :desc => "Where the CA stores private certificate information."
+        },
+        :csrdir => { :default => "$cadir/requests",
+            :owner => "$user",
+            :group => "$group",
+            :desc => "Where the CA stores certificate requests"
+        },
+        :signeddir => { :default => "$cadir/signed",
+            :owner => "$user",
+            :group => "$group",
+            :mode => 0770,
+            :desc => "Where the CA stores signed certificates."
+        },
+        :capass => { :default => "$caprivatedir/ca.pass",
+            :owner => "$user",
+            :group => "$group",
+            :mode => 0660,
+            :desc => "Where the CA stores the password for the private key"
+        },
+        :serial => { :default => "$cadir/serial",
+            :owner => "$user",
+            :group => "$group",
+            :desc => "Where the serial number for certificates is stored."
+        },
+        :autosign => { :default => "$confdir/autosign.conf",
+            :mode => 0644,
+            :desc => "Whether to enable autosign.  Valid values are true (which
+                autosigns any key request, and is a very bad idea), false (which
+                never autosigns any key request), and the path to a file, which
+                uses that configuration file to determine which keys to sign."},
+        :ca_days => ["", "How long a certificate should be valid. 
+                 This parameter is deprecated, use ca_ttl instead"],
+        :ca_ttl => ["5y", "The default TTL for new certificates; valid values 
+                must be an integer, optionally followed by one of the units 
+                'y' (years of 365 days), 'd' (days), 'h' (hours), or 
+                's' (seconds). The unit defaults to seconds. If this parameter
+                is set, ca_days is ignored. Examples are '3600' (one hour) 
+                and '1825d', which is the same as '5y' (5 years) "],
+        :ca_md => ["md5", "The type of hash used in certificates."],
+        :req_bits => [2048, "The bit length of the certificates."],
+        :keylength => [1024, "The bit length of keys."],
+        :cert_inventory => {
+            :default => "$cadir/inventory.txt",
+            :mode => 0644,
+            :owner => "$user",
+            :group => "$group",
+            :desc => "A Complete listing of all certificates"
+        }
+    )
+
     # Define the config default.
-    self.setdefaults(self.name,
-        :config => ["$confdir/#{Puppet[:name]}.conf",
+    self.setdefaults(self.config[:name],
+        :config => ["$confdir/puppet.conf",
             "The configuration file for #{Puppet[:name]}."],
         :pidfile => ["", "The pid file"],
         :bindaddress => ["", "The address to bind to.  Mongrel servers
@@ -137,7 +270,7 @@ module Puppet
             speak SSL."]
     )
 
-    self.setdefaults("puppetmasterd",
+    self.setdefaults(:puppetmasterd,
         :user => ["puppet", "The user puppetmasterd should run as."],
         :group => ["puppet", "The group puppetmasterd should run as."],
         :manifestdir => ["$confdir/manifests",
@@ -176,16 +309,20 @@ module Puppet
         :ca => [true, "Wether the master should function as a certificate authority."],
         :modulepath => [ "$confdir/modules:/usr/share/puppet/modules",
            "The search path for modules as a colon-separated list of
-            directories." ]
+            directories." ],
+        :ssl_client_header => ["HTTP_X_CLIENT_DN", "The header containing an authenticated
+            client's SSL DN.  Only used with Mongrel.  This header must be set by the proxy
+            to the authenticated client's SSL DN (e.g., ``/CN=puppet.reductivelabs.com``).
+            See the `UsingMongrel`:trac: wiki page for more information."]
     )
 
-    self.setdefaults("puppetd",
+    self.setdefaults(:puppetd,
         :localconfig => { :default => "$statedir/localconfig",
             :owner => "root",
             :mode => 0660,
             :desc => "Where puppetd caches the local configuration.  An
                 extension indicating the cache format is added automatically."},
-        :classfile => { :default => "$confdir/classes.txt",
+        :classfile => { :default => "$statedir/classes.txt",
             :owner => "root",
             :mode => 0644,
             :desc => "The file in which puppetd stores a list of the classes
@@ -222,14 +359,14 @@ module Puppet
         :ca_port => ["$masterport", "The port to use for the certificate authority."]
     )
         
-    self.setdefaults("filebucket",
+    self.setdefaults(:filebucket,
         :clientbucketdir => {
             :default => "$vardir/clientbucket",
             :mode => 0750,
             :desc => "Where FileBucket files are stored locally."
         }
     )
-    self.setdefaults("fileserver",
+    self.setdefaults(:fileserver,
         :fileserverconfig => ["$confdir/fileserver.conf",
             "Where the fileserver configuration is stored."]
     )
@@ -247,7 +384,7 @@ module Puppet
                     received from the client.  Each client gets a separate
                     subdirectory."}
     )
-    self.setdefaults("puppetd",
+    self.setdefaults(:puppetd,
         :puppetdlockfile => [ "$statedir/puppetdlock",
             "A lock file to temporarily stop puppetd from doing anything."],
         :usecacheonfailure => [true,
@@ -263,7 +400,17 @@ module Puppet
             change or if the server changes."
         ],
         :downcasefacts => [false,
-            "Whether facts should be made all lowercase when sent to the server."]
+            "Whether facts should be made all lowercase when sent to the server."],
+        :dynamicfacts => ["memorysize,memoryfree,swapsize,swapfree",
+            "Facts that are dynamic; these facts will be ignored when deciding whether
+            changed facts should result in a recompile.  Multiple facts should be
+            comma-separated."],
+        :splaylimit => ["$runinterval",
+            "The maximum time to delay before runs.  Defaults to being the same as the
+            run interval."],
+        :splay => [false,
+            "Whether to sleep for a pseudo-random (but consistent) amount of time before
+            a run."]
     )
 
     self.setdefaults(:puppetd,
@@ -281,7 +428,7 @@ module Puppet
     )
 
     # Plugin information.
-    self.setdefaults("puppet",
+    self.setdefaults(:main,
         :pluginpath => ["$vardir/plugins",
             "Where Puppet should look for plugins.  Multiple directories should
             be colon-separated, like normal PATH variables."],
@@ -299,7 +446,7 @@ module Puppet
     )
 
     # Central fact information.
-    self.setdefaults("puppet",
+    self.setdefaults(:main,
         :factpath => ["$vardir/facts",
             "Where Puppet should look for facts.  Multiple directories should
             be colon-separated, like normal PATH variables."],
@@ -316,7 +463,7 @@ module Puppet
             "What files to ignore when pulling down facts."]
     )
 
-    self.setdefaults(:reporting,
+    self.setdefaults(:tagmail,
         :tagmap => ["$confdir/tagmail.conf",
             "The mapping between reporting tags and email addresses."],
         :sendmail => [%x{which sendmail 2>/dev/null}.chomp,
@@ -326,6 +473,154 @@ module Puppet
         :smtpserver => ["none",
             "The server through which to send email reports."]
     )
+
+    self.setdefaults(:facts,
+        :factstore => ["yaml",
+            "The backend store to use for client facts."]
+    )
+
+    self.setdefaults(:yamlfacts,
+        :yamlfactdir => ["$vardir/facts",
+            "The directory in which client facts are stored when the yaml fact store is used."]
+    )
+
+    self.setdefaults(:rails,
+        :dblocation => { :default => "$statedir/clientconfigs.sqlite3",
+            :mode => 0660,
+            :owner => "$user",
+            :group => "$group",
+            :desc => "The database cache for client configurations.  Used for
+                querying within the language."
+        },
+        :dbadapter => [ "sqlite3", "The type of database to use." ],
+        :dbmigrate => [ false, "Whether to automatically migrate the database." ],
+        :dbname => [ "puppet", "The name of the database to use." ],
+        :dbserver => [ "localhost", "The database server for Client caching. Only
+            used when networked databases are used."],
+        :dbuser => [ "puppet", "The database user for Client caching. Only
+            used when networked databases are used."],
+        :dbpassword => [ "puppet", "The database password for Client caching. Only
+            used when networked databases are used."],
+        :railslog => {:default => "$logdir/rails.log",
+            :mode => 0600,
+            :owner => "$user",
+            :group => "$group",
+            :desc => "Where Rails-specific logs are sent"
+        }
+    )
+
+    setdefaults(:graphing,
+        :graph => [false, "Whether to create dot graph files for the different
+            configuration graphs.  These dot files can be interpreted by tools
+            like OmniGraffle or dot (which is part of ImageMagick)."],
+        :graphdir => ["$statedir/graphs", "Where to store dot-outputted graphs."]
+    )
+
+    setdefaults(:transaction,
+        :tags => ["", "Tags to use to find resources.  If this is set, then
+            only resources tagged with the specified tags will be applied.
+            Values must be comma-separated."],
+        :evaltrace => [false, "Whether each resource should log when it is
+            being evaluated.  This allows you to interactively see exactly
+            what is being done."],
+        :summarize => [false,
+            "Whether to print a transaction summary."
+        ]
+    )
+
+    setdefaults(:parser,
+        :typecheck => [true, "Whether to validate types during parsing."],
+        :paramcheck => [true, "Whether to validate parameters during parsing."]
+    )
+    
+    setdefaults(:main,
+        :casesensitive => [false,
+            "Whether matching in case statements and selectors
+            should be case-sensitive.  Case insensitivity is
+            handled by downcasing all values before comparison."],
+        :external_nodes => ["none",
+            "An external command that can produce node information.  The output
+            must be a YAML dump of a hash, and that hash must have one or both of
+            ``classes`` and ``parameters``, where ``classes`` is an array and
+            ``parameters`` is a hash.  For unknown nodes, the commands should
+            exit with a non-zero exit code.
+
+            This command makes it straightforward to store your node mapping
+            information in other data sources like databases."])
+
+    setdefaults(:ldap,
+        :ldapnodes => [false,
+            "Whether to search for node configurations in LDAP."],
+        :ldapssl => [false,
+            "Whether SSL should be used when searching for nodes.
+            Defaults to false because SSL usually requires certificates
+            to be set up on the client side."],
+        :ldaptls => [false,
+            "Whether TLS should be used when searching for nodes.
+            Defaults to false because TLS usually requires certificates
+            to be set up on the client side."],
+        :ldapserver => ["ldap",
+            "The LDAP server.  Only used if ``ldapnodes`` is enabled."],
+        :ldapport => [389,
+            "The LDAP port.  Only used if ``ldapnodes`` is enabled."],
+        :ldapstring => ["(&(objectclass=puppetClient)(cn=%s))",
+            "The search string used to find an LDAP node."],
+        :ldapclassattrs => ["puppetclass",
+            "The LDAP attributes to use to define Puppet classes.  Values
+            should be comma-separated."],
+        :ldapattrs => ["all",
+            "The LDAP attributes to include when querying LDAP for nodes.  All
+            returned attributes are set as variables in the top-level scope.
+            Multiple values should be comma-separated.  The value 'all' returns
+            all attributes."],
+        :ldapparentattr => ["parentnode",
+            "The attribute to use to define the parent node."],
+        :ldapuser => ["",
+            "The user to use to connect to LDAP.  Must be specified as a
+            full DN."],
+        :ldappassword => ["",
+            "The password to use to connect to LDAP."],
+        :ldapbase => ["",
+            "The search base for LDAP searches.  It's impossible to provide
+            a meaningful default here, although the LDAP libraries might
+            have one already set.  Generally, it should be the 'ou=Hosts'
+            branch under your main directory."]
+    )
+
+    setdefaults(:puppetmasterd,
+        :storeconfigs => [false,
+            "Whether to store each client's configuration.  This
+             requires ActiveRecord from Ruby on Rails."]
+    )
+
+    # This doesn't actually work right now.
+    setdefaults(:parser,
+        :lexical => [false, "Whether to use lexical scoping (vs. dynamic)."],
+        :templatedir => ["$vardir/templates",
+            "Where Puppet looks for template files."
+        ]
+    )
+
+    setdefaults(:main,
+        :filetimeout => [ 15,
+            "The minimum time to wait (in seconds) between checking for updates in
+            configuration files.  This timeout determines how quickly Puppet checks whether
+            a file (such as manifests or templates) has changed on disk."
+        ]
+    )
+
+    setdefaults(:metrics,
+        :rrddir => {:default => "$vardir/rrd",
+            :owner => "$user",
+            :group => "$group",
+            :desc => "The directory where RRD database files are stored.
+                Directories for each reporting host will be created under
+                this directory."
+        },
+        :rrdgraph => [false, "Whether RRD information should be graphed."],
+        :rrdinterval => ["$runinterval", "How often RRD should expect data.
+            This should match how often the hosts report back to the server."]
+    )
 end
 
-# $Id: configuration.rb 2411 2007-04-24 18:59:20Z luke $
+# $Id: configuration.rb 2587 2007-06-15 02:40:20Z luke $