openvox 7.37.1

data/lib/puppet/util/checksums.rb

@@ -0,0 +1,376 @@
+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
+
+  KNOWN_CHECKSUMS = [
+    :sha256, :sha256lite,
+    :md5, :md5lite,
+    :sha1, :sha1lite,
+    :sha512,
+    :sha384,
+    :sha224,
+    :mtime, :ctime, :none
+  ].freeze
+
+  # 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
+    KNOWN_CHECKSUMS
+  end
+
+  def valid_checksum?(type, value)
+    !!send("#{type}?", value)
+  rescue NoMethodError
+    false
+  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_relative '../../puppet/ssl/openssl_loader'
+    OpenSSL::Digest::SHA224.new.hexdigest(content)
+  end
+
+  def sha224?(string)
+    string =~ /^\h{56}$/
+  end
+
+  def sha224_file(filename, lite = false)
+    require_relative '../../puppet/ssl/openssl_loader'
+
+    digest = OpenSSL::Digest::SHA224.new
+    checksum_file(digest, filename,  lite)
+  end
+
+  def sha224_stream(lite = false, &block)
+    require_relative '../../puppet/ssl/openssl_loader'
+    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).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).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) #rubocop:disable Lint/AssignmentInCondition
+        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/lib/puppet/util/classgen.rb

@@ -0,0 +1,228 @@
+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
+
+  # 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)
+    const = genconst_string(name, options)
+    retval = false
+    if is_constant_defined?(const)
+      remove_const(const)
+      retval = true
+    end
+
+    hash = options[:hash]
+    if hash && 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)
+    const = options[:constant]
+    unless const
+      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)
+    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
+
+    attrs = options[:attributes]
+    if attrs
+      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|
+      set = options[method]
+      if set
+        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)
+    hash = options[:hash]
+    if 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
+    array = options[:array]
+    if 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
+

data/lib/puppet/util/colors.rb

@@ -0,0 +1,100 @@
+require_relative '../../puppet/util/platform'
+
+module Puppet::Util::Colors
+  BLACK       = {:console => "\e[0;30m", :html => "color: #FFA0A0"     }
+  RED         = {:console => "\e[0;31m", :html => "color: #FFA0A0"     }
+  GREEN       = {:console => "\e[0;32m", :html => "color: #00CD00"     }
+  YELLOW      = {:console => "\e[0;33m", :html => "color: #FFFF60"     }
+  BLUE        = {:console => "\e[0;34m", :html => "color: #80A0FF"     }
+  MAGENTA     = {:console => "\e[0;35m", :html => "color: #FFA500"     }
+  CYAN        = {:console => "\e[0;36m", :html => "color: #40FFFF"     }
+  WHITE       = {:console => "\e[0;37m", :html => "color: #FFFFFF"     }
+  HBLACK      = {:console => "\e[1;30m", :html => "color: #FFA0A0"     }
+  HRED        = {:console => "\e[1;31m", :html => "color: #FFA0A0"     }
+  HGREEN      = {:console => "\e[1;32m", :html => "color: #00CD00"     }
+  HYELLOW     = {:console => "\e[1;33m", :html => "color: #FFFF60"     }
+  HBLUE       = {:console => "\e[1;34m", :html => "color: #80A0FF"     }
+  HMAGENTA    = {:console => "\e[1;35m", :html => "color: #FFA500"     }
+  HCYAN       = {:console => "\e[1;36m", :html => "color: #40FFFF"     }
+  HWHITE      = {:console => "\e[1;37m", :html => "color: #FFFFFF"     }
+  BG_RED      = {:console => "\e[0;41m", :html => "background: #FFA0A0"}
+  BG_GREEN    = {:console => "\e[0;42m", :html => "background: #00CD00"}
+  BG_YELLOW   = {:console => "\e[0;43m", :html => "background: #FFFF60"}
+  BG_BLUE     = {:console => "\e[0;44m", :html => "background: #80A0FF"}
+  BG_MAGENTA  = {:console => "\e[0;45m", :html => "background: #FFA500"}
+  BG_CYAN     = {:console => "\e[0;46m", :html => "background: #40FFFF"}
+  BG_WHITE    = {:console => "\e[0;47m", :html => "background: #FFFFFF"}
+  BG_HRED     = {:console => "\e[1;41m", :html => "background: #FFA0A0"}
+  BG_HGREEN   = {:console => "\e[1;42m", :html => "background: #00CD00"}
+  BG_HYELLOW  = {:console => "\e[1;43m", :html => "background: #FFFF60"}
+  BG_HBLUE    = {:console => "\e[1;44m", :html => "background: #80A0FF"}
+  BG_HMAGENTA = {:console => "\e[1;45m", :html => "background: #FFA500"}
+  BG_HCYAN    = {:console => "\e[1;46m", :html => "background: #40FFFF"}
+  BG_HWHITE   = {:console => "\e[1;47m", :html => "background: #FFFFFF"}
+  RESET       = {:console => "\e[0m",    :html => ""                   }
+
+  Colormap = {
+    :debug => WHITE,
+    :info => GREEN,
+    :notice => CYAN,
+    :warning => YELLOW,
+    :err => HMAGENTA,
+    :alert => RED,
+    :emerg => HRED,
+    :crit => HRED,
+
+    :black       => BLACK,
+    :red         => RED,
+    :green       => GREEN,
+    :yellow      => YELLOW,
+    :blue        => BLUE,
+    :magenta     => MAGENTA,
+    :cyan        => CYAN,
+    :white       => WHITE,
+    :hblack      => HBLACK,
+    :hred        => HRED,
+    :hgreen      => HGREEN,
+    :hyellow     => HYELLOW,
+    :hblue       => HBLUE,
+    :hmagenta    => HMAGENTA,
+    :hcyan       => HCYAN,
+    :hwhite      => HWHITE,
+    :bg_red      => BG_RED,
+    :bg_green    => BG_GREEN,
+    :bg_yellow   => BG_YELLOW,
+    :bg_blue     => BG_BLUE,
+    :bg_magenta  => BG_MAGENTA,
+    :bg_cyan     => BG_CYAN,
+    :bg_white    => BG_WHITE,
+    :bg_hred     => BG_HRED,
+    :bg_hgreen   => BG_HGREEN,
+    :bg_hyellow  => BG_HYELLOW,
+    :bg_hblue    => BG_HBLUE,
+    :bg_hmagenta => BG_HMAGENTA,
+    :bg_hcyan    => BG_HCYAN,
+    :bg_hwhite   => BG_HWHITE,
+    :reset       => { :console => "\e[m", :html => "" }
+  }
+
+  def colorize(color, str)
+    case Puppet[:color]
+    when true, :ansi, "ansi", "yes"
+        console_color(color, str)
+    when :html, "html"
+      html_color(color, str)
+    else
+      str
+    end
+  end
+
+  def console_color(color, str)
+    Colormap[color][:console] +
+    str.gsub(RESET[:console], Colormap[color][:console]) +
+    RESET[:console]
+  end
+
+  def html_color(color, str)
+    span = '<span style="%s">' % Colormap[color][:html]
+    "#{span}%s</span>" % str.gsub(/<span .*?<\/span>/, "</span>\\0#{span}")
+  end
+end