puppet 5.5.22 → 6.0.0

data/lib/puppet/util/feature.rb

@@ -3,40 +3,56 @@ require 'puppet'
 class Puppet::Util::Feature
   attr_reader :path
 
-  # Create a new feature test.  You have to pass the feature name,
-  # and it must be unique.  You can either provide a block that
-  # will get executed immediately to determine if the feature
-  # is present, or you can pass an option to determine it.
-  # Currently, the only supported option is 'libs' (must be
-  # passed as a symbol), which will make sure that each lib loads
-  # successfully.
-  def add(name, options = {})
+  # Create a new feature test. You have to pass the feature name, and it must be
+  # unique. You can pass a block to determine if the feature is present:
+  #
+  #     Puppet.features.add(:myfeature) do
+  #       # return true or false if feature is available
+  #       # return nil if feature may become available later
+  #     end
+  #
+  # The block should return true if the feature is available, false if it is
+  # not, or nil if the state is unknown. True and false values will be cached. A
+  # nil value will not be cached, and should be used if the feature may become
+  # true in the future.
+  #
+  # Features are often used to detect if a ruby library is installed. To support
+  # that common case, you can pass one or more ruby libraries, and the feature
+  # will be true if all of the libraries load successfully:
+  #
+  #     Puppet.features.add(:myfeature, libs: 'mylib')
+  #     Puppet.features.add(:myfeature, libs: ['mylib', 'myotherlib'])
+  #
+  # If the ruby library is not installed, then the failure is not cached, as
+  # it's assumed puppet may install the gem during catalog application.
+  #
+  # If a feature is defined using `:libs` and a block, then the block is
+  # used and the `:libs` are ignored.
+  #
+  # Puppet evaluates the feature test when the `Puppet.features.myfeature?`
+  # method is called. If the feature test was defined using a block and the
+  # block returns nil, then the feature test will be re-evaluated the next time
+  # `Puppet.features.myfeature?` is called.
+  #
+  # @param [Symbol] name The unique feature name
+  # @param [Hash<Symbol,Array<String>>] options The libraries to load
+  def add(name, options = {}, &block)
     method = name.to_s + "?"
     @results.delete(name)
 
-    if block_given?
-      begin
-        result = yield
-      rescue StandardError,ScriptError => detail
-        warn _("Failed to load feature test for %{name}: %{detail}") % { name: name, detail: detail }
-        result = false
-      end
-      @results[name] = result
-    end
-
     meta_def(method) do
       # we return a cached result if:
-      #  * if a block is given (and we just evaluated it above)
-      #  * if we already have a positive result
-      #  * if we've tested this feature before and it failed, but we're
-      #    configured to always cache
-      if block_given?     ||
-          @results[name]  ||
-          (@results.has_key?(name) && (!Puppet[:always_retry_plugins]))
-        @results[name]
+      #  * if we've tested this feature before
+      #  AND
+      #    * the result was true/false
+      #    OR
+      #    * we're configured to never retry
+      if @results.has_key?(name) &&
+         (!@results[name].nil? || !Puppet[:always_retry_plugins])
+        !!@results[name]
       else
-        @results[name] = test(name, options)
-        @results[name]
+        @results[name] = test(name, options, &block)
+        !!@results[name]
       end
     end
   end
@@ -49,14 +65,14 @@ class Puppet::Util::Feature
   end
 
   def load
-    @loader.loadall
+    @loader.loadall(Puppet.lookup(:current_environment))
   end
 
   def method_missing(method, *args)
     return super unless method.to_s =~ /\?$/
 
     feature = method.to_s.sub(/\?$/, '')
-    @loader.load(feature)
+    @loader.load(feature, Puppet.lookup(:current_environment))
 
     respond_to?(method) && self.send(method)
   end
@@ -64,16 +80,22 @@ class Puppet::Util::Feature
   # Actually test whether the feature is present.  We only want to test when
   # someone asks for the feature, so we don't unnecessarily load
   # files.
-  def test(name, options)
-    return true unless ary = options[:libs]
-    ary = [ary] unless ary.is_a?(Array)
-
-    ary.each do |lib|
-      return false unless load_library(lib, name)
+  def test(name, options, &block)
+    if block_given?
+      begin
+        result = yield
+      rescue StandardError,ScriptError => detail
+        warn _("Failed to load feature test for %{name}: %{detail}") % { name: name, detail: detail }
+        result = nil
+      end
+      @results[name] = result
+      result
+    elsif libs = options[:libs]
+      libs = [libs] unless libs.is_a?(Array)
+      libs.all? { |lib| load_library(lib, name) } ? true : nil
+    else
+      true
     end
