puppet 2.6.0 → 2.6.1

data/lib/puppet/type/computer.rb

@@ -10,7 +10,7 @@ Puppet::Type.newtype(:computer) do
     This provider only manages Computer objects in the local directory service
     domain, not in remote directories.
 
-    If you wish to manage /etc/hosts on Mac OS X, then simply use the host
+    If you wish to manage `/etc/hosts` file on Mac OS X, then simply use the host
     type as per other platforms.
 
     This type primarily exists to create localhost Computer objects that MCX
@@ -31,7 +31,7 @@ Puppet::Type.newtype(:computer) do
 
   newproperty(:ensure, :parent => Puppet::Property::Ensure) do
     desc "Control the existences of this computer record. Set this attribute to
-      ``present`` to ensure the computer record exists.  Set it to ``absent``
+      `present` to ensure the computer record exists.  Set it to `absent`
       to delete any computer records with this name"
     newvalue(:present) do
       provider.create

data/lib/puppet/type/cron.rb

@@ -15,32 +15,32 @@ Puppet::Type.newtype(:cron) do
     association is made and synced to disk, you can then manage the job
     normally (e.g., change the schedule of the job).
 
-    Example::
-
-      cron { logrotate:
-        command => \"/usr/sbin/logrotate\",
-        user => root,
-        hour => 2,
-        minute => 0
-      }
-
-    Note that all cron values can be specified as an array of values::
-
-      cron { logrotate:
-        command => \"/usr/sbin/logrotate\",
-        user => root,
-        hour => [2, 4]
-      }
-
-    Or using ranges, or the step syntax ``*/2`` (although there's no guarantee that
-    your ``cron`` daemon supports it)::
-
-      cron { logrotate:
-        command => \"/usr/sbin/logrotate\",
-        user => root,
-        hour => ['2-4'],
-        minute => '*/10'
-      }
+    Example:
+
+        cron { logrotate:
+          command => \"/usr/sbin/logrotate\",
+          user => root,
+          hour => 2,
+          minute => 0
+        }
+
+    Note that all cron values can be specified as an array of values:
+
+        cron { logrotate:
+          command => \"/usr/sbin/logrotate\",
+          user => root,
+          hour => [2, 4]
+        }
+
+    Or using ranges, or the step syntax `*/2` (although there's no guarantee that
+    your `cron` daemon supports it):
+
+        cron { logrotate:
+          command => \"/usr/sbin/logrotate\",
+          user => root,
+          hour => ['2-4'],
+          minute => '*/10'
+        }
     "
   ensurable
 
@@ -169,7 +169,7 @@ Puppet::Type.newtype(:cron) do
       end
 
       if value == "*"
-        return value
+        return :absent
       end
 
       return value unless self.class.boundaries
@@ -206,7 +206,7 @@ Puppet::Type.newtype(:cron) do
       profile is not sourced when the command is run, so if the
       user's environment is desired it should be sourced manually.
 
-      All cron parameters support ``absent`` as a value; this will
+      All cron parameters support `absent` as a value; this will
       remove any existing values for that field."
 
     def retrieve
@@ -293,7 +293,7 @@ Puppet::Type.newtype(:cron) do
       but will not associate them with a specific job.
 
       Settings should be specified exactly as they should appear in
-      the crontab, e.g., ``PATH=/bin:/usr/bin:/usr/sbin``."
+      the crontab, e.g., `PATH=/bin:/usr/bin:/usr/sbin`."
 
     validate do |value|
       unless value =~ /^\s*(\w+)\s*=\s*(.*)\s*$/ or value == :absent or value == "absent"

data/lib/puppet/type/exec.rb

@@ -6,51 +6,51 @@ module Puppet
     @doc = "Executes external commands.  It is critical that all commands
       executed using this mechanism can be run multiple times without
       harm, i.e., they are *idempotent*.  One useful way to create idempotent
-      commands is to use the checks like ``creates`` to avoid running the
+      commands is to use the checks like `creates` to avoid running the
       command unless some condition is met.
 
