puppet 4.1.0 → 5.0.0

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

@@ -1,12 +1,82 @@
   # Static Loader contains constants, basic data types and other types required for the system
   # to boot.
   #
-class Puppet::Pops::Loader::StaticLoader < Puppet::Pops::Loader::Loader
+module Puppet::Pops
+module Loader
+class StaticLoader < Loader
+
+  BUILTIN_TYPE_NAMES = %w{
+      Auegas
+      Component
+      Computer
+      Cron
+      Exec
+      File
+      Filebucket
+      Group
+      Host
+      Interface
+      K5login
+      Macauthorization
+      Mailalias
+      Maillist
+      Mcx
+      Mount
+      Nagios_command
+      Nagios_contact
+      Nagios_contactgroup
+      Nagios_host
+      Nagios_hostdependency
+      Nagios_hostescalation
+      Nagios_hostgroup
+      Nagios_hostextinfo
+      Nagios_service
+      Nagios_servicedependency
+      Nagios_serviceescalation
+      Nagios_serviceextinfo
+      Nagios_servicegroup
+      Nagios_timeperiod
+      Node
+      Notify
+      Package
+      Resources
+      Router
+      Schedule
+      Scheduled_task
+      Selboolean
+      Selmodule
+      Service
+      Ssh_authorized_key
+      Sshkey
+      Stage
+      Tidy
+      User
+      Vlan
+      Whit
+      Yumrepo
+      Zfs
+      Zone
+      Zpool
+    }.freeze
+
+  BUILTIN_TYPE_NAMES_LC = Set.new(BUILTIN_TYPE_NAMES.map { |n| n.downcase }).freeze
+
+  BUILTIN_ALIASES = {
+    'Data' => 'Variant[ScalarData,Undef,Hash[String,Data],Array[Data]]',
+    'RichDataKey' => 'Variant[String,Numeric]',
+    'RichData' => 'Variant[Scalar,SemVerRange,Binary,Sensitive,Type,TypeSet,Undef,Hash[RichDataKey,RichData],Array[RichData]]',
+
+    # Backward compatible aliases.
+    'Puppet::LookupKey' => 'RichDataKey',
+    'Puppet::LookupValue' => 'RichData'
+  }.freeze
 
   attr_reader :loaded
   def initialize
     @loaded = {}
-    create_logging_functions()
+    create_built_in_types
+    create_resource_type_references
+    register_aliases
   end
 
   def load_typed(typed_name)
@@ -17,6 +87,10 @@ class Puppet::Pops::Loader::StaticLoader < Puppet::Pops::Loader::Loader
     load_constant(typed_name)
   end
 
+  def set_entry(typed_name, value, origin = nil)
+    @loaded[typed_name] = Loader::NamedEntry.new(typed_name, value, origin)
+  end
+
   def find(name)
     # There is nothing to search for, everything this loader knows about is already available
     nil
@@ -29,51 +103,47 @@ class Puppet::Pops::Loader::StaticLoader < Puppet::Pops::Loader::Loader
   def to_s()
     "(StaticLoader)"
   end
-  private
 
-  def load_constant(typed_name)
+  def loaded_entry(typed_name, check_dependencies = false)
     @loaded[typed_name]
   end
 
   private
 
