(maint) Refactor call paths for loading resource types

This commit:
* Adds Puppet::Pops::Evaluator::Runtime3ResourceSupport - a module
  with helper methods for loading / finding resource types,
  resources and hostclasses.
* Changes calls to various Scope methods to use the new resoure
  support.
* Refactors calls to known_resource_types to always go to environment
  instead of via Scope (or elsewhere).
* Adds Puppet::Pops::Resource namespace with WIP for resource_impl, and 
  param (to be loaded from Pcore), and the type implementation
  Puppet::Pops::Resource::ResourceTypeImpl.
* Adds module Puppet::CompilableResourceType as a module common to
  both implementations of resource type (Puppet::Type, and 
  Puppet::Pops::Resource::ResourceTypeImpl).
* A WIP Mocking Type (to be removed when real implementation is ready)
* The `create_resources` function is modified as it used AST::Resource 
  to do its work.
* The `defined` function made calls to Scope methods that are now moved 
  to Runtime3ResourceSupport.
* Runtime3Support is modified to use Runtime3ResourceSupport instead of 
  directly containing the methods for resource search and creation.
* Runtime3Support now adds to the puppet call stack when calling a 
  function from puppet logic.
* Puppet::Resource is modified to use CompilableResource and adjusted to 
  work with the API Puppet::Pops::Resource::ResourceTypeImpl.
* Puppet::Type is modified to compare against CompilableResourceType 
  instead of just Puppet::Type (this is important for ordering)
* The `create_resources` function and spec is modified as error messages 
  were improved, and because of the inclusion of a puppet call stack, 
  the created resources now gets file/line information.

Author: hlindberg

lib/puppet.rb

@@ -273,6 +273,7 @@ def self.rollback_context(name)
 #  effort, but I think we should strive for it and revisit this at some point.  --cprice 2012-03-16
 
 require 'puppet/indirector'
+require 'puppet/compilable_resource_type'
 require 'puppet/type'
 require 'puppet/resource'
 require 'puppet/parser'

lib/puppet/compilable_resource_type.rb

@@ -0,0 +1,15 @@
+require 'puppet'
+# The CompilableResourceType module should be either included in a class or used as a class extension
+# to mark that the instance used as the 'resource type' of a resource instance
+# is an object that is compatible with Puppet::Type's API wrt. compiling.
+# Puppet Resource Types written in Ruby use a meta programmed Ruby Class as the type. Those classes
+# are subtypes of Puppet::Type. Meta data (Pcore/puppet language) based resource types uses instances of
+# a class instead.
+# 
+module Puppet::CompilableResourceType
+  # All 3.x resource types implemented in Ruby using Puppet::Type respond true.
+  # Other kinds of implementations should reimplement and return false.
+  def is_3x_ruby_plugin?
+    true
+  end
+end

lib/puppet/functions/defined.rb

@@ -105,6 +105,7 @@
   end
 
   def is_defined(scope, *vals)
+    env = scope.environment
     vals.any? do |val|
       case val
       when String
@@ -116,11 +117,11 @@ def is_defined(scope, *vals)
             next nil
           when 'main'
             # Find the main class (known as ''), it does not have to be in the catalog
-            scope.environment.known_resource_types.find_hostclass('')
+            Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_main_class(env)
           else
             # Find a resource type, definition or class definition
             krt = scope.environment.known_resource_types
-            scope.find_resource_type(val) || krt.find_definition(val) || krt.find_hostclass(val)
+            Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type_or_class(env, val)
           end
         end
       when Puppet::Resource
@@ -130,7 +131,7 @@ def is_defined(scope, *vals)
       when Puppet::Pops::Types::PResourceType
         raise ArgumentError, 'The given resource type is a reference to all kind of types' if val.type_name.nil?
         if val.title.nil?
-          scope.find_builtin_resource_type(val.type_name) || scope.environment.known_resource_types.find_definition(val.type_name)
+          Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(env, val.type_name)
         else
           scope.compiler.findresource(val.type_name, val.title)
         end
