puppet 5.3.3-x64-mingw32 → 5.3.4-x64-mingw32

data/lib/puppet/module_tool/errors/installer.rb

@@ -14,9 +14,11 @@ module Puppet::ModuleTool::Errors
     def multiline
       message = []
       message << _("Could not install module '%{module_name}' (%{version})") % { module_name: @module_name, version: @requested_version }
-      message << _("  Module '%{module_name}' (%{version}) is already installed") % { module_name: @module_name, version: @installed_version }
+      message << _("  Module '%{module_name}' (%{installed_version}) is already installed") % { module_name: @module_name, installed_version: @installed_version }
       message << _("    Installed module has had changes made locally") unless @local_changes.empty?
+      #TRANSLATORS `puppet module upgrade` is a command line and should not be translated
       message << _("    Use `puppet module upgrade` to install a different version")
+      #TRANSLATORS `puppet module install --force` is a command line and should not be translated
       message << _("    Use `puppet module install --force` to re-install only this module")
       message.join("\n")
     end
@@ -33,10 +35,8 @@ module Puppet::ModuleTool::Errors
     def multiline
       message = []
       message << _("Could not install '%{requested_package}'") % { requested_package: @requested_package }
-
       message << _("  No releases are available from %{source}") % { source: @source }
       message << _("    Does '%{requested_package}' have at least one published release?") % { requested_package: @requested_package }
-
       message.join("\n")
     end
   end
@@ -50,12 +50,12 @@ module Puppet::ModuleTool::Errors
     end
 
     def multiline
-      _(<<-MSG).strip % { module_name: @requested_module, version: @requested_version, dir: @directory }
-Could not install module '%{module_name}' (%{version})
-  Path '%{dir}' exists but is not a directory.
-  A potential solution is to rename the path and then
-  mkdir -p '%{dir}'
-      MSG
+      message = []
+      message << _("Could not install module '%{module_name}' (%{version})") % { module_name: @requested_module, version: @requested_version }
+      message << _("  Path '%{directory}' exists but is not a directory.") % { directory: @directory }
+      #TRANSLATORS "mkdir -p '%{directory}'" is a command line example and should not be translated
+      message << _("  A potential solution is to rename the path and then \"mkdir -p '%{directory}'\"") % { directory: @directory }
+      message.join("\n")
     end
   end
 
@@ -68,12 +68,11 @@ Could not install module '%{module_name}' (%{version})
     end
 
     def multiline
-      _(<<-MSG).strip % { module_name: @requested_module, version: @requested_version, dir: @directory }
-Could not install module '%{module_name}' (%{version})
-  Permission is denied when trying to create directory '%{dir}'.
-  A potential solution is to check the ownership and permissions of
-  parent directories.
-      MSG
+      message = []
+      message << _("Could not install module '%{module_name}' (%{version})") % { module_name: @requested_module, version: @requested_version }
+      message << _("  Permission is denied when trying to create directory '%{directory}'.")  % { directory: @directory }
+      message << _('  A potential solution is to check the ownership and permissions of parent directories.')
+      message.join("\n")
     end
   end
 
@@ -85,11 +84,10 @@ Could not install module '%{module_name}' (%{version})
     end
 
     def multiline
-      _(<<-MSG).strip % { path: @entry_path.inspect, dir: @directory.inspect }
-Could not install package with an invalid path.
-  Package attempted to install file into
-  %{path} under %{dir}.
-      MSG
+      message = []
+      message << _('Could not install package with an invalid path.')
+      message << _('  Package attempted to install file into %{path} under %{directory}.') % { path: @entry_path.inspect, directory: @directory.inspect }
+      message.join("\n")
     end
   end
 end

data/lib/puppet/module_tool/errors/shared.rb

@@ -15,8 +15,8 @@ module Puppet::ModuleTool::Errors
       message = []
       message << _("Could not %{action} module '%{module_name}' (%{version})") % { action: @action, module_name: @requested_name, version: vstring }
       message << _("  No version of '%{module_name}' can satisfy all dependencies") % { module_name: @requested_name }
