openvox 7.37.1

data/lib/puppet/forge/errors.rb

@@ -0,0 +1,114 @@
+require_relative '../../puppet/util/json'
+require_relative '../../puppet/error'
+require_relative '../../puppet/forge'
+
+# Puppet::Forge specific exceptions
+module Puppet::Forge::Errors
+
+  # This exception is the parent for all Forge API errors
+  class ForgeError < Puppet::Error
+    # This is normally set by the child class, but if it is not this will
+    # fall back to displaying the message as a multiline.
+    #
+    # @return [String] the multiline version of the error message
+    def multiline
+      self.message
+    end
+  end
+
+  # This exception is raised when there is an SSL verification error when
+  # communicating with the forge.
+  class SSLVerifyError < ForgeError
+    # @option options [String] :uri The URI that failed
+    # @option options [String] :original the original exception
+    def initialize(options)
+      @uri     = options[:uri]
+      original = options[:original]
+
+      super(_("Unable to verify the SSL certificate at %{uri}") % { uri: @uri }, original)
+    end
+
+    # Return a multiline version of the error message
+    #
+    # @return [String] the multiline version of the error message
+    def multiline
+      message = []
+      message << _('Could not connect via HTTPS to %{uri}') % { uri: @uri }
+      message << _('  Unable to verify the SSL certificate')
+      message << _('    The certificate may not be signed by a valid CA')
+      message << _('    The CA bundle included with OpenSSL may not be valid or up to date')
+      message.join("\n")
+    end
+  end
+
+  # This exception is raised when there is a communication error when connecting
+  # to the forge
+  class CommunicationError < ForgeError
+    # @option options [String] :uri The URI that failed
+    # @option options [String] :original the original exception
+    def initialize(options)
+      @uri     = options[:uri]
+      original = options[:original]
+      @detail  = original.message
+
+      message = _("Unable to connect to the server at %{uri}. Detail: %{detail}.") % { uri: @uri, detail: @detail }
+      super(message, original)
+    end
+
+    # Return a multiline version of the error message
+    #
+    # @return [String] the multiline version of the error message
+    def multiline
+      message = []
+      message << _('Could not connect to %{uri}') % { uri: @uri }
+      message << _('  There was a network communications problem')
+      message << _("    The error we caught said '%{detail}'") % { detail: @detail }
+      message << _('    Check your network connection and try again')
+      message.join("\n")
+    end
+  end
+
+  # This exception is raised when there is a bad HTTP response from the forge
+  # and optionally a message in the response.
+  class ResponseError < ForgeError
+    # @option options [String] :uri The URI that failed
+    # @option options [String] :input The user's input (e.g. module name)
+    # @option options [String] :message Error from the API response (optional)
+    # @option options [Puppet::HTTP::Response] :response The original HTTP response
+    def initialize(options)
+      @uri     = options[:uri]
+      @message = options[:message]
+      response = options[:response]
+      @response = "#{response.code} #{response.reason.strip}"
+
+      begin
+        body = Puppet::Util::Json.load(response.body)
+        if body['message']
+          @message ||= body['message'].strip
+        end
+      rescue Puppet::Util::Json::ParseError
+      end
+
+      message = if @message
+                  _("Request to Puppet Forge failed.") + ' ' + _("Detail: %{detail}.") % { detail: "#{@message} / #{@response}" }
+                else
+                  _("Request to Puppet Forge failed.") + ' ' + _("Detail: %{detail}.") % { detail: @response }
+                end
+      super(message, original)
+    end
+
+    # Return a multiline version of the error message
+    #
+    # @return [String] the multiline version of the error message
+    def multiline
+
+      message = []
+      message << _('Request to Puppet Forge failed.')
+      message << _('  The server being queried was %{uri}') % { uri: @uri }
+      message << _("  The HTTP response we received was '%{response}'") % { response: @response }
+      message << _("  The message we received said '%{message}'") % { message: @message } if @message
+      message.join("\n")
+    end
+  end
+
+end

data/lib/puppet/forge/repository.rb

