puppet 2.6.0 → 2.6.1

data/lib/puppet/reference/indirection.rb

@@ -1,5 +1,5 @@
 require 'puppet/indirector/indirection'
-require 'puppet/checksum'
+require 'puppet/util/checksums'
 require 'puppet/file_serving/content'
 require 'puppet/file_serving/metadata'
 
@@ -26,9 +26,8 @@ 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., ``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.
+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

@@ -29,14 +29,6 @@ metaparameter = Puppet::Util::Reference.newreference :metaparameter, :doc => "Al
       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

data/lib/puppet/reference/network.rb

@@ -1,3 +1,5 @@
+require 'puppet/network/handler'
+
 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|
@@ -27,11 +29,11 @@ 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
-``puppet master``, and the clients are mostly started on the client,
-usually within ``puppet agent``.
+`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
-``puppet/network/client/<name>.rb``.
+`puppet/network/handler/<name>.rb` and the client class at
+`puppet/network/client/<name>.rb`.
 
 "

data/lib/puppet/reference/providers.rb

@@ -47,7 +47,7 @@ providers = Puppet::Util::Reference.newreference :providers, :title => "Provider
 
       # Add the suitability note
       if missing = provider.suitable?(false) and missing.empty?
-        data << "**X**"
+        data << "*X*"
         suit = true
         functional = true
       else
@@ -86,7 +86,7 @@ providers = Puppet::Util::Reference.newreference :providers, :title => "Provider
       # Add a note for every feature
       features.each do |feature|
         if provider.features.include?(feature)
-          data << "**X**"
+          data << "*X*"
         else
           data << ""
         end
@@ -95,7 +95,7 @@ providers = Puppet::Util::Reference.newreference :providers, :title => "Provider
 
     ret += h(type.name.to_s + "_", 2)
 
-    ret += ".. _#{type.name}: #{"http://docs.puppetlabs.com/references/stable/type.html##{type.name}"}\n\n"
+    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)
 
@@ -111,7 +111,7 @@ providers = Puppet::Util::Reference.newreference :providers, :title => "Provider
   ret
 end
 providers.header = "
-Puppet resource types are usually backed by multiple implementations called ``providers``,
+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

data/lib/puppet/reference/report.rb

@@ -7,16 +7,15 @@ 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
+`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.
+to collect.  See [Reports and Reporting](http://projects.puppetlabs.com/projects/puppet/wiki/Reports_And_Reporting) 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.
+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
+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

@@ -16,25 +16,25 @@ type = Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource
     - 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``.
+  worry about which parameter is the `namevar`.
 
-  In the following code::
+  In the following code:
 
-    file { "/etc/passwd":
-      owner => root,
-      group => root,
-      mode => 644
-    }
+      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.
+  `/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.
 
-- *Parameters* determine the specific configuration of the instance.  They either
+  - *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).
+  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
+  - *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
@@ -42,7 +42,7 @@ type = Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource
   binaries indicate that Puppet will search for the binary using the shell
   path.
 
-- *Features* are abilities that some providers might not support.  You can use the list
+  - *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.
 
   Resource types define features they can use, and providers can be tested to see

data/lib/puppet/reports/http.rb

@@ -5,7 +5,7 @@ require 'uri'
 Puppet::Reports.register_report(:http) do
 
   desc <<-DESC
-  Send report information via HTTP to the ``reporturl``. Each host sends
+  Send report information via HTTP to the `reporturl`. Each host sends
   its report as a YAML dump and this sends this YAML to a client via HTTP POST.
   The YAML is the `report` parameter of the request."
   DESC

data/lib/puppet/reports/rrdgraph.rb

@@ -1,12 +1,11 @@
 Puppet::Reports.register_report(:rrdgraph) do
   desc "Graph all available data about hosts using the RRD library.  You
     must have the Ruby RRDtool library installed to use this report, which
-    you can get from `the RubyRRDTool RubyForge page`_.  This package may also
-    be available as ``ruby-rrd`` or ``rrdtool-ruby`` in your distribution's package
-    management system.  The library and/or package will both require the binary
-    ``rrdtool`` package from your distribution to be installed.
-
-    .. _the RubyRRDTool RubyForge page: http://rubyforge.org/projects/rubyrrdtool/
+    you can get from 
+    [the RubyRRDTool RubyForge page](http://rubyforge.org/projects/rubyrrdtool/).  
+    This package may also be available as `ruby-rrd` or `rrdtool-ruby` in your 
+    distribution's package management system.  The library and/or package will both 
+    require the binary `rrdtool` package from your distribution to be installed.
 
     This report will create, manage, and graph RRD database files for each
     of the metrics generated during transactions, and it will create a
@@ -14,12 +13,12 @@ Puppet::Reports.register_report(:rrdgraph) do
     point, it will not create a common index file to display links to
     all hosts.
 
-    All RRD files and graphs get created in the ``rrddir`` directory.  If
+    All RRD files and graphs get created in the `rrddir` directory.  If
     you want to serve these publicly, you should be able to just alias that
     directory in a web server.
 
-    If you really know what you're doing, you can tune the ``rrdinterval``,
-    which defaults to the ``runinterval``."
+    If you really know what you're doing, you can tune the `rrdinterval`,
+    which defaults to the `runinterval`."
 
   def hostdir
     @hostdir ||= File.join(Puppet[:rrddir], self.host)

data/lib/puppet/reports/store.rb

@@ -2,7 +2,7 @@ require 'puppet'
 
 Puppet::Reports.register_report(:store) do
   desc "Store the yaml report on disk.  Each host sends its report as a YAML dump
-    and this just stores the file on disk, in the ``reportdir`` directory.
+    and this just stores the file on disk, in the `reportdir` directory.
 
     These files collect quickly -- one every half hour -- so it is a good idea
     to perform some maintenance on them if you use this report (it's the only
@@ -19,7 +19,7 @@ Puppet::Reports.register_report(:store) do
         :owner => 'service',
         :group => 'service'
       },
-        
+
       :noop => [false, "Used by settings internally."]
     )
 

data/lib/puppet/reports/tagmail.rb

@@ -6,12 +6,12 @@ require 'time'
 
 Puppet::Reports.register_report(:tagmail) do
   desc "This report sends specific log messages to specific email addresses
-    based on the tags in the log messages.  See the
-    `UsingTags tag documentation`:trac: for more information
-    on tags.
+    based on the tags in the log messages.  
 
-    To use this report, you must create a ``tagmail.conf`` (in the location
-    specified by ``tagmap``).  This is a simple file that maps tags to
+    See the [UsingTags tag documentation](http://projects.puppetlabs.com/projects/puppet/wiki/Using_Tags) for more information on tags.
+
+    To use this report, you must create a `tagmail.conf` (in the location
+    specified by `tagmap`).  This is a simple file that maps tags to
     email addresses:  Any log messages in the report that match the specified
     tags will be sent to the specified email addresses.
 
@@ -20,21 +20,20 @@ Puppet::Reports.register_report(:tagmail) do
     the email addresses by a colon, and the email addresses should also
     be comma-separated.
 
-    Lastly, there is an ``all`` tag that will always match all log messages.
+    Lastly, there is an `all` tag that will always match all log messages.
 
-    Here is an example tagmail.conf::
+    Here is an example `tagmail.conf`:
 
-      all: me@domain.com
-      webserver, !mailserver: httpadmins@domain.com
+        all: me@domain.com
+        webserver, !mailserver: httpadmins@domain.com
 
-    This will send all messages to ``me@domain.com``, and all messages from
-    webservers that are not also from mailservers to ``httpadmins@domain.com``.
+    This will send all messages to `me@domain.com`, and all messages from
+    webservers that are not also from mailservers to `httpadmins@domain.com`.
 
     If you are using anti-spam controls, such as grey-listing, on your mail
-    server you should whitelist the sending email (controlled by ``reportform`` configuration option) to ensure your email is not discarded as spam.
+    server you should whitelist the sending email (controlled by `reportform` configuration option) to ensure your email is not discarded as spam.
     "
 
-
   # Find all matching messages.
   def match(taglists)
     matching_logs = []

data/lib/puppet/resource.rb

@@ -13,7 +13,7 @@ class Puppet::Resource
   extend Puppet::Util::Pson
   include Enumerable
   attr_accessor :file, :line, :catalog, :exported, :virtual, :validate_parameters, :strict
-  attr_reader :namespaces
+  attr_reader :type, :title
 
   require 'puppet/indirector'
   extend Puppet::Indirector
@@ -157,27 +157,26 @@ class Puppet::Resource
   # Create our resource.
   def initialize(type, title = nil, attributes = {})
     @parameters = {}
-    @namespaces = [""]
 
-    # Set things like namespaces and strictness first.
+    # Set things like strictness first.
     attributes.each do |attr, value|
       next if attr == :parameters
       send(attr.to_s + "=", value)
     end
 
-    # We do namespaces first, and use tmp variables, so our title
-    # canonicalization works (i.e., namespaces are set and resource
-    # types can be looked up)
-    tmp_type, tmp_title = extract_type_and_title(type, title)
-    self.type = tmp_type
-    self.title = tmp_title
+    @type, @title = extract_type_and_title(type, title)
+
+    @type = munge_type_name(@type)
+
+    if @type == "Class"
+      @title = :main if @title == ""
+      @title = munge_type_name(@title)
+    end
 
     if params = attributes[:parameters]
       extract_parameters(params)
     end
 
-    resolve_type_and_title
-
     tag(self.type)
     tag(self.title) if valid_tag?(self.title)
 
@@ -193,17 +192,12 @@ class Puppet::Resource
     return(catalog ? catalog.resource(to_s) : nil)
   end
 
-  def title=(value)
-    @unresolved_title = value
-    @title = nil
-  end
-
   def resource_type
-    @resource_type ||= case type
-    when "Class"; find_hostclass(title)
-    when "Node"; find_node(title)
+    case type
+    when "Class"; known_resource_types.hostclass(title == :main ? "" : title)
+    when "Node"; known_resource_types.node(title)
     else
-      find_resource_type(type)
+      Puppet::Type.type(type.to_s.downcase.to_sym) || known_resource_types.definition(type)
     end
   end
 
@@ -314,28 +308,6 @@ class Puppet::Resource
     self
   end
 
-  # We have to lazy-evaluate this.
-  def title=(value)
-    @title = nil
-    @unresolved_title = value
-  end
-
-  # We have to lazy-evaluate this.
-  def type=(value)
-    @type = nil
-    @unresolved_type = value || "Class"
-  end
-
-  def title
-    resolve_type_and_title unless @title
-    @title
-  end
-
-  def type
-    resolve_type_and_title unless @type
-    @type
-  end
-
   def valid_parameter?(name)
     resource_type.valid_parameter?(name)
   end
@@ -346,29 +318,6 @@ class Puppet::Resource
 
   private
 
-  def find_node(name)
-    known_resource_types.node(name)
-  end
-
-  def find_hostclass(title)
-    name = title == :main ? "" : title
-    known_resource_types.find_hostclass(namespaces, name)
-  end
-
-  def find_resource_type(type)
-    # It still works fine without the type == 'class' short-cut, but it is a lot slower.
-    return nil if ["class", "node"].include? type.to_s.downcase
-    find_builtin_resource_type(type) || find_defined_resource_type(type)
-  end
-
-  def find_builtin_resource_type(type)
-    Puppet::Type.type(type.to_s.downcase.to_sym)
-  end
-
-  def find_defined_resource_type(type)
-    known_resource_types.find_definition(namespaces, type.to_s.downcase)
-  end
-
   # Produce a canonical method name.
   def parameter_name(param)
     param = param.to_s.downcase.to_sym
@@ -378,10 +327,6 @@ class Puppet::Resource
     param
   end
 
-  def namespaces=(ns)
-    @namespaces = Array(ns)
-  end
-
   # The namevar for our resource type. If the type doesn't exist,
   # always use :name.
   def namevar
@@ -428,54 +373,9 @@ class Puppet::Resource
     value.to_s.split("::").collect { |s| s.capitalize }.join("::")
   end
 
-  # This is an annoyingly complicated method for resolving qualified
-  # types as necessary, and putting them in type or title attributes.
-  def resolve_type_and_title
-    if @unresolved_type
-      @type = resolve_type
-      @unresolved_type = nil
-    end
-    if @unresolved_title
-      @title = resolve_title
-      @unresolved_title = nil
-    end
-  end
-
-  def resolve_type
-    case type = munge_type_name(@unresolved_type)
-    when "Class", "Node";
-      type
-    else
-      # Otherwise, some kind of builtin or defined resource type
-      munge_type_name( (r = find_resource_type(type)) ? r.name : type)
-    end
-  end
-
-  # This method only works if resolve_type was called first
-  def resolve_title
-    case @type
-    when "Node"; return @unresolved_title
-    when "Class";
-      resolve_title_for_class(@unresolved_title)
-    else
-      @unresolved_title
-    end
-  end
-
-  def resolve_title_for_class(title)
-    if title == "" or title == :main
-      return :main
-    end
-
-    if klass = find_hostclass(title)
-      result = klass.name
-    end
-    munge_type_name(result || title)
-  end
-
   def parse_title
     h = {}
-    type = find_resource_type(@type)
+    type = resource_type
     if type.respond_to? :title_patterns
       type.title_patterns.each { |regexp, symbols_and_lambdas|
         if captures = regexp.match(title.to_s)