-  # Creates a function for each of the specified log levels
-  #
-  def create_logging_functions()
-    Puppet::Util::Log.levels.each do |level|
-
-      fc = Puppet::Functions.create_function(level) do
-        # create empty dispatcher to stop it from complaining about missing method since
-        # an override of :call is made instead of using dispatch.
-        dispatch(:log) { }
-
-        # Logs per the specified level, outputs formatted information for arrays, hashes etc.
-        # Overrides the implementation in Function that uses dispatching. This is not needed here
-        # since it accepts 0-n Object.
-        #
-        define_method(:call) do |scope, *vals|
-          # NOTE: 3x, does this: vals.join(" ")
-          # New implementation uses the evaluator to get proper formatting per type
-          # TODO: uses a fake scope (nil) - fix when :scopes are available via settings
-          mapped = vals.map {|v| Puppet::Pops::Evaluator::EvaluatorImpl.new.string(v, nil) }
-
-          # Bypass Puppet.<level> call since it picks up source from "self" which is not applicable in the 4x
-          # Function API.
-          # TODO: When a function can obtain the file, line, pos of the call merge those in (3x supports
-          #       options :file, :line. (These were never output when calling the 3x logging functions since
-          #       3x scope does not know about the calling location at that detailed level, nor do they
-          #       appear in a report to stdout/error when included). Now, the output simply uses scope (like 3x)
-          #       as this is good enough, but does not reflect the true call-stack, but is a rough estimate
-          #       of where the logging call originates from).
-          #
-          Puppet::Util::Log.create({:level => level, :source => scope, :message => mapped.join(" ")})
-        end
-      end
-
-      typed_name = Puppet::Pops::Loader::Loader::TypedName.new(:function, level)
-      # TODO:closure scope is fake (an empty hash) - waiting for new global scope to be available via lookup of :scopes
-      func = fc.new({},self)
-      @loaded[ typed_name ] = Puppet::Pops::Loader::Loader::NamedEntry.new(typed_name, func, __FILE__)
+  def load_constant(typed_name)
+    @loaded[typed_name]
+  end
+
+  def create_built_in_types
+    origin_uri = URI("puppet:Puppet-Type-System/Static-Loader")
+    type_map = Puppet::Pops::Types::TypeParser.type_map
+    type_map.each do |name, type|
+      set_entry(TypedName.new(:type, name), type, origin_uri)
     end
   end
+
+  def create_resource_type_references()
+    # These needs to be done quickly and we do not want to scan the file system for these
+    # We are also not interested in their definition only that they exist.
+    # These types are in all environments.
+    #
+    BUILTIN_TYPE_NAMES.each { |name| create_resource_type_reference(name) }
+  end
+
+  def add_type(name, type)
+    set_entry(TypedName.new(:type, name), type)
+    type
+  end
+
+  def create_resource_type_reference(name)
+    add_type(name, Types::TypeFactory.resource(name))
+  end
+
+  def register_aliases
+    aliases = BUILTIN_ALIASES.map { |name, string| add_type(name, Types::PTypeAliasType.new(name, Types::TypeFactory.type_reference(string), nil)) }
+    parser = Types::TypeParser.singleton
+    aliases.each { |type| type.resolve(parser, self) }
+  end
+end
+end
 end

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

@@ -0,0 +1,93 @@
+# The TypeDefinitionInstantiator instantiates a type alias or a type definition
+#
+module Puppet::Pops
+module Loader
+class TypeDefinitionInstantiator
+  def self.create(loader, typed_name, source_ref, pp_code_string)
+    # parse and validate
+    parser = Parser::EvaluatingParser.new()
+    model = parser.parse_string(pp_code_string, source_ref)
+    # Only one type is allowed (and no other definitions)
+
+    name = typed_name.name
+    case model.definitions.size
+    when 0
+      raise ArgumentError, _("The code loaded from %{source_ref} does not define the type '%{name}' - it is empty.") % { source_ref: source_ref, name: name }
+    when 1
+      # ok
+    else
+      raise ArgumentError,
+        _("The code loaded from %{source_ref} must contain only the type '%{name}' - it has additional definitions.") % { source_ref: source_ref, name: name }
+    end
+    type_definition = model.definitions[0]
+
+    unless type_definition.is_a?(Model::TypeAlias) || type_definition.is_a?(Model::TypeDefinition)
+      raise ArgumentError,
+        _("The code loaded from %{source_ref} does not define the type '%{name}' - no type alias or type definition found.") % { source_ref: source_ref, name: name }
+    end
+
+    actual_name = type_definition.name
+    unless name == actual_name.downcase
+      raise ArgumentError,
+        _("The code loaded from %{source_ref} produced type with the wrong name, expected '%{name}', actual '%{actual_name}'") % { source_ref: source_ref, name: name, actual_name: actual_name }
+    end
+
+    unless model.body == type_definition
+      raise ArgumentError,
+        _("The code loaded from %{source_ref} contains additional logic - can only contain the type '%{name}'") % { source_ref: source_ref, name: name }
+    end
+
+    # Adapt the type definition with loader - this is used from logic contained in its body to find the
+    # loader to use when resolving contained aliases API. Such logic have a hard time finding the closure (where
+    # the loader is known - hence this mechanism
+    private_loader = loader.private_loader
+    Adapters::LoaderAdapter.adapt(type_definition).loader_name = private_loader.loader_name
+    create_runtime_type(type_definition)
+  end
+
+  def self.create_from_model(type_definition, loader)
+    typed_name = TypedName.new(:type, type_definition.name)
+    type = create_runtime_type(type_definition)
+    loader.set_entry(
+      typed_name,
+      type,
+      type_definition.locator.to_uri(type_definition))
+    type
+  end
+
+  # @api private
+  def self.create_runtime_type(type_definition)
+    # Using the RUNTIME_NAME_AUTHORITY as the name_authority is motivated by the fact that the type
+    # alias name (managed by the runtime) becomes the name of the created type
+    #
+    create_type(type_definition.name, type_definition.type_expr, Pcore::RUNTIME_NAME_AUTHORITY)
+  end
+
+  # @api private
+  def self.create_type(name, type_expr, name_authority)
+    create_named_type(name, named_definition(type_expr), type_expr, name_authority)
+  end
+
+  # @api private
+  def self.create_named_type(name, type_name, type_expr, name_authority)
+    case type_name
+    when 'Object'
+      # No need for an alias. The Object type itself will receive the name instead
+      type_expr = type_expr.keys.empty? ? nil : type_expr.keys[0] unless type_expr.is_a?(Hash)
+      Types::PObjectType.new(name, type_expr)
+    when 'TypeSet'
+      # No need for an alias. The Object type itself will receive the name instead
+      type_expr = type_expr.keys.empty? ? nil : type_expr.keys[0] unless type_expr.is_a?(Hash)
+      Types::PTypeSetType.new(name, type_expr, name_authority)
+    else
+      Types::PTypeAliasType.new(name, type_expr)
+    end
+  end
+
+  # @api private
+  def self.named_definition(te)
+    te.is_a?(Model::AccessExpression) && (left = te.left_expr).is_a?(Model::QualifiedReference) ? left.cased_value : nil
+  end
+end
+end
+end

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

