puppet 6.26.0-x64-mingw32 → 7.0.0-x64-mingw32

data/lib/puppet/indirector/rest.rb

@@ -1,241 +1,23 @@
-require 'net/http'
-require 'uri'
-require 'puppet/util/json'
-require 'puppet/util/connection'
-require 'semantic_puppet'
-
-require 'puppet/network/http'
-require 'puppet/network/http_pool'
-
 # Access objects via REST
 class Puppet::Indirector::REST < Puppet::Indirector::Terminus
-  include Puppet::Network::HTTP::Compression.module
-
-  IndirectedRoutes = Puppet::Network::HTTP::API::IndirectedRoutes
-  EXCLUDED_FORMATS = [:yaml, :b64_zlib_yaml, :dot]
-
-  # puppet major version where JSON is enabled by default
-  MAJOR_VERSION_JSON_DEFAULT = 5
-
-  class << self
-    attr_reader :server_setting, :port_setting
-  end
-
-  # Specify the setting that we should use to get the server name.
-  def self.use_server_setting(setting)
-    @server_setting = setting
-  end
-
-  # Specify the setting that we should use to get the port.
-  def self.use_port_setting(setting)
-    @port_setting = setting
-  end
-
-  # Specify the service to use when doing SRV record lookup
-  def self.use_srv_service(service)
-    @srv_service = service
-  end
-
-  def self.srv_service
-    @srv_service || :puppet
-  end
-
-  # Select the server to use based on the settings configuration
-  # for this indirection, taking into account the HA server list.
-  def self.server
-    Puppet::Util::Connection.determine_server(server_setting)
-  end
-
-  # Select the port to use based on the settings configuration
-  # for this indirection, taking into account the HA server list.
-  def self.port
-    Puppet::Util::Connection.determine_port(port_setting, server_setting)
-  end
-
-  # 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::ConnectionAdapter
-  end
-
-  # Provide appropriate headers.
-  def headers
-    # yaml is not allowed on the network
-    network_formats = model.supported_formats - EXCLUDED_FORMATS
-    mime_types = network_formats.map { |f| model.get_format(f).mime }
-    common_headers = {
-      "Accept"                                     => mime_types.join(', '),
-      Puppet::Network::HTTP::HEADER_PUPPET_VERSION => Puppet.version
-    }
-
-    add_accept_encoding(common_headers)
-  end
-
-  def add_profiling_header(headers)
-    if (Puppet[:profile])
-      headers[Puppet::Network::HTTP::HEADER_ENABLE_PROFILING] = "true"
-    end
-    headers
-  end
-
-  def network(request)
-    ssl_context = Puppet.lookup(:ssl_context)
-    Puppet::Network::HttpPool.connection(request.server || self.class.server,
-                                         request.port || self.class.port,
-                                         ssl_context: ssl_context)
-  end
-
-  def http_get(request, path, headers = nil, *args)
-    http_request(:get, request, path, add_profiling_header(headers), *args)
-  end
-
-  def http_post(request, path, data, headers = nil, *args)
-    http_request(:post, request, path, data, add_profiling_header(headers), *args)
-  end
-
-  def http_head(request, path, headers = nil, *args)
-    http_request(:head, request, path, add_profiling_header(headers), *args)
-  end
-
-  def http_delete(request, path, headers = nil, *args)
-    http_request(:delete, request, path, add_profiling_header(headers), *args)
-  end
-
-  def http_put(request, path, data, headers = nil, *args)
-    http_request(:put, request, path, data, add_profiling_header(headers), *args)
-  end
-
-  def http_request(method, request, *args)
-    conn = network(request)
-    conn.send(method, *args)
-  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}"
-
-    response = do_request(request) do |req|
-      # WEBrick in Ruby 1.9.1 only supports up to 1024 character lines in an HTTP request
-      # http://redmine.ruby-lang.org/issues/show/3991
-      if "GET #{uri_with_query_string} HTTP/1.1\r\n".length > 1024
-        uri_with_env = "#{uri}?environment=#{request.environment.name}"
-        http_post(req, uri_with_env, body, headers)
-      else
-        http_get(req, uri_with_query_string, headers)
-      end
-    end
-
-    if is_http_200?(response)
-      content_type, body = parse_response(response)
-      result = deserialize_find(content_type, body)
-      result.name = request.key if result.respond_to?(:name=)
-      result
-
-    elsif is_http_404?(response)
-      return nil unless request.options[:fail_on_404]
-
-      # 404 can get special treatment as the indirector API can not produce a meaningful
-      # reason to why something is not found - it may not be the thing the user is
-      # expecting to find that is missing, but something else (like the environment).
-      # While this way of handling the issue is not perfect, there is at least an error
-      # that makes a user aware of the reason for the failure.
-      #
-      _, body = parse_response(response)
-      msg = _("Find %{uri} resulted in 404 with the message: %{body}") % { uri: elide(uri_with_query_string, 100), body: body }
-      raise Puppet::Error, msg
-    else
-      nil
-    end
+    raise NotImplementedError
   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
