RubyGems - bolt - Versions diffs - 0.19.1 → 0.20.0 - Mend

bolt 0.19.1 → 0.20.0

Potentially problematic release.

This version of bolt might be problematic. Click here for more details.

Files changed (1261) hide show

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

@@ -1,50 +0,0 @@
-require 'puppet/util/checksums'
-# Specify which checksum algorithm to use when checksumming
-# files.
-Puppet::Type.type(:file).newparam(:checksum) do
-  include Puppet::Util::Checksums
-  desc "The checksum type to use when determining whether to replace a file's contents.
-    The default checksum type is md5."
-  newvalues "md5", "md5lite", "sha224", "sha256", "sha256lite", "sha384", "sha512", "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/vendored/puppet/lib/puppet/type/file/checksum_value.rb DELETED

@@ -1,54 +0,0 @@
-require 'puppet/util/checksums'
-require '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) {|_is| super(_is)}
-    end
-    def property_matches?(current, desired)
-      return true if super(current, desired)
-      return 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/vendored/puppet/lib/puppet/type/file/content.rb DELETED

@@ -1,160 +0,0 @@
-require 'net/http'
-require 'uri'
-require 'tempfile'
-require 'puppet/util/checksums'
-require 'puppet/type/file/data_sync.rb'
-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://docs.puppetlabs.com/puppet/latest/reference/function.html#template)
-      or [file](https://docs.puppetlabs.com/puppet/latest/reference/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.
-        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.
-      if source = resource.parameter(:source) and tmp = source.checksum
-        newvalue = tmp
-      end
-      if currentvalue == :absent
-        return "defined content as '#{newvalue}'"
-      elsif newvalue == :absent
-        return "undefined content from '#{currentvalue}'"
-      else
-        return "content changed '#{currentvalue}' to '#{newvalue}'"
-      end
-    end
-    def length
-      (actual_content and actual_content.length) || 0
-    end
-    def content
-      self.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?) {|_is| super(_is)}
-    end
-    def property_matches?(current, desired)
-      # If checksum_value is specified, it overrides comparing the content field.
-      checksum_type = resource.parameter(:checksum).value
-      if checksum_value = resource.parameter(: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)
-      return 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, in Ruby versions that support it, regardless of the encoding
-      # in which it has been supplied
-      value = value.dup.force_encoding(Encoding::ASCII_8BIT) if value.respond_to?(:force_encoding)
-      @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
-      raise "Could not get filebucket from file" unless dipper = resource.bucket
-      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/vendored/puppet/lib/puppet/type/file/ctime.rb DELETED

@@ -1,20 +0,0 @@
-module Puppet
-  Puppet::Type.type(:file).newproperty(:ctime) do
-    desc %q{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
-      if stat = @resource.stat
-        current_value = stat.ctime
-      end
-      current_value
-    end
-    validate do |val|
-      fail "ctime is read-only"
-    end
-  end
-end

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

@@ -1,93 +0,0 @@
-require 'puppet/util/checksums'
-require '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 if ! 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|
-            send resource[:loglevel], "\n" + diff(resource[:path], path)
-          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 if !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)
-      return :absent unless stat = resource.stat
-      ftype = stat.ftype
-      # Don't even try to manage the content on directories or links
-      return nil if ["directory","link"].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/vendored/puppet/lib/puppet/type/file/ensure.rb DELETED

@@ -1,192 +0,0 @@
-module Puppet
-  Puppet::Type.type(:file).ensurable do
-    require 'etc'
-    require '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.puppetlabs.com/puppet/4.3/reference/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
-      if property = @resource.property(:content)
-        property.sync
-      elsif property = @resource.property(:checksum_value)
-        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(000) do
-          Dir.mkdir(@resource[:path], symbolic_mode_to_int(mode, 0755, 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
-      fail "Cannot create a symlink without a target" unless property = resource.property(:target)
-      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)
-      value,resource[:target] = :link,value unless value.is_a? Symbol
-      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)
-      return super unless property = @resource.property(:content)
-      # We know that content is out of sync if we're here, because
-      # it's essentially equivalent to 'ensure' in the transaction.
-      if source = @resource.parameter(: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 self.should == :present
-        return !(currentvalue.nil? or currentvalue == :absent)
-      else
-        return super(currentvalue)
-      end
-    end
-    def retrieve
-      if stat = @resource.stat
-        return stat.ftype.intern
-      else
-        if self.should == :false
-          return :false
-        else
-          return :absent
-        end
-      end
-    end
-    def sync
-      @resource.remove_existing(self.should)
-      if self.should == :absent
-        return :file_removed
-      end
-      event = super
-      event
-    end
-  end
-end