puppet 5.3.7-universal-darwin → 5.4.0-universal-darwin

data/lib/puppet/parser.rb

@@ -2,6 +2,7 @@
 module Puppet::Parser; end
 
 require 'puppet/parser/ast'
+require 'puppet/parser/abstract_compiler'
 require 'puppet/parser/compiler'
 require 'puppet/parser/compiler/catalog_validator'
 require 'puppet/resource/type_collection'

data/lib/puppet/parser/abstract_compiler.rb

@@ -0,0 +1,36 @@
+
+module Puppet::Parser::AbstractCompiler
+
+  # Returns the catalog for a compilation. Must return a Puppet::Resource::Catalog or fail with an 
+  # error if the specific compiler does not support catalog operations.
+  #
+  def catalog
+    raise Puppet::DevError("Class '#{self.class}' should have implemented 'catalog'")
+  end
+
+  # Returns the environment for the compilation
+  #
+  def environment
+    raise Puppet::DevError("Class '#{self.class}' should have implemented 'environment'")
+  end
+
+  # Produces a new scope
+  # This method is here if there are functions/logic that will call this for some other purpose than to create
+  # a named scope for a class. It may not have to be here. (TODO)
+  #
+  def newscope(scope, options)
+    raise Puppet::DevError("Class '#{self.class}' should have implemented 'newscope'")
+  end
+
+  # Returns a hash of all externally referenceable qualified variables
+  #
+  def qualified_variables
+    raise Puppet::DevError("Class '#{self.class}' should have implemented 'qualified_variables'")
+  end
+
+  # Returns the top scope instance
+  def topscope
+    raise Puppet::DevError("Class '#{self.class}' should have implemented 'topscope'")
+  end
+
+end

data/lib/puppet/parser/ast/branch.rb

@@ -1,7 +1,7 @@
 # The parent class of all AST objects that contain other AST objects.
 # Everything but the really simple objects descend from this.  It is
 # important to note that Branch objects contain other AST objects only --
-# if you want to contain values, use a descendent of the AST::Leaf class.
+# if you want to contain values, use a descendant of the AST::Leaf class.
 #
 # @api private
 class Puppet::Parser::AST::Branch < Puppet::Parser::AST

data/lib/puppet/parser/ast/pops_bridge.rb

@@ -95,7 +95,8 @@ class Puppet::Parser::AST::PopsBridge
     # efficient as it avoids one full scan of all logic via recursive enumeration/yield)
     #
     def instantiate(modname)
-      @program_model.definitions.collect do |d|
+
+      @program_model.definitions.map do |d|
         case d
         when Puppet::Pops::Model::HostClassDefinition
           instantiate_HostClassDefinition(d, modname)
@@ -107,25 +108,17 @@ class Puppet::Parser::AST::PopsBridge
           instantiate_NodeDefinition(d, modname)
         when Puppet::Pops::Model::SiteDefinition
             instantiate_SiteDefinition(d, modname)
-        when Puppet::Pops::Model::FunctionDefinition
-          # The 3x logic calling this will not know what to do with the result, it is compacted away at the end
-          instantiate_FunctionDefinition(d, modname)
-          next
-        when Puppet::Pops::Model::TypeAlias
-          # The 3x logic calling this will not know what to do with the result, it is compacted away at the end
-          instantiate_TypeAlias(d, modname)
-          next
-        when Puppet::Pops::Model::TypeMapping
-          # The 3x logic calling this will not know what to do with the result, it is compacted away at the end
-          instantiate_TypeMapping(d, modname)
-          next
         when Puppet::Pops::Model::Application
           instantiate_ApplicationDefinition(d, modname)
         else
-          raise Puppet::ParseError, _("Internal Error: Unknown type of definition - got '%{name}'") % { name: d.class }
+          loaders = Puppet::Pops::Loaders.loaders
+          loaders.instantiate_definition(d, loaders.find_loader(modname))
+
+          # The 3x logic calling this will not know what to do with the result, it is compacted away at the end
+          nil
         end
       end.flatten().compact() # flatten since node definition may have returned an array