+      #TRANSLATORS `puppet module %{action} --ignore-dependencies` is a command line and should not be translated
       message << _("    Use `puppet module %{action} --ignore-dependencies` to %{action} only this module") % { action: @action }
-
       message.join("\n")
     end
   end
@@ -39,14 +39,12 @@ module Puppet::ModuleTool::Errors
     def multiline
       message = []
       message << _("Could not %{action} '%{module_name}' (%{version})") % { action: @action, module_name: @module_name, version: vstring }
-
       if @requested_version == :latest
         message << _("  No releases are available from %{source}") % { source: @source }
         message << _("    Does '%{module_name}' have at least one published release?") % { module_name: @module_name }
       else
-        message << _("  No releases matching '%{version}' are available from %{source}") % { version: @requested_version, source: @source }
+        message << _("  No releases matching '%{requested_version}' are available from %{source}") % { requested_version: @requested_version, source: @source }
       end
-
       message.join("\n")
     end
   end
@@ -66,21 +64,22 @@ module Puppet::ModuleTool::Errors
       message << _("Could not install module '%{module_name}' (%{version})") % { module_name: @requested_module, version: @requested_version }
 
       if @dependency
-        message << _("  Dependency '%{name}' (%{version}) would overwrite %{dir}") % { name: @dependency[:name], version: v(@dependency[:version]), dir: @directory }
+        message << _("  Dependency '%{name}' (%{version}) would overwrite %{directory}") % { name: @dependency[:name], version: v(@dependency[:version]), directory: @directory }
       else
-        message << _("  Installation would overwrite %{dir}") % { dir: @directory }
+        message << _("  Installation would overwrite %{directory}") % { directory: @directory }
       end
 
       if @metadata
-        message << _("    Currently, '%{name}' (%{version}) is installed to that directory") % { name: @metadata["name"], version: v(@metadata["version"]) }
+        message << _("    Currently, '%{current_name}' (%{current_version}) is installed to that directory") % { current_name: @metadata["name"], current_version: v(@metadata["version"]) }
       end
 
       if @dependency
+        #TRANSLATORS `puppet module install --ignore-dependencies` is a command line and should not be translated
         message << _("    Use `puppet module install --ignore-dependencies` to install only this module")
       else
+        #TRANSLATORS `puppet module install --force` is a command line and should not be translated
         message << _("    Use `puppet module install --force` to install this module anyway")
       end
-
       message.join("\n")
     end
   end
@@ -97,17 +96,18 @@ module Puppet::ModuleTool::Errors
     end
 
     def multiline
-      trace = []
-      trace << _("You specified '%{name}' (%{version})") % { name: @source.first[:name], version: v(@requested_version) }
-      #TRANSLATORS Second half of "You specified a module..."
-      trace += @source[1..-1].map { |m| _("which depends on '%{name}' (%{version})") % { name: m[:name], version: v(m[:version]) } }
-
+      dependency_list = []
+      dependency_list << _("You specified '%{name}' (%{version})") % { name: @source.first[:name], version: v(@requested_version) }
+      dependency_list += @source[1..-1].map do |m|
+        #TRANSLATORS This message repeats as separate lines as a list under the heading "You specified '%{name}' (%{version})\n"
+        _("This depends on '%{name}' (%{version})") % { name: m[:name], version: v(m[:version]) }
+      end
       message = []
       message << _("Could not install module '%{module_name}' (%{version})") % { module_name: @requested_module, version: v(@requested_version) }
       message << _("  No version of '%{module_name}' will satisfy dependencies") % { module_name: @module_name }
-      message << trace.map { |s| "    #{s}".join(",\n") }
+      message << dependency_list.map {|s| "    #{s}".join(",\n")}
+      #TRANSLATORS `puppet module install --force` is a command line and should not be translated
       message << _("    Use `puppet module install --force` to install this module anyway")
-
       message.join("\n")
     end
   end
