bolt 0.0.1 → 0.5.0

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

@@ -0,0 +1,98 @@
+# 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 aleady 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 enocding 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
+
+    REPLACEMENT_CHAR_MAP = {
+      Encoding::UTF_8 => "\uFFFD",
+      Encoding::UTF_16LE => "\xFD\xFF".force_encoding(Encoding::UTF_16LE),
+    }
+
+    # Given a string, return a copy of that string with any invalid byte
+    # sequences in its current encoding replaced with the replacement character
+    # "\uFFFD" (UTF-8) if the string is UTF-8 or UTF-16LE, or "?" otherwise.
+    # @param string a string to remove invalid byte sequences from
+    # @return a copy of string invalid byte sequences replaced by the unicode
+    #   replacement character or "?" character
+    # @note does not modify encoding, but new string will have different bytes
+    #   from original. Only needed for ruby 1.9.3 support.
+    def scrub(string)
+      if string.respond_to?(:scrub)
+        string.scrub
+      else
+        replacement_character = REPLACEMENT_CHAR_MAP[string.encoding] || '?'
+        string.chars.map { |c| c.valid_encoding? ? c : replacement_character }.join
+      end
+    end
+  end
+end

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

@@ -0,0 +1,282 @@
+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,
+      :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::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
+
+  private_class_method
+
+  # 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

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

