openvox 8.19.0

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/util/checksums'
+
+# Specify which checksum algorithm to use when checksumming
+# files.
+Puppet::Type.type(:file).newparam(:checksum) do
+  include Puppet::Util::Checksums
+
+  # The default is defined in Puppet.default_digest_algorithm
+  desc "The checksum type to use when determining whether to replace a file's contents.
+
+    The default checksum type is sha256."
+
+  # The values are defined in Puppet::Util::Checksums.known_checksum_types
+  newvalues(:sha256, :sha256lite, :md5, :md5lite, :sha1, :sha1lite, :sha512, :sha384, :sha224, :mtime, :ctime, :none)
+
+  defaultto do
+    Puppet[:digest_algorithm].to_sym
+  end
+
+  validate do |value|
+    if Puppet::Util::Platform.fips_enabled? && (value == :md5 || value == :md5lite)
+      raise ArgumentError, _("MD5 is not supported in FIPS mode")
+    end
+  end
+
+  def sum(content)
+    content = content.is_a?(Puppet::Pops::Types::PBinaryType::Binary) ? content.binary_buffer : content
+    type = digest_algorithm
+    "{#{type}}" + send(type, content)
+  end
+
+  def sum_file(path)
+    type = digest_algorithm
+    method = type.to_s + "_file"
+    "{#{type}}" + send(method, path).to_s
+  end
+
+  def sum_stream(&block)
+    type = digest_algorithm
+    method = type.to_s + "_stream"
+    checksum = send(method, &block)
+    "{#{type}}#{checksum}"
+  end
+
+  private
+
+  # Return the appropriate digest algorithm with fallbacks in case puppet defaults have not
+  # been initialized.
+  def digest_algorithm
+    value || Puppet[:digest_algorithm].to_sym
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/util/checksums'
+require_relative '../../../puppet/type/file/data_sync'
+
+module Puppet
+  Puppet::Type.type(:file).newproperty(:checksum_value) do
+    include Puppet::Util::Checksums
+    include Puppet::DataSync
+
+    desc "The checksum of the source contents. Only md5, sha256, sha224, sha384 and sha512
+      are supported when specifying this parameter. If this parameter is set,
+      source_permissions will be assumed to be false, and ownership and permissions
+      will not be read from source."
+
+    def insync?(is)
+      # If checksum_value and source are specified, manage the file contents.
+      # Otherwise the content property will manage syncing.
+      if resource.parameter(:source).nil?
+        return true
+      end
+
+      checksum_insync?(resource.parameter(:source), is, true) { |inner| super(inner) }
+    end
+
+    def property_matches?(current, desired)
+      return true if super(current, desired)
+
+      date_matches?(resource.parameter(:checksum).value, current, desired)
+    end
+
+    def retrieve
+      # If checksum_value and source are specified, manage the file contents.
+      # Otherwise the content property will manage syncing. Don't compute the checksum twice.
+      if resource.parameter(:source).nil?
+        return nil
+      end
+
+      result = retrieve_checksum(resource)
+      # If the returned type matches the util/checksums format (prefixed with the type),
+      # strip the checksum type.
+      result = sumdata(result) if checksum?(result)
+      result
+    end
+
+    def sync
+      if resource.parameter(:source).nil?
+        devfail "checksum_value#sync should not be called without a source parameter"
+      end
+
+      # insync? only returns false if it expects to manage the file content,
+      # so instruct the resource to write its contents.
+      contents_sync(resource.parameter(:source))
+    end
+  end
+end

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

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'tempfile'
+
+require_relative '../../../puppet/util/checksums'
+require_relative '../../../puppet/type/file/data_sync'
+
+module Puppet
+  Puppet::Type.type(:file).newproperty(:content) do
+    include Puppet::Util::Checksums
+    include Puppet::DataSync
+
+    attr_reader :actual_content
+
+    desc <<-'EOT'
+      The desired contents of a file, as a string. This attribute is mutually
+      exclusive with `source` and `target`.
+
+      Newlines and tabs can be specified in double-quoted strings using
+      standard escaped syntax --- \n for a newline, and \t for a tab.
+
+      With very small files, you can construct content strings directly in
+      the manifest...
+
+          define resolve($nameserver1, $nameserver2, $domain, $search) {
+              $str = "search ${search}
+                  domain ${domain}
+                  nameserver ${nameserver1}
+                  nameserver ${nameserver2}
+                  "
+
+              file { '/etc/resolv.conf':
+                content => $str,
+              }
+          }
+
+      ...but for larger files, this attribute is more useful when combined with the
+      [template](https://puppet.com/docs/puppet/latest/function.html#template)
+      or [file](https://puppet.com/docs/puppet/latest/function.html#file)
+      function.
+    EOT
+
+    # Store a checksum as the value, rather than the actual content.
+    # Simplifies everything.
+    munge do |value|
+      if value == :absent
+        value
+      elsif value.is_a?(String) && checksum?(value)
+        # XXX This is potentially dangerous because it means users can't write a file whose
+        # entire contents are a plain checksum unless it is a Binary content.
+        Puppet.puppet_deprecation_warning([
+          # TRANSLATORS "content" is an attribute and should not be translated
+          _('Using a checksum in a file\'s "content" property is deprecated.'),
+          # TRANSLATORS "filebucket" is a resource type and should not be translated. The quoted occurrence of "content" is an attribute and should not be translated.
+          _('The ability to use a checksum to retrieve content from the filebucket using the "content" property will be removed in a future release.'),
+          # TRANSLATORS "content" is an attribute and should not be translated.
+          _('The literal value of the "content" property will be written to the file.'),
+          # TRANSLATORS "static catalogs" should not be translated.
+          _('The checksum retrieval functionality is being replaced by the use of static catalogs.'),
+          _('See https://puppet.com/docs/puppet/latest/static_catalogs.html for more information.')
+        ].join(" "),
+                                          :file => @resource.file,
+                                          :line => @resource.line) if !@actual_content && !resource.parameter(:source)
+        value
+      else
+        @actual_content = value.is_a?(Puppet::Pops::Types::PBinaryType::Binary) ? value.binary_buffer : value
+        resource.parameter(:checksum).sum(@actual_content)
+      end
+    end
+
+    # Checksums need to invert how changes are printed.
+    def change_to_s(currentvalue, newvalue)
+      # Our "new" checksum value is provided by the source.
+      source = resource.parameter(:source)
+      tmp = source.checksum if source
+      if tmp
+        newvalue = tmp
+      end
+      if currentvalue == :absent
+        "defined content as '#{newvalue}'"
+      elsif newvalue == :absent
+        "undefined content from '#{currentvalue}'"
+      else
+        "content changed '#{currentvalue}' to '#{newvalue}'"
+      end
+    end
+
+    def length
+      (actual_content and actual_content.length) || 0
+    end
+
+    def content
+      should
+    end
+
+    # Override this method to provide diffs if asked for.
+    # Also, fix #872: when content is used, and replace is true, the file
+    # should be insync when it exists
+    def insync?(is)
+      if resource[:source] && resource[:checksum_value]
+        # Asserts that nothing has changed since validate ran.
+        devfail "content property should not exist if source and checksum_value are specified"
+      end
+
+      contents_prop = resource.parameter(:source) || self
+      checksum_insync?(contents_prop, is, !resource[:content].nil?) { |inner| super(inner) }
+    end
+
+    def property_matches?(current, desired)
+      # If checksum_value is specified, it overrides comparing the content field.
+      checksum_type = resource.parameter(:checksum).value
+      checksum_value = resource.parameter(:checksum_value)
+      if checksum_value
+        desired = "{#{checksum_type}}#{checksum_value.value}"
+      end
+
+      # The inherited equality is always accepted, so use it if valid.
+      return true if super(current, desired)
+
+      date_matches?(checksum_type, current, desired)
+    end
+
+    def retrieve
+      retrieve_checksum(resource)
+    end
+
+    # Make sure we're also managing the checksum property.
+    def should=(value)
+      # treat the value as a bytestring
+      value = value.b if value.is_a?(String)
+      @resource.newattr(:checksum) unless @resource.parameter(:checksum)
+      super
+    end
+
+    # Just write our content out to disk.
+    def sync
+      contents_sync(resource.parameter(:source) || self)
+    end
+
+    def write(file)
+      resource.parameter(:checksum).sum_stream { |sum|
+        each_chunk_from { |chunk|
+          sum << chunk
+          file.print chunk
+        }
+      }
+    end
+
+    private
+
+    # the content is munged so if it's a checksum source_or_content is nil
+    # unless the checksum indirectly comes from source
+    def each_chunk_from
+      if actual_content.is_a?(String)
+        yield actual_content
+      elsif content_is_really_a_checksum? && actual_content.nil?
+        yield read_file_from_filebucket
+      elsif actual_content.nil?
+        yield ''
+      end
+    end
+
+    def content_is_really_a_checksum?
+      checksum?(should)
+    end
+
+    def read_file_from_filebucket
+      dipper = resource.bucket
+      raise "Could not get filebucket from file" unless dipper
+
+      sum = should.sub(/\{\w+\}/, '')
+
+      dipper.getfile(sum)
+    rescue => detail
+      self.fail Puppet::Error, "Could not retrieve content for #{should} from filebucket: #{detail}", detail
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Puppet
+  Puppet::Type.type(:file).newproperty(:ctime) do
+    desc "A read-only state to check the file ctime. On most modern \*nix-like
+      systems, this is the time of the most recent change to the owner, group,
+      permissions, or content of the file."
+
+    def retrieve
+      current_value = :absent
+      stat = @resource.stat
+      if stat
+        current_value = stat.ctime
+      end
+      current_value.to_s
+    end
+
+    validate do |_val|
+      fail "ctime is read-only"
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/util/checksums'
+require_relative '../../../puppet/util/diff'
+require 'date'
+require 'tempfile'
+
+module Puppet
+  module DataSync
+    include Puppet::Util::Checksums
+    include Puppet::Util::Diff
+
+    def write_temporarily(param)
+      tempfile = Tempfile.new("puppet-file")
+      tempfile.open
+
+      param.write(tempfile)
+
+      tempfile.close
+
+      yield tempfile.path
+    ensure
+      tempfile.delete if tempfile
+    end
+
+    def checksum_insync?(param, is, has_contents, &block)
+      resource = param.resource
+      if resource.should_be_file?
+        return false if is == :absent
+      else
+        if resource[:ensure] == :present && has_contents && (s = resource.stat)
+          # TRANSLATORS 'Ensure' is an attribute and ':present' is a value and should not be translated
+          resource.warning _("Ensure set to :present but file type is %{file_type} so no content will be synced") % { file_type: s.ftype }
+        end
+        return true
+      end
+
+      return true unless resource.replace?
+
+      is_insync = yield(is)
+
+      if show_diff?(!is_insync)
+        if param.sensitive
+          send resource[:loglevel], "[diff redacted]"
+        else
+          write_temporarily(param) do |path|
+            diff_output = diff(resource[:path], path)
+            if diff_output.encoding == Encoding::BINARY || !diff_output.valid_encoding?
+              diff_output = "Binary files #{resource[:path]} and #{path} differ"
+            end
+            send resource[:loglevel], "\n" + diff_output
+          end
+        end
+      end
+      is_insync
+    end
+
+    def show_diff?(has_changes)
+      has_changes && Puppet[:show_diff] && resource.show_diff?
+    end
+
+    def date_matches?(checksum_type, current, desired)
+      time_types = [:mtime, :ctime]
+      return false unless time_types.include?(checksum_type)
+      return false unless current && desired
+
+      begin
+        if checksum?(current) || checksum?(desired)
+          raise if !time_types.include?(sumtype(current).to_sym) || !time_types.include?(sumtype(desired).to_sym)
+
+          current = sumdata(current)
+          desired = sumdata(desired)
+        end
+        DateTime.parse(current) >= DateTime.parse(desired)
+      rescue => detail
+        self.fail Puppet::Error, "Resource with checksum_type #{checksum_type} didn't contain a date in #{current} or #{desired}", detail.backtrace
+      end
+    end
+
+    def retrieve_checksum(resource)
+      stat = resource.stat
+      return :absent unless stat
+
+      ftype = stat.ftype
+      # Don't even try to manage the content on directories or links
+      return nil if %w[directory link fifo socket].include?(ftype)
+
+      begin
+        resource.parameter(:checksum).sum_file(resource[:path])
+      rescue => detail
+        raise Puppet::Error, "Could not read #{ftype} #{resource.title}: #{detail}", detail.backtrace
+      end
+    end
+
+    def contents_sync(param)
+      return_event = param.resource.stat ? :file_changed : :file_created
+      resource.write(param)
+      return_event
+    end
+  end
+end

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

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module Puppet
+  Puppet::Type.type(:file).ensurable do
+    require 'etc'
+    require_relative '../../../puppet/util/symbolic_file_mode'
+    include Puppet::Util::SymbolicFileMode
+
+    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` accepts any form of file existence, and creates a
+        normal file if the file is missing. (The file will have no content
+        unless the `content` or `source` attribute is used.)
+      * `absent` ensures the file doesn't exist, and deletes it if necessary.
+      * `file` ensures it's a normal file, and enables use of the `content` or
+        `source` attribute.
+      * `directory` ensures it's a directory, and enables use of the `source`,
+        `recurse`, `recurselimit`, `ignore`, and `purge` attributes.
+      * `link` ensures 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 has 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:
+
+          file { '/etc/inetd.conf':
+            ensure => '/etc/inet/inetd.conf',
+          }
+
+          file { '/etc/inetd.conf':
+            ensure => link,
+            target => '/etc/inet/inetd.conf',
+          }
+
+      However, we recommend using `link` and `target` explicitly, since this
+      behavior can be harder to read and is
+      [deprecated](https://docs.puppet.com/puppet/4.3/deprecated_language.html)
+      as of Puppet 4.3.0.
+    EOT
+
+    # Most 'ensure' properties have a default, but with files we, um, don't.
+    nodefault
+
+    newvalue(:absent) do
+      Puppet::FileSystem.unlink(@resource[:path])
+    end
+
+    aliasvalue(:false, :absent)
+
+    newvalue(:file, :event => :file_created) do
+      # Make sure we're not managing the content some other way
+      property = @resource.property(:content) || @resource.property(:checksum_value)
+      if property
+        property.sync
+      else
+        @resource.write
+        @resource.should(:mode)
+      end
+    end
+
+    # aliasvalue(:present, :file)
+    newvalue(:present, :event => :file_created) do
+      # Make a file if they want something, but this will match almost
+      # anything.
+      set_file
+    end
+
+    newvalue(:directory, :event => :directory_created) do
+      mode = @resource.should(:mode)
+      parent = File.dirname(@resource[:path])
+      unless Puppet::FileSystem.exist? parent
+        raise Puppet::Error,
+              "Cannot create #{@resource[:path]}; parent directory #{parent} does not exist"
+      end
+      if mode
+        Puppet::Util.withumask(0o00) do
+          Dir.mkdir(@resource[:path], symbolic_mode_to_int(mode, 0o755, true))
+        end
+      else
+        Dir.mkdir(@resource[:path])
+      end
+      @resource.send(:property_fix)
+      return :directory_created
+    end
+
+    newvalue(:link, :event => :link_created, :required_features => :manages_symlinks) do
+      property = resource.property(:target)
+      fail "Cannot create a symlink without a target" unless property
+
+      property.retrieve
+      property.mklink
+    end
+
+    # Symlinks.
+    newvalue(/./) do
+      # This code never gets executed.  We need the regex to support
+      # specifying it, but the work is done in the 'symlink' code block.
+    end
+
+    munge do |value|
+      value = super(value)
+      unless value.is_a? Symbol
+        resource[:target] = value
+        value = :link
+      end
+      resource[:links] = :manage if value == :link and resource[:links] != :follow
+      value
+    end
+
+    def change_to_s(currentvalue, newvalue)
+      return super unless [:file, :present].include?(newvalue)
+
+      property = @resource.property(:content)
+      return super unless property
+
+      # We know that content is out of sync if we're here, because
+      # it's essentially equivalent to 'ensure' in the transaction.
+      source = @resource.parameter(:source)
+      if source
+        should = source.checksum
+      else
+        should = property.should
+      end
+      if should == :absent
+        is = property.retrieve
+      else
+        is = :absent
+      end
+
+      property.change_to_s(is, should)
+    end
+
+    # Check that we can actually create anything
+    def check
+      basedir = File.dirname(@resource[:path])
+
+      if !Puppet::FileSystem.exist?(basedir)
+        raise Puppet::Error,
+              "Can not create #{@resource.title}; parent directory does not exist"
+      elsif !FileTest.directory?(basedir)
+        raise Puppet::Error,
+              "Can not create #{@resource.title}; #{dirname} is not a directory"
+      end
+    end
+
+    # We have to treat :present specially, because it works with any
+    # type of file.
+    def insync?(currentvalue)
+      unless currentvalue == :absent or resource.replace?
+        return true
+      end
+
+      if should == :present
+        !(currentvalue.nil? or currentvalue == :absent)
+      else
+        super(currentvalue)
+      end
+    end
+
+    def retrieve
+      stat = @resource.stat
+      if stat
+        stat.ftype.intern
+      elsif should == :false
+        :false
+      else
+        :absent
+      end
+    end
+
+    def sync
+      @resource.remove_existing(should)
+      if should == :absent
+        return :file_removed
+      end
+
+      super
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/util/posix'
+
+module Puppet
+  # Manage file group ownership.
+  Puppet::Type.type(:file).newproperty(:group) do
+    desc <<-EOT
+      Which group should own the file.  Argument can be either a group
+      name or a group ID.
+
+      On Windows, a user (such as "Administrator") can be set as a file's group
+      and a group (such as "Administrators") can be set as a file's owner;
+      however, a file's owner and group shouldn't be the same. (If the owner
+      is also the group, files with modes like `"0640"` will cause log churn, as
+      they will always appear out of sync.)
+    EOT
+
+    validate do |group|
+      raise(Puppet::Error, "Invalid group name '#{group.inspect}'") unless group and group != ""
+    end
+
+    def insync?(current)
+      # We don't want to validate/munge groups until we actually start to
+      # evaluate this property, because they might be added during the catalog
+      # apply.
+      @should.map! do |val|
+        gid = provider.name2gid(val)
+        if gid
+          gid
+        elsif provider.resource.noop?
+          return false
+        else
+          raise "Could not find group #{val}"
+        end
+      end
+
+      @should.include?(current)
+    end
+
+    # We want to print names, not numbers
+    def is_to_s(currentvalue) # rubocop:disable Naming/PredicateName
+      super(provider.gid2name(currentvalue) || currentvalue)
+    end
+
+    def should_to_s(newvalue)
+      super(provider.gid2name(newvalue) || newvalue)
+    end
+  end
+end