puppet 4.4.2-universal-darwin → 4.5.0-universal-darwin

data/lib/puppet/functions/regsubst.rb

@@ -16,9 +16,10 @@
 # @param regexp [String|Regexp|Type[Regexp]]
 #      The regular expression matching the target string.  If you want it anchored at the start
 #      and or end of the string, you must do that with ^ and $ yourself.
-# @param replacement [String]
+# @param replacement [String|Hash[String, String]]
 #      Replacement string. Can contain backreferences to what was matched using \\0 (whole match),
 #      \\1 (first set of parentheses), and so on.
+#      If the second argument is a Hash, and the matched text is one of its keys, the corresponding value is the replacement string.
 # @param flags [String]
 #      Optional. String of single letter flags for how the regexp is interpreted (E, I, and M cannot be used
 #      if pattern is a precompiled regexp):
@@ -37,18 +38,18 @@
 #
 Puppet::Functions.create_function(:regsubst) do
   dispatch :regsubst_string do
-    param          'Variant[Array[String],String]',  :target
-    param          'String',                         :pattern
-    param          'String',                         :replacement
-    optional_param 'Optional[Pattern[/^[GEIM]*$/]]', :flags
-    optional_param "Enum['N','E','S','U']",          :encoding
+    param          'Variant[Array[String],String]',       :target
+    param          'String',                              :pattern
+    param          'Variant[String,Hash[String,String]]', :replacement
+    optional_param 'Optional[Pattern[/^[GEIM]*$/]]',      :flags
+    optional_param "Enum['N','E','S','U']",               :encoding
   end
 
   dispatch :regsubst_regexp do
-    param          'Variant[Array[String],String]',  :target
-    param          'Variant[Regexp,Type[Regexp]]',   :pattern
-    param          'String',                         :replacement
-    optional_param 'Pattern[/^G?$/]',                :flags
+    param          'Variant[Array[String],String]',       :target
+    param          'Variant[Regexp,Type[Regexp]]',        :pattern
+    param          'Variant[String,Hash[String,String]]', :replacement
+    optional_param 'Pattern[/^G?$/]',                     :flags
   end
 
   def regsubst_string(target, pattern, replacement, flags = nil, encoding = nil)

data/lib/puppet/functions/then.rb

@@ -0,0 +1,74 @@
+# Call a [lambda](https://docs.puppet.com/puppet/latest/reference/lang_lambdas.html)
+# with the given argument unless the argument is undef. Return undef if argument is
+# undef, and otherwise the result of giving the argument to the lambda.
+#
+# This is useful to process a sequence of operations where an intermediate
+# result may be undef (which makes the entire sequence undef).
+# The `then` function is especially useful with the function `dig` which
+# performs in a similar way "digging out" a value in a complex structure.
+#
+# @example Using `then`
+#
+# ~~~ puppet
+# $data = {a => { b => [{x => 10, y => 20}, {x => 100, y => 200}]}}
+# notice $data.dig(a, b, 1, x).then |$x| { $x * 2 }
+# ~~~
+#
+# Would notice the value 200
+#
+# Contrast this with:
+#
+# ~~~ puppet
+# $data = {a => { b => [{x => 10, y => 20}, {ex => 100, why => 200}]}}
+# notice $data.dig(a, b, 1, x).then |$x| { $x * 2 }
+# ~~~
+#
+# Which would notice undef since the last lookup of 'x' results in `undef` which
+# is returned (without calling the block).
+#
+# As a result there was no need for conditional logic or a temporary (non local) 
+# variable as the result is now either the wanted value (x) multiplied
+# by 2 or `undef`.
+#
+# Calls to `then` can be chained. In the next example, a structure is using an offset that
+# is using 1 as the index to the first element (instead of 0 which is used in the language).
+# We are not sure if user input actually contains an index at all, or if it is
+# outside the range of available names.
+#
+# ~~~ puppet
+# # Names to choose from
+# $names = ['Ringo', 'Paul', 'George', 'John']
+#
+# # structure where 'beatle 2' is wanted (but where the number refers
+# # to 'Paul' because input comes from a source using 1 for the first
+# # element).
+#
+# $data = [202, { beatle => 2 }]
+# $picked = assert_type(String,
+#   # the data we are interested in is the second in the array,
+#   # a hash, where we want the value of the key 'beatle'
+#   $data.dig(1, 'beatle')
+#     # and we want the index in $names before the given index
+#     .then |$x| { $names[$x-1] }
+#     # so we can construct a string with that beatle's name
+#     .then |$x| { "Picked Beatle '${x}'" }
+# )
+#
+# ~~~ puppet
+#
+# Would notice "Picked Beatle 'Paul'", and would raise an error if the result
+# was not a String.
+#
+# @since 4.5.0
+#
+Puppet::Functions.create_function(:then) do
+  dispatch :then do
+    param 'Any', :arg
+    block_param 'Callable[1,1]', :block
+  end
+
+  def then(arg)
+    return nil if arg.nil?
+    yield(arg)
+  end
+end

