puppet 6.0.10-universal-darwin → 6.1.0-universal-darwin

data/lib/puppet/forge.rb

@@ -17,9 +17,6 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
 
   USER_AGENT = "PMT/1.1.1 (v3; Net::HTTP)".freeze
 
-  # From https://forgeapi.puppet.com/#!/release/getReleases
-  MODULE_RELEASE_EXCLUSIONS=%w[readme changelog license uri module tags supported file_size downloads created_at updated_at deleted_at].join(',').freeze
-
   attr_reader :host, :repository
 
   def initialize(host = Puppet[:module_repository])
@@ -92,7 +89,7 @@ class Puppet::Forge < SemanticPuppet::Dependency::Source
   # @see SemanticPuppet::Dependency::Source#fetch
   def fetch(input)
     name = input.tr('/', '-')
-    uri = "/v3/releases?module=#{name}&sort_by=version&exclude_fields=#{MODULE_RELEASE_EXCLUSIONS}"
+    uri = "/v3/releases?module=#{name}&sort_by=version"
     if Puppet[:module_groups]
       uri += "&module_groups=#{Puppet[:module_groups].gsub('+', ' ')}"
     end

data/lib/puppet/functions/abs.rb

@@ -28,7 +28,7 @@
 # Integer($strval, 10, true) # Converts to absolute Integer using base 10 (decimal)
 # Integer($strval, 16, true) # Converts to absolute Integer using base 16 (hex)
 # Float($strval, true)       # Converts to absolute Float
-# ```puppet
+# ```
 #
 Puppet::Functions.create_function(:abs) do
   dispatch :on_numeric do

data/lib/puppet/functions/call.rb

@@ -69,8 +69,7 @@ Puppet::Functions.create_function(:call, Puppet::Functions::InternalFunction) do
   end
 
   def call_impl_block(scope, function_name, *args, &block)
-    # The call function must be able to call functions loaded by any loader visible from the calling scope.
-    Puppet::Pops::Parser::EvaluatingParser.new.evaluator.external_call_function(function_name, args, scope, &block)
+    call_function_with_scope(scope, function_name, *args, &block)
   end
 
   def call_deferred(scope, deferred)

data/lib/puppet/functions/new.rb

@@ -608,7 +608,7 @@
 # | Format | String
 # | ------ | ------
 # | s      | Unquoted string, verbatim output of control chars.
-# | p      | Programmatic representation - strings are quoted, interior quotes and control chars are escaped.
+# | p      | Programmatic representation - strings are quoted, interior quotes and control chars are escaped. Selects single or double quotes based on content, or uses double quotes if alternative flag `#` is used.
 # | C      | Each `::` name segment capitalized, quoted if alternative flag `#` is used.
 # | c      | Capitalized string, quoted if alternative flag `#` is used.
 # | d      | Downcased string, quoted if alternative flag `#` is used.

data/lib/puppet/indirector/request.rb

@@ -200,37 +200,26 @@ class Puppet::Indirector::Request
       end
     end
 
-    if default_server
-      self.server = default_server
-    else
-      self.server = Puppet.lookup(:server) do
-        if primary_server = Puppet.settings[:server_list][0]
-          #TRANSLATORS 'server_list' is the name of a setting and should not be translated
-          Puppet.debug _("Selected server from first entry of the `server_list` setting: %{server}") % {server: primary_server[0]}
-          primary_server[0]
-        else
-          #TRANSLATORS 'server' is the name of a setting and should not be translated
-          Puppet.debug _("Selected server from the `server` setting: %{server}") % {server: Puppet.settings[:server]}
-          Puppet.settings[:server]
-        end
+    # ... Fall back onto the default server.
+    bound_server = Puppet.lookup(:server) do
+      if primary_server = Puppet.settings[:server_list][0]
+        primary_server[0]
+      else
+        Puppet.settings[:server]
       end
     end
 
