puppet 4.1.0 → 5.0.0

data/lib/puppet/forge/repository.rb

@@ -45,7 +45,7 @@ class Puppet::Forge
     # Return a Net::HTTPResponse read for this +path+.
     def make_http_request(path, io = nil)
       Puppet.debug "HTTP GET #{@host}#{path}"
-      request = get_request_object(path)
+      request = get_request_object(@uri.path.chomp('/')+path)
       return read_response(request, io)
     end
 
@@ -57,6 +57,7 @@ class Puppet::Forge
       end
     end
 
+    # responsible for properly encoding a URI
     def get_request_object(path)
       headers = {
         "User-Agent" => user_agent,
@@ -72,7 +73,7 @@ class Puppet::Forge
         headers = headers.merge({"Authorization" => forge_authorization})
       end
 
-      request = Net::HTTP::Get.new(URI.escape(path), headers)
+      request = Net::HTTP::Get.new(Puppet::Util.uri_encode(path), headers)
 
       unless @uri.user.nil? || @uri.password.nil? || forge_authorization
         request.basic_auth(@uri.user, @uri.password)
@@ -90,7 +91,7 @@ class Puppet::Forge
     # @raise [Puppet::Forge::Errors::SSLVerifyError] if there is a problem
     #  verifying the remote SSL certificate
     def read_response(request, io = nil)
-      http_object = get_http_object
+      http_object = Puppet::Util::HttpProxy.get_http_object(uri)
 
       http_object.start do |http|
         response = http.request(request)
@@ -121,37 +122,6 @@ class Puppet::Forge
       end
     end
 
-    # Return a Net::HTTP::Proxy object constructed from the settings provided
-    # accessing the repository.
-    #
-    # This method optionally configures SSL correctly if the URI scheme is
-    # 'https', including setting up the root certificate store so remote server
-    # SSL certificates can be validated.
-    #
-    # @return [Net::HTTP::Proxy] object constructed from repo settings
-    def get_http_object
-      proxy_class = Net::HTTP::Proxy(Puppet::Util::HttpProxy.http_proxy_host, Puppet::Util::HttpProxy.http_proxy_port, Puppet::Util::HttpProxy.http_proxy_user, Puppet::Util::HttpProxy.http_proxy_password)
-      proxy = proxy_class.new(@uri.host, @uri.port)
-
-      if @uri.scheme == 'https'
-        cert_store = OpenSSL::X509::Store.new
-        cert_store.set_default_paths
-
-        proxy.use_ssl = true
-        proxy.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        proxy.cert_store = cert_store
-      end
-
-      if Puppet[:http_debug]
-        proxy.set_debug_output($stderr)
-      end
-
-      proxy.open_timeout = Puppet[:http_connect_timeout]
-      proxy.read_timeout = Puppet[:http_read_timeout]
-
-      proxy
-    end
-
     # Return the local file name containing the data downloaded from the
     # repository at +release+ (e.g. "myuser-mymodule").
     def retrieve(release)
@@ -178,8 +148,7 @@ class Puppet::Forge
     def user_agent
       @user_agent ||= [
         @agent,
-        "Puppet/#{Puppet.version}",
-        "Ruby/#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} (#{RUBY_PLATFORM})",
+        Puppet[:http_user_agent]
       ].join(' ').freeze
     end
   end

data/lib/puppet/forge.rb

@@ -6,9 +6,9 @@ require 'tempfile'
 require 'uri'
 require 'pathname'
 require 'json'
-require 'semantic'
+require 'semantic_puppet'
 
-class Puppet::Forge < Semantic::Dependency::Source
+class Puppet::Forge < SemanticPuppet::Dependency::Source
   require 'puppet/forge/cache'
   require 'puppet/forge/repository'
   require 'puppet/forge/errors'
@@ -38,7 +38,7 @@ class Puppet::Forge < Semantic::Dependency::Source
   #     "releases"    => [{"version"=>"0.0.1"}, {"version"=>"0.0.2"}],
   #     "full_name"   => "puppetlabs/bacula",
   #     "version"     => "0.0.2",
-  #     "project_url" => "http://github.com/puppetlabs/puppetlabs-bacula",
+  #     "project_url" => "https://github.com/puppetlabs/puppetlabs-bacula",
   #     "desc"        => "bacula"
   #   }
   # ]
@@ -53,12 +53,13 @@ class Puppet::Forge < Semantic::Dependency::Source
   #   bad HTTP response
   def search(term)
     matches = []
-    uri = "/v3/modules?query=#{URI.escape(term)}"
+    uri = "/v3/modules?query=#{term}"
     if Puppet[:module_groups]
-      uri += "&module_groups=#{Puppet[:module_groups]}"
+      uri += "&module_groups=#{Puppet[:module_groups].gsub('+', ' ')}"
     end
 
     while uri
+      # make_http_request URI encodes parameters
       response = make_http_request(uri)
 
       if response.code == '200'
@@ -83,18 +84,19 @@ class Puppet::Forge < Semantic::Dependency::Source
   # Fetches {ModuleRelease} entries for each release of the named module.
   #
   # @param input [String] the module name to look up
-  # @return [Array<Semantic::Dependency::ModuleRelease>] a list of releases for
+  # @return [Array<SemanticPuppet::Dependency::ModuleRelease>] a list of releases for
   #         the given name
-  # @see Semantic::Dependency::Source#fetch
+  # @see SemanticPuppet::Dependency::Source#fetch
   def fetch(input)
     name = input.tr('/', '-')
     uri = "/v3/releases?module=#{name}"
     if Puppet[:module_groups]
-      uri += "&module_groups=#{Puppet[:module_groups]}"
+      uri += "&module_groups=#{Puppet[:module_groups].gsub('+', ' ')}"
     end
     releases = []
 
     while uri
+      # make_http_request URI encodes parameters
       response = make_http_request(uri)
 
       if response.code == '200'
@@ -114,22 +116,22 @@ class Puppet::Forge < Semantic::Dependency::Source
     @repository.make_http_request(*args)
   end
 
-  class ModuleRelease < Semantic::Dependency::ModuleRelease
+  class ModuleRelease < SemanticPuppet::Dependency::ModuleRelease
     attr_reader :install_dir, :metadata
 
-    def initialize(source, data)
+    def initialize(source, data, strict_semver = true)
       @data = data
       @metadata = meta = data['metadata']
 
       name = meta['name'].tr('/', '-')
-      version = Semantic::Version.parse(meta['version'])
+      version = SemanticPuppet::Version.parse(meta['version'])
       release = "#{name}@#{version}"
 
       if meta['dependencies']
         dependencies = meta['dependencies'].collect do |dep|
           begin
             Puppet::ModuleTool::Metadata.new.add_dependency(dep['name'], dep['version_requirement'], dep['repository'])
-            Puppet::ModuleTool.parse_module_dependency(release, dep)[0..1]
+            Puppet::ModuleTool.parse_module_dependency(release, dep, strict_semver)[0..1]
           rescue ArgumentError => e
             raise ArgumentError, "Malformed dependency: #{dep['name']}. Exception was: #{e}"
           end
@@ -195,7 +197,7 @@ class Puppet::Forge < Semantic::Dependency::Source
 
     def validate_checksum(file, checksum)
       if Digest::MD5.file(file.path).hexdigest != checksum
-        raise RuntimeError, "Downloaded release for #{name} did not match expected checksum"
+        raise RuntimeError, _("Downloaded release for %{name} did not match expected checksum") % { name: name }
       end
     end
 
@@ -203,7 +205,7 @@ class Puppet::Forge < Semantic::Dependency::Source
       begin
         Puppet::ModuleTool::Applications::Unpacker.unpack(file.path, destination)
       rescue Puppet::ExecutionFailure => e
-        raise RuntimeError, "Could not extract contents of module archive: #{e.message}"
+        raise RuntimeError, _("Could not extract contents of module archive: %{message}") % { message: e.message }
       end
     end
   end
@@ -216,7 +218,7 @@ class Puppet::Forge < Semantic::Dependency::Source
       begin
         ModuleRelease.new(self, release)
       rescue ArgumentError => e
-        Puppet.warning "Cannot consider release #{metadata['name']}-#{metadata['version']}: #{e}"
+        Puppet.warning _("Cannot consider release %{name}-%{version}: %{error}") % { name: metadata['name'], version: metadata['version'], error: e }
         false
       end
     end

data/lib/puppet/functions/alert.rb

@@ -0,0 +1,14 @@
+# Log a message on the server at level alert.
+Puppet::Functions.create_function(:alert, Puppet::Functions::InternalFunction) do
+  # @param values The values to log.
+  # @return [Undef]
+  dispatch :alert do
+    scope_param
+    repeated_param 'Any', :values
+    return_type 'Undef'
+  end
+
+  def alert(scope, *values)
+    Puppet::Util::Log.log_func(scope, :alert, values)
+  end
+end

data/lib/puppet/functions/annotate.rb

@@ -0,0 +1,108 @@
+# Handles annotations on objects. The function can be used in four different ways.
+#
+# With two arguments, an `Annotation` type and an object, the function returns the annotation
+# for the object of the given type, or `undef` if no such annotation exists.
+#
+# @example Using `annotate` with two arguments
+#
+# ~~~ puppet
+# $annotation = Mod::NickNameAdapter.annotate(o)
+#
+# $annotation = annotate(Mod::NickNameAdapter.annotate, o)
+# ~~~
+#
+# With three arguments, an `Annotation` type, an object, and a block, the function returns the
+# annotation for the object of the given type, or annotates it with a new annotation initialized
+# from the hash returned by the given block when no such annotation exists. The block will not
+# be called when an annotation of the given type is already present.
+#
+# @example Using `annotate` with two arguments and a block
+#
+# ~~~ puppet
+# $annotation = Mod::NickNameAdapter.annotate(o) || { { 'nick_name' => 'Buddy' } }
+#
+# $annotation = annotate(Mod::NickNameAdapter.annotate, o) || { { 'nick_name' => 'Buddy' } }
+# ~~~
+#
+# With three arguments, an `Annotation` type, an object, and an `Hash`, the function will annotate
+# the given object with a new annotation of the given type that is initialized from the given hash.
+# An existing annotation of the given type is discarded.
+#
+# @example Using `annotate` with three arguments where third argument is a Hash
+#
+# ~~~ puppet
+# $annotation = Mod::NickNameAdapter.annotate(o, { 'nick_name' => 'Buddy' })
+#
+# $annotation = annotate(Mod::NickNameAdapter.annotate, o, { 'nick_name' => 'Buddy' })
+# ~~~
+#
+# With three arguments, an `Annotation` type, an object, and an the string `clear`, the function will
+# clear the annotatation of the given type in the given object. The old annotation is returned if
+# it existed.
+#
+# @example Using `annotate` with three arguments where third argument is the string 'clear'
+#
+# ~~~ puppet
+# $annotation = Mod::NickNameAdapter.annotate(o, clear)
+#
+# $annotation = annotate(Mod::NickNameAdapter.annotate, o, clear)
+# ~~~
+#
+# With three arguments, the type `Pcore`, an object, and a Hash of hashes keyed by `Annotation` types,
+# the function will annotate the given object with all types used as keys in the given hash. Each annotation
+# is initialized with the nested hash for the respective type. The annotated object is returned.
+#
+# @example Add multiple annotations to a new instance of `Mod::Person` using the `Pcore` type.
+#
+# ~~~ puppet
+#   $person = Pcore.annotate(Mod::Person({'name' => 'William'}), {
+#     Mod::NickNameAdapter >= { 'nick_name' => 'Bill' },
+#     Mod::HobbiesAdapter => { 'hobbies' => ['Ham Radio', 'Philatelist'] }
+#   })
+# ~~~
+#
+# @since 5.0.0
+#
+Puppet::Functions.create_function(:annotate) do
+  dispatch :annotate do
+    param 'Type[Annotation]', :type
+    param 'Any', :value
+    optional_block_param 'Callable[0, 0]', :block
+  end
+
+  dispatch :annotate_new do
+    param 'Type[Annotation]', :type
+    param 'Any', :value
+    param 'Variant[Enum[clear],Hash[Pcore::MemberName,Any]]', :annotation_hash
+  end
+
+  dispatch :annotate_multi do
+    param 'Type[Pcore]', :type
+    param 'Any', :value
+    param 'Hash[Type[Annotation], Hash[Pcore::MemberName,Any]]', :annotations
+  end
+
+  # @param type [Annotation] the annotation type
+  # @param value [Object] the value to annotate
+  # @param block [Proc] optional block to produce the annotation hash
+  #
+  def annotate(type, value, &block)
+    type.implementation_class.annotate(value, &block)
+  end
+
+  # @param type [Annotation] the annotation type
+  # @param value [Object] the value to annotate
+  # @param annotation_hash [Hash{String => Object}] the annotation hash
+  #
+  def annotate_new(type, value, annotation_hash)
+    type.implementation_class.annotate_new(value, annotation_hash)
+  end
+
+  # @param type [Type] the Pcore type
+  # @param value [Object] the value to annotate
+  # @param annotations [Hash{Annotation => Hash{String => Object}}] hash of annotation hashes
+  #
+  def annotate_multi(type, value, annotations)
+    type.implementation_class.annotate(value, annotations)
+  end
+end

data/lib/puppet/functions/assert_type.rb

@@ -1,18 +1,54 @@
-# Returns the given value if it is an instance of the given type, and raises an error otherwise.
-# Optionally, if a block is given (accepting two parameters), it will be called instead of raising
-# an error. This to enable giving the user richer feedback, or to supply a default value.
+# Returns the given value if it is of the given
+# [data type](https://docs.puppetlabs.com/puppet/latest/reference/lang_data.html), or
+# otherwise either raises an error or executes an optional two-parameter
+# [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html).
 #
-# @example how to assert type
-#   # assert that `$b` is a non empty `String` and assign to `$a`
-#   $a = assert_type(String[1], $b)
+# The function takes two mandatory arguments, in this order:
 #
-# @example using custom error message
-#   $a = assert_type(String[1], $b) |$expected, $actual| { fail("The name cannot be empty") }
+# 1. The expected data type.
+# 2. A value to compare against the expected data type.
 #
-# @example using a warning and a default
-#   $a = assert_type(String[1], $b) |$expected, $actual| { warning("Name is empty, using default") 'anonymous' }
+# @example Using `assert_type`
 #
-# See the documentation for "The Puppet Type System" for more information about types.
+# ~~~ puppet
+# $raw_username = 'Amy Berry'
+#
+# # Assert that $raw_username is a non-empty string and assign it to $valid_username.
+# $valid_username = assert_type(String[1], $raw_username)
+#
+# # $valid_username contains "Amy Berry".
+# # If $raw_username was an empty string or a different data type, the Puppet run would
+# # fail with an "Expected type does not match actual" error.
+# ~~~
+#
+# You can use an optional lambda to provide enhanced feedback. The lambda takes two
+# mandatory parameters, in this order:
+#
+# 1. The expected data type as described in the function's first argument.
+# 2. The actual data type of the value.
+#
+# @example Using `assert_type` with a warning and default value
+#
+# ~~~ puppet
+# $raw_username = 'Amy Berry'
+#
+# # Assert that $raw_username is a non-empty string and assign it to $valid_username.
+# # If it isn't, output a warning describing the problem and use a default value.
+# $valid_username = assert_type(String[1], $raw_username) |$expected, $actual| {
+#   warning( "The username should be \'${expected}\', not \'${actual}\'. Using 'anonymous'." )
+#   'anonymous'
+# }
+#
+# # $valid_username contains "Amy Berry".
+# # If $raw_username was an empty string, the Puppet run would set $valid_username to
+# # "anonymous" and output a warning: "The username should be 'String[1, default]', not
+# # 'String[0, 0]'. Using 'anonymous'."
+# ~~~
+#
+# For more information about data types, see the
+# [documentation](https://docs.puppetlabs.com/puppet/latest/reference/lang_data.html).
+#
+# @since 4.0.0
 #
 Puppet::Functions.create_function(:assert_type) do
   dispatch :assert_type do
@@ -32,18 +68,16 @@ Puppet::Functions.create_function(:assert_type) do
   #
   def assert_type(type, value)
     unless Puppet::Pops::Types::TypeCalculator.instance?(type,value)
-      inferred_type = Puppet::Pops::Types::TypeCalculator.infer(value)
+      inferred_type = Puppet::Pops::Types::TypeCalculator.infer_set(value)
       if block_given?
-        # Give the inferred type to allow richer comparisson in the given block (if generalized
+        # Give the inferred type to allow richer comparison in the given block (if generalized
         # information is lost).
         #
         value = yield(type, inferred_type)
       else
-        # Do not give all the details - i.e. format as Integer, instead of Integer[n, n] for exact value, which
-        # is just confusing. (OTOH: may need to revisit, or provide a better "type diff" output.
-        #
-        actual = Puppet::Pops::Types::TypeCalculator.generalize!(inferred_type)
-        raise Puppet::Pops::Types::TypeAssertionError.new("assert_type(): Expected type #{type} does not match actual: #{actual}", type,actual)
+        raise Puppet::Pops::Types::TypeAssertionError.new(
+          Puppet::Pops::Types::TypeMismatchDescriber.singleton.describe_mismatch('assert_type():', type, inferred_type),
+          type, inferred_type)
       end
     end
     value
@@ -53,7 +87,7 @@ Puppet::Functions.create_function(:assert_type) do
   # @param value [Object] the value to assert
   #
   def assert_type_s(type_string, value, &proc)
-    t = Puppet::Pops::Types::TypeParser.new.parse(type_string)
+    t = Puppet::Pops::Types::TypeParser.singleton.parse(type_string)
     block_given? ? assert_type(t, value, &proc) : assert_type(t, value)
   end
 end

data/lib/puppet/functions/binary_file.rb

@@ -0,0 +1,19 @@
+# Loads a binary file from a module or file system and returns its contents as a Binary.
+# (Documented in 3.x stub)
+#
+# @since 4.8.0
+#
+Puppet::Functions.create_function(:binary_file, Puppet::Functions::InternalFunction) do
+  dispatch :binary_file do
+    scope_param
+    param 'String', :path
+  end
+
+  def binary_file(scope, unresolved_path)
+    path = Puppet::Parser::Files.find_file(unresolved_path, scope.compiler.environment)
+    unless path && Puppet::FileSystem.exist?(path)
+      raise Puppet::ParseError, _("binary_file(): The given file '%{unresolved_path}' does not exist") % { unresolved_path: unresolved_path }
+    end
+    Puppet::Pops::Types::PBinaryType::Binary.from_binary_string(Puppet::FileSystem.binread(path))
+  end
+end

data/lib/puppet/functions/break.rb

@@ -0,0 +1,22 @@
+# Make iteration break as if there were no more values to process
+#
+# @since 4.7.0
+#
+Puppet::Functions.create_function(:break) do
+  dispatch :break_impl do
+  end
+
+  def break_impl()
+    stacktrace = Puppet::Pops::PuppetStack.stacktrace()
+    if stacktrace.size > 0
+      file, line = stacktrace[0]
+    else
+      file = nil
+      line = nil
+    end
+    # PuppetStopIteration contains file and line and is a StopIteration exception
+    # so it can break a Ruby Kernel#loop or enumeration
+    #
+    raise Puppet::Pops::Evaluator::PuppetStopIteration.new(file, line)
+  end
+end

data/lib/puppet/functions/call.rb

@@ -0,0 +1,42 @@
+# Calls an arbitrary Puppet function by name.
+#
+# This function takes one mandatory argument and one or more optional arguments:
+#
+# 1. A string corresponding to a function name.
+# 2. Any number of arguments to be passed to the called function.
+# 3. An optional lambda, if the function being called supports it.
+#
+# @example Using the `call` function
+#
+# ~~~ puppet
+# $a = 'notice'
+# call($a, 'message')
+# ~~~
+#
+# @example Using the `call` function with a lambda
+#
+# ~~~ puppet
+# $a = 'each'
+# $b = [1,2,3]
+# call($a, $b) |$item| {
+#  notify { $item: }
+# }
+# ~~~
+#
+# The `call` function can be used to call either Ruby functions or Puppet language
+# functions.
+#
+# @since 5.0.0
+#
+Puppet::Functions.create_function(:call, Puppet::Functions::InternalFunction) do
+  dispatch :call_impl_block do
+    scope_param
+    param 'String', :function_name
+    repeated_param 'Any', :arguments
+    optional_block_param
+  end
+
+  def call_impl_block(scope, function_name, *args, &block)
+    call_function_with_scope(scope, function_name, *args, &block)
+  end
+end

data/lib/puppet/functions/contain.rb

@@ -0,0 +1,33 @@
+# Called within a class definition, establishes a containment
+# relationship with another class
+# For documentation, see the 3.x stub
+#
+Puppet::Functions.create_function(:contain, Puppet::Functions::InternalFunction) do
+  dispatch :contain do
+    scope_param
+    # The function supports what the type system sees as Ruby runtime objects, and
+    # they cannot be parameterized to find what is actually valid instances.
+    # The validation is instead done in the function body itself via a call to
+    # `transform_and_assert_classnames` on the calling scope.
+    required_repeated_param 'Any', :names
+  end
+
+  def contain(scope, *classes)
+    # Make call patterns uniform and protected against nested arrays, also make
+    # names absolute if so desired.
+    classes = scope.transform_and_assert_classnames(classes.flatten)
+
+    result = classes.map {|name| Puppet::Pops::Types::TypeFactory.host_class(name) }
+    containing_resource = scope.resource
+
+    # This is the same as calling the include function but faster and does not rely on the include
+    # function.
+    (scope.compiler.evaluate_classes(classes, scope, false) || []).each do |resource|
+      if ! scope.catalog.edge?(containing_resource, resource)
+        scope.catalog.add_edge(containing_resource, resource)
+      end
+    end
+    # Result is an Array[Class, 1, n] which allows chaining other operations
+    result
+  end
+end

data/lib/puppet/functions/crit.rb

@@ -0,0 +1,14 @@
+# Log a message on the server at level crit.
+Puppet::Functions.create_function(:crit, Puppet::Functions::InternalFunction) do
+  # @param values The values to log.
+  # @return [Undef]
+  dispatch :crit do
+    scope_param
+    repeated_param 'Any', :values
+    return_type 'Undef'
+  end
+
+  def crit(scope, *values)
+    Puppet::Util::Log.log_func(scope, :crit, values)
+  end
+end

data/lib/puppet/functions/debug.rb

@@ -0,0 +1,14 @@
+# Log a message on the server at level debug.
+Puppet::Functions.create_function(:debug, Puppet::Functions::InternalFunction) do
+  # @param values The values to log.
+  # @return [Undef]
+  dispatch :debug do
+    scope_param
+    repeated_param 'Any', :values
+    return_type 'Undef'
+  end
+
+  def debug(scope, *values)
+    Puppet::Util::Log.log_func(scope, :debug, values)
+  end
+end