puppet 6.14.0-universal-darwin → 6.19.0-universal-darwin

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

@@ -20,7 +20,7 @@ class Puppet::Node::Facts::Yaml < Puppet::Indirector::Yaml
 
   # Return the path to a given node's file.
   def yaml_dir_path
-    base = Puppet.run_mode.master? ? Puppet[:yamldir] : Puppet[:clientyamldir]
+    base = Puppet.run_mode.server? ? Puppet[:yamldir] : Puppet[:clientyamldir]
     File.join(base, 'facts', '*.yaml')
   end
 

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

@@ -4,5 +4,53 @@ require 'puppet/file_bucket/file'
 module Puppet::FileBucketFile
   class Rest < Puppet::Indirector::REST
     desc "This is a REST based mechanism to send/retrieve file to/from the filebucket"
+
+    def head(request)
+      return super unless use_http_client?
+
+      session = Puppet.lookup(:http_session)
+      api = session.route_to(:puppet)
+      api.head_filebucket_file(
+        request.key,
+        environment: request.environment.to_s,
+        bucket_path: request.options[:bucket_path],
+      )
+    rescue Puppet::HTTP::ResponseError => e
+      return nil if e.response.code == 404
+      raise convert_to_http_error(e.response.nethttp)
+    end
+
+    def find(request)
+      return super unless use_http_client?
+
+      session = Puppet.lookup(:http_session)
+      api = session.route_to(:puppet)
+      _, filebucket_file = api.get_filebucket_file(
+        request.key,
+        environment: request.environment.to_s,
+        bucket_path: request.options[:bucket_path],
+        diff_with: request.options[:diff_with],
+        list_all: request.options[:list_all],
+        fromdate: request.options[:fromdate],
+        todate: request.options[:todate],
+      )
+      filebucket_file
+    rescue Puppet::HTTP::ResponseError => e
+      raise convert_to_http_error(e.response.nethttp)
+    end
+
+    def save(request)
+      return super unless use_http_client?
+
+      session = Puppet.lookup(:http_session)
+      api = session.route_to(:puppet)
+      api.put_filebucket_file(
+        request.key,
+        body: request.instance.render,
+        environment: request.environment.to_s,
+      )
+    rescue Puppet::HTTP::ResponseError => e
+      raise convert_to_http_error(e.response.nethttp)
+    end
   end
 end

data/lib/puppet/indirector/file_content/http.rb

@@ -10,6 +10,11 @@ class Puppet::Indirector::FileContent::Http < Puppet::Indirector::GenericHttp
 
   @http_method = :get
 
+  def initialize
+    Puppet.deprecation_warning(_("Puppet::Indirector::FileContent::Http is deprecated. Use Puppet::HTTP::Client instead."))
+    super
+  end
+
   def find(request)
     response = super
     model.from_binary(uncompress_body(response))

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

@@ -18,7 +18,7 @@ class Puppet::Indirector::FileContent::Rest < Puppet::Indirector::REST
     api = session.route_to(:fileserver, url: url)
 
     api.get_file_content(
-      path: URI.unescape(url.path),
+      path: Puppet::Util.uri_unescape(url.path),
       environment: request.environment.to_s,
     ) do |data|
       content << data

data/lib/puppet/indirector/file_metadata/http.rb

@@ -8,20 +8,40 @@ class Puppet::Indirector::FileMetadata::Http < Puppet::Indirector::GenericHttp
 
   include Puppet::FileServing::TerminusHelper
 
-  @http_method = :head
-
   def find(request)
-    head = super
+    checksum_type = request.options[:checksum_type]
+    # See URL encoding comment in Puppet::Type::File::ParamSource#chunk_file_from_source
+    uri = URI(request.uri)
+    client = Puppet.runtime[:http]
+    head = client.head(uri, options: {include_system_store: true})
+
+    return create_httpmetadata(head, checksum_type) if head.success?
 
-    if head.is_a?(Net::HTTPSuccess)
-      metadata = Puppet::FileServing::HttpMetadata.new(head)
-      metadata.checksum_type = request.options[:checksum_type] if request.options[:checksum_type]
-      metadata.collect
-      metadata
+    case head.code
+    when 403, 405
+      # AMZ presigned URL and puppetserver may return 403
+      # instead of 405. Fallback to partial get
+      get = partial_get(client, uri)
+      return create_httpmetadata(get, checksum_type) if get.success?
     end
+
+    nil
   end
 
   def search(request)
     raise Puppet::Error, _("cannot lookup multiple files")
   end
