puppet 4.4.0 → 4.5.0

data/lib/puppet/provider/service/systemd.rb

@@ -1,7 +1,11 @@
 # Manage systemd services using systemctl
 
 Puppet::Type.type(:service).provide :systemd, :parent => :base do
-  desc "Manages `systemd` services using `systemctl`."
+  desc "Manages `systemd` services using `systemctl`.
+
+  Because `systemd` defaults to assuming the `.service` unit type, the suffix
+  may be omitted.  Other unit types (such as `.path`) may be managed by
+  providing the proper suffix."
 
   commands :systemctl => "systemctl"
 
@@ -32,10 +36,21 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
     return []
   end
 
+  # This helper ensures that the enable state cache is always reset
+  # after a systemctl enable operation. A particular service state is not guaranteed
+  # after such an operation, so the cache must be emptied to prevent inconsistencies
+  # in the provider's believed state of the service and the actual state.
+  # @param action [String,Symbol] One of 'enable', 'disable', 'mask' or 'unmask'
+  def systemctl_change_enable(action)
+    output = systemctl(action, @resource[:name])
+  rescue
+    raise Puppet::Error, "Could not #{action} #{self.name}: #{output}", $!.backtrace
+  ensure
+    @cached_enabled = nil
+  end
+
   def disable
-    output = systemctl(:disable, @resource[:name])
-  rescue Puppet::ExecutionFailure
-    raise Puppet::Error, "Could not disable #{self.name}: #{output}", $!.backtrace
+    systemctl_change_enable(:disable)
   end
 
   def get_start_link_count
@@ -49,38 +64,27 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
     Dir.glob("/etc/rc*.d/S??#{link_name}").length
   end
 
-  def enabled?
-    begin
-      systemctl_info = systemctl(
-         'show',
-         @resource[:name],
-         '--property', 'LoadState',
-         '--property', 'UnitFileState',
-         '--no-pager'
-      )
-
-      svc_info = Hash.new
-      systemctl_info.split.each do |svc|
-        entry_pair = svc.split('=')
-        svc_info[entry_pair.first.to_sym] = entry_pair.last
-      end
+  def cached_enabled?
+    return @cached_enabled if @cached_enabled
+    cmd = [command(:systemctl), 'is-enabled', @resource[:name]]
+    @cached_enabled = execute(cmd, :failonfail => false).strip
+  end
 
-      # The masked state is equivalent to the disabled state in terms of
-      # comparison so we only care to check if it is masked if we want to keep
-      # it masked.
-      #
-      # We only return :mask if we're trying to mask the service. This prevents
-      # flapping when simply trying to disable a masked service.
-      return :mask if (@resource[:enable] == :mask) && (svc_info[:LoadState] == 'masked')
-      return :true if svc_info[:UnitFileState] == 'enabled'
-      if Facter.value(:osfamily).downcase == 'debian'
-        ret = debian_enabled?(svc_info)
-        return ret if ret
-      end
-    rescue Puppet::ExecutionFailure
-      # The execution of the systemd command can fail for quite a few reasons.
-      # In all of these cases, the failure of the query indicates that the
-      # service is disabled and therefore we simply return :false.
+  def enabled?
+    output = cached_enabled?
+
+    # The masked state is equivalent to the disabled state in terms of
+    # comparison so we only care to check if it is masked if we want to keep
+    # it masked.
+    #
+    # We only return :mask if we're trying to mask the service. This prevents
+    # flapping when simply trying to disable a masked service.
+    return :mask if (@resource[:enable] == :mask) && (output == 'masked')
+    return :true if ['static', 'enabled'].include? output
+    return :false if ['disabled', 'linked', 'indirect', 'masked'].include? output
+    if (output.empty?) && (Facter.value(:osfamily).downcase == 'debian')
+      ret = debian_enabled?
+      return ret if ret
     end
 
     return :false
@@ -91,60 +95,38 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
   # have a Systemd unit file, we need to go through the old init script to determine
   # whether it is enabled or not. See PUP-5016 for more details.
   #