@@ -125,8 +125,10 @@ module Puppet::ModuleTool::Errors
       message << _("Could not %{action} module '%{module_name}'") % { action: @action, module_name: @module_name }
       message << _("  Module '%{module_name}' is not installed") % { module_name: @module_name }
       message += @suggestions.map do |suggestion|
+        #TRANSLATORS `puppet module %{action} %{suggestion}` is a command line and should not be translated
         _("    You may have meant `puppet module %{action} %{suggestion}`") % { action: @action, suggestion: suggestion }
       end
+      #TRANSLATORS `puppet module install` is a command line and should not be translated
       message << _("    Use `puppet module install` to install this module") if @action == :upgrade
       message.join("\n")
     end
@@ -146,8 +148,10 @@ module Puppet::ModuleTool::Errors
       message << _("Could not %{action} module '%{module_name}'") % { action: @action, module_name: @module_name }
       message << _("  Module '%{module_name}' appears multiple places in the module path") % { module_name: @module_name }
       message += @modules.map do |mod|
+        #TRANSLATORS This is repeats as separate lines as a list under "Module '%{module_name}' appears multiple places in the module path"
         _("    '%{module_name}' (%{version}) was found in %{path}") % { module_name: @module_name, version: v(mod.version), path: mod.modulepath }
       end
+      #TRANSLATORS `--modulepath` is command line option and should not be translated
       message << _("    Use the `--modulepath` option to limit the search to specific directories")
       message.join("\n")
     end
@@ -166,6 +170,7 @@ module Puppet::ModuleTool::Errors
       message = []
       message << _("Could not %{action} module '%{module_name}' (%{version})") % { action: @action, module_name: @module_name, version: vstring }
       message << _("  Installed module has had changes made locally")
+      #TRANSLATORS `puppet module %{action} --ignore-changes` is a command line and should not be translated
       message << _("    Use `puppet module %{action} --ignore-changes` to %{action} this module anyway") % { action: @action }
       message.join("\n")
     end

data/lib/puppet/module_tool/errors/uninstaller.rb

@@ -42,6 +42,7 @@ module Puppet::ModuleTool::Errors
       message += @required_by.map do |mod|
         _("    '%{module_name}' (%{version}) requires '%{module_dep}' (%{dep_version})") % { module_name: mod['name'], version: v(mod['version']), module_dep: @module_name, dep_version: v(mod['version_requirement']) }
       end
+      #TRANSLATORS `puppet module uninstall --force` is a command line option that should not be translated
       message << _("    Use `puppet module uninstall --force` to uninstall this module anyway")
       message.join("\n")
     end

data/lib/puppet/module_tool/errors/upgrader.rb

@@ -36,6 +36,7 @@ module Puppet::ModuleTool::Errors
           end
         end
       end
+      #TRANSLATORS `puppet module upgrade --force` is a command line option that should not be translated
       message << _("    Use `puppet module upgrade --force` to upgrade only this module")
       message.join("\n")
     end
@@ -56,7 +57,6 @@ module Puppet::ModuleTool::Errors
       message = []
       message << _("Could not %{action} module '%{module_name}' (%{version})") % { action: @action, module_name: @module_name, version: vstring }
       message << _("  Downgrading is not allowed.")
-
       message.join("\n")
     end
   end

data/lib/puppet/module_tool/tar/mini.rb

@@ -3,24 +3,77 @@ class Puppet::ModuleTool::Tar::Mini
     Zlib::GzipReader.open(sourcefile) do |reader|
       Archive::Tar::Minitar.unpack(reader, destdir, find_valid_files(reader)) do |action, name, stats|
         case action
-        when :file_done
-          File.chmod(0644, "#{destdir}/#{name}")
-        when :dir, :file_start
+        when :dir
           validate_entry(destdir, name)
+          set_dir_mode!(stats)
+          Puppet.debug("Extracting: #{destdir}/#{name}")
+        when :file_start
+          # Octal string of the old file mode.
+          validate_entry(destdir, name)
+          set_file_mode!(stats)
           Puppet.debug("Extracting: #{destdir}/#{name}")
         end