-
-    # We loaded all of the required libraries
-    true
   end
 
   private
@@ -86,10 +108,10 @@ class Puppet::Util::Feature
 
     begin
       require lib
+      true
     rescue ScriptError => detail
       Puppet.debug _("Failed to load library '%{lib}' for feature '%{name}': %{detail}") % { lib: lib, name: name, detail: detail }
-      return false
+      false
     end
-    true
   end
 end

data/lib/puppet/util/fileparsing.rb

@@ -24,15 +24,12 @@
 # You could then call 'parser.to_line(hash)' on any of those hashes to generate
 # the text line again.
 
-require 'puppet/util/methodhelper'
-
 module Puppet::Util::FileParsing
   include Puppet::Util
   attr_writer :line_separator, :trailing_separator
 
   class FileRecord
     include Puppet::Util
-    include Puppet::Util::MethodHelper
     attr_accessor :absent, :joiner, :rts, :separator, :rollup, :name, :match, :block_eval
 
     attr_reader :fields, :optional, :type
@@ -48,11 +45,36 @@ module Puppet::Util::FileParsing
       end
     end
 
-    def initialize(type, options = {}, &block)
+    def initialize(type,
+                   absent: nil,
+                   block_eval: nil,
+                   fields: nil,
+                   joiner: nil,
+                   match: nil,
+                   optional: nil,
+                   post_parse: nil,
+                   pre_gen: nil,
+                   rollup: nil,
+                   rts: nil,
+                   separator: nil,
+                   to_line: nil,
+                   &block)
       @type = type.intern
       raise ArgumentError, _("Invalid record type %{record_type}") % { record_type: @type } unless [:record, :text].include?(@type)
 
-      set_options(options)
+      @absent = absent
+      @block_eval = block_eval
+      @joiner = joiner
+      @match = match
+      @rollup = rollup if rollup
+      @rts = rts
+      @separator = separator
+
+      self.fields = fields if fields
+      self.optional = optional if optional
+      self.post_parse = post_parse if post_parse
+      self.pre_gen = pre_gen if pre_gen
+      self.to_line = to_line if to_line
 
       if self.type == :record
         # Now set defaults.

data/lib/puppet/util/filetype.rb

@@ -166,12 +166,6 @@ class Puppet::Util::FileType
   end
 
   # Handle Linux-style cron tabs.
-  #
-  # TODO: We can possibly eliminate the "-u <username>" option in cmdbase
-  # by just running crontab under <username>'s uid (like we do for suntab
-  # and aixtab). It may be worth investigating this alternative
-  # implementation in the future. This way, we can refactor all three of
-  # our cron file types into a common crontab file type.
   newfiletype(:crontab) do
     def initialize(user)
       self.path = user
@@ -191,47 +185,21 @@ class Puppet::Util::FileType
 
     # Read a specific @path's cron tab.
     def read
