puppet 0.22.4 → 0.23.0

data/lib/puppet/rails/param_name.rb

@@ -4,17 +4,12 @@ require 'puppet/rails/param_value'
 class Puppet::Rails::ParamName < ActiveRecord::Base
     include Puppet::Util::CollectionMerger
     has_many :param_values, :dependent => :destroy 
-#        def <<(value)
-#            ParamValue.with_scope(:create => {:value => value})
-#        end
-##    end
-    belongs_to :resource
 
-    def to_resourceparam(source)
+    def to_resourceparam(resource, source)
         hash = {}
         hash[:name] = self.name.to_sym
         hash[:source] = source
-        hash[:value] = self.param_values.find(:all).collect { |v| v.value }
+        hash[:value] = resource.param_values.find(:all, :conditions => [ "param_name_id = ?", self]).collect { |v| v.value }
         if hash[:value].length == 1
             hash[:value] = hash[:value].shift
         end
@@ -25,4 +20,4 @@ class Puppet::Rails::ParamName < ActiveRecord::Base
     end
 end
 
-# $Id: param_name.rb 2296 2007-03-18 22:48:57Z luke $
+# $Id: param_name.rb 2565 2007-06-12 00:31:16Z ballman $

data/lib/puppet/rails/param_value.rb

@@ -1,5 +1,6 @@
 class Puppet::Rails::ParamValue < ActiveRecord::Base
     belongs_to :param_name
+    belongs_to :resource
 end
 
-# $Id: param_value.rb 2296 2007-03-18 22:48:57Z luke $
+# $Id: param_value.rb 2565 2007-06-12 00:31:16Z ballman $

data/lib/puppet/rails/puppet_class.rb

@@ -2,8 +2,6 @@ class Puppet::Rails::PuppetClass < ActiveRecord::Base
     has_many :resources
     has_many :source_files
     has_many :hosts
-
-    acts_as_taggable
 end
 
 # $Id$

data/lib/puppet/rails/puppet_tag.rb

@@ -0,0 +1,5 @@
+require 'puppet/rails/resource_tag'
+class Puppet::Rails::PuppetTag < ActiveRecord::Base
+    has_many :resource_tags, :dependent => :destroy
+    has_many :resources, :through => :resource_tags
+end

data/lib/puppet/rails/resource.rb

@@ -1,21 +1,23 @@
 require 'puppet'
-require 'puppet/rails/external/tagging/init'
 require 'puppet/rails/param_name'
+require 'puppet/rails/puppet_tag'
 require 'puppet/util/rails/collection_merger'
 
 class Puppet::Rails::Resource < ActiveRecord::Base
     include Puppet::Util::CollectionMerger
 
-    has_many :param_values, :through => :param_names
-    has_many :param_names, :dependent => :destroy
+    has_many :param_values, :dependent => :destroy
+    has_many :param_names, :through => :param_values
+
+    has_many :resource_tags, :dependent => :destroy
+    has_many :puppet_tags, :through => :resource_tags
+    
     belongs_to :source_file
     belongs_to :host
 
-    acts_as_taggable
-    
-    def tags=(tags)
-        #puts "setting tags %s" % tags.inspect
-        self.tag_with(tags.join(","))
+    def add_resource_tag(tag)
+        pt = Puppet::Rails::PuppetTag.find_or_create_by_name(tag, :include => :puppet_tag)
+        resource_tags.create(:puppet_tag => pt)
     end
 
     def file
@@ -27,7 +29,25 @@ class Puppet::Rails::Resource < ActiveRecord::Base
     end
 
     def file=(file)
-        self.source_file = Puppet::Rails::SourceFile.new(:filename => file)
+        self.source_file = Puppet::Rails::SourceFile.find_or_create_by_filename(file)
+    end
+
+    # returns a hash of param_names.name => [param_values]
+    def get_params_hash(values = nil)
+        values ||= param_values.find(:all, :include => :param_name)
+        values.inject({}) do | hash, value |
+            hash[value.param_name.name] ||= []
+            hash[value.param_name.name] << value
+            hash
+        end
+    end
+    
+    def get_tag_hash(tags = nil)
+        tags ||= resource_tags.find(:all, :include => :puppet_tag)
+        return tags.inject({}) do |hash, tag|
+            hash[tag.puppet_tag.name] = tag.puppet_tag.name
+            hash
+        end
     end
 
     def [](param)