+        set_default_user_and_group!(stats)
+        stats
       end
     end
   end
 
   def pack(sourcedir, destfile)
     Zlib::GzipWriter.open(destfile) do |writer|
-      Archive::Tar::Minitar.pack(sourcedir, writer)
+      Archive::Tar::Minitar.pack(sourcedir, writer) do |step, name, stats|
+        # TODO smcclellan 2017-10-31 Set permissions here when this yield block
+        # executes before the header is written. As it stands, the `stats`
+        # argument isn't mutable in a way that will effect the desired mode for
+        # the file.
+      end
     end
   end
 
   private
 
+  EXECUTABLE = 0755
+  NOT_EXECUTABLE = 0644
+  USER_EXECUTE = 0100
+
+  def set_dir_mode!(stats)
+    if stats.key?(:mode)
+      # This is only the case for `pack`, so this code will not run.
+      stats[:mode] = EXECUTABLE
+    elsif stats.key?(:entry)
+      old_mode = stats[:entry].instance_variable_get(:@mode)
+      if old_mode.is_a?(Fixnum)
+        stats[:entry].instance_variable_set(:@mode, EXECUTABLE)
+      end
+    end
+  end
+
+  # Sets a file mode to 0755 if the file is executable by the user.
+  # Sets a file mode to 0644 if the file mode is set (non-Windows).
+  def sanitized_mode(old_mode)
+    old_mode & USER_EXECUTE != 0 ? EXECUTABLE : NOT_EXECUTABLE
+  end
+
+  def set_file_mode!(stats)
+    if stats.key?(:mode)
+      # This is only the case for `pack`, so this code will not run.
+      stats[:mode] = sanitized_mode(stats[:mode])
+    elsif stats.key?(:entry)
+      old_mode = stats[:entry].instance_variable_get(:@mode)
+      # If the user can execute the file, set 0755, otherwise 0644.
+      if old_mode.is_a?(Fixnum)
+        new_mode = sanitized_mode(old_mode)
+        stats[:entry].instance_variable_set(:@mode, new_mode)
+      end
+    end
+  end
+
+  # Sets UID and GID to 0 for standardization.
+  def set_default_user_and_group!(stats)
+    stats[:uid] = 0
+    stats[:gid] = 0
+  end
+
   # Find all the valid files in tarfile.
   #
   # This check was mainly added to ignore 'x' and 'g' flags from the PAX

data/lib/puppet/network/auth_config_parser.rb

@@ -29,11 +29,14 @@ class AuthConfigParser
       when /^\s*(allow(?:_ip)?|deny(?:_ip)?|method|environment|auth(?:enticated)?)\s+(.+?)(\s*#.*)?$/
         if right.nil?
           #TRANSLATORS "path" is a configuration file entry and should not be translated
-          raise Puppet::ConfigurationError, _("Missing or invalid 'path' before right directive at line %{count} of %{file}") % { count: count, file: @file }
+          raise Puppet::ConfigurationError, _("Missing or invalid 'path' before right directive at %{error_location}") %
+              { error_location: Puppet::Util::Errors.error_location(@file, count) }
         end
         parse_right_directive(right, $1, $2, count)
       else
-        raise Puppet::ConfigurationError, _("Invalid line %{count}: %{line}") % { count: count, line: line }
+        error_location_str = Puppet::Util::Errors.error_location(nil, count)
+        raise Puppet::ConfigurationError, _("Invalid entry at %{error_location}: %{file_text}") %
+            { error_location: error_location_str, file_text: line }
       end
       count += 1
     }
@@ -51,22 +54,23 @@ class AuthConfigParser
     value.strip!
     case var
     when "allow"
-      modify_right(right, :allow, value, _("allowing %s access"), count)
+      modify_right(right, :allow, value, _("allowing %{value} access"), count)
     when "deny"
-      modify_right(right, :deny, value, _("denying %s access"), count)
+      modify_right(right, :deny, value, _("denying %{value} access"), count)
     when "allow_ip"