-
-    if is_http_200?(response)
-      true
-    else
-      false
-    end
+    raise NotImplementedError
   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
-
-    if is_http_200?(response)
-      content_type, body = parse_response(response)
-      deserialize_search(content_type, body) || []
-    else
-      []
-    end
+    raise NotImplementedError
   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|
-      http_delete(req, IndirectedRoutes.request_to_uri(req), headers)
-    end
-
-    if is_http_200?(response)
-      content_type, body = parse_response(response)
-      deserialize_destroy(content_type, body)
-    else
-      nil
-    end
+    raise NotImplementedError
   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|
-      http_put(req, IndirectedRoutes.request_to_uri(req), req.instance.render, headers.merge({ "Content-Type" => req.instance.mime }))
-    end
-
-    if is_http_200?(response)
-      content_type, body = parse_response(response)
-      deserialize_save(content_type, body)
-    else
-      nil
-    end
-  end
-
-  # Encapsulate call to request.do_request with the arguments from this class
-  # Then yield to the code block that was called in
-  # We certainly could have retained the full request.do_request(...) { |r| ... }
-  # but this makes the code much cleaner and we only then actually make the call
-  # to request.do_request from here, thus if we change what we pass or how we
-  # get it, we only need to change it here.
-  def do_request(request)
-    response = request.do_request(self.class.srv_service, self.class.server, self.class.port) { |req| yield(req) }
-
-    handle_response(request, response) if response
-
-    response
-  end
-
-  def handle_response(request, response)
-    server_version = response[Puppet::Network::HTTP::HEADER_PUPPET_VERSION]
-    if server_version
-      Puppet.lookup(:server_agent_version) do
-        Puppet.push_context(:server_agent_version => server_version)
-      end
-      if SemanticPuppet::Version.parse(server_version).major < MAJOR_VERSION_JSON_DEFAULT &&
-          Puppet[:preferred_serialization_format] != 'pson'
-        #TRANSLATORS "PSON" should not be translated
-        Puppet.warning(_("Downgrading to PSON for future requests"))
-        Puppet[:preferred_serialization_format] = 'pson'
-      end
-    end
+    raise NotImplementedError
   end
 
   def validate_key(request)
@@ -244,67 +26,34 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
 
   private
 
-  def is_http_200?(response)
-    case response.code
-    when "404"
-      false
-    when /^2/
-      true
-    else
-      # Raise the http error if we didn't get a 'success' of some kind.
-      raise convert_to_http_error(response)
-    end
-  end
-
-  def is_http_404?(response)
-    response.code == "404"
-  end
-
   def convert_to_http_error(response)
-    if response.body.to_s.empty? && response.respond_to?(:message)
-      returned_message = response.message
+    if response.body.to_s.empty? && response.reason
+      returned_message = response.reason
     elsif response['content-type'].is_a?(String)
       content_type, body = parse_response(response)
       if content_type =~ /[pj]son/
         returned_message = Puppet::Util::Json.load(body)["message"]
       else
-        returned_message = uncompress_body(response)
+        returned_message = response.body
       end
     else
-      returned_message = uncompress_body(response)
+      returned_message = response.body
     end
 
     message = _("Error %{code} on SERVER: %{returned_message}") % { code: response.code, returned_message: returned_message }
-    Net::HTTPError.new(message, response)
+    Net::HTTPError.new(message, Puppet::HTTP::ResponseConverter.to_ruby_response(response))
   end
 
   # Returns the content_type, stripping any appended charset, and the
