openvox 7.37.1 → 8.19.0

data/lib/puppet/resource/type_collection.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../puppet/parser/type_loader'
 require_relative '../../puppet/util/file_watcher'
 require_relative '../../puppet/util/warnings'
@@ -73,6 +74,7 @@ class Puppet::Resource::TypeCollection
   def handle_hostclass_merge(instance)
     # Only main class (named '') can be merged (for purpose of merging top-scopes).
     return instance unless instance.name == ''
+
     if instance.type == :hostclass && (other = @hostclasses[instance.name]) && other.type == :hostclass
       other.merge(instance)
       # throw is used to signal merge - avoids dupe checks and adding it to hostclasses
@@ -81,11 +83,11 @@ class Puppet::Resource::TypeCollection
   end
 
   # Replaces the known settings with a new instance (that must be named 'settings').
-  # This is primarily needed for testing purposes. Also see PUP-5954 as it makes 
+  # This is primarily needed for testing purposes. Also see PUP-5954 as it makes
   # it illegal to merge classes other than the '' (main) class. Prior to this change
   # settings where always merged rather than being defined from scratch for many testing scenarios
   # not having a complete side effect free setup for compilation.
-  # 
+  #
   def replace_settings(instance)
     @hostclasses['settings'] = instance
   end
@@ -166,7 +168,7 @@ class Puppet::Resource::TypeCollection
   end
 
   def version
-    if !defined?(@version)
+    unless defined?(@version)
       if environment.config_version.nil? || environment.config_version == ""
         @version = Time.now.to_i
       else
@@ -190,11 +192,11 @@ class Puppet::Resource::TypeCollection
     @environment.lock.synchronize do
       @lock.synchronize do
         # Name is always absolute, but may start with :: which must be removed
-        fqname = (name[0,2] == COLON_COLON ? name[2..-1] : name)
+        fqname = (name[0, 2] == COLON_COLON ? name[2..] : name)
 
         result = send(type, fqname)
         unless result
-          if @notfound[ fqname ] && Puppet[ :ignoremissingtypes ]
+          if @notfound[fqname] && Puppet[:ignoremissingtypes]
             # do not try to autoload if we already tried and it wasn't conclusive
             # as this is a time consuming operation. Warn the user.
             # Check first if debugging is on since the call to debug_once is expensive
@@ -204,7 +206,7 @@ class Puppet::Resource::TypeCollection
           else
             fqname = munge_name(fqname)
             result = loader.try_load_fqname(type, fqname)
-            @notfound[ fqname ] = result.nil?
+            @notfound[fqname] = result.nil?
           end
         end
         result
@@ -219,12 +221,14 @@ class Puppet::Resource::TypeCollection
   def dupe_check(instance, hash)
     dupe = hash[instance.name]
     return unless dupe
+
     message = yield dupe
     instance.fail Puppet::ParseError, message
   end
 
   def dupe_check_singleton(instance, set)
     return if set.empty?
+
     message = yield set[0]
     instance.fail Puppet::ParseError, message
   end

data/lib/puppet/resource.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../puppet'
 require_relative '../puppet/util/tagging'
 require_relative '../puppet/parameter'
@@ -30,19 +32,19 @@ class Puppet::Resource
   EMPTY_HASH = {}.freeze
 
   ATTRIBUTES = [:file, :line, :exported, :kind].freeze
-  TYPE_CLASS = 'Class'.freeze
-  TYPE_NODE  = 'Node'.freeze
+  TYPE_CLASS = 'Class'
+  TYPE_NODE  = 'Node'
 
-  CLASS_STRING = 'class'.freeze
-  DEFINED_TYPE_STRING = 'defined_type'.freeze
-  COMPILABLE_TYPE_STRING = 'compilable_type'.freeze
-  UNKNOWN_TYPE_STRING  = 'unknown'.freeze
+  CLASS_STRING = 'class'
+  DEFINED_TYPE_STRING = 'defined_type'
+  COMPILABLE_TYPE_STRING = 'compilable_type'
+  UNKNOWN_TYPE_STRING = 'unknown'
 
-  PCORE_TYPE_KEY = '__ptype'.freeze
-  VALUE_KEY = 'value'.freeze
+  PCORE_TYPE_KEY = '__ptype'
+  VALUE_KEY = 'value'
 
   def self.from_data_hash(data)
-    resource = self.allocate
+    resource = allocate
     resource.initialize_from_hash(data)
     resource
   end
@@ -50,8 +52,10 @@ class Puppet::Resource
   def initialize_from_hash(data)
     type = data['type']
     raise ArgumentError, _('No resource type provided in serialized data') unless type