@@ -0,0 +1,95 @@
+require_relative '../../puppet/ssl/openssl_loader'
+require 'digest/sha1'
+require 'uri'
+require_relative '../../puppet/forge'
+require_relative '../../puppet/forge/errors'
+require_relative '../../puppet/network/http'
+
+class Puppet::Forge
+  # = Repository
+  #
+  # This class is a file for accessing remote repositories with modules.
+  class Repository
+    include Puppet::Forge::Errors
+
+    attr_reader :uri, :cache
+
+    # Instantiate a new repository instance rooted at the +url+.
+    # The library will report +for_agent+ in the User-Agent to the repository.
+    def initialize(host, for_agent)
+      @host  = host
+      @agent = for_agent
+      @cache = Cache.new(self)
+      @uri   = URI.parse(host)
+
+      ssl_provider = Puppet::SSL::SSLProvider.new
+      @ssl_context = ssl_provider.create_system_context(cacerts: [])
+    end
+
+    # Return a Net::HTTPResponse read for this +path+.
+    def make_http_request(path, io = nil)
+      raise ArgumentError, "Path must start with forward slash" unless path.start_with?('/')
+      begin
+        str = @uri.to_s
+        str.chomp!('/')
+        str += Puppet::Util.uri_encode(path)
+        uri = URI(str)
+
+        headers = { "User-Agent" => user_agent }
+
+        if forge_authorization
+          uri.user = nil
+          uri.password = nil
+          headers["Authorization"] = forge_authorization
+        end
+
+        http = Puppet.runtime[:http]
+        response = http.get(uri, headers: headers, options: {ssl_context: @ssl_context})
+        io.write(response.body) if io.respond_to?(:write)
+        response
+      rescue Puppet::SSL::CertVerifyError => e
+        raise SSLVerifyError.new(:uri => @uri.to_s, :original => e.cause)
+      rescue => e
+        raise CommunicationError.new(:uri => @uri.to_s, :original => e)
+      end
+    end
+
+    def forge_authorization
+      if Puppet[:forge_authorization]
+        Puppet[:forge_authorization]
+      elsif Puppet.features.pe_license?
+        PELicense.load_license_key.authorization_token
+      end
+    end
+
+    # Return the local file name containing the data downloaded from the
+    # repository at +release+ (e.g. "myuser-mymodule").
+    def retrieve(release)
+      path = @host.chomp('/') + release
+      return cache.retrieve(path)
+    end
+
+    # Return the URI string for this repository.
+    def to_s
+      "#<#{self.class} #{@host}>"
+    end
+
+    # Return the cache key for this repository, this a hashed string based on
+    # the URI.
+    def cache_key
+      return @cache_key ||= [
+        @host.to_s.gsub(/[^[:alnum:]]+/, '_').sub(/_$/, ''),
+        Digest::SHA1.hexdigest(@host.to_s)
+      ].join('-').freeze
+    end
+
+    private
+
+    def user_agent
+      @user_agent ||= [
+        @agent,
+        Puppet[:http_user_agent]
+      ].join(' ').freeze
+    end
+  end
+end

data/lib/puppet/forge.rb

