puppet 0.22.4 → 0.23.0

data/lib/puppet/reference/report.rb

@@ -0,0 +1,21 @@
+report = Puppet::Util::Reference.newreference :report, :doc => "All available transaction reports" do
+    Puppet::Network::Handler.report.reportdocs
+end
+
+report.header = "
+Puppet clients can report back to the server after each transaction.  This
+transaction report is sent as a YAML dump of the
+``Puppet::Transaction::Report`` class and includes every log message that was
+generated during the transaction along with as many metrics as Puppet knows how
+to collect.  See `ReportsAndReporting Reports and Reporting`:trac:
+for more information on how to use reports.
+
+Currently, clients default to not sending in reports; you can enable reporting
+by setting the ``report`` parameter to true.
+
+To use a report, set the ``reports`` parameter on the server; multiple
+reports must be comma-separated.  You can also specify ``none`` to disable
+reports entirely.
+
+Puppet provides multiple report handlers that will process client reports:
+"

data/lib/puppet/reference/type.rb

@@ -0,0 +1,152 @@
+type = Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource types and all their details" do
+    types = {}
+    Puppet::Type.loadall
+
+    Puppet::Type.eachtype { |type|
+        next if type.name == :puppet
+        next if type.name == :component
+        types[type.name] = type
+    }
+
+    str = %{
+Metaparameters
+--------------
+Metaparameters are parameters that work with any element; they are part of the
+Puppet framework itself rather than being part of the implementation of any
+given instance.  Thus, any defined metaparameter can be used with any instance
+in your manifest, including defined components.
+
+Available Metaparameters
+++++++++++++++++++++++++
+}
+    begin
+        params = []
+        Puppet::Type.eachmetaparam { |param|
+            params << param
+        }
+
+        params.sort { |a,b|
+            a.to_s <=> b.to_s
+        }.each { |param|
+            str += paramwrap(param.to_s, scrub(Puppet::Type.metaparamdoc(param)), :level => 4)
+            #puts "<dt>" + param.to_s + "</dt>"
+            #puts tab(1) + Puppet::Type.metaparamdoc(param).scrub.indent($tab)gsub(/\n\s*/,' ')
+            #puts "<dd>"
+            #puts indent(scrub(Puppet::Type.metaparamdoc(param)), $tab)
+            #puts scrub(Puppet::Type.metaparamdoc(param))
+            #puts "</dd>"
+
+            #puts ""
+        }
+    rescue => detail
+        puts detail.backtrace
+        puts "incorrect metaparams: %s" % detail
+        exit(1)
+    end
+
+    str += %{
+
+Resource Types
+--------------
+
+- The *namevar* is the parameter used to uniquely identify a type instance.
+  This is the parameter that gets assigned when a string is provided before
+  the colon in a type declaration.  In general, only developers will need to
+  worry about which parameter is the ``namevar``.
+  
+  In the following code::
+
+      file { "/etc/passwd":
+          owner => root,
+          group => root,
+          mode => 644
+      }
+
+  ``/etc/passwd`` is considered the title of the file object (used for things like
+  dependency handling), and because ``path`` is the namevar for ``file``, that
+  string is assigned to the ``path`` parameter.
+
+- *Features* are abilities that some providers might not support.  You can use the list
+  of supported features to determine how a given provider can be used.
+
+- *Parameters* determine the specific configuration of the instance.  They either
+  directly modify the system (internally, these are called properties) or they affect
+  how the instance behaves (e.g., adding a search path for ``exec`` instances
+  or determining recursion on ``file`` instances).
+
+- *Providers* provide low-level functionality for a given resource type.  This is
+  usually in the form of calling out to external commands.
+
+  When required binaries are specified for providers, fully qualifed paths
+  indicate that the binary must exist at that specific path and unqualified
+  binaries indicate that Puppet will search for the binary using the shell
+  path.
+
+  Resource types define features they can use, and providers can be tested to see
+  which features they provide.
+
+    }
+
+    types.sort { |a,b|
+        a.to_s <=> b.to_s
+    }.each { |name,type|
+
+        str += "
+
+----------------
+
+"
+
+        str += h(name, 3)
+        str += scrub(type.doc) + "\n\n"
+
+        # Handle the feature docs.
+        if featuredocs = type.featuredocs
+            str += h("Features", 4)
+            str += featuredocs
+        end
+
+        docs = {}
+        type.validproperties.sort { |a,b|
+            a.to_s <=> b.to_s
+        }.reject { |sname|
+            property = type.propertybyname(sname)
+            property.nodoc
+        }.each { |sname|
+            property = type.propertybyname(sname)
+
+            unless property
+                raise "Could not retrieve property %s on type %s" % [sname, type.name]
+            end
+
+            doc = nil
+            unless doc = property.doc
+                $stderr.puts "No docs for %s[%s]" % [type, sname]
+                next
+            end
+            doc = doc.dup
+            tmp = doc
+            tmp = scrub(tmp)
+
+            docs[sname]  = tmp
+        }
+
+        str += h("Parameters", 4) + "\n"
+        type.parameters.sort { |a,b|
+            a.to_s <=> b.to_s
+        }.each { |name,param|
+            #docs[name] = indent(scrub(type.paramdoc(name)), $tab)
+            docs[name] = scrub(type.paramdoc(name))
+        }
+
+        docs.sort { |a, b|
+            a[0].to_s <=> b[0].to_s
+        }.each { |name, doc|
+            namevar = type.namevar == name and name != :name
+            str += paramwrap(name, doc, :namevar => namevar)
+        }
+        str += "\n"
+    }
+
+    str
+end