+
     title = data['title']
     raise ArgumentError, _('No resource title provided in serialized data') unless title
+
     @type, @title = self.class.type_and_title(type, title)
 
     params = data['parameters']
@@ -108,11 +112,11 @@ class Puppet::Resource
     # To get stringified parameter values the flag :stringify_rich can be set
     # in the puppet context.
     #
-    stringify = Puppet.lookup(:stringify_rich) { false }
+    stringify = Puppet.lookup(:stringify_rich)
     converter = stringify ? Puppet::Pops::Serialization::ToStringifiedConverter.new : nil
 
     params = {}
-    self.to_hash.each_pair do |param, value|
+    to_hash.each_pair do |param, value|
       # Don't duplicate the title as the namevar
       unless param == namevar && value == title
         if stringify
@@ -124,14 +128,17 @@ class Puppet::Resource
     end
 
     unless params.empty?
-      data['parameters'] = Puppet::Pops::Serialization::ToDataConverter.convert(params, {
-        :rich_data => Puppet.lookup(:rich_data),
-        :symbol_as_string => true,
-        :local_reference => false,
-        :type_by_reference => true,
-        :message_prefix => ref,
-        :semantic => self
-      })
+      data['parameters'] =
+        Puppet::Pops::Serialization::ToDataConverter
+        .convert(params,
+                 {
+                   :rich_data => Puppet.lookup(:rich_data),
+                   :symbol_as_string => true,
+                   :local_reference => false,
+                   :type_by_reference => true,
+                   :message_prefix => ref,
+                   :semantic => self
+                 })
     end
 
     data['sensitive_parameters'] = sensitive_parameters.map(&:to_s) unless sensitive_parameters.empty?
@@ -140,7 +147,7 @@ class Puppet::Resource
 
   def self.value_to_json_data(value)
     if value.is_a?(Array)
-      value.map{|v| value_to_json_data(v) }
+      value.map { |v| value_to_json_data(v) }
     elsif value.is_a?(Hash)
       result = {}
       value.each_pair { |k, v| result[value_to_json_data(k)] = value_to_json_data(v) }
@@ -155,12 +162,12 @@ class Puppet::Resource
   end
 
   def yaml_property_munge(x)
-    self.value.to_json_data(x)
+    value.to_json_data(x)
   end
 
   # Proxy these methods to the parameters hash.  It's likely they'll
   # be overridden at some point, but this works for now.
-  %w{has_key? keys length delete empty? <<}.each do |method|
+  %w[has_key? keys length delete empty? <<].each do |method|
     define_method(method) do |*args|
       parameters.send(method, *args)
     end
@@ -180,9 +187,10 @@ class Puppet::Resource
   end
 
   def ==(other)
-    return false unless other.respond_to?(:title) and self.type == other.type and self.title == other.title
+    return false unless other.respond_to?(:title) and type == other.type and title == other.title
 
     return false unless to_hash == other.to_hash
+
     true
   end
 
@@ -212,16 +220,16 @@ class Puppet::Resource
 
   # Iterate over each param/value pair, as required for Enumerable.
   def each
-    parameters.each { |p,v| yield p, v }
+    parameters.each { |p, v| yield p, v }
   end
 
   def include?(parameter)
-    super || parameters.keys.include?( parameter_name(parameter) )
+    super || parameters.keys.include?(parameter_name(parameter))
   end
 
-  %w{exported virtual strict}.each do |m|
-    define_method(m+"?") do
-      self.send(m)
+  %w[exported virtual strict].each do |m|
+    define_method(m + "?") do
+      send(m)
     end
   end
 
@@ -267,16 +275,17 @@ class Puppet::Resource
       self.kind = src.kind
       self.exported = src.exported
       self.virtual = src.virtual
-      self.set_tags(src)
+      set_tags(src)
       self.environment = src.environment
       @rstype = src.resource_type
       @type = src.type
       @title = src.title
 
       src.to_hash.each do |p, v|
-        if v.is_a?(Puppet::Resource)
+        case v
+        when Puppet::Resource
           v = v.copy_as_resource
-        elsif v.is_a?(Array)
+        when Array
           # flatten resource references arrays
           v = v.flatten if v.flatten.find { |av| av.is_a?(Puppet::Resource) }
           v = v.collect do |av|
@@ -290,10 +299,10 @@ class Puppet::Resource
       @sensitive_parameters.replace(type.sensitive_parameters)
     else
       if type.is_a?(Hash)
