bolt 0.23.0 → 0.24.0

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

@@ -305,15 +305,14 @@ module Runtime3Support
         return Kernel.eval('_func.call(scope, *args, &block)'.freeze, Kernel.binding, file || '', line)
       end
     end
-    # Call via 3x API if function exists there
+    # Call via 3x API if function exists there without having been autoloaded
     fail(Issues::UNKNOWN_FUNCTION, o, {:name => name}) unless Puppet::Parser::Functions.function(name)
 
     # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
     # NOTE: Passing an empty string last converts nil/:undef to empty string
     mapped_args = Runtime3FunctionArgumentConverter.map_args(args, scope, '')
-    result = Puppet::Pops::PuppetStack.stack(file, line, scope, "function_#{name}", [mapped_args], &block)
-    # Prevent non r-value functions from leaking their result (they are not written to care about this)
-    Puppet::Parser::Functions.rvalue?(name) ? result : nil
+    # The 3x function performs return value mapping and returns nil if it is not of rvalue type
+    Puppet::Pops::PuppetStack.stack(file, line, scope, "function_#{name}", [mapped_args], &block)
   end
 
   # The o is used for source reference

data/vendored/puppet/lib/puppet/pops/functions/dispatch.rb

@@ -81,6 +81,10 @@ class Dispatch < Evaluator::CallableSignature
               Puppet.lookup(:pal_script_compiler)
             when :cache
               Puppet::Pops::Adapters::ObjectIdCacheAdapter.adapt(scope.compiler)
+            when :pal_catalog_compiler
+              Puppet.lookup(:pal_catalog_compiler)
+            when :pal_compiler
+              Puppet.lookup(:pal_compiler)
             else
               raise ArgumentError, _("Unknown injection %{injection_name}") % { injection_name: injection_name }
             end

data/vendored/puppet/lib/puppet/pops/issues.rb

@@ -490,6 +490,14 @@ module Issues
     _("Unacceptable location. The name '%{name}' is unacceptable in file '%{file}'") % { name: name, file: file }
   end
 
+  ILLEGAL_TOP_CONSTRUCT_LOCATION = issue :ILLEGAL_TOP_CONSTRUCT_LOCATION do
+    if semantic.is_a?(Puppet::Pops::Model::NamedDefinition)
+      _("The %{value} '%{name}' is unacceptable as a top level construct in this location") % { name: semantic.name, value: label(semantic) }
+    else
+      _("This %{value} is unacceptable as a top level construct in this location") % { value: label(semantic) }
+    end
+  end
+
   CAPTURES_REST_NOT_LAST = hard_issue :CAPTURES_REST_NOT_LAST, :param_name do
     _("Parameter $%{param} is not last, and has 'captures rest'") % { param: param_name }
   end

data/vendored/puppet/lib/puppet/pops/loader/loader.rb

@@ -29,7 +29,7 @@ class Loader
   attr_reader :loader_name
 
   # Describes the kinds of things that loaders can load
-  LOADABLE_KINDS = [:func_4x, :func_4xpp, :datatype, :type_pp, :resource_type_pp, :plan, :task].freeze
+  LOADABLE_KINDS = [:func_4x, :func_4xpp, :func_3x, :datatype, :type_pp, :resource_type_pp, :plan, :task].freeze
 
   # @param [String] name the name of the loader. Must be unique among all loaders maintained by a {Loader} instance
   def initialize(loader_name)
@@ -107,7 +107,7 @@ class Loader
   #
   # @api private
   #
-  def [] (typed_name)
+  def [](typed_name)
     if found = get_entry(typed_name)
       found.value
     else

data/vendored/puppet/lib/puppet/pops/loader/loader_paths.rb

@@ -25,7 +25,9 @@ module LoaderPaths
         if loader.loadables.include?(:func_4xpp)
           result << FunctionPathPP.new(loader)
         end
-        # When wanted also add FunctionPath3x to load 3x functions
+        if loader.loadables.include?(:func_3x)
+          result << FunctionPath3x.new(loader)
+        end
     when :plan
       result << PlanPathPP.new(loader)
     when :task

data/vendored/puppet/lib/puppet/pops/loader/module_loaders.rb

@@ -19,6 +19,24 @@ module Loader
 # @api private
 #
 module ModuleLoaders
