puppet 6.0.5-x64-mingw32 → 8.8.1-x64-mingw32

data/lib/puppet/resource.rb

@@ -1,6 +1,8 @@
-require 'puppet'
-require 'puppet/util/tagging'
-require 'puppet/parameter'
+# frozen_string_literal: true
+
+require_relative '../puppet'
+require_relative '../puppet/util/tagging'
+require_relative '../puppet/parameter'
 
 # The simplest resource class.  Eventually it will function as the
 # base class for all resource-like behaviour.
@@ -11,7 +13,7 @@ class Puppet::Resource
   include Puppet::Util::PsychSupport
 
   include Enumerable
-  attr_accessor :file, :line, :catalog, :exported, :virtual, :strict
+  attr_accessor :file, :line, :catalog, :exported, :virtual, :strict, :kind
   attr_reader :type, :title, :parameters
 
   # @!attribute [rw] sensitive_parameters
@@ -22,33 +24,42 @@ class Puppet::Resource
   # @deprecated
   attr_accessor :validate_parameters
 
-  require 'puppet/indirector'
+  require_relative '../puppet/indirector'
   extend Puppet::Indirector
   indirects :resource, :terminus_class => :ral
 
   EMPTY_ARRAY = [].freeze
   EMPTY_HASH = {}.freeze
 
-  ATTRIBUTES = [:file, :line, :exported].freeze
-  TYPE_CLASS = 'Class'.freeze
-  TYPE_NODE  = 'Node'.freeze
-  TYPE_SITE  = 'Site'.freeze
+  ATTRIBUTES = [:file, :line, :exported, :kind].freeze
+  TYPE_CLASS = 'Class'
+  TYPE_NODE  = 'Node'
+
+  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
 
   def initialize_from_hash(data)
-    raise ArgumentError, _('No resource type provided in serialized data') unless type = data['type']
-    raise ArgumentError, _('No resource title provided in serialized data') unless title = data['title']
+    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)
 
-    if params = data['parameters']
+    params = data['parameters']
+    if params
       params = Puppet::Pops::Serialization::FromDataConverter.convert(params)
       @parameters = {}
       params.each { |param, value| self[param] = value }
@@ -56,13 +67,15 @@ class Puppet::Resource
       @parameters = EMPTY_HASH
     end
 
-    if sensitives = data['sensitive_parameters']
+    sensitives = data['sensitive_parameters']
+    if sensitives
       @sensitive_parameters = sensitives.map(&:to_sym)
     else
       @sensitive_parameters = EMPTY_ARRAY
     end
 
-    if tags = data['tags']
+    tags = data['tags']
+    if tags
       tag(*tags)
     end
 
@@ -103,7 +116,7 @@ class Puppet::Resource
     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
@@ -115,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?
@@ -131,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) }
@@ -146,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
@@ -171,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
 
@@ -189,18 +206,30 @@ class Puppet::Resource
     resource_type.is_a?(Puppet::CompilableResourceType)
   end
 
+  def self.to_kind(resource_type)
+    if resource_type == CLASS_STRING
+      CLASS_STRING
+    elsif resource_type.is_a?(Puppet::Resource::Type) && resource_type.type == :definition
+      DEFINED_TYPE_STRING
+    elsif resource_type.is_a?(Puppet::CompilableResourceType)
+      COMPILABLE_TYPE_STRING
+    else
+      UNKNOWN_TYPE_STRING
+    end
+  end
+
   # 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
 
@@ -209,7 +238,7 @@ class Puppet::Resource
   end
 
   def stage?
-    @is_stage ||= @type.to_s.downcase == "stage"
+    @is_stage ||= @type.to_s.casecmp("stage").zero?
   end
 
   # Construct a resource from data.
@@ -243,18 +272,20 @@ class Puppet::Resource
       src = type
       self.file = src.file
       self.line = src.line
+      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|
@@ -268,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
@@ -298,15 +329,21 @@ class Puppet::Resource
       # Set things like environment, strictness first.
       attributes.each do |attr, value|
         next if attr == :parameters
+
         send(attr.to_s + "=", value)
       end
 
+      if environment.is_a?(Puppet::Node::Environment) && environment != Puppet::Node::Environment::NONE
+        self.file = environment.externalize_path(attributes[:file])
+      end
+
       @type, @title = self.class.type_and_title(type, title)
 
       rt = resource_type
 
+      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 }
@@ -335,29 +372,6 @@ class Puppet::Resource
     catalog ? catalog.resource(to_s) : nil
   end
 
