puppet 6.14.0-universal-darwin → 6.15.0-universal-darwin

data/lib/puppet/indirector/report/yaml.rb

@@ -2,10 +2,33 @@ require 'puppet/transaction/report'
 require 'puppet/indirector/yaml'
 
 class Puppet::Transaction::Report::Yaml < Puppet::Indirector::Yaml
+  include Puppet::Util::SymbolicFileMode
+
   desc "Store last report as a flat file, serialized using YAML."
 
   # Force report to be saved there
   def path(name,ext='.yaml')
     Puppet[:lastrunreport]
   end
+
+  def save(request)
+    filename = path(request.key)
+    mode = Puppet.settings.setting(:lastrunreport).mode
+
+    unless valid_symbolic_mode?(mode)
+      raise Puppet::DevError, _("replace_file mode: %{mode} is invalid") % { mode: mode }
+    end
+
+    mode = symbolic_mode_to_int(normalize_symbolic_mode(mode))
+
+    FileUtils.mkdir_p(File.dirname(filename))
+
+    begin
+      Puppet::FileSystem.replace_file(filename, mode) do |fh|
+        fh.print YAML.dump(request.instance)
+      end
+    rescue TypeError => detail
+      Puppet.err _("Could not save %{indirection} %{request}: %{detail}") % { indirection: self.name, request: request.key, detail: detail }
+    end
+  end
 end

data/lib/puppet/indirector/status/rest.rb

@@ -11,7 +11,8 @@ class Puppet::Indirector::Status::Rest < Puppet::Indirector::REST
 
     session = Puppet.lookup(:http_session)
     api = session.route_to(:puppet)
-    api.get_status(request.key)
+    _, status = api.get_status(request.key)
+    status
   rescue Puppet::HTTP::ResponseError => e
     if e.response.code == 404
       return nil unless request.options[:fail_on_404]

data/lib/puppet/metatype/manager.rb

@@ -70,68 +70,68 @@ module Manager
   # @dsl type
   # @api public
   def newtype(name, options = {}, &block)
-    # Handle backward compatibility
-    unless options.is_a?(Hash)
-      #TRANSLATORS 'Puppet::Type.newtype' should not be translated
-      Puppet.warning(_("Puppet::Type.newtype(%{name}) now expects a hash as the second argument, not %{argument}") %
-                         { name: name, argument: options.inspect})
-    end
-
-    # First make sure we don't have a method sitting around
-    name = name.intern
-    newmethod = "new#{name}"
+    @manager_lock.synchronize do
+      # Handle backward compatibility
+      unless options.is_a?(Hash)
+        #TRANSLATORS 'Puppet::Type.newtype' should not be translated
+        Puppet.warning(_("Puppet::Type.newtype(%{name}) now expects a hash as the second argument, not %{argument}") %
+                       { name: name, argument: options.inspect})
+      end
 
-    # Used for method manipulation.
-    selfobj = singleton_class
+      # First make sure we don't have a method sitting around
+      name = name.intern
+      newmethod = "new#{name}"
 
-    @types ||= {}
+      # Used for method manipulation.
+      selfobj = singleton_class
 
-    if @types.include?(name)
-      if self.respond_to?(newmethod)
-        # Remove the old newmethod
-        selfobj.send(:remove_method,newmethod)
+      if @types.include?(name)
+        if self.respond_to?(newmethod)
+          # Remove the old newmethod
+          selfobj.send(:remove_method,newmethod)
+        end
       end
-    end
-
-    # Then create the class.
 
-    klass = genclass(
-      name,
-      :parent => Puppet::Type,
-      :overwrite => true,
-      :hash => @types,
-      :attributes => options,
-      &block
-    )
-
-    # Now define a "new<type>" method for convenience.
-    if self.respond_to? newmethod
-      # Refuse to overwrite existing methods like 'newparam' or 'newtype'.
-      #TRANSLATORS 'new%{method}' will become a method name, do not translate this string
-      Puppet.warning(_("'new%{method}' method already exists; skipping") % { method: name.to_s })
-    else
-      selfobj.send(:define_method, newmethod) do |*args|
-        klass.new(*args)
+      # Then create the class.
+
+      klass = genclass(
+        name,
+        :parent => Puppet::Type,
+        :overwrite => true,
+        :hash => @types,
+        :attributes => options,
+        &block
+      )
+
+      # Now define a "new<type>" method for convenience.
+      if self.respond_to? newmethod
+        # Refuse to overwrite existing methods like 'newparam' or 'newtype'.
+        #TRANSLATORS 'new%{method}' will become a method name, do not translate this string
+        Puppet.warning(_("'new%{method}' method already exists; skipping") % { method: name.to_s })
+      else
+        selfobj.send(:define_method, newmethod) do |*args|
+          klass.new(*args)
+        end
       end
-    end
 
-    # If they've got all the necessary methods defined and they haven't
-    # already added the property, then do so now.
-    klass.ensurable if klass.ensurable? and ! klass.validproperty?(:ensure)
+      # If they've got all the necessary methods defined and they haven't
+      # already added the property, then do so now.
+      klass.ensurable if klass.ensurable? and ! klass.validproperty?(:ensure)
 
