bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/util/backups.rb

@@ -1,86 +0,0 @@
-require 'find'
-require 'fileutils'
-module Puppet::Util::Backups
-
-  # Deal with backups.
-  def perform_backup(file = nil)
-    # if they specifically don't want a backup, then just say
-    # we're good
-    return true unless self[:backup]
-
-    # let the path be specified
-    file ||= self[:path]
-    return true unless Puppet::FileSystem.exist?(file)
-
-    return(self.bucket ? perform_backup_with_bucket(file) : perform_backup_with_backuplocal(file, self[:backup]))
-  end
-
-  private
-
-  def perform_backup_with_bucket(fileobj)
-    file = (fileobj.class == String) ? fileobj : fileobj.name
-    case Puppet::FileSystem.lstat(file).ftype
-    when "directory"
-      # we don't need to backup directories when recurse is on
-      return true if self[:recurse]
-      info _("Recursively backing up to filebucket")
-      Find.find(self[:path]) { |f| backup_file_with_filebucket(f) if File.file?(f) }
-    when "file"; backup_file_with_filebucket(file)
-    when "link";
-    end
-    true
-  end
-
-  def perform_backup_with_backuplocal(fileobj, backup)
-    file = (fileobj.class == String) ? fileobj : fileobj.name
-    newfile = file + backup
-
-    remove_backup(newfile)
-
-    begin
-      bfile = file + backup
-
-      # N.B. cp_r works on both files and directories
-      FileUtils.cp_r(file, bfile, :preserve => true)
-      return true
-    rescue => detail
-      # since they said they want a backup, let's error out
-      # if we couldn't make one
-      self.fail Puppet::Error, _("Could not back %{file} up: %{message}") % { file: file, message: detail.message }, detail
-    end
-  end
-
-  def remove_backup(newfile)
-    if self.class.name == :file and self[:links] != :follow
-      method = :lstat
-    else
-      method = :stat
-    end
-
-    begin
-      stat = Puppet::FileSystem.send(method, newfile)
-    rescue Errno::ENOENT
-      return
-    end
-
-    if stat.ftype == "directory"
-      raise Puppet::Error, _("Will not remove directory backup %{newfile}; use a filebucket") % { newfile: newfile }
-    end
-
-    info _("Removing old backup of type %{file_type}") % { file_type: stat.ftype }
-
-    begin
-      Puppet::FileSystem.unlink(newfile)
-    rescue => detail
-      message = _("Could not remove old backup: %{detail}") % { detail: detail }
-      self.log_exception(detail, message)
-      self.fail Puppet::Error, message, detail
-    end
-  end
-
-  def backup_file_with_filebucket(f)
-    sum = self.bucket.backup(f)
-    self.info _("Filebucketed %{f} to %{filebucket} with sum %{sum}") % { f: f, filebucket: self.bucket.name, sum: sum }
-    return sum
-  end
-end

data/vendored/puppet/lib/puppet/util/character_encoding.rb

@@ -1,76 +0,0 @@
-# A module to centralize heuristics/practices for managing character encoding in Puppet
-
-module Puppet::Util::CharacterEncoding
-  class << self
-    # Given a string, attempts to convert a copy of the string to UTF-8. Conversion uses
-    # encode - the string's internal byte representation is modifed to UTF-8.
-    #
-    # This method is intended for situations where we generally trust that the
-    # string's bytes are a faithful representation of the current encoding
-    # associated with it, and can use it as a starting point for transcoding
-    # (conversion) to UTF-8.
-    #
-    # @api public
-    # @param [String] string a string to transcode
-    # @return [String] copy of the original string, in UTF-8 if transcodable
-    def convert_to_utf_8(string)
-      original_encoding = string.encoding
-      string_copy = string.dup
-      begin
-        if original_encoding == Encoding::UTF_8
-          if !string_copy.valid_encoding?
-            Puppet.debug(_("%{value} is already labeled as UTF-8 but this encoding is invalid. It cannot be transcoded by Puppet.") %
-              { value: string.dump })
-          end
-          # String is already valid UTF-8 - noop
-          return string_copy
-        else
-          # If the string comes to us as BINARY encoded, we don't know what it
-          # started as. However, to encode! we need a starting place, and our
-          # best guess is whatever the system currently is (default_external).
-          # So set external_encoding to default_external before we try to
-          # transcode to UTF-8.
-          string_copy.force_encoding(Encoding.default_external) if original_encoding == Encoding::BINARY
-          return string_copy.encode(Encoding::UTF_8)
-        end
-      rescue EncodingError => detail
-        # Set the encoding on our copy back to its original if we modified it
-        string_copy.force_encoding(original_encoding) if original_encoding == Encoding::BINARY
-
-        # Catch both our own self-determined failure to transcode as well as any
-        # error on ruby's part, ie Encoding::UndefinedConversionError on a
-        # failure to encode!.
-        Puppet.debug(_("%{error}: %{value} cannot be transcoded by Puppet.") %
-          { error: detail.inspect, value: string.dump })
-        return string_copy
-      end
-    end
-
-    # Given a string, tests if that string's bytes represent valid UTF-8, and if
-    # so return a copy of the string with external encoding set to UTF-8. Does
-    # not modify the byte representation of the string. If the string does not
-    # represent valid UTF-8, does not set the external encoding.
-    #
-    # This method is intended for situations where we do not believe that the
-    # encoding associated with a string is an accurate reflection of its actual
-    # bytes, i.e., effectively when we believe Ruby is incorrect in its
-    # assertion of the encoding of the string.
-    #
-    # @api public
-    # @param [String] string to set external encoding (re-label) to utf-8
-    # @return [String] a copy of string with external encoding set to utf-8, or
-    # a copy of the original string if override would result in invalid encoding.
-    def override_encoding_to_utf_8(string)
-      string_copy = string.dup
-      original_encoding = string_copy.encoding
-      return string_copy if original_encoding == Encoding::UTF_8
-      if string_copy.force_encoding(Encoding::UTF_8).valid_encoding?
-        return string_copy
-      else
-        Puppet.debug(_("%{value} is not valid UTF-8 and result of overriding encoding would be invalid.") % { value: string.dump })
-        # Set copy back to its original encoding before returning
-        return string_copy.force_encoding(original_encoding)
-      end
-    end
-  end
-end