@@ -0,0 +1,259 @@
+require_relative '../puppet/vendor'
+Puppet::Vendor.load_vendored
+
+require 'net/http'
+require 'tempfile'
+require 'uri'
+require 'pathname'
+require_relative '../puppet/util/json'
+require 'semantic_puppet'
+
+class Puppet::Forge < SemanticPuppet::Dependency::Source
+  require_relative 'forge/cache'
+  require_relative 'forge/repository'
+  require_relative 'forge/errors'
+
+  include Puppet::Forge::Errors
+
+  USER_AGENT = "PMT/1.1.1 (v3; Net::HTTP)".freeze
+
+  # From https://forgeapi.puppet.com/#!/release/getReleases
+  MODULE_RELEASE_EXCLUSIONS=%w[readme changelog license uri module tags supported file_size downloads created_at updated_at deleted_at].join(',').freeze
+
+  attr_reader :host, :repository
+
+  def initialize(host = Puppet[:module_repository])
+    @host = host
+    @repository = Puppet::Forge::Repository.new(host, USER_AGENT)
+  end
+
+  # Return a list of module metadata hashes that match the search query.
+  # This return value is used by the module_tool face install search,
+  # and displayed to on the console.
+  #
+  # Example return value:
+  #
+  # [
+  #   {
+  #     "author"      => "puppetlabs",
+  #     "name"        => "bacula",
+  #     "tag_list"    => ["backup", "bacula"],
+  #     "releases"    => [{"version"=>"0.0.1"}, {"version"=>"0.0.2"}],
+  #     "full_name"   => "puppetlabs/bacula",
+  #     "version"     => "0.0.2",
+  #     "project_url" => "https://github.com/puppetlabs/puppetlabs-bacula",
+  #     "desc"        => "bacula"
+  #   }
+  # ]
+  #
+  # @param term [String] search term
+  # @return [Array] modules found
+  # @raise [Puppet::Forge::Errors::CommunicationError] if there is a network
+  #   related error
+  # @raise [Puppet::Forge::Errors::SSLVerifyError] if there is a problem
+  #   verifying the remote SSL certificate
+  # @raise [Puppet::Forge::Errors::ResponseError] if the repository returns a
+  #   bad HTTP response
+  def search(term)
+    matches = []
+    uri = "/v3/modules?query=#{term}"
+    if Puppet[:module_groups]
+      uri += "&module_groups=#{Puppet[:module_groups].tr('+', ' ')}"
+    end
+
+    while uri
+      # make_http_request URI encodes parameters
+      response = make_http_request(uri)
+
+      if response.code == 200
+        result = Puppet::Util::Json.load(response.body)
+        uri = decode_uri(result['pagination']['next'])
+        matches.concat result['results']
+      else
+        raise ResponseError.new(:uri => response.url, :response => response)
+      end
+    end
+
+    matches.each do |mod|
+      mod['author'] = mod['owner']['username']
+      mod['tag_list'] = mod['current_release']['tags']
+      mod['full_name'] = "#{mod['author']}/#{mod['name']}"
+      mod['version'] = mod['current_release']['version']
+      mod['project_url'] = mod['homepage_url']
+      mod['desc'] = mod['current_release']['metadata']['summary'] || ''
+    end
+  end
+
+  # Fetches {ModuleRelease} entries for each release of the named module.
+  #
+  # @param input [String] the module name to look up
+  # @return [Array<SemanticPuppet::Dependency::ModuleRelease>] a list of releases for
+  #         the given name
+  # @see SemanticPuppet::Dependency::Source#fetch
+  def fetch(input)
+    name = input.tr('/', '-')
+    uri = "/v3/releases?module=#{name}&sort_by=version&exclude_fields=#{MODULE_RELEASE_EXCLUSIONS}"
+    if Puppet[:module_groups]
+      uri += "&module_groups=#{Puppet[:module_groups].tr('+', ' ')}"
+    end
+    releases = []
+
+    while uri
+      # make_http_request URI encodes parameters
+      response = make_http_request(uri)
+
+      if response.code == 200
+        response = Puppet::Util::Json.load(response.body)
+      else
+        raise ResponseError.new(:uri => response.url, :response => response)
+      end
+
+      releases.concat(process(response['results']))
+      uri = decode_uri(response['pagination']['next'])
+    end
+
+    return releases
+  end
+
+  def make_http_request(*args)
+    @repository.make_http_request(*args)
+  end
+
+  class ModuleRelease < SemanticPuppet::Dependency::ModuleRelease
+    attr_reader :install_dir, :metadata
+
+    def initialize(source, data)
+      @data = data
+      @metadata = meta = data['metadata']
+
+      name = meta['name'].tr('/', '-')
+      version = SemanticPuppet::Version.parse(meta['version'])
+      release = "#{name}@#{version}"
+
+      if meta['dependencies']
+        dependencies = meta['dependencies'].collect do |dep|
+          begin
+            Puppet::ModuleTool::Metadata.new.add_dependency(dep['name'], dep['version_requirement'], dep['repository'])
+            Puppet::ModuleTool.parse_module_dependency(release, dep)[0..1]
+          rescue ArgumentError => e
+            raise ArgumentError, _("Malformed dependency: %{name}.") % { name: dep['name'] } +
+                ' ' + _("Exception was: %{detail}") % { detail: e }
+          end
+        end
+      else
+        dependencies = []
+      end
+
+      super(source, name, version, Hash[dependencies])
+    end
+
+    def install(dir)
+      staging_dir = self.prepare
+
+      module_dir = dir + name[/-(.*)/, 1]
+      module_dir.rmtree if module_dir.exist?
+
+      # Make sure unpacked module has the same ownership as the folder we are moving it into.
+      Puppet::ModuleTool::Applications::Unpacker.harmonize_ownership(dir, staging_dir)
+
+      FileUtils.mv(staging_dir, module_dir)
+      @install_dir = dir
+
+      # Return the Pathname object representing the directory where the
+      # module release archive was unpacked the to.
+      return module_dir
+    ensure
+      staging_dir.rmtree if staging_dir.exist?
+    end
+
+    def prepare
+      return @unpacked_into if @unpacked_into
+
+      Puppet.warning "#{@metadata['name']} has been deprecated by its author! View module on Puppet Forge for more info." if deprecated?
+
+      download(@data['file_uri'], tmpfile)
+      checksum = @data['file_sha256']
+      if checksum
+        validate_checksum(tmpfile, checksum, Digest::SHA256)
+      else
+        checksum = @data['file_md5']
+        if checksum
+          validate_checksum(tmpfile, checksum, Digest::MD5)
+        else
+          raise _("Forge module is missing SHA256 and MD5 checksums")
+        end
+      end
+
+      unpack(tmpfile, tmpdir)
+
+      @unpacked_into = Pathname.new(tmpdir)
+    end
+
+    private
+
+    # Obtain a suitable temporary path for unpacking tarballs
+    #
+    # @return [Pathname] path to temporary unpacking location
+    def tmpdir
+      @dir ||= Dir.mktmpdir(name, Puppet::Forge::Cache.base_path)
+    end
+
+    def tmpfile
+      @file ||= Tempfile.new(name, Puppet::Forge::Cache.base_path).tap do |f|
+        f.binmode
+      end
+    end
+
+    def download(uri, destination)
+      response = @source.make_http_request(uri, destination)
+      destination.flush and destination.close
+      unless response.code == 200
+        raise Puppet::Forge::Errors::ResponseError.new(:uri => response.url, :response => response)
+      end
+    end
+
+    def validate_checksum(file, checksum, digest_class)
+      if Puppet.runtime[:facter].value(:fips_enabled) && digest_class == Digest::MD5
+        raise _("Module install using MD5 is prohibited in FIPS mode.")
+      end
+
+      if digest_class.file(file.path).hexdigest != checksum
+        raise RuntimeError, _("Downloaded release for %{name} did not match expected checksum %{checksum}") % { name: name, checksum: checksum }
+      end
+    end
+
+    def unpack(file, destination)
+      begin
+        Puppet::ModuleTool::Applications::Unpacker.unpack(file.path, destination)
+      rescue Puppet::ExecutionFailure => e
+        raise RuntimeError, _("Could not extract contents of module archive: %{message}") % { message: e.message }
+      end
+    end
+
+    def deprecated?
+      @data['module'] && (@data['module']['deprecated_at'] != nil)
+    end
+  end
+
+  private
+
+  def process(list)
+    l = list.map do |release|
+      metadata = release['metadata']
+      begin
+        ModuleRelease.new(self, release)
+      rescue ArgumentError => e
+        Puppet.warning _("Cannot consider release %{name}-%{version}: %{error}") % { name: metadata['name'], version: metadata['version'], error: e }
+        false
+      end
+    end
+
+    l.select { |r| r }
+  end
+
+  def decode_uri(uri)
+    return if uri.nil?
+
+    Puppet::Util.uri_unescape(uri.tr('+', ' '))
+  end
+end