-  # A resource is an application component if it exports or consumes
-  # one or more capabilities, or if it requires a capability resource
-  def is_application_component?
-    return true if ! export.empty? || self[:consume]
-    # Array(self[:require]) does not work for Puppet::Resource instances
-    req = self[:require] || []
-    req = [ req ] unless req.is_a?(Array)
-    req.any? { |r| r.is_capability? }
-  end
-
-  # A resource is a capability (instance) if its underlying type is a
-  # capability type
-  def is_capability?
-    !resource_type.nil? && resource_type.is_capability?
-  end
-
-  # Returns the value of the 'export' metaparam as an Array
-  # @api private
-  def export
-    v = self[:export] || []
-    v.is_a?(Array) ? v : [ v ]
-  end
-
   # The resource's type implementation
   # @return [Puppet::Type, Puppet::Resource::Type]
   # @api private
@@ -372,12 +386,11 @@ class Puppet::Resource
     case type
     when TYPE_CLASS; environment.known_resource_types.hostclass(title == :main ? "" : title)
     when TYPE_NODE; environment.known_resource_types.node(title)
-    when TYPE_SITE; environment.known_resource_types.site(nil)
     else
       result = Puppet::Type.type(type)
-      if !result
+      unless result
         krt = environment.known_resource_types
-        result = krt.definition(type) || krt.application(type)
+        result = krt.definition(type)
       end
       result
     end
@@ -415,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
@@ -427,54 +440,89 @@ class Puppet::Resource
   end
 
   # Convert our resource to yaml for Hiera purposes.
+  #
+  # @deprecated Use {to_hiera_hash} instead.
   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
 
+    # rubocop:disable Lint/FormatParameterMismatch
     attributes = attr.collect { |k|
       v = parameters[k]
       "    %-#{attr_max}s: %s\n" % [k, Puppet::Parameter.format_value_for_display(v)]
     }.join
+    # rubocop:enable Lint/FormatParameterMismatch
 
-    "  %s:\n%s" % [self.title, attributes]
+    "  %s:\n%s" % [title, attributes]
+  end
+
+  # Convert our resource to a hiera hash suitable for serialization.
+  def to_hiera_hash
+    # to_data_hash converts to safe Data types, e.g. no symbols, unicode replacement character
+    h = to_data_hash
+
+    params = h['parameters'] || {}
+    value = params.delete('ensure')
+
+    res = {}
+    res['ensure'] = value if value
+    res.merge!(params.sort.to_h)
+
+    { 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
 
+    # rubocop:disable Lint/FormatParameterMismatch
     attributes = attr.collect { |k|
       v = parameters[k]
       "  %-#{attr_max}s => %s,\n" % [k, Puppet::Parameter.format_value_for_display(v)]
     }.join
+    # rubocop:enable Lint/FormatParameterMismatch
 
-    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
     ref
   end
 
-  # Convert our resource to a RAL resource instance.  Creates component
-  # instances for resource types that don't exist.
+  # 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
+  # must check its kind before deciding whether the catalog format is of an older
+  # version or not.
   def to_ral
-    typeklass = Puppet::Type.type(self.type) || Puppet::Type.type(:component)
+    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(type) || Puppet::Type.type(:component)
+    end
+
+    raise(Puppet::Error, "Resource type '#{type}' was not found") unless typeklass
+
     typeklass.new(self)
   end
 
@@ -482,49 +530,17 @@ 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
   end
   private :missing_arguments
 
-  # @deprecated Not used by Puppet
-  # @api private
-  def set_default_parameters(scope)
-    Puppet.deprecation_warning(_('The method Puppet::Resource.set_default_parameters is deprecated and will be removed in the next major release of Puppet.'))
-
-    return [] unless resource_type and resource_type.respond_to?(:arguments)
-
-    unless is_a?(Puppet::Parser::Resource)
-      fail Puppet::DevError, _("Cannot evaluate default parameters for %{resource} - not a parser resource") % { resource: self }
-    end
-
-    missing_arguments.collect do |param, default|
-      rtype = resource_type
-      if rtype.type == :hostclass
-        using_bound_value = false
-        catch(:no_such_key) do
-          bound_value = Puppet::Pops::Lookup.search_and_merge("#{rtype.name}::#{param}", Puppet::Pops::Lookup::Invocation.new(scope), nil)
-          # Assign bound value but don't let an undef trump a default expression
-          unless bound_value.nil? && !default.nil?
-            self[param.to_sym] = bound_value
-            using_bound_value = true
-          end
-        end
-      end
-      unless using_bound_value
-        next if default.nil?
-        self[param.to_sym] = default.safeevaluate(scope)
-      end
-      param
-    end.compact
-  end
-
   def copy_as_resource
     Puppet::Resource.new(self)
   end
@@ -533,36 +549,6 @@ class Puppet::Resource
     resource_type.valid_parameter?(name)
   end
 
-  # Verify that all required arguments are either present or
-  # have been provided with defaults.
-  # Must be called after 'set_default_parameters'.  We can't join the methods
-  # because Type#set_parameters needs specifically ordered behavior.
-  #
-  # @deprecated Not used by Puppet
-  # @api private
-  def validate_complete
-    Puppet.deprecation_warning(_('The method Puppet::Resource.validate_complete is deprecated and will be removed in the next major release of Puppet.'))
-
-    return unless resource_type and resource_type.respond_to?(:arguments)
-
-    resource_type.arguments.each do |param, default|
-      param = param.to_sym
-      fail Puppet::ParseError, _("Must pass %{param} to %{resource}") % { param: param, resource: self } unless parameters.include?(param)
-    end
-
-    # Perform optional type checking
-    arg_types = resource_type.argument_types
-    # Parameters is a map from name, to parameter, and the parameter again has name and value
-    parameters.each do |name, value|
-      next unless t = arg_types[name.to_s]  # untyped, and parameters are symbols here (aargh, strings in the type)
-      unless Puppet::Pops::Types::TypeCalculator.instance?(t, value.value)
-        inferred_type = Puppet::Pops::Types::TypeCalculator.infer_set(value.value)
-        actual = inferred_type.generalize()
-        fail Puppet::ParseError, _("Expected parameter '%{name}' of '%{value0}' to have type %{value1}, got %{value2}") % { name: name, value0: self, value1: t.to_s, value2: actual.to_s }
-      end
-    end
-  end
-
   def validate_parameter(name)
     raise Puppet::ParseError.new(_("no parameter named '%{name}'") % { name: name }, file, line) unless valid_parameter?(name)
   end
@@ -583,7 +569,9 @@ class Puppet::Resource
         delete(attribute)
       end
 
-      parameters_to_include = options[:parameters_to_include] || []
+      parameters_to_include = resource_type.parameters_to_include
+      parameters_to_include += options[:parameters_to_include] || []
+
       delete(attribute) unless properties.include?(attribute) || parameters_to_include.include?(attribute)
     end
     self
@@ -599,14 +587,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            ]
-    elsif argtitle.nil? && 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 }
+       argtitle =~ /^([^\[\]]+)\[(.+)\]$/m                  then [::Regexp.last_match(1), ::Regexp.last_match(2)]
+    elsif argtitle.nil? && argtype.is_a?(String) &&
+          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
@@ -614,6 +602,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
@@ -655,33 +644,34 @@ class Puppet::Resource
     h = {}
     type = resource_type
     if type.respond_to?(:title_patterns) && !type.title_patterns.nil?