-      modify_right(right, :allow_ip, value, _("allowing IP %s access"), count)
+      modify_right(right, :allow_ip, value, _("allowing IP %{value} access"), count)
     when "deny_ip"
-      modify_right(right, :deny_ip, value, _("denying IP %s access"), count)
+      modify_right(right, :deny_ip, value, _("denying IP %{value} access"), count)
     when "method"
-      modify_right(right, :restrict_method, value, _("allowing 'method' %s"), count)
+      modify_right(right, :restrict_method, value, _("allowing 'method' %{value}"), count)
     when "environment"
-      modify_right(right, :restrict_environment, value, _("adding environment %s"), count)
+      modify_right(right, :restrict_environment, value, _("adding environment %{value}"), count)
     when /auth(?:enticated)?/
-      modify_right(right, :restrict_authenticated, value, _("adding authentication %s"), count)
+      modify_right(right, :restrict_authenticated, value, _("adding authentication %{value}"), count)
     else
-      raise Puppet::ConfigurationError,
-        _("Invalid argument '%{var}' at line %{count}") % { var: var, count: count }
+      error_location_str = Puppet::Util::Errors.error_location(nil, count)
+      raise Puppet::ConfigurationError, _("Invalid argument '%{var}' at %{error_location}") %
+          { var: var, error_location: error_location_str }
     end
   end
 
@@ -74,10 +78,11 @@ class AuthConfigParser
     value.split(/\s*,\s*/).each do |val|
       begin
         val.strip!
-        right.info msg % val
+        right.info msg % { value: val }
         right.send(method, val)
       rescue Puppet::AuthStoreError => detail
-        raise Puppet::ConfigurationError, _("%{detail} at line %{count} of %{file}") % { detail: detail, count: count, file: @file }, detail.backtrace
+        error_location_str = Puppet::Util::Errors.error_location(@file, count)
+        raise Puppet::ConfigurationError, "#{detail} #{error_location_str}", detail.backtrace
       end
     end
   end

data/lib/puppet/network/authstore.rb

@@ -19,7 +19,7 @@ module Puppet
         # This is probably unnecessary, and can cause some weirdnesses in
         # cases where we're operating over localhost but don't have a real
         # IP defined.
-        raise Puppet::DevError, "Name and IP must be passed to 'allowed?'" unless name and ip
+        raise Puppet::DevError, _("Name and IP must be passed to 'allowed?'") unless name and ip
         # else, we're networked and such
       else
         # we're local
@@ -186,7 +186,7 @@ module Puppet
       # Set the declaration type.  Either :allow or :deny.
       def type=(type)
         type = type.intern
-        raise ArgumentError, "Invalid declaration type #{type}" unless VALID_TYPES.include?(type)
+        raise ArgumentError, _("Invalid declaration type %{type}") % { type: type } unless VALID_TYPES.include?(type)
         @type = type
       end
 

data/lib/puppet/network/client_request.rb

@@ -12,7 +12,7 @@ module Puppet::Network # :nodoc:
     # are responsible for setting the values correctly, but this common
     # format makes it possible to check rights.
     def call
-      raise ArgumentError, "Request is not set up; cannot build call" unless handler and method
+      raise ArgumentError, _("Request is not set up; cannot build call") unless handler and method
 
       [handler, method].join(".")
     end

data/lib/puppet/network/format.rb

@@ -40,7 +40,7 @@ class Puppet::Network::Format
       init_attribute(method, value)
     end
 
-    raise ArgumentError, "Unsupported option(s) #{@options.keys}" unless @options.empty?
+    raise ArgumentError, _("Unsupported option(s) %{options_list}") % { options_list: @options.keys } unless @options.empty?
 
     @options = nil
 
@@ -69,8 +69,8 @@ class Puppet::Network::Format
   def render_multiple(instances)
     # This method implicitly assumes that all instances are of the same type.
     return instances[0].class.send(render_multiple_method, instances) if instances[0].class.respond_to?(render_multiple_method)
