puppet 7.0.0-x64-mingw32 → 7.5.0-x64-mingw32

data/lib/puppet/module_tool/errors/shared.rb

@@ -7,6 +7,7 @@ module Puppet::ModuleTool::Errors
       @installed_version = options[:installed_version]
       @conditions        = options[:conditions]
       @action            = options[:action]
+      @unsatisfied       = options[:unsatisfied]
 
       super _("Could not %{action} '%{module_name}' (%{version}); no version satisfies all dependencies") % { action: @action, module_name: @requested_name, version: vstring }
     end
@@ -14,9 +15,23 @@ module Puppet::ModuleTool::Errors
     def multiline
       message = []
       message << _("Could not %{action} module '%{module_name}' (%{version})") % { action: @action, module_name: @requested_name, version: vstring }
-      message << _("  No version of '%{module_name}' can satisfy all dependencies") % { module_name: @requested_name }
+
+      if @unsatisfied
+        message << _("  The requested version cannot satisfy one or more of the following installed modules:")
+        if @unsatisfied[:current_version]
+          message << _("    %{name}, installed: %{current_version}, expected: %{constraints}") % { name: @unsatisfied[:name], current_version: @unsatisfied[:current_version], constraints: @unsatisfied[:constraints][@unsatisfied[:name]] }
+        else
+          @unsatisfied[:constraints].each do |mod, range|
+            message << _("    %{mod}, expects '%{name}': %{range}") % { mod: mod, name: @requested_name, range: range }
+          end
+        end
+        message << _("")
+      else
+        message << _("  The requested version cannot satisfy all dependencies")
+      end
+
       #TRANSLATORS `puppet module %{action} --ignore-dependencies` is a command line and should not be translated
-      message << _("    Use `puppet module %{action} --ignore-dependencies` to %{action} only this module") % { action: @action }
+      message << _("  Use `puppet module %{action} '%{module_name}' --ignore-dependencies` to %{action} only this module") % { action: @action, module_name: @requested_name }
       message.join("\n")
     end
   end

data/lib/puppet/network/formats.rb

@@ -183,6 +183,73 @@ Puppet::Network::FormatHandler.create(:console,
   end
 end
 
+Puppet::Network::FormatHandler.create(:flat,
+                                      :mime   => 'text/x-flat-text',
+                                      :weight => 0) do
+
+  def flatten_hash(hash)
+    hash.each_with_object({}) do |(k, v), h|
+      if v.is_a? Hash
+        flatten_hash(v).map do |h_k, h_v|
+          h["#{k}.#{h_k}"] = h_v
+        end
+      elsif v.is_a? Array
+        v.each_with_index do |el, i|
+          if el.is_a? Hash
+            flatten_hash(el).map do |el_k, el_v|
+              h["#{k}.#{i}.#{el_k}"] = el_v
+            end
+          else
+            h["#{k}.#{i}"] = el
+          end
+        end
+      else
+        h[k] = v
+      end
+    end
+  end
+
+  def flatten_array(array)
+    a={}
+    array.each_with_index do |el, i|
+      if el.is_a? Hash
+        flatten_hash(el).map do |el_k, el_v|
+          a["#{i}.#{el_k}"] = el_v
+        end
+      else
+        a["#{i}"] = el
+      end
+    end
+    a
+  end
+
+  def construct_output(data)
+    output = ''
+    data.each do |key, value|
+      output << "#{key}=#{value}"
+      output << "\n"
+    end
+    output
+  end
+
+  def render(datum)
+    return datum if datum.is_a?(String) || datum.is_a?(Numeric)
+    # Simple hash
+    if datum.is_a?(Hash)
+      data = flatten_hash(datum)
+      return construct_output(data)
+    elsif datum.is_a?(Array)
+      data = flatten_array(datum)
+      return construct_output(data)
+    end
+    Puppet::Util::Json.dump(datum, :pretty => true, :quirks_mode => true)
+  end
+  def render_multiple(data)
+    data.collect(&:render).join("\n")
+  end
+end
+
+
 Puppet::Network::FormatHandler.create(:rich_data_json, mime: 'application/vnd.puppet.rich+json', charset: Encoding::UTF_8, weight: 30) do
   def intern(klass, text)
     Puppet.override({:rich_data => true}) do

data/lib/puppet/network/http.rb

@@ -3,8 +3,11 @@ module Puppet::Network::HTTP
   HEADER_ENABLE_PROFILING = "X-Puppet-Profiling"
   HEADER_PUPPET_VERSION = "X-Puppet-Version"
 
-  MASTER_URL_PREFIX = "/puppet"
-  MASTER_URL_VERSIONS = "v3"
+  SERVER_URL_PREFIX = "/puppet"
+  SERVER_URL_VERSIONS = "v3"
+
+  MASTER_URL_PREFIX = SERVER_URL_PREFIX
+  MASTER_URL_VERSIONS = SERVER_URL_VERSIONS
 
   CA_URL_PREFIX = "/puppet-ca"
   CA_URL_VERSIONS = "v1"

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

@@ -18,18 +18,22 @@ class Puppet::Network::HTTP::API
                                                                       "Note that Puppet 3 agents aren't compatible with this version; if you're " +
                                                                       "running Puppet 3, you must either upgrade your agents to match the server " +
                                                                       "or point them to a server running Puppet 3.\n\n" +
-                                                                      "Master Info:\n" +
+                                                                      "Server Info:\n" +
                                                                       "  Puppet version: #{Puppet.version}\n" +
-                                                                      "  Supported /puppet API versions: #{Puppet::Network::HTTP::MASTER_URL_VERSIONS}\n",
+                                                                      "  Supported /puppet API versions: #{Puppet::Network::HTTP::SERVER_URL_VERSIONS}\n",
                                                                   Puppet::Network::HTTP::Issues::HANDLER_NOT_FOUND)
       end)
   end
 