data/vendored/puppet/lib/puppet/util/checksums.rb

@@ -1,361 +0,0 @@
-require 'digest/md5'
-require 'digest/sha1'
-require 'time'
-
-# A stand-alone module for calculating checksums
-# in a generic way.
-module Puppet::Util::Checksums
-  module_function
-
-  # It's not a good idea to use some of these in some contexts: for example, I
-  # wouldn't try bucketing a file using the :none checksum type.
-  def known_checksum_types
-    [:sha256, :sha256lite, :md5, :md5lite, :sha1, :sha1lite, :sha512, :sha384, :sha224, 
-      :mtime, :ctime, :none]
-  end
-
-  class FakeChecksum
-    def <<(*args)
-      self
-    end
-  end
-
-  # Is the provided string a checksum?
-  def checksum?(string)
-    # 'sha256lite'.length == 10
-    string =~ /^\{(\w{3,10})\}\S+/
-  end
-
-  # Strip the checksum type from an existing checksum
-  def sumdata(checksum)
-    checksum =~ /^\{(\w+)\}(.+)/ ? $2 : nil
-  end
-
-  # Strip the checksum type from an existing checksum
-  def sumtype(checksum)
-    checksum =~ /^\{(\w+)\}/ ? $1 : nil
-  end
-
-  # Calculate a checksum using Digest::SHA256.
-  def sha256(content)
-    require 'digest/sha2'
-    Digest::SHA256.hexdigest(content)
-  end
-
-  def sha256?(string)
-    string =~ /^\h{64}$/
-  end
-
-  def sha256_file(filename, lite = false)
-    require 'digest/sha2'
-
-    digest = Digest::SHA256.new
-    checksum_file(digest, filename,  lite)
-  end
-
-  def sha256_stream(lite = false, &block)
-    require 'digest/sha2'
-    digest = Digest::SHA256.new
-    checksum_stream(digest, block, lite)
-  end
-
-  def sha256_hex_length
-    64
-  end
-
-  def sha256lite(content)
-    sha256(content[0..511])
-  end
-
-  def sha256lite?(string)
-    sha256?(string)
-  end
-
-  def sha256lite_file(filename)
-    sha256_file(filename, true)
-  end
-
-  def sha256lite_stream(&block)
-    sha256_stream(true, &block)
-  end
-
-  def sha256lite_hex_length
-    sha256_hex_length
-  end
-
-  # Calculate a checksum using Digest::SHA384.
-  def sha384(content)
-    require 'digest/sha2'
-    Digest::SHA384.hexdigest(content)
-  end
-
-  def sha384?(string)
-    string =~ /^\h{96}$/
-  end
-
-  def sha384_file(filename, lite = false)
-    require 'digest/sha2'
-
-    digest = Digest::SHA384.new
-    checksum_file(digest, filename,  lite)
-  end
-
-  def sha384_stream(lite = false, &block)
-    require 'digest/sha2'
-    digest = Digest::SHA384.new
-    checksum_stream(digest, block, lite)
-  end
-
-  def sha384_hex_length
-    96
-  end
-
-  # Calculate a checksum using Digest::SHA512.
-  def sha512(content)
-    require 'digest/sha2'
-    Digest::SHA512.hexdigest(content)
-  end
-
-  def sha512?(string)
-    string =~ /^\h{128}$/
-  end
-
-  def sha512_file(filename, lite = false)
-    require 'digest/sha2'
-
-    digest = Digest::SHA512.new
-    checksum_file(digest, filename,  lite)
-  end
-
-  def sha512_stream(lite = false, &block)
-    require 'digest/sha2'
-    digest = Digest::SHA512.new
-    checksum_stream(digest, block, lite)
-  end
-
-  def sha512_hex_length
-    128
-  end
-
-  # Calculate a checksum using Digest::SHA224.
-  def sha224(content)
-    require 'openssl'
-    OpenSSL::Digest::SHA224.new.hexdigest(content)
-  end
-
-  def sha224?(string)
-    string =~ /^\h{56}$/
-  end
-
-  def sha224_file(filename, lite = false)
-    require 'openssl'
-
-    digest = OpenSSL::Digest::SHA224.new
-    checksum_file(digest, filename,  lite)
-  end
-
-  def sha224_stream(lite = false, &block)
-    require 'openssl'
-    digest = OpenSSL::Digest::SHA224.new
-    checksum_stream(digest, block, lite)
-  end
-
-  def sha224_hex_length
-    56
-  end
-
-  # Calculate a checksum using Digest::MD5.
-  def md5(content)
-    Digest::MD5.hexdigest(content)
-  end
-
-  def md5?(string)
-    string =~ /^\h{32}$/
-  end
-
-  # Calculate a checksum of a file's content using Digest::MD5.
-  def md5_file(filename, lite = false)
-    digest = Digest::MD5.new
-    checksum_file(digest, filename,  lite)
-  end
-
-  def md5_stream(lite = false, &block)
-    digest = Digest::MD5.new
-    checksum_stream(digest, block, lite)
-  end
-
-  def md5_hex_length
-    32
-  end
-
-  # Calculate a checksum of the first 500 chars of the content using Digest::MD5.
-  def md5lite(content)
-    md5(content[0..511])
-  end
-
-  def md5lite?(string)
-    md5?(string)
-  end
-
-  # Calculate a checksum of the first 500 chars of a file's content using Digest::MD5.
-  def md5lite_file(filename)
-    md5_file(filename, true)
-  end
-
-  def md5lite_stream(&block)
-    md5_stream(true, &block)
-  end
-
-  def md5lite_hex_length
-    md5_hex_length
-  end
-
-  def mtime(content)
-    ""
-  end
-
-  def mtime?(string)
-    return true if string.is_a? Time
-    !!DateTime.parse(string)
-  rescue
-    false
-  end
-
-  # Return the :mtime timestamp of a file.
-  def mtime_file(filename)
-    Puppet::FileSystem.stat(filename).send(:mtime)
-  end
-
-  # by definition this doesn't exist
-  # but we still need to execute the block given
-  def mtime_stream(&block)
-    noop_digest = FakeChecksum.new
-    yield noop_digest
-    nil
-  end
-
-  # Calculate a checksum using Digest::SHA1.
-  def sha1(content)
-    Digest::SHA1.hexdigest(content)
-  end
-
-  def sha1?(string)
-    string =~ /^\h{40}$/
-  end
-
-  # Calculate a checksum of a file's content using Digest::SHA1.
-  def sha1_file(filename, lite = false)
-    digest = Digest::SHA1.new
-    checksum_file(digest, filename, lite)
-  end
-
-  def sha1_stream(lite = false, &block)
-    digest = Digest::SHA1.new
-    checksum_stream(digest, block, lite)
-  end
-
-  def sha1_hex_length
-    40
-  end
-
-  # Calculate a checksum of the first 500 chars of the content using Digest::SHA1.
-  def sha1lite(content)
-    sha1(content[0..511])
-  end
-
-  def sha1lite?(string)
-    sha1?(string)
-  end
-
-  # Calculate a checksum of the first 500 chars of a file's content using Digest::SHA1.
-  def sha1lite_file(filename)
-    sha1_file(filename, true)
-  end
-
-  def sha1lite_stream(&block)
-    sha1_stream(true, &block)
-  end
-
-  def sha1lite_hex_length
-    sha1_hex_length
-  end
-
-  def ctime(content)
-    ""
-  end
-
-  def ctime?(string)
-    return true if string.is_a? Time
-    !!DateTime.parse(string)
-  rescue
-    false
-  end
-
-  # Return the :ctime of a file.
-  def ctime_file(filename)
-    Puppet::FileSystem.stat(filename).send(:ctime)
-  end
-
-  def ctime_stream(&block)
-    mtime_stream(&block)
-  end
-
-  def none(content)
-    ""
-  end
-
-  def none?(string)
-    string.empty?
-  end
-
-  # Return a "no checksum"
-  def none_file(filename)
-    ""
-  end
-
-  def none_stream
-    noop_digest = FakeChecksum.new
-    yield noop_digest
-    ""
-  end
-
-  class DigestLite
-    def initialize(digest, lite = false)
-      @digest = digest
-      @lite = lite
-      @bytes = 0
-    end
-
-    # Provide an interface for digests. If lite, only digest the first 512 bytes
-    def <<(str)
-      if @lite
-        if @bytes < 512
-          buf = str[0, 512 - @bytes]
-          @digest << buf
-          @bytes += buf.length
-        end
-      else
-        @digest << str
-      end
-    end
-  end
-
-  # Perform an incremental checksum on a file.
-  def checksum_file(digest, filename, lite = false)
-    buffer = lite ? 512 : 4096
-    File.open(filename, 'rb') do |file|
-      while content = file.read(buffer)
-        digest << content
-        break if lite
-      end
-    end
-
-    digest.hexdigest
-  end
-
-  def checksum_stream(digest, block, lite = false)
-    block.call(DigestLite.new(digest, lite))
-    digest.hexdigest
-  end
-
-end