data/lib/puppet/reports/rrdgraph.rb

@@ -2,10 +2,11 @@ require 'puppet'
 
 Puppet::Network::Handler.report.newreport(:rrdgraph) do
     desc "Graph all available data about hosts using the RRD library.  You
-        must have the RRD binary ruby library installed to use this report, which
-        you can get from `Tobias Oetiker's site`_.
+        must have the Ruby RRDtool library installed to use this report, which
+        you can get from `the RubyRRDTool RubyForge page`_.  This package requires
+        the binary rrdtool2 package to be installed.
 
-        .. _tobias oetiker's site: http://oss.oetiker.ch/rrdtool/pub/contrib/
+        .. _the RubyRRDTool RubyForge page: http://rubyforge.org/projects/rubyrrdtool/
         
         This report will create, manage, and graph RRD database files for each
         of the metrics generated during transactions, and it will create a
@@ -99,10 +100,10 @@ Puppet::Network::Handler.report.newreport(:rrdgraph) do
     def process(time = nil)
         time ||= Time.now.to_i
 
-        unless File.directory?(hostdir)
-            # Some hackishness to create the dir
+        unless File.directory?(hostdir) and FileTest.writable?(hostdir)
+            # Some hackishness to create the dir with all of the right modes and ownership
             config = Puppet::Util::Config.new
-            config.setdefaults(:reports, :hostdir => [hostdir, "eh"])
+            config.setdefaults(:reports, :hostdir => {:default => hostdir, :owner => Puppet[:user], :mode => 0755, :group => Puppet[:group], :desc => "eh"})
 
             # This creates the dir.
             config.use(:reports)
@@ -110,6 +111,11 @@ Puppet::Network::Handler.report.newreport(:rrdgraph) do
 
         self.metrics.each do |name, metric|
             metric.basedir = hostdir
+
+            if name == "time"
+                timeclean(metric)
+            end
+
             metric.store(time)
 
             metric.graph
@@ -119,6 +125,14 @@ Puppet::Network::Handler.report.newreport(:rrdgraph) do
             mkhtml()
         end
     end
