puppet 6.18.0-x86-mingw32 → 6.21.1-x86-mingw32

data/lib/puppet/http/resolver/settings.rb

@@ -13,14 +13,14 @@ class Puppet::HTTP::Resolver::Settings < Puppet::HTTP::Resolver
   # @param [Puppet::HTTP::Session] session
   # @param [Symbol] name the name of the service to be resolved
   # @param [Puppet::SSL::SSLContext] ssl_context
-  # @param [Proc] error_handler (nil) optional callback for each error
-  #   encountered while resolving a route.
+  # @param [Proc] canceled_handler (nil) optional callback allowing a resolver
+  #   to cancel resolution.
   #
   # @return [Puppet::HTTP::Service] if the service successfully connects,
   #   return it. Otherwise, return nil.
   #
-  def resolve(session, name, ssl_context: nil, error_handler: nil)
+  def resolve(session, name, ssl_context: nil, canceled_handler: nil)
     service = Puppet::HTTP::Service.create_service(@client, session, name)
-    check_connection?(session, service, ssl_context: ssl_context, error_handler: error_handler) ? service : nil
+    check_connection?(session, service, ssl_context: ssl_context) ? service : nil
   end
 end

data/lib/puppet/http/resolver/srv.rb

@@ -25,21 +25,21 @@ class Puppet::HTTP::Resolver::SRV < Puppet::HTTP::Resolver
   # @param [Puppet::HTTP::Session] session
   # @param [Symbol] name the service being resolved
   # @param [Puppet::SSL::SSLContext] ssl_context
-  # @param [Proc] error_handler (nil) optional callback for each error
-  #   encountered while resolving a route.
+  # @param [Proc] canceled_handler (nil) optional callback allowing a resolver
+  #   to cancel resolution.
   #
   # @return [Puppet::HTTP::Service] if an available service is found, return
   #   it. Return nil otherwise.
   #
-  def resolve(session, name, ssl_context: nil, error_handler: nil)
+  def resolve(session, name, ssl_context: nil, canceled_handler: nil)
     # Here we pass our HTTP service name as the DNS SRV service name
     # This is fine for :ca, but note that :puppet and :file are handled
     # specially in `each_srv_record`.
     @delegate.each_srv_record(@srv_domain, name) do |server, port|
       service = Puppet::HTTP::Service.create_service(@client, session, name, server, port)
-      return service if check_connection?(session, service, ssl_context: ssl_context, error_handler: error_handler)
+      return service if check_connection?(session, service, ssl_context: ssl_context)
     end
 
-    return nil
+    nil
   end
 end

data/lib/puppet/http/service.rb

@@ -10,7 +10,7 @@ class Puppet::HTTP::Service
 
   # @api private
   # @return [Array<Symbol>] available services
-  SERVICE_NAMES = [:ca, :fileserver, :puppet, :report].freeze
+  SERVICE_NAMES = [:ca, :fileserver, :puppet, :puppetserver, :report].freeze
 
   # @api private
   # @return [Array<Symbol>] format types that are unsupported
@@ -43,6 +43,8 @@ class Puppet::HTTP::Service
       Puppet::HTTP::Service::FileServer.new(client, session, server, port)
     when :puppet
       ::Puppet::HTTP::Service::Compiler.new(client, session, server, port)
+    when :puppetserver
+      ::Puppet::HTTP::Service::Puppetserver.new(client, session, server, port)
     when :report
       Puppet::HTTP::Service::Report.new(client, session, server, port)
     else

data/lib/puppet/http/service/compiler.rb

@@ -22,7 +22,7 @@ class Puppet::HTTP::Service::Compiler < Puppet::HTTP::Service
   #   create the service.
   #
   def initialize(client, session, server, port)
-    url = build_url(API, server || Puppet[:server], port || Puppet[:masterport])
+    url = build_url(API, server || Puppet[:server], port || Puppet[:serverport])
     super(client, session, url)
   end
 

data/lib/puppet/http/service/file_server.rb

@@ -27,7 +27,7 @@ class Puppet::HTTP::Service::FileServer < Puppet::HTTP::Service
   #   create the service.
   #
   def initialize(client, session, server, port)
-    url = build_url(API, server || Puppet[:server], port || Puppet[:masterport])
+    url = build_url(API, server || Puppet[:server], port || Puppet[:serverport])
     super(client, session, url)
   end
 

data/lib/puppet/http/service/puppetserver.rb