-    raise NotImplementedError, _("%{klass} does not respond to %{method}; can not render multiple instances to %{mime}") \
-                               % { klass: instances[0].class, method: render_multiple_method, mime: mime }
+    raise NotImplementedError, _("%{klass} does not respond to %{method}; can not render multiple instances to %{mime}") %
+        { klass: instances[0].class, method: render_multiple_method, mime: mime }
   end
 
   def required_methods_present?(klass)

data/lib/puppet/network/http/api/indirection_type.rb

@@ -26,7 +26,7 @@ class Puppet::Network::HTTP::API::IndirectionType
     when :master
       master_url_prefix
     else
-      raise ArgumentError, "Not a valid indirection type"
+      raise ArgumentError, _("Not a valid indirection type")
     end
   end
 end

data/lib/puppet/network/http/api/master/v3/environment.rb

@@ -36,12 +36,15 @@ class Puppet::Network::HTTP::API::Master::V3::Environment
 
       nonexistent_components = mapped_components - required_components
       if nonexistent_components.any?
-        raise Puppet::ParseError.new("Application #{app} assigns nodes to non-existent components: #{nonexistent_components.join(', ')}", file, line)
+        raise Puppet::ParseError.new(
+            _("Application %{application} assigns nodes to non-existent components: %{component_list}") %
+                { application: app, component_list: nonexistent_components.join(', ') }, file, line)
       end
 
       missing_components = required_components - mapped_components
       if missing_components.any?
-        raise Puppet::ParseError.new("Application #{app} has components without assigned nodes: #{missing_components.join(', ')}", file, line)
+        raise Puppet::ParseError.new(_("Application %{application} has components without assigned nodes: %{component_list}") %
+                                         { application: app, component_list: missing_components.join(', ') }, file, line)
       end
 
       # Turn the 'nodes' hash into a map component ref => node name

data/lib/puppet/network/http/error.rb

@@ -20,42 +20,42 @@ module Puppet::Network::HTTP::Error
   class HTTPNotAcceptableError < HTTPError
     CODE = 406
     def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
-      super(_("Not Acceptable: ") + message, CODE, issue_kind)
+      super(_("Not Acceptable: %{message}") % { message: message }, CODE, issue_kind)
     end
   end
 
   class HTTPNotFoundError < HTTPError
     CODE = 404
     def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
-      super(_("Not Found: ") + message, CODE, issue_kind)
+      super(_("Not Found: %{message}") % { message: message }, CODE, issue_kind)
     end
   end
 
   class HTTPNotAuthorizedError < HTTPError
     CODE = 403
     def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
-      super(_("Not Authorized: ") + message, CODE, issue_kind)
+      super(_("Not Authorized: %{message}") % { message: message }, CODE, issue_kind)
     end
   end
 
   class HTTPBadRequestError < HTTPError
     CODE = 400
     def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
-      super(_("Bad Request: ") + message, CODE, issue_kind)
+      super(_("Bad Request: %{message}") % { message: message }, CODE, issue_kind)
     end
   end
 
   class HTTPMethodNotAllowedError < HTTPError
     CODE = 405
     def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
-      super(_("Method Not Allowed: ") + message, CODE, issue_kind)
+      super(_("Method Not Allowed: %{message}") % { message: message }, CODE, issue_kind)
     end
   end
 
   class HTTPUnsupportedMediaTypeError < HTTPError
     CODE = 415
     def initialize(message, issue_kind = Issues::RUNTIME_ERROR)
-      super(_("Unsupported Media Type: ") + message, CODE, issue_kind)
+      super(_("Unsupported Media Type: %{message}") % { message: message }, CODE, issue_kind)
     end
   end
 
@@ -63,7 +63,7 @@ module Puppet::Network::HTTP::Error
     CODE = 500
 
     def initialize(original_error, issue_kind = Issues::RUNTIME_ERROR)
-      super(_("Server Error: ") + original_error.message, CODE, issue_kind)
+      super(_("Server Error: %{message}") % { message: original_error.message }, CODE, issue_kind)
     end
 
     def to_json