-  def self.master_routes
-    master_prefix = Regexp.new("^#{Puppet::Network::HTTP::MASTER_URL_PREFIX}/")
-    Puppet::Network::HTTP::Route.path(master_prefix).
+  def self.server_routes
+    server_prefix = Regexp.new("^#{Puppet::Network::HTTP::SERVER_URL_PREFIX}/")
+    Puppet::Network::HTTP::Route.path(server_prefix).
       any.
-      chain(Puppet::Network::HTTP::API::Master::V3.routes,
+      chain(Puppet::Network::HTTP::API::Server::V3.routes,
             Puppet::Network::HTTP::API.not_found)
   end
+
+  def self.master_routes
+    server_routes
+  end
 end

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

@@ -1,2 +1,3 @@
-module Puppet::Network::HTTP::API::Master
-end
+require 'puppet/network/http/api/server'
+
+Puppet::Network::HTTP::API::Master = Puppet::Network::HTTP::API::Server

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

@@ -1,26 +1,3 @@
-class Puppet::Network::HTTP::API::Master::V3
-  require 'puppet/network/http/api/master/v3/environments'
-  require 'puppet/network/http/api/indirected_routes'
+require 'puppet/network/http/api/master'
+require 'puppet/network/http/api/server/v3'
 
-  def self.wrap(&block)
-    lambda do |request, response|
-      Puppet::Network::Authorization.check_external_authorization(request.method, request.path)
-
-      block.call.call(request, response)
-    end
-  end
-
-  INDIRECTED = Puppet::Network::HTTP::Route.
-      path(/.*/).
-      any(wrap { Puppet::Network::HTTP::API::IndirectedRoutes.new } )
-
-  ENVIRONMENTS = Puppet::Network::HTTP::Route.
-      path(%r{^/environments$}).
-      get(wrap { Environments.new(Puppet.lookup(:environments)) } )
-
-  def self.routes
-    Puppet::Network::HTTP::Route.path(%r{v3}).
-        any.
-        chain(ENVIRONMENTS, INDIRECTED)
-  end
-end

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

@@ -1,34 +1,3 @@
-require 'puppet/util/json'
+require 'puppet/network/http/api/master'
+require 'puppet/network/http/api/server/v3/environments'
 
-class Puppet::Network::HTTP::API::Master::V3::Environments
-  def initialize(env_loader)
-    @env_loader = env_loader
-  end
-
-  def call(request, response)
-    response.respond_with(200, "application/json", Puppet::Util::Json.dump({
-      "search_paths" => @env_loader.search_paths,
-      "environments" => Hash[@env_loader.list.collect do |env|
-        [env.name, {
-          "settings" => {
-            "modulepath" => env.full_modulepath,
-            "manifest" => env.manifest,
-            "environment_timeout" => timeout(env),
-            "config_version" => env.config_version || '',
-          }
-        }]
-      end]
-    }))
-  end
-
-  private
-
-  def timeout(env)
-    ttl = @env_loader.get_conf(env.name).environment_timeout
-    if ttl == Float::INFINITY
-      "unlimited"
-    else
-      ttl
-    end
-  end
-end

data/lib/puppet/network/http/api/server.rb

@@ -0,0 +1,10 @@
+module Puppet
+  module Network
+    module HTTP
+      class API
+        module Server
+        end
+      end
+    end
+  end
+end

data/lib/puppet/network/http/api/server/v3.rb

@@ -0,0 +1,39 @@
+require 'puppet/network/http/api/server/v3/environments'
+require 'puppet/network/http/api/indirected_routes'
+
+module Puppet
+  module Network
+    module HTTP
+      class API
+        module Server
+          class V3
+
+            def self.wrap(&block)
+              lambda do |request, response|
+                Puppet::Network::Authorization.
+                  check_external_authorization(request.method,
+                                               request.path)
+
+                block.call.call(request, response)
+              end
+            end
+
+            INDIRECTED = Puppet::Network::HTTP::Route.
+                path(/.*/).
+                any(wrap { Puppet::Network::HTTP::API::IndirectedRoutes.new } )
+
+            ENVIRONMENTS = Puppet::Network::HTTP::Route.
+                path(%r{^/environments$}).
+                get(wrap { Environments.new(Puppet.lookup(:environments)) } )
+
+            def self.routes
+              Puppet::Network::HTTP::Route.path(%r{v3}).
+                  any.
+                  chain(ENVIRONMENTS, INDIRECTED)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puppet/network/http/api/server/v3/environments.rb

@@ -0,0 +1,48 @@
+require 'puppet/util/json'
+
+module Puppet
+  module Network
+    module HTTP
+      class API
+        module Server
+          class V3
+            class Environments
+
+              def initialize(env_loader)
+                @env_loader = env_loader
+              end
+
+              def call(request, response)
+                response.respond_with(200, "application/json", Puppet::Util::Json.dump({
+                  "search_paths" => @env_loader.search_paths,
+                  "environments" => Hash[@env_loader.list.collect do |env|
+                    [env.name, {
+                      "settings" => {
+                        "modulepath" => env.full_modulepath,
+                        "manifest" => env.manifest,
+                        "environment_timeout" => timeout(env),
+                        "config_version" => env.config_version || '',
+                      }
+                    }]
+                  end]
+                }))
+              end
+
+              private
+
+              def timeout(env)
+                ttl = @env_loader.get_conf(env.name).environment_timeout
+                if ttl == Float::INFINITY
+                  "unlimited"
+                else
+                  ttl
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -50,8 +50,9 @@ class Puppet::Parser::AST::HostName < Puppet::Parser::AST::Leaf
 end
 
 class Puppet::Parser::AST::Regex < Puppet::Parser::AST::Leaf
-  def initialize(hash)
-    super(**hash)
+  def initialize(value: nil, file: nil, line: nil, pos: nil)
+    super(value: value, file: file, line: line, pos: pos)
+
     # transform value from hash options unless it is already a regular expression
     @value = Regexp.new(@value) unless @value.is_a?(Regexp)
   end

data/lib/puppet/parser/templatewrapper.rb

@@ -50,7 +50,7 @@ class Puppet::Parser::TemplateWrapper
   # @return [Array<String>] The tags defined in the current scope
   # @api public
   def tags
-    scope.tags
+    raise NotImplementedError, "Call 'all_tags' instead."
   end
 
   # @return [Array<String>] All the defined tags

data/lib/puppet/pops/evaluator/deferred_resolver.rb

@@ -16,10 +16,12 @@ class DeferredResolver
   #
   # @param facts [Puppet::Node::Facts] the facts object for the node
   # @param catalog [Puppet::Resource::Catalog] the catalog where all deferred values should be replaced
+  # @param environment [Puppet::Node::Environment] the environment whose anonymous module methods
+  #  are to be mixed into the scope
   # @return [nil] does not return anything - the catalog is modified as a side effect
   #
-  def self.resolve_and_replace(facts, catalog)
-    compiler = Puppet::Parser::ScriptCompiler.new(catalog.environment_instance, catalog.name, true)
+  def self.resolve_and_replace(facts, catalog, environment = catalog.environment_instance)
+    compiler = Puppet::Parser::ScriptCompiler.new(environment, catalog.name, true)
     resolver = new(compiler)
     resolver.set_facts_variable(facts)
     # TODO:
@@ -108,7 +110,7 @@ class DeferredResolver
     # If any of the arguments to a future is a future it needs to be resolved first
     func_name = f.name
     mapped_arguments = map_arguments(f.arguments)
-    # if name starts with $ then this is a call to dig 
+    # if name starts with $ then this is a call to dig
     if func_name[0] == DOLLAR
       var_name = func_name[1..-1]
       func_name = DIG

data/lib/puppet/pops/model/ast_transformer.rb

@@ -31,7 +31,7 @@ class Puppet::Pops::Model::AstTransformer
   def ast(o, klass, hash={})
     # create and pass hash with file and line information
     # PUP-3274 - still needed since hostname transformation requires AST::HostName, and AST::Regexp
-    klass.new(merge_location(hash, o))
+    klass.new(**merge_location(hash, o))
   end
 
   # THIS IS AN EXPENSIVE OPERATION

data/lib/puppet/pops/parser/lexer2.rb

@@ -134,10 +134,6 @@ class Lexer2
     'type'     => [:TYPE,     'type',     4],
     'attr'     => [:ATTR,     'attr',     4],
     'private'  => [:PRIVATE,  'private',  7],
-    'application' => [:APPLICATION, 'application',  11], # reserved
-    'consumes'    => [:CONSUMES,    'consumes',  8], # reserved
-    'produces'    => [:PRODUCES,    'produces',  8], # reserved
-    'site'        => [:SITE,        'site',  4], # reserved
   }
 
   KEYWORDS.each {|k,v| v[1].freeze; v.freeze }

