puppet 3.3.2 → 3.4.0.rc1

data/lib/puppet/type.rb

@@ -692,6 +692,20 @@ class Type
     }
   end
 
+  # Return the parameters, metaparams, and properties that have a value or were set by a default. Properties are
+  # included since they are a subclass of parameter.
+  # @return [Array<Puppet::Parameter>] Array of parameter objects ( or subclass thereof )
+  def parameters_with_value
+    self.class.allattrs.collect { |attr| parameter(attr) }.compact
+  end
+
+  # Iterates over all parameters with value currently set.
+  # @yieldparam parameter [Puppet::Parameter] or a subclass thereof
+  # @return [void]
+  def eachparameter
+    parameters_with_value.each { |parameter| yield parameter }
+  end
+
   # Creates a transaction event.
   # Called by Transaction or by a property.
   # Merges the given options with the options `:resource`, `:file`, `:line`, and `:tags`, initialized from
@@ -2278,6 +2292,13 @@ class Type
   # @return [Array<Puppet::Parameter>] the validated list/set of attributes
   #
   def finish
+    # Call post_compile hook on every parameter that implements it. This includes all subclasses
+    # of parameter including, but not limited to, regular parameters, metaparameters, relationship
+    # parameters, and properties.
+    eachparameter do |parameter|
+      parameter.post_compile if parameter.respond_to? :post_compile
+    end
+
     # Make sure all of our relationships are valid.  Again, must be done
     # when the entire catalog is instantiated.
     self.class.relationship_params.collect do |klass|
@@ -2297,25 +2318,21 @@ class Type
     self[:name]
   end
 
-  # Returns the parent of this in the catalog.
-  # In case of an erroneous catalog where multiple parents have been produced, the first found (non deterministic)
-  # parent is returned.
-  # @return [???, nil] WHAT (which types can be the parent of a resource in a catalog?), or nil if there
-  #   is no catalog.
-  #
+  # Returns the parent of this in the catalog.  In case of an erroneous catalog
+  # where multiple parents have been produced, the first found (non
+  # deterministic) parent is returned.
+  # @return [Puppet::Type, nil] the
+  #   containing resource or nil if there is no catalog or no containing
+  #   resource.
   def parent
     return nil unless catalog
 
-    unless defined?(@parent)
+    @parent ||=
       if parents = catalog.adjacent(self, :direction => :in)
-        # We should never have more than one parent, so let's just ignore
-        # it if we happen to.
-        @parent = parents.shift
+        parents.shift
       else
-        @parent = nil
+        nil
       end
-    end
-    @parent
   end
 
   # Returns a reference to this as a string in "Type[name]" format.

data/lib/puppet/type/augeas.rb

@@ -96,52 +96,18 @@ Puppet::Type.newtype(:augeas) do
     desc "The changes which should be applied to the filesystem. This
     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
