openvox 8.19.0

data/lib/puppet/forge.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+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)"
+
+  # 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
+
+    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|
+          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
+      else
+        dependencies = []
+      end
+
+      super(source, name, version, dependencies.to_h)
+    end
+
+    def install(dir)
+      staging_dir = 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.
+      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
+    # rubocop:disable Naming/MemoizedInstanceVariableName
+    def tmpdir
+      @dir ||= Dir.mktmpdir(name, Puppet::Forge::Cache.base_path)
+    end
+
+    def tmpfile
+      @file ||= Tempfile.new(name, Puppet::Forge::Cache.base_path).tap(&:binmode)
+    end
+    # rubocop:enable Naming/MemoizedInstanceVariableName
+
+    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)
+      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
+
+    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,64 @@
+# frozen_string_literal: true
+
+# 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.
+    #
+    case x
+    when /^-?(?:\d+)(?:\.\d+){1}$/
+      x.to_f.abs
+    when /^-?\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,16 @@
+# frozen_string_literal: true
+
+# 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,106 @@
+# frozen_string_literal: true
+
+# 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

data/lib/puppet/functions/annotate.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+# Handles annotations on objects. The function can be used in four different ways.
+#
+# With two arguments, an `Annotation` type and an object, the function returns the annotation
+# for the object of the given type, or `undef` if no such annotation exists.
+#
+# @example Using `annotate` with two arguments
+#
+# ```puppet
+# $annotation = Mod::NickNameAdapter.annotate(o)
+#
+# $annotation = annotate(Mod::NickNameAdapter.annotate, o)
+# ```
+#
+# With three arguments, an `Annotation` type, an object, and a block, the function returns the
+# annotation for the object of the given type, or annotates it with a new annotation initialized
+# from the hash returned by the given block when no such annotation exists. The block will not
+# be called when an annotation of the given type is already present.
+#
+# @example Using `annotate` with two arguments and a block
+#
+# ```puppet
+# $annotation = Mod::NickNameAdapter.annotate(o) || { { 'nick_name' => 'Buddy' } }
+#
+# $annotation = annotate(Mod::NickNameAdapter.annotate, o) || { { 'nick_name' => 'Buddy' } }
+# ```
+#
+# With three arguments, an `Annotation` type, an object, and an `Hash`, the function will annotate
+# the given object with a new annotation of the given type that is initialized from the given hash.
+# An existing annotation of the given type is discarded.
+#
+# @example Using `annotate` with three arguments where third argument is a Hash
+#
+# ```puppet
+# $annotation = Mod::NickNameAdapter.annotate(o, { 'nick_name' => 'Buddy' })
+#
+# $annotation = annotate(Mod::NickNameAdapter.annotate, o, { 'nick_name' => 'Buddy' })
+# ```
+#
+# With three arguments, an `Annotation` type, an object, and an the string `clear`, the function will
+# clear the annotation of the given type in the given object. The old annotation is returned if
+# it existed.
+#
+# @example Using `annotate` with three arguments where third argument is the string 'clear'
+#
+# ```puppet
+# $annotation = Mod::NickNameAdapter.annotate(o, clear)
+#
+# $annotation = annotate(Mod::NickNameAdapter.annotate, o, clear)
+# ```
+#
+# With three arguments, the type `Pcore`, an object, and a Hash of hashes keyed by `Annotation` types,
+# the function will annotate the given object with all types used as keys in the given hash. Each annotation
+# is initialized with the nested hash for the respective type. The annotated object is returned.
+#
+# @example Add multiple annotations to a new instance of `Mod::Person` using the `Pcore` type.
+#
+# ```puppet
+#   $person = Pcore.annotate(Mod::Person({'name' => 'William'}), {
+#     Mod::NickNameAdapter >= { 'nick_name' => 'Bill' },
+#     Mod::HobbiesAdapter => { 'hobbies' => ['Ham Radio', 'Philatelist'] }
+#   })
+# ```
+#
+# @since 5.0.0
+#
+Puppet::Functions.create_function(:annotate) do
+  dispatch :annotate do
+    param 'Type[Annotation]', :type
+    param 'Any', :value
+    optional_block_param 'Callable[0, 0]', :block
+  end
+
+  dispatch :annotate_new do
+    param 'Type[Annotation]', :type
+    param 'Any', :value
+    param 'Variant[Enum[clear],Hash[Pcore::MemberName,Any]]', :annotation_hash
+  end
+
+  dispatch :annotate_multi do
+    param 'Type[Pcore]', :type
+    param 'Any', :value
+    param 'Hash[Type[Annotation], Hash[Pcore::MemberName,Any]]', :annotations
+  end
+
+  # @param type [Annotation] the annotation type
+  # @param value [Object] the value to annotate
+  # @param block [Proc] optional block to produce the annotation hash
+  #
+  def annotate(type, value, &block)
+    type.implementation_class.annotate(value, &block)
+  end
+
+  # @param type [Annotation] the annotation type
+  # @param value [Object] the value to annotate
+  # @param annotation_hash [Hash{String => Object}] the annotation hash
+  #
+  def annotate_new(type, value, annotation_hash)
+    type.implementation_class.annotate_new(value, annotation_hash)
+  end
+
+  # @param type [Type] the Pcore type
+  # @param value [Object] the value to annotate
+  # @param annotations [Hash{Annotation => Hash{String => Object}}] hash of annotation hashes
+  #
+  def annotate_multi(type, value, annotations)
+    type.implementation_class.annotate(value, annotations)
+  end
+end