data/lib/puppet/functions/type.rb

@@ -9,14 +9,14 @@
 # Would notice true
 #
 # By default, the best possible inference is made where all details are retained.
-# This is good when the type is used for futher type calculations but is overwhelmingly
-# rich i information if it is used in a error message.
+# This is good when the type is used for further type calculations but is overwhelmingly
+# rich in information if it is used in a error message.
 #
 # The optional argument `inference_method` may be given as (from lowest to highest fidelity):
 #
-# * ´generalized` - reduces to common type and drops size constraints
+# * `generalized` - reduces to common type and drops size constraints
 # * `reduced` - reduces to common type in collections
-# * `detailed` - (defaut) all details about inferred types is retained
+# * `detailed` - (default) all details about inferred types is retained
 #
 # @example Using `type()` with different qualities:
 #

data/lib/puppet/functions/with.rb

@@ -1,4 +1,4 @@
-# Call a [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+# Call a [lambda](https://docs.puppet.com/puppet/latest/reference/lang_lambdas.html)
 # with the given arguments and return the result. Since a lambda's scope is
 # [local](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html#lambda-scope)
 # to the lambda, you can use the `with` function to create private blocks of code within a

data/lib/puppet/indirector/catalog/compiler.rb

@@ -267,6 +267,8 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
         rescue Puppet::Error => detail
           Puppet.err(detail.to_s) if networked?
           raise
+        ensure
+          Puppet::Type.clear_misses unless Puppet[:always_retry_plugins]
         end
 
         if checksum_type && config.is_a?(model)

data/lib/puppet/indirector/resource_type/parser.rb

@@ -100,4 +100,9 @@ class Puppet::Indirector::ResourceType::Parser < Puppet::Indirector::Code
     environment.check_for_reparse
     environment.known_resource_types
   end
+
+  def allow_remote_requests?
+    Puppet.deprecation_warning("The resource_type endpoint is deprecated in favor of the environment_classes endpoint. See https://docs.puppet.com/puppetserver/latest/puppet-api/v3/environment_classes.html")
+    super
+  end
 end

data/lib/puppet/indirector/rest.rb

@@ -43,8 +43,12 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
 
   # Provide appropriate headers.
   def headers
+    # yaml is not allowed on the network
+    network_formats = model.supported_formats.reject do |format|
+      [:yaml, :b64_zlib_yaml].include?(format)
+    end
     common_headers = {
-      "Accept"                                     => model.supported_formats.join(", "),
+      "Accept"                                     => network_formats.join(", "),
       Puppet::Network::HTTP::HEADER_PUPPET_VERSION => Puppet.version
     }
 

data/lib/puppet/loaders.rb

@@ -10,11 +10,13 @@ module Puppet
       require 'puppet/pops/loader/dependency_loader'
       require 'puppet/pops/loader/null_loader'
       require 'puppet/pops/loader/static_loader'
+      require 'puppet/pops/loader/runtime3_type_loader'
       require 'puppet/pops/loader/ruby_function_instantiator'
       require 'puppet/pops/loader/puppet_function_instantiator'
       require 'puppet/pops/loader/type_definition_instantiator'
       require 'puppet/pops/loader/loader_paths'
       require 'puppet/pops/loader/simple_environment_loader'
+      require 'puppet/pops/loader/predefined_loader'
     end
   end
 

data/lib/puppet/metatype/manager.rb