-  def debian_enabled?(svc_info)
-    # If UnitFileState == UnitFileState then we query the older way.
-    if svc_info[:UnitFileState] == 'UnitFileState'
-      system("/usr/sbin/invoke-rc.d", "--quiet", "--query", @resource[:name], "start")
-      if [104, 106].include?($CHILD_STATUS.exitstatus)
+  def debian_enabled?
+    system("/usr/sbin/invoke-rc.d", "--quiet", "--query", @resource[:name], "start")
+    if [104, 106].include?($CHILD_STATUS.exitstatus)
+      return :true
+    elsif [101, 105].include?($CHILD_STATUS.exitstatus)
+      # 101 is action not allowed, which means we have to do the check manually.
+      # 105 is unknown, which generally means the iniscript does not support query
+      # The debian policy states that the initscript should support methods of query
+      # For those that do not, peform the checks manually
+      # http://www.debian.org/doc/debian-policy/ch-opersys.html
+      if get_start_link_count >= 4
         return :true
-      elsif [101, 105].include?($CHILD_STATUS.exitstatus)
-        # 101 is action not allowed, which means we have to do the check manually.
-        # 105 is unknown, which generally means the iniscript does not support query
-        # The debian policy states that the initscript should support methods of query
-        # For those that do not, peform the checks manually
-        # http://www.debian.org/doc/debian-policy/ch-opersys.html
-        if get_start_link_count >= 4
-          return :true
-        else
-          return :false
-        end
       else
         return :false
       end
+    else
+      return :false
     end
   end
 
-  def status
-    begin
-      systemctl("is-active", @resource[:name])
-    rescue Puppet::ExecutionFailure
-      return :stopped
-    end
-    return :running
-  end
-
   def enable
     self.unmask
-    output = systemctl("enable", @resource[:name])
-  rescue Puppet::ExecutionFailure
-    raise Puppet::Error, "Could not enable #{self.name}: #{output}", $!.backtrace
+    systemctl_change_enable(:enable)
   end
 
   def mask
     self.disable
-    begin
-      output = systemctl("mask", @resource[:name])
-    rescue Puppet::ExecutionFailure
-      raise Puppet::Error, "Could not mask #{self.name}: #{output}", $!.backtrace
-    end
+    systemctl_change_enable(:mask)
   end
 
   def unmask
-    begin
-      output = systemctl("unmask", @resource[:name])
-    rescue Puppet::ExecutionFailure
-      raise Puppet::Error, "Could not unmask #{self.name}: #{output}", $!.backtrace
-    end
+    systemctl_change_enable(:unmask)
   end
 
   def restartcmd
@@ -159,5 +141,9 @@ Puppet::Type.type(:service).provide :systemd, :parent => :base do
   def stopcmd
     [command(:systemctl), "stop", @resource[:name]]
   end
+
+  def statuscmd
+    [command(:systemctl), "is-active", @resource[:name]]
+  end
 end
 

data/lib/puppet/provider/user/user_role_add.rb

@@ -167,10 +167,12 @@ Puppet::Type.type(:user).provide :user_role_add, :parent => :useradd, :source =>
   end
 
   def password
-    shadow_entry[1] if shadow_entry
+    return :absent unless shadow_entry
+    shadow_entry[1]
   end
 
   def password_min_age
+    return :absent unless shadow_entry
     shadow_entry[3].empty? ? -1 : shadow_entry[3]
   end
 

data/lib/puppet/reference/providers.rb

@@ -1,9 +1,8 @@
-# This doesn't get stored in trac, since it changes every time.
 providers = Puppet::Util::Reference.newreference :providers, :title => "Provider Suitability Report", :depth => 1, :dynamic => true, :doc => "Which providers are valid for this machine" do
   types = []
   Puppet::Type.loadall
   Puppet::Type.eachtype do |klass|
-    next unless klass.providers.length > 0
+    next unless klass && klass.providers.length > 0
     types << klass
   end
   types.sort! { |a,b| a.name.to_s <=> b.name.to_s }
@@ -91,7 +90,7 @@ providers = Puppet::Util::Reference.newreference :providers, :title => "Provider
 
     ret << markdown_header(type.name.to_s + "_", 2)
 