data/lib/puppet/functions/abs.rb

@@ -0,0 +1,61 @@
+# Returns the absolute value of a Numeric value, for example -34.56 becomes
+# 34.56. Takes a single `Integer` or `Float` value as an argument.
+#
+# *Deprecated behavior*
+#
+# For backwards compatibility reasons this function also works when given a
+# number in `String` format such that it first attempts to covert it to either a `Float` or
+# an `Integer` and then taking the absolute value of the result. Only strings representing
+# a number in decimal format is supported - an error is raised if
+# value is not decimal (using base 10). Leading 0 chars in the string
+# are ignored. A floating point value in string form can use some forms of
+# scientific notation but not all.
+#
+# Callers should convert strings to `Numeric` before calling
+# this function to have full control over the conversion.
+#
+# @example Converting to Numeric before calling
+# ```puppet
+# abs(Numeric($str_val))
+# ```
+# 
+# It is worth noting that `Numeric` can convert to absolute value
+# directly as in the following examples:
+#
+# @example Absolute value and String to Numeric
+# ```puppet
+# Numeric($strval, true)     # Converts to absolute Integer or Float
+# Integer($strval, 10, true) # Converts to absolute Integer using base 10 (decimal)
+# Integer($strval, 16, true) # Converts to absolute Integer using base 16 (hex)
+# Float($strval, true)       # Converts to absolute Float
+# ```
+#
+Puppet::Functions.create_function(:abs) do
+  dispatch :on_numeric do
+    param 'Numeric', :val
+  end
+
+  dispatch :on_string do
+    param 'String', :val
+  end
+
+  def on_numeric(x)
+    x.abs
+  end
+
+  def on_string(x)
+    Puppet.warn_once('deprecations', 'abs_function_numeric_coerce_string',
+      _("The abs() function's auto conversion of String to Numeric is deprecated - change to convert input before calling"))
+
+    # These patterns for conversion are backwards compatible with the stdlib
+    # version of this function.
+    #
+    if x =~ %r{^-?(?:\d+)(?:\.\d+){1}$}
+      x.to_f.abs
+    elsif x =~ %r{^-?\d+$}
+      x.to_i.abs
+    else
+      raise(ArgumentError, 'abs(): Requires float or integer to work with - was given non decimal string')
+    end
+  end
+end