@@ -20,6 +20,16 @@ module Manager
     }
   end
 
+  # Clears any types that were used but absent when types were last loaded.
+  # @note Used after each catalog compile when always_retry_plugins is false
+  # @api private
+  #
+  def clear_misses
+    unless @types.nil?
+      @types.delete_if {|_, v| v.nil? }
+    end
+  end
+
   # Iterates over all already loaded Type subclasses.
   # @yield [t] a block receiving each type
   # @yieldparam t [Puppet::Type] each defined type
@@ -116,6 +126,10 @@ module Manager
     klass.providerloader.loadall Puppet.lookup(:current_environment)
     klass.providify unless klass.providers.empty?
 
+    loc = block_given? ? block.source_location : nil
+    uri = loc.nil? ? nil : URI("#{Puppet::Util.path_to_uri(loc[0])}?line=#{loc[1]}")
+    Puppet::Pops::Loaders.register_runtime3_type(name, uri)
+
     klass
   end
 
@@ -146,16 +160,19 @@ module Manager
     # We are overwhelmingly symbols here, which usually match, so it is worth
     # having this special-case to return quickly.  Like, 25K symbols vs. 300
     # strings in this method. --daniel 2012-07-17
-    return @types[name] if @types[name]
+    return @types[name] if @types.include? name
 
     # Try mangling the name, if it is a string.
     if name.is_a? String
       name = name.downcase.intern
-      return @types[name] if @types[name]
+      return @types[name] if @types.include? name
     end
     # Try loading the type.
     if typeloader.load(name, Puppet.lookup(:current_environment))
       Puppet.warning "Loaded puppet/type/#{name} but no class was created" unless @types.include? name
+    elsif !Puppet[:always_retry_plugins]
+      # PUP-5482 - Only look for a type once if plugin retry is disabled
+      @types[name] = nil
     end
 
     # ...and I guess that is that, eh.

data/lib/puppet/module_tool/applications/application.rb

@@ -41,7 +41,7 @@ module Puppet::ModuleTool
         end
 
         if require_metadata && !Puppet::ModuleTool.is_module_root?(@path)
-          raise ArgumentError, "Unable to find metadata.json in module root at #{@path} See https://docs.puppetlabs.com/puppet/latest/reference/modules_publishing.html for required file format."
+          raise ArgumentError, "Unable to find metadata.json in module root at #{@path} See https://docs.puppet.com/puppet/latest/reference/modules_publishing.html for required file format."
         end
 
         metadata_path   = File.join(@path, 'metadata.json')

data/lib/puppet/module_tool/skeleton/templates/generator/Gemfile

@@ -1,6 +1,6 @@
 source ENV['GEM_SOURCE'] || 'https://rubygems.org'
 
-puppetversion = ENV.key?('PUPPET_VERSION') ? "#{ENV['PUPPET_VERSION']}" : ['>= 3.3']
+puppetversion = ENV.key?('PUPPET_VERSION') ? ENV['PUPPET_VERSION'] : ['>= 3.3']
 gem 'metadata-json-lint'
 gem 'puppet', puppetversion
 gem 'puppetlabs_spec_helper', '>= 1.0.0'
@@ -9,6 +9,10 @@ gem 'facter', '>= 1.7.0'
 gem 'rspec-puppet'
 
 # rspec must be v2 for ruby 1.8.7
-if RUBY_VERSION >= '1.8.7' and RUBY_VERSION < '1.9'
+if RUBY_VERSION >= '1.8.7' && RUBY_VERSION < '1.9'
   gem 'rspec', '~> 2.0'
+  gem 'rake', '~> 10.0'
+else
+  # rubocop requires ruby >= 1.9
+  gem 'rubocop'
 end

data/lib/puppet/module_tool/skeleton/templates/generator/Rakefile

@@ -1,17 +1,32 @@
 require 'puppetlabs_spec_helper/rake_tasks'
 require 'puppet-lint/tasks/puppet-lint'
+require 'metadata-json-lint/rake_task'
+
+if RUBY_VERSION >= '1.9'
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+end
+
 PuppetLint.configuration.send('disable_80chars')