-      unless Puppet::Util.uid(@path)
-        Puppet.debug _("The %{path} user does not exist. Treating their crontab file as empty in case Puppet creates them in the middle of the run.") % { path: @path }
-
-        return ""
-      end
-
-      Puppet::Util::Execution.execute("#{cmdbase} -l", failonfail: true, combine: true)
-    rescue => detail
-      case detail.to_s
-      when /no crontab for/
-        return ""
-      when /are not allowed to/
-        Puppet.debug _("The %{path} user is not authorized to use cron. Their crontab file is treated as empty in case Puppet authorizes them in the middle of the run (by, for example, modifying the cron.deny or cron.allow files).") % { path: @path }
-
-        return ""
-      else
-        raise FileReadError, _("Could not read crontab for %{path}: %{detail}") % { path: @path, detail: detail }, detail.backtrace
-      end
+      %x{#{cmdbase} -l 2>/dev/null}
     end
 
     # Remove a specific @path's cron tab.
     def remove
-      cmd = "#{cmdbase} -r"
       if %w{Darwin FreeBSD DragonFly}.include?(Facter.value("operatingsystem"))
-        cmd = "/bin/echo yes | #{cmd}"
+        %x{/bin/echo yes | #{cmdbase} -r 2>/dev/null}
+      else
+        %x{#{cmdbase} -r 2>/dev/null}
       end
-
-      Puppet::Util::Execution.execute(cmd, failonfail: true, combine: true)
     end
 
     # Overwrite a specific @path's cron tab; must be passed the @path name
     # and the text with which to create the cron tab.
-    #
-    # TODO: We should refactor this at some point to make it identical to the
-    # :aixtab and :suntab's write methods so that, at the very least, the pipe
-    # is not created and the crontab command's errors are not swallowed.
     def write(text)
-      unless Puppet::Util.uid(@path)
-        raise Puppet::Error, _("Cannot write the %{path} user's crontab: The user does not exist") % { path: @path }
-      end
-
       # this file is managed by the OS and should be using system encoding
       IO.popen("#{cmdbase()} -", "w", :encoding => Encoding.default_external) { |p|
         p.print text
@@ -256,21 +224,13 @@ class Puppet::Util::FileType
   newfiletype(:suntab) do
     # Read a specific @path's cron tab.
     def read
-      unless Puppet::Util.uid(@path)
-        Puppet.debug _("The %{path} user does not exist. Treating their crontab file as empty in case Puppet creates them in the middle of the run.") % { path: @path }
-
-        return ""
-      end
-
       Puppet::Util::Execution.execute(%w{crontab -l}, cronargs)
     rescue => detail
       case detail.to_s
       when /can't open your crontab/
         return ""
       when /you are not authorized to use cron/
-        Puppet.debug _("The %{path} user is not authorized to use cron. Their crontab file is treated as empty in case Puppet authorizes them in the middle of the run (by, for example, modifying the cron.deny or cron.allow files).") % { path: @path }
-
-        return ""
+        raise FileReadError, _("User %{path} not authorized to use cron") % { path: @path }, detail.backtrace
       else
         raise FileReadError, _("Could not read crontab for %{path}: %{detail}") % { path: @path, detail: detail }, detail.backtrace
       end
@@ -307,21 +267,13 @@ class Puppet::Util::FileType
   newfiletype(:aixtab) do
     # Read a specific @path's cron tab.
     def read
-      unless Puppet::Util.uid(@path)
-        Puppet.debug _("The %{path} user does not exist. Treating their crontab file as empty in case Puppet creates them in the middle of the run.") % { path: @path }
-
-        return ""
-      end
-
       Puppet::Util::Execution.execute(%w{crontab -l}, cronargs)
     rescue => detail
       case detail.to_s
-      when /open.*in.*directory/
-        return ""
-      when /not.*authorized.*cron/
-        Puppet.debug _("The %{path} user is not authorized to use cron. Their crontab file is treated as empty in case Puppet authorizes them in the middle of the run (by, for example, modifying the cron.deny or cron.allow files).") % { path: @path }
-
+      when /Cannot open a file in the .* directory/
         return ""
+      when /You are not authorized to use the cron command/
+        raise FileReadError, _("User %{path} not authorized to use cron") % { path: @path }, detail.backtrace
       else
         raise FileReadError, _("Could not read crontab for %{path}: %{detail}") % { path: @path, detail: detail }, detail.backtrace
       end

data/lib/puppet/util/http_proxy.rb

@@ -4,15 +4,13 @@ require 'puppet/network/http'
 
 module Puppet::Util::HttpProxy
   def self.proxy(uri)
-    if http_proxy_host && !no_proxy?(uri)
-      Net::HTTP.new(uri.host, uri.port, self.http_proxy_host, self.http_proxy_port, self.http_proxy_user, self.http_proxy_password)
+    if self.no_proxy?(uri)
+      proxy_class = Net::HTTP::Proxy(nil)
     else
-      http = Net::HTTP.new(uri.host, uri.port, nil, nil, nil, nil)
-      # Net::HTTP defaults the proxy port even though we said not to
-      # use one. Set it to nil so caller is not surprised
-      http.proxy_port = nil if http.respond_to?(:proxy_port=)
-      http
+      proxy_class = Net::HTTP::Proxy(self.http_proxy_host, self.http_proxy_port, self.http_proxy_user, self.http_proxy_password)
     end
+
+    return proxy_class.new(uri.host, uri.port)
   end
 
   def self.http_proxy_env
@@ -35,7 +33,7 @@ module Puppet::Util::HttpProxy
   #   .example.com
   # We'll accommodate both here.
   def self.no_proxy?(dest)
-    unless no_proxy = self.no_proxy
+    unless no_proxy_env = ENV["no_proxy"] || ENV["NO_PROXY"]
       return false
     end
 
@@ -47,10 +45,18 @@ module Puppet::Util::HttpProxy
       end
     end
 
-    no_proxy.split(/\s*,\s*/).each do |d|
+    no_proxy_env.split(/\s*,\s*/).each do |d|
       host, port = d.split(':')
       host = Regexp.escape(host).gsub('\*', '.*')
 
+      #If the host of this no_proxy value starts with '.', this entry is
+      #a domain level entry. Don't pin the regex to the beginning of the entry.
+      #If it does not start with a '.' then it is a host specific entry and
+      #should be matched to the destination starting at the beginning.
+      unless host =~ /^\\\./
+        host = "^#{host}"
+      end
+
       #If this no_proxy entry specifies a port, we want to match it against
       #the destination port.  Otherwise just match hosts.
       if port
@@ -121,20 +127,6 @@ module Puppet::Util::HttpProxy
     return Puppet.settings[:http_proxy_password]
   end
 
-  def self.no_proxy
-    no_proxy_env = ENV["no_proxy"] || ENV["NO_PROXY"]
-
-    if no_proxy_env
-      return no_proxy_env
-    end
-
-    if Puppet.settings[:no_proxy] == 'none'
-      return nil
-    end
-
-    return Puppet.settings[:no_proxy]
-  end
-
   # Return a Net::HTTP::Proxy object.
   #
   # This method optionally configures SSL correctly if the URI scheme is
@@ -186,11 +178,10 @@ module Puppet::Util::HttpProxy
 
       headers = { 'Accept' => '*/*', 'User-Agent' => Puppet[:http_user_agent] }
       if Puppet.features.zlib?
-        headers["Accept-Encoding"] = Puppet::Network::HTTP::Compression::ACCEPT_ENCODING
+        headers.merge!({"Accept-Encoding" => Puppet::Network::HTTP::Compression::ACCEPT_ENCODING})
       end
 
       response = proxy.send(:head, current_uri.path, headers)
-      Puppet.debug("HTTP HEAD request to #{current_uri} returned #{response.code} #{response.message}")
 
       if [301, 302, 307].include?(response.code.to_i)
         # handle the redirection
@@ -204,10 +195,10 @@ module Puppet::Util::HttpProxy
         else
           response = proxy.send(method, current_uri.path, headers)
         end
-
-        Puppet.debug("HTTP #{method.to_s.upcase} request to #{current_uri} returned #{response.code} #{response.message}")
       end
 
+      Puppet.debug("HTTP #{method.to_s.upcase} request to #{current_uri} returned #{response.code} #{response.message}")
+
       return response
     end
 

data/lib/puppet/util/instance_loader.rb

@@ -12,12 +12,12 @@ module Puppet::Util::InstanceLoader
   end
 
   # Define a new type of autoloading.
-  def instance_load(type, path, options = {})
+  def instance_load(type, path)
     @autoloaders ||= {}
     @instances ||= {}
     type = type.intern
     @instances[type] = {}
-    @autoloaders[type] = Puppet::Util::Autoload.new(self, path, options)
+    @autoloaders[type] = Puppet::Util::Autoload.new(self, path)
 
     # Now define our new simple methods
     unless respond_to?(type)
@@ -32,24 +32,6 @@ module Puppet::Util::InstanceLoader
     @instances[type].keys
   end
 
-  # Collect the docs for all of our instances.
-  def instance_docs(type)
-    docs = ""
-
-    # Load all instances.
-    instance_loader(type).loadall
-
-    # Use this method so they all get loaded
-    loaded_instances(type).sort_by(&:to_s).each do |name|
-      mod = self.loaded_instance(type, name)
-      docs << "#{name}\n#{"-" * name.to_s.length}\n"
-
-      docs << Puppet::Util::Docs.scrub(mod.doc) << "\n\n"
-    end
-
-    docs
-  end
-
   # Return the instance hash for our type.
   def instance_hash(type)
     @instances[type.intern]
@@ -65,7 +47,7 @@ module Puppet::Util::InstanceLoader
     name = name.intern
     return nil unless instances = instance_hash(type)
     unless instances.include? name
-      if instance_loader(type).load(name)
+      if instance_loader(type).load(name, Puppet.lookup(:current_environment))
         unless instances.include? name
           Puppet.warning(_("Loaded %{type} file for %{name} but %{type} was not defined") % { type: type, name: name })
           return nil