-    if default_port
-      self.port = default_port
-    else
-      self.port = Puppet.lookup(:serverport) do
-        if primary_server = Puppet.settings[:server_list][0]
-          #TRANSLATORS 'server_list' is the name of a setting and should not be translated
-          Puppet.debug _("Selected port from the first entry of the `server_list` setting: %{port}") % {port: primary_server[1]}
-          primary_server[1]
-        else
-          #TRANSLATORS 'masterport' is the name of a setting and should not be translated
-          Puppet.debug _("Selected port from the `masterport` setting: %{port}") % {port: Puppet.settings[:masterport]}
-          Puppet.settings[:masterport]
-        end
+    bound_port = Puppet.lookup(:serverport) do
+      if primary_server = Puppet.settings[:server_list][0]
+        primary_server[1]
+      else
+        Puppet.settings[:masterport]
       end
     end
+    self.server = default_server || bound_server
+    self.port   = default_port || bound_port
+
+    Puppet.debug "No more servers left, falling back to #{self.server}:#{self.port}" if Puppet.settings[:use_srv_records]
 
     return yield(self)
   end

data/lib/puppet/network/http/connection.rb

@@ -130,26 +130,20 @@ module Puppet::Network::HTTP
     # future we may want to refactor these so that they are funneled through
     # that method and do inherit the error handling.
     def request_get(*args, &block)
-      with_connection(@site) do |http|
-        resp = http.request_get(*args, &block)
-        Puppet.debug("HTTP GET #{@site}#{args.first.split('?').first} returned #{resp.code} #{resp.message}")
-        resp
+      with_connection(@site) do |connection|
+        connection.request_get(*args, &block)
       end
     end
 
     def request_head(*args, &block)
-      with_connection(@site) do |http|
-        resp = http.request_head(*args, &block)
-        Puppet.debug("HTTP HEAD #{@site}#{args.first.split('?').first} returned #{resp.code} #{resp.message}")
-        resp
+      with_connection(@site) do |connection|
+        connection.request_head(*args, &block)
       end
     end
 
     def request_post(*args, &block)
-      with_connection(@site) do |http|
-        resp = http.request_post(*args, &block)
-        Puppet.debug("HTTP POST #{@site}#{args.first.split('?').first} returned #{resp.code} #{resp.message}")
-        resp
+      with_connection(@site) do |connection|
+        connection.request_post(*args, &block)
       end
     end
     # end of Net::HTTP#request_* proxies
@@ -303,25 +297,13 @@ module Puppet::Network::HTTP
 
     def execute_request(connection, request)
       start = Time.now
-      resp = connection.request(request)
-      Puppet.debug("HTTP #{request.method.upcase} #{@site}#{request.path.split('?').first} returned #{resp.code} #{resp.message}")
-      resp
-    rescue => exception
+      connection.request(request)
+    rescue EOFError => e
       elapsed = (Time.now - start).to_f.round(3)
-      uri = [@site.addr, request.path.split('?')[0]].join('/')
-      eclass = exception.class
-
-      err = case exception
-            when EOFError
-              eclass.new(_('request %{uri} interrupted after %{elapsed} seconds') % {uri: uri, elapsed: elapsed})
-            when Timeout::Error
-              eclass.new(_('request %{uri} timed out after %{elapsed} seconds') % {uri: uri, elapsed: elapsed})
-            else
-              eclass.new(_('request %{uri} failed: %{msg}') % {uri: uri, msg: exception.message})
-            end
-
-      err.set_backtrace(exception.backtrace) unless exception.backtrace.empty?
-      raise err
+      uri = @site.addr + request.path.split('?')[0]
+      eof = EOFError.new(_('request %{uri} interrupted after %{elapsed} seconds') % {uri: uri, elapsed: elapsed})
+      eof.set_backtrace(e.backtrace) unless e.backtrace.empty?
+      raise eof
     end
 
     def with_connection(site, &block)
@@ -331,8 +313,6 @@ module Puppet::Network::HTTP
       end
       response
     rescue OpenSSL::SSL::SSLError => error