-PuppetLint.configuration.ignore_paths = ["spec/**/*.pp", "pkg/**/*.pp"]
+PuppetLint.configuration.relative = true
+PuppetLint.configuration.ignore_paths = ['spec/**/*.pp', 'pkg/**/*.pp']
 
-desc "Validate manifests, templates, and ruby files"
+desc 'Validate manifests, templates, and ruby files'
 task :validate do
   Dir['manifests/**/*.pp'].each do |manifest|
     sh "puppet parser validate --noop #{manifest}"
   end
-  Dir['spec/**/*.rb','lib/**/*.rb'].each do |ruby_file|
-    sh "ruby -c #{ruby_file}" unless ruby_file =~ /spec\/fixtures/
+  Dir['spec/**/*.rb', 'lib/**/*.rb'].each do |ruby_file|
+    sh "ruby -c #{ruby_file}" unless ruby_file =~ %r{spec/fixtures}
   end
   Dir['templates/**/*.erb'].each do |template|
     sh "erb -P -x -T '-' #{template} | ruby -c"
   end
 end
+
+desc 'Run metadata_lint, lint, validate, and spec tests.'
+task :test do
+  [:metadata_lint, :lint, :validate, :spec].each do |test|
+    Rake::Task[test].invoke
+  end
+end

data/lib/puppet/module_tool/skeleton/templates/generator/{tests → examples}/init.pp.erb

@@ -7,6 +7,6 @@
 # environment (to compare the resulting system state to the desired state).
 #
 # Learn more about module testing here:
-# https://docs.puppetlabs.com/guides/tests_smoke.html
+# https://docs.puppet.com/guides/tests_smoke.html
 #
 include ::<%= metadata.name %>

data/lib/puppet/module_tool/skeleton/templates/generator/spec/classes/init_spec.rb.erb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 describe '<%= metadata.name %>' do
-
   context 'with default values for all parameters' do
     it { should contain_class('<%= metadata.name %>') }
   end

data/lib/puppet/network/http/api/master/v3/environment.rb

@@ -5,14 +5,18 @@ class Puppet::Network::HTTP::API::Master::V3::Environment
   def call(request, response)
     env_name = request.routing_path.split('/').last
     env = Puppet.lookup(:environments).get(env_name)
+    code_id = request.params[:code_id]
 
     if env.nil?
       raise Puppet::Network::HTTP::Error::HTTPNotFoundError.new("#{env_name} is not a known environment", Puppet::Network::HTTP::Issues::RESOURCE_NOT_FOUND)
     end
 
-    catalog = Puppet::Parser::EnvironmentCompiler.compile(env).to_resource
+    catalog = Puppet::Parser::EnvironmentCompiler.compile(env, code_id).to_resource
 
-    env_graph = {:environment => env.name, :applications => {}}
+    # This reads code_id off the catalog rather than using the one from the
+    # request. There shouldn't really be a case where the two differ, but if
+    # they do, the one from the catalog itself is authoritative.
+    env_graph = {:environment => env.name, :applications => {}, :code_id => catalog.code_id}
     applications = catalog.resources.select do |res|
       type = res.resource_type
       type.is_a?(Puppet::Resource::Type) && type.application?

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

@@ -102,6 +102,10 @@ class Puppet::Parser::AST::PopsBridge
           # 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
@@ -189,7 +193,9 @@ class Puppet::Parser::AST::PopsBridge
     end
 
     def instantiate_ResourceTypeDefinition(o, modname)
-      Puppet::Resource::Type.new(:definition, o.name, @context.merge(args_from_definition(o, modname)))
+      instance = Puppet::Resource::Type.new(:definition, o.name, @context.merge(args_from_definition(o, modname)))
+      Puppet::Pops::Loaders.register_runtime3_type(instance.name, Puppet::Pops::Adapters::SourcePosAdapter.adapt(o).to_uri)
+      instance
     end
 
     def instantiate_CapabilityMapping(o, modname)
@@ -262,12 +268,23 @@ class Puppet::Parser::AST::PopsBridge
       loader = Puppet::Pops::Loaders.find_loader(modname)
 
       # Bind the type alias to the loader using the alias
