bolt 0.20.0 → 0.20.2

data/vendored/puppet/lib/puppet/functions/unwrap.rb

@@ -0,0 +1,44 @@
+# Unwraps a Sensitive value and returns the wrapped object.
+#
+# @example Usage of unwrap
+#
+# ```puppet
+# $plaintext = 'hunter2'
+# $pw = Sensitive.new($plaintext)
+# notice("Wrapped object is $pw") #=> Prints "Wrapped object is Sensitive [value redacted]"
+# $unwrapped = $pw.unwrap
+# notice("Unwrapped object is $unwrapped") #=> Prints "Unwrapped object is hunter2"
+# ```
+#
+# You can optionally pass a block to unwrap in order to limit the scope where the
+# unwrapped value is visible.
+#
+# @example Unwrapping with a block of code
+#
+# ```puppet
+# $pw = Sensitive.new('hunter2')
+# notice("Wrapped object is $pw") #=> Prints "Wrapped object is Sensitive [value redacted]"
+# $pw.unwrap |$unwrapped| {
+#   $conf = inline_template("password: ${unwrapped}\n")
+#   Sensitive.new($conf)
+# } #=> Returns a new Sensitive object containing an interpolated config file
+# # $unwrapped is now out of scope
+# ```
+#
+# @since 4.0.0
+#
+Puppet::Functions.create_function(:unwrap) do
+  dispatch :unwrap do
+    param 'Sensitive', :arg
+    optional_block_param
+  end
+
+  def unwrap(arg)
+    unwrapped = arg.unwrap
+    if block_given?
+      yield(unwrapped)
+    else
+      unwrapped
+    end
+  end
+end

data/vendored/puppet/lib/puppet/functions/values.rb

@@ -0,0 +1,25 @@
+# Returns the values of a hash as an Array
+#
+# @example Using `values`
+#
+# ```puppet
+# $hsh = {"apples" => 3, "oranges" => 4 }
+# $hsh.values()
+# values($hsh)
+# # both results in the array [3, 4]
+# ```
+#
+# * Note that a hash in the puppet language accepts any data value (including `undef`) unless
+#   it is constrained with a `Hash` data type that narrows the allowed data types.
+# * For an empty hash, an empty array is returned.
+# * The order of the values is the same as the order in the hash (typically the order in which they were added).
+#
+Puppet::Functions.create_function(:values) do
+  dispatch :values do
+    param 'Hash', :hsh
+  end
+
+  def values(hsh)
+    hsh.values
+  end
+end

data/vendored/puppet/lib/puppet/functions/versioncmp.rb

@@ -0,0 +1,36 @@
+require 'puppet/util/package'
+
+# Compares two version numbers.
+#
+# Prototype:
+#
+#     \$result = versioncmp(a, b)
+#
+# Where a and b are arbitrary version strings.
+#
+# This function returns:
+#
+# * `1` if version a is greater than version b
+# * `0` if the versions are equal
+# * `-1` if version a is less than version b
+#
+# @example Using versioncmp
+#
+#     if versioncmp('2.6-1', '2.4.5') > 0 {
+#         notice('2.6-1 is > than 2.4.5')
+#     }
+#
+# This function uses the same version comparison algorithm used by Puppet's
+# `package` type.
+#
+Puppet::Functions.create_function(:versioncmp) do
+
+  dispatch :versioncmp do
+    param 'String', :a
+    param 'String', :b
+  end
+
+  def versioncmp(a, b)
+    Puppet::Util::Package.versioncmp(a, b)
+  end
+end

data/vendored/puppet/lib/puppet/functions/warning.rb

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

data/vendored/puppet/lib/puppet/functions/with.rb

