module Puppet::Pops::Evaluator::Runtime3ResourceSupport

@api private

Constants

CLASS_STRING

Public Class Methods

create_resources(file, line, scope, virtual, exported, type_name, resource_titles, evaluated_parameters) click to toggle source
   # File lib/puppet/pops/evaluator/runtime3_resource_support.rb
 8 def self.create_resources(file, line, scope, virtual, exported, type_name, resource_titles, evaluated_parameters)
 9 
10   env = scope.environment
11   #    loader = Adapters::LoaderAdapter.loader_for_model_object(o, scope)
12 
13   if type_name.is_a?(String) && type_name.casecmp(CLASS_STRING) == 0
14     # Resolve a 'class' and its titles
15     resource_titles = resource_titles.collect do |a_title|
16       hostclass = env.known_resource_types.find_hostclass(a_title)
17       hostclass ?  hostclass.name : a_title
18     end
19     # resolved type is just the string CLASS
20     resolved_type = CLASS_STRING
21   else
22     # resolve a resource type - pcore based, ruby impl or user defined
23     resolved_type = find_resource_type(scope, type_name)
24   end
25 
26   # TODO: Unknown resource causes creation of Resource to fail with ArgumentError, should give
27   # a proper Issue. Now the result is "Error while evaluating a Resource Statement" with the message
28   # from the raised exception. (It may be good enough).
29   unless resolved_type
30     # TODO: do this the right way
31     raise ArgumentError, _("Unknown resource type: '%{type}'") % { type: type_name }
32   end
33 
34   # Build a resource for each title - use the resolved *type* as opposed to a reference
35   # as this makes the created resource retain the type instance.
36   #
37   resource_titles.map do |resource_title|
38       resource = Puppet::Parser::Resource.new(
39         resolved_type, resource_title,
40         :parameters => evaluated_parameters,
41         :file => file,
42         :line => line,
43         :exported => exported,
44         :virtual => virtual,
45         # WTF is this? Which source is this? The file? The name of the context ?
46         :source => scope.source,
47         :scope => scope,
48         :strict => true
49       )
50 
51       # If this resource type supports inheritance (e.g. 'class') the parent chain must be walked
52       # This impl delegates to the resource type to figure out what is needed.
53       #
54       if resource.resource_type.is_a? Puppet::Resource::Type
55         resource.resource_type.instantiate_resource(scope, resource)
56       end
57 
58       scope.compiler.add_resource(scope, resource)
59 
60       # Classes are evaluated immediately
61       scope.compiler.evaluate_classes([resource_title], scope, false) if resolved_type == CLASS_STRING
62 
63       # Turn the resource into a PTypeType (a reference to a resource type)
64       # weed out nil's
65       resource_to_ptype(resource)
66   end
67 end
find_hostclass(scope, class_name) click to toggle source
   # File lib/puppet/pops/evaluator/runtime3_resource_support.rb
88 def self.find_hostclass(scope, class_name)
89   scope.environment.known_resource_types.find_hostclass(class_name)
90 end
find_main_class(scope) click to toggle source
   # File lib/puppet/pops/evaluator/runtime3_resource_support.rb
83 def self.find_main_class(scope)
84   # Find the main class (known as ''), it does not have to be in the catalog
85   scope.environment.known_resource_types.find_hostclass('')
86 end
find_resource_type(scope, type_name) click to toggle source
   # File lib/puppet/pops/evaluator/runtime3_resource_support.rb
69 def self.find_resource_type(scope, type_name)
70   find_builtin_resource_type(scope, type_name) || find_defined_resource_type(scope, type_name)
71 end
find_resource_type_or_class(scope, name) click to toggle source
   # File lib/puppet/pops/evaluator/runtime3_resource_support.rb
73 def self.find_resource_type_or_class(scope, name)
74   find_builtin_resource_type(scope, name) || find_defined_resource_type(scope, name) || find_hostclass(scope, name)
75 end
resource_to_ptype(resource) click to toggle source
   # File lib/puppet/pops/evaluator/runtime3_resource_support.rb
77 def self.resource_to_ptype(resource)
78   nil if resource.nil?
79   # inference returns the meta type since the 3x Resource is an alternate way to describe a type
80   Puppet::Pops::Types::TypeCalculator.singleton().infer(resource).type
81 end

Private Class Methods

find_builtin_resource_type(scope, type_name) click to toggle source
    # File lib/puppet/pops/evaluator/runtime3_resource_support.rb
 92 def self.find_builtin_resource_type(scope, type_name)
 93   if type_name.include?(':')
 94     # Skip the search for built in types as they are always in global namespace
 95     # (At least for now).
 96     return nil
 97   end
 98 
 99   loader = scope.compiler.loaders.private_environment_loader
100   loaded = loader.load(:resource_type_pp, type_name)
101   if loaded
102     return loaded
103   end
104 
105   # horrible - should be loaded by a "last loader" in 4.x loaders instead.
106   Puppet::Type.type(type_name)
107 end
find_defined_resource_type(scope, type_name) click to toggle source
    # File lib/puppet/pops/evaluator/runtime3_resource_support.rb
110 def self.find_defined_resource_type(scope, type_name)
111   krt = scope.environment.known_resource_types
112   krt.find_definition(type_name)
113 end