@@ -0,0 +1,54 @@
+module Puppet::Pops
+module Loader
+# A namespace/name/type combination that can be used as a compound hash key
+#
+# @api public
+class TypedName
+  attr_reader :hash
+  attr_reader :type
+  attr_reader :name_authority
+  attr_reader :name
+  attr_reader :name_parts
+  attr_reader :compound_name
+
+  def initialize(type, name, name_authority = Pcore::RUNTIME_NAME_AUTHORITY)
+    name = name.downcase
+    @type = type
+    @name_authority = name_authority
+    # relativize the name (get rid of leading ::), and make the split string available
+    parts = name.to_s.split(DOUBLE_COLON)
+    if parts[0].empty?
+      parts.shift
+      @name = name[2..-1]
+    else
+      @name = name
+    end
+    @name_parts = parts.freeze
+
+    # Use a frozen compound key for the hash and comparison. Most varying part first
+    @compound_name = "#{@name}/#{@type}/#{@name_authority}".freeze
+    @hash = @compound_name.hash
+    freeze
+  end
+
+  def ==(o)
+    o.class == self.class && o.compound_name == @compound_name
+  end
+
+  alias eql? ==
+
+  # @return the parent of this instance, or nil if this instance is not qualified
+  def parent
+    @name_parts.size > 1 ? self.class.new(@type, @name_parts[0...-1].join(DOUBLE_COLON), @name_authority) : nil
+  end
+
+  def qualified?
+    @name_parts.size > 1
+  end
+
+  def to_s
+    "#{@name_authority}/#{@type}/#{@name}"
+  end
+end
+end
+end

data/lib/puppet/pops/loaders.rb

@@ -1,14 +1,40 @@
-class Puppet::Pops::Loaders
+module Puppet::Pops
+# This is the container for all Loader instances. Each Loader instance has a `loader_name` by which it can be uniquely
+# identified within this container.
+# A Loader can be private or public. In general, code will have access to the private loader associated with the
+# location of the code. It will be parented by a loader that in turn have access to other public loaders that
+# can load only such entries that have been publicly available. The split between public and private is not
+# yet enforced in Puppet.
+#
+# The name of a private loader should always end with ' private'
+#
+class Loaders
   class LoaderError < Puppet::Error; end
 
   attr_reader :static_loader
   attr_reader :puppet_system_loader
   attr_reader :public_environment_loader
   attr_reader :private_environment_loader