@@ -0,0 +1,32 @@
+# Calls a [lambda](https://docs.puppet.com/puppet/latest/reference/lang_lambdas.html)
+# with the given arguments and returns the result.
+#
+# Since a lambda's scope is
+# [local](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html#lambda-scope)
+# to the lambda, you can use the `with` function to create private blocks of code within a
+# class using variables whose values cannot be accessed outside of the lambda.
+#
+# @example Using `with`
+#
+# ```puppet
+# # Concatenate three strings into a single string formatted as a list.
+# $fruit = with("apples", "oranges", "bananas") |$x, $y, $z| { 
+#   "${x}, ${y}, and ${z}" 
+# }
+# $check_var = $x
+# # $fruit contains "apples, oranges, and bananas"
+# # $check_var is undefined, as the value of $x is local to the lambda.
+# ```
+#
+# @since 4.0.0
+#
+Puppet::Functions.create_function(:with) do
+  dispatch :with do
+    repeated_param 'Any', :arg
+    block_param
+  end
+
+  def with(*args)
+    yield(*args)
+  end
+end

data/vendored/puppet/lib/puppet/functions/yaml_data.rb

@@ -0,0 +1,42 @@
+# The `yaml_data` is a hiera 5 `data_hash` data provider function.
+# See [the configuration guide documentation](https://docs.puppet.com/puppet/latest/hiera_config_yaml_5.html#configuring-a-hierarchy-level-built-in-backends) for
+# how to use this function.
+#
+# @since 4.8.0
+#
+require 'yaml'
+
+Puppet::Functions.create_function(:yaml_data) do
+  dispatch :yaml_data do
+    param 'Struct[{path=>String[1]}]', :options
+    param 'Puppet::LookupContext', :context
+  end
+
+  argument_mismatch :missing_path do
+    param 'Hash', :options
+    param 'Puppet::LookupContext', :context
+  end
+
+  def yaml_data(options, context)
+    path = options['path']
+    context.cached_file_data(path) do |content|
+      begin
+        data = YAML.load(content, path)
+        if data.is_a?(Hash)
+          Puppet::Pops::Lookup::HieraConfig.symkeys_to_string(data)
+        else
+          Puppet.warning(_("%{path}: file does not contain a valid yaml hash" % { path: path }))
+          {}
+        end
+      rescue YAML::SyntaxError => ex
+        # Psych errors includes the absolute path to the file, so no need to add that
+        # to the message
+        raise Puppet::DataBinding::LookupError, "Unable to parse #{ex.message}"
+      end
+    end
+  end
+
+  def missing_path(options, context)
+    "one of 'path', 'paths' 'glob', 'globs' or 'mapped_paths' must be declared in hiera.yaml when using this data_hash function"
+  end
+end

data/vendored/puppet/lib/puppet/generate/models/type/property.rb

@@ -0,0 +1,70 @@
+module Puppet
+  module Generate
+    module Models
+      module Type
+        # A model for resource type properties and parameters.
+        class Property
+          # Gets the name of the property as a Puppet string literal.
+          attr_reader :name
+
+          # Gets the Puppet type of the property.
+          attr_reader :type
+
+          # Gets the doc string of the property.
+          attr_reader :doc
+
+          # Initializes a property model.
+          # @param property [Puppet::Property] The Puppet property to model.
+          # @return [void]
+          def initialize(property)
+            @name = Puppet::Pops::Types::StringConverter.convert(property.name.to_s, '%p')
+            @type = self.class.get_puppet_type(property)
+            @doc = property.doc.strip
+            @is_namevar = property.isnamevar?
+          end
+
+          # Determines if this property is a namevar.
+          # @return [Boolean] Returns true if the property is a namevar or false if not.
+          def is_namevar?
+            @is_namevar
+          end
+
+          # Gets the Puppet type for a property.
+          # @param property [Puppet::Property] The Puppet property to get the Puppet type for.
+          # @return [String] Returns the string representing the Puppet type.
+          def self.get_puppet_type(property)
+            # HACK: the value collection does not expose the underlying value information at all
+            #       thus this horribleness to get the underlying values hash
+            regexes = []
+            strings = []
+            values = property.value_collection.instance_variable_get('@values') || {}
+            values.each do |_, value|
+              if value.regex?
+                regexes << Puppet::Pops::Types::StringConverter.convert(value.name, '%p')
+                next
+              end
+
+              strings << Puppet::Pops::Types::StringConverter.convert(value.name.to_s, '%p')
+              value.aliases.each do |a|
+                strings << Puppet::Pops::Types::StringConverter.convert(a.to_s, '%p')
+              end
+            end
+
+            # If no string or regexes, default to Any type
+            return 'Any' if strings.empty? && regexes.empty?
+
+            # Calculate a variant of supported values
+            # Note that boolean strings are mapped to Variant[Boolean, Enum['true', 'false']]
+            # because of tech debt...
+            enum    = strings.empty? ? nil : "Enum[#{strings.join(', ')}]"
+            pattern = regexes.empty? ? nil : "Pattern[#{regexes.join(', ')}]"
+            boolean = strings.include?('\'true\'') || strings.include?('\'false\'') ? 'Boolean' : nil
+            variant = [boolean, enum, pattern].reject { |t| t.nil? }
+            return variant[0] if variant.size == 1
+            "Variant[#{variant.join(', ')}]"
+          end
+        end
+      end
+    end
+  end
+end

