Class: Puppet::Parser::Compiler

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Includes:
Resource::TypeCollectionHelper, Util, Util::Errors, Util::MethodHelper
Defined in:
lib/puppet/parser/compiler.rb

Overview

Maintain a graph of scopes, along with a bunch of data about the individual catalog we’re compiling.

Constant Summary

Constants included from Util

Util::AbsolutePathPosix, Util::AbsolutePathWindows, Util::DEFAULT_POSIX_MODE, Util::DEFAULT_WINDOWS_MODE

Constants included from Util::POSIX

Util::POSIX::LOCALE_ENV_VARS, Util::POSIX::USER_ENV_VARS

Constants included from Util::SymbolicFileMode

Util::SymbolicFileMode::SetGIDBit, Util::SymbolicFileMode::SetUIDBit, Util::SymbolicFileMode::StickyBit, Util::SymbolicFileMode::SymbolicMode, Util::SymbolicFileMode::SymbolicSpecialToBit

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Resource::TypeCollectionHelper

#known_resource_types

Methods included from Util::MethodHelper

#requiredopts, #set_options, #symbolize_options

Methods included from Util::Errors

#adderrorcontext, #devfail, #error_context, #exceptwrap, #fail

Methods included from Util

absolute_path?, activerecord_version, benchmark, binread, chuser, classproxy, deterministic_rand, execfail, execpipe, execute, exit_on_fail, logmethods, memory, path_to_uri, pretty_backtrace, proxy, replace_file, safe_posix_fork, symbolizehash, thinmark, uri_to_path, which, withenv, withumask

Methods included from Util::POSIX

#get_posix_field, #gid, #idfield, #methodbyid, #methodbyname, #search_posix_field, #uid

Methods included from Util::SymbolicFileMode

#normalize_symbolic_mode, #symbolic_mode_to_int, #valid_symbolic_mode?

Constructor Details

#initialize(node, options = {}) ⇒ Compiler

Returns a new instance of Compiler.



250
251
252
253
254
 
# File 'lib/puppet/parser/compiler.rb', line 250

def initialize(node, options = {})
  @node = node
  set_options(options)
  initvars
end

Instance Attribute Details

#boot_injector ⇒ Puppet::Pops::Binder::Injector?

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

The injector that provides lookup services during the creation of the #injector.

Returns:



66
67
68
 
# File 'lib/puppet/parser/compiler.rb', line 66

def boot_injector
  @boot_injector
end

#catalog ⇒ Object (readonly) 



45
46
47
 
# File 'lib/puppet/parser/compiler.rb', line 45

def catalog
  @catalog
end

#collections ⇒ Object (readonly) 



45
46
47
 
# File 'lib/puppet/parser/compiler.rb', line 45

def collections
  @collections
end

#facts ⇒ Object (readonly) 



45
46
47
 
# File 'lib/puppet/parser/compiler.rb', line 45

def facts
  @facts
end

#injector ⇒ Puppet::Pops::Binder::Injector?

The injector that provides lookup services, or nil if accessed before the compiler has started compiling and bootstrapped. The injector is initialized and available before any manifests are evaluated.

Returns:



53
54
55
 
# File 'lib/puppet/parser/compiler.rb', line 53

def injector
  @injector
end

#loaders ⇒ Puppet::Pops::Loader::Loaders (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Access to the configured loaders for 4x

Returns:

  • (Puppet::Pops::Loader::Loaders) —

    the configured loaders



58
59
60
 
# File 'lib/puppet/parser/compiler.rb', line 58

def loaders
  @loaders
end

#node ⇒ Object (readonly) 



45
46
47
 
# File 'lib/puppet/parser/compiler.rb', line 45

def node
  @node
end

#relationships ⇒ Object (readonly) 



45
46
47
 
# File 'lib/puppet/parser/compiler.rb', line 45

def relationships
  @relationships
end

#resources ⇒ Object (readonly) 



45
46
47
 
# File 'lib/puppet/parser/compiler.rb', line 45

def resources
  @resources
end

#topscope ⇒ Object (readonly) 



45
46
47
 
# File 'lib/puppet/parser/compiler.rb', line 45

def topscope
  @topscope
end

Class Method Details

.compile(node) ⇒ Object 



19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/puppet/parser/compiler.rb', line 19