-      typed_name, t = Puppet::Pops::Loader::TypeDefinitionInstantiator.create_from_model(type_alias, loader)
-      loader.set_entry(typed_name, t, Puppet::Pops::Adapters::SourcePosAdapter.adapt(type_alias).to_uri)
+      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.new
+      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/catalog_validator/relationship_validator.rb

@@ -15,9 +15,31 @@ class Puppet::Parser::Compiler
 
     private
 
+    # A hash lookup is 6x avg times faster than find among 3 values.
+    CAPABILITY_ACCEPTED_METAPARAMS = {:require => true, :consume => true, :export => true}.freeze
+
     def validate_relationship(param)
-      unless [:require, :consume, :export].find {|pname| pname == param.name }
-        raise CatalogValidationError.new("'#{param.name}' is not a valid relationship to a capability", param.file, param.line) if has_capability?(param.value)
+      # when relationship is to a capability
+      if has_capability?(param.value)
+        unless CAPABILITY_ACCEPTED_METAPARAMS[param.name]
+          raise CatalogValidationError.new(
+            "'#{param.name}' is not a valid relationship to a capability", 
+              param.file, param.line)
+        end
+      elsif Puppet[:strict] != :off
+        # all other relationships requires the referenced resource to exist when mode is strict
+        refs = param.value.is_a?(Array) ? param.value.flatten : [param.value]
+        refs.each do |r|
+          next if r.nil?
+          unless catalog.resource(r.to_s)
+            msg = "Could not find resource '#{r.to_s}' in parameter '#{param.name.to_s}'"
+            if Puppet[:strict] == :error
+              raise CatalogValidationError.new(msg, param.file, param.line)
+            else
+              Puppet.warn_once(:undefined_resources, r.to_s, msg, param.file, param.line)
+            end
+          end
+        end
       end
     end
 

data/lib/puppet/parser/e4_parser_adapter.rb

@@ -1,16 +1,16 @@
 require 'puppet/pops'
 
-module Puppet; module Parser; end; end;
+module Puppet
+module Parser
 # Adapts an egrammar/eparser to respond to the public API of the classic parser
 # and makes use of the new evaluator.
 #
-class Puppet::Parser::E4ParserAdapter
+class E4ParserAdapter
 
   def initialize
     @file = ''
     @string = ''
     @use = :unspecified
-    @@evaluating_parser ||= Puppet::Pops::Parser::EvaluatingParser.new()
   end
 
   def file=(file)
@@ -20,15 +20,15 @@ class Puppet::Parser::E4ParserAdapter
 
   def parse(string = nil)
     self.string= string if string
-
+    parser = Pops::Parser::EvaluatingParser.singleton
     parse_result =
     if @use == :string
       # Parse with a source_file to set in created AST objects (it was either given, or it may be unknown
       # if caller did not set a file and the present a string.
       #
-      @@evaluating_parser.parse_string(@string, @file || "unknown-source-location")
+      parser.parse_string(@string, @file || "unknown-source-location")
     else
-      @@evaluating_parser.parse_file(@file)
+      parser.parse_file(@file)
     end
 
     # the parse_result may be
@@ -38,19 +38,18 @@ class Puppet::Parser::E4ParserAdapter
     #
     model = parse_result.nil? ? nil : parse_result.current
     args = {}
-    Puppet::Pops::Model::AstTransformer.new(@file).merge_location(args, model)
+    Pops::Model::AstTransformer.new(@file).merge_location(args, model)
 
     ast_code =
-    if model.is_a? Puppet::Pops::Model::Program
-      Puppet::Parser::AST::PopsBridge::Program.new(model, args)
+    if model.is_a? Pops::Model::Program
+      AST::PopsBridge::Program.new(model, args)
     else
       args[:value] = model
-      Puppet::Parser::AST::PopsBridge::Expression.new(args)
+      AST::PopsBridge::Expression.new(args)
     end
 
     # Create the "main" class for the content - this content will get merged with all other "main" content
-    Puppet::Parser::AST::Hostclass.new('', :code => ast_code)
-
+    AST::Hostclass.new('', :code => ast_code)
   end
 
   def string=(string)
@@ -58,3 +57,5 @@ class Puppet::Parser::E4ParserAdapter
     @use = :string
   end
 end
+end
+end