@@ -0,0 +1,39 @@
+# The puppetserver service.
+#
+# @api private
+#
+class Puppet::HTTP::Service::Puppetserver < Puppet::HTTP::Service
+  # @param [Puppet::HTTP::Client] client
+  # @param [Puppet::HTTP::Session] session
+  # @param [String] server If an explicit server is given,
+  #   create a service using that server. If server is nil, the default value
+  #   is used to create the service.
+  # @param [Integer] port If an explicit port is given, create
+  #   a service using that port. If port is nil, the default value is used to
+  #   create the service.
+  # @api private
+  #
+  def initialize(client, session, server, port)
+    url = build_url('', server || Puppet[:server], port || Puppet[:serverport])
+    super(client, session, url)
+  end
+
+  # Request the puppetserver's simple status
+  #
+  # @param [Puppet::SSL::SSLContext] ssl_context to use when establishing
+  # the connection.
+  # @return Puppet::HTTP::Response The HTTP response
+  # @api private
+  #
+  def get_simple_status(ssl_context: nil)
+    response = @client.get(
+      with_base_url("/status/v1/simple/master"),
+      headers: add_puppet_headers({}),
+      options: {ssl_context: ssl_context}
+    )
+
+    process_response(response)
+
+    [response, response.body.to_s]
+  end
+end

data/lib/puppet/http/session.rb

@@ -64,20 +64,21 @@ class Puppet::HTTP::Session
     cached = @resolved_services[name]
     return cached if cached
 
-    resolution_exceptions = []
-    error_handler = proc { |e| resolution_exceptions << e }
+    canceled = false
+    canceled_handler  = lambda { |cancel| canceled = cancel }
 
     @resolvers.each do |resolver|
       Puppet.debug("Resolving service '#{name}' using #{resolver.class}")
-      service = resolver.resolve(self, name, ssl_context: ssl_context, error_handler: error_handler)
+      service = resolver.resolve(self, name, ssl_context: ssl_context, canceled_handler: canceled_handler)
       if service
         @resolved_services[name] = service
         Puppet.debug("Resolved service '#{name}' to #{service.url}")
         return service
+      elsif canceled
+        break
       end
     end
 
-    resolution_exceptions.each { |e| Puppet.log_exception(e) }
     raise Puppet::HTTP::RouteError, "No more routes to #{name}"
   end
 

data/lib/puppet/indirector/catalog/compiler.rb

@@ -75,7 +75,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
 
   # Is our compiler part of a network, or are we just local?
   def networked?
-    Puppet.run_mode.master?
+    Puppet.run_mode.server?
   end
 
   private

data/lib/puppet/indirector/fact_search.rb

@@ -0,0 +1,60 @@
+# module containing common methods used by json and yaml facts indirection terminus
+module Puppet::Indirector::FactSearch
+  def node_matches?(facts, options)
+    options.each do |key, value|
+      type, name, operator = key.to_s.split(".")
+      operator ||= 'eq'
+
+      return false unless node_matches_option?(type, name, operator, value, facts)
+    end
+    return true
+  end
+
+  def node_matches_option?(type, name, operator, value, facts)
+    case type
+    when "meta"
+      case name
+      when "timestamp"
+        compare_timestamp(operator, facts.timestamp, Time.parse(value))
+      end
+    when "facts"
+      compare_facts(operator, facts.values[name], value)
+    end
+  end
+
+  def compare_facts(operator, value1, value2)
+    return false unless value1
+
+    case operator
+    when "eq"
+      value1.to_s == value2.to_s
+    when "le"
+      value1.to_f <= value2.to_f
+    when "ge"
+      value1.to_f >= value2.to_f
+    when "lt"
+      value1.to_f < value2.to_f
+    when "gt"
+      value1.to_f > value2.to_f
+    when "ne"
+      value1.to_s != value2.to_s
+    end
+  end
+
+  def compare_timestamp(operator, value1, value2)
+    case operator
+    when "eq"
+      value1 == value2
+    when "le"
+      value1 <= value2
+    when "ge"
+      value1 >= value2
+    when "lt"
+      value1 < value2
+    when "gt"
+      value1 > value2
+    when "ne"
+      value1 != value2
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'puppet/node/facts'
+require 'puppet/indirector/json'
+require 'puppet/indirector/fact_search'
+
+class Puppet::Node::Facts::Json < Puppet::Indirector::JSON
+  desc "Store client facts as flat files, serialized using JSON, or
+    return deserialized facts from disk."
+
+  include Puppet::Indirector::FactSearch
+  
+  def search(request)
+    node_names = []
+    Dir.glob(json_dir_path).each do |file|
+      facts = load_json_from_file(file, '')
+      if facts && node_matches?(facts, request.options)
+        node_names << facts.name
+      end
+    end
+    node_names
+  end
+
+  private
+
+  def json_dir_path
+    self.path("*")
+  end
+end

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

