bolt 0.23.0 → 0.24.0

data/vendored/puppet/lib/puppet/module_tool/applications/unpacker.rb

@@ -14,7 +14,7 @@ module Puppet::ModuleTool
       end
 
       def self.harmonize_ownership(source, target)
-        unless Puppet.features.microsoft_windows?
+        unless Puppet::Util::Platform.windows?
           source = Pathname.new(source) unless source.respond_to?(:stat)
           target = Pathname.new(target) unless target.respond_to?(:stat)
 

data/vendored/puppet/lib/puppet/network/format_support.rb

@@ -45,11 +45,9 @@ module Puppet::Network::FormatSupport
       end.sort do |a, b|
         # It's an inverse sort -- higher weight formats go first.
         b.weight <=> a.weight
-      end.collect do |f|
-        f.name
       end
 
-      result = put_preferred_format_first(result)
+      result = put_preferred_format_first(result).map(&:name)
 
       Puppet.debug "#{friendly_name} supports formats: #{result.join(' ')}"
 
@@ -76,13 +74,20 @@ module Puppet::Network::FormatSupport
     end
 
     def put_preferred_format_first(list)
-      preferred_format = Puppet.settings[:preferred_serialization_format].to_sym
-      if list.include?(preferred_format)
-        list.delete(preferred_format)
-        list.unshift(preferred_format)
+      preferred_format = Puppet.settings[:preferred_serialization_format].to_s
+
+      preferred = list.select { |format|
+        format.mime.end_with?(preferred_format)
+      }
+
+      if preferred.empty?
+        Puppet.debug "Value of 'preferred_serialization_format' (#{preferred_format}) is invalid for #{friendly_name}, using default (#{list.first.name})"
       else
-        Puppet.debug "Value of 'preferred_serialization_format' (#{preferred_format}) is invalid for #{friendly_name}, using default (#{list.first})"
+        list = preferred + list.reject { |format|
+          format.mime.end_with?(preferred_format)
+        }
       end
+
       list
     end
   end

data/vendored/puppet/lib/puppet/network/formats.rb