+
+  # Wildcard module name for module loaders, makes loading possible from any namespace.
+  NAMESPACE_WILDCARD = '*'.freeze
+
+  # This is exactly the same as the #system_loader_from method, but the argument for path is changed to
+  # location where pluginsync stores functions. It also accepts definitions in any namespace since pluginsync
+  # places all of them in the same directory.
+  #
+  def self.cached_loader_from(parent_loader, loaders)
+    LibRootedFileBased.new(parent_loader,
+      loaders,
+      NAMESPACE_WILDCARD,
+      Puppet[:libdir],
+      'cached_puppet_lib',
+      [:func_4x, :datatype]
+    )
+  end
+
   def self.system_loader_from(parent_loader, loaders)
     # Puppet system may be installed in a fixed location via RPM, installed as a Gem, via source etc.
     # The only way to find this across the different ways puppet can be installed is
@@ -31,7 +49,7 @@ module ModuleLoaders
                                                        nil,
                                                        puppet_lib,   # may or may not have a 'lib' above 'puppet'
                                                        'puppet_system',
-                                                        [:func_4x, :datatype]   # only load ruby functions and types from "puppet"
+                                                        [:func_4x, :func_3x, :datatype]   # only load ruby functions and types from "puppet"
                                                        )
   end
 
@@ -82,9 +100,10 @@ module ModuleLoaders
 
   class AbstractPathBasedModuleLoader < BaseLoader
 
-    # The name of the module, or nil, if this is a global "component"
+    # The name of the module, or nil, if this is a global "component", or "any module" if set to the `NAMESPACE_WILDCARD` (*)
     attr_reader :module_name
 
+
     # The path to the location of the module/component - semantics determined by subclass
     attr_reader :path
 
@@ -169,10 +188,12 @@ module ModuleLoaders
         # The name is in a name space.
 
         # Then entity cannot possible be in this module unless the name starts with the module name.
-        # Note: If "module" represents a "global component", the module_name is nil and cannot match which is
-        # ok since such a "module" cannot have namespaced content).
+        # Note:
+        # * If "module" represents a "global component", the module_name is nil and cannot match which is
+        #   ok since such a "module" cannot have namespaced content).
+        # * If this loader is allowed to have namespaced content, the module_name can be set to NAMESPACE_WILDCARD `*`
         #
-        return nil unless name_parts[0] == module_name
+        return nil unless name_parts[0] == module_name || module_name == NAMESPACE_WILDCARD
       else
         # The name is in the global name space.
 
@@ -203,7 +224,7 @@ module ModuleLoaders
         when :type
           if !global?
             # Global name must be the name of the module
-            unless name_parts[0] == module_name
+            unless name_parts[0] == module_name || module_name == NAMESPACE_WILDCARD
               # Check for ruby defined data type in global namespace before giving up
               origin, smart_path = find_existing_path(typed_name)
               return smart_path.is_a?(LoaderPaths::DataTypePath) ? instantiate(smart_path, typed_name, origin) : nil
@@ -219,9 +240,9 @@ module ModuleLoaders
               return set_entry(typed_name, value, origin)
             end
 
-            #TRANSLATORS 'TypeSet' should not be translated
+            # TRANSLATORS 'TypeSet' should not be translated
             raise ArgumentError, _("The code loaded from %{origin} does not define the TypeSet '%{module_name}'") %
-                { origin: origin, module_name: module_name.capitalize }
+                { origin: origin, module_name: name_parts[0].capitalize }
           end
         else
           # anything else cannot possibly be in this module
@@ -325,7 +346,7 @@ module ModuleLoaders
     # @return [Boolean] `true` if this loader represents a global component
     #
     def global?
-      module_name.nil? || module_name == ENVIRONMENT
+      module_name.nil? || module_name == NAMESPACE_WILDCARD || module_name == ENVIRONMENT
     end
 
     # Answers `true` if the loader used by this instance is rooted beneath 'lib'. This is

data/vendored/puppet/lib/puppet/pops/loader/ruby_legacy_function_instantiator.rb