+
+  private
+
+  def partial_get(client, uri)
+    client.get(uri, headers: {'Range' => 'bytes=0-0'}, options: {include_system_store: true})
+  end
+
+  def create_httpmetadata(http_request, checksum_type)
+    metadata = Puppet::FileServing::HttpMetadata.new(http_request)
+    metadata.checksum_type = checksum_type if checksum_type
+    metadata.collect
+    metadata
+  end
 end

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

@@ -14,13 +14,14 @@ class Puppet::Indirector::FileMetadata::Rest < Puppet::Indirector::REST
     session = Puppet.lookup(:http_session)
     api = session.route_to(:fileserver, url: url)
 
-    api.get_file_metadata(
-      path: URI.unescape(url.path),
+    _, file_metadata = api.get_file_metadata(
+      path: Puppet::Util.uri_unescape(url.path),
       environment: request.environment.to_s,
       links: request.options[:links],
       checksum_type: request.options[:checksum_type],
       source_permissions: request.options[:source_permissions]
     )
+    file_metadata
   rescue Puppet::HTTP::ResponseError => e
     if e.response.code == 404
       return nil unless request.options[:fail_on_404]
@@ -40,8 +41,8 @@ class Puppet::Indirector::FileMetadata::Rest < Puppet::Indirector::REST
     session = Puppet.lookup(:http_session)
     api = session.route_to(:fileserver, url: url)
 
-    api.get_file_metadatas(
-      path: URI.unescape(url.path),
+    _, file_metadatas = api.get_file_metadatas(
+      path: Puppet::Util.uri_unescape(url.path),
       environment: request.environment.to_s,
       recurse: request.options[:recurse],
       recurselimit: request.options[:recurselimit],
@@ -50,6 +51,7 @@ class Puppet::Indirector::FileMetadata::Rest < Puppet::Indirector::REST
       checksum_type: request.options[:checksum_type],
       source_permissions: request.options[:source_permissions],
     )
+    file_metadatas
   rescue Puppet::HTTP::ResponseError => e
     # since it's search, return empty array instead of nil
     return [] if e.response.code == 404

data/lib/puppet/indirector/hiera.rb

@@ -1,6 +1,10 @@
 require 'puppet/indirector/terminus'
 require 'hiera/scope'
 
+# This class can't be collapsed into Puppet::Indirector::DataBindings::Hiera
+# because some community plugins rely on this class directly, see PUP-1843.
+# This class is deprecated and will be deleted in a future release.
+# Use `Puppet::DataBinding.indirection.terminus(:hiera)` instead.
 class Puppet::Indirector::Hiera < Puppet::Indirector::Terminus
   def initialize(*args)
     if ! Puppet.features.hiera?

data/lib/puppet/indirector/indirection.rb

@@ -269,7 +269,7 @@ class Puppet::Indirector::Indirection
       return nil
     end
 
-    Puppet.debug "Using cached #{self.name} for #{request.key}"
+    Puppet.debug { "Using cached #{self.name} for #{request.key}" }
     cached
   rescue => detail
     Puppet.log_exception(detail, _("Cached %{indirection} for %{request} failed: %{detail}") % { indirection: self.name, request: request.key, detail: detail })

data/lib/puppet/indirector/json.rb

@@ -41,7 +41,7 @@ class Puppet::Indirector::JSON < Puppet::Indirector::Terminus
       raise ArgumentError, _("invalid key")
     end
 
-    base = Puppet.run_mode.master? ? Puppet[:server_datadir] : Puppet[:client_datadir]
+    base = Puppet.run_mode.server? ? Puppet[:server_datadir] : Puppet[:client_datadir]
     File.join(base, self.class.indirection_name.to_s, name.to_s + ext)
   end
 

data/lib/puppet/indirector/msgpack.rb

@@ -48,7 +48,7 @@ class Puppet::Indirector::Msgpack < Puppet::Indirector::Terminus
       raise ArgumentError, _("invalid key")
     end
 
-    base = Puppet.run_mode.master? ? Puppet[:server_datadir] : Puppet[:client_datadir]
+    base = Puppet.run_mode.server? ? Puppet[:server_datadir] : Puppet[:client_datadir]
     File.join(base, self.class.indirection_name.to_s, name.to_s + ext)
   end
 

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

@@ -10,12 +10,13 @@ class Puppet::Node::Rest < Puppet::Indirector::REST
 
     session = Puppet.lookup(:http_session)
     api = session.route_to(:puppet)
-    api.get_node(
+    _, node = api.get_node(
       request.key,
       environment: request.environment.to_s,
       configured_environment: request.options[:configured_environment],
       transaction_uuid: request.options[:transaction_uuid]
     )
+    node
   rescue Puppet::HTTP::ResponseError => e
     if e.response.code == 404
       return nil unless request.options[:fail_on_404]

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

@@ -26,9 +26,9 @@ class Puppet::Transaction::Report::Processor < Puppet::Indirector::Code
   # LAK:NOTE This isn't necessarily the best design, but it's backward
   # compatible and that's good enough for now.
   def process(report)
-    Puppet.debug "Received report to process from #{report.host}"
+    Puppet.debug { "Received report to process from #{report.host}" }
     processors do |mod|
-      Puppet.debug "Processing report from #{report.host} with processor #{mod}"
+      Puppet.debug { "Processing report from #{report.host} with processor #{mod}" }
       # We have to use a dup because we're including a module in the
       # report.
       newrep = report.dup

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/request.rb

@@ -231,9 +231,9 @@ class Puppet::Indirector::Request
           debug_once _("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
-          debug_once _("Selected port from the `masterport` setting: %{port}") % {port: Puppet.settings[:masterport]}
-          Puppet.settings[:masterport]
+          #TRANSLATORS 'serverport' is the name of a setting and should not be translated
+          debug_once _("Selected port from the `serverport` setting: %{port}") % {port: Puppet.settings[:serverport]}
+          Puppet.settings[:serverport]
         end
       end
     end
@@ -277,7 +277,7 @@ class Puppet::Indirector::Request
     # If the URI class can look up the scheme, it will provide a port,
     # otherwise it will default to '0'.
     if uri.port.to_i == 0 and uri.scheme == "puppet"
-      @port = Puppet.settings[:masterport].to_i
+      @port = Puppet.settings[:serverport].to_i
     else
       @port = uri.port.to_i
     end
@@ -290,6 +290,6 @@ class Puppet::Indirector::Request
       @protocol = uri.scheme
     end
 
-    @key = URI.unescape(uri.path.sub(/^\//, ''))
+    @key = Puppet::Util.uri_unescape(uri.path.sub(/^\//, ''))
   end
 end

data/lib/puppet/indirector/rest.rb

@@ -55,7 +55,8 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   # Should we use puppet's http client to make requests. Will return
   # false when running in puppetserver
   def use_http_client?
-    Puppet::Network::HttpPool.http_client_class == Puppet::Network::HTTP::Connection
+    Puppet::Network::HttpPool.http_client_class == Puppet::Network::HTTP::Connection ||
+      Puppet::Network::HttpPool.http_client_class == Puppet::Network::HTTP::ConnectionAdapter
   end
 
   # Provide appropriate headers.
@@ -111,6 +112,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   end
 
   def find(request)
+    Puppet.deprecation_warning(_("Puppet::Indirector::Rest#find is deprecated. Use Puppet::HTTP::Client instead."))
     uri, body = IndirectedRoutes.request_to_uri_and_body(request)
     uri_with_query_string = "#{uri}?#{body}"
 
@@ -149,6 +151,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   end
 
   def head(request)
+    Puppet.deprecation_warning(_("Puppet::Indirector::Rest#head is deprecated. Use Puppet::HTTP::Client instead."))
     response = do_request(request) do |req|
       http_head(req, IndirectedRoutes.request_to_uri(req), headers)
     end
@@ -161,6 +164,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   end
 
   def search(request)
+    Puppet.deprecation_warning(_("Puppet::Indirector::Rest#search is deprecated. Use Puppet::HTTP::Client instead."))
     response = do_request(request) do |req|
       http_get(req, IndirectedRoutes.request_to_uri(req), headers)
     end
@@ -174,6 +178,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   end
 
   def destroy(request)
+    Puppet.deprecation_warning(_("Puppet::Indirector::Rest#destroy is deprecated. Use Puppet::HTTP::Client instead."))
     raise ArgumentError, _("DELETE does not accept options") unless request.options.empty?
 
     response = do_request(request) do |req|
@@ -189,6 +194,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   end
 
   def save(request)
+    Puppet.deprecation_warning(_("Puppet::Indirector::Rest#save is deprecated. Use Puppet::HTTP::Client instead."))
     raise ArgumentError, _("PUT does not accept options") unless request.options.empty?
 
     response = do_request(request) do |req|

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/indirector/yaml.rb

@@ -40,7 +40,7 @@ class Puppet::Indirector::Yaml < Puppet::Indirector::Terminus
       raise ArgumentError, _("invalid key")
     end
 
-    base = Puppet.run_mode.master? ? Puppet[:yamldir] : Puppet[:clientyamldir]
+    base = Puppet.run_mode.server? ? Puppet[:yamldir] : Puppet[:clientyamldir]
     File.join(base, self.class.indirection_name.to_s, name.to_s + ext)
   end
 

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