@@ -40,7 +60,7 @@ class Puppet::Rails::Resource < ActiveRecord::Base
 
     def parameter(param)
         if pn = param_names.find_by_name(param)
-            if pv = pn.param_values.find(:first)
+            if pv = param_values.find(:first, :conditions => [ 'param_name_id = ?', pn]                                                            )
                 return pv.value
             else
                 return nil
@@ -49,12 +69,15 @@ class Puppet::Rails::Resource < ActiveRecord::Base
     end
 
     def parameters
-        hash = {}
-        self.param_values.find(:all).each do |pvalue|
-            pname = pvalue.param_name.name
-            hash.store(pname, pvalue.value)
+        result = get_params_hash
+        result.each do |param, value|
+            if value.is_a?(Array)
+                result[param] = value.collect { |v| v.value }
+            else
+                result[param] = value.value
+            end
         end
-        return hash
+        result
     end
 
     def ref
@@ -81,8 +104,9 @@ class Puppet::Rails::Resource < ActiveRecord::Base
         hash[:scope] = scope
         hash[:source] = scope.source
         obj = Puppet::Parser::Resource.new(hash)
+
         self.param_names.each do |pname|
-            obj.set(pname.to_resourceparam(scope.source))
+            obj.set(pname.to_resourceparam(self, scope.source))
         end
 
         # Store the ID, so we can check if we're re-collecting the same resource.
@@ -92,4 +116,4 @@ class Puppet::Rails::Resource < ActiveRecord::Base
     end
 end
 
-# $Id: resource.rb 2350 2007-03-24 21:24:29Z luke $
+# $Id: resource.rb 2597 2007-06-17 21:41:50Z luke $

data/lib/puppet/rails/resource_tag.rb

@@ -0,0 +1,4 @@
+class Puppet::Rails::ResourceTag < ActiveRecord::Base
+    belongs_to :puppet_tag
+    belongs_to :resource
+end

data/lib/puppet/reference/configuration.rb