+
+    # Unfortunately, RRD does not deal well with changing lists of values,
+    # so we have to pick a list of values and stick with it.  In this case,
+    # that means we record the total time, the config time, and that's about
+    # it.  We should probably send each type's time as a separate metric.
+    def timeclean(metric)
+        metric.values = metric.values.find_all { |name, label, value| [:total, :config_retrieval].include?(name) }
+    end
 end
 
-# $Id: rrdgraph.rb 2438 2007-04-30 18:15:01Z luke $
+# $Id: rrdgraph.rb 2603 2007-06-18 16:26:22Z luke $

data/lib/puppet/reports/tagmail.rb

@@ -30,6 +30,9 @@ Puppet::Network::Handler.report.newreport(:tagmail) do
         webservers that are not also from mailservers to ``httpadmins@domain.com``.
         "
 
+
+    Puppet.config.use(:tagmail)
+
     # Find all matching messages.
     def match(taglists)
         reports = []
@@ -164,4 +167,4 @@ Puppet::Network::Handler.report.newreport(:tagmail) do
     end
 end
 
-# $Id: tagmail.rb 2406 2007-04-23 06:16:10Z luke $
+# $Id: tagmail.rb 2463 2007-05-04 23:09:34Z luke $

data/lib/puppet/sslcertificates.rb

@@ -9,54 +9,6 @@ rescue LoadError
 end
 
 module Puppet::SSLCertificates
-    hostname = Facter["hostname"].value
-    domain = Facter["domain"].value
-    if domain and domain != ""
-        fqdn = [hostname, domain].join(".")
-    else
-        fqdn = hostname
-    end
-
-    Puppet.setdefaults("certificates",
-        :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."
-        }
-    )
-
     #def self.mkcert(type, name, ttl, issuercert, issuername, serial, publickey)
     def self.mkcert(hash)
         [:type, :name, :ttl, :issuer, :serial, :publickey].each { |param|
@@ -190,4 +142,4 @@ module Puppet::SSLCertificates
     require 'puppet/sslcertificates/ca'
 end
 
-# $Id: sslcertificates.rb 2376 2007-03-30 23:45:48Z luke $
+# $Id: sslcertificates.rb 2463 2007-05-04 23:09:34Z luke $

data/lib/puppet/sslcertificates/ca.rb

@@ -4,83 +4,6 @@ class Puppet::SSLCertificates::CA
     Certificate = Puppet::SSLCertificates::Certificate
     attr_accessor :keyfile, :file, :config, :dir, :cert, :crl
 
-    Puppet.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."]
-    )
-
     def certfile
         @config[:cacert]
     end
@@ -128,7 +51,7 @@ class Puppet::SSLCertificates::CA
     end
 
     def initialize(hash = {})
-        Puppet.config.use(:puppet, :certificates, :ca)
+        Puppet.config.use(:main, :ca, :ssl)
         self.setconfig(hash)
 
         if Puppet[:capass]
@@ -459,4 +382,4 @@ class Puppet::SSLCertificates::CA
     end
 end
 
-# $Id: ca.rb 2259 2007-03-06 19:03:05Z luke $
+# $Id: ca.rb 2463 2007-05-04 23:09:34Z luke $

data/lib/puppet/sslcertificates/inventory.rb

@@ -3,16 +3,6 @@
 module Puppet::SSLCertificates
     module Inventory
 
-        Puppet.config.setdefaults(:ca,
-            :cert_inventory => {
-                :default => "$cadir/inventory.txt",
-                :mode => 0644,
-                :owner => "$user",
-                :group => "$group",
-                :desc => "A Complete listing of all certificates"
-            }
-        )
-
         # Add CERT to the inventory of issued certs in '$cadir/inventory.txt'
         # If no inventory exists yet, build an inventory and list all the 
         # certificates that have been signed so far

data/lib/puppet/transaction.rb

@@ -15,21 +15,6 @@ class Transaction
 
     include Puppet::Util
 
