puppet 5.0.0 → 6.0.0

data/lib/puppet/interface/option_builder.rb

@@ -40,12 +40,17 @@ class Puppet::Interface::OptionBuilder
   # @api public
   # @dsl Faces
   def before_action(&block)
-    block or raise ArgumentError, "#{@option} before_action requires a block"
+    unless block
+      #TRANSLATORS 'before_action' is a method name and should not be translated
+      raise ArgumentError, _("%{option} before_action requires a block") % { option: @option }
+    end
     if @option.before_action
-      raise ArgumentError, "#{@option} already has a before_action set"
+      #TRANSLATORS 'before_action' is a method name and should not be translated
+      raise ArgumentError, _("%{option} already has a before_action set") % { option: @option }
     end
     unless block.arity == 3 then
-      raise ArgumentError, "before_action takes three arguments, action, args, and options"
+      #TRANSLATORS 'before_action' is a method name and should not be translated
+      raise ArgumentError, _("before_action takes three arguments, action, args, and options")
     end
     @option.before_action = block
   end
@@ -55,12 +60,17 @@ class Puppet::Interface::OptionBuilder
   # @api public
   # @dsl Faces
   def after_action(&block)
-    block or raise ArgumentError, "#{@option} after_action requires a block"
+    unless block
+      #TRANSLATORS 'after_action' is a method name and should not be translated
+      raise ArgumentError, _("%{option} after_action requires a block") % { option: @option }
+    end
     if @option.after_action
-      raise ArgumentError, "#{@option} already has an after_action set"
+      #TRANSLATORS 'after_action' is a method name and should not be translated
+      raise ArgumentError, _("%{option} already has an after_action set") % { option: @option }
     end
     unless block.arity == 3 then
-      raise ArgumentError, "after_action takes three arguments, action, args, and options"
+      #TRANSLATORS 'after_action' is a method name and should not be translated
+      raise ArgumentError, _("after_action takes three arguments, action, args, and options")
     end
     @option.after_action = block
   end
@@ -79,12 +89,16 @@ class Puppet::Interface::OptionBuilder
   # @api public
   # @dsl Faces
   def default_to(&block)
-    block or raise ArgumentError, "#{@option} default_to requires a block"
+    unless block
+      #TRANSLATORS 'default_to' is a method name and should not be translated
+      raise ArgumentError, _("%{option} default_to requires a block") % { option: @option }
+    end
     if @option.has_default?
-      raise ArgumentError, "#{@option} already has a default value"
+      raise ArgumentError, _("%{option} already has a default value") % { option: @option }
     end
     unless block.arity == 0
-      raise ArgumentError, "#{@option} default_to block should not take any arguments"
+      #TRANSLATORS 'default_to' is a method name and should not be translated
+      raise ArgumentError, _("%{option} default_to block should not take any arguments") % { option: @option }
     end
     @option.default = block
   end

data/lib/puppet/interface/option_manager.rb

@@ -9,7 +9,10 @@ module Puppet::Interface::OptionManager
   def display_global_options(*args)
     @display_global_options ||= []
     [args].flatten.each do |refopt|
-      raise ArgumentError, "Global option #{refopt} does not exist in Puppet.settings" unless Puppet.settings.include? refopt
+      unless Puppet.settings.include?(refopt)
+        #TRANSLATORS 'Puppet.settings' references to the Puppet settings options and should not be translated
+        raise ArgumentError, _("Global option %{option} does not exist in Puppet.settings") % { option: refopt }
+      end
       @display_global_options << refopt if refopt
     end
     @display_global_options.uniq!
@@ -23,7 +26,7 @@ module Puppet::Interface::OptionManager
 
   # @api private
   def walk_inheritance_tree(start, sym)
-    result = (start ||= [])
+    result = (start || [])
     if self.is_a?(Class) and superclass.respond_to?(sym)
       result = superclass.send(sym) + result
     elsif self.class.respond_to?(sym)
@@ -51,13 +54,15 @@ module Puppet::Interface::OptionManager
 
     option.aliases.each do |name|
       if conflict = get_option(name) then
-        raise ArgumentError, "Option #{option} conflicts with existing option #{conflict}"
+        raise ArgumentError, _("Option %{option} conflicts with existing option %{conflict}") %
+            { option: option, conflict: conflict }
       end
 
       actions.each do |action|
         action = get_action(action)
         if conflict = action.get_option(name) then