-                              # Compact since functions are not understood by compiler
+                              # Compact since 4x definitions are not understood by compiler
     end
 
     def evaluate(scope)
@@ -261,43 +254,6 @@ class Puppet::Parser::AST::PopsBridge
       Puppet::Resource::Type.new(:site, 'site', @context.merge(args))
     end
 
-    # Propagates a found Function to the appropriate loader.
-    # This is for 4x evaluator/loader
-    #
-    def instantiate_FunctionDefinition(function_definition, modname)
-      loader = Puppet::Pops::Loaders.find_loader(modname)
-
-      # Instantiate Function, and store it in the loader
-      typed_name, f = Puppet::Pops::Loader::PuppetFunctionInstantiator.create_from_model(function_definition, loader)
-      loader.set_entry(typed_name, f, function_definition.locator.to_uri(function_definition))
-
-      nil # do not want the function to inadvertently leak into 3x
-    end
-
-    # Propagates a found TypeAlias to the appropriate loader.
-    # This is for 4x evaluator/loader
-    #
-    def instantiate_TypeAlias(type_alias, modname)
-      loader = Puppet::Pops::Loaders.find_loader(modname)
-
-      # Bind the type alias to the loader using the alias
-      Puppet::Pops::Loader::TypeDefinitionInstantiator.create_from_model(type_alias, loader)
-
-      nil # do not want the type alias to inadvertently leak into 3x
-    end
-
-    # Adds the TypeMapping to the ImplementationRegistry
-    # This is for 4x evaluator/loader
-    #
-    def instantiate_TypeMapping(type_mapping, modname)
-      loader = Puppet::Pops::Loaders.find_loader(modname)
-      tf = Puppet::Pops::Types::TypeParser.singleton
-      lhs = tf.interpret(type_mapping.type_expr, loader)
-      rhs = tf.interpret_any(type_mapping.mapping_expr, loader)
-      Puppet::Pops::Loaders.implementation_registry.register_type_mapping(lhs, rhs, loader)
-      nil
-    end
-
     def code()
       Expression.new(:value => @value)
     end

data/lib/puppet/parser/compiler.rb

@@ -10,6 +10,8 @@ require 'puppet/pops'
 # Maintain a graph of scopes, along with a bunch of data
 # about the individual catalog we're compiling.
 class Puppet::Parser::Compiler
+  include Puppet::Parser::AbstractCompiler
+
   extend Forwardable
 
   include Puppet::Util
@@ -719,6 +721,7 @@ class Puppet::Parser::Compiler
     Puppet.override( @context_overrides , _("For initializing compiler")) do
       # THE MAGIC STARTS HERE ! This triggers parsing, loading etc.
       @catalog.version = environment.known_resource_types.version
+      @loaders.pre_load
     end
 
     @catalog.add_resource(Puppet::Parser::Resource.new("stage", :main, :scope => @topscope))
@@ -737,69 +740,16 @@ class Puppet::Parser::Compiler
   end
 
   def sanitize_node(node)