def self.compile(node)
   $env_module_directories = nil
   node.environment.check_for_reparse

   if node.environment.conflicting_manifest_settings?
     errmsg = [
       "The 'disable_per_environment_manifest' setting is true, and this '#{node.environment}'",
       "has an environment.conf manifest that conflicts with the 'default_manifest' setting.",
       "Compilation has been halted in order to avoid running a catalog which may be using",
       "unexpected manifests. For more information, see",
       "http://docs.puppetlabs.com/puppet/latest/reference/environments.html",
     ]
     raise(Puppet::Error, errmsg.join(' '))
   end

   new(node).compile {|resulting_catalog| resulting_catalog.to_resource }
 rescue Puppet::ParseErrorWithIssue => detail
   detail.node = node.name
   Puppet.log_exception(detail)
   raise
 rescue => detail
   message = "#{detail} on node #{node.name}"
   Puppet.log_exception(detail, message)
   raise Puppet::Error, message, detail.backtrace
end

Instance Method Details

#add_class(name) ⇒ Object

Store the fact that we’ve evaluated a class



110
111
112
 
# File 'lib/puppet/parser/compiler.rb', line 110

def add_class(name)
  @catalog.add_class(name) unless name == ""
end

#add_override(override) ⇒ Object

Store a resource override.



73
74
75
76
77
78
79
80
81
82
 
# File 'lib/puppet/parser/compiler.rb', line 73

def add_override(override)
  # If possible, merge the override in immediately.
  if resource = @catalog.resource(override.ref)
    resource.merge(override)
  else
    # Otherwise, store the override for later; these
    # get evaluated in Resource#finish.
    @resource_overrides[override.ref] << override
  end
end

#add_resource(scope, resource) ⇒ Object 



84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/puppet/parser/compiler.rb', line 84

def add_resource(scope, resource)
  @resources << resource

  # Note that this will fail if the resource is not unique.
  @catalog.add_resource(resource)

  if not resource.class? and resource[:stage]
    raise ArgumentError, "Only classes can set 'stage'; normal resources like #{resource} cannot change run stage"
  end

  # Stages should not be inside of classes.  They are always a
  # top-level container, regardless of where they appear in the
  # manifest.
  return if resource.stage?

  # This adds a resource to the class it lexically appears in in the
  # manifest.
  unless resource.class?
    return @catalog.add_edge(scope.resource, resource)
  end
end

#compile ⇒ Object

Compiler our catalog. This mostly revolves around finding and evaluating classes. This is the main entry into our catalog.



120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'lib/puppet/parser/compiler.rb', line 120

def compile
  Puppet.override( @context_overrides , "For compiling #{node.name}") do
    @catalog.environment_instance = environment

    # Set the client's parameters into the top scope.
    Puppet::Util::Profiler.profile("Compile: Set node parameters", [:compiler, :set_node_params]) { set_node_parameters }

    Puppet::Util::Profiler.profile("Compile: Created settings scope", [:compiler, :create_settings_scope]) { create_settings_scope }

    if is_binder_active?
      # create injector, if not already created - this is for 3x that does not trigger
      # lazy loading of injector via context
      Puppet::Util::Profiler.profile("Compile: Created injector", [:compiler, :create_injector]) { injector }
    end

    Puppet::Util::Profiler.profile("Compile: Evaluated main", [:compiler, :evaluate_main]) { evaluate_main }

    Puppet::Util::Profiler.profile("Compile: Evaluated AST node", [:compiler, :evaluate_ast_node]) { evaluate_ast_node }

    Puppet::Util::Profiler.profile("Compile: Evaluated node classes", [:compiler, :evaluate_node_classes]) { evaluate_node_classes }

    Puppet::Util::Profiler.profile("Compile: Evaluated generators", [:compiler, :evaluate_generators]) { evaluate_generators }

    Puppet::Util::Profiler.profile("Compile: Finished catalog", [:compiler, :finish_catalog]) { finish }

    fail_on_unevaluated

    if block_given?
      yield @catalog
    else
      @catalog
    end
  end
end

#context_overrides ⇒ Object

Constructs the overrides for the context



156
157
158
159
160
161
162
163
164
165
166
167
168
169
 
# File 'lib/puppet/parser/compiler.rb', line 156

def context_overrides()
  if Puppet.future_parser?(environment)
    {
      :current_environment => environment,
      :global_scope => @topscope,             # 4x placeholder for new global scope
      :loaders  => lambda {|| loaders() },    # 4x loaders
      :injector => lambda {|| injector() }    # 4x API - via context instead of via compiler
    }
  else
    {
      :current_environment => environment,
    }
  end
end

#create_boot_injector(env_boot_bindings) ⇒ Puppet::Pops::Binder::Injector

Creates the boot injector from registered system, default, and injector config.

Returns:



288
289
290
291
292
293
294
295
 
# File 'lib/puppet/parser/compiler.rb', line 288