-          raise ArgumentError, "Option #{option} conflicts with existing option #{conflict} on #{action}"
+          raise ArgumentError, _("Option %{option} conflicts with existing option %{conflict} on %{action}") %
+              { option: option, conflict: conflict, action: action }
         end
       end
     end

data/lib/puppet/interface.rb

@@ -149,7 +149,7 @@ class Puppet::Interface
   # @api private
   def initialize(name, version, &block)
     unless SemanticPuppet::Version.valid?(version)
-      raise ArgumentError, "Cannot create face #{name.inspect} with invalid version number '#{version}'!"
+      raise ArgumentError, _("Cannot create face %{name} with invalid version number '%{version}'!") % { name: name.inspect, version: version }
     end
 
     @name    = Puppet::Interface::FaceCollection.underscorize(name)
@@ -170,7 +170,7 @@ class Puppet::Interface
   # @return [void]
   # @api private
   def load_actions
-    loader.loadall
+    loader.loadall(Puppet.lookup(:current_environment))
   end
 
   # Returns a string representation with the face's name and version
@@ -178,6 +178,7 @@ class Puppet::Interface
   def to_s
     "Puppet::Face[#{name.inspect}, #{version.inspect}]"
   end
+  alias_method :inspect, :to_s
 
   # @return [void]
   def deprecate

data/lib/puppet/loaders.rb

@@ -13,12 +13,15 @@ module Puppet
       require 'puppet/pops/loader/static_loader'
       require 'puppet/pops/loader/runtime3_type_loader'
       require 'puppet/pops/loader/ruby_function_instantiator'
+      require 'puppet/pops/loader/ruby_legacy_function_instantiator'
+      require 'puppet/pops/loader/ruby_data_type_instantiator'
       require 'puppet/pops/loader/puppet_function_instantiator'
       require 'puppet/pops/loader/type_definition_instantiator'
       require 'puppet/pops/loader/puppet_resource_type_impl_instantiator'
       require 'puppet/pops/loader/loader_paths'
       require 'puppet/pops/loader/simple_environment_loader'
       require 'puppet/pops/loader/predefined_loader'
+      require 'puppet/pops/loader/puppet_plan_instantiator'
     end
   end
 

data/lib/puppet/metatype/manager.rb

@@ -50,7 +50,7 @@ module Manager
   # @return [void]
   #
   def loadall
-    typeloader.loadall
+    typeloader.loadall(Puppet.lookup(:current_environment))
   end
 
   # Defines a new type or redefines an existing type with the given name.
@@ -72,7 +72,9 @@ module Manager
   def newtype(name, options = {}, &block)
     # Handle backward compatibility
     unless options.is_a?(Hash)
-      Puppet.warning "Puppet::Type.newtype(#{name}) now expects a hash as the second argument, not #{options.inspect}"
+      #TRANSLATORS 'Puppet::Type.newtype' should not be translated
+      Puppet.warning(_("Puppet::Type.newtype(%{name}) now expects a hash as the second argument, not %{argument}") %
+                         { name: name, argument: options.inspect})
     end
 
     # First make sure we don't have a method sitting around
@@ -91,8 +93,6 @@ module Manager
       end
     end
 