+  attr_reader :implementation_registry
+  attr_reader :environment
+
+  def self.new(environment, for_agent = false)
+    obj = environment.loaders
+    if obj.nil?
+      obj = self.allocate
+      obj.send(:initialize, environment, for_agent)
+    end
+    obj
+  end
 
-  def initialize(environment)
-    # The static loader can only be changed after a reboot
-    @@static_loader ||= Puppet::Pops::Loader::StaticLoader.new()
+  def initialize(environment, for_agent)
+    # Protect against environment havoc
+    raise ArgumentError.new(_("Attempt to redefine already initialized loaders for environment")) unless environment.loaders.nil?
+    environment.loaders = self
+    @environment = environment
+    @loaders_by_name = {}
+
+    add_loader_by_name(self.class.static_loader)
 
     # Create the set of loaders
     # 1. Puppet, loads from the "running" puppet - i.e. bundled functions, types, extension points and extensions
@@ -23,26 +49,161 @@ class Puppet::Pops::Loaders
     #    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 = create_environment_loader(environment)
+    @private_environment_loader = if for_agent
+      add_loader_by_name(Loader::SimpleEnvironmentLoader.new(@puppet_system_loader, 'agent environment'))
+    else
+      create_environment_loader(environment)
+    end
+
+    # 3. The implementation registry maintains mappings between Puppet types and Runtime types for
+    #    the current environment
+    @implementation_registry = Types::ImplementationRegistry.new(@private_environment_loader)
+    Pcore.init(@puppet_system_loader, @implementation_registry, for_agent)
 
-    # 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
 
   # Clears the cached static and puppet_system loaders (to enable testing)
   #
   def self.clear
     @@static_loader = nil