-  # body, decompressed if necessary (content-encoding is checked inside
-  # uncompress_body)
+  # body, decompressed if necessary
   def parse_response(response)
     if response['content-type']
-      [ response['content-type'].gsub(/\s*;.*$/,''), uncompress_body(response) ]
+      [ response['content-type'].gsub(/\s*;.*$/,''), response.body ]
     else
       raise _("No content type in http response; cannot parse")
     end
   end
 
-  def deserialize_find(content_type, body)
-    model.convert_from(content_type, body)
-  end
-
-  def deserialize_search(content_type, body)
-    model.convert_from_multiple(content_type, body)
-  end
-
-  def deserialize_destroy(content_type, body)
-    model.convert_from(content_type, body)
-  end
-
-  def deserialize_save(content_type, body)
-    nil
-  end
-
   def elide(string, length)
     if Puppet::Util::Log.level == :debug || string.length <= length
       string

data/lib/puppet/indirector/terminus.rb

@@ -143,10 +143,6 @@ class Puppet::Indirector::Terminus
     self.class.name
   end
 
-  def require_environment?
-    true
-  end
-
   def allow_remote_requests?
     true
   end

data/lib/puppet/interface/documentation.rb

@@ -76,7 +76,6 @@ class Puppet::Interface
         s.text(" ")
 
         options.each do |option|
-          next if option == :extra
           option = get_option(option)
           wrap = option.required? ? %w{ < > } : %w{ [ ] }
 

data/lib/puppet/module/plan.rb

@@ -50,6 +50,7 @@ class Puppet::Module
     RESERVED_DATA_TYPES = %w{any array boolean catalogentry class collection
         callable data default enum float hash integer numeric optional pattern
         resource runtime scalar string struct tuple type undef variant}
+    MOUNTS = %w[lib files plans]
 
     def self.is_plan_name?(name)
       return true if name =~ /^[a-z][a-z0-9_]*$/

data/lib/puppet/module/task.rb

@@ -45,7 +45,7 @@ class Puppet::Module
     end
 
     FORBIDDEN_EXTENSIONS = %w{.conf .md}
-    MOUNTS = %w[files lib scripts tasks]
+    MOUNTS = %w[lib files tasks]
 
     def self.is_task_name?(name)
       return true if name =~ /^[a-z][a-z0-9_]*$/

data/lib/puppet/module.rb

@@ -25,7 +25,6 @@ class Puppet::Module
     "plugins" => "lib",
     "pluginfacts" => "facts.d",
     "locales" => "locales",
-    "scripts" => "scripts",
   }
 
   # Find and return the +module+ that +path+ belongs to. If +path+ is

data/lib/puppet/module_tool/applications/installer.rb

@@ -59,10 +59,6 @@ module Puppet::ModuleTool
         results = { :action => :install, :module_name => name, :module_version => version }
 
         begin
-          if !@local_tarball && name !~ /-/
-            raise InvalidModuleNameError.new(module_name: @name, suggestion: "puppetlabs-#{@name}", action: :install)
-          end
-
           installed_module = installed_modules[name]
           if installed_module
             unless forced?
@@ -135,58 +131,8 @@ module Puppet::ModuleTool
           begin
             Puppet.info _("Resolving dependencies ...")
             releases = SemanticPuppet::Dependency.resolve(graph)