-    options = symbolize_options(options)
-
     # Then create the class.
 
     klass = genclass(
@@ -107,7 +107,8 @@ module Manager
     # Now define a "new<type>" method for convenience.
     if self.respond_to? newmethod
       # Refuse to overwrite existing methods like 'newparam' or 'newtype'.
-      Puppet.warning "'new#{name.to_s}' method already exists; skipping"
+      #TRANSLATORS 'new%{method}' will become a method name, do not translate this string
+      Puppet.warning(_("'new%{method}' method already exists; skipping") % { method: name.to_s })
     else
       selfobj.send(:define_method, newmethod) do |*args|
         klass.new(*args)
@@ -123,7 +124,7 @@ module Manager
     klass.providerloader = Puppet::Util::Autoload.new(klass, "puppet/provider/#{klass.name.to_s}")
 
     # We have to load everything so that we can figure out the default provider.
-    klass.providerloader.loadall Puppet.lookup(:current_environment)
+    klass.providerloader.loadall(Puppet.lookup(:current_environment))
     klass.providify unless klass.providers.empty?
 
     loc = block_given? ? block.source_location : nil
@@ -169,7 +170,8 @@ module Manager
     end
     # Try loading the type.
     if typeloader.load(name, Puppet.lookup(:current_environment))
-      Puppet.warning "Loaded puppet/type/#{name} but no class was created" unless @types.include? name
+      #TRANSLATORS 'puppet/type/%{name}' should not be translated
+      Puppet.warning(_("Loaded puppet/type/%{name} but no class was created") % { name: name }) unless @types.include? name
     elsif !Puppet[:always_retry_plugins]
       # PUP-5482 - Only look for a type once if plugin retry is disabled
       @types[name] = nil

data/lib/puppet/module/task.rb

@@ -0,0 +1,267 @@
+require 'puppet/util/logging'
+
+class Puppet::Module
+  class Task
+    class Error < Puppet::Error
+      attr_accessor :kind, :details
+      def initialize(message, kind, details = nil)
+        super(message)
+        @details = details || {}
+        @kind = kind
+      end
+
+      def to_h
+        {
+          msg: message,
+          kind: kind,
+          details: details
+        }
+      end
+    end
+
+    class InvalidName < Error
+      def initialize(name)
+        msg = _("Task names must start with a lowercase letter and be composed of only lowercase letters, numbers, and underscores")
+        super(msg, 'puppet.tasks/invalid-name')
+      end
+    end
+
+    class InvalidFile < Error
+      def initialize(msg)
+        super(msg, 'puppet.tasks/invalid-file')
+      end
+    end
+
+    class InvalidTask < Error
+    end
+    class InvalidMetadata < Error
+    end
+    class TaskNotFound < Error
+      def initialize(task_name, module_name)
+        msg = _("Task %{task_name} not found in module %{module_name}.") %
+          {task_name: task_name, module_name: module_name}
+        super(msg, 'puppet.tasks/task-not-found', { 'name' => task_name })
+      end
+    end
+
+    FORBIDDEN_EXTENSIONS = %w{.conf .md}
+    MOUNTS = %w[lib files tasks]
+
+    def self.is_task_name?(name)
+      return true if name =~ /^[a-z][a-z0-9_]*$/
+      return false
+    end
+
+    # Determine whether a file has a legal name for either a task's executable or metadata file.
+    def self.is_tasks_filename?(path)
+      name_less_extension = File.basename(path, '.*')
+      return false if not is_task_name?(name_less_extension)
+      FORBIDDEN_EXTENSIONS.each do |ext|
+        return false if path.end_with?(ext)
+      end
+      return true
+    end
+
+    def self.get_file_details(path, mod)
+      # This gets the path from the starting point onward
+      # For files this should be the file subpath from the metadata
+      # For directories it should be the directory subpath plus whatever we globbed
+      # Partition matches on the first instance it finds of the parameter
+      name = "#{mod.name}#{path.partition(mod.path).last}"
+
+      { "name" => name, "path" =>  path }
+    end
+
+    # Find task's required lib files and retrieve paths
+    # for both 'files' and 'implementation:files' metadata keys
+    def self.find_files(files, mod)
+      env = mod.environment.respond_to?(:name) ? mod.environment.name : 'production'
+
+      file_list = files.flat_map do |file|
+        module_name, mount, endpath = file.split("/", 3)
+        # If there's a mount directory with no trailing slash this will be nil
+        # We want it to be empty to construct a path
+        endpath ||= ''
+
+        pup_module = Puppet::Module.find(module_name, env)
+        if pup_module.nil?
+          msg = _("Could not find module %{module_name} containing task file %{filename}" %
+                  {module_name: module_name, filename: endpath})
+          raise InvalidMetadata.new(msg, 'puppet.tasks/invalid-metadata')
+        end
+
+        unless MOUNTS.include? mount
+          msg = _("Files must be saved in module directories that Puppet makes available via mount points: %{mounts}" %
+                  {mounts: MOUNTS.join(', ')})
+          raise InvalidMetadata.new(msg, 'puppet.tasks/invalid-metadata')
+        end
+
+        path = File.join(pup_module.path, mount, endpath)
+        unless File.absolute_path(path) == File.path(path).chomp('/')
+          msg = _("File pathnames cannot include relative paths")
+          raise InvalidMetadata.new(msg, 'puppet.tasks/invalid-metadata')
+        end
+
+        unless File.exist?(path)
+          msg = _("Could not find %{path} on disk" % { path: path })
+          raise InvalidFile.new(msg)
+        end
+
+        last_char = file[-1] == '/'
+        if File.directory?(path)
+          unless last_char
+            msg = _("Directories specified in task metadata must include a trailing slash: %{dir}" % { dir: file } )
+            raise InvalidMetadata.new(msg, 'puppet.tasks/invalid-metadata')
+          end
+          dir_files = Dir.glob("#{path}**/*").select { |f| File.file?(f) }
+          files = dir_files.map { |f| get_file_details(f, pup_module) }
+        else
+          if last_char
+            msg = _("Files specified in task metadata cannot include a trailing slash: %{file}" % { file: file } )
+            raise InvalidMetadata.new(msg, 'puppet.task/invalid-metadata')
+          end
+          files = get_file_details(path, pup_module)
+        end
+
+        files
+      end
+      return file_list
+    end
+
+    # Copied from TaskInstantiator so we can use the Error classes here
+    # TODO: harmonize on one implementation
+    # Executables list should contain the full path of all possible implementation files
+    def self.find_implementations(name, directory, metadata, executables)
+      basename = name.split('::')[1] || 'init'
+      # If 'implementations' is defined, it needs to mention at least one
+      # implementation, and everything it mentions must exist.
+      metadata ||= {}
+      if metadata.key?('implementations')
+        unless metadata['implementations'].is_a?(Array)
+          msg = _("Task metadata for task %{name} does not specify implementations as an array" % { name: name })
+          raise InvalidMetadata.new(msg, 'puppet.tasks/invalid-metadata')
+        end
+
+        implementations = metadata['implementations'].map do |impl|
+          path = executables.find { |real_impl| File.basename(real_impl) == impl['name'] }
+          unless path
+            msg = _("Task metadata for task %{name} specifies missing implementation %{implementation}" % { name: name, implementation: impl['name'] })
+            raise InvalidTask.new(msg, 'puppet.tasks/missing-implementation', { missing: [impl['name']] } )
+          end
+          { "name" => impl['name'], "requirements" => impl.fetch('requirements', []), "path" => path }
+        end
+        return implementations
+      end
+
+      # If implementations isn't defined, then we use executables matching the
+      # task name, and only one may exist.
+      implementations = executables.select { |impl| File.basename(impl, '.*') == basename }
+      if implementations.empty?
+        msg = _('No source besides task metadata was found in directory %{directory} for task %{name}') %
+          { name: name, directory: directory }
+        raise InvalidTask.new(msg, 'puppet.tasks/no-implementation')
+      elsif implementations.length > 1
+        msg =_("Multiple executables were found in directory %{directory} for task %{name}; define 'implementations' in metadata to differentiate between them") %
+          { name: name, directory: implementations[0] }
+        raise InvalidTask.new(msg, 'puppet.tasks/multiple-implementations')
+      end
+
+      [{ "name" => File.basename(implementations.first), "path" => implementations.first, "requirements" => [] }]
+    end
+
+    def self.is_tasks_metadata_filename?(name)
+      is_tasks_filename?(name) && name.end_with?('.json')
+    end
+
+    def self.is_tasks_executable_filename?(name)
+      is_tasks_filename?(name) && !name.end_with?('.json')
+    end
+
+    def self.tasks_in_module(pup_module)
+      task_files = Dir.glob(File.join(pup_module.tasks_directory, '*'))
+        .keep_if { |f| is_tasks_filename?(f) }
+
+      module_executables = task_files.reject(&method(:is_tasks_metadata_filename?)).map.to_a
+
+      tasks = task_files.group_by { |f| task_name_from_path(f) }
+
+      tasks.map do |task, executables|
+        new_with_files(pup_module, task, executables, module_executables)
+      end
+    end
+
+    attr_reader :name, :module, :metadata_file, :metadata
+
+    # file paths must be relative to the modules task directory
+    def initialize(pup_module, task_name,  module_executables, metadata_file = nil)
+      if !Puppet::Module::Task.is_task_name?(task_name)
+        raise InvalidName, _("Task names must start with a lowercase letter and be composed of only lowercase letters, numbers, and underscores")
+      end
+
+      name = task_name == "init" ? pup_module.name : "#{pup_module.name}::#{task_name}"
+
+      @module = pup_module
+      @name = name
+      @metadata_file = metadata_file
+      @module_executables = module_executables || []
+    end
+
+    def read_metadata(file)
+      Puppet::Util::Json.load(Puppet::FileSystem.read(file, :encoding => 'utf-8')) if file
+    rescue SystemCallError, IOError => err
+      msg = _("Error reading metadata: %{message}" % {message: err.message})
+      raise InvalidMetadata.new(msg, 'puppet.tasks/unreadable-metadata')
+    rescue Puppet::Util::Json::ParseError => err
+      raise InvalidMetadata.new(err.message, 'puppet.tasks/unparseable-metadata')
+    end
+
+    def metadata
+      @metadata ||= read_metadata(@metadata_file)
+    end
+
+    def implementations
+      @implementations ||= self.class.find_implementations(@name, @module.tasks_directory, metadata, @module_executables)
+    end
+
+    def files
+      md = metadata
+      outer_files = []
+      impl_lib_files = []
+      lib_files = []
+
+      unless md.nil?
+        outer_files = md['files'] if md.key?('files')
+        # There's definitely a more elegant way to do this...
+        if md.key?('implementations')
+          md['implementations'].each { |impl| impl_lib_files << impl['files'] if impl.key?('files') }
+        end
+        lib_files = self.class.find_files((impl_lib_files.flatten.uniq + outer_files).uniq, @module)
+      end
+      task_file = implementations.map {|imp| { 'name' => imp['name'], 'path' => imp['path'] } }
+      # PXP agent relies on 'impls' (which is the task file) being first if there is no metadata
+      task_file + lib_files
+    end
+
+    def validate
+      implementations
+      true
+    end
+
+    def ==(other)
+      self.name == other.name &&
+      self.module == other.module
+    end
+
+    def self.new_with_files(pup_module, name, task_files, module_executables)
+      metadata_file = task_files.find { |f| is_tasks_metadata_filename?(f) }
+      Puppet::Module::Task.new(pup_module, name, module_executables, metadata_file)
+    end
+    private_class_method :new_with_files
+
+    # Abstracted here so we can add support for subdirectories later
+    def self.task_name_from_path(path)
+      return File.basename(path, '.*')
+    end
+    private_class_method :task_name_from_path
+  end
+end

data/lib/puppet/module.rb

@@ -1,5 +1,7 @@
 require 'puppet/util/logging'
-require 'json'
+require 'puppet/module/task'
+require 'puppet/util/json'
+require 'semantic_puppet/gem_version'
 
 # Support for modules
 class Puppet::Module
@@ -21,6 +23,7 @@ class Puppet::Module
     "templates" => "templates",
     "plugins" => "lib",
     "pluginfacts" => "facts.d",
+    "locales" => "locales",
   }
 
   # Find and return the +module+ that +path+ belongs to. If +path+ is