-    ret << "[#{type.name}](https://docs.puppetlabs.com/references/stable/type.html##{type.name})\n\n"
+    ret << "[#{type.name}](https://docs.puppetlabs.com/puppet/latest/reference/type.html##{type.name})\n\n"
     ret << option("Default provider", default)
     ret << doctable(headers, table_data)
 

data/lib/puppet/resource/catalog.rb

@@ -102,6 +102,9 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     end
   end
 
+  # Add `resources` to the catalog after `other`. WARNING: adding
+  # multiple resources will produce the reverse ordering, e.g. calling
+  # `add_resource_after(A, [B,C])` will result in `[A,C,B]`.
   def add_resource_after(other, *resources)
     resources.each do |resource|
       other_title_key = title_key_for_ref(other.ref)
@@ -111,7 +114,6 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     end
   end
 
-
   def add_resource(*resources)
     resources.each do |resource|
       add_one_resource(resource)
@@ -165,14 +167,15 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
 
   # Create an alias for a resource.
   def alias(resource, key)
-    resource.ref =~ /^(.+)\[/
+    ref = resource.ref
+    ref =~ /^(.+)\[/
     class_name = $1 || resource.class.name
 
     newref = [class_name, key].flatten
 
     if key.is_a? String
       ref_string = "#{class_name}[#{key}]"
-      return if ref_string == resource.ref
+      return if ref_string == ref
     end
 
     # LAK:NOTE It's important that we directly compare the references,
@@ -183,12 +186,12 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       return if existing == resource
       resource_declaration = " at #{resource.file}:#{resource.line}" if resource.file and resource.line
       existing_declaration = " at #{existing.file}:#{existing.line}" if existing.file and existing.line
-      msg = "Cannot alias #{resource.ref} to #{key.inspect}#{resource_declaration}; resource #{newref.inspect} already declared#{existing_declaration}"
+      msg = "Cannot alias #{ref} to #{key.inspect}#{resource_declaration}; resource #{newref.inspect} already declared#{existing_declaration}"
       raise ArgumentError, msg
     end
     @resource_table[newref] = resource
-    @aliases[resource.ref] ||= []
-    @aliases[resource.ref] << newref
+    @aliases[ref] ||= []
+    @aliases[ref] << newref
   end
 
   # Apply our catalog to the local host.
@@ -330,11 +333,12 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   # references to the resource instances.
   def remove_resource(*resources)
     resources.each do |resource|
-      title_key = title_key_for_ref(resource.ref)
+      ref = resource.ref
+      title_key = title_key_for_ref(ref)
       @resource_table.delete(title_key)
-      if aliases = @aliases[resource.ref]
+      if aliases = @aliases[ref]
         aliases.each { |res_alias| @resource_table.delete(res_alias) }
-        @aliases.delete(resource.ref)
+        @aliases.delete(ref)
       end
       remove_vertex!(resource) if vertex?(resource)
       @relationship_graph.remove_vertex!(resource) if @relationship_graph and @relationship_graph.vertex?(resource)
@@ -346,27 +350,27 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
 
   # Look a resource up by its reference (e.g., File[/etc/passwd]).
   def resource(type, title = nil)
-    # Always create a resource reference, so that it always
-    # canonicalizes how we are referring to them.
-    attributes = { :environment => environment_instance }
-    if title
-      res = Puppet::Resource.new(type, title, attributes)
-    else
-      # If they didn't provide a title, then we expect the first
-      # argument to be of the form 'Class[name]', which our
-      # Reference class canonicalizes for us.
-      res = Puppet::Resource.new(nil, type, attributes)
-    end
-    res.catalog = self
-    title_key      = [res.type, res.title.to_s]
-    uniqueness_key = [res.type, res.uniqueness_key].flatten
-    result = @resource_table[title_key] || @resource_table[uniqueness_key]
-    if ! result && res.resource_type && res.resource_type.is_capability?
-      # @todo lutter 2015-03-10: this assumes that it is legal to just
-      # mention a capability resource in code and have it automatically
-      # made available, even if the current component does not require it
-      result = Puppet::Resource::CapabilityFinder.find(environment, code_id, res)
-      add_resource(result) if result
+    type, title = Puppet::Resource.type_and_title(type, title)
+    title_key   = [type, title.to_s]
+    result = @resource_table[title_key]
+    if result.nil?
+      # an instance has to be created in order to construct the unique key used when
+      # searching for aliases.
+      unless @aliases.empty? && !Puppet[:app_management]
+        res = Puppet::Resource.new(type, title, { :environment => @environment_instance })
+        result = @resource_table[[type, res.uniqueness_key].flatten]
+      end
+
+      if result.nil? && Puppet[:app_management]
+        resource_type = res.resource_type
+        if resource_type && resource_type.is_capability?
+          # @todo lutter 2015-03-10: this assumes that it is legal to just
+          # mention a capability resource in code and have it automatically
+          # made available, even if the current component does not require it
+          result = Puppet::Resource::CapabilityFinder.find(environment, code_id, res)
+          add_resource(result) if result
+        end
+      end
     end
     result
   end

data/lib/puppet/resource/type_collection.rb

@@ -55,17 +55,16 @@ class Puppet::Resource::TypeCollection
   end
 
   def add(instance)
-    if instance.type == :hostclass and other = @hostclasses[instance.name] and other.type == :hostclass
-      other.merge(instance)
-      return other
-    end
-    method = "add_#{instance.type}"
-    send(method, instance)
-    instance.resource_type_collection = self
-    instance
+    # return a merged instance, or the given
+    result = catch(:merged) {
+      send("add_#{instance.type}", instance)
+      instance.resource_type_collection = self
+      instance
+    }
   end
 
   def add_hostclass(instance)
+    handle_hostclass_merge(instance)
     dupe_check(instance, @hostclasses) { |dupe| "Class '#{instance.name}' is already defined#{dupe.error_context}; cannot redefine" }
     dupe_check(instance, @definitions) { |dupe| "Definition '#{instance.name}' is already defined#{dupe.error_context}; cannot be redefined as a class" }
     dupe_check(instance, @applications) { |dupe| "Application '#{instance.name}' is already defined#{dupe.error_context}; cannot be redefined as a class" }
@@ -74,6 +73,22 @@ class Puppet::Resource::TypeCollection
     instance
   end
 
+  def handle_hostclass_merge(instance)
+    if instance.type == :hostclass && (other = @hostclasses[instance.name]) && other.type == :hostclass
+      unless instance.name == ''
+        case Puppet[:strict]
+        when :warning
+          Puppet.warning("Class '#{instance.name}' is already defined#{other.error_context}; cannot redefine at #{instance.file}:#{instance.line}") 
+        when :error
+          # returning means a merge (with throw) is not performed, that will then trigger a duplication check with error.
+          return instance
+        end
+      end
+      other.merge(instance)
+      throw :merged, other
+    end
+  end
+
   def hostclass(name)
     @hostclasses[munge_name(name)]
   end

data/lib/puppet/resource.rb

@@ -21,7 +21,10 @@ class Puppet::Resource
   extend Puppet::Indirector
   indirects :resource, :terminus_class => :ral
 
-  ATTRIBUTES = [:file, :line, :exported]
+  ATTRIBUTES = [:file, :line, :exported].freeze
+  TYPE_CLASS = 'Class'.freeze
+  TYPE_NODE  = 'Node'.freeze
+  TYPE_SITE  = 'Site'.freeze
 
   def self.from_data_hash(data)
     raise ArgumentError, "No resource type provided in serialized data" unless type = data['type']
@@ -162,7 +165,7 @@ class Puppet::Resource
   end
 
   def class?
-    @is_class ||= @type == "Class"
+    @is_class ||= @type == TYPE_CLASS
   end
 
   def stage?
@@ -222,6 +225,11 @@ class Puppet::Resource
         self[p] = v
       end
     else
+      if type.is_a?(Hash)
+        raise ArgumentError, "Puppet::Resource.new does not take a hash as the first argument. "+
+          "Did you mean (#{(type[:type] || type["type"]).inspect}, #{(type[:title] || type["title"]).inspect }) ?"
+      end
+
       environment = attributes[:environment]
       if type.is_a?(Class) && type < Puppet::Type
         # Set the resource type to avoid an expensive `known_resource_types`
@@ -238,22 +246,15 @@ class Puppet::Resource
         send(attr.to_s + "=", value)
       end
 
-      @type, @title = extract_type_and_title(type, title)
-
-      @type = munge_type_name(@type)
-
-      if self.class?
-        @title = :main if @title == ""
-        @title = munge_type_name(@title)
-      end
+      @type, @title = self.class.type_and_title(type, title)
 
       if params = attributes[:parameters]
         extract_parameters(params)
       end
 
-    	if resource_type && resource_type.respond_to?(:deprecate_params)
+      if resource_type && resource_type.respond_to?(:deprecate_params)
         resource_type.deprecate_params(title, attributes[:parameters])
-    	end
+      end
 
       tag(self.type)
       tag_if_valid(self.title)
@@ -304,10 +305,17 @@ class Puppet::Resource
   # @return [Puppet::Type, Puppet::Resource::Type]
   # @api private
   def resource_type
-    @rstype ||= case type
-    when "Class"; environment.known_resource_types.hostclass(title == :main ? "" : title)
-    when "Node"; environment.known_resource_types.node(title)
-    when "Site"; environment.known_resource_types.site(nil)
+    @rstype ||= self.class.resource_type(type, title, environment)
+  end
+
+  # The resource's type implementation
+  # @return [Puppet::Type, Puppet::Resource::Type]
+  # @api private
+  def self.resource_type(type, title, environment)
+    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
@@ -516,6 +524,35 @@ class Puppet::Resource
     self
   end
 
+  # @api private
+  def self.type_and_title(type, title)
+    type, title = extract_type_and_title(type, title)
+    type = munge_type_name(type)
+    if type == TYPE_CLASS
+      title = title == '' ? :main : munge_type_name(title)
+    end
+    [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 #{argtype.inspect} is not a valid resource reference"
+    end
+  end
+  private_class_method :extract_type_and_title
+
+  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
+
   private
 
   # Produce a canonical method name.
@@ -530,7 +567,7 @@ class Puppet::Resource
   # The namevar for our resource type. If the type doesn't exist,
   # always use :name.
   def namevar
-    if builtin_type? and t = resource_type and t.key_attributes.length == 1
+    if builtin_type? && !(t = resource_type).nil? && t.key_attributes.length == 1
       t.key_attributes.first
     else
       :name
@@ -544,26 +581,6 @@ class Puppet::Resource
     end
   end
 
-  def 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 ]
-    elsif argtype.is_a?(Hash)                                  then
-      raise ArgumentError, "Puppet::Resource.new does not take a hash as the first argument. "+
-        "Did you mean (#{(argtype[:type] || argtype["type"]).inspect}, #{(argtype[:title] || argtype["title"]).inspect }) ?"
-    else raise ArgumentError, "No title provided and #{argtype.inspect} is not a valid resource reference"
-    end
-  end
-
-  def munge_type_name(value)
-    return :main if value == :main
-    return "Class" if value == "" or value.nil? or value.to_s.downcase == "component"
-
-    value.to_s.split("::").collect { |s| s.capitalize }.join("::")
-  end
-
   def parse_title
     h = {}
     type = resource_type

data/lib/puppet/settings/base_setting.rb

@@ -95,10 +95,16 @@ class Puppet::Settings::BaseSetting
 
   def default(check_application_defaults_first = false)
     if @default.is_a? Proc
-      @default = @default.call
+      # Give unit tests a chance to reevaluate the call by removing the instance variable
+      unless instance_variable_defined?(:@evaluated_default)
+        @evaluated_default = @default.call
+      end
+      default_value = @evaluated_default
+    else
+      default_value = @default
     end
-    return @default unless check_application_defaults_first
-    return @settings.value(name, :application_defaults, true) || @default
+    return default_value unless check_application_defaults_first
+    return @settings.value(name, :application_defaults, true) || default_value
   end
 
   # Convert the object to a config statement.

data/lib/puppet/settings/symbolic_enum_setting.rb

@@ -0,0 +1,17 @@
+class Puppet::Settings::SymbolicEnumSetting < Puppet::Settings::BaseSetting
+  attr_accessor :values
+
+  def type
+    :symbolic_enum
+  end
+
+  def munge(value)
+    sym = value.to_sym
+    if values.include?(sym)
+      sym
+    else
+      raise Puppet::Settings::ValidationError,
+        "Invalid value '#{value}' for parameter #{@name}. Allowed values are '#{values.join("', '")}'"
+    end
+  end
+end

data/lib/puppet/settings.rb

@@ -14,6 +14,7 @@ class Puppet::Settings
   require 'puppet/settings/base_setting'
   require 'puppet/settings/string_setting'
   require 'puppet/settings/enum_setting'
+  require 'puppet/settings/symbolic_enum_setting'
   require 'puppet/settings/array_setting'
   require 'puppet/settings/file_setting'
   require 'puppet/settings/directory_setting'
@@ -561,7 +562,7 @@ class Puppet::Settings
           # will have associated hooks that it ends up being less work this
           # way overall.
           if setting.call_hook_on_initialize?
-            @hooks_to_call_on_application_initialization << setting
+            @hooks_to_call_on_application_initialization |= [ setting ]
           else
             setting.handle(ChainedValues.new(
               preferred_run_mode,
@@ -663,6 +664,7 @@ class Puppet::Settings
       :ttl        => TTLSetting,
       :array      => ArraySetting,
       :enum       => EnumSetting,
+      :symbolic_enum   => SymbolicEnumSetting,
       :priority   => PrioritySetting,
       :autosign   => AutosignSetting,
   }
@@ -906,7 +908,7 @@ class Puppet::Settings
         if tryconfig.call_hook_on_define?
           call << tryconfig
         elsif tryconfig.call_hook_on_initialize?
-          @hooks_to_call_on_application_initialization << tryconfig
+          @hooks_to_call_on_application_initialization |= [ tryconfig ]
         end
       end
 
@@ -1189,7 +1191,7 @@ Generated on #{Time.now}.
   # Read the file in.
   # @api private
   def read_file(file)
-    return Puppet::FileSystem.read(file)
+    return Puppet::FileSystem.read(file, :encoding => 'utf-8')
   end
 
   # Private method for internal test use only; allows to do a comprehensive clear of all settings between tests.

data/lib/puppet/ssl/oids.rb

@@ -69,7 +69,7 @@ module Puppet::SSL::Oids
     end
   end
 
-  # Parse and load custom OID mapping file that enables custom OIDs to be resolved
+  # Parse custom OID mapping file that enables custom OIDs to be resolved
   # into user-friendly names.
   #
   # @param custom_oid_file [String] File to obtain custom OIDs mapping from
@@ -84,7 +84,7 @@ module Puppet::SSL::Oids
   #  '1.3.6.1.4.1.34380.1.2.1.2':
   #    shortname: 'myothershortname'
   #    longname: 'Other Long name'
-  def self.load_custom_oid_file(custom_oid_file, map_key='oid_mapping')
+  def self.parse_custom_oid_file(custom_oid_file, map_key='oid_mapping')
     if File.exists?(custom_oid_file) && File.readable?(custom_oid_file)
       mapping = nil
       begin
@@ -110,6 +110,28 @@ module Puppet::SSL::Oids
         oid_defns << [oid, shortname, longname]
       end
 
+      oid_defns
+    end
+  end
+
+  # Load custom OID mapping file that enables custom OIDs to be resolved
+  # into user-friendly names.
+  #
+  # @param custom_oid_file [String] File to obtain custom OIDs mapping from
+  # @param map_key [String] Hash key in which custom OIDs mapping is stored
+  #
+  # @example Custom OID mapping file
+  # ---
+  # oid_mapping:
+  #  '1.3.6.1.4.1.34380.1.2.1.1':
+  #    shortname : 'myshortname'
+  #    longname  : 'Long name'
+  #  '1.3.6.1.4.1.34380.1.2.1.2':
+  #    shortname: 'myothershortname'
+  #    longname: 'Other Long name'
+  def self.load_custom_oid_file(custom_oid_file, map_key='oid_mapping')
+    oid_defns = parse_custom_oid_file(custom_oid_file, map_key)
+    unless oid_defns.nil?
       begin
         oid_defns.each do |oid_defn|
           OpenSSL::ASN1::ObjectId.register(*oid_defn)