-      raise @verify.last_error if @verify.last_error
-
       Puppet::Util::SSL.handle_connection_error(error, @verify, site.host)
     end
   end

data/lib/puppet/network/http/factory.rb

@@ -41,11 +41,6 @@ class Puppet::Network::HTTP::Factory
     http.open_timeout = Puppet[:http_connect_timeout]
     http.keep_alive_timeout = KEEP_ALIVE_TIMEOUT if http.respond_to?(:keep_alive_timeout=)
 
-    if http.respond_to?(:max_retries)
-      # 0 means make one request and never retry
-      http.max_retries = 0
-    end
-
     if Puppet[:sourceaddress]
       Puppet.debug("Using source IP #{Puppet[:sourceaddress]}")
       http.local_host = Puppet[:sourceaddress]

data/lib/puppet/pal/catalog_compiler.rb

@@ -0,0 +1,96 @@
+module Puppet
+module Pal
+  # 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.
+  #
+  # @api public
+  class CatalogCompiler < Compiler
+
+    # @api private
+    def catalog
+      internal_compiler.catalog
+    end
+    private :catalog
+
+    # Returns true if this is a compiler that compiles a catalog.
+    # This implementation returns `true`
+    # @return [Boolean] true
+    # @api public
+    def has_catalog?
+      true
+    end
+
+    # Calls a block of code and yields a configured `JsonCatalogEncoder` to the block.
+    # @example 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
+    #
+    # @api public
+    #
+    def with_json_encoding(pretty: true, exclude_virtual: true)
+      yield JsonCatalogEncoder.new(catalog, pretty: pretty, exclude_virtual: exclude_virtual)
+    end
+
+    # 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).
+    #
+    # @param ast [Puppet::Pops::Model::PopsObject] typically the returned `Program` from the parse methods, but can be any `Expression`
+    # @returns [Object] whatever the ast evaluates to
+    #
+    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
+
+
+    # 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.
+    #
+    # @return [Void]
+    def compile_additions
+      internal_compiler.compile_additions
+    end
+
+    # Validates the state of the catalog (without performing evaluation of any elements
+    # requiring lazy evaluation. Can be called multiple times.
+    #
+    def validate
+      internal_compiler.validate
+    end
+
+    # Evaluates all lazy constructs that were produced as a side effect of evaluating puppet logic.
+    # Can be called multiple times.
+    #
+    def evaluate_additions
+      internal_compiler.evaluate_additions
+    end
+
+  end
+
+end
+end

data/lib/puppet/pal/compiler.rb