@@ -52,16 +55,20 @@ class Puppet::Module
     return false
   end
 
-  attr_reader :name, :environment, :path, :metadata
+  # @api private
+  def self.parse_range(range)
+    SemanticPuppet::VersionRange.parse(range)
+  end
+
+  attr_reader :name, :environment, :path, :metadata, :tasks
   attr_writer :environment
 
   attr_accessor :dependencies, :forge_name
   attr_accessor :source, :author, :version, :license, :summary, :description, :project_page
 
-  def initialize(name, path, environment, strict_semver = true)
+  def initialize(name, path, environment)
     @name = name
     @path = path
-    @strict_semver = strict_semver
     @environment = environment
 
     assert_validity
@@ -131,6 +138,39 @@ class Puppet::Module
     end
   end
 
+  def tasks_directory
+    subpath("tasks")
+  end
+
+  def tasks
+    return @tasks if instance_variable_defined?(:@tasks)
+
+    if Puppet::FileSystem.exist?(tasks_directory)
+      @tasks = Puppet::Module::Task.tasks_in_module(self)
+    else
+      @tasks = []
+    end
+  end
+
+  # This is a re-implementation of the Filetypes singular type method (e.g.
+  # `manifest('my/manifest.pp')`. We don't implement the full filetype "API" for
+  # tasks since tasks don't map 1:1 onto files.
+  def task_file(name)
+    # If 'file' is nil then they're asking for the base path.
+    # This is used for things like fileserving.
+    if name
+      full_path = File.join(tasks_directory, name)
+    else
+      full_path = tasks_directory
+    end
+
+    if Puppet::FileSystem.exist?(full_path)
+      return full_path
+    else
+      return nil
+    end
+  end
+
   def license_file
     return @license_file if defined?(@license_file)
 