-    # Now set up autoload any providers that might exist for this type.
+      # Now set up autoload any providers that might exist for this type.
 
-    klass.providerloader = Puppet::Util::Autoload.new(klass, "puppet/provider/#{klass.name}")
+      klass.providerloader = Puppet::Util::Autoload.new(klass, "puppet/provider/#{klass.name}")
 
-    # We have to load everything so that we can figure out the default provider.
-    klass.providerloader.loadall(Puppet.lookup(:current_environment))
-    klass.providify unless klass.providers.empty?
+      # We have to load everything so that we can figure out the default provider.
+      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)
+      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
+      klass
+    end
   end
 
   # Removes an existing type.
@@ -151,47 +151,47 @@ module Manager
   # @return [Puppet::Type, nil] the type or nil if the type was not defined and could not be loaded
   #
   def type(name)
-    # Avoid loading if name obviously is not a type name
-    if name.to_s.include?(':')
-      return nil
-    end
+    @manager_lock.synchronize do
+      # Avoid loading if name obviously is not a type name
+      if name.to_s.include?(':')
+        return nil
+      end
 
-    @types ||= {}
+      # 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.include? name
 
-    # 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.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.include? name
+      end
+      # Try loading the type.
+      if typeloader.load(name, Puppet.lookup(:current_environment))
+        #TRANSLATORS 'puppet/type/%{name}' should not be translated
+        Puppet.warning(_("Loaded puppet/type/%{name} but no class was created") % { name: name }) 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
 
-    # Try mangling the name, if it is a string.
-    if name.is_a? String
-      name = name.downcase.intern
-      return @types[name] if @types.include? name
-    end
-    # Try loading the type.
-    if typeloader.load(name, Puppet.lookup(:current_environment))
-      #TRANSLATORS 'puppet/type/%{name}' should not be translated
-      Puppet.warning(_("Loaded puppet/type/%{name} but no class was created") % { name: name }) 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
+      # ...and I guess that is that, eh.
+      return @types[name]
     end
-
-    # ...and I guess that is that, eh.
-    return @types[name]
   end
 
   # Creates a loader for Puppet types.
   # Defaults to an instance of {Puppet::Util::Autoload} if no other auto loader has been set.
   # @return [Puppet::Util::Autoload] the loader to use.
   # @api private
-def typeloader
-  unless defined?(@typeloader)
-    @typeloader = Puppet::Util::Autoload.new(self, "puppet/type")
-  end
+  def typeloader
+    unless defined?(@typeloader)
+      @typeloader = Puppet::Util::Autoload.new(self, "puppet/type")
+    end
 
-  @typeloader
-end
+    @typeloader
+  end
 end
 end
 

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

@@ -26,6 +26,11 @@ class Puppet::Network::HTTP::BasePool
     socket = buffered_io.io
     return unless socket
 
-    Puppet.debug("Using #{socket.ssl_version} with cipher #{socket.cipher.first}")
+    cipher = if Puppet::Util::Platform.jruby?
+               socket.cipher
+             else
+               socket.cipher.first
+             end
+    Puppet.debug("Using #{socket.ssl_version} with cipher #{cipher}")
   end
 end

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

@@ -9,11 +9,9 @@
 # @api private
 #
 class Puppet::Network::HTTP::Pool < Puppet::Network::HTTP::BasePool
-  FIFTEEN_SECONDS = 15
+  attr_reader :factory, :keepalive_timeout
 
-  attr_reader :factory
-
-  def initialize(keepalive_timeout = FIFTEEN_SECONDS)
+  def initialize(keepalive_timeout)
     @pool = {}
     @factory = Puppet::Network::HTTP::Factory.new
     @keepalive_timeout = keepalive_timeout

data/lib/puppet/network/http_pool.rb

@@ -19,6 +19,7 @@ module Puppet::Network::HttpPool
   end
   def self.http_client_class=(klass)
     @http_client_class = klass
+    Puppet.runtime['http'] = Puppet::HTTP::ExternalClient.new(klass)
   end
 
   # Retrieve a connection for the given host and port.

data/lib/puppet/node/environment.rb

@@ -162,6 +162,10 @@ class Puppet::Node::Environment
   # @api private
   attr_accessor :loaders
 
+  # Lock for compilation that needs exclusive access to the environment
+  # @api private
+  attr_reader :lock
+
   # Checks to make sure that this environment did not have a manifest set in
   # its original environment.conf if Puppet is configured with
   # +disable_per_environment_manifest+ set true.  If it did, the environment's
@@ -293,7 +297,13 @@ class Puppet::Node::Environment
   def modules
     if @modules.nil?
       module_references = []
-      seen_modules = {}
+      project = Puppet.lookup(:bolt_project) { nil }
+      seen_modules = if project
+                       module_references << project.to_h
+                       { project.name => true }
+                     else
+                       {}
+                     end
       modulepath.each do |path|
         Dir.entries(path).each do |name|
           next unless Puppet::Module.is_module_directory?(name, path)

