puppet 4.5.3-universal-darwin → 4.6.1-universal-darwin

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

@@ -5,6 +5,61 @@ 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
+      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
+
   attr_reader :loaded
   def initialize
     @loaded = {}

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

@@ -41,13 +41,13 @@ class TypeDefinitionInstantiator
     # 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 = private_loader
-    create_type(type_definition, 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 = Loader::TypedName.new(:type, type_definition.name.downcase)
-    type = create_type(type_definition, loader)
+    typed_name = TypedName.new(:type, type_definition.name.downcase)
+    type = create_runtime_type(type_definition)
     loader.set_entry(
       typed_name,
       type,
@@ -55,23 +55,39 @@ class TypeDefinitionInstantiator
     type
   end
 
-  def self.create_type(type_definition, loader)
-    type_expr = type_definition.type_expr
-    name = type_definition.name
-    if object_definition?(type_expr)
+  # @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
-      i12n_hash_expr = type_expr.keys.empty? ? nil : type_expr.keys[0]
-      Types::PObjectType.new(name, i12n_hash_expr)
+      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
-  private_class_method :create_type
 
-  def self.object_definition?(te)
-    te.is_a?(Model::AccessExpression) && (left = te.left_expr).is_a?(Model::QualifiedReference) && left.cased_value == 'Object'
+  # @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
-  private_class_method :object_definition?
 end
 end
 end

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

@@ -0,0 +1,50 @@
+module Puppet::Pops
+module Loader
+# A namespace/name/type combination that can be used as a compound hash key
+#
+# @api public
+class TypedName
+  DOUBLE_COLON = '::'.freeze
+
+  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)
+    @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? ==
+
+  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,4 +1,13 @@
 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
 
@@ -8,7 +17,22 @@ class Loaders
   attr_reader :private_environment_loader
   attr_reader :implementation_registry
 
+  def self.new(environment)
+    obj = environment.loaders
+    if obj.nil?
+      obj = self.allocate
+      obj.send(:initialize, environment)
+    end
+    obj
+  end
+
   def initialize(environment)
+    # Protect against environment havoc
+    raise ArgumentError.new("Attempt to redefine already initialized loaders for environment") unless environment.loaders.nil?
+    environment.loaders = self
+    @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
@@ -60,17 +84,17 @@ class Loaders
     loaders.nil? ? nil : loaders.implementation_registry
   end
 
-  def register_implementations(*obj_classes)
+  def register_implementations(obj_classes, name_authority)
     loader = @private_environment_loader
     types = obj_classes.map do |obj_class|
       type = obj_class._ptype
-      typed_name = Loader::Loader::TypedName.new(:type, type.name.downcase)
+      typed_name = Loader::TypedName.new(:type, type.name.downcase, name_authority)
       entry = loader.loaded_entry(typed_name)
       loader.set_entry(typed_name, type, obj_class._plocation) if entry.nil? || entry.value.nil?
       type
     end
-    # Resolve lazy so that all types can cross reference eachother
-    parser = Types::TypeParser.new
+    # Resolve lazy so that all types can cross reference each other
+    parser = Types::TypeParser.singleton
     types.each { |type| type.resolve(parser, loader) }
   end
 
@@ -85,7 +109,7 @@ class Loaders
     unless loaders.nil?
       name = name.to_s
       caps_name = Types::TypeFormatter.singleton.capitalize_segments(name)
-      typed_name = Loader::Loader::TypedName.new(:type, name.downcase)
+      typed_name = Loader::TypedName.new(:type, name.downcase)
       loaders.runtime3_type_loader.set_entry(typed_name, Types::PResourceType.new(caps_name), origin)
     end
     nil
@@ -102,6 +126,21 @@ class Loaders
     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}'" 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.
   #
@@ -160,6 +199,12 @@ class 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()
@@ -183,19 +228,20 @@ class Loaders
     # 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)
+    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 = Loader::Runtime3TypeLoader.new(puppet_system_loader, environment)
+    @runtime3_type_loader = add_loader_by_name(Loader::Runtime3TypeLoader.new(puppet_system_loader, self, environment, env_conf.nil? ? nil : env_path))
 
-    if env_conf.nil? || !env_conf.is_a?(Puppet::Settings::EnvironmentConf)
+    if env_path.nil?
       # Not a real directory environment, cannot work as a module TODO: Drop when legacy env are dropped?
-      loader = Loader::SimpleEnvironmentLoader.new(@runtime3_type_loader, loader_name)
+      loader = add_loader_by_name(Loader::SimpleEnvironmentLoader.new(@runtime3_type_loader, loader_name))
     else
       # View the environment as a module to allow loading from it - this module is always called 'environment'
-      loader = Loader::ModuleLoaders.module_loader_from(@runtime3_type_loader, self, 'environment', env_conf.path_to_env)
+      loader = Loader::ModuleLoaders.module_loader_from(@runtime3_type_loader, self, 'environment', env_path)
     end
 
     # An environment has a module path even if it has a null loader