def create_boot_injector(env_boot_bindings)
  assert_binder_active()
  pb = Puppet::Pops::Binder
  boot_contribution = pb::SystemBindings.injector_boot_contribution(env_boot_bindings)
  final_contribution = pb::SystemBindings.final_contribution
  binder = pb::Binder.new(pb::BindingsFactory.layered_bindings(final_contribution, boot_contribution))
  @boot_injector = pb::Injector.new(binder)
end

#environment ⇒ Object

Return the node’s environment.



174
175
176
 
# File 'lib/puppet/parser/compiler.rb', line 174

def environment
  node.environment
end

#evaluate_classes(classes, scope, lazy_evaluate = true, fqname = false) ⇒ Object

Evaluate each specified class in turn. If there are any classes we can’t find, raise an error. This method really just creates resource objects that point back to the classes, and then the resources are themselves evaluated later in the process.

Sometimes we evaluate classes with a fully qualified name already, in which case, we tell scope.find_hostclass we’ve pre-qualified the name so it doesn’t need to search its namespaces again. This gets around a weird edge case of duplicate class names, one at top scope and one nested in our namespace and the wrong one (or both!) getting selected. See ticket #13349 for more detail. –jeffweiss 26 apr 2012

Raises:



212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
 
# File 'lib/puppet/parser/compiler.rb', line 212

def evaluate_classes(classes, scope, lazy_evaluate = true, fqname = false)
  raise Puppet::DevError, "No source for scope passed to evaluate_classes" unless scope.source
  class_parameters = nil
  # if we are a param class, save the classes hash
  # and transform classes to be the keys
  if classes.class == Hash
    class_parameters = classes
    classes = classes.keys
  end

  hostclasses = classes.collect do |name|
    scope.find_hostclass(name, :assume_fqname => fqname) or raise Puppet::Error, "Could not find class #{name} for #{node.name}"
  end

  if class_parameters
    resources = ensure_classes_with_parameters(scope, hostclasses, class_parameters)
    if !lazy_evaluate
      resources.each(&:evaluate)
    end

    resources
  else
    already_included, newly_included = ensure_classes_without_parameters(scope, hostclasses)
    if !lazy_evaluate
      newly_included.each(&:evaluate)
    end

    already_included + newly_included
  end
end

#evaluate_node_classes ⇒ Object

Evaluate all of the classes specified by the node. Classes with parameters are evaluated as if they were declared. Classes without parameters or with an empty set of parameters are evaluated as if they were included. This means classes with an empty set of parameters won’t conflict even if the class has already been included.



183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
 
# File 'lib/puppet/parser/compiler.rb', line 183

def evaluate_node_classes
  if @node.classes.is_a? Hash
    classes_with_params, classes_without_params = @node.classes.partition {|name,params| params and !params.empty?}

    # The results from Hash#partition are arrays of pairs rather than hashes,
    # so we have to convert to the forms evaluate_classes expects (Hash, and
    # Array of class names)
    classes_with_params = Hash[classes_with_params]
    classes_without_params.map!(&:first)
  else
    classes_with_params = {}
    classes_without_params = @node.classes
  end

  evaluate_classes(classes_with_params, @node_scope || topscope)
  evaluate_classes(classes_without_params, @node_scope || topscope)
end

#evaluate_relationships ⇒ Object 



243
244
245
 
# File 'lib/puppet/parser/compiler.rb', line 243

def evaluate_relationships
  @relationships.each { |rel| rel.evaluate(catalog) }
end

#is_binder_active? ⇒ Boolean

Answers if Puppet Binder should be active or not, and if it should and is not active, then it is activated.

Returns:

  • (Boolean) —

    true if the Puppet Binder should be activated



299
300
301
302
303
304
305
306
307
308
309
310
311
312
 
# File 'lib/puppet/parser/compiler.rb', line 299

def is_binder_active?
  should_be_active = Puppet[:binder] || Puppet.future_parser?
  if should_be_active
    # TODO: this should be in a central place, not just for ParserFactory anymore...
    Puppet::Parser::ParserFactory.assert_rgen_installed()
    @@binder_loaded ||= false
    unless @@binder_loaded
      require 'puppet/pops'
      require 'puppetx'
      @@binder_loaded = true
    end
  end
  should_be_active
end

#newscope(parent, options = {}) ⇒ Object

Create a new scope, with either a specified parent scope or using the top scope.



258
259
260
261
262
263
 
# File 'lib/puppet/parser/compiler.rb', line 258

def newscope(parent, options = {})
  parent ||= topscope
  scope = Puppet::Parser::Scope.new(self, options)
  scope.parent = parent
  scope
end

#resource_overrides(resource) ⇒ Object

Return any overrides for the given resource.



266
267
268
 
# File 'lib/puppet/parser/compiler.rb', line 266

def resource_overrides(resource)
  @resource_overrides[resource.ref]
end