data/lib/puppet/pops/validation/checker4_0.rb

@@ -236,7 +236,6 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     case p
     when Model::AbstractResource
     when Model::CollectExpression
-      acceptor.accept(Issues::UNSUPPORTED_OPERATOR_IN_CONTEXT, p, :operator=>'* =>')
     else
       # protect against just testing a snippet that has no parent, error message will be a bit strange
       # but it is not for a real program.

data/lib/puppet/property/list.rb

@@ -47,7 +47,7 @@ module Puppet
         #ok, some 'convention' if the list property is named groups, provider should implement a groups method
         tmp = provider.send(name) if provider
         if tmp && tmp != :absent
-          return tmp.split(delimiter)
+          return tmp.instance_of?(Array) ? tmp : tmp.split(delimiter)
         else
           return :absent
         end

data/lib/puppet/provider/group/groupadd.rb

@@ -130,16 +130,21 @@ Puppet::Type.type(:group).provide :groupadd, :parent => Puppet::Provider::NameSe
   private
 
   def findgroup(key, value)
-    group_file = "/etc/group"
+    group_file = '/etc/group'
     group_keys = [:group_name, :password, :gid, :user_list]
-    index = group_keys.index(key)
-    @group_content ||= File.read(group_file)
-    @group_content.each_line do |line|
-      group = line.split(":")
-      if group[index] == value
-        return Hash[group_keys.zip(group)]
+
+    unless @groups
+      unless Puppet::FileSystem.exist?(group_file)
+        raise Puppet::Error.new("Forcelocal set for group resource '#{resource[:name]}', but #{group_file} does not exist")
+      end
+
+      @groups = []
+      Puppet::FileSystem.each_line(group_file) do |line|
+        group = line.chomp.split(':')
+        @groups << Hash[group_keys.zip(group)]
       end
     end
-    false
+
+    @groups.find { |param| param[key] == value } || false
   end
 end