-          rescue SemanticPuppet::Dependency::UnsatisfiableGraph => e
-            unsatisfied = nil
-
-            if e.respond_to?(:unsatisfied) && e.unsatisfied
-              constraints = {}
-              # If the module we're installing satisfies all its
-              # dependencies, but would break an already installed
-              # module that depends on it, show what would break.
-              if name == e.unsatisfied
-                graph.constraints[name].each do |mod, range, _|
-                  next unless mod.split.include?('constraint')
-
-                  # If the user requested a specific version or range,
-                  # only show the modules with non-intersecting ranges
-                  if options[:version]
-                    requested_range = SemanticPuppet::VersionRange.parse(options[:version])
-                    constraint_range = SemanticPuppet::VersionRange.parse(range)
-
-                    if requested_range.intersection(constraint_range) == SemanticPuppet::VersionRange::EMPTY_RANGE
-                      constraints[mod.split.first] = range
-                    end
-                  else
-                    constraints[mod.split.first] = range
-                  end
-                end
-
-              # If the module fails to satisfy one of its
-              # dependencies, show the unsatisfiable module
-              else
-                dep_constraints = graph.dependencies[name].max.constraints
-
-                if dep_constraints.key?(e.unsatisfied)
-                  unsatisfied_range = dep_constraints[e.unsatisfied].first[1]
-                  constraints[e.unsatisfied] = unsatisfied_range
-                end
-              end
-
-              installed_module = @environment.module_by_forge_name(e.unsatisfied.tr('-', '/'))
-              current_version = installed_module.version if installed_module
-
-              unsatisfied = {
-                :name => e.unsatisfied,
-                :constraints => constraints,
-                :current_version => current_version
-              } if constraints.any?
-            end
-
-            raise NoVersionsSatisfyError, results.merge(
-                    :requested_name => name,
-                    :requested_version => options[:version] || graph.dependencies[name].max.version.to_s,
-                    :unsatisfied => unsatisfied
-            )
+          rescue SemanticPuppet::Dependency::UnsatisfiableGraph
+            raise NoVersionsSatisfyError, results.merge(:requested_name => name)
           end
 
           unless forced?

data/lib/puppet/module_tool/applications/uninstaller.rb

@@ -89,7 +89,7 @@ module Puppet::ModuleTool
         mod = @installed.first
 
         unless @ignore_changes
-          raise _("Either the `--ignore_changes` or `--force` argument must be specified to uninstall modules when running in FIPS mode.") if Puppet.runtime[:facter].value(:fips_enabled)
+          raise _("Either the `--ignore_changes` or `--force` argument must be specified to uninstall modules when running in FIPS mode.") if Facter.value(:fips_enabled)
 
           changes = begin
             Puppet::ModuleTool::Applications::Checksummer.run(mod.path)

data/lib/puppet/module_tool/applications/upgrader.rb

@@ -27,7 +27,7 @@ module Puppet::ModuleTool
 
       def run
         # Disallow anything that invokes md5 to avoid un-friendly termination due to FIPS
-        raise _("Module upgrade is prohibited in FIPS mode.") if Puppet.runtime[:facter].value(:fips_enabled)
+        raise _("Module upgrade is prohibited in FIPS mode.") if Facter.value(:fips_enabled)
 
         name = @name.tr('/', '-')
         version = options[:version] || '>= 0.0.0'

data/lib/puppet/module_tool/applications.rb

@@ -5,7 +5,6 @@ module Puppet::ModuleTool
     require 'puppet/module_tool/applications/application'
     require 'puppet/module_tool/applications/checksummer'
     require 'puppet/module_tool/applications/installer'
-    require 'puppet/module_tool/applications/searcher'
     require 'puppet/module_tool/applications/unpacker'
     require 'puppet/module_tool/applications/uninstaller'
     require 'puppet/module_tool/applications/upgrader'

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

@@ -7,7 +7,6 @@ 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
@@ -15,23 +14,9 @@ module Puppet::ModuleTool::Errors
     def multiline
       message = []
       message << _("Could not %{action} module '%{module_name}' (%{version})") % { action: @action, module_name: @requested_name, version: vstring }
-
-      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
-
+      message << _("  No version of '%{module_name}' can satisfy all dependencies") % { module_name: @requested_name }
       #TRANSLATORS `puppet module %{action} --ignore-dependencies` is a command line and should not be translated
-      message << _("  Use `puppet module %{action} '%{module_name}' --ignore-dependencies` to %{action} only this module") % { action: @action, module_name: @requested_name }
+      message << _("    Use `puppet module %{action} --ignore-dependencies` to %{action} only this module") % { action: @action }
       message.join("\n")
     end
   end
@@ -127,23 +112,6 @@ module Puppet::ModuleTool::Errors
     end
   end
 