@@ -23,13 +23,25 @@ Puppet::Network::FormatHandler.create_serialized_formats(:msgpack, :weight => 20
 end
 
 Puppet::Network::FormatHandler.create_serialized_formats(:yaml) do
+  def allowed_yaml_classes
+    @allowed_yaml_classes ||= [
+      Puppet::Node::Facts,
+      Puppet::Node,
+      Puppet::Transaction::Report,
+      Puppet::Resource,
+      Puppet::Resource::Catalog
+    ]
+  end
+
   def intern(klass, text)
-    data = YAML.load(text)
+    data = Puppet::Util::Yaml.safe_load(text, allowed_yaml_classes)
     data_to_instance(klass, data)
+  rescue Puppet::Util::Yaml::YamlLoadError => e
+    raise Puppet::Network::FormatHandler::FormatError, _("Serialized YAML did not contain a valid instance of %{klass}: %{message}") % { klass: klass, message: e.message }
   end
 
   def intern_multiple(klass, text)
-    data = YAML.load(text)
+    data = Puppet::Util::Yaml.safe_load(text, allowed_yaml_classes)
     unless data.respond_to?(:collect)
       raise Puppet::Network::FormatHandler::FormatError, _("Serialized YAML did not contain a collection of instances when calling intern_multiple")
     end
@@ -37,6 +49,8 @@ Puppet::Network::FormatHandler.create_serialized_formats(:yaml) do
     data.collect do |datum|
       data_to_instance(klass, datum)
     end
+  rescue Puppet::Util::Yaml::YamlLoadError => e
+    raise Puppet::Network::FormatHandler::FormatError, _("Serialized YAML did not contain a valid instance of %{klass}: %{message}") % { klass: klass, message: e.message }
   end
 
   def data_to_instance(klass, data)
@@ -167,3 +181,80 @@ Puppet::Network::FormatHandler.create(:console,
     data.collect(&:render).join("\n")
   end
 end
+
+Puppet::Network::FormatHandler.create(:rich_data_json, mime: 'application/vnd.puppet.rich+json', charset: Encoding::UTF_8, weight: 30) do
+  def intern(klass, text)
+    Puppet.override({:rich_data => true}) do
+      data_to_instance(klass, Puppet::Util::Json.load(text))
+    end
+  end
+
+  def intern_multiple(klass, text)
+    Puppet.override({:rich_data => true}) do
+      Puppet::Util::Json.load(text).collect do |data|
+        data_to_instance(klass, data)
+      end
+    end
+  end
+
+  def render(instance)
+    Puppet.override({:rich_data => true}) do
+      instance.to_json
+    end
+  end
+
+  def render_multiple(instances)
+    Puppet.override({:rich_data => true}) do
+      Puppet::Util::Json.dump(instances)
+    end
+  end
+
+  def data_to_instance(klass, data)
+    Puppet.override({:rich_data => true}) do
+      return data if data.is_a?(klass)
+      klass.from_data_hash(data)
+    end
+  end
+
+  def supported?(klass)
+    klass == Puppet::Resource::Catalog &&
+      Puppet.lookup(:current_environment).rich_data?
+  end
+end
+
+Puppet::Network::FormatHandler.create_serialized_formats(:rich_data_msgpack, mime: "application/vnd.puppet.rich+msgpack", weight: 35) do
+  confine :feature => :msgpack
+
+  def intern(klass, text)
+    Puppet.override(rich_data: true) do
+      data = MessagePack.unpack(text)
+      return data if data.is_a?(klass)
+      klass.from_data_hash(data)
+    end
+  end
+
+  def intern_multiple(klass, text)
+    Puppet.override(rich_data: true) do
+      MessagePack.unpack(text).collect do |data|
+        klass.from_data_hash(data)
+      end
+    end
+  end
+
+  def render_multiple(instances)
+    Puppet.override(rich_data: true) do
+      instances.to_msgpack
+    end
+  end
+
+  def render(instance)
+    Puppet.override(rich_data: true) do
+      instance.to_msgpack
+    end
+  end
+
+  def supported?(klass)
+    klass == Puppet::Resource::Catalog &&
+      Puppet.lookup(:current_environment).rich_data?
+  end
+end

data/vendored/puppet/lib/puppet/network/http/api/indirected_routes.rb

@@ -43,8 +43,14 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
       raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new(_("No handler for %{indirection}") % { indirection: indirection.name }, :NO_INDIRECTION_REMOTE_REQUESTS)
     end
 
-    trusted = Puppet::Context::TrustedInformation.remote(params[:authenticated], params[:node], certificate)
-    Puppet.override(:trusted_information => trusted) do
+    overrides = {
+      trusted_information: Puppet::Context::TrustedInformation.remote(params[:authenticated], params[:node], certificate),
+    }
+    if params[:environment]
+      overrides[:current_environment] = params[:environment]
+    end
+
+    Puppet.override(overrides) do
       send("do_#{method}", indirection, key, params, request, response)
     end
   end
@@ -191,7 +197,8 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
       begin
         yield format
         true
-      rescue Puppet::Network::FormatHandler::FormatError
+      rescue Puppet::Network::FormatHandler::FormatError => err
+        Puppet.log_exception(err, err.message, level: :debug)
         false
       end
     end

data/vendored/puppet/lib/puppet/node/facts.rb

@@ -131,7 +131,17 @@ class Puppet::Node::Facts
       or fact.is_a? String
       fact
     else
-      fact.to_s
+      result = fact.to_s
+      # The result may be ascii-8bit encoded without being a binary (low level object.inspect returns ascii-8bit string)
+      if result.encoding == Encoding::ASCII_8BIT
+        begin
+          result = result.encode(Encoding::UTF_8)
+        rescue
+          # return the ascii-8bit - it will be taken as a binary
+          result
+        end
+      end
+      result
     end
   end
 end

data/vendored/puppet/lib/puppet/parser/catalog_compiler.rb

@@ -0,0 +1,56 @@
+require 'puppet/loaders'
+require 'puppet/pops'
+
+# A Catalog "compiler" that is like the regular compiler but with an API
+# that is harmonized with the ScriptCompiler
+#
+# The Script compiler is "one shot" - it does not support rechecking if underlying source has changed or
+# deal with possible errors in a cached environment.
+#
+class Puppet::Parser::CatalogCompiler < Puppet::Parser::Compiler
+
+  # Evaluates the configured setup for a script + code in an environment with modules
+  #
+  def compile
+    Puppet[:strict_variables] = true
+    Puppet[:strict] = :error
+
+    Puppet.override(rich_data: true) do
+      super
+    end
+
+  rescue Puppet::ParseErrorWithIssue => detail
+    detail.node = node.name
+    Puppet.log_exception(detail)
+    raise
+  rescue => detail
+    message = "#{detail} on node #{node.name}"
+    Puppet.log_exception(detail, message)
+    raise Puppet::Error, message, detail.backtrace
+  end
+
+  # Evaluates all added constructs, and validates the resulting catalog.
+  # This can be called whenever a series of evaluation of puppet code strings
+  # have reached a stable state (essentially that there are no relationships to
+  # non-existing resources).
+  #
+  # Raises an error if validation fails.
+  #
+  def compile_additions
+    evaluate_additions
+    validate
+  end
+
+  # Evaluates added constructs that are lazily evaluated until all of them have been evaluated.
+  # 
+  def evaluate_additions
+    evaluate_generators
+    finish
+  end
+
+  # Validates the current state of the catalog.
+  # Does not cause evaluation of lazy constructs.
+  def validate
+    validate_catalog(CatalogValidator::FINAL)
+  end
+end

data/vendored/puppet/lib/puppet/parser/compiler.rb

@@ -577,6 +577,7 @@ class Puppet::Parser::Compiler
       end
     end
   end
+  protected :evaluate_generators
 
   # Find and evaluate our main object, if possible.
   def evaluate_main
@@ -641,6 +642,7 @@ class Puppet::Parser::Compiler
 
     add_resource_metaparams
   end
+  protected :finish
 
   def add_resource_metaparams
     unless main = catalog.resource(:class, :main)
@@ -780,8 +782,8 @@ class Puppet::Parser::Compiler
     settings_resource = Puppet::Parser::Resource.new('class', SETTINGS, :scope => @topscope)
 
     @catalog.add_resource(settings_resource)
-
     settings_type.evaluate_code(settings_resource)
+    settings_resource.instance_variable_set(:@evaluated, true) # Prevents settings from being reevaluated
 
     scope = @topscope.class_scope(settings_type)
     scope.merge_settings(environment.name)

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

@@ -203,7 +203,9 @@ module Puppet::Parser::Functions
           elsif arity < 0 and args[0].size < (arity+1).abs
             raise ArgumentError, _("%{name}(): Wrong number of arguments given (%{arg_count} for minimum %{min_arg_count})") % { name: name, arg_count: args[0].size, min_arg_count: (arity+1).abs }
           end
-          self.send(real_fname, args[0])
+          r = Puppet::Pops::Evaluator::Runtime3FunctionArgumentConverter.convert_return(self.send(real_fname, args[0]))
+          # avoid leaking aribtrary value if not being an rvalue function
+          options[:type] == :rvalue ? r : nil
         else
           raise ArgumentError, _("custom functions must be called with a single array that contains the arguments. For example, function_example([1]) instead of function_example(1)")
         end

data/vendored/puppet/lib/puppet/parser/functions/filter.rb

@@ -5,7 +5,7 @@ Puppet::Parser::Functions::newfunction(
   :doc => <<-DOC
 Applies a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
 to every value in a data structure and returns an array or hash containing any elements
-for which the lambda evaluates to `true`.
+for which the lambda evaluates to a truthy value (not `false` or `undef`).
 
 This function takes two mandatory arguments, in this order:
 

data/vendored/puppet/lib/puppet/parser/functions/generate.rb

@@ -14,7 +14,7 @@ Puppet::Parser::Functions::newfunction(:generate, :arity => -2, :type => :rvalue
       #TRANSLATORS "fully qualified" refers to a fully qualified file system path
       raise Puppet::ParseError, _("Generators must be fully qualified") unless Puppet::Util.absolute_path?(args[0])
 
-      if Puppet.features.microsoft_windows?
+      if Puppet::Util::Platform.windows?
         valid = args[0] =~ /^[a-z]:(?:[\/\\][-.~\w]+)+$/i
       else
         valid = args[0] =~ /^[-\/\w.+]+$/

data/vendored/puppet/lib/puppet/parser/functions/sprintf.rb

@@ -30,7 +30,18 @@ Puppet::Parser::Functions::newfunction(
   :doc => "Perform printf-style formatting of text.
 
   The first parameter is format string describing how the rest of the parameters should be formatted.
-  See the documentation for the `Kernel::sprintf` function in Ruby for all the details."
+  See the documentation for the [`Kernel::sprintf` function](https://ruby-doc.org/core/Kernel.html)
+  in Ruby for details.
+  
+  To use [named format](https://idiosyncratic-ruby.com/49-what-the-format.html) arguments, provide a
+  hash containing the target string values as the argument to be formatted. For example:
+
+  ```puppet
+  notice sprintf(\"%<x>s : %<y>d\", { 'x' => 'value is', 'y' => 42 })
+  ```
+
+  This statement produces a notice of `value is : 42`."
+
 ) do |args|
   fmt = args[0]
   args = args[1..-1]

data/vendored/puppet/lib/puppet/parser/functions/tagged.rb

@@ -9,12 +9,9 @@ Puppet::Parser::Functions::newfunction(:tagged, :type => :rvalue, :arity => -2,
         {:operation => 'tagged'})
     end
 
-    configtags = compiler.catalog.tags
-    resourcetags = resource.tags
-
     retval = true
     vals.each do |val|
-      unless configtags.include?(val) or resourcetags.include?(val)
+      unless compiler.catalog.tagged?(val) or resource.tagged?(val)
         retval = false
         break
       end

data/vendored/puppet/lib/puppet/parser/scope.rb

@@ -814,7 +814,7 @@ class Puppet::Parser::Scope
   end
 
   # Deeply freezes the given object. The object and its content must be of the types:
-  # Array, Hash, Numeric, Boolean, Symbol, Regexp, NilClass, or String. All other types raises an Error.
+  # Array, Hash, Numeric, Boolean, Regexp, NilClass, or String. All other types raises an Error.
   # (i.e. if they are assignable to Puppet::Pops::Types::Data type).
   #
   def deep_freeze(object)

data/vendored/puppet/lib/puppet/parser/script_compiler.rb

@@ -66,13 +66,14 @@ class Puppet::Parser::ScriptCompiler
       :current_environment => environment,
       :global_scope => @topscope,             # 4x placeholder for new global scope
       :loaders  => @loaders,                  # 4x loaders
+      :rich_data => true,
     }
   end
 
   # Create a script compiler for the given environment where errors are logged as coming
   # from the given node_name
   #
-  def initialize(environment, node_name)
+  def initialize(environment, node_name, for_agent=false)
     @environment = environment
     @node_name = node_name
 
@@ -80,7 +81,11 @@ class Puppet::Parser::ScriptCompiler
     @topscope = Puppet::Parser::Scope.new(self)
 
     # Initialize loaders and Pcore
-    @loaders = Puppet::Pops::Loaders.new(environment)
+    if for_agent
+      @loaders = Puppet::Pops::Loaders.new(environment, true)
+    else
+      @loaders = Puppet::Pops::Loaders.new(environment)
+    end
 
     # Need to compute overrides here, and remember them, because we are about to
     # Expensive entries in the context are bound lazily.

data/vendored/puppet/lib/puppet/pops/evaluator/deferred_resolver.rb

@@ -14,13 +14,12 @@ class DeferredResolver
   # Deferred values inside of custom Object instances are not resolved as this
   # is expected to be done by such objects.
   #
-  # @param node [Puppet::Node] the node for the catalog
   # @param facts [Puppet::Node::Facts] the facts object for the node
   # @param catalog [Puppet::Resource::Catalog] the catalog where all deferred values should be replaced
   # @return [nil] does not return anything - the catalog is modified as a side effect
   #
-  def self.resolve_and_replace(node, facts, catalog)
-    compiler = Puppet::Parser::ScriptCompiler.new(node.environment, node.name)
+  def self.resolve_and_replace(facts, catalog)
+    compiler = Puppet::Parser::ScriptCompiler.new(catalog.environment_instance, catalog.name, true)
     resolver = new(compiler)
     resolver.set_facts_variable(facts)
     # TODO:
@@ -97,6 +96,9 @@ class DeferredResolver
     elsif x.is_a?(Puppet::Pops::Types::PSensitiveType::Sensitive)
       # rewrap in a new Sensitive after resolving any nested deferred values
       Puppet::Pops::Types::PSensitiveType::Sensitive.new(resolve(x.unwrap))
+    elsif x.is_a?(Puppet::Pops::Types::PBinaryType::Binary)
+      # use the ASCII-8BIT string that it wraps
+      x.binary_buffer
     else
       x
     end

data/vendored/puppet/lib/puppet/pops/evaluator/runtime3_converter.rb

@@ -61,7 +61,7 @@ class Runtime3Converter
   end
 
   def convert_NilClass(o, scope, undef_value)
-    @inner ? :undef : undef_value
+    @inner ? nil : undef_value
   end
 
   def convert_Integer(o, scope, undef_value)
@@ -78,8 +78,10 @@ class Runtime3Converter
   end
 
   def convert_String(o, scope, undef_value)
-    # although wasteful, needed because user code may mutate these strings in Resources
-    o.frozen? ? o.dup : o
+    # Although wasteful, a dup is needed because user code may mutate these strings when applying
+    # Resources. This does not happen when in master mode since it only uses Resources that are
+    # in puppet core and those are all safe.
+    o.frozen? && !Puppet.run_mode.master? ? o.dup : o
   end
 
   def convert_Object(o, scope, undef_value)
@@ -103,7 +105,8 @@ class Runtime3Converter
   end
 
   def convert_Symbol(o, scope, undef_value)
-    o == :undef && !@inner ? undef_value : o
+    o == :undef ? undef_value : o
+    #o == :undef && !@inner ? undef_value : o
   end
 
   def convert_PAnyType(o, scope, undef_value)
@@ -196,6 +199,22 @@ class Runtime3FunctionArgumentConverter < Runtime3Converter
     o.to_s
   end
 
+  # Converts result back to 4.x by replacing :undef with nil in Array and Hash objects
+  #
+  def self.convert_return(val3x)
+    if val3x == :undef
+      nil
+    elsif val3x.is_a?(Array)
+      val3x.map {|v| convert_return(v) }
+    elsif val3x.is_a?(Hash)
+      hsh = {}
+      val3x.each_pair {|k,v| hsh[convert_return(k)] = convert_return(v)}
+      hsh
+    else
+      val3x
+    end
+  end
+
   @instance = self.new
 end