@@ -206,7 +252,7 @@ class 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 = Loader::DependencyLoader.new(loader, "environment", @module_resolver.all_module_loaders())
+    loader = add_loader_by_name(Loader::DependencyLoader.new(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.
@@ -217,7 +263,7 @@ class 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)
@@ -239,7 +285,6 @@ class Loaders
   #
   class LoaderModuleData
 
-    attr_accessor :state
     attr_accessor :public_loader
     attr_accessor :private_loader
     attr_accessor :resolutions
@@ -250,7 +295,6 @@ class 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
@@ -270,7 +314,7 @@ class Loaders
     end
 
     def resolved?
-      @state == :resolved
+      !@private_loader.nil?
     end
 
     def restrict_to_dependencies?
@@ -290,7 +334,8 @@ class Loaders
   #
   class ModuleResolver
 
-    def initialize()
+    def initialize(loaders)
+      @loaders = loaders
       @index = {}
       @all_module_loaders = nil
     end
@@ -309,7 +354,7 @@ class Loaders
 
     def resolve(module_data)
       if module_data.resolved?
-        return
+        nil
       else
         module_data.private_loader =
           if module_data.restrict_to_dependencies?
@@ -325,7 +370,7 @@ class 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"}
 
-      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)
@@ -345,7 +390,7 @@ class Loaders
         end
       end
       dependency_loaders = from_module_data.dependency_names.collect { |name| @index[name].public_loader }
-      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

data/lib/puppet/pops/merge_strategy.rb

@@ -8,7 +8,7 @@ module Puppet::Pops
 
     # The type used for validation of the _merge_ argument
     def self.merge_t
-      @@merge_t ||=  Types::TypeParser.new.parse("Variant[String[1],Runtime[ruby,'Symbol'],Hash[Variant[String[1],Runtime[ruby,'Symbol']],Scalar,1]]")
+      @@merge_t ||=  Types::TypeParser.singleton.parse("Variant[String[1],Runtime[ruby,'Symbol'],Hash[Variant[String[1],Runtime[ruby,'Symbol']],Scalar,1]]")
     end
     private_class_method :merge_t
 
@@ -123,7 +123,7 @@ module Puppet::Pops
       result
     end
 
-    # Converts a single value to the type expeced when peforming a merge of two elements
+    # Converts a single value to the type expected when merging two elements
     # @param value [Object] the value to convert
     # @return [Object] the converted value
     def convert_value(value)
@@ -149,7 +149,7 @@ module Puppet::Pops
     # @return [Types::PStructType] the puppet type
     #
     def options_t
-      @options_t ||=Types::TypeParser.new.parse("Struct[{strategy=>Optional[Pattern[#{self.class.key}]]}]")
+      @options_t ||=Types::TypeParser.singleton.parse("Struct[{strategy=>Optional[Pattern[#{self.class.key}]]}]")
     end
 
     # Returns the type used to validate the options hash
@@ -217,7 +217,7 @@ module Puppet::Pops
     protected
 
     def value_t
-      @value_t ||= Types::TypeParser.new.parse('Hash[String,Data]')
+      @value_t ||= Types::TypeParser.singleton.parse('Hash[String,Data]')
     end
 
     MergeStrategy.add_strategy(self)
@@ -249,7 +249,7 @@ module Puppet::Pops
     protected
 
     def value_t
-      @value_t ||= Types::TypeParser.new.parse('Variant[Scalar,Array[Data]]')
+      @value_t ||= Types::TypeParser.singleton.parse('Variant[Scalar,Array[Data]]')
     end
 
     MergeStrategy.add_strategy(self)
@@ -320,7 +320,7 @@ module Puppet::Pops
     #
     # @return [Types::PAnyType] the puppet type used when validating the options hash
     def options_t
-      @options_t ||= Types::TypeParser.new.parse('Struct[{'\
+      @options_t ||= Types::TypeParser.singleton.parse('Struct[{'\
           "strategy=>Optional[Pattern[#{self.class.key}]],"\
           'knockout_prefix=>Optional[String],'\
           'merge_debug=>Optional[Boolean],'\
@@ -330,7 +330,7 @@ module Puppet::Pops
     end
 
     def value_t
-      @value_t ||= Types::TypeParser.new.parse('Variant[Array[Data],Hash[String,Data]]')
+      @value_t ||= Types::TypeParser.singleton.parse('Variant[Array[Data],Hash[String,Data]]')
     end
 
     MergeStrategy.add_strategy(self)

data/lib/puppet/pops/migration/migration_checker.rb

@@ -6,6 +6,10 @@ class Puppet::Pops::Migration::MigrationChecker
   def initialize()
   end
 
+  def self.singleton
+    @null_checker ||= self.new
+  end
+
   # Produces a hash of available migrations; a map from a symbolic name in string form to a brief description.
   # This version has no such supported migrations.
   def available_migrations()