data/lib/puppet/functions/any.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+# 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 "truthy" value which
+# makes the function return `true`, or if the end of the iteration is reached, false 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 `any` function
+#
+# `$data.any |$parameter| { <PUPPET CODE BLOCK> }`
+#
+# or
+#
+# `any($data) |$parameter| { <PUPPET CODE BLOCK> }`
+#
+# @example Using the `any` function with an Array and a one-parameter lambda
+#
+# ```puppet
+# # For the array $data, run a lambda that checks if an unknown hash contains those keys
+# $data = ["routers", "servers", "workstations"]
+# $looked_up = lookup('somekey', Hash)
+# notice $data.any |$item| { $looked_up[$item] }
+# ```
+#
+# Would notice `true` if the looked up hash had a value that is neither `false` nor `undef` for at least
+# one of the keys. That is, it is equivalent to the expression
+# `$looked_up[routers] || $looked_up[servers] || $looked_up[workstations]`.
+#
+# 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 `any` 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 = {"rtr" => "Router", "svr" => "Server", "wks" => "Workstation"}
+# $looked_up = lookup('somekey', Hash)
+# notice $data.any |$item| { $looked_up[$item[0]] }
+# ```
+#
+# Would notice `true` if the looked up hash had a value for one of the wanted key that is
+# neither `false` nor `undef`.
+#
+# 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 `any` function with an array and a two-parameter lambda
+#
+# ```puppet
+# # Check if there is an even numbered index that has a non String value
+# $data = [key1, 1, 2, 2]
+# notice $data.any |$index, $value| { $index % 2 == 0 and $value !~ String }
+# ```
+#
+# Would notice true as the index `2` is even and not a `String`
+#
+# 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(:any) do
+  dispatch :any_Hash_2 do
+    param 'Hash[Any, Any]', :hash
+    block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :any_Hash_1 do
+    param 'Hash[Any, Any]', :hash
+    block_param 'Callable[1,1]', :block
+  end
+
+  dispatch :any_Enumerable_2 do
+    param 'Iterable', :enumerable
+    block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :any_Enumerable_1 do
+    param 'Iterable', :enumerable
+    block_param 'Callable[1,1]', :block
+  end
+
+  def any_Hash_1(hash)
+    hash.each_pair.any? { |x| yield(x) }
+  end
+
+  def any_Hash_2(hash)
+    hash.each_pair.any? { |x, y| yield(x, y) }
+  end
+
+  def any_Enumerable_1(enumerable)
+    Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable).any? { |e| yield(e) }
+  end
+
+  def any_Enumerable_2(enumerable)
+    enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
+    if enum.hash_style?
+      enum.any? { |entry| yield(*entry) }
+    else
+      enum.each_with_index { |e, i| return true if yield(i, e) }
+      false
+    end
+  end
+end