data/lib/puppet/pal/pal_impl.rb

@@ -422,37 +422,9 @@ module Pal
     # TRANSLATORS, the string "For puppet PAL" is not user facing
     Puppet.override({:current_environment => apply_environment}, "For puppet PAL") do
       begin
-        # support the following features when evaluating puppet code
-        # * $facts with facts from host running the script
-        # * $settings with 'settings::*' namespace populated, and '$settings::all_local' hash
-        # * $trusted as setup when using puppet apply
-        # * an environment
-        #
-
-        # fixup trusted information
         node.sanitize()
-
         compiler = create_internal_compiler(internal_compiler_class, node)
-        # compiler = Puppet::Parser::ScriptCompiler.new(node.environment, node.name)
-        topscope = compiler.topscope
-
-        # When scripting the trusted data are always local, but set them anyway
-        # When compiling for a catalog, the catalog compiler does this
-        unless internal_compiler_class == :catalog
-          topscope.set_trusted(node.trusted_data)
-
-          # Server facts are always about the local node's version etc.
-          topscope.set_server_facts(node.server_facts)
-
-          # Set $facts for the node running the script
-          facts_hash = node.facts.nil? ? {} : node.facts.values
-          topscope.set_facts(facts_hash)
-
-          # create the $settings:: variables
-          topscope.merge_settings(node.environment.name, false)
-        end
-
-        add_variables(topscope, pal_variables)
+        add_variables(compiler.topscope, pal_variables)
 
         case internal_compiler_class
         when :script

data/lib/puppet/parser/compiler.rb

@@ -777,13 +777,7 @@ class Puppet::Parser::Compiler
   SETTINGS = 'settings'.freeze
 
   def create_settings_scope
-    resource_types = environment.known_resource_types
-    settings_type = resource_types.hostclass(SETTINGS)
-    if settings_type.nil?
-      settings_type = Puppet::Resource::Type.new(:hostclass, SETTINGS)
-      resource_types.add(settings_type)
-    end
-
+    settings_type = create_settings_type
     settings_resource = Puppet::Parser::Resource.new('class', SETTINGS, :scope => @topscope)
 
     @catalog.add_resource(settings_resource)
@@ -794,6 +788,19 @@ class Puppet::Parser::Compiler
     scope.merge_settings(environment.name)
   end
 
+  def create_settings_type
+    environment.lock.synchronize do
+      resource_types = environment.known_resource_types
+      settings_type = resource_types.hostclass(SETTINGS)
+      if settings_type.nil?
+        settings_type = Puppet::Resource::Type.new(:hostclass, SETTINGS)
+        resource_types.add(settings_type)
+      end
+
+      settings_type
+    end
+  end
+
   # Return an array of all of the unevaluated resources.  These will be definitions,
   # which need to get evaluated into native resources.
   def unevaluated_resources

data/lib/puppet/parser/functions.rb

@@ -1,6 +1,7 @@
 require 'puppet/util/autoload'
 require 'puppet/parser/scope'
 require 'puppet/pops/adaptable'
+require 'puppet/concurrent/lock'
 
 # A module for managing parser functions.  Each specified function
 # is added to a central module that then gets included into the Scope
@@ -78,28 +79,32 @@ module Puppet::Parser::Functions
     attr_accessor :module
   end
 
+  @environment_module_lock = Puppet::Concurrent::Lock.new
+
   # Get the module that functions are mixed into corresponding to an
   # environment
   #
   # @api private
   def self.environment_module(env)
-    AnonymousModuleAdapter.adapt(env) do |a|
-      a.module ||= Module.new do
-        @metadata = {}
+    @environment_module_lock.synchronize do
+      AnonymousModuleAdapter.adapt(env) do |a|
+        a.module ||= Module.new do
+          @metadata = {}
 
-        def self.all_function_info
-          @metadata
-        end
+          def self.all_function_info
+            @metadata
+          end
 
-        def self.get_function_info(name)
-          @metadata[name]
-        end
+          def self.get_function_info(name)
+            @metadata[name]
+          end
 
-        def self.add_function_info(name, info)
-          @metadata[name] = info
+          def self.add_function_info(name, info)
+            @metadata[name] = info
+          end
         end
-      end
-    end.module
+      end.module
+    end
   end
 
   # Create a new Puppet DSL function.

data/lib/puppet/pops/loaders.rb

@@ -19,12 +19,14 @@ class Loaders
   attr_reader :environment
 
   def self.new(environment, for_agent = false)
-    obj = environment.loaders
-    if obj.nil?
-      obj = self.allocate
-      obj.send(:initialize, environment, for_agent)
+    environment.lock.synchronize do
+      obj = environment.loaders
+      if obj.nil?
+        obj = self.allocate
+        obj.send(:initialize, environment, for_agent)
+      end
+      obj
     end
-    obj
   end
 
   def initialize(environment, for_agent)