-      Note also that you can restrict an ``exec`` to only run when it receives
-      events by using the ``refreshonly`` parameter; this is a useful way to
+      Note also that you can restrict an `exec` to only run when it receives
+      events by using the `refreshonly` parameter; this is a useful way to
       have your configuration respond to events with arbitrary commands.
 
-      It is worth noting that ``exec`` is special, in that it is not
-      currently considered an error to have multiple ``exec`` instances
+      It is worth noting that `exec` is special, in that it is not
+      currently considered an error to have multiple `exec` instances
       with the same name.  This was done purely because it had to be this
       way in order to get certain functionality, but it complicates things.
-      In particular, you will not be able to use ``exec`` instances that
+      In particular, you will not be able to use `exec` instances that
       share their commands with other instances as a dependency, since
       Puppet has no way of knowing which instance you mean.
 
-      For example::
+      For example:
 
-        # defined in the production class
-        exec { \"make\":
-          cwd => \"/prod/build/dir\",
-          path => \"/usr/bin:/usr/sbin:/bin\"
-        }
+          # defined in the production class
+          exec { \"make\":
+            cwd => \"/prod/build/dir\",
+            path => \"/usr/bin:/usr/sbin:/bin\"
+          }
 
-        . etc. .
+          . etc. .
 
-        # defined in the test class
-        exec { \"make\":
-          cwd => \"/test/build/dir\",
-          path => \"/usr/bin:/usr/sbin:/bin\"
-        }
+          # defined in the test class
+          exec { \"make\":
+            cwd => \"/test/build/dir\",
+            path => \"/usr/bin:/usr/sbin:/bin\"
+          }
 
       Any other type would throw an error, complaining that you had
       the same instance being managed in multiple places, but these are
-      obviously different images, so ``exec`` had to be treated specially.
+      obviously different images, so `exec` had to be treated specially.
 
       It is recommended to avoid duplicate names whenever possible.
 
-      Note that if an ``exec`` receives an event from another resource,
-      it will get executed again (or execute the command specified in ``refresh``, if there is one).
+      Note that if an `exec` receives an event from another resource,
+      it will get executed again (or execute the command specified in `refresh`, if there is one).
 
-      There is a strong tendency to use ``exec`` to do whatever work Puppet
+      There is a strong tendency to use `exec` to do whatever work Puppet
       can't already do; while this is obviously acceptable (and unavoidable)
-      in the short term, it is highly recommended to migrate work from ``exec``
+      in the short term, it is highly recommended to migrate work from `exec`
       to native Puppet types as quickly as possible.  If you find that
-      you are doing a lot of work with ``exec``, please at least notify
+      you are doing a lot of work with `exec`, please at least notify
       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."
 
@@ -159,9 +159,9 @@ module Puppet
       desc "The actual command to execute.  Must either be fully qualified
         or a search path for the command must be provided.  If the command
         succeeds, any output produced will be logged at the instance's
-        normal log level (usually ``notice``), but if the command fails
+        normal log level (usually `notice`), but if the command fails
         (meaning its return code does not match the specified code) then
-        any output is logged at the ``err`` log level."
+        any output is logged at the `err` log level."
     end
 
     newparam(:path) do
@@ -223,7 +223,7 @@ module Puppet
 
     newparam(:logoutput) do
       desc "Whether to log output.  Defaults to logging output at the
-        loglevel for the ``exec`` resource. Use *on_failure* to only
+        loglevel for the `exec` resource. Use *on_failure* to only
         log the output when the command reports an error.  Values are
         **true**, *false*, *on_failure*, and any legal log level."
 
@@ -253,7 +253,7 @@ module Puppet
     newparam(:environment) do
       desc "Any additional environment variables you want to set for a
         command.  Note that if you use this to set PATH, it will override
-        the ``path`` attribute.  Multiple environment variables should be
+        the `path` attribute.  Multiple environment variables should be
         specified as an array."
 
       validate do |values|