-    # Resurrect "trusted information" that comes from node/fact terminus.
-    # The current way this is done in puppet db (currently the only one)
-    # is to store the node parameter 'trusted' as a hash of the trusted information.
-    #
-    # Thus here there are two main cases:
-    # 1. This terminus was used in a real agent call (only meaningful if someone curls the request as it would
-    #  fail since the result is a hash of two catalogs).
-    # 2  It is a command line call with a given node that use a terminus that:
-    # 2.1 does not include a 'trusted' fact - use local from node trusted information
-    # 2.2 has a 'trusted' fact - this in turn could be
-    # 2.2.1 puppet db having stored trusted node data as a fact (not a great design)
-    # 2.2.2 some other terminus having stored a fact called "trusted" (most likely that would have failed earlier, but could
-    #       be spoofed).
-    #
-    # For the reasons above, the resurrection of trusted node data with authenticated => true is only performed
-    # if user is running as root, else it is resurrected as unauthenticated.
-    #
-    trusted_param = node.parameters['trusted']
-    if trusted_param
-      # Blows up if it is a parameter as it will be set as $trusted by the compiler as if it was a variable
-      node.parameters.delete('trusted')
-      unless trusted_param.is_a?(Hash) && %w{authenticated certname extensions}.all? {|key| trusted_param.has_key?(key) }
-        # trusted is some kind of garbage, do not resurrect
-        trusted_param = nil
-      end
-    else
-      # trusted may be Boolean false if set as a fact by someone
-      trusted_param = nil
-    end
-
-    # The options for node.trusted_data in priority order are:
-    # 1) node came with trusted_data so use that
-    # 2) else if there is :trusted_information in the puppet context
-    # 3) else if the node provided a 'trusted' parameter (parsed out above)
-    # 4) last, fallback to local node trusted information
-    #
-    # Note that trusted_data should be a hash, but (2) and (4) are not
-    # hashes, so we to_h at the end
-    if !node.trusted_data
-      trusted = Puppet.lookup(:trusted_information) do
-        trusted_param || Puppet::Context::TrustedInformation.local(node)
-      end
-
-      # Ruby 1.9.3 can't apply to_h to a hash, so check first
-      node.trusted_data = trusted.is_a?(Hash) ? trusted : trusted.to_h
-    end
-
+    node.sanitize
     node
   end
 
   # Set the node's parameters into the top-scope as variables.
   def set_node_parameters
     node.parameters.each do |param, value|
-      # We don't want to set @topscope['environment'] from the parameters,
-      # instead we want to get that from the node's environment itself in
-      # case a custom node terminus has done any mucking about with
-      # node.parameters.
-      next if param.to_s == 'environment'
       # Ensure node does not leak Symbol instances in general
       @topscope[param.to_s] = value.is_a?(Symbol) ? value.to_s : value
     end
-    @topscope['environment'] = node.environment.name.to_s
-
     # These might be nil.
     catalog.client_version = node.parameters["clientversion"]
     catalog.server_version = node.parameters["serverversion"]

data/lib/puppet/parser/functions.rb

@@ -198,7 +198,6 @@ module Puppet::Parser::Functions
   def self.function(name, environment = Puppet.lookup(:current_environment))
     name = name.intern
 
-    func = nil
     unless func = get_function(name, environment)
       autoloader.load(name, environment)
       func = get_function(name, environment)

data/lib/puppet/parser/functions/create_resources.rb

@@ -47,6 +47,12 @@ Puppet::Parser::Functions::newfunction(:create_resources, :arity => -3, :doc =>
     final value of a parameter (just as when setting a parameter to `undef` in a puppet language
     resource declaration).
   ENDHEREDOC
+  if Puppet[:tasks]
+    raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+      Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
+      {:operation => 'create_resources'})
+  end
+
   raise ArgumentError, (_("create_resources(): wrong number of arguments (%{count}; must be 2 or 3)") % { count: args.length }) if args.length > 3
   raise ArgumentError, (_('create_resources(): second argument must be a hash')) unless args[1].is_a?(Hash)
   if args.length == 3

data/lib/puppet/parser/functions/fqdn_rand.rb

