puppet 5.3.3-x86-mingw32 → 5.3.4-x86-mingw32

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

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

@@ -38,6 +38,15 @@ class Puppet::Network::HTTP::Factory
     http.read_timeout = Puppet[:http_read_timeout]
     http.open_timeout = Puppet[:http_connect_timeout]
 
+    if Puppet[:sourceaddress]
+      if http.respond_to?(:local_host)
+        Puppet.debug("Using source IP #{Puppet[:sourceaddress]}")
+        http.local_host = Puppet[:sourceaddress]
+      else
+        raise ArgumentError, "Setting 'sourceaddress' is unsupported by this version of Net::HTTP."
+      end
+    end
+
     if Puppet[:http_debug]
       http.set_debug_output($stderr)
     end

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

@@ -23,9 +23,9 @@ class Puppet::Network::HTTP::Rack
       # Send a Status 500 Error on unhandled exceptions.
       response.status = 500
       response['Content-Type'] = 'text/plain'
-      response.write _('Internal Server Error: "%s"') % detail.message
+      response.write _("Internal Server Error: \"%{message}\"") % { message: detail.message }
       # log what happened
-      Puppet.log_exception(detail, _("Puppet Server (Rack): Internal Server Error: Unhandled Exception: \"%s\"") % detail.message)
+      Puppet.log_exception(detail, _("Puppet Server (Rack): Internal Server Error: Unhandled Exception: \"%{message}\"") % { message: detail.message })
     end
     response.finish
   end

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

@@ -17,8 +17,6 @@ class Puppet::Network::HTTP::WEBrick
   def listen(address, port)
     @server = create_server(address, port)
 
-    @server.listeners.each { |l| l.start_immediately = false }
-
     @server.mount('/', Puppet::Network::HTTP::WEBrickREST)
 
     raise _("WEBrick server is already listening") if @listening
@@ -27,7 +25,7 @@ class Puppet::Network::HTTP::WEBrick
       @server.start do |sock|
         timeout = 10.0
         if ! IO.select([sock],nil,nil,timeout)
-          raise _("Client did not send data within %.1f seconds of connecting") % timeout
+          raise _("Client did not send data within %{timeout} seconds of connecting") % { timeout: ("%.1f") % timeout }
         end
         sock.accept
         @server.run(sock)
@@ -101,7 +99,7 @@ class Puppet::Network::HTTP::WEBrick
 
     results[:SSLPrivateKey] = host.key.content
     results[:SSLCertificate] = host.certificate.content
-    results[:SSLStartImmediately] = true
+    results[:SSLStartImmediately] = false
     results[:SSLEnable] = true
     results[:SSLOptions] = OpenSSL::SSL::OP_NO_SSLv2 | OpenSSL::SSL::OP_NO_SSLv3
 

data/lib/puppet/node.rb

@@ -27,10 +27,10 @@ class Puppet::Node
     @name       = data['name']       || (raise ArgumentError, _("No name provided in serialized data"))
     @classes    = data['classes']    || []
     @parameters = data['parameters'] || {}
-    env_name = data['environment']
+    env_name = data['environment'] || @parameters[ENVIRONMENT]
     env_name = env_name.intern unless env_name.nil?
     @environment_name = env_name
-    environment = env_name
+    self.environment = env_name
   end
 
   def self.from_data_hash(data)
@@ -45,10 +45,17 @@ class Puppet::Node
       'environment' => environment.name.to_s,
     }
     result['classes'] = classes unless classes.empty?
-    result['parameters'] = parameters unless parameters.empty?
+    serialized_params = self.serializable_parameters
+    result['parameters'] = serialized_params unless serialized_params.empty?
     result
   end
 
+  def serializable_parameters
+    new_params = parameters.dup
+    new_params.delete(ENVIRONMENT)
+    new_params
+  end
+
   def environment
     if @environment
       @environment
@@ -60,7 +67,7 @@ class Puppet::Node
       else
         # This should not be :current_environment, this is the default
         # for a node when it has not specified its environment
-        # Tt will be used to establish what the current environment is.
+        # it will be used to establish what the current environment is.
         #
         self.environment = Puppet.lookup(:environments).get!(Puppet[:environment])
       end
@@ -78,7 +85,8 @@ class Puppet::Node
 
     # Keep environment_name attribute and parameter in sync if they have been set
     unless @environment.nil?
-      @parameters[ENVIRONMENT] = @environment.name.to_s if @parameters.include?(ENVIRONMENT)
+      # always set the environment parameter. It becomes top scope $environment for a manifest during catalog compilation.
+      @parameters[ENVIRONMENT] = @environment.name.to_s
       self.environment_name = @environment.name if instance_variable_defined?(:@environment_name)
     end
     @environment
@@ -132,7 +140,10 @@ class Puppet::Node
 
     if !@facts.nil?
       @facts.sanitize
+      # facts should never modify the environment parameter
+      orig_param_env = @parameters[ENVIRONMENT]
       merge(@facts.values)
+      @parameters[ENVIRONMENT] = orig_param_env
     end
   end
 
@@ -145,8 +156,16 @@ class Puppet::Node
         @parameters[name] = value
       end
     end
+  end
 
-    @parameters[ENVIRONMENT] ||= self.environment.name.to_s
+  # Add extra facts, such as facts given to lookup on the command line The
+  # extra facts will override existing ones.
+  # @param extra_facts [Hash{String=>Object}] the facts to tadd
+  # @api private
+  def add_extra_facts(extra_facts)
+    @facts.add_extra_values(extra_facts)
+    @parameters.merge!(extra_facts)
+    nil
   end
 
   def add_server_facts(facts)

data/lib/puppet/node/environment.rb

@@ -433,6 +433,20 @@ class Puppet::Node::Environment
     deps
   end
 
+  # Loads module translations for the current environment once for
+  # the lifetime of the environment.
+  def use_text_domain
+    return if Puppet[:disable_i18n]
+
+    if @text_domain.nil?
+      @text_domain = @name
+      Puppet::GettextConfig.reset_text_domain(@text_domain)
+      Puppet::ModuleTranslations.load_from_modulepath(modules)
+    else
+      Puppet::GettextConfig.use_text_domain(@text_domain)
+    end
+  end
+
   # Checks if a reparse is required (cache of files is stale).
   #
   def check_for_reparse