-    @puppet_system_loader = nil
+    Model.class_variable_set(:@@pcore_ast_initialized, false)
+    Model.register_pcore_types
+  end
+
+  # Calls {#loaders} to obtain the {{Loaders}} instance and then uses it to find the appropriate loader
+  # for the given `module_name`, or for the environment in case `module_name` is `nil` or empty.
+  #
+  # @param module_name [String,nil] the name of the module
+  # @return [Loader::Loader] the found loader
+  # @raise [Puppet::ParseError] if no loader can be found
+  # @api private
+  def self.find_loader(module_name)
+    loaders.find_loader(module_name)
+  end
+
+  def self.static_loader
+    # The static loader can only be changed after a reboot
+    @@static_loader ||= Loader::StaticLoader.new()
+  end
+
+  def self.implementation_registry
+    loaders = Puppet.lookup(:loaders) { nil }
+    loaders.nil? ? nil : loaders.implementation_registry
+  end
+
+  def register_implementations(obj_classes, name_authority)
+    self.class.register_implementations_with_loader(obj_classes, name_authority, loader = @private_environment_loader)
+  end
+
+  # Register implementations using the global static loader
+  def self.register_static_implementations(obj_classes)
+    register_implementations_with_loader(obj_classes, Pcore::RUNTIME_NAME_AUTHORITY, static_loader)
+  end
+
+  def self.register_implementations_with_loader(obj_classes, name_authority, loader)
+    types = obj_classes.map do |obj_class|
+      type = obj_class._pcore_type
+      typed_name = Loader::TypedName.new(:type, type.name, name_authority)
+      entry = loader.loaded_entry(typed_name)
+      loader.set_entry(typed_name, type) if entry.nil? || entry.value.nil?
+      type
+    end
+    # Resolve lazy so that all types can cross reference each other
+    parser = Types::TypeParser.singleton
+    types.each { |type| type.resolve(parser, loader) }
+  end
+
+  # Register the given type with the Runtime3TypeLoader. The registration will not happen unless
+  # the type system has been initialized.
+  #
+  # @param name [String,Symbol] the name of the entity being set
+  # @param origin [URI] the origin or the source where the type is defined
+  # @api private
+  def self.register_runtime3_type(name, origin)
+    loaders = Puppet.lookup(:loaders) { nil }
+    return nil if loaders.nil?
+
+    rt3_loader = loaders.runtime3_type_loader
+    return nil if rt3_loader.nil?
+
+    name = name.to_s
+    caps_name = Types::TypeFormatter.singleton.capitalize_segments(name)
+    typed_name = Loader::TypedName.new(:type, name)
+    rt3_loader.set_entry(typed_name, Types::PResourceType.new(caps_name), origin)
+    nil
+  end
+
+  # Finds a loader to use when deserializing a catalog and then subsequenlty use user
+  # defined types found in that catalog.
+  #
+  def self.catalog_loader
+    loaders = Puppet.lookup(:loaders) { nil }
+    if loaders.nil?
+      loaders = Loaders.new(Puppet.lookup(:current_environment), true)
+      Puppet.push_context(:loaders => loaders)
+    end
+    loaders.find_loader(nil)
+  end
+
+  # Finds the `Loaders` instance by looking up the :loaders in the global Puppet context
+  #
+  # @return [Loaders] the loaders instance
+  # @raise [Puppet::ParseError] if loader has been bound to the global context
+  # @api private
+  def self.loaders
+    loaders = Puppet.lookup(:loaders) { nil }
+    raise Puppet::ParseError, "Internal Error: Puppet Context ':loaders' missing" if loaders.nil?
+    loaders
+  end
+
+  # Lookup a loader by its unique name.
+  #
+  # @param [String] loader_name the name of the loader to lookup
+  # @return [Loader] the found loader
+  # @raise [Puppet::ParserError] if no loader is found
+  def [](loader_name)
+    loader = @loaders_by_name[loader_name]
+    if loader.nil?
+      # Unable to find the module private loader. Try resolving the module
+      loader = private_loader_for_module(loader_name[0..-9]) if loader_name.end_with?(' private')
+      raise Puppet::ParseError, _("Unable to find loader named '%{loader_name}'") % { loader_name: loader_name } if loader.nil?
+    end
+    loader
+  end
+
+  # Finds the appropriate loader for the given `module_name`, or for the environment in case `module_name`
+  # is `nil` or empty.
+  #
+  # @param module_name [String,nil] the name of the module
+  # @return [Loader::Loader] the found loader
+  # @raise [Puppet::ParseError] if no loader can be found
+  # @api private
+  def find_loader(module_name)
+    if module_name.nil? || EMPTY_STRING == module_name
+      # Use the public environment loader
+      public_environment_loader
+    else
+      # TODO : Later check if definition is private, and then add it to private_loader_for_module
+      #
+      loader = public_loader_for_module(module_name)
+      raise Puppet::ParseError, "Internal Error: did not find public loader for module: '#{module_name}'" if loader.nil?
+      loader
+    end
   end
 
   def static_loader
-    @@static_loader
+    self.class.static_loader
   end
 
   def puppet_system_loader
     @puppet_system_loader
   end
 
+  def runtime3_type_loader
+    @runtime3_type_loader
+  end
+
   def public_loader_for_module(module_name)
     md = @module_resolver[module_name] || (return nil)
     # Note, this loader is not resolved until there is interest in the visibility of entities from the
@@ -63,10 +224,16 @@ class Puppet::Pops::Loaders
     md.private_loader
   end
 
+  def add_loader_by_name(loader)
+    name = loader.loader_name
+    raise Puppet::ParseError, "Internal Error: Attempt to redefine loader named '#{name}'" if @loaders_by_name.include?(name)
+    @loaders_by_name[name] = loader
+  end
+
   private
 
   def create_puppet_system_loader()
-    Puppet::Pops::Loader::ModuleLoaders.system_loader_from(static_loader, self)
+    Loader::ModuleLoaders.system_loader_from(static_loader, self)
   end
 
   def create_environment_loader(environment)
@@ -85,16 +252,19 @@ class Puppet::Pops::Loaders
     # available modules. (3x is everyone sees everything).
     # Puppet binder currently reads confdir/bindings - that is bad, it should be using the new environment support.
 
-    # The environment is not a namespace, so give it a nil "module_name"
-    module_name = nil
-    loader_name = "environment:#{environment.name}"
+    # env_conf is setup from the environment_dir value passed into Puppet::Environments::Directories.new
     env_conf = Puppet.lookup(:environments).get_conf(environment.name)