data/vendored/puppet/lib/puppet/generate/models/type/type.rb

@@ -0,0 +1,62 @@
+require 'puppet/generate/models/type/property'
+
+module Puppet
+  module Generate
+    module Models
+      module Type
+        # A model for Puppet resource types.
+        class Type
+          # Gets the name of the type as a Puppet string literal.
+          attr_reader :name
+
+          # Gets the doc string of the type.
+          attr_reader :doc
+
+          # Gets the properties of the type.
+          attr_reader :properties
+
+          # Gets the parameters of the type.
+          attr_reader :parameters
+
+          # Gets the title patterns of the type
+          attr_reader :title_patterns
+
+          # Gets the isomorphic member attribute of the type
+          attr_reader :isomorphic
+
+          # Gets the capability member attribute of the type
+          attr_reader :capability
+
+          # Initializes a type model.
+          # @param type [Puppet::Type] The Puppet type to model.
+          # @return [void]
+          def initialize(type)
+            @name = Puppet::Pops::Types::StringConverter.convert(type.name.to_s, '%p')
+            @doc = type.doc.strip
+            @properties = type.properties.map { |p| Property.new(p) }
+            @parameters = type.parameters.map do |name|
+              Property.new(type.paramclass(name))
+            end
+            sc = Puppet::Pops::Types::StringConverter.singleton
+            @title_patterns = Hash[type.title_patterns.map do |mapping|
+              [
+                sc.convert(mapping[0], '%p'),
+                sc.convert(mapping[1].map do |names|
+                  next if names.empty?
+                  raise Puppet::Error, _('title patterns that use procs are not supported.') unless names.size == 1
+                  names[0].to_s
+                end, '%p')
+              ]
+            end]
+            @isomorphic = type.isomorphic?
+            @capability = type.is_capability?
+          end
+
+          def render(template)
+            template.result(binding)
+          end
+        end
+      end
+    end
+  end
+end

data/vendored/puppet/lib/puppet/generate/type.rb