@@ -0,0 +1,149 @@
+config = Puppet::Util::Reference.newreference(:configuration, :depth => 1, :doc => "A reference for all configuration parameters") do
+    docs = {}
+    Puppet.config.each do |name, object|
+        docs[name] = object
+    end
+
+    str = ""
+    docs.sort { |a, b|
+        a[0].to_s <=> b[0].to_s
+    }.each do |name, object|
+        # Make each name an anchor
+        header = name.to_s
+        str += h(header, 3)
+
+        # Print the doc string itself
+        begin
+            str += object.desc.gsub(/\n/, " ")
+        rescue => detail
+            puts detail.backtrace
+            puts detail
+        end
+        str += "\n\n"
+
+        # Now print the data about the item.
+        str += ""
+        val = object.default
+        if name.to_s == "vardir"
+            val = "/var/puppet"
+        elsif name.to_s == "confdir"
+            val = "/etc/puppet"
+        end
+        str += "- **Section**: %s\n" % object.section
+        unless val == ""
+            str += "- **Default**: %s\n" % val
+        end
+        str += "\n"
+    end
+
+    return str
+end
+
+config.header = "
+Specifying Configuration Parameters
+-----------------------------------
+
+On The Command-Line
++++++++++++++++++++
+Every Puppet executable (with the exception of ``puppetdoc``) accepts all of
+the arguments below, but not all of the arguments make sense for every executable.
+Each argument has a section listed with it in parentheses; often, that section
+will map to an executable (e.g., ``puppetd``), in which case it probably only
+makes sense for that one executable.  If ``puppet`` is listed as the section,
+it is most likely an option that is valid for everyone.
+
+This will not always be the case.  I have tried to be as thorough as possible
+in the descriptions of the arguments, so it should be obvious whether an
+argument is appropriate or not.
+
+These arguments can be supplied to the executables either as command-line 
+arugments or in the configuration file for the appropriate executable.  For 
+instance, the command-line invocation below would set the configuration directory
+to ``/private/puppet``::
+  
+    $ puppetd --confdir=/private/puppet
+  
+Note that boolean options are turned on and off with a slightly different syntax
+on the command line::
+
+    $ puppetd --storeconfigs
+      
+    $ puppetd --no-storeconfigs
+
+The invocations above will enable and disable, respectively, the storage of 
+the client configuration.
+
+Configuration Files
++++++++++++++++++++
+As mentioned above, the configuration parameters can also be stored in a 
+configuration file located in the configuration directory (`/etc/puppet` 
+by default).  All executables look for ``puppet.conf`` in their
+configuration directory (although they used to each look to separate files).
+
+All executables will set any parameters set within the ``main`` section,
+while each executable will also look for a section named for the executable
+and load those parameters.  For example, ``puppetd`` will look for a
+section named ``puppetd`, and ``puppetmasterd`` looks for a section
+named ``puppetmasterd``.  This allows you to use a single configuration file
+to customize the settings for all of your executables.
+
+File Format
+'''''''''''
+The file follows INI-style formatting.  Here is an example of a very simple
+``puppet.conf`` file::
+
+    [main]
+        confdir = /private/puppet
+        storeconfigs = true
+    
+Note that boolean parameters must be explicitly specified as `true` or
+`false` as seen above.
+
+If you need to change file parameters (e.g., reset the mode or owner), do
+so within curly braces on the same line::
+
+    [main]
+        myfile = /tmp/whatever {owner = root, mode = 644}
+
+If you're starting out with a fresh configuration, you may wish to let
+the executable generate a template configuration file for you by invoking
+the executable in question with the `--genconfig` command.  The executable
+will print a template configuration to standard output, which can be
+redirected to a file like so::
+
+    $ puppetd --genconfig > /etc/puppet/puppetd.conf
+  
+Note that this invocation will \"clobber\" (throw away) the contents of any
+pre-existing `puppetd.conf` file, so make a backup of your present config
+if it contains valuable information.
+  
+Like the `--genconfig` argument, the executables also accept a `--genmanifest`
+argument, which will generate a manifest that can be used to manage all of 
+Puppet's directories and files and prints it to standard output.  This can
+likewise be redirected to a file::
+
+    $ puppetd --genmanifest > /etc/puppet/manifests/site.pp
+
+Puppet can also create user and group accounts for itself (one `puppet` group
+and one `puppet` user) if it is invoked as `root` with the `--mkusers` argument::
+
+    $ puppetd --mkusers
+  
+Signals
+-------
+The ``puppetd`` and ``puppetmasterd`` executables catch some signals for special 
+handling.  Both daemons catch (``SIGHUP``), which forces the server to restart 
+tself.  Predictably, interrupt and terminate (``SIGINT`` and ``SIGHUP``) will shut 
+down the server, whether it be an instance of ``puppetd`` or ``puppetmasterd``.
+
+Sending the ``SIGUSR1`` signal to an instance of ``puppetd`` will cause it to 
+immediately begin a new configuration transaction with the server.  This 
+signal has no effect on ``puppetmasterd``.
+
+Configuration Parameter Reference
+---------------------------------
+Below is a list of all documented parameters.  Not all of them are valid with all
+Puppet executables, but the executables will ignore any inappropriate values.
+
+"
+

data/lib/puppet/reference/function.rb

@@ -0,0 +1,13 @@
+function = Puppet::Util::Reference.newreference :function, :doc => "All functions available in the parser" do
+    Puppet::Parser::Functions.functiondocs
+end
+function.header = "
+There are two types of functions in Puppet: Statements and rvalues.
+Statements stand on their own and do not return arguments; they are used for
+performing stand-alone work like importing.  Rvalues return values and can
+only be used in a statement requiring a value, such as an assignment or a case
+statement. 
+
+Here are the functions available in Puppet:
+
+"

data/lib/puppet/reference/network.rb

@@ -0,0 +1,37 @@
+network = Puppet::Util::Reference.newreference :network, :depth => 2, :doc => "Available network handlers and clients" do
+    ret = ""
+    Puppet::Network::Handler.subclasses.sort { |a,b| a.to_s <=> b.to_s }.each do |name|
+        handler = Puppet::Network::Handler.handler(name)
+
+        next if ! handler.doc or handler.doc == ""
+
+        interface = handler.interface
+
+        ret += h(name, 2)
+
+        ret += scrub(handler.doc)
+        ret += "\n\n"
+        ret += option(:prefix, interface.prefix)
+        ret += option(:side, handler.side.to_s.capitalize)
+        ret += option(:methods, interface.methods.collect { |ary| ary[0] }.join(", ") )
+        ret += "\n\n"
+    end
+
+    ret
+end
+
+network.header = "
+This is a list of all Puppet network interfaces.  Each interface is
+implemented in the form of a client and a handler; the handler is loaded
+on the server, and the client knows how to call the handler's methods
+appropriately.
+
+Most handlers are meant to be started on the server, usually within
+``puppetmasterd``, and the clients are mostly started on the client,
+usually within ``puppetd``.
+
+You can find the server-side handler for each interface at
+``puppet/network/handler/<name>.rb`` and the client class at
+``puppet/network/client/<name>.rb``.
+
+"

data/lib/puppet/reference/providers.rb

@@ -0,0 +1,118 @@
+# This doesn't get stored in trac, since it changes every time.
+providers = Puppet::Util::Reference.newreference :providers, :title => "Provider Suitability Report", :depth => 1, :dynamic => true, :doc => "Which providers are valid for this machine" do
+    types = []
+    Puppet::Type.loadall
+    Puppet::Type.eachtype do |klass|
+        next unless klass.providers.length > 0
+        types << klass
+    end
+    types.sort! { |a,b| a.name.to_s <=> b.name.to_s }
+
+    unless ARGV.empty?
+        types.reject! { |type| ! ARGV.include?(type.name.to_s) }
+    end
+
+    ret = "Details about this host:\n\n"
+
+    # Throw some facts in there, so we know where the report is from.
+    ["Ruby Version", "Puppet Version", "Operating System", "Operating System Release"].each do |label|
+        name = label.gsub(/\s+/, '')
+        value = Facter.value(name)
+        ret += option(label, value)
+    end
+    ret += "\n"
+
+    count = 1
+
+    # Produce output for each type.
+    types.each do |type|
+        features = type.features
+        ret += "\n" # add a trailing newline
+
+        # Now build up a table of provider suitability.
+        headers = %w{Provider Suitable?} + features.collect { |f| f.to_s }.sort
+
+        table_data = {}
+
+        functional = false
+        notes = []
+        begin
+            default = type.defaultprovider.name
+        rescue Puppet::DevError
+            default = "none"
+        end
+        type.providers.sort { |a,b| a.to_s <=> b.to_s }.each do |pname|
+            data = []
+            table_data[pname] = data
+            provider = type.provider(pname)
+
+            # Add the suitability note
+            if missing = provider.suitable?(false) and missing.empty?
+                data << "**X**"
+                suit = true
+                functional = true
+            else
+                data << "[%s]_" % [count] # A pointer to the appropriate footnote
+                suit = false
+            end
+
+            # Add a footnote with the details about why this provider is unsuitable, if that's the case
+            unless suit
+                details = ".. [%s]\n" % count
+                missing.each do |test, values|
+                    case test
+                    when :exists:
+                        details += "  - Missing files %s\n" % values.join(", ")
+                    when :facter:
+                        values.each do |name, facts|
+                            details += "  - Fact %s (currently %s) not in list %s\n" % [name, Facter.value(name).inspect, facts.join(", ")]
+                        end
+                    when :true:
+                        details += "  - Got %s true tests that should have been false\n" % values
+                    when :false:
+                        details += "  - Got %s false tests that should have been true\n" % values
+                    end
+                end
+                notes << details
+                
+                count += 1
+            end
+
+            # Add a note for every feature
+            features.each do |feature|
+                if provider.features.include?(feature)
+                    data << "**X**"
+                else
+                    data << ""
+                end
+            end
+        end
+
+        ret += h(type.name.to_s + "_", 2)
+
+        ret += ".. _%s: %s\n\n" % [type.name, "http://reductivelabs.com/trac/puppet/wiki/TypeReference#%s" % type.name]
+        ret += option("Default provider", default)
+        ret += doctable(headers, table_data)
+
+        notes.each do |note|
+            ret += note + "\n"
+        end
+
+        ret += "\n"
+    end
+
+    ret += "\n"
+
+    ret
+end
+providers.header = "
+Puppet resource types are usually backed by multiple implementations called ``providers``,
+which handle variance between platforms and tools.
+
+Different providers are suitable or unsuitable on different platforms based on things
+like the presence of a given tool.
+
+Here are all of the provider-backed types and their different providers.  Any unmentioned
+types do not use providers yet.
+
+"