-    Puppet.config.setdefaults(:puppet,
-        :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."]
-    )
-    Puppet.config.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."]
-    )
-
     # Add some additional times for reporting
     def addtimes(hash)
         hash.each do |name, num|
@@ -122,7 +107,7 @@ class Transaction
                     puts detail.backtrace
                 end
                 change.property.err "change from %s to %s failed: %s" %
-                    [change.property.is_to_s, change.property.should_to_s, detail]
+                    [change.property.is_to_s(change.is), change.property.should_to_s(change.should), detail]
                 @failures[resource] += 1
                 next
                 # FIXME this should support using onerror to determine
@@ -144,7 +129,7 @@ class Transaction
     # Find all of the changed resources.
     def changed?
         @changes.find_all { |change| change.changed }.collect { |change|
-            change.property.parent
+            change.property.resource
         }.uniq
     end
     
@@ -409,16 +394,6 @@ class Transaction
             total
         end
 
-        # Unfortunately, RRD does not deal well with changing lists of values,
-        # so we have to pick a list of values and stick with it.  In this case,
-        # that means we record the total time, the config time, and that's about
-        # it.  We should probably send each type's time as a separate metric.
-        @timemetrics.dup.each do |name, value|
-            if Puppet::Type.type(name)
-                @timemetrics.delete(name)
-            end
-        end
-
         # Add all of the metrics related to resource count and status
         @report.newmetric(:resources, @resourcemetrics)
 
@@ -442,6 +417,8 @@ class Transaction
         
         return unless Puppet[:graph]
 
+        Puppet.config.use(:graphing)
+
         file = File.join(Puppet[:graphdir], "%s.dot" % name.to_s)
         File.open(file, "w") { |f|
             f.puts gr.to_dot("name" => name.to_s.capitalize)
@@ -496,16 +473,24 @@ class Transaction
     # Prefetch any providers that support it.  We don't support prefetching
     # types, just providers.
     def prefetch
-        @resources.collect { |obj|
-            if pro = obj.provider
-                pro.class
-            else
-                nil
+        prefetchers = {}
+        @resources.each do |resource|
+            if provider = resource.provider and provider.class.respond_to?(:prefetch)
+                prefetchers[provider.class] ||= {}
+                prefetchers[provider.class][resource.title] = resource
             end
-        }.reject { |o| o.nil? }.uniq.each do |klass|
-            # XXX We need to do something special here in case of failure.
-            if klass.respond_to?(:prefetch)
-                klass.prefetch
+        end
+
+        # Now call prefetch, passing in the resources so that the provider instances can be replaced.
+        prefetchers.each do |provider, resources|
+            Puppet.debug "Prefetching %s resources for %s" % [provider.name, provider.resource_type.name]
+            begin
+                provider.prefetch(resources)
+            rescue => detail
+                if Puppet[:trace]
+                    puts detail.backtrace
+                end
+                Puppet.err "Could not prefetch % provider %s: %s" % [resources[0].class.name, provider.name, detail]
             end
         end
     end
@@ -520,10 +505,8 @@ class Transaction
         # Create a relationship graph from our resource graph
         @relgraph = relationship_graph
         
+        # This will throw an error if there are cycles in the graph.
         @sorted_resources = @relgraph.topsort
-
-        # Now make sure no cycles crept into our graph.
-        @relgraph.check_cycle(@sorted_resources)
     end
     
     # Create a graph of all of the relationships in our resource graph.
@@ -596,7 +579,7 @@ class Transaction
             # Now check to see if there are any events for this child.
             # Kind of hackish, since going backwards goes a change at a
             # time, not a child at a time.
-            trigger(change.property.parent)
+            trigger(change.property.resource)
 
             # And return the events for collection
             events
@@ -754,4 +737,4 @@ end
 
 require 'puppet/transaction/report'
 
-# $Id: transaction.rb 2372 2007-03-30 00:47:03Z luke $
+# $Id: transaction.rb 2621 2007-06-18 21:56:11Z luke $