@@ -0,0 +1,239 @@
+require 'erb'
+require 'fileutils'
+require 'puppet/util/autoload'
+require 'puppet/generate/models/type/type'
+
+module Puppet
+  module Generate
+    # Responsible for generating type definitions in Puppet
+    class Type
+      # Represents an input to the type generator
+      class Input
+        # Gets the path to the input.
+        attr_reader :path
+
+        # Gets the format to use for generating the output file.
+        attr_reader :format
+
+        # Initializes an input.
+        # @param base [String] The base path where the input is located.
+        # @param path [String] The path to the input file.
+        # @param format [Symbol] The format to use for generation.
+        # @return [void]
+        def initialize(base, path, format)
+          @base = base
+          @path = path
+          self.format = format
+        end
+
+        # Gets the expected resource type name for the input.
+        # @return [Symbol] Returns the expected resource type name for the input.
+        def type_name
+          File.basename(@path, '.rb').to_sym
+        end
+
+        # Sets the format to use for this input.
+        # @param format [Symbol] The format to use for generation.
+        # @return [Symbol] Returns the new format.
+        def format=(format)
+          format = format.to_sym
+          raise _("unsupported format '%{format}'.") % { format: format } unless self.class.supported_format?(format)
+          @format = format
+        end
+
+        # Determines if the output file is up-to-date with respect to the input file.
+        # @param [String, nil] The path to output to, or nil if determined by input
+        # @return [Boolean] Returns true if the output is up-to-date or false if not.
+        def up_to_date?(outputdir)
+          f = effective_output_path(outputdir)
+          Puppet::FileSystem::exist?(f) && (Puppet::FileSystem::stat(@path) <=> Puppet::FileSystem::stat(f)) <= 0
+        end
+
+        # Gets the filename of the output file.
+        # @return [String] Returns the name to the output file.
+        def output_name
+          @output_name ||=
+            case @format
+            when :pcore
+              "#{File.basename(@path, '.rb')}.pp"
+            else
+              raise _("unsupported format '%{format}'.") % { format: @format }
+            end
+        end
+
+        # Gets the path to the output file.
+        # @return [String] Returns the path to the output file.
+        def output_path
+          @output_path ||=
+            case @format
+            when :pcore
+              File.join(@base, 'pcore', 'types', output_name)
+            else
+              raise _("unsupported format '%{format}'.") % { format: @format }
+            end
+        end
+
+        # Sets the path to the output file.
+        # @param path [String] The new path to the output file.
+        # @return [String] Returns the new path to the output file.
+        def output_path=(path)
+          @output_path = path
+        end
+
+        # Returns the outputpath to use given an outputdir that may be nil
+        # If outputdir is not nil, the returned path is relative to that outpudir
+        # otherwise determined by this input.
+        # @param [String, nil] The outputdirectory to use, or nil if to be determined by this Input
+        def effective_output_path(outputdir)
+          outputdir ? File.join(outputdir, output_name) : output_path
+        end
+
+        # Gets the path to the template to use for this input.
+        # @return [String] Returns the path to the template.
+        def template_path
+          File.join(File.dirname(__FILE__), 'templates', 'type', "#{@format}.erb")
+        end
+
+        # Gets the string representation of the input.
+        # @return [String] Returns the string representation of the input.
+        def to_s
+          @path
+        end
+
+        # Determines if the given format is supported
+        # @param format [Symbol] The format to use for generation.
+        # @return [Boolean] Returns true if the format is supported or false if not.
+        def self.supported_format?(format)
+          [:pcore].include?(format)
+        end
+      end
+
+      # Finds the inputs for the generator.
+      # @param format [Symbol] The format to use.
+      # @param environment [Puppet::Node::Environment] The environment to search for inputs. Defaults to the current environment.
+      # @return [Array<Input>] Returns the array of inputs.
+      def self.find_inputs(format = :pcore, environment = Puppet.lookup(:current_environment))
+        Puppet.debug "Searching environment '#{environment.name}' for custom types."
+        inputs = []
+        environment.modules.each do |mod|
+          directory = File.join(Puppet::Util::Autoload.cleanpath(mod.plugin_directory), 'puppet', 'type')
+          unless Puppet::FileSystem.exist?(directory)
+            Puppet.debug "Skipping '#{mod.name}' module because it contains no custom types."
+            next
+          end
+
+          Puppet.debug "Searching '#{mod.name}' module for custom types."
+          Dir.glob("#{directory}/*.rb") do |file|
+            next unless Puppet::FileSystem.file?(file)
+            Puppet.debug "Found custom type source file '#{file}'."
+            inputs << Input.new(mod.path, file, format)
+          end
+        end
+
+        # Sort the inputs by path
+        inputs.sort_by! { |input| input.path }
+      end
+
+      # Generates files for the given inputs.
+      # If a file is up to date (newer than input) it is kept.
+      # If a file is out of date it is regenerated.
+      # If there is a file for a non existing output in a given output directory it is removed.
+      # If using input specific output removal must be made by hand if input is removed.
+      #
+      # @param inputs [Array<Input>] The inputs to generate files for.
+      # @param outputdir [String, nil] the outputdir where all output should be generated, or nil if next to input
+      # @param force [Boolean] True to force the generation of the output files (skip up-to-date checks) or false if not.
+      # @return [void]
+      def self.generate(inputs, outputdir = nil, force = false)
+        # remove files for non existing inputs
+        unless outputdir.nil?
+          filenames_to_keep = inputs.map {|i| i.output_name }
+          existing_files = Puppet::FileSystem.children(outputdir).map {|f| Puppet::FileSystem.basename(f) }
+          files_to_remove = existing_files - filenames_to_keep
+          files_to_remove.each do |f|
+            Puppet::FileSystem.unlink(File.join(outputdir, f))
+          end
+          Puppet.notice(_("Removed output '%{files_to_remove}' for non existing inputs") % { files_to_remove: files_to_remove }) unless files_to_remove.empty?
+        end
+
+        if inputs.empty?
+          Puppet.notice _('No custom types were found.')
+          return nil
+        end
+
+        templates = {}
+        templates.default_proc = lambda { |hash, key|
+          raise _("template was not found at '%{key}'.") % { key: key } unless Puppet::FileSystem.file?(key)
+          template = ERB.new(File.read(key), nil, '-')
+          template.filename = key
+          template
+        }
+
+        up_to_date = true
+        Puppet.notice _('Generating Puppet resource types.')
+        inputs.each do |input|
+          if !force && input.up_to_date?(outputdir)
+            Puppet.debug "Skipping '#{input}' because it is up-to-date."
+            next
+          end
+
+          up_to_date = false
+
+          type_name = input.type_name
+          Puppet.debug "Loading custom type '#{type_name}' in '#{input}'."
+          begin
+            require input.path
+          rescue SystemExit
+            raise
+          rescue Exception => e
+            # Log the exception and move on to the next input
+            Puppet.log_exception(e, _("Failed to load custom type '%{type_name}' from '%{input}': %{message}") % { type_name: type_name, input: input, message: e.message })
+            next
+          end
+
+          # HACK: there's no way to get a type without loading it (sigh); for now, just get the types hash directly
+          types ||= Puppet::Type.instance_variable_get('@types')
+
+          # Assume the type follows the naming convention
+          unless type = types[type_name]
+            Puppet.err _("Custom type '%{type_name}' was not defined in '%{input}'.") % { type_name: type_name, input: input }
+            next
+          end
+
+          # Create the model
+          begin
+            model = Models::Type::Type.new(type)
+          rescue Exception => e
+            # Move on to the next input
+            Puppet.log_exception(e, "#{input}: #{e.message}")
+            next
+          end
+
+          # Render the template
+          begin
+            result = model.render(templates[input.template_path])
+          rescue Exception => e
+            Puppet.log_exception(e)
+            raise
+          end
+
+          # Write the output file
+          begin
+            effective_output_path = input.effective_output_path(outputdir)
+            Puppet.notice _("Generating '%{effective_output_path}' using '%{format}' format.") % { effective_output_path: effective_output_path, format: input.format }
+            FileUtils.mkdir_p(File.dirname(effective_output_path))
+            Puppet::FileSystem.open(effective_output_path, nil, 'w:UTF-8') do |file|
+              file.write(result)
+            end
+          rescue Exception => e
+            Puppet.log_exception(e, _("Failed to generate '%{effective_output_path}': %{message}") % { effective_output_path: effective_output_path, message: e.message })
+            # Move on to the next input
+            next
+          end
+        end
+
+        Puppet.notice _('No files were generated because all inputs were up-to-date.') if up_to_date
+      end
+    end
+  end
+end