-    if env_conf.nil? || !env_conf.is_a?(Puppet::Settings::EnvironmentConf)
+    env_path = env_conf.nil? || !env_conf.is_a?(Puppet::Settings::EnvironmentConf) ? nil : env_conf.path_to_env
+
+    # Create the 3.x resource type loader
+    @runtime3_type_loader = add_loader_by_name(Loader::Runtime3TypeLoader.new(puppet_system_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?
-      loader = Puppet::Pops::Loader::SimpleEnvironmentLoader.new(puppet_system_loader, loader_name)
+      loader = add_loader_by_name(Loader::SimpleEnvironmentLoader.new(@runtime3_type_loader, Loader::ENVIRONMENT))
     else
       # View the environment as a module to allow loading from it - this module is always called 'environment'
-      loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(puppet_system_loader, self, 'environment', env_conf.path_to_env)
+      loader = Loader::ModuleLoaders.environment_loader_from(@runtime3_type_loader, self, env_path)
     end
 
     # An environment has a module path even if it has a null loader
@@ -105,7 +275,7 @@ class Puppet::Pops::Loaders
     # Code in the environment gets to see all modules (since there is no metadata for the environment)
     # but since this is not given to the module loaders, they can not load global code (since they can not
     # have prior knowledge about this
-    loader = Puppet::Pops::Loader::DependencyLoader.new(loader, "environment", @module_resolver.all_module_loaders())
+    loader = add_loader_by_name(Loader::DependencyLoader.new(loader, Loader::ENVIRONMENT_PRIVATE, @module_resolver.all_module_loaders()))
 
     # The module loader gets the private loader via a lazy operation to look up the module's private loader.
     # This does not work for an environment since it is not resolved the same way.
@@ -116,12 +286,12 @@ class Puppet::Pops::Loaders
   end
 
   def configure_loaders_for_modules(parent_loader, environment)
-    @module_resolver = mr = ModuleResolver.new()
+    @module_resolver = mr = ModuleResolver.new(self)
     environment.modules.each do |puppet_module|
       # Create data about this module
       md = LoaderModuleData.new(puppet_module)
       mr[puppet_module.name] = md
-      md.public_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(parent_loader, self, md.name, md.path)
+      md.public_loader = Loader::ModuleLoaders.module_loader_from(parent_loader, self, md.name, md.path)
     end
     # NOTE: Do not resolve all modules here - this is wasteful if only a subset of modules / functions are used
     #       The resolution is triggered by asking for a module's private loader, since this means there is interest
@@ -138,7 +308,6 @@ class Puppet::Pops::Loaders
   #
   class LoaderModuleData
 
-    attr_accessor :state
     attr_accessor :public_loader
     attr_accessor :private_loader
     attr_accessor :resolutions
@@ -149,7 +318,6 @@ class Puppet::Pops::Loaders
     # @param puppet_module [Puppet::Module] the module instance for the module being represented
     #
     def initialize(puppet_module)
-      @state = :initial
       @puppet_module = puppet_module
       @resolutions = []
       @public_loader = nil
@@ -169,7 +337,7 @@ class Puppet::Pops::Loaders
     end
 
     def resolved?
-      @state == :resolved
+      !@private_loader.nil?
     end
 
     def restrict_to_dependencies?
@@ -189,7 +357,8 @@ class Puppet::Pops::Loaders
   #
   class ModuleResolver
 
-    def initialize()
+    def initialize(loaders)
+      @loaders = loaders
       @index = {}
       @all_module_loaders = nil
     end
@@ -208,7 +377,7 @@ class Puppet::Pops::Loaders
 
     def resolve(module_data)
       if module_data.resolved?
-        return
+        nil
       else
         module_data.private_loader =
           if module_data.restrict_to_dependencies?
@@ -224,17 +393,28 @@ class Puppet::Pops::Loaders
     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"}
 
-      Puppet::Pops::Loader::DependencyLoader.new(from_module_data.public_loader, from_module_data.name, all_module_loaders())
+      @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?
-        Puppet.warning("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")
+        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
       dependency_loaders = from_module_data.dependency_names.collect { |name| @index[name].public_loader }
-      Puppet::Pops::Loader::DependencyLoader.new(from_module_data.public_loader, from_module_data.name, dependency_loaders)
+      @loaders.add_loader_by_name(Loader::DependencyLoader.new(from_module_data.public_loader, "#{from_module_data.name} private", dependency_loaders))
     end
   end
 end
+end