@@ -330,22 +330,22 @@ module Puppet
       desc "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\"
-          }
-
-          # Rebuild the database, but only when the file changes
-          exec { newaliases:
-            path => [\"/usr/bin\", \"/usr/sbin\"],
-            subscribe => File[\"/etc/aliases\"],
-            refreshonly => true
-          }
+        other object; it is useful for triggering an action:
+
+            # Pull down the main aliases file
+            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\"],
+              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``."
+        Note that only `subscribe` and `notify` can trigger actions, not `require`,
+        so it only makes sense to use `refreshonly` with `subscribe` or `notify`."
 
       newvalues(:true, :false)
 
@@ -364,13 +364,13 @@ module Puppet
     newcheck(:creates) do
       desc "A file that this command creates.  If this
         parameter is provided, then the command will only be run
-        if the specified file does not exist::
+        if the specified file does not exist:
 
-          exec { \"tar xf /my/tar/file.tar\":
-            cwd => \"/var/tmp\",
-            creates => \"/var/tmp/myfile\",
-            path => [\"/usr/bin\", \"/usr/sbin\"]
-          }
+            exec { \"tar xf /my/tar/file.tar\":
+              cwd => \"/var/tmp\",
+              creates => \"/var/tmp/myfile\",
+              path => [\"/usr/bin\", \"/usr/sbin\"]
+            }
 
         "
 
@@ -396,16 +396,16 @@ module Puppet
     end
 
     newcheck(:unless) do
-      desc "If this parameter is set, then this ``exec`` will run unless
-        the command returns 0.  For example::
+      desc "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
-        ``grep`` determines it's already there.
+        This would add `root` to the cron.allow file (on Solaris) unless
+        `grep` determines it's already there.
 
         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.
@@ -433,22 +433,22 @@ module Puppet
     end
 
     newcheck(:onlyif) do
-      desc "If this parameter is set, then this ``exec`` will only run if
-        the command returns 0.  For example::
+      desc "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.
+        This would run `logrotate` only if that test returned true.
 
         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.
 
-        Also note that onlyif can take an array as its value, eg::
+        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.
         "
@@ -683,4 +683,3 @@ module Puppet
     end
   end
 end
-

data/lib/puppet/type/file.rb

@@ -16,7 +16,7 @@ Puppet::Type.newtype(:file) do
   @doc = "Manages local files, including setting ownership and
     permissions, creation of both files and directories, and
     retrieving entire files from remote servers.  As Puppet matures, it
-    expected that the ``file`` resource will be used less and less to
+    expected that the `file` resource will be used less and less to
     manage content, and instead native resources will be used to do so.
 
     If you find that you are often copying files in from a central
@@ -61,33 +61,33 @@ Puppet::Type.newtype(:file) do
   newparam(:backup) do
     desc "Whether files should be backed up before
       being replaced.  The preferred method of backing files up is via
-      a ``filebucket``, which stores files by their MD5 sums and allows
+      a `filebucket`, which stores files by their MD5 sums and allows
       easy retrieval without littering directories with backups.  You
       can specify a local filebucket or a network-accessible
-      server-based filebucket by setting ``backup => bucket-name``.
-      Alternatively, if you specify any value that begins with a ``.``
-      (e.g., ``.puppet-bak``), then Puppet will use copy the file in
+      server-based filebucket by setting `backup => bucket-name`.
+      Alternatively, if you specify any value that begins with a `.`
+      (e.g., `.puppet-bak`), then Puppet will use copy the file in
       the same directory with that value as the extension of the
-      backup. Setting ``backup => false`` disables all backups of the
+      backup. Setting `backup => false` disables all backups of the
       file in question.
 
-      Puppet automatically creates a local filebucket named ``puppet`` and
+      Puppet automatically creates a local filebucket named `puppet` and
       defaults to backing up there.  To use a server-based filebucket,
-      you must specify one in your configuration::
+      you must specify one in your configuration
 
-        filebucket { main:
-          server => puppet
-        }
+            filebucket { main:
+              server => puppet
+            }
 
-      The ``puppet master`` daemon creates a filebucket by default,
+      The `puppet master` daemon creates a filebucket by default,
       so you can usually back up to your main server with this
       configuration.  Once you've described the bucket in your
-      configuration, you can use it in any file::
+      configuration, you can use it in any file
 
-        file { \"/my/file\":
-          source => \"/path/in/nfs/or/something\",
-          backup => main
-        }
+            file { \"/my/file\":
+              source => \"/path/in/nfs/or/something\",
+              backup => main
+            }
 
       This will back the file up to the central server.
 
@@ -192,9 +192,9 @@ Puppet::Type.newtype(:file) do
   newparam(:ignore) do
     desc "A parameter which omits action on files matching
       specified patterns during recursion.  Uses Ruby's builtin globbing
-      engine, so shell metacharacters are fully supported, e.g. ``[a-z]*``.
+      engine, so shell metacharacters are fully supported, e.g. `[a-z]*`.
       Matches that would descend into the directory structure are ignored,
-      e.g., ``*/*``."
+      e.g., `*/*`."
 
     validate do |value|
       unless value.is_a?(Array) or value.is_a?(String) or value == false
@@ -205,10 +205,10 @@ Puppet::Type.newtype(:file) do
 
   newparam(:links) do
     desc "How to handle links during file actions.  During file copying,
-      ``follow`` will copy the target file instead of the link, ``manage``
-      will copy the link itself, and ``ignore`` will just pass it by.
-      When not copying, ``manage`` and ``ignore`` behave equivalently
-      (because you cannot really ignore links entirely during local recursion), and ``follow`` will manage the file to which the
+      `follow` will copy the target file instead of the link, `manage`
+      will copy the link itself, and `ignore` will just pass it by.
+      When not copying, `manage` and `ignore` behave equivalently
+      (because you cannot really ignore links entirely during local recursion), and `follow` will manage the file to which the
       link points."
 
     newvalues(:follow, :manage)
@@ -223,7 +223,7 @@ Puppet::Type.newtype(:file) do
       files unless you really know what you are doing.  This option only
       makes sense when recursively managing directories.
 
-      Note that when using ``purge`` with ``source``, Puppet will purge any files
+      Note that when using `purge` with `source`, Puppet will purge any files
       that are not on the remote system."
 
     defaultto :false
@@ -234,7 +234,7 @@ Puppet::Type.newtype(:file) do
   newparam(:sourceselect) do
     desc "Whether to copy all valid sources, or just the first one.  This parameter
       is only used in recursive copies; by default, the first valid source is the
-      only one used as a recursive source, but if this parameter is set to ``all``,
+      only one used as a recursive source, but if this parameter is set to `all`,
       then all valid sources will have all of their contents copied to the local host,
       and for sources that have the same file, the source earlier in the list will
       be used."

data/lib/puppet/type/file/content.rb

@@ -161,11 +161,17 @@ module Puppet
       }
     end
 
+    def self.standalone?
+      Puppet.settings[:name] == "apply"
+    end
+
     def each_chunk_from(source_or_content)
       if source_or_content.is_a?(String)
         yield source_or_content
       elsif source_or_content.nil?
         yield read_file_from_filebucket
+      elsif self.class.standalone?
+        yield source_or_content.content
       elsif source_or_content.local?
         chunk_file_from_disk(source_or_content) { |chunk| yield chunk }
       else
@@ -184,7 +190,7 @@ module Puppet
     end
 
     def chunk_file_from_source(source_or_content)
-      request = Puppet::Indirector::Request.new(:file_content, :find, source_or_content.full_path)
+      request = Puppet::Indirector::Request.new(:file_content, :find, source_or_content.full_path.sub(/^\//,''))
       connection = Puppet::Network::HttpPool.http_instance(source_or_content.server, source_or_content.port)
       connection.request_get(indirection2uri(request), add_accept_encoding({"Accept" => "raw"})) do |response|
         case response.code