-      type.title_patterns.each { |regexp, symbols_and_lambdas|
-        if captures = regexp.match(title.to_s)
-          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
+      type.title_patterns.each do |regexp, symbols_and_lambdas|
+        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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative '../puppet/http'
+require_relative '../puppet/facter_impl'
+require 'singleton'
+
+# Provides access to runtime implementations.
+#
+# @api private
+class Puppet::Runtime
+  include Singleton
+
+  def initialize
+    @runtime_services = {
+      http: proc do
+        klass = Puppet::Network::HttpPool.http_client_class
+        if klass == Puppet::Network::HTTP::Connection
+          Puppet::HTTP::Client.new
+        else
+          Puppet::HTTP::ExternalClient.new(klass)
+        end
+      end,
+      facter: proc { Puppet::FacterImpl.new }
+    }
+  end
+  private :initialize
+
+  # Loads all runtime implementations.
+  #
+  # @return Array[Symbol] the names of loaded implementations
+  # @api private
+  def load_services
+    @runtime_services.keys.each { |key| self[key] }
+  end
+
+  # Get a runtime implementation.
+  #
+  # @param name [Symbol] the name of the implementation
+  # @return [Object] the runtime implementation
+  # @api private
+  def [](name)
+    service = @runtime_services[name]
+    raise ArgumentError, "Unknown service #{name}" unless service
+
+    if service.is_a?(Proc)
+      @runtime_services[name] = service.call
+    else
+      service
+    end
+  end
+
+  # Register a runtime implementation.
+  #
+  # @param name [Symbol] the name of the implementation
+  # @param impl [Object] the runtime implementation
+  # @api private
+  def []=(name, impl)
+    @runtime_services[name] = impl
+  end
+
+  # Clears all implementations. This is used for testing.
+  #
+  # @api private
+  def clear
+    initialize
+  end
+end

data/lib/puppet/scheduler/job.rb

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