Class: Puppet::Pal::CatalogCompiler

Inherits:
Compiler show all
Defined in:
lib/puppet/pal/catalog_compiler.rb

Overview

A CatalogCompiler is a compiler that builds a catalog of resources and dependencies as a side effect of evaluating puppet language code. When the compilation of the given input manifest(s)/code string/file is finished the catalog is complete for encoding and use. It is also possible to evaluate more strings within the same compilation context to add or remove things from the catalog.

Instance Method Summary collapse

Methods inherited from Compiler

#call_function, #create, #evaluate_file, #evaluate_literal, #evaluate_string, #function_signature, #initialize, #list_functions, #parse_file, #parse_string, #type

Constructor Details

This class inherits a constructor from Puppet::Pal::Compiler

Instance Method Details

#catalog_data_hashObject

Returns a hash representation of the compiled catalog.


43
44
45
# File 'lib/puppet/pal/catalog_compiler.rb', line 43

def catalog_data_hash
  catalog.to_data_hash
end

#compile_additionsVoid

Compiles the result of additional evaluation taking place in a PAL catalog compilation. This will evaluate all lazy constructs until all have been evaluated, and will the validate the result.

This should be called if evaluating string or files of puppet logic after the initial compilation taking place by giving PAL a manifest or code-string. This method should be called when a series of evaluation should have reached a valid state (there should be no dangling relationships (to resources that does not exist).

As an alternative the methods `evaluate_additions` can be called without any requirements on consistency and then calling `validate` at the end.

Can be called multiple times.


82
83
84
# File 'lib/puppet/pal/catalog_compiler.rb', line 82

def compile_additions
  internal_compiler.compile_additions
end

#evaluate(ast) ⇒ Object

Evaluates an AST obtained from `parse_string` or `parse_file` in topscope. If the ast is a `Puppet::Pops::Model::Program` (what is returned from the `parse` methods, any definitions in the program (that is, any function, plan, etc. that is defined will be made available for use).


54
55
56
57
58
59
60
61
62
63
# File 'lib/puppet/pal/catalog_compiler.rb', line 54

def evaluate(ast)
  if ast.is_a?(Puppet::Pops::Model::Program)
    bridged = Puppet::Parser::AST::PopsBridge::Program.new(ast)
    # define all catalog types
    internal_compiler.environment.known_resource_types.import_ast(bridged, "")
    bridged.evaluate(internal_compiler.topscope)
  else
    internal_evaluator.evaluate(topscope, ast)
  end
end

#evaluate_additionsObject

Evaluates all lazy constructs that were produced as a side effect of evaluating puppet logic. Can be called multiple times.


96
97
98
# File 'lib/puppet/pal/catalog_compiler.rb', line 96

def evaluate_additions
  internal_compiler.evaluate_additions
end

#has_catalog?Boolean

Returns true if this is a compiler that compiles a catalog. This implementation returns `true`


22
23
24
# File 'lib/puppet/pal/catalog_compiler.rb', line 22

def has_catalog?
  true
end

#validateObject

Validates the state of the catalog (without performing evaluation of any elements requiring lazy evaluation. Can be called multiple times.


89
90
91
# File 'lib/puppet/pal/catalog_compiler.rb', line 89

def validate
  internal_compiler.validate
end

#with_json_encoding(pretty: true, exclude_virtual: true) {|JsonCatalogEncoder.new(catalog, pretty: pretty, exclude_virtual: exclude_virtual)| ... } ⇒ Object

Calls a block of code and yields a configured `JsonCatalogEncoder` to the block.

Examples:

Get resulting catalog as pretty printed Json

Puppet::Pal.in_environment(...) do |pal|
  pal.with_catalog_compiler(...) do |compiler|
    compiler.with_json_encoding { |encoder| encoder.encode }
  end
end

Yields:


36
37
38
# File 'lib/puppet/pal/catalog_compiler.rb', line 36

def with_json_encoding(pretty: true, exclude_virtual: true)
  yield JsonCatalogEncoder.new(catalog, pretty: pretty, exclude_virtual: exclude_virtual)
end