-        #TRANSLATORS 'Puppet::Resource.new' should not be translated
+        # TRANSLATORS 'Puppet::Resource.new' should not be translated
         raise ArgumentError, _("Puppet::Resource.new does not take a hash as the first argument.") + ' ' +
-          _("Did you mean (%{type}, %{title}) ?") %
-              { type: (type[:type] || type["type"]).inspect, title: (type[:title] || type["title"]).inspect }
+                             _("Did you mean (%{type}, %{title}) ?") %
+                             { type: (type[:type] || type["type"]).inspect, title: (type[:title] || type["title"]).inspect }
       end
 
       # In order to avoid an expensive search of 'known_resource_types" and
@@ -320,6 +329,7 @@ class Puppet::Resource
       # Set things like environment, strictness first.
       attributes.each do |attr, value|
         next if attr == :parameters
+
         send(attr.to_s + "=", value)
       end
 
@@ -333,7 +343,7 @@ class Puppet::Resource
 
       self.kind = self.class.to_kind(rt) unless kind
       if strict? && rt.nil?
-        if self.class?
+        if class?
           raise ArgumentError, _("Could not find declared class %{title}") % { title: title }
         else
           raise ArgumentError, _("Invalid resource type %{type}") % { type: type }
@@ -378,7 +388,7 @@ class Puppet::Resource
     when TYPE_NODE; environment.known_resource_types.node(title)
     else
       result = Puppet::Type.type(type)
-      if !result
+      unless result
         krt = environment.known_resource_types
         result = krt.definition(type)
       end
@@ -418,11 +428,11 @@ class Puppet::Resource
 
   def uniqueness_key
     # Temporary kludge to deal with inconsistent use patterns; ensure we don't return nil for namevar/:name
-    h = self.to_hash
+    h = to_hash
     name = h[namevar] || h[:name] || self.name
     h[namevar] ||= name
     h[:name]   ||= name
-    h.values_at(*key_attributes.sort_by { |k| k.to_s })
+    h.values_at(*key_attributes.sort_by(&:to_s))
   end
 
   def key_attributes
@@ -435,10 +445,10 @@ class Puppet::Resource
   def to_hierayaml
     # Collect list of attributes to align => and move ensure first
     attr = parameters.keys
-    attr_max = attr.inject(0) { |max,k| k.to_s.length > max ? k.to_s.length : max }
+    attr_max = attr.inject(0) { |max, k| k.to_s.length > max ? k.to_s.length : max }
 
     attr.sort!
-    if attr.first != :ensure  && attr.include?(:ensure)
+    if attr.first != :ensure && attr.include?(:ensure)
       attr.delete(:ensure)
       attr.unshift(:ensure)
     end
@@ -448,7 +458,7 @@ class Puppet::Resource
       "    %-#{attr_max}s: %s\n" % [k, Puppet::Parameter.format_value_for_display(v)]
     }.join
 
-    "  %s:\n%s" % [self.title, attributes]
+    "  %s:\n%s" % [title, attributes]
   end
 
   # Convert our resource to a hiera hash suitable for serialization.
@@ -461,19 +471,19 @@ class Puppet::Resource
 
     res = {}
     res['ensure'] = value if value
-    res.merge!(Hash[params.sort])
+    res.merge!(params.sort.to_h)
 
-    return { h['title'] => res }
+    { h['title'] => res }
   end
 
   # Convert our resource to Puppet code.
   def to_manifest
     # Collect list of attributes to align => and move ensure first
     attr = parameters.keys
-    attr_max = attr.inject(0) { |max,k| k.to_s.length > max ? k.to_s.length : max }
+    attr_max = attr.inject(0) { |max, k| k.to_s.length > max ? k.to_s.length : max }
 
     attr.sort!
-    if attr.first != :ensure  && attr.include?(:ensure)
+    if attr.first != :ensure && attr.include?(:ensure)
       attr.delete(:ensure)
       attr.unshift(:ensure)
     end
@@ -483,8 +493,8 @@ class Puppet::Resource
       "  %-#{attr_max}s => %s,\n" % [k, Puppet::Parameter.format_value_for_display(v)]
     }.join
 