@@ -0,0 +1,62 @@
+# The RubyLegacyFunctionInstantiator instantiates a Puppet::Functions::Function given the ruby source
+# that calls Puppet::Functions.create_function.
+#
+class Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
+  # Produces an instance of the Function class with the given typed_name, or fails with an error if the
+  # given ruby source does not produce this instance when evaluated.
+  #
+  # @param loader [Puppet::Pops::Loader::Loader] The loader the function is associated with
+  # @param typed_name [Puppet::Pops::Loader::TypedName] the type / name of the function to load
+  # @param source_ref [URI, String] a reference to the source / origin of the ruby code to evaluate
+  # @param ruby_code_string [String] ruby code in a string
+  #
+  # @return [Puppet::Pops::Functions.Function] - an instantiated function with global scope closure associated with the given loader
+  #
+  def self.create(loader, typed_name, source_ref, ruby_code_string)
+    unless ruby_code_string.is_a?(String) && ruby_code_string =~ /Puppet\:\:Parser\:\:Functions.*newfunction/m
+      raise ArgumentError, _("The code loaded from %{source_ref} does not seem to be a Puppet 3x API function - no 'newfunction' call.") % { source_ref: source_ref }
+    end
+    # make the private loader available in a binding to allow it to be passed on
+    loader_for_function = loader.private_loader
+    here = get_binding(loader_for_function)
+
+    # Avoid reloading the function if already loaded via one of the APIs that trigger 3x function loading
+    # Check if function is already loaded the 3x way (and obviously not the 4x way since we would not be here in the
+    # first place.
+    environment = Puppet.lookup(:current_environment)
+    func_info = Puppet::Parser::Functions.environment_module(environment).get_function_info(typed_name.name.to_sym)
+    if func_info.nil?
+      # This will to do the 3x loading and define the "function_<name>" and "real_function_<name>" methods
+      # in the anonymous module used to hold function definitions.
+      #
+      func_info = eval(ruby_code_string, here, source_ref, 1)
+
+      # Validate what was loaded
+      unless func_info.is_a?(Hash)
+        raise ArgumentError, _("The code loaded from %{source_ref} did not produce the expected 3x function info Hash when evaluated. Got '%{klass}'") % { source_ref: source_ref, klass: created.class }
+      end
+      unless func_info[:name] == "function_#{typed_name.name()}"
+        raise ArgumentError, _("The code loaded from %{source_ref} produced mis-matched name, expected 'function_%{type_name}', got %{created_name}") % { 
+          source_ref: source_ref, type_name: typed_name.name, created_name: func_info[:name] }
+      end
+    end
+
+    created = Puppet::Functions::Function3x.create_function(typed_name.name(), func_info, loader_for_function)
+
+    # create the function instance - it needs closure (scope), and loader (i.e. where it should start searching for things
+    # when calling functions etc.
+    # It should be bound to global scope
+
+    # Sets closure scope to nil, to let it be picked up at runtime from Puppet.lookup(:global_scope)
+    # If function definition used the loader from the binding to create a new loader, that loader wins
+    created.new(nil, loader_for_function)
+  end
+
+  # Produces a binding where the given loader is bound as a local variable (loader_injected_arg). This variable can be used in loaded
+  # ruby code - e.g. to call Puppet::Function.create_loaded_function(:name, loader,...)
+  #
+  def self.get_binding(loader_injected_arg)
+    binding
+  end
+  private_class_method :get_binding
+end

data/vendored/puppet/lib/puppet/pops/loader/static_loader.rb