-  class InvalidModuleNameError < ModuleToolError
-    def initialize(options)
-      @module_name = options[:module_name]
-      @suggestion = options[:suggestion]
-      @action = options[:action]
-      super _("Could not %{action} '%{module_name}', did you mean '%{suggestion}'?") % { action: @action, module_name: @module_name, suggestion: @suggestion }
-    end
-
-    def multiline
-      message = []
-      message << _("Could not %{action} module '%{module_name}'") % { action: @action, module_name: @module_name }
-      message << _("  The name '%{module_name}' is invalid") % { module_name: @module_name }
-      message << _("    Did you mean `puppet module %{action} %{suggestion}`?") % { action: @action, suggestion: @suggestion }
-      message.join("\n")
-    end
-  end
-
   class NotInstalledError < ModuleToolError
     def initialize(options)
       @module_name = options[:module_name]

data/lib/puppet/network/authconfig.rb

@@ -1,101 +1,7 @@
-require 'puppet/network/rights'
-require 'puppet/network/http'
-
 module Puppet
-  class ConfigurationError < Puppet::Error; end
-  class Network::DefaultAuthProvider
-    attr_accessor :rights
-
-    def self.master_url_prefix
-      Puppet::Network::HTTP::MASTER_URL_PREFIX
-    end
-
-    def self.default_acl
-      [
-      # Master API V3
-      { :acl => "#{master_url_prefix}/v3/environments", :method => :find, :allow => '*', :authenticated => true },
-
-      { :acl => "~ ^#{master_url_prefix}\/v3\/catalog\/([^\/]+)$", :method => :find, :allow => '$1', :authenticated => true },
-      { :acl => "~ ^#{master_url_prefix}\/v3\/node\/([^\/]+)$", :method => :find, :allow => '$1', :authenticated => true },
-      { :acl => "~ ^#{master_url_prefix}\/v3\/report\/([^\/]+)$", :method => :save, :allow => '$1', :authenticated => true },
-
-      # this one will allow all file access, and thus delegate
-      # to fileserver.conf
-      { :acl => "#{master_url_prefix}/v3/file" },
-
-      { :acl => "#{master_url_prefix}/v3/status", :method => [:find], :authenticated => true },
-      ]
-    end
-
-    # Just proxy the setting methods to our rights stuff
-    [:allow, :deny].each do |method|
-      define_method(method) do |*args|
-        @rights.send(method, *args)
-      end
-    end
-
-    # force regular ACLs to be present
-    def insert_default_acl
-      self.class.default_acl.each do |acl|
-        unless rights[acl[:acl]]
-          Puppet.info _("Inserting default '%{acl}' (auth %{auth}) ACL") % { acl: acl[:acl], auth: acl[:authenticated] }
-          mk_acl(acl)
-        end
-      end
-      # queue an empty (ie deny all) right for every other path
-      # actually this is not strictly necessary as the rights system
-      # denies not explicitly allowed paths
-      unless rights["/"]
-        rights.newright("/").restrict_authenticated(:any)
-      end
-    end
-
-    def mk_acl(acl)
-      right = @rights.newright(acl[:acl])
-      right.allow(acl[:allow] || "*")
-
-      method = acl[:method]
-      if method
-        method = [method] unless method.is_a?(Array)
-        method.each { |m| right.restrict_method(m) }
-      end
-      right.restrict_authenticated(acl[:authenticated]) unless acl[:authenticated].nil?
-    end
-
-    # check whether this request is allowed in our ACL
-    # raise an Puppet::Network::AuthorizedError if the request
-    # is denied.
-    def check_authorization(method, path, params)
-      authorization_failure_exception = @rights.is_request_forbidden_and_why?(method, path, params)
-      if authorization_failure_exception
-        Puppet.warning(_("Denying access: %{authorization_failure_exception}") % { authorization_failure_exception: authorization_failure_exception })
-        raise authorization_failure_exception
-      end
-    end
-
-    def initialize(rights=nil)
-      @rights = rights || Puppet::Network::Rights.new
-      insert_default_acl
-    end
-  end
-
   class Network::AuthConfig
-    @@authprovider_class = nil
-
-    def self.authprovider_class=(klass)
-      @@authprovider_class = klass
-    end
-
-    def self.authprovider_class
-      @@authprovider_class || Puppet::Network::DefaultAuthProvider
-    end
-
-    def initialize(rights=nil)
-      @authprovider = self.class.authprovider_class.new(rights)
-    end
-
-    def check_authorization(method, path, params)
-      @authprovider.check_authorization(method, path, params)
+    def self.authprovider_class=(_)
+      # legacy auth is not supported, ignore
     end
   end
 end