data/lib/puppet/functions/alert.rb

@@ -0,0 +1,14 @@
+# Logs a message on the server at level `alert`.
+Puppet::Functions.create_function(:alert, Puppet::Functions::InternalFunction) do
+  # @param values The values to log.
+  # @return [Undef]
+  dispatch :alert do
+    scope_param
+    repeated_param 'Any', :values
+    return_type 'Undef'
+  end
+
+  def alert(scope, *values)
+    Puppet::Util::Log.log_func(scope, :alert, values)
+  end
+end

data/lib/puppet/functions/all.rb

@@ -0,0 +1,104 @@
+# Runs a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
+# repeatedly using each value in a data structure until the lambda returns a non "truthy" value which
+# makes the function return `false`, or if the end of the iteration is reached, `true` is returned.
+#
+# This function takes two mandatory arguments, in this order:
+#
+# 1. An array, hash, or other iterable object that the function will iterate over.
+# 2. A lambda, which the function calls for each element in the first argument. It can
+# request one or two parameters.
+#
+# @example Using the `all` function
+#
+# `$data.all |$parameter| { <PUPPET CODE BLOCK> }`
+#
+# or
+#
+# `all($data) |$parameter| { <PUPPET CODE BLOCK> }`
+#
+# @example Using the `all` function with an Array and a one-parameter lambda
+#
+# ```puppet
+# # For the array $data, run a lambda that checks that all values are multiples of 10
+# $data = [10, 20, 30]
+# notice $data.all |$item| { $item % 10 == 0 }
+# ```
+#
+# Would notice `true`.
+#
+# When the first argument is a `Hash`, Puppet passes each key and value pair to the lambda
+# as an array in the form `[key, value]`.
+#
+# @example Using the `all` function with a `Hash` and a one-parameter lambda
+#
+# ```puppet
+# # For the hash $data, run a lambda using each item as a key-value array
+# $data = { 'a_0'=> 10, 'b_1' => 20 }
+# notice $data.all |$item| { $item[1] % 10 == 0  }
+# ```
+#
+# Would notice `true` if all values in the hash are multiples of 10.
+#
+# When the lambda accepts two arguments, the first argument gets the index in an array
+# or the key from a hash, and the second argument the value.
+#
+#
+# @example Using the `all` function with a hash and a two-parameter lambda
+#
+# ```puppet
+# # Check that all values are a multiple of 10 and keys start with 'abc'
+# $data = {abc_123 => 10, abc_42 => 20, abc_blue => 30}
+# notice $data.all |$key, $value| { $value % 10 == 0  and $key =~ /^abc/ }
+# ```
+#
+# Would notice `true`.
+#
+# For an general examples that demonstrates iteration, see the Puppet
+# [iteration](https://puppet.com/docs/puppet/latest/lang_iteration.html)
+# documentation.
+#
+# @since 5.2.0
+#
+Puppet::Functions.create_function(:all) do
+  dispatch :all_Hash_2 do
+    param 'Hash[Any, Any]', :hash
+    block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :all_Hash_1 do
+    param 'Hash[Any, Any]', :hash
+    block_param 'Callable[1,1]', :block
+  end
+
+  dispatch :all_Enumerable_2 do
+    param 'Iterable', :enumerable
+    block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :all_Enumerable_1 do
+    param 'Iterable', :enumerable
+    block_param 'Callable[1,1]', :block
+  end
+
+  def all_Hash_1(hash)
+    hash.each_pair.all? { |x| yield(x) }
+  end
+
+  def all_Hash_2(hash)
+    hash.each_pair.all? { |x,y| yield(x,y) }
+  end
+
+  def all_Enumerable_1(enumerable)
+    Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable).all? { |e| yield(e) }
+  end
+
+  def all_Enumerable_2(enumerable)
+    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
+    if enum.hash_style?
+      enum.all? { |entry| yield(*entry) }
+    else
+      enum.each_with_index { |e, i| return false unless yield(i, e) }
+      true
+    end
+  end
+end