@@ -7,7 +7,6 @@ class StaticLoader < Loader
 
   BUILTIN_TYPE_NAMES = %w{
       Component
-      Cron
       Exec
       File
       Filebucket

data/vendored/puppet/lib/puppet/pops/loader/task_instantiator.rb

@@ -1,58 +1,9 @@
 # The TypeDefinitionInstantiator instantiates a type alias or a type definition
 #
+require 'puppet/module/task'
 module Puppet::Pops
 module Loader
 class TaskInstantiator
-  def self.load_metadata(loader, metadata)
-    if metadata.nil?
-      EMPTY_HASH
-    else
-      json_text = loader.get_contents(metadata)
-      begin
-        Puppet::Util::Json.load(json_text).freeze || EMPTY_HASH
-      rescue Puppet::Util::Json::ParseError => ex
-        raise Puppet::ParseError.new(ex.message, metadata)
-      end
-    end
-  end
-
-  def self.validate_implementations(typed_name, directory, metadata, executables)
-    name = typed_name.name
-    basename = typed_name.name_parts[1] || 'init'
-    # If 'implementations' is defined, it needs to mention at least one
-    # implementation, and everything it mentions must exist.
-    if metadata.key?('implementations')
-      if metadata['implementations'].is_a?(Array)
-        metadata['implementations'].map do |impl|
-          path = executables.find { |real_impl| File.basename(real_impl) == impl['name'] }
-          if path
-            { "name" => impl['name'], "requirements" => impl.fetch('requirements', []), "path" => path }
-          else
-            raise ArgumentError, _("Task metadata for task %{name} specifies missing implementation %{implementation}") %
-              { name: name, implementation: impl['name'] }
-          end
-        end
-      else
-        # If 'implementations' is the wrong type, we just pass it through and
-        # let the task type definition reject it.
-        metadata['implementations']
-      end
-    # If implementations isn't defined, then we use executables matching the
-    # task name, and only one may exist.
-    else
-      implementations = executables.select { |impl| File.basename(impl, '.*') == basename }
-      if implementations.empty?
-        raise ArgumentError, _('No source besides task metadata was found in directory %{directory} for task %{name}') %
-          { name: name, directory: directory }
-      elsif implementations.length > 1
-        raise ArgumentError, _("Multiple executables were found in directory %{directory} for task %{name}; define 'implementations' in metadata to differentiate between them") %
-          { name: name, directory: implementations[0] }
-      end
-
-      [{ "name" => File.basename(implementations.first), "path" => implementations.first, "requirements" => [] }]
-    end
-  end
-
   def self.create(loader, typed_name, source_refs)
     name = typed_name.name
     basename = typed_name.name_parts[1] || 'init'
@@ -60,31 +11,16 @@ class TaskInstantiator
     metadata_files, executables = source_refs.partition { |source_ref| source_ref.end_with?('.json') }
     metadata_file = metadata_files.find { |source_ref| File.basename(source_ref, '.json') == basename }
 
-    metadata = load_metadata(loader, metadata_file)
+    metadata = Puppet::Module::Task.read_metadata(metadata_file) || {}
 
-    implementation_metadata = validate_implementations(typed_name, dirname, metadata, executables)
+    files = Puppet::Module::Task.find_files(name, dirname, metadata, executables)
 
-    arguments = {
-      'name' => name,
-      'implementations' => implementation_metadata
-    }
+    task = { 'name' => name, 'metadata' => metadata, 'files' => files }
 
     begin
-      metadata.each_pair do |key, value|
-        if %w[parameters output].include?(key)
-          ps = {}
-          value.each_pair do |k, v|
-            pd = v.dup
-            t = v['type']
-            pd['type'] = t.nil? ? Types::TypeFactory.data : Types::TypeParser.singleton.parse(t)
-            ps[k] = pd
-          end
-          value = ps
-        end
-        arguments[key] = value unless arguments.key?(key)
-      end
+      task['parameters'] = convert_types(metadata['parameters'])
 
-      Types::TypeFactory.task.from_hash(arguments)
+      Types::TypeFactory.task.from_hash(task)
     rescue Types::TypeAssertionError => ex
       # Not strictly a parser error but from the users perspective, the file content didn't parse properly. The
       # ParserError also conveys file info (even though line is unknown)
@@ -92,6 +28,13 @@ class TaskInstantiator
       raise Puppet::ParseError.new(msg, metadata_file)
     end
   end
+
+  def self.convert_types(args)
+    args.each_with_object({}) do |(k, v), hsh|
+      hsh[k] = v['type'].nil? ? Types::TypeFactory.data : Types::TypeParser.singleton.parse(v['type'])
+    end if args
+  end
+  private_class_method :convert_types
 end
 end
 end

data/vendored/puppet/lib/puppet/pops/loaders.rb

@@ -13,6 +13,7 @@ class Loaders
 
   attr_reader :static_loader
   attr_reader :puppet_system_loader
+  attr_reader :puppet_cache_loader
   attr_reader :public_environment_loader
   attr_reader :private_environment_loader
   attr_reader :environment
@@ -43,20 +44,21 @@ class Loaders
     #
     @puppet_system_loader = create_puppet_system_loader()
 
-    # 2. Environment loader - i.e. what is bound across the environment, may change for each setup
+    # 2. Cache loader(optional) - i.e. what puppet stores on disk via pluginsync; gate behind the for_agent flag.
+    # 3. Environment loader - i.e. what is bound across the environment, may change for each setup
     #    TODO: loaders need to work when also running in an agent doing catalog application. There is no
     #    concept of environment the same way as when running as a master (except when doing apply).
     #    The creation mechanisms should probably differ between the two.
-    #
     @private_environment_loader = if for_agent
-      add_loader_by_name(Loader::SimpleEnvironmentLoader.new(@puppet_system_loader, 'agent environment'))
+      @puppet_cache_loader = create_puppet_cache_loader()
+      create_environment_loader(environment, @puppet_cache_loader)
     else
-      create_environment_loader(environment)
+      create_environment_loader(environment, @puppet_system_loader)
     end
 
     Pcore.init_env(@private_environment_loader)
 
-    # 3. module loaders are set up from the create_environment_loader, they register themselves
+    # 4. module loaders are set up from the create_environment_loader, they register themselves
   end
 
   # Called after loader has been added to Puppet Context as :loaders so that dynamic types can
@@ -354,7 +356,11 @@ class Loaders
     Loader::ModuleLoaders.system_loader_from(static_loader, self)
   end
 
-  def create_environment_loader(environment)
+  def create_puppet_cache_loader()
+    Loader::ModuleLoaders.cached_loader_from(puppet_system_loader, self)
+  end
+
+  def create_environment_loader(environment, parent_loader)
     # This defines where to start parsing/evaluating - the "initial import" (to use 3x terminology)
     # Is either a reference to a single .pp file, or a directory of manifests. If the environment becomes
     # a module and can hold functions, types etc. then these are available across all other modules without
@@ -375,11 +381,11 @@ class Loaders
     env_path = env_conf.nil? || !env_conf.is_a?(Puppet::Settings::EnvironmentConf) ? nil : env_conf.path_to_env
 
     if Puppet[:tasks]
-      loader = Loader::ModuleLoaders.environment_loader_from(puppet_system_loader, self, env_path)
+      loader = Loader::ModuleLoaders.environment_loader_from(parent_loader, self, env_path)
     else
       # Create the 3.x resource type loader
       static_loader.runtime_3_init
-      @runtime3_type_loader = add_loader_by_name(Loader::Runtime3TypeLoader.new(puppet_system_loader, self, environment, env_conf.nil? ? nil : env_path))
+      @runtime3_type_loader = add_loader_by_name(Loader::Runtime3TypeLoader.new(parent_loader, self, environment, env_conf.nil? ? nil : env_path))
 
       if env_path.nil?
         # Not a real directory environment, cannot work as a module TODO: Drop when legacy env are dropped?
@@ -503,8 +509,8 @@ class Loaders
         nil
       else
         module_data.private_loader =
-          if module_data.restrict_to_dependencies? && !Puppet[:tasks]
-            create_loader_with_only_dependencies_visible(module_data)
+          if module_data.restrict_to_dependencies?
+            create_loader_with_dependencies_first(module_data)
           else
             create_loader_with_all_modules_visible(module_data)
           end
@@ -514,29 +520,13 @@ class Loaders
     private
 
     def create_loader_with_all_modules_visible(from_module_data)
-      Puppet.debug{"ModuleLoader: module '#{from_module_data.name}' has unknown dependencies - it will have all other modules visible"}
-
       @loaders.add_loader_by_name(Loader::DependencyLoader.new(from_module_data.public_loader, "#{from_module_data.name} private", all_module_loaders()))
     end
 
-    def create_loader_with_only_dependencies_visible(from_module_data)
-      if from_module_data.unmet_dependencies?
-        if Puppet[:strict] != :off
-          msg = "ModuleLoader: module '#{from_module_data.name}' has unresolved dependencies" \
-              " - it will only see those that are resolved." \
-              " Use 'puppet module list --tree' to see information about modules"
-          case Puppet[:strict]
-          when :error
-              raise LoaderError.new(msg)
-          when :warning
-            Puppet.warn_once(:unresolved_module_dependencies,
-                             "unresolved_dependencies_for_module_#{from_module_data.name}",
-                             msg)
-          end
-        end
-      end
+    def create_loader_with_dependencies_first(from_module_data)
       dependency_loaders = from_module_data.dependency_names.collect { |name| @index[name].public_loader }
-      @loaders.add_loader_by_name(Loader::DependencyLoader.new(from_module_data.public_loader, "#{from_module_data.name} private", dependency_loaders))
+      visible_loaders = dependency_loaders + (all_module_loaders() - dependency_loaders)
+      @loaders.add_loader_by_name(Loader::DependencyLoader.new(from_module_data.public_loader, "#{from_module_data.name} private", visible_loaders))
     end
   end
 end