@@ -151,7 +152,8 @@ def is_defined(scope, *vals)
           # (this is the same as asking for just the class' name, but with the added certainty that it cannot be a defined type.
           #
           raise  ArgumentError, 'The given class type is a reference to all classes' if val.type.class_name.nil?
-          scope.environment.known_resource_types.find_hostclass(val.type.class_name)
+          Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_hostclass(env, val.type.class_name)
+          #scope.environment.known_resource_types.find_hostclass(val.type.class_name)
         end
       else
         raise ArgumentError, "Invalid argument of type '#{val.class}' to 'defined'"

lib/puppet/metatype/manager.rb

@@ -183,13 +183,13 @@ def type(name)
   # Defaults to an instance of {Puppet::Util::Autoload} if no other auto loader has been set.
   # @return [Puppet::Util::Autoload] the loader to use.
   # @api private
-  def typeloader
-    unless defined?(@typeloader)
-      @typeloader = Puppet::Util::Autoload.new(self, "puppet/type")
-    end
-
-    @typeloader
+def typeloader
+  unless defined?(@typeloader)
+    @typeloader = Puppet::Util::Autoload.new(self, "puppet/type")
   end
+
+  @typeloader
+end
 end
 end
 

lib/puppet/parser/functions/create_resources.rb

@@ -53,35 +53,46 @@
     raise ArgumentError, ('create_resources(): third argument, if provided, must be a hash') unless args[2].is_a?(Hash)
   end
 
-
   type, instances, defaults = args
   defaults ||= {}
-
-  resource = Puppet::Parser::AST::Resource.new(:type => type.sub(/^@{1,2}/, '').downcase, :instances =>
-    instances.collect do |title, params|
-      Puppet::Parser::AST::ResourceInstance.new(
-        :title => Puppet::Parser::AST::Leaf.new(:value => title),
-        :parameters => defaults.merge(params).collect do |name, value|
-          next if (value == :undef || value.nil?)
-          Puppet::Parser::AST::ResourceParam.new(
-            :param => name,
-            :value => Puppet::Parser::AST::Leaf.new(:value => value))
-        end.compact)
-    end)
+  type_name = type.sub(/^@{1,2}/, '').downcase
+
+  # Get file/line information from the puppet stack (where call comes from in puppet source)
+  # If relayed via other puppet functions in ruby that do not nest their calls, the source position
+  # will be in the original puppet source.
+  #
+  stacktrace = Puppet::Pops::PuppetStack.stacktrace()
+  if stacktrace.size > 0
+    file, line = stacktrace[0]
+  else
+    file = nil
+    line = nil
+  end
 
   if type.start_with? '@@'
-    resource.exported = true
+    exported = true
   elsif type.start_with? '@'
-    resource.virtual = true
+    virtual = true
   end
 
-  begin
-    resource.safeevaluate(self)
-  rescue Puppet::ParseError => internal_error
-    if internal_error.original.nil?
-      raise internal_error
-    else
-      raise internal_error.original
-    end
-  end
+  instances.map do |title, params|
+    # Add support for iteration if title is an array
+    resource_titles = title.is_a?(Array) ? title  : [title]
+    Puppet::Pops::Evaluator::Runtime3ResourceSupport.create_resources(
+      file, line,
+      self,
+      virtual, exported,
+      type_name,
+      resource_titles,
+      defaults.merge(params).map do |name, value|
+        next if (value == :undef || value.nil?)
+        Puppet::Parser::Resource::Param.new(
+          :name   => name,
+          :value  => value, # wide open to various data types, must be correct
+          :source => self.source, # TODO: support :line => line, :file => file,
+          :add    => false
+        )
+      end.compact
+      )
+  end.flatten.compact
 end

lib/puppet/parser/resource.rb

@@ -75,7 +75,7 @@ def evaluate
     return if evaluated?
     Puppet::Util::Profiler.profile("Evaluated resource #{self}", [:compiler, :evaluate_resource, self]) do
       @evaluated = true
-      if builtin?
+      if builtin_type?
         devfail "Cannot evaluate a builtin type (#{type})"
       elsif resource_type.nil?
         self.fail "Cannot find definition #{type}"