@@ -1,10 +1,13 @@
 require 'puppet/node/facts'
 require 'puppet/indirector/yaml'
+require 'puppet/indirector/fact_search'
 
 class Puppet::Node::Facts::Yaml < Puppet::Indirector::Yaml
   desc "Store client facts as flat files, serialized using YAML, or
     return deserialized facts from disk."
 
+  include Puppet::Indirector::FactSearch
+
   def search(request)
     node_names = []
     Dir.glob(yaml_dir_path).each do |file|
@@ -20,65 +23,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
-
-  def node_matches?(facts, options)
-    options.each do |key, value|
-      type, name, operator = key.to_s.split(".")
-      operator ||= 'eq'
-
-      return false unless node_matches_option?(type, name, operator, value, facts)
-    end
-    return true
-  end
-
-  def node_matches_option?(type, name, operator, value, facts)
-    case type
-    when "meta"
-      case name
-      when "timestamp"
-        compare_timestamp(operator, facts.timestamp, Time.parse(value))
-      end
-    when "facts"
-      compare_facts(operator, facts.values[name], value)
-    end
-  end
-
-  def compare_facts(operator, value1, value2)
-    return false unless value1
-
-    case operator
-    when "eq"
-      value1.to_s == value2.to_s
-    when "le"
-      value1.to_f <= value2.to_f
-    when "ge"
-      value1.to_f >= value2.to_f
-    when "lt"
-      value1.to_f < value2.to_f
-    when "gt"
-      value1.to_f > value2.to_f
-    when "ne"
-      value1.to_s != value2.to_s
-    end
-  end
-
-  def compare_timestamp(operator, value1, value2)
-    case operator
-    when "eq"
-      value1 == value2
-    when "le"
-      value1 <= value2
-    when "ge"
-      value1 >= value2
-    when "lt"
-      value1 < value2
-    when "gt"
-      value1 > value2
-    when "ne"
-      value1 != value2
-    end
-  end
 end

data/lib/puppet/indirector/json.rb

@@ -41,12 +41,16 @@ class Puppet::Indirector::JSON < Puppet::Indirector::Terminus
       raise ArgumentError, _("invalid key")
     end
 
-    base = Puppet.run_mode.master? ? Puppet[:server_datadir] : Puppet[:client_datadir]
+    base = data_dir
     File.join(base, self.class.indirection_name.to_s, name.to_s + ext)
   end
 
   private
 
+  def data_dir()
+    Puppet.run_mode.server? ? Puppet[:server_datadir] : Puppet[:client_datadir]
+  end
+
   def load_json_from_file(file, key)
     json = nil
 

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

@@ -0,0 +1,8 @@
+require 'puppet/node'
+require 'puppet/indirector/json'
+
+class Puppet::Node::Json < Puppet::Indirector::JSON
+  desc "Store node information as flat files, serialized using JSON,
+    or deserialize stored JSON nodes."
+
+end

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

@@ -0,0 +1,34 @@
+require 'puppet/transaction/report'
+require 'puppet/indirector/json'
+
+class Puppet::Transaction::Report::Json < Puppet::Indirector::JSON
+  include Puppet::Util::SymbolicFileMode
+
+  desc "Store last report as a flat file, serialized using JSON."
+
+  # Force report to be saved there
+  def path(name,ext='.json')
+    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 JSON.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

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/module_tool/applications/installer.rb

@@ -131,8 +131,54 @@ module Puppet::ModuleTool
           begin
             Puppet.info _("Resolving dependencies ...")
             releases = SemanticPuppet::Dependency.resolve(graph)
-          rescue SemanticPuppet::Dependency::UnsatisfiableGraph
-            raise NoVersionsSatisfyError, results.merge(:requested_name => name)
+          rescue SemanticPuppet::Dependency::UnsatisfiableGraph => e
+            unsatisfied = nil
+
+            if e.respond_to?(: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
+                unsatisfied_range = graph.dependencies[name].max.constraints[e.unsatisfied].first[1]
+                constraints[e.unsatisfied] = unsatisfied_range
+              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
+              }
+            end
+
+            raise NoVersionsSatisfyError, results.merge(
+                    :requested_name => name,
+                    :requested_version => options[:version] || graph.dependencies[name].max.version.to_s,
+                    :unsatisfied => unsatisfied
+            )
           end
 
           unless forced?