-
-
-    `clearm <PATH> <SUB>`
-    : Sets multiple nodes (matching `SUB` relative to `PATH`) to `NULL`
-
-
-    `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
+    * `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
+    * `clearm <PATH> <SUB>` --- Sets multiple nodes (matching `SUB` relative to `PATH`) to `NULL`
+    * `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

data/lib/puppet/type/component.rb

@@ -34,13 +34,7 @@ Puppet::Type.newtype(:component) do
   # Component paths are special because they function as containers.
   def pathbuilder
     if reference.type == "Class"
-      # 'main' is the top class, so we want to see '//' instead of
-      # its name.
-      if reference.title.to_s.downcase == "main"
-        myname = ""
-      else
-        myname = reference.title
-      end
+      myname = reference.title
     else
       myname = reference.to_s
     end

data/lib/puppet/type/exec.rb

@@ -220,6 +220,18 @@ module Puppet
       end
     end
 
+    newparam(:umask, :required_feature => :umask) do
+      desc "Sets the umask to be used while executing this command"
+
+      munge do |value|
+        if value =~ /^0?[0-7]{1,4}$/
+          return value.to_i(8)
+        else
+          raise Puppet::Error, "The umask specification is invalid: #{value.inspect}"
+        end
+      end
+    end
+
     newparam(:timeout) do
       desc "The maximum time the command should take.  If the command takes
         longer than the timeout, the command is considered to have failed
@@ -341,7 +353,7 @@ module Puppet
       # If the file exists, return false (i.e., don't run the command),
       # else return true
       def check(value)
-        ! FileTest.exists?(value)
+        ! Puppet::FileSystem::File.exist?(value)
       end
     end
 

data/lib/puppet/type/file.rb

@@ -34,6 +34,9 @@ Puppet::Type.newtype(:file) do
     file, the file resource will autorequire them. If Puppet is managing any
     parent directories of a file, the file resource will autorequire them."
 
+  feature :manages_symlinks,
+    "The provider can manage symbolic links."
+
   def self.title_patterns
     [ [ /^(.*?)\/*\Z/m, [ [ :path ] ] ] ]
   end
@@ -54,7 +57,12 @@ Puppet::Type.newtype(:file) do
     end
 
     munge do |value|
-      ::File.join(::File.split(::File.expand_path(value)))
+      if value.start_with?('//') and ::File.basename(value) == "/"
+        # This is a UNC path pointing to a share, so don't add a trailing slash
+        ::File.expand_path(value)
+      else
+        ::File.join(::File.split(::File.expand_path(value)))
+      end
     end
   end
 
@@ -118,15 +126,16 @@ Puppet::Type.newtype(:file) do
   end
 
   newparam(:recurse) do
-    desc "Whether and how deeply to do recursive
-      management. Options are:
+    desc "Whether and how to do recursive file management. Options are:
 
       * `inf,true` --- Regular style recursion on both remote and local
-        directory structure.
-      * `remote` --- Descends recursively into the remote directory
-        but not the local directory. Allows copying of
+        directory structure.  See `recurselimit` to specify a limit to the
+        recursion depth.
+      * `remote` --- Descends recursively into the remote (source) directory
+        but not the local (destination) directory. Allows copying of
         a few files into a directory containing many
         unmanaged files without scanning all the local files.
+        This can only be used when a source parameter is specified. 
       * `false` --- Default of no recursion.
     "
 
@@ -682,7 +691,7 @@ Puppet::Type.newtype(:file) do
     end
 
     @stat = begin
-      ::File.send(method, self[:path])
+      Puppet::FileSystem::File.new(self[:path]).send(method)
     rescue Errno::ENOENT => error
       nil
     rescue Errno::ENOTDIR => error
@@ -707,7 +716,7 @@ Puppet::Type.newtype(:file) do
     use_temporary_file = write_temporary_file?
     if use_temporary_file
       path = "#{self[:path]}.puppettmp_#{rand(10000)}"
-      path = "#{self[:path]}.puppettmp_#{rand(10000)}" while ::File.exists?(path) or ::File.symlink?(path)
+      path = "#{self[:path]}.puppettmp_#{rand(10000)}" while Puppet::FileSystem::File.exist?(path) or Puppet::FileSystem::File.new(path).symlink?
     else
       path = self[:path]
     end
@@ -727,7 +736,7 @@ Puppet::Type.newtype(:file) do
         fail "Could not rename temporary file #{path} to #{self[:path]}: #{detail}"
       ensure
         # Make sure the created file gets removed
-        ::File.unlink(path) if FileTest.exists?(path)
+        Puppet::FileSystem::File.unlink(path) if Puppet::FileSystem::File.exist?(path)
       end
     end
 
@@ -777,7 +786,7 @@ Puppet::Type.newtype(:file) do
   # @api private
   def remove_file(current_type, wanted_type)
     debug "Removing existing #{current_type} for replacement with #{wanted_type}"
-    ::File.unlink(self[:path])
+    Puppet::FileSystem::File.unlink(self[:path])
     stat_needed
     true
   end

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

@@ -133,6 +133,9 @@ module Puppet
 
     # Make sure we're also managing the checksum property.
     def should=(value)
+      # treat the value as a bytestring, in Ruby versions that support it, regardless of the encoding
+      # in which it has been supplied
+      value = value.clone.force_encoding(Encoding::ASCII_8BIT) if value.respond_to?(:force_encoding)
       @resource.newattr(:checksum) unless @resource.parameter(:checksum)
       super
     end

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

@@ -5,17 +5,35 @@ module Puppet
     require 'puppet/util/symbolic_file_mode'
     include Puppet::Util::SymbolicFileMode
 
-    desc <<-'EOT'
-      Whether to create files that don't currently exist.
-      Possible values are `absent`, `present`, `file`, `directory`, and `link`.
-      Specifying `present` will match any form of file existence, and
-      if the file is missing will create an empty file. Specifying
-      `absent` will delete the file (or directory, if `recurse => true` and
-      `force => true`). Specifying `link` requires that you also set the `target`
-      attribute; note that symlinks cannot be managed on Windows.
-
-      If you specify the path to another file as the ensure value, it is
-      equivalent to specifying `link` and using that path as the `target`:
+    desc <<-EOT
+      Whether the file should exist, and if so what kind of file it should be.
+      Possible values are `present`, `absent`, `file`, `directory`, and `link`.
+
+      * `present` will accept any form of file existence, and will create a
+        normal file if the file is missing. (The file will have no content
+        unless the `content` or `source` attribute is used.)
+      * `absent` will make sure the file doesn't exist, deleting it
+        if necessary.
+      * `file` will make sure it's a normal file, and enables use of the
+        `content` or `source` attribute.
+      * `directory` will make sure it's a directory, and enables use of the
+        `source`, `recurse`, `recurselimit`, `ignore`, and `purge` attributes.
+      * `link` will make sure the file is a symlink, and **requires** that you
+        also set the `target` attribute. Symlinks are supported on all Posix
+        systems and on Windows Vista / 2008 and higher. On Windows, managing
+        symlinks requires puppet agent's user account to have the "Create
+        Symbolic Links" privilege; this can be configured in the "User Rights
+        Assignment" section in the Windows policy editor. By default, puppet
+        agent runs as the Administrator account, which does have this privilege.
+
+      Puppet avoids destroying directories unless the `force` attribute is set
+      to `true`. This means that if a file is currently a directory, setting
+      `ensure` to anything but `directory` or `present` will cause Puppet to
+      skip managing the resource and log either a notice or an error.
+
+      There is one other non-standard value for `ensure`. If you specify the
+      path to another file as the ensure value, it is equivalent to specifying
+      `link` and using that path as the `target`:
 
           # Equivalent resources:
 
@@ -36,7 +54,7 @@ module Puppet
     nodefault
 
     newvalue(:absent) do
-      File.unlink(@resource[:path])
+      Puppet::FileSystem::File.unlink(@resource[:path])
     end
 
     aliasvalue(:false, :absent)
@@ -61,7 +79,7 @@ module Puppet
     newvalue(:directory, :event => :directory_created) do
       mode = @resource.should(:mode)
       parent = File.dirname(@resource[:path])
-      unless FileTest.exists? parent
+      unless Puppet::FileSystem::File.exist? parent
         raise Puppet::Error,
           "Cannot create #{@resource[:path]}; parent directory #{parent} does not exist"
       end
@@ -77,7 +95,7 @@ module Puppet
     end
 
 
-    newvalue(:link, :event => :link_created) do
+    newvalue(:link, :event => :link_created, :required_features => :manages_symlinks) do
       fail "Cannot create a symlink without a target" unless property = resource.property(:target)
       property.retrieve
       property.mklink
@@ -121,7 +139,7 @@ module Puppet
     def check
       basedir = File.dirname(@resource[:path])
 
-      if ! FileTest.exists?(basedir)
+      if ! Puppet::FileSystem::File.exist?(basedir)
         raise Puppet::Error,
           "Can not create #{@resource.title}; parent directory does not exist"
       elsif ! FileTest.directory?(basedir)

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

@@ -39,8 +39,12 @@ module Puppet
           * g (group's current permissions)
           * o (other's current permissions)
 
-      Thus, mode `0664` could be represented symbolically as either `a=r,ug+w` or
-      `ug=rw,o=r`. See the manual page for GNU or BSD `chmod` for more details
+      Thus, mode `0664` could be represented symbolically as either `a=r,ug+w`
+      or `ug=rw,o=r`.  However, symbolic modes are more expressive than numeric
+      modes: a mode only affects the specified bits, so `mode => 'ug+w'` will
+      set the user and group write bits, without affecting any other bits.
+
+      See the manual page for GNU or BSD `chmod` for more details
       on numeric and symbolic modes.
 
       On Windows, permissions are translated as follows:

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

@@ -1,4 +1,3 @@
-
 require 'puppet/file_serving/content'
 require 'puppet/file_serving/metadata'
 
@@ -85,7 +84,7 @@ module Puppet
 
     def change_to_s(currentvalue, newvalue)
       # newvalue = "{md5}#{@metadata.checksum}"
-      if @resource.property(:ensure).retrieve == :absent
+      if resource.property(:ensure).retrieve == :absent
         return "creating from source #{metadata.source} with contents #{metadata.checksum}"
       else
         return "replacing from source #{metadata.source} with contents #{metadata.checksum}"
@@ -111,28 +110,48 @@ module Puppet
     def copy_source_values
       devfail "Somehow got asked to copy source values without any metadata" unless metadata
 
+      # conditionally copy :checksum
+      if metadata.ftype != "directory" && !(metadata.ftype == "link" && metadata.links == :manage)
+        copy_source_value(:checksum)
+      end
+
       # Take each of the stats and set them as states on the local file
       # if a value has not already been provided.
-      [:owner, :mode, :group, :checksum].each do |metadata_method|
-        param_name = (metadata_method == :checksum) ? :content : metadata_method
+      [:owner, :mode, :group].each do |metadata_method|
         next if metadata_method == :owner and !Puppet.features.root?
-        next if metadata_method == :checksum and metadata.ftype == "directory"
-        next if metadata_method == :checksum and metadata.ftype == "link" and metadata.links == :manage
+        next if metadata_method == :group and !Puppet.features.root?
 
         if Puppet.features.microsoft_windows?
-          next if [:owner, :group].include?(metadata_method) and !local?
+          # Warn on Windows if source permissions are being used and the file resource
+          # does not have mode owner and group all set (which would take precedence).
+          if [:use, :use_when_creating].include?(resource[:source_permissions]) &&
+            (resource[:owner] == nil || resource[:group] == nil || resource[:mode] == nil)
+
+            warning = "Copying %s from the source" <<
+                      " file on Windows is deprecated;" <<
+                      " use source_permissions => ignore."
+            Puppet.deprecation_warning(warning % 'owner/mode/group')
+            resource.debug(warning % metadata_method.to_s)
+          end
+          # But never try to copy remote owner/group on Windows
+          next if [:owner, :group].include?(metadata_method) && !local?
         end
 
-        if resource[param_name].nil? or resource[param_name] == :absent
-          resource[param_name] = metadata.send(metadata_method)
+        case resource[:source_permissions]
+        when :ignore
+          next
+        when :use_when_creating
+          next if Puppet::FileSystem::File.exist?(resource[:path])
         end
+
+        copy_source_value(metadata_method)
       end
 
       if resource[:ensure] == :absent
         # We know all we need to
       elsif metadata.ftype != "link"
         resource[:ensure] = metadata.ftype
-      elsif @resource[:links] == :follow
+      elsif resource[:links] == :follow
         resource[:ensure] = :present
       else
         resource[:ensure] = "link"
@@ -140,10 +159,6 @@ module Puppet
       end
     end
 
-    def found?
-      ! (metadata.nil? or metadata.ftype.nil?)
-    end
-
     attr_writer :metadata
 
     # Provide, and retrieve if necessary, the metadata for this file.  Fail
@@ -195,5 +210,41 @@ module Puppet
     def uri
       @uri ||= URI.parse(URI.escape(metadata.source))
     end
+
+    private
+    def found?
+      ! (metadata.nil? or metadata.ftype.nil?)
+    end
+
+    def copy_source_value(metadata_method)
+      param_name = (metadata_method == :checksum) ? :content : metadata_method
+      if resource[param_name].nil? or resource[param_name] == :absent
+        resource[param_name] = metadata.send(metadata_method)
+      end
+    end
+  end
+
+  Puppet::Type.type(:file).newparam(:source_permissions) do
+    desc <<-'EOT'
+      Whether (and how) Puppet should copy owner, group, and mode permissions from
+      the `source` to `file` resources when the permissions are not explicitly
+      specified. (In all cases, explicit permissions will take precedence.)
+      Valid values are `use`, `use_when_creating`, and `ignore`:
+
+      * `use` (the default) will cause Puppet to apply the owner, group,
+        and mode from the `source` to any files it is managing.
+      * `use_when_creating` will only apply the owner, group, and mode from the
+        `source` when creating a file; existing files will not have their permissions
+        overwritten.
+      * `ignore` will never apply the owner, group, or mode from the `source` when
+        managing a file. When creating new files without explicit permissions,
+        the permissions they receive will depend on platform-specific behavior.
+        On POSIX, Puppet will use the umask of the user it is running as. On
+        Windows, Puppet will use the default DACL associated with the user it is
+        running as.
+    EOT
+
+    defaultto :use
+    newvalues(:use, :use_when_creating, :ignore)
   end
 end