@@ -256,7 +256,7 @@ def add_parameters_from_consume
       scope.with_global_scope do |global_scope|
         cns_scope = global_scope.newscope(:source => self, :resource => self)
         cns.to_hash.each { |name, value| cns_scope[name.to_s] = value }
-  
+
         # evaluate mappings in that scope
         resource_type.arguments.keys.each do |name|
           if expr = blueprint[:mappings][name]

lib/puppet/parser/scope.rb

@@ -976,18 +976,19 @@ def ephemeral_from(match, file = nil, line = nil)
     end
   end
 
+  # @api private
   def find_resource_type(type)
-    # It still works fine without the type == 'class' short-cut, but it is a lot slower.
-    return nil if ["class", "node"].include? type.to_s.downcase
-    find_builtin_resource_type(type) || find_defined_resource_type(type)
+    raise Puppet::DevError, "Scope#find_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead"
   end
 
+  # @api private
   def find_builtin_resource_type(type)
-    Puppet::Type.type(type.to_s.downcase.to_sym)
+    raise Puppet::DevError, "Scope#find_builtin_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead"
   end
 
+  # @api private
   def find_defined_resource_type(type)
-    environment.known_resource_types.find_definition(type.to_s.downcase)
+    raise Puppet::DevError, "Scope#find_defined_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead"
   end
 
 
@@ -1005,25 +1006,33 @@ def method_missing(method, *args, &block)
     end
   end
 
+  # Called from two places:
+  # runtime3support when creating resources
+  # ast::resource - used by create resources ?
+  # @api private
   def resolve_type_and_titles(type, titles)
-    raise ArgumentError, "titles must be an array" unless titles.is_a?(Array)
-
-    case type.downcase
-    when "class"
-      # resolve the titles
-      titles = titles.collect do |a_title|
-        hostclass = find_hostclass(a_title)
-        hostclass ?  hostclass.name : a_title
-      end
-    when "node"
-      # no-op
-    else
-      # resolve the type
-      resource_type = find_resource_type(type)
-      type = resource_type.name if resource_type
-    end
+    raise Puppet::DevError, "Scope#resolve_type_and_title() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead"
 
-    return [type, titles]
+#    Puppet.deprecation_warning('Scope#resolve_type_and_titles is deprecated.')
+#
+#    raise ArgumentError, "titles must be an array" unless titles.is_a?(Array)
+#
+#    case type.downcase
+#    when "class"
+#      # resolve the titles
+#      titles = titles.collect do |a_title|
+#        hostclass = find_hostclass(a_title)
+#        hostclass ?  hostclass.name : a_title
+#      end
+#    when "node"
+#      # no-op
+#    else
+#      # resolve the type
+#      resource_type = find_resource_type(type)
+#      type = resource_type.name if resource_type
+#    end
+#
+#    return [type, titles]
   end
 
   # Transforms references to classes to the form suitable for

lib/puppet/pops.rb

@@ -82,10 +82,14 @@ module Config
       end
     end
 
+    module Resource
+      require 'puppet/pops/resource/resource_type_impl'
+    end
     module Evaluator
       require 'puppet/pops/evaluator/literal_evaluator'
       require 'puppet/pops/evaluator/callable_signature'
       require 'puppet/pops/evaluator/runtime3_converter'
+      require 'puppet/pops/evaluator/runtime3_resource_support'
       require 'puppet/pops/evaluator/runtime3_support'
       require 'puppet/pops/evaluator/evaluator_impl'
       require 'puppet/pops/evaluator/epp_evaluator'

lib/puppet/pops/evaluator/collector_transformer.rb

@@ -19,7 +19,8 @@ def transform(o, scope)
       fail "Classes cannot be collected"
     end
 
-    resource_type = scope.find_resource_type(type)
+    resource_type = Runtime3ResourceSupport.find_resource_type(scope.environment, type)
+
     fail "Resource type #{type} doesn't exist" unless resource_type
 
     adapter = Adapters::SourcePosAdapter.adapt(o)

lib/puppet/pops/evaluator/runtime3_resource_support.rb