@@ -140,11 +180,12 @@ class Puppet::Module
 
   def read_metadata
     md_file = metadata_file
-    md_file.nil? ? {} : JSON.parse(File.read(md_file, :encoding => 'utf-8'))
+    md_file.nil? ? {} : Puppet::Util::Json.load(File.read(md_file, :encoding => 'utf-8'))
   rescue Errno::ENOENT
     {}
-  rescue JSON::JSONError => e
-    msg = "#{name} has an invalid and unparsable metadata.json file. The parse error: #{e.message}"
+  rescue Puppet::Util::Json::ParseError => e
+    #TRANSLATORS 'metadata.json' is a specific file name and should not be translated.
+    msg = _("%{name} has an invalid and unparsable metadata.json file. The parse error: %{error}") % { name: name, error: e.message }
     case Puppet[:strict]
     when :off
       Puppet.debug(msg)
@@ -238,6 +279,21 @@ class Puppet::Module
     subpath("facts.d")
   end
 
+  #@return [String]
+  def locale_directory
+    subpath("locales")
+  end
+
+  # Returns true if the module has translation files for the
+  # given locale.
+  # @param [String] locale the two-letter language code to check
+  #        for translations
+  # @return true if the module has a directory for the locale, false
+  #         false otherwise
+  def has_translations?(locale)
+    return Puppet::FileSystem.exist?(File.join(locale_directory, locale))
+  end
+
   def has_external_facts?
     File.directory?(plugin_fact_directory)
   end
