puppet 0.25.5 → 2.6.0

data/lib/puppet/rails/resource_tag.rb

@@ -1,26 +1,26 @@
 class Puppet::Rails::ResourceTag < ActiveRecord::Base
-    belongs_to :puppet_tag
-    belongs_to :resource
+  belongs_to :puppet_tag
+  belongs_to :resource
 
-    def to_label
-      "#{self.puppet_tag.name}"
-    end
+  def to_label
+    "#{self.puppet_tag.name}"
+  end
 
-    # returns an array of hash containing tags of resource
-    def self.find_all_tags_from_resource(db_resource)
-        tags = db_resource.connection.select_all("SELECT t.id, t.resource_id, p.name FROM resource_tags as t INNER JOIN puppet_tags as p ON t.puppet_tag_id=p.id WHERE t.resource_id=%s" % db_resource.id)
-        tags.each do |val|
-            val['resource_id'] = Integer(val['resource_id'])
-        end
-        tags
+  # returns an array of hash containing tags of resource
+  def self.find_all_tags_from_resource(db_resource)
+    tags = db_resource.connection.select_all("SELECT t.id, t.resource_id, p.name FROM resource_tags t INNER JOIN puppet_tags p ON t.puppet_tag_id=p.id WHERE t.resource_id=#{db_resource.id}")
+    tags.each do |val|
+      val['resource_id'] = Integer(val['resource_id'])
     end
+    tags
+  end
 
-    # returns an array of hash containing tags of a host
-    def self.find_all_tags_from_host(db_host)
-        tags = db_host.connection.select_all("SELECT t.id, t.resource_id, p.name FROM resource_tags as t INNER JOIN resources r ON t.resource_id=r.id INNER JOIN puppet_tags as p ON t.puppet_tag_id=p.id WHERE r.host_id=%s" % db_host.id)
-        tags.each do |val|
-            val['resource_id'] = Integer(val['resource_id'])
-        end
-        tags
+  # returns an array of hash containing tags of a host
+  def self.find_all_tags_from_host(db_host)
+    tags = db_host.connection.select_all("SELECT t.id, t.resource_id, p.name FROM resource_tags t INNER JOIN resources r ON t.resource_id=r.id INNER JOIN puppet_tags p ON t.puppet_tag_id=p.id WHERE r.host_id=#{db_host.id}")
+    tags.each do |val|
+      val['resource_id'] = Integer(val['resource_id'])
     end
+    tags
+  end
 end

data/lib/puppet/rails/source_file.rb

@@ -1,8 +1,8 @@
 class Puppet::Rails::SourceFile < ActiveRecord::Base
-    has_one :host
-    has_one :resource
+  has_one :host
+  has_one :resource
 
-    def to_label
-      "#{self.filename}"
-    end
+  def to_label
+    "#{self.filename}"
+  end
 end

data/lib/puppet/reference/configuration.rb

@@ -1,44 +1,44 @@
 config = Puppet::Util::Reference.newreference(:configuration, :depth => 1, :doc => "A reference for all configuration parameters") do
-    docs = {}
-    Puppet.settings.each do |name, object|
-        docs[name] = object
+  docs = {}
+  Puppet.settings.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/lib/puppet"
+    elsif name.to_s == "confdir"
+      val = "/etc/puppet"
     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/lib/puppet"
-        elsif name.to_s == "confdir"
-            val = "/etc/puppet"
-        end
-
-        # Leave out the section information; it was apparently confusing people.
-        #str += "- **Section**: %s\n" % object.section
-        unless val == ""
-            str += "- **Default**: %s\n" % val
-        end
-        str += "\n"
+    # Leave out the section information; it was apparently confusing people.
+    #str += "- **Section**: #{object.section}\n"
+    unless val == ""
+      str += "- **Default**: #{val}\n"
     end
+    str += "\n"
+  end
 
-    return str
+  return str
 end
 
 config.header = "
@@ -57,14 +57,14 @@ These parameters can be supplied to the executables either as command-line
 options or in the configuration file.  For instance, the command-line
 invocation below would set the configuration directory to ``/private/puppet``::
 
-    $ puppetd --confdir=/private/puppet
+  $ puppet agent --confdir=/private/puppet
 
 Note that boolean options are turned on and off with a slightly different
 syntax on the command line::
 
-    $ puppetd --storeconfigs
+  $ puppet agent --storeconfigs
 
-    $ puppetd --no-storeconfigs
+  $ puppet agent --no-storeconfigs
 
 The invocations above will enable and disable, respectively, the storage of
 the client configuration.