-    escaped = self.title.gsub(/'/,"\\\\'")
-    "%s { '%s':\n%s}" % [self.type.to_s.downcase, escaped, attributes]
+    escaped = title.gsub(/'/, "\\\\'")
+    "%s { '%s':\n%s}" % [type.to_s.downcase, escaped, attributes]
   end
 
   def to_ref
@@ -494,20 +504,20 @@ class Puppet::Resource
   # Convert our resource to a RAL resource instance. Creates component
   # instances for resource types that are not of a compilable_type kind. In case
   # the resource doesn’t exist and it’s compilable_type kind, raise an error.
-  # There are certain cases where a resource won't be in a catalog, such as 
-  # when we create a resource directly by using Puppet::Resource.new(...), so we 
+  # There are certain cases where a resource won't be in a catalog, such as
+  # when we create a resource directly by using Puppet::Resource.new(...), so we
   # must check its kind before deciding whether the catalog format is of an older
   # version or not.
   def to_ral
-    if self.kind == COMPILABLE_TYPE_STRING
-      typeklass = Puppet::Type.type(self.type)
-    elsif self.catalog && self.catalog.catalog_format >= 2
+    if kind == COMPILABLE_TYPE_STRING
+      typeklass = Puppet::Type.type(type)
+    elsif catalog && catalog.catalog_format >= 2
       typeklass = Puppet::Type.type(:component)
     else
-      typeklass =  Puppet::Type.type(self.type) || Puppet::Type.type(:component)
+      typeklass = Puppet::Type.type(type) || Puppet::Type.type(:component)
     end
 
-    raise(Puppet::Error, "Resource type '#{self.type}' was not found") unless typeklass
+    raise(Puppet::Error, "Resource type '#{type}' was not found") unless typeklass
 
     typeklass.new(self)
   end
@@ -516,11 +526,11 @@ class Puppet::Resource
     # this is potential namespace conflict
     # between the notion of an "indirector name"
     # and a "resource name"
-    [ type, title ].join('/')
+    [type, title].join('/')
   end
 
   def missing_arguments
-    resource_type.arguments.select do |param, default|
+    resource_type.arguments.select do |param, _default|
       the_param = parameters[param.to_sym]
       the_param.nil? || the_param.value.nil? || the_param.value == :undef
     end
@@ -573,15 +583,14 @@ class Puppet::Resource
     [type, title]
   end
 
-
   def self.extract_type_and_title(argtype, argtitle)
     if (argtype.nil? || argtype == :component || argtype == :whit) &&
-          argtitle =~ /^([^\[\]]+)\[(.+)\]$/m                  then [ $1,                 $2            ]
+       argtitle =~ /^([^\[\]]+)\[(.+)\]$/m                  then [::Regexp.last_match(1), ::Regexp.last_match(2)]
     elsif argtitle.nil? && argtype.is_a?(String) &&
-          argtype =~ /^([^\[\]]+)\[(.+)\]$/m                   then [ $1,                 $2            ]
-    elsif argtitle                                             then [ argtype,            argtitle      ]
-    elsif argtype.is_a?(Puppet::Type)                          then [ argtype.class.name, argtype.title ]
-    else  raise ArgumentError, _("No title provided and %{type} is not a valid resource reference") % { type: argtype.inspect }
+          argtype =~ /^([^\[\]]+)\[(.+)\]$/m                   then [::Regexp.last_match(1), ::Regexp.last_match(2)]
+    elsif argtitle                                             then [argtype,            argtitle]
+    elsif argtype.is_a?(Puppet::Type)                          then [argtype.class.name, argtype.title]
+    else  raise ArgumentError, _("No title provided and %{type} is not a valid resource reference") % { type: argtype.inspect } # rubocop:disable Lint/ElseLayout
     end
   end
   private_class_method :extract_type_and_title
@@ -589,6 +598,7 @@ class Puppet::Resource
   def self.munge_type_name(value)
     return :main if value == :main
     return TYPE_CLASS if value == '' || value.nil? || value.to_s.casecmp('component') == 0
+
     Puppet::Pops::Types::TypeFormatter.singleton.capitalize_segments(value.to_s)
   end
   private_class_method :munge_type_name
@@ -631,33 +641,33 @@ class Puppet::Resource
     type = resource_type
     if type.respond_to?(:title_patterns) && !type.title_patterns.nil?
       type.title_patterns.each do |regexp, symbols_and_lambdas|
-        captures = regexp.match(title.to_s)  
-        if captures
-          symbols_and_lambdas.zip(captures[1..-1]).each do |symbol_and_lambda,capture|
-            symbol, proc = symbol_and_lambda
-            # Many types pass "identity" as the proc; we might as well give
-            # them a shortcut to delivering that without the extra cost.
-            #
-            # Especially because the global type defines title_patterns and
-            # uses the identity patterns.
-            #
-            # This was worth about 8MB of memory allocation saved in my
-            # testing, so is worth the complexity for the API.
-            if proc then
-              h[symbol] = proc.call(capture)
-            else
-              h[symbol] = capture
-            end
+        captures = regexp.match(title.to_s)
+        next unless captures
+
+        symbols_and_lambdas.zip(captures[1..]).each do |symbol_and_lambda, capture|
+          symbol, proc = symbol_and_lambda
+          # Many types pass "identity" as the proc; we might as well give
+          # them a shortcut to delivering that without the extra cost.
+          #
+          # Especially because the global type defines title_patterns and
+          # uses the identity patterns.
+          #
+          # This was worth about 8MB of memory allocation saved in my
+          # testing, so is worth the complexity for the API.
+          if proc then
+            h[symbol] = proc.call(capture)
+          else
+            h[symbol] = capture
           end
-          return h
         end
+        return h
       end
       # If we've gotten this far, then none of the provided title patterns
       # matched. Since there's no way to determine the title then the
       # resource should fail here.
       raise Puppet::Error, _("No set of title patterns matched the title \"%{title}\".") % { title: title }
     else
-      return { :name => title.to_s }
+      { :name => title.to_s }
     end
   end
 end

data/lib/puppet/runtime.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../puppet/http'
 require_relative '../puppet/facter_impl'
 require 'singleton'

data/lib/puppet/scheduler/job.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet::Scheduler
   class Job
     attr_reader :run_interval

data/lib/puppet/scheduler/scheduler.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module Puppet::Scheduler
   class Scheduler
-    def initialize(timer=Puppet::Scheduler::Timer.new)
+    def initialize(timer = Puppet::Scheduler::Timer.new)
       @timer = timer
     end
 
     def run_loop(jobs)
       mark_start_times(jobs, @timer.now)
-      while not enabled(jobs).empty?
+      until enabled(jobs).empty?
         @timer.wait_for(min_interval_to_next_run_from(jobs, @timer.now))
         run_ready(jobs, @timer.now)
       end

data/lib/puppet/scheduler/splay_job.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Puppet::Scheduler
   class SplayJob < Job
-    attr_reader :splay
+    attr_reader :splay, :splay_limit
 
     def initialize(run_interval, splay_limit, &block)
-      @splay = calculate_splay(splay_limit)
+      @splay, @splay_limit = calculate_splay(splay_limit)
       super(run_interval, &block)
     end
 
@@ -23,10 +25,21 @@ module Puppet::Scheduler
       end
     end
 
+    # Recalculates splay.
+    #
+    # @param splay_limit [Integer] the maximum time (in seconds) to delay before an agent's first run.
+    # @return @splay [Integer] a random integer less than or equal to the splay limit that represents the seconds to
+    # delay before next agent run.
+    def splay_limit=(splay_limit)
+      if @splay_limit != splay_limit
+        @splay, @splay_limit = calculate_splay(splay_limit)
+      end
+    end
+
     private
 
     def calculate_splay(limit)
-      rand(limit + 1)
+      [rand(limit + 1), limit]
     end
   end
 end

data/lib/puppet/scheduler/timer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet::Scheduler
   class Timer
     def wait_for(seconds)

data/lib/puppet/scheduler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet::Scheduler
   require_relative 'scheduler/job'
   require_relative 'scheduler/splay_job'
@@ -6,7 +8,7 @@ module Puppet::Scheduler
 
   module_function
 
-  def create_job(interval, splay=false, splay_limit=0, &block)
+  def create_job(interval, splay = false, splay_limit = 0, &block)
     if splay
       Puppet::Scheduler::SplayJob.new(interval, splay_limit, &block)
     else

data/lib/puppet/settings/alias_setting.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Puppet::Settings::AliasSetting
   attr_reader :name, :alias_name
 
@@ -24,11 +26,9 @@ class Puppet::Settings::AliasSetting
   end
 
   def method_missing(method, *args)
-    begin
-      alias_for.send(method, *args)
-    rescue => e
-      Puppet.log_exception(self.class, e.message)
-    end
+    alias_for.send(method, *args)
+  rescue => e
+    Puppet.log_exception(self.class, e.message)
   end
 
   private

data/lib/puppet/settings/array_setting.rb

@@ -1,5 +1,6 @@
-class Puppet::Settings::ArraySetting < Puppet::Settings::BaseSetting
+# frozen_string_literal: true
 
+class Puppet::Settings::ArraySetting < Puppet::Settings::BaseSetting
   def type
     :array
   end

data/lib/puppet/settings/autosign_setting.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../puppet/settings/base_setting'
 
 # A specialization of the file setting to allow boolean values.
@@ -7,7 +9,6 @@ require_relative '../../puppet/settings/base_setting'
 #
 # @api private
 class Puppet::Settings::AutosignSetting < Puppet::Settings::FileSetting
-
   def munge(value)
     if ['true', true].include? value
       true