@@ -0,0 +1,113 @@
+module Puppet::Pops
+module Evaluator
+
+# @api private
+module Runtime3ResourceSupport
+  CLASS_STRING = 'class'.freeze
+
+  def self.create_resources(file, line, scope, virtual, exported, type_name, resource_titles, evaluated_parameters)
+
+    env = scope.environment
+    #    loader = Adapters::LoaderAdapter.loader_for_model_object(o, scope)
+
+    if type_name.is_a?(String) && type_name.casecmp(CLASS_STRING) == 0
+      # Resolve a 'class' and its titles
+      resource_titles = resource_titles.collect do |a_title|
+        hostclass = env.known_resource_types.find_hostclass(a_title)
+        hostclass ?  hostclass.name : a_title
+      end
+      # resolved type is just the string CLASS
+      resolved_type = CLASS_STRING
+    else
+      # resolve a resource type - pcore based, ruby impl, user defined, or application
+      fully_qualified_type = find_resource_type(env, type_name)
+      type = fully_qualified_type.name if fully_qualified_type
+      resolved_type = fully_qualified_type
+    end
+
+    # TODO: Unknown resource causes creation of Resource to fail with ArgumentError, should give
+    # a proper Issue. Now the result is "Error while evaluating a Resource Statement" with the message
+    # from the raised exception. (It may be good enough).
+    unless resolved_type
+      # TODO: do this the right way
+      raise ArgumentError, "Unknown resource type: '#{type_name}'"
+    end
+
+    # Build a resource for each title - use the resolved *type* as opposed to a reference
+    # as this makes the created resource retain the type instance.
+    #
+    resource_titles.map do |resource_title|
+        resource = Puppet::Parser::Resource.new(
+          resolved_type, resource_title,
+          :parameters => evaluated_parameters,
+          :file => file,
+          :line => line,
+          :exported => exported,
+          :virtual => virtual,
+          # WTF is this? Which source is this? The file? The name of the context ?
+          :source => scope.source,
+          :scope => scope,
+          :strict => true
+        )
+
+        # If this resource type supports inheritance (e.g. 'class') the parent chain must be walked
+        # This impl delegates to the resource type to figure out what is needed.
+        #
+        if resource.resource_type.is_a? Puppet::Resource::Type
+          resource.resource_type.instantiate_resource(scope, resource)
+        end
+
+        scope.compiler.add_resource(scope, resource)
+
+        # Classes are evaluated immediately
+        scope.compiler.evaluate_classes([resource_title], scope, false) if fully_qualified_type == CLASS_STRING
+
+        # Turn the resource into a PType (a reference to a resource type)
+        # weed out nil's
+        resource_to_ptype(resource)
+    end
+  end
+
+  def self.find_resource_type(env, type_name)
+    type_name = type_name.to_s.downcase
+    find_builtin_resource_type(env, type_name) || find_defined_resource_type(env, type_name)
+  end
+
+  def self.find_resource_type_or_class(env, name)
+    type_name = type_name.to_s.downcase
+    find_builtin_resource_type(env, name) || find_defined_resource_type(env, name) || find_hostclass(env, name)
+  end
+
+  def self.resource_to_ptype(resource)
+    nil if resource.nil?
+    # inference returns the meta type since the 3x Resource is an alternate way to describe a type
+    Puppet::Pops::Types::TypeCalculator.singleton().infer(resource).type
+  end
+
+  def self.find_main_class(env)
+    # Find the main class (known as ''), it does not have to be in the catalog
+    env.known_resource_types.find_hostclass('')
+  end
+
+  def self.find_hostclass(env, class_name)
+    env.known_resource_types.find_hostclass(class_name)
+  end
+
+  private
+
+  def self.find_builtin_resource_type(env, type_name)
+    # TODO: IF 4.X LOADER FINDS TYPE - USE IT
+    # Step 1 - use cheat for notify by doing return Puppet::Pops::Resource::ResourceTypeImpl.notify_cheat()
+
+    # horrible
+    Puppet::Type.type(type_name)
+  end
+
+  def self.find_defined_resource_type(env, type_name)
+    krt = env.known_resource_types
+    krt.find_definition(type_name) || krt.application(type_name)
+  end
+
+end
+end
+end