@@ -1,4 +1,4 @@
-require 'digest/md5'
+require 'digest/sha2'
 
 Puppet::Parser::Functions::newfunction(:fqdn_rand, :arity => -2, :type => :rvalue, :doc =>
   "Usage: `fqdn_rand(MAX, [SEED])`. MAX is required and must be a positive
@@ -16,6 +16,10 @@ Puppet::Parser::Functions::newfunction(:fqdn_rand, :arity => -2, :type => :rvalu
   node. (For example, `fqdn_rand(30)`, `fqdn_rand(30, 'expensive job 1')`, and
   `fqdn_rand(30, 'expensive job 2')` will produce totally different numbers.)") do |args|
     max = args.shift.to_i
-    seed = Digest::MD5.hexdigest([self['::fqdn'],max,args].join(':')).hex
+ 
+    # We are consciously not using different hash algs based on fips mode here
+    # since the randomness is not guaranteed to be predictable for a given node
+    # It just needs to be unique for a given node
+    seed = Digest::SHA256.hexdigest([self['::fqdn'],max,args].join(':')).hex
     Puppet::Util.deterministic_rand_int(seed,max)
 end

data/lib/puppet/parser/functions/inline_template.rb

@@ -4,6 +4,12 @@ Puppet::Parser::Functions::newfunction(:inline_template, :type => :rvalue, :arit
   more information. Note that if multiple template strings are specified, their
   output is all concatenated and returned as the output of the function.") do |vals|
 
+  if Puppet[:tasks]
+    raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+      Puppet::Pops::Issues::FEATURE_NOT_SUPPORTED_WHEN_SCRIPTING,
+      {:feature => 'ERB inline_template'})
+  end
+
   require 'erb'
 
     vals.collect do |string|

data/lib/puppet/parser/functions/new.rb

@@ -56,14 +56,16 @@ Would fail with an assertion error (since value is less than 0).
 The following sections show the arguments and conversion rules
 per data type built into the Puppet Type System.
 
-### Conversion to Optional[T] and NotUndef[T]
+Conversion to Optional[T] and NotUndef[T]
+-----------------------------------------
 
 Conversion to these data types is the same as a conversion to the type argument `T`.
 In the case of `Optional[T]` it is accepted that the argument to convert may be `undef`.
 It is however not acceptable to give other arguments (than `undef`) that cannot be
 converted to `T`.
 
-### Conversion to Integer
+Conversion to Integer
+---------------------
 
 A new `Integer` can be created from `Integer`, `Float`, `Boolean`, and `String` values.
 For conversion from `String` it is possible to specify the radix (base).
@@ -111,7 +113,8 @@ $a_number = Integer(true)          # results in 1
 $a_number = Integer(-38, 10, true) # results in 38
 ```
 
-### Conversion to Float
+Conversion to Float
+-------------------
 
 A new `Float` can be created from `Integer`, `Float`, `Boolean`, and `String` values.
 For conversion from `String` both float and integer formats are supported.
@@ -123,13 +126,15 @@ function Float.new(
 )
 ```
 
+
 * For an integer, the floating point fraction of `.0` is added to the value.
 * A `Boolean` `true` is converted to 1.0, and a `false` to 0.0
 * In `String` format, integer prefixes for hex and binary are understood (but not octal since
   floating point in string format may start with a '0').
 * When `abs` is set to `true`, the result will be an absolute floating point value.
 
-### Conversion to Numeric
+Conversion to Numeric
+---------------------
 
 A new `Integer` or `Float` can be created from `Integer`, `Float`, `Boolean` and
 `String` values.
@@ -158,7 +163,8 @@ $a_number = Numeric(-42.3, true) # results in 42.3
 $a_number = Numeric(-42, true)   # results in 42
 ```
 
-### Conversion to Timespan
+Conversion to Timespan
+-------------------
 
 A new `Timespan` can be created from `Integer`, `Float`, `String`, and `Hash` values. Several variants of the constructor are provided.
 
@@ -172,7 +178,7 @@ function Timespan.new(
 )
 ```
 
-#### Timespan from days, hours, mintues, seconds, and fractions of a second
+#### Timespan from days, hours, minutes, seconds, and fractions of a second
 
 The arguments can be passed separately in which case the first four, days, hours, minutes, and seconds are mandatory and the rest are optional.
 All values may overflow and/or be negative. The internal 128-bit nano-second integer is calculated as:
@@ -275,7 +281,8 @@ $duration = Timespan('10:03.5', '%M:%S.%L') # 10 minutes, 3 seconds, and 5 milli
 $duration = Timespan('10:03.5', '%M:%S.%N') # 10 minutes, 3 seconds, and 5 nano-seconds
 ```
 
-### Conversion to Timestamp
+Conversion to Timestamp
+-------------------
 
 A new `Timestamp` can be created from `Integer`, `Float`, `String`, and `Hash` values. Several variants of the constructor are provided.
 
@@ -468,8 +475,8 @@ $ts = Timestamp('2016-08-24T12:13:14', default, 'PST')   # 2016-08-24 20:13:14.0
 
 ```
 
-### Conversion to Type
-
+Conversion to Type
+------------------
 A new `Type` can be create from its `String` representation.
 
 **Example:** Creating a type from a string
@@ -478,7 +485,8 @@ A new `Type` can be create from its `String` representation.
 $t = Type.new('Integer[10]')
 ```
 
-### Conversion to String
+Conversion to String
+--------------------
 
 Conversion to `String` is the most comprehensive conversion as there are many
 use cases where a string representation is wanted. The defaults for the many options
@@ -521,7 +529,7 @@ included in a string format.
 Note that all data type supports the formats `s` and `p` with the meaning "default string representation" and
 "default programmatic string representation" (which for example means that a String is quoted in 'p' format).
 
-#### Signatures of String conversion
+### Signatures of String conversion
 
 ```puppet
 type Format = Pattern[/^%([\s\+\-#0\[\{<\(\|]*)([1-9][0-9]*)?(?:\.([0-9]+))?([a-zA-Z])/]
@@ -579,7 +587,7 @@ $str = String([1,2,3], $formats) # produces '(0x1, 0x2, 0x3)'
 The given formats are merged with the default formats, and matching of values to convert against format is based on
 the specificity of the mapped type; for example, different formats can be used for short and long arrays.
 
-#### Integer to String
+### Integer to String
 
 | Format  | Integer Formats
 | ------  | ---------------
@@ -594,7 +602,7 @@ the specificity of the mapped type; for example, different formats can be used f
 
 Defaults to `d`.
 
-#### Float to String
+### Float to String
 
 | Format  | Float formats
 | ------  | -------------
@@ -608,7 +616,7 @@ Defaults to `d`.
 
 Defaults to `p`.
 
-#### String to String
+### String to String
 
 | Format | String
 | ------ | ------
@@ -622,7 +630,7 @@ Defaults to `p`.
 
 Defaults to `s` at top level and `p` inside array or hash.
 
-#### Boolean to String
+### Boolean to String
 
 | Format    | Boolean Formats
 | ----      | -------------------
@@ -633,14 +641,14 @@ Defaults to `s` at top level and `p` inside array or hash.
 | s         | String 'true' / 'false'.
 | p         | String 'true' / 'false'.
 
-#### Regexp to String
+### Regexp to String
 
 | Format    | Regexp Formats
 | ----      | --------------
 | s         | No delimiters, quoted if alternative flag `#` is used.
 | p         | Delimiters `/ /`.
 
-#### Undef to String
+### Undef to String
 
 | Format    | Undef formats
 | ------    | -------------
@@ -653,7 +661,7 @@ Defaults to `s` at top level and `p` inside array or hash.
 | V         | String 'N/A'.
 | u         | String 'undef', or 'undefined' if alternative `#` flag is used.
 
-#### Default value to String
+### Default value to String
 
 | Format    | Default formats
 | ------    | ---------------
@@ -661,7 +669,7 @@ Defaults to `s` at top level and `p` inside array or hash.
 | s         | Same as d.
 | p         | Same as d.
 
-#### Binary value to String
+### Binary value to String
 
 | Format    | Default formats
 | ------    | ---------------
@@ -678,7 +686,7 @@ Defaults to `s` at top level and `p` inside array or hash.
   as hex escaped characters on the form `\\xHH` where `H` is a hex digit.
 * The width and precision values are applied to the text part only in `%p` format.
 
-#### Array & Tuple to String
+### Array & Tuple to String
 
 | Format    | Array/Tuple Formats
 | ------    | -------------
@@ -693,7 +701,7 @@ The alternate form flag `#` will cause indentation of nested array or hash conta
 it is taken as the maximum allowed length of a sequence of elements (not including delimiters). If this max length
 is exceeded, each element will be indented.
 
-#### Hash & Struct to String
+### Hash & Struct to String
 
 | Format    | Hash/Struct Formats
 | ------    | -------------
@@ -707,14 +715,14 @@ more information about options.
 
 The alternate form flag `#` will format each hash key/value entry indented on a separate line.
 
-#### Type to String
+### Type to String
 
 | Format    | Array/Tuple Formats
 | ------    | -------------
 | s         | The same as `p`, quoted if alternative flag `#` is used.
 | p         | Outputs the type in string form as specified by the Puppet Language.
 
-#### Flags
+### Flags
 
 | Flag     | Effect
 | ------   | ------
@@ -725,7 +733,8 @@ The alternate form flag `#` will format each hash key/value entry indented on a
 | 0        | Pad with 0 instead of space for widths larger than value.
 | <[({\|   | Defines an enclosing pair <> [] () {} or \| \| when used with a container type.
 
-### Conversion to Boolean
+Conversion to Boolean
+---
 
 Accepts a single value as argument:
 
@@ -736,7 +745,8 @@ Accepts a single value as argument:
   * `false` if 'false', 'no', 'n' (case independent compare)
 * Boolean is already boolean and is simply returned
 
-### Conversion to Array and Tuple
+Conversion to Array and Tuple
+---
 
 When given a single value as argument:
 
@@ -761,7 +771,8 @@ $arr = Array($value, true)
 Conversion to a `Tuple` works exactly as conversion to an `Array`, only that the constructed array is
 asserted against the given tuple type.
 
-### Conversion to Hash and Struct
+Conversion to Hash and Struct
+---
 
 Accepts a single value as argument:
 
@@ -800,8 +811,8 @@ Would notice the hash `{a => {b => {x => wine}}, b => {y => wine}}`
 Conversion to a `Struct` works exactly as conversion to a `Hash`, only that the constructed hash is
 asserted against the given struct type.
 
-### Conversion to a Regexp
-
+Conversion to a Regexp
+---
 A `String` can be converted into a `Regexp`
 
 **Example**: Converting a String into a Regexp
@@ -813,7 +824,8 @@ if('foo.com' =~ $r) {
 }
 ```
 
-### Creating a SemVer
+Creating a SemVer
+---
 
 A SemVer object represents a single [Semantic Version](http://semver.org/).
 It can be created from a String, individual values for its parts, or a hash specifying the value per part.
@@ -862,7 +874,8 @@ notice(SemVer('2.3.4') =~ $t) # false
 notice(SemVer('3.4.5') =~ $t) # true
 ```
 
-### Creating a SemVerRange
+Creating a SemVerRange
+---
 
 A `SemVerRange` object represents a range of `SemVer`. It can be created from
 a `String`, or from two `SemVer` instances, where either end can be given as
@@ -896,9 +909,10 @@ function SemVerRange.new(
 )
 ```
 
-For examples of `SemVerRange` use, see "Creating a SemVer".
+For examples of `SemVerRange` use see "Creating a SemVer"
 
-### Creating a Binary
+Creating a Binary
+---
 
 A `Binary` object represents a sequence of bytes and it can be created from a String in Base64 format,
 an Array containing byte values. A Binary can also be created from a Hash containing the value to convert to
@@ -918,6 +932,7 @@ function Binary.new(
   Optional[Base64Format] $format
 )
 
+
 function Binary.new(
   Array[ByteInteger] $byte_array
 }