puppet 2.7.6 → 2.7.8

data/lib/puppet/transaction/event_manager.rb

@@ -77,7 +77,7 @@ class Puppet::Transaction::EventManager
 
     @event_queues[target] ||= {}
     @event_queues[target][callback] ||= []
-    @event_queues[target][callback] += events
+    @event_queues[target][callback].concat(events)
   end
 
   def queued_events(resource)

data/lib/puppet/type.rb

@@ -635,6 +635,10 @@ class Type
   ###############################
   # Code related to evaluating the resources.
 
+  def ancestors
+    []
+  end
+
   # Flush the provider, if it supports it.  This is called by the
   # transaction.
   def flush
@@ -1116,13 +1120,22 @@ class Type
       (e.g., each class and definition containing the resource), it can
       be useful to add your own tags to a given resource.
 
-      Tags are currently useful for things like applying a subset of a
-      host's configuration:
+      Multiple tags can be specified as an array:
+
+          file {'/etc/hosts':
+            ensure => file,
+            source => 'puppet:///modules/site/hosts',
+            mode   => 0644,
+            tag    => ['bootstrap', 'minimumrun', 'mediumrun'],
+          }
+
+      Tags are useful for things like applying a subset of a host's configuration
+      with [the `tags` setting](/references/latest/configuration.html#tags):
 
-          puppet agent --test --tags mytag
+          puppet agent --test --tags bootstrap
 
-      This way, when you're testing a configuration you can run just the
-      portion you're testing."
+      This way, you can easily isolate the portion of the configuration you're
+      trying to test."
 
     munge do |tags|
       tags = [tags] unless tags.is_a? Array
@@ -1370,33 +1383,25 @@ class Type
 
   # Find the default provider.
   def self.defaultprovider
-    unless @defaultprovider
-      suitable = suitableprovider
+    return @defaultprovider if @defaultprovider
 
-      # Find which providers are a default for this system.
-      defaults = suitable.find_all { |provider| provider.default? }
+    suitable = suitableprovider
 
-      # If we don't have any default we use suitable providers
-      defaults = suitable if defaults.empty?
-      max = defaults.collect { |provider| provider.specificity }.max
-      defaults = defaults.find_all { |provider| provider.specificity == max }
+    # Find which providers are a default for this system.
+    defaults = suitable.find_all { |provider| provider.default? }
 
-      retval = nil
-      if defaults.length > 1
-        Puppet.warning(
-          "Found multiple default providers for #{self.name}: #{defaults.collect { |i| i.name.to_s }.join(", ")}; using #{defaults[0].name}"
-        )
-        retval = defaults.shift
-      elsif defaults.length == 1
-        retval = defaults.shift
-      else
-        raise Puppet::DevError, "Could not find a default provider for #{self.name}"
-      end
+    # If we don't have any default we use suitable providers
+    defaults = suitable if defaults.empty?
+    max = defaults.collect { |provider| provider.specificity }.max
+    defaults = defaults.find_all { |provider| provider.specificity == max }
 
-      @defaultprovider = retval
+    if defaults.length > 1
+      Puppet.warning(
+        "Found multiple default providers for #{self.name}: #{defaults.collect { |i| i.name.to_s }.join(", ")}; using #{defaults[0].name}"
+      )
     end
 
-    @defaultprovider
+    @defaultprovider = defaults.shift unless defaults.empty?
   end
 
   def self.provider_hash_by_type(type)
@@ -1477,9 +1482,15 @@ class Type
     return if @paramhash.has_key? :provider
 
     newparam(:provider) do
-      desc "The specific backend for #{self.name.to_s} to use. You will
-        seldom need to specify this --- Puppet will usually discover the
-        appropriate provider for your platform."
+      # We're using a hacky way to get the name of our type, since there doesn't
+      # seem to be a correct way to introspect this at the time this code is run.
+      # We expect that the class in which this code is executed will be something
+      # like Puppet::Type::Ssh_authorized_key::ParameterProvider.
+      desc <<-EOT
+        The specific backend to use for this `#{self.to_s.split('::')[2].downcase}`
+        resource. You will seldom need to specify this --- Puppet will usually
+        discover the appropriate provider for your platform.
+      EOT
 
       # This is so we can refer back to the type to get a list of
       # providers for documentation.
@@ -1497,7 +1508,8 @@ class Type
       end
 
       defaultto {
-        @resource.class.defaultprovider.name
+        prov = @resource.class.defaultprovider
+        prov.name if prov
       }
 
       validate do |provider_class|
@@ -1541,6 +1553,24 @@ class Type
     }.reject { |p| p.name == :fake } # For testing
   end
 