@@ -0,0 +1,228 @@
+require 'puppet/util/methodhelper'
+
+module Puppet
+  class ConstantAlreadyDefined < Error; end
+  class SubclassAlreadyDefined < Error; end
+end
+
+# This is a utility module for generating classes.
+# @api public
+#
+module Puppet::Util::ClassGen
+  include Puppet::Util::MethodHelper
+  include Puppet::Util
+
+  # Create a new class.
+  # @param name [String] the name of the generated class
+  # @param options [Hash] a hash of options
+  # @option options [Array<Class>] :array if specified, the generated class is appended to this array
+  # @option options [Hash<{String => Object}>] :attributes a hash that is applied to the generated class
+  #   by calling setter methods corresponding to this hash's keys/value pairs. This is done before the given
+  #   block is evaluated.
+  # @option options [Proc] :block a block to evaluate in the context of the class (this block can be provided
+  #   this way, or as a normal yield block).
+  # @option options [String] :constant (name with first letter capitalized) what to set the constant that references
+  #   the generated class to.
+  # @option options [Hash] :hash a hash of existing classes that this class is appended to (name => class).
+  #   This hash must be specified if the `:overwrite` option is set to `true`.
+  # @option options [Boolean] :overwrite whether an overwrite of an existing class should be allowed (requires also
+  #   defining the `:hash` with existing classes as the test is based on the content of this hash).
+  # @option options [Class] :parent (self) the parent class of the generated class.
+  # @option options [String] ('') :prefix the constant prefix to prepend to the constant name referencing the
+  #   generated class.
+  # @return [Class] the generated class
+  #
+  def genclass(name, options = {}, &block)
+    genthing(name, Class, options, block)
+  end
+
+  # Creates a new module.
+  # @param name [String] the name of the generated module
+  # @param options [Hash] hash with options
+  # @option options [Array<Class>] :array if specified, the generated class is appended to this array
+  # @option options [Hash<{String => Object}>] :attributes a hash that is applied to the generated class
+  #   by calling setter methods corresponding to this hash's keys/value pairs. This is done before the given
+  #   block is evaluated.
+  # @option options [Proc] :block a block to evaluate in the context of the class (this block can be provided
+  #   this way, or as a normal yield block).
+  # @option options [String] :constant (name with first letter capitalized) what to set the constant that references
+  #   the generated class to.
+  # @option options [Hash] :hash a hash of existing classes that this class is appended to (name => class).
+  #   This hash must be specified if the `:overwrite` option is set to `true`.
+  # @option options [Boolean] :overwrite whether an overwrite of an existing class should be allowed (requires also
+  #   defining the `:hash` with existing classes as the test is based on the content of this hash).
+  #   the capitalized name is appended and the result is set as the constant.
+  # @option options [String] ('') :prefix the constant prefix to prepend to the constant name referencing the
+  #   generated class.
+  # @return [Module] the generated Module
+  def genmodule(name, options = {}, &block)
+    genthing(name, Module, options, block)
+  end
+
+  # Removes an existing class.
+  # @param name [String] the name of the class to remove
+  # @param options [Hash] options
+  # @option options [Hash] :hash a hash of existing classes from which the class to be removed is also removed
+  # @return [Boolean] whether the class was removed or not
+  #
+  def rmclass(name, options)
+    options = symbolize_options(options)
+    const = genconst_string(name, options)
+    retval = false
+    if is_constant_defined?(const)
+      remove_const(const)
+      retval = true
+    end
+
+    if hash = options[:hash] and hash.include? name
+      hash.delete(name)
+      retval = true
+    end
+
+    # Let them know whether we did actually delete a subclass.
+    retval
+  end
+
+  private
+
+  # Generates the constant to create or remove.
+  # @api private
+  def genconst_string(name, options)
+    unless const = options[:constant]
+      prefix = options[:prefix] || ""
+      const = prefix + name2const(name)
+    end
+
+    const
+  end
+
+  # This does the actual work of creating our class or module.  It's just a
+  # slightly abstract version of genclass.
+  # @api private
+  def genthing(name, type, options, block)
+    options = symbolize_options(options)
+
+    name = name.to_s.downcase.intern
+
+    if type == Module
+      #evalmethod = :module_eval
+      evalmethod = :class_eval
+      # Create the class, with the correct name.
+      klass = Module.new do
+        class << self
+          attr_reader :name
+        end
+        @name = name
+      end
+    else
+      options[:parent] ||= self
+      evalmethod = :class_eval
+      # Create the class, with the correct name.
+      klass = Class.new(options[:parent]) do
+        @name = name
+      end
+    end
+
+    # Create the constant as appropriation.
+    handleclassconst(klass, name, options)
+
+    # Initialize any necessary variables.
+    initclass(klass, options)
+
+    block ||= options[:block]
+
+    # Evaluate the passed block if there is one.  This should usually
+    # define all of the work.
+    klass.send(evalmethod, &block) if block
+
+    klass.postinit if klass.respond_to? :postinit
+
+    # Store the class in hashes or arrays or whatever.
+    storeclass(klass, name, options)
+
+    klass
+  end
+
+  # @api private
+  #
+  def is_constant_defined?(const)
+    const_defined?(const, false)
+  end
+
+  # Handle the setting and/or removing of the associated constant.
+  # @api private
+  #
+  def handleclassconst(klass, name, options)
+   const = genconst_string(name, options)
+
+    if is_constant_defined?(const)
+      if options[:overwrite]
+        Puppet.info _("Redefining %{name} in %{klass}") % { name: name, klass: self }
+        remove_const(const)
+      else
+        raise Puppet::ConstantAlreadyDefined,
+          _("Class %{const} is already defined in %{klass}") % { const: const, klass: self }
+      end
+    end
+    const_set(const, klass)
+
+    const
+  end
+
+  # Perform the initializations on the class.
+  # @api private
+  #
+  def initclass(klass, options)
+    klass.initvars if klass.respond_to? :initvars
+
+    if attrs = options[:attributes]
+      attrs.each do |param, value|
+        method = param.to_s + "="
+        klass.send(method, value) if klass.respond_to? method
+      end
+    end
+
+    [:include, :extend].each do |method|
+      if set = options[method]
+        set = [set] unless set.is_a?(Array)
+        set.each do |mod|
+          klass.send(method, mod)
+        end
+      end
+    end
+
+    klass.preinit if klass.respond_to? :preinit
+  end
+
+  # Convert our name to a constant.
+  # @api private
+  def name2const(name)
+    name.to_s.capitalize
+  end
+
+  # Store the class in the appropriate places.
+  # @api private
+  def storeclass(klass, klassname, options)
+    if hash = options[:hash]
+      if hash.include? klassname and ! options[:overwrite]
+        raise Puppet::SubclassAlreadyDefined,
+          _("Already a generated class named %{klassname}") % { klassname: klassname }
+      end
+
+      hash[klassname] = klass
+    end
+
+    # If we were told to stick it in a hash, then do so
+    if array = options[:array]
+      if (klass.respond_to? :name and
+              array.find { |c| c.name == klassname } and
+              ! options[:overwrite])
+        raise Puppet::SubclassAlreadyDefined,
+          _("Already a generated class named %{klassname}") % { klassname: klassname }
+      end
+
+      array << klass
+    end
+  end
+end
+