@@ -256,7 +312,7 @@ class Puppet::Module
   def dependencies_as_modules
     dependent_modules = []
     dependencies and dependencies.each do |dep|
-      author, dep_name = dep["name"].split('/')
+      _, dep_name = dep["name"].split('/')
       found_module = environment.module(dep_name)
       dependent_modules << found_module if found_module
     end
@@ -328,7 +384,7 @@ class Puppet::Module
 
       if version_string
         begin
-          required_version_semver_range = SemanticPuppet::VersionRange.parse(version_string, @strict_semver)
+          required_version_semver_range = self.class.parse_range(version_string)
           actual_version_semver = SemanticPuppet::Version.parse(dep_mod.version)
         rescue ArgumentError
           error_details[:reason] = :non_semantic_version
@@ -354,10 +410,6 @@ class Puppet::Module
     self.environment == other.environment
   end
 
-  def strict_semver?
-    @strict_semver
-  end
-
   private
 
   def wanted_manifests_from(pattern)
@@ -379,7 +431,11 @@ class Puppet::Module
 
   def assert_validity
     if !Puppet::Module.is_module_directory_name?(@name) && !Puppet::Module.is_module_namespaced_name?(@name)
-      raise InvalidName, "Invalid module name #{@name}; module names must be alphanumeric (plus '-'), not '#{@name}'"
+      raise InvalidName, _(<<-ERROR_STRING).chomp % { name: @name }
+        Invalid module name '%{name}'; module names must match either:
+        An installed module name (ex. modulename) matching the expression /^[a-z][a-z0-9_]*$/ -or-
+        A namespaced module name (ex. author-modulename) matching the expression /^[a-zA-Z0-9]+[-][a-z][a-z0-9_]*$/
+      ERROR_STRING
     end
   end
 end

data/lib/puppet/module_tool/applications/application.rb

@@ -1,5 +1,5 @@
 require 'net/http'
-require 'json'
+require 'puppet/util/json'
 require 'puppet/util/colors'
 
 module Puppet::ModuleTool
@@ -26,7 +26,7 @@ module Puppet::ModuleTool
         when Net::HTTPOK, Net::HTTPCreated
           Puppet.notice success
         else
-          errors = JSON.parse(response.body)['error'] rescue "HTTP #{response.code}, #{response.body}"
+          errors = Puppet::Util::Json.load(response.body)['error'] rescue "HTTP #{response.code}, #{response.body}"
           Puppet.warning "#{failure} (#{errors})"
         end
       end
@@ -40,7 +40,7 @@ module Puppet::ModuleTool
         end
 
         if require_metadata && !Puppet::ModuleTool.is_module_root?(@path)
-          raise ArgumentError, _("Unable to find metadata.json in module root at %{path} See https://docs.puppet.com/puppet/latest/reference/modules_publishing.html for required file format.") % { path: @path }
+          raise ArgumentError, _("Unable to find metadata.json in module root at %{path} See https://puppet.com/docs/puppet/latest/modules_publishing.html for required file format.") % { path: @path }
         end
 
         metadata_path   = File.join(@path, 'metadata.json')
@@ -48,8 +48,8 @@ module Puppet::ModuleTool
         if File.file?(metadata_path)
           File.open(metadata_path) do |f|
             begin
-              @metadata.update(JSON.load(f))
-            rescue JSON::ParserError => ex
+              @metadata.update(Puppet::Util::Json.load(f))
+            rescue Puppet::Util::Json::ParseError => ex
               raise ArgumentError, _("Could not parse JSON %{metadata_path}") % { metadata_path: metadata_path }, ex.backtrace
             end
           end