+  def suitable?
+    # If we don't use providers, then we consider it suitable.
+    return true unless self.class.paramclass(:provider)
+
+    # We have a provider and it is suitable.
+    return true if provider && provider.class.suitable?
+
+    # We're using the default provider and there is one.
+    if !provider and self.class.defaultprovider
+      self.provider = self.class.defaultprovider.name
+      return true
+    end
+
+    # We specified an unsuitable provider, or there isn't any suitable
+    # provider.
+    false
+  end
+
   def provider=(name)
     if name.is_a?(Puppet::Provider)
       @provider = name

data/lib/puppet/type/augeas.rb

@@ -21,13 +21,13 @@ Puppet::Type.newtype(:augeas) do
   feature :execute_changes, "Actually make the changes"
 
   @doc = <<-EOT
-    Apply the changes (single or array of changes) to the filesystem
-    via the augeas tool.
+    Apply a change or an array of changes to the filesystem
+    using the augeas tool.
 
     Requires:
 
-    - augeas to be installed (http://www.augeas.net)
-    - ruby-augeas bindings
+    - [Augeas](http://www.augeas.net)
+    - The ruby-augeas bindings
 
     Sample usage with a string:
 
@@ -40,23 +40,25 @@ Puppet::Type.newtype(:augeas) do
     Sample usage with an array and custom lenses:
 
         augeas{"jboss_conf":
-          context => "/files",
-          changes => [
-            "set etc/jbossas/jbossas.conf/JBOSS_IP $ipaddress",
-            "set etc/jbossas/jbossas.conf/JAVA_HOME /usr",
-          ],
+          context   => "/files",
+          changes   => [
+              "set etc/jbossas/jbossas.conf/JBOSS_IP $ipaddress",
+              "set etc/jbossas/jbossas.conf/JAVA_HOME /usr",
+            ],
           load_path => "$/usr/share/jbossas/lenses",
         }
 
   EOT
 
   newparam (:name) do
-    desc "The name of this task. Used for uniqueness"
+    desc "The name of this task. Used for uniqueness."
     isnamevar
   end
 
   newparam (:context) do
-    desc "Optional context path. This value is prepended to the paths of all changes if the path is relative. If INCL is set, defaults to '/files' + INCL, otherwise the empty string"
+    desc "Optional context path. This value is prepended to the paths of all
+      changes if the path is relative. If the `incl` parameter is set,
+      defaults to `/files + incl`; otherwise, defaults to the empty string."
     defaultto ""
     munge do |value|
       if value.empty? and resource[:incl]
@@ -71,91 +73,123 @@ Puppet::Type.newtype(:augeas) do
     desc "Optional augeas command and comparisons to control the execution of this type.
       Supported onlyif syntax:
 
-          get [AUGEAS_PATH] [COMPARATOR] [STRING]
-          match [MATCH_PATH] size [COMPARATOR] [INT]
-          match [MATCH_PATH] include [STRING]
-          match [MATCH_PATH] not_include [STRING]
-          match [MATCH_PATH] == [AN_ARRAY]
-          match [MATCH_PATH] != [AN_ARRAY]
+      * `get <AUGEAS_PATH> <COMPARATOR> <STRING>`
+      * `match <MATCH_PATH> size <COMPARATOR> <INT>`
+      * `match <MATCH_PATH> include <STRING>`
+      * `match <MATCH_PATH> not_include <STRING>`
+      * `match <MATCH_PATH> == <AN_ARRAY>`
+      * `match <MATCH_PATH> != <AN_ARRAY>`
 
       where:
 
-          AUGEAS_PATH is a valid path scoped by the context
-          MATCH_PATH is a valid match synatx scoped by the context
-          COMPARATOR is in the set [> >= != == <= <]
-          STRING is a string
-          INT is a number
-          AN_ARRAY is in the form ['a string', 'another']"
+      * `AUGEAS_PATH` is a valid path scoped by the context
+      * `MATCH_PATH` is a valid match synatx scoped by the context
+      * `COMPARATOR` is one of `>, >=, !=, ==, <=,` or `<`
+      * `STRING` is a string
+      * `INT` is a number
+      * `AN_ARRAY` is in the form `['a string', 'another']`"
     defaultto ""
   end
 
 
   newparam(:changes) do
     desc "The changes which should be applied to the filesystem. This
-    can be either a string which contains a command or an array of commands.
-    Commands supported are:
-
-        set [PATH] [VALUE]            Sets the value VALUE at loction PATH
-        setm [PATH] [SUB] [VALUE]     Sets multiple nodes matching SUB relative to PATH, to VALUE
-        rm [PATH]                     Removes the node at location PATH
-        remove [PATH]                 Synonym for rm
-        clear [PATH]                  Sets the node at PATH to NULL, creating it if needed
-        ins [LABEL] [WHERE] [PATH]    Inserts an empty node LABEL either [WHERE={before|after}] PATH.
-        insert [LABEL] [WHERE] [PATH] Synonym for ins
-        mv [PATH] [PATH]              Moves a node at PATH to the new location PATH
-        move [PATH] [PATH]            Synonym for mv
-        defvar [NAME] [PATH]          Sets Augeas variable $NAME to PATH
-        defnode [NAME] [PATH] [VALUE] Sets Augeas variable $NAME to PATH, creating it with VALUE if needed
-
-    If the parameter 'context' is set that value is prepended to a relative PATH"
+    can be a command or an array of commands. The following commands are supported:
+
+    `set <PATH> <VALUE>`
+    : Sets the value `VALUE` at loction `PATH`
+
+
+    `setm <PATH> <SUB> <VALUE>`
+    : Sets multiple nodes (matching `SUB` relative to `PATH`) to `VALUE`
+
+
+    `rm <PATH>`
+    : Removes the node at location `PATH`
+
+
+    `remove <PATH>`
+    : Synonym for `rm`
+
+
+    `clear <PATH>`
+    : Sets the node at `PATH` to `NULL`, creating it if needed
+
+
+    `ins <LABEL> (before|after) <PATH>`
+    : Inserts an empty node `LABEL` either before or after `PATH`.
+
+
+    `insert <LABEL> <WHERE> <PATH>`
+    : Synonym for `ins`
+
+
+    `mv <PATH> <OTHER PATH>`
+    : Moves a node at `PATH` to the new location `OTHER PATH`
+
+
+    `move <PATH> <OTHER PATH>`
+    : Synonym for `mv`
+
+
+    `defvar <NAME> <PATH>`
+    : Sets Augeas variable `$NAME` to `PATH`
+
+
+    `defnode <NAME> <PATH> <VALUE>`
+    : Sets Augeas variable `$NAME` to `PATH`, creating it with `VALUE` if needed
+
+    If the `context` parameter is set, that value is prepended to any relative `PATH`s."
   end
 
 
   newparam(:root) do
-    desc "A file system path; all files loaded by Augeas are loaded underneath ROOT"
+    desc "A file system path; all files loaded by Augeas are loaded underneath `root`."
     defaultto "/"
   end
 
   newparam(:load_path) do
-    desc "Optional colon separated list of directories; these directories are searched for schema definitions"
+    desc "Optional colon-separated list of directories; these directories are searched for schema definitions."
     defaultto ""
   end
 
   newparam(:force) do
     desc "Optional command to force the augeas type to execute even if it thinks changes
-    will not be made. This does not overide the only setting. If onlyif is set, then the
-    foce setting will not override that result"
+    will not be made. This does not overide the `onlyif` parameter."
 
     defaultto false
   end
 
   newparam(:type_check) do
-    desc "Set to true if augeas should perform typechecking. Optional, defaults to false"
+    desc "Whether augeas should perform typechecking. Defaults to false."
     newvalues(:true, :false)
 
     defaultto :false
   end
 
   newparam(:lens) do
-    desc "Use a specific lens, e.g. `Hosts.lns`. When this parameter is set, you must also set the incl parameter to indicate which file to load. Only that file will be loaded, which greatly speeds up execution of the type"
+    desc "Use a specific lens, e.g. `Hosts.lns`. When this parameter is set, you
+      must also set the `incl` parameter to indicate which file to load."
   end
 
   newparam(:incl) do
-    desc "Load only a specific file, e.g. `/etc/hosts`.  When this parameter is set, you must also set the lens parameter to indicate which lens to use."
+    desc "Load only a specific file, e.g. `/etc/hosts`. This can greatly speed
+      up the execution the resource. When this parameter is set, you must also
+      set the `lens` parameter to indicate which lens to use."
   end
 
   validate do
     has_lens = !self[:lens].nil?
     has_incl = !self[:incl].nil?
-    self.fail "You must specify both the lens and incl parameters, or neither" if has_lens != has_incl
+    self.fail "You must specify both the lens and incl parameters, or neither." if has_lens != has_incl
   end
 
-  # This is the acutal meat of the code. It forces
+  # This is the actual meat of the code. It forces
   # augeas to be run and fails or not based on the augeas return
   # code.
   newproperty(:returns) do |property|
     include Puppet::Util
-    desc "The expected return code from the augeas command. Should not be set"
+    desc "The expected return code from the augeas command. Should not be set."
 
     defaultto 0
 

data/lib/puppet/type/computer.rb

@@ -15,7 +15,7 @@ Puppet::Type.newtype(:computer) do
 
     This type primarily exists to create localhost Computer objects that MCX
     policy can then be attached to.
-    
+
     **Autorequires:** If Puppet is managing the plist file representing a
     Computer object (located at `/var/db/dslocal/nodes/Default/computers/{name}.plist`),
     the Computer resource will autorequire it."

data/lib/puppet/type/cron.rb

@@ -20,17 +20,17 @@ Puppet::Type.newtype(:cron) do
 
         cron { logrotate:
           command => "/usr/sbin/logrotate",
-          user => root,
-          hour => 2,
-          minute => 0
+          user    => root,
+          hour    => 2,
+          minute  => 0
         }
 
     Note that all periodic attributes can be specified as an array of values:
 
         cron { logrotate:
           command => "/usr/sbin/logrotate",
-          user => root,
-          hour => [2, 4]
+          user    => root,
+          hour    => [2, 4]
         }
 
     ...or using ranges or the step syntax `*/2` (although there's no guarantee
@@ -38,9 +38,9 @@ Puppet::Type.newtype(:cron) do
 
         cron { logrotate:
           command => "/usr/sbin/logrotate",
-          user => root,
-          hour => ['2-4'],
-          minute => '*/10'
+          user    => root,
+          hour    => ['2-4'],
+          minute  => '*/10'
         }
   EOT
   ensurable
@@ -338,9 +338,9 @@ Puppet::Type.newtype(:cron) do
       is used for human reference only and is generated automatically
       for cron jobs found on the system.  This generally won't
       matter, as Puppet will do its best to match existing cron jobs
-      against specified jobs (and Puppet adds a comment to cron jobs it adds), but it is at least possible that converting from
-      unmanaged jobs to managed jobs might require manual
-      intervention."
+      against specified jobs (and Puppet adds a comment to cron jobs it adds),
+      but it is at least possible that converting from unmanaged jobs to
+      managed jobs might require manual intervention."
 
     isnamevar
   end

data/lib/puppet/type/exec.rb

@@ -24,7 +24,10 @@ module Puppet
       us at Puppet Labs what you are doing, and hopefully we can work with
       you to get a native resource type for the work you are doing.
 
-      **Autorequires:** If Puppet is managing an exec's cwd or the executable file used in an exec's command, the exec resource will autorequire those files. If Puppet is managing the user that an exec should run as, the exec resource will autorequire that user."
+      **Autorequires:** If Puppet is managing an exec's cwd or the executable
+      file used in an exec's command, the exec resource will autorequire those
+      files. If Puppet is managing the user that an exec should run as, the
+      exec resource will autorequire that user."
 
     # Create a new check mechanism.  It's basically just a parameter that
     # provides one extra 'check' method.
@@ -271,25 +274,27 @@ module Puppet
 
 
     newcheck(:refreshonly) do
-      desc "The command should only be run as a
+      desc <<-EOT
+        The command should only be run as a
         refresh mechanism for when a dependent object is changed.  It only
         makes sense to use this option when this command depends on some
         other object; it is useful for triggering an action:
 
             # Pull down the main aliases file
-            file { \"/etc/aliases\":
-              source => \"puppet://server/module/aliases\"
+            file { "/etc/aliases":
+              source => "puppet://server/module/aliases"
             }
 
             # Rebuild the database, but only when the file changes
             exec { newaliases:
-              path => [\"/usr/bin\", \"/usr/sbin\"],
-              subscribe => File[\"/etc/aliases\"],
+              path        => ["/usr/bin", "/usr/sbin"],
+              subscribe   => File["/etc/aliases"],
               refreshonly => true
             }
 
         Note that only `subscribe` and `notify` can trigger actions, not `require`,
-        so it only makes sense to use `refreshonly` with `subscribe` or `notify`."
+        so it only makes sense to use `refreshonly` with `subscribe` or `notify`.
+      EOT
 
       newvalues(:true, :false)
 
@@ -312,9 +317,9 @@ module Puppet
         if the specified file does not exist.
 
             exec { "tar -xf /Volumes/nfs02/important.tar":
-              cwd => "/var/tmp",
+              cwd     => "/var/tmp",
               creates => "/var/tmp/myfile",
-              path => ["/usr/bin", "/usr/sbin"]
+              path    => ["/usr/bin", "/usr/sbin"]
             }
 
         In this example, if `/var/tmp/myfile` is ever deleted, the exec
@@ -331,12 +336,13 @@ module Puppet
     end
 
     newcheck(:unless) do
-      desc "If this parameter is set, then this `exec` will run unless
+      desc <<-EOT
+        If this parameter is set, then this `exec` will run unless
         the command returns 0.  For example:
 
-            exec { \"/bin/echo root >> /usr/lib/cron/cron.allow\":
-              path => \"/usr/bin:/usr/sbin:/bin\",
-              unless => \"grep root /usr/lib/cron/cron.allow 2>/dev/null\"
+            exec { "/bin/echo root >> /usr/lib/cron/cron.allow":
+              path   => "/usr/bin:/usr/sbin:/bin",
+              unless => "grep root /usr/lib/cron/cron.allow 2>/dev/null"
             }
 
         This would add `root` to the cron.allow file (on Solaris) unless
@@ -344,7 +350,7 @@ module Puppet
 
         Note that this command follows the same rules as the main command,
         which is to say that it must be fully qualified if the path is not set.
-        "
+      EOT
 
       validate do |cmds|
         cmds = [cmds] unless cmds.is_a? Array
@@ -368,12 +374,13 @@ module Puppet
     end
 
     newcheck(:onlyif) do
-      desc "If this parameter is set, then this `exec` will only run if
+      desc <<-EOT
+        If this parameter is set, then this `exec` will only run if
         the command returns 0.  For example:
 
-            exec { \"logrotate\":
-              path => \"/usr/bin:/usr/sbin:/bin\",
-              onlyif => \"test `du /var/log/messages | cut -f1` -gt 100000\"
+            exec { "logrotate":
+              path   => "/usr/bin:/usr/sbin:/bin",
+              onlyif => "test `du /var/log/messages | cut -f1` -gt 100000"
             }
 
         This would run `logrotate` only if that test returned true.
@@ -383,10 +390,10 @@ module Puppet
 
         Also note that onlyif can take an array as its value, e.g.:
 
-            onlyif => [\"test -f /tmp/file1\", \"test -f /tmp/file2\"]
+            onlyif => ["test -f /tmp/file1", "test -f /tmp/file2"]
 
-        This will only run the exec if /all/ conditions in the array return true.
-        "
+        This will only run the exec if _all_ conditions in the array return true.
+      EOT
 
       validate do |cmds|
         cmds = [cmds] unless cmds.is_a? Array