@@ -0,0 +1,221 @@
+module Puppet
+module Pal
+
+  # A configured compiler as obtained in the callback from `Puppet::Pal.with_script_compiler`.
+  # (Later, there may also be a catalog compiler available.)
+  #
+  class Compiler
+    attr_reader :internal_compiler
+    protected :internal_compiler
+
+    attr_reader :internal_evaluator
+    protected :internal_evaluator
+
+    def initialize(internal_compiler)
+      @internal_compiler = internal_compiler
+      @internal_evaluator = Puppet::Pops::Parser::EvaluatingParser.new
+    end
+
+    # Calls a function given by name with arguments specified in an `Array`, and optionally accepts a code block.
+    # @param function_name [String] the name of the function to call
+    # @param args [Object] the arguments to the function
+    # @param block [Proc] an optional callable block that is given to the called function
+    # @return [Object] what the called function returns
+    #
+    def call_function(function_name, *args, &block)
+      # TRANSLATORS: do not translate variable name strings in these assertions
+      Pal::assert_non_empty_string(function_name, 'function_name', false)
+      Pal::assert_type(Pal::T_ANY_ARRAY, args, 'args', false)
+      internal_evaluator.evaluator.external_call_function(function_name, args, topscope, &block)
+    end
+
+    # Returns a Puppet::Pal::FunctionSignature object or nil if function is not found
+    # The returned FunctionSignature has information about all overloaded signatures of the function
+    #
+    # @example using function_signature
+    #   # returns true if 'myfunc' is callable with three integer arguments 1, 2, 3
+    #   compiler.function_signature('myfunc').callable_with?([1,2,3])
+    #
+    # @param function_name [String] the name of the function to get a signature for
+    # @return [Puppet::Pal::FunctionSignature] a function signature, or nil if function not found
+    #
+    def function_signature(function_name)
+      loader = internal_compiler.loaders.private_environment_loader
+      if func = loader.load(:function, function_name)
+        return FunctionSignature.new(func.class)
+      end
+      # Could not find function
+      nil
+    end
+
+    # Returns an array of TypedName objects for all functions, optionally filtered by a regular expression.
+    # The returned array has more information than just the leaf name - the typical thing is to just get
+    # the name as showing the following example.
+    #
+    # Errors that occur during function discovery will either be logged as warnings or collected by the optional
+    # `error_collector` array. When provided, it will receive {Puppet::DataTypes::Error} instances describing
+    # each error in detail and no warnings will be logged.
+    #
+    # @example getting the names of all functions
+    #   compiler.list_functions.map {|tn| tn.name }
+    #
+    # @param filter_regex [Regexp] an optional regexp that filters based on name (matching names are included in the result)
+    # @param error_collector [Array<Puppet::DataTypes::Error>] an optional array that will receive errors during load
+    # @return [Array<Puppet::Pops::Loader::TypedName>] an array of typed names
+    #
+    def list_functions(filter_regex = nil, error_collector = nil)
+      list_loadable_kind(:function, filter_regex, error_collector)
+    end
+
+    # Evaluates a string of puppet language code in top scope.
+    # A "source_file" reference to a source can be given - if not an actual file name, by convention the name should
+    # be bracketed with < > to indicate it is something symbolic; for example `<commandline>` if the string was given on the
+    # command line.
+    #
+    # If the given `puppet_code` is `nil` or an empty string, `nil` is returned, otherwise the result of evaluating the
+    # puppet language string. The given string must form a complete and valid expression/statement as an error is raised
+    # otherwise. That is, it is not possible to divide a compound expression by line and evaluate each line individually.
+    #
+    # @param puppet_code [String, nil] the puppet language code to evaluate, must be a complete expression/statement
+    # @param source_file [String, nil] an optional reference to a source (a file or symbolic name/location)
+    # @return [Object] what the `puppet_code` evaluates to
+    #
+    def evaluate_string(puppet_code, source_file = nil)
+      return nil if puppet_code.nil? || puppet_code == ''
+      unless puppet_code.is_a?(String)
+        raise ArgumentError, _("The argument 'puppet_code' must be a String, got %{type}") % { type: puppet_code.class }
+      end
+      evaluate(parse_string(puppet_code, source_file))
+    end
+
+    # Evaluates a puppet language file in top scope.
+    # The file must exist and contain valid puppet language code or an error is raised.
+    #
+    # @param file [Path, String] an absolute path to a file with puppet language code, must exist
+    # @return [Object] what the last evaluated expression in the file evaluated to
+    #
+    def evaluate_file(file)
+      evaluate(parse_file(file))
+    end
+
+    # 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).
+    #
+    # @param ast [Puppet::Pops::Model::PopsObject] typically the returned `Program` from the parse methods, but can be any `Expression`
+    # @returns [Object] whatever the ast evaluates to
+    #
+    def evaluate(ast)
+      if ast.is_a?(Puppet::Pops::Model::Program)
+        loaders = Puppet.lookup(:loaders)
+        loaders.instantiate_definitions(ast, loaders.public_environment_loader)
+      end
+      internal_evaluator.evaluate(topscope, ast)
+    end
+
+    # Produces a literal value if the AST obtained from `parse_string` or `parse_file` does not require any actual evaluation.
+    # This method is useful if obtaining an AST that represents literal values; string, integer, float, boolean, regexp, array, hash;
+    # for example from having read this from the command line or as values in some file.
+    #
+    # @param ast [Puppet::Pops::Model::PopsObject] typically the returned `Program` from the parse methods, but can be any `Expression`
+    # @returns [Object] whatever the literal value the ast evaluates to
+    #
+    def evaluate_literal(ast)
+      catch :not_literal do
+        return Puppet::Pops::Evaluator::LiteralEvaluator.new().literal(ast)
+      end
+      # TRANSLATORS, the 'ast' is the name of a parameter, do not translate
+      raise ArgumentError, _("The given 'ast' does not represent a literal value")
+    end
+
+    # Parses and validates a puppet language string and returns an instance of Puppet::Pops::Model::Program on success.
+    # If the content is not valid an error is raised.
+    #
+    # @param code_string [String] a puppet language string to parse and validate
+    # @param source_file [String] an optional reference to a file or other location in angled brackets
+    # @return [Puppet::Pops::Model::Program] returns a `Program` instance on success
+    #
+    def parse_string(code_string, source_file = nil)
+      unless code_string.is_a?(String)
+        raise ArgumentError, _("The argument 'code_string' must be a String, got %{type}") % { type: code_string.class }
+      end
+      internal_evaluator.parse_string(code_string, source_file)
+    end
+
+    # Parses and validates a puppet language file and returns an instance of Puppet::Pops::Model::Program on success.
+    # If the content is not valid an error is raised.
+    #
+    # @param file [String] a file with puppet language content to parse and validate
+    # @return [Puppet::Pops::Model::Program] returns a `Program` instance on success
+    #
+    def parse_file(file)
+      unless file.is_a?(String)
+        raise ArgumentError, _("The argument 'file' must be a String, got %{type}") % { type: file.class }
+      end
+      internal_evaluator.parse_file(file)
+    end
+
+    # Parses a puppet data type given in String format and returns that type, or raises an error.
+    # A type is needed in calls to `new` to create an instance of the data type, or to perform type checking
+    # of values - typically using `type.instance?(obj)` to check if `obj` is an instance of the type.
+    #
+    # @example Verify if obj is an instance of a data type
+    #   # evaluates to true
+    #   pal.type('Enum[red, blue]').instance?("blue")
+    #
+    # @example Create an instance of a data type
+    #   # using an already create type
+    #   t = pal.type('Car')
+    #   pal.create(t, 'color' => 'black', 'make' => 't-ford')
+    #
+    #   # letting 'new_object' parse the type from a string
+    #   pal.create('Car', 'color' => 'black', 'make' => 't-ford')
+    #
+    # @param type_string [String] a puppet language data type
+    # @return [Puppet::Pops::Types::PAnyType] the data type
+    #
+    def type(type_string)
+      Puppet::Pops::Types::TypeParser.singleton.parse(type_string)
+    end
+
+    # Creates a new instance of a given data type.
+    # @param data_type [String, Puppet::Pops::Types::PAnyType] the data type as a data type or in String form.
+    # @param arguments [Object] one or more arguments to the called `new` function
+    # @return [Object] an instance of the given data type,
+    #   or raises an error if it was not possible to parse data type or create an instance.
+    #
+    def create(data_type, *arguments)
+      t = data_type.is_a?(String) ? type(data_type) : data_type
+      unless t.is_a?(Puppet::Pops::Types::PAnyType)
+        raise ArgumentError, _("Given data_type value is not a data type, got '%{type}'") % {type: t.class}
+      end
+      call_function('new', t, *arguments)
+    end
+
+    # Returns true if this is a compiler that compiles a catalog.
+    # This implementation returns `false`
+    # @return Boolan false
+    def has_catalog?
+      false
+    end
+
+    protected
+
+    def list_loadable_kind(kind, filter_regex = nil, error_collector = nil)
+      loader = internal_compiler.loaders.private_environment_loader
+      if filter_regex.nil?
+        loader.discover(kind, error_collector)
+      else
+        loader.discover(kind, error_collector) {|f| f.name =~ filter_regex }
+      end
+    end
+
+    private
+
+    def topscope
+      internal_compiler.topscope
+    end
+  end
+
+end
+end