@@ -81,20 +81,17 @@ executables look for ``puppet.conf`` in their configuration directory
 ``~user/.puppet/puppet.conf`` as a regular user by default.
 
 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.
+and each executable will also use one of the ``master``, ``agent``, or
+``user`` sections.
 
 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
+  [main]
+    confdir = /private/puppet
+    storeconfigs = true
 
 Note that boolean parameters must be explicitly specified as `true` or
 `false` as seen above.
@@ -102,8 +99,8 @@ Note that boolean parameters must be explicitly specified as `true` or
 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}
+  [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
@@ -111,7 +108,7 @@ 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/puppet.conf
+  $ puppet agent --genconfig > /etc/puppet/puppet.conf
 
 Note that this invocation will replace the contents of any pre-existing
 `puppet.conf` file, so make a backup of your present config if it contains
@@ -122,23 +119,23 @@ 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 agent --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
+  $ puppet agent --mkusers
 
 Signals
 -------
-The ``puppetd`` and ``puppetmasterd`` executables catch some signals for special
+The ``puppet agent`` and ``puppet master`` executables catch some signals for special
 handling.  Both daemons catch (``SIGHUP``), which forces the server to restart
 tself.  Predictably, interrupt and terminate (``SIGINT`` and ``SIGTERM``) will shut
-down the server, whether it be an instance of ``puppetd`` or ``puppetmasterd``.
+down the server, whether it be an instance of ``puppet agent`` or ``puppet master``.
 
-Sending the ``SIGUSR1`` signal to an instance of ``puppetd`` will cause it to
+Sending the ``SIGUSR1`` signal to an instance of ``puppet agent`` will cause it to
 immediately begin a new configuration transaction with the server.  This
-signal has no effect on ``puppetmasterd``.
+signal has no effect on ``puppet master``.
 
 Configuration Parameter Reference
 ---------------------------------

data/lib/puppet/reference/function.rb

@@ -1,5 +1,5 @@
 function = Puppet::Util::Reference.newreference :function, :doc => "All functions available in the parser" do
-    Puppet::Parser::Functions.functiondocs
+  Puppet::Parser::Functions.functiondocs
 end
 function.header = "
 There are two types of functions in Puppet: Statements and rvalues.

data/lib/puppet/reference/indirection.rb

@@ -4,29 +4,29 @@ require 'puppet/file_serving/content'
 require 'puppet/file_serving/metadata'
 
 reference = Puppet::Util::Reference.newreference :indirection, :doc => "Indirection types and their terminus classes" do
-    text = ""
-    Puppet::Indirector::Indirection.instances.sort { |a,b| a.to_s <=> b.to_s }.each do |indirection|
-        ind = Puppet::Indirector::Indirection.instance(indirection)
-        name = indirection.to_s.capitalize
-        text += indirection.to_s + "\n" + ("-" * name.length) + "\n\n"
+  text = ""
+  Puppet::Indirector::Indirection.instances.sort { |a,b| a.to_s <=> b.to_s }.each do |indirection|
+    ind = Puppet::Indirector::Indirection.instance(indirection)
+    name = indirection.to_s.capitalize
+    text += indirection.to_s + "\n" + ("-" * name.length) + "\n\n"
 
-        text += ind.doc + "\n\n"
+    text += ind.doc + "\n\n"
 
-        Puppet::Indirector::Terminus.terminus_classes(ind.name).sort { |a,b| a.to_s <=> b.to_s }.each do |terminus|
-            text += terminus.to_s + "\n" + ("+" * terminus.to_s.length) + "\n\n"
+    Puppet::Indirector::Terminus.terminus_classes(ind.name).sort { |a,b| a.to_s <=> b.to_s }.each do |terminus|
+      text += terminus.to_s + "\n" + ("+" * terminus.to_s.length) + "\n\n"
 
-            term_class = Puppet::Indirector::Terminus.terminus_class(ind.name, terminus)
+      term_class = Puppet::Indirector::Terminus.terminus_class(ind.name, terminus)
 
-            text += Puppet::Util::Docs.scrub(term_class.doc) + "\n\n"
-        end
+      text += Puppet::Util::Docs.scrub(term_class.doc) + "\n\n"
     end
+  end
 
-    text
+  text
 end
 
 reference.header = "This is the list of all indirections, their associated terminus classes, and how you select between them.
 
-In general, the appropriate terminus class is selected by the application for you (e.g., ``puppetd`` would always use the ``rest``
+In general, the appropriate terminus class is selected by the application for you (e.g., ``puppet agent`` would always use the ``rest``
 terminus for most of its indirected classes), but some classes are tunable via normal settings.  These will have ``terminus setting``
 documentation listed with them.
 

data/lib/puppet/reference/metaparameter.rb

@@ -1,48 +1,48 @@
 metaparameter = Puppet::Util::Reference.newreference :metaparameter, :doc => "All Puppet metaparameters and all their details" do
-    types = {}
-    Puppet::Type.loadall
+  types = {}
+  Puppet::Type.loadall
 
-    Puppet::Type.eachtype { |type|
-        next if type.name == :puppet
-        next if type.name == :component
-        types[type.name] = type
-    }
+  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 resource type; 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.
+  str = %{
+    Metaparameters
+    --------------
+    Metaparameters are parameters that work with any resource type; 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
-        }
+    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>"
+    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}</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
+      #puts ""
+    }
+  rescue => detail
+    puts detail.backtrace
+    puts "incorrect metaparams: #{detail}"
+    exit(1)
+  end
 
-    str
+  str
 end

data/lib/puppet/reference/network.rb

@@ -1,23 +1,23 @@
 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)
+  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 == ""
+    next if ! handler.doc or handler.doc == ""
 
-        interface = handler.interface
+    interface = handler.interface
 
-        ret += h(name, 2)
+    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 += 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
+  ret
 end
 
 network.header = "
@@ -27,8 +27,8 @@ 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``.
+``puppet master``, and the clients are mostly started on the client,
+usually within ``puppet agent``.
 
 You can find the server-side handler for each interface at
 ``puppet/network/handler/<name>.rb`` and the client class at

data/lib/puppet/reference/providers.rb

@@ -1,115 +1,114 @@
 # 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
+  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 }
+
+  command_line = Puppet::Util::CommandLine.new
+  types.reject! { |type| ! command_line.args.include?(type.name.to_s) } unless command_line.args.empty?
+
+  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
-    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
+    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 << "[#{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 = ".. [#{count}]\n"
+        missing.each do |test, values|
+          case test
+          when :exists
+            details += "  - Missing files #{values.join(", ")}\n"
+          when :variable
+            values.each do |name, facts|
+              if Puppet.settings.valid?(name)
+                details += "  - Setting #{name} (currently #{Puppet.settings.value(name).inspect}) not in list #{facts.join(", ")}\n"
+              else
+                details += "  - Fact #{name} (currently #{Facter.value(name).inspect}) not in list #{facts.join(", ")}\n"
+              end
             end
+          when :true
+            details += "  - Got #{values} true tests that should have been false\n"
+          when :false
+            details += "  - Got #{values} false tests that should have been true\n"
+          when :feature
+            details += "  - Missing features #{values.collect { |f| f.to_s }.join(",")}\n"
+          end
+        end
+        notes << details
 
-            # 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 :variable
-                        values.each do |name, facts|
-                            if Puppet.settings.valid?(name)
-                                details += "  - Setting %s (currently %s) not in list %s\n" % [name, Puppet.settings.value(name).inspect, facts.join(", ")]
-                            else
-                                details += "  - Fact %s (currently %s) not in list %s\n" % [name, Facter.value(name).inspect, facts.join(", ")]
-                            end
-                        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
-                    when :feature
-                        details += "  - Missing features %s\n" % values.collect { |f| f.to_s }.join(",")
-                    end
-                end
-                notes << details
-
-                count += 1
-            end
+        count += 1
+      end
 
-            # Add a note for every feature
-            features.each do |feature|
-                if provider.features.include?(feature)
-                    data << "**X**"
-                else
-                    data << ""
-                end
-            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://puppetlabs.com/trac/puppet/wiki/TypeReference#%s" % type.name]
-        ret += option("Default provider", default)
-        ret += doctable(headers, table_data)
+    ret += h(type.name.to_s + "_", 2)
 
-        notes.each do |note|
-            ret += note + "\n"
-        end
+    ret += ".. _#{type.name}: #{"http://docs.puppetlabs.com/references/stable/type.html##{type.name}"}\n\n"
+    ret += option("Default provider", default)
+    ret += doctable(headers, table_data)
 
-        ret += "\n"
+    notes.each do |note|
+      ret += note + "\n"
     end
 
     ret += "\n"
+  end
+
+  ret += "\n"
 
-    ret
+  ret
 end
 providers.header = "
 Puppet resource types are usually backed by multiple implementations called ``providers``,