puppet 6.0.10-x64-mingw32 → 6.1.0-x64-mingw32

data/lib/puppet/type/file/source.rb

@@ -320,6 +320,7 @@ module Puppet
       end
     end
 
+
     def chunk_file_from_source
       get_from_source do |response|
         case response.code

data/lib/puppet/type/filebucket.rb

@@ -42,23 +42,19 @@ module Puppet
     end
 
     newparam(:server) do
-      desc "The server providing the remote filebucket service.
+      desc "The server providing the remote filebucket service. Defaults to the
+        value of the `server` setting (that is, the currently configured
+        puppet master server).
 
-        This setting is _only_ consulted if the `path` attribute is set to `false`.
-
-        If this attribute is not specified, the first entry in the `server_list`
-        configuration setting is used, followed by the value of the `server` setting
-        if `server_list` is not set."
+        This setting is _only_ consulted if the `path` attribute is set to `false`."
+      defaultto { Puppet[:server] }
     end
 
     newparam(:port) do
-      desc "The port on which the remote server is listening.
-
-        This setting is _only_ consulted if the `path` attribute is set to `false`.
+      desc "The port on which the remote server is listening. Defaults to the
+        value of the `masterport` setting, which is usually %s." % Puppet[:masterport]
 
-        If this attribute is not specified, the first entry in the `server_list`
-        configuration setting is used, followed by the value of the `masterport`
-        setting if `server_list` is not set."
+      defaultto { Puppet[:masterport] }
     end
 
     newparam(:path) do

data/lib/puppet/type/package.rb

@@ -20,8 +20,8 @@ module Puppet
       requires in order to function, and you must meet those requirements
       to use a given provider.
 
-      You can declare multiple package resources with the same `name` as long
-      as they have unique titles, and specify different providers and commands.
+      You can declare multiple package resources with the same `name`, as long
+      as they specify different providers and have unique titles.
 
       Note that you must use the _title_ to make a reference to a package
       resource; `Package[<NAME>]` is not a synonym for `Package[<TITLE>]` like
@@ -66,8 +66,6 @@ module Puppet
       :methods => [:package_settings_insync?, :package_settings, :package_settings=]
     feature :virtual_packages, "The provider accepts virtual package names for install and uninstall."
 
-    feature :targetable, "The provider accepts a targeted package management command."
-
     ensurable do
       desc <<-EOT
         What state the package should be in. On packaging systems that can
@@ -273,55 +271,24 @@ module Puppet
     providify
     paramclass(:provider).isnamevar
 
-    # Specify a targeted package management command.
-    newparam(:command, :required_features => :targetable) do
-      desc <<-EOT
-        The targeted command to use when managing a package:
-
-          package { 'mysql':
-            provider => gem,
-          }
-
-          package { 'mysql-opt':
-            name     => 'mysql',
-            provider => gem,
-            command  => '/opt/ruby/bin/gem',
-          }
-
-        Each provider defines a package management command; and uses the first
-        instance of the command found in the PATH.
-
-        Providers supporting the targetable feature allow you to specify the
-        absolute path of the package management command; useful when multiple
-        instances of the command are installed, or the command is not in the PATH.
-      EOT
-
-      isnamevar
-      defaultto :default
+    def self.parameters_to_include
+      [:provider]
     end
 
-    # We have more than one namevar, so we need title_patterns.
-    # However, we cheat and set the patterns to map to name only
-    # and completely ignore provider (and command, for targetable providers).
-    # So far, the logic that determines uniqueness appears to just
-    # "Do The Right Thing™" when provider (and command) are explicitly set.
+    # We have more than one namevar, so we need title_patterns. However, we
+    # cheat and set the patterns to map to name only and completely ignore
+    # provider. So far, the logic that determines uniqueness appears to just
+    # "Do The Right Thing™" when the provider is explicitly set by the user.
     #
     # The following resources will be seen as unique by puppet:
     #
     #     # Uniqueness Key: ['mysql', nil]
-    #     package {'mysql': }
-    #
-    #     # Uniqueness Key: ['mysql', 'gem', nil]
-    #     package {'gem-mysql':
-    #       name     => 'mysql,
-    #       provider => gem,
-    #     }
+    #     package{'mysql': }
     #
-    #     # Uniqueness Key: ['mysql', 'gem', '/opt/ruby/bin/gem']
-    #     package {'gem-mysql-opt':
+    #     # Uniqueness Key: ['mysql', 'gem']
+    #     package{'gem-mysql':
     #       name     => 'mysql,
     #       provider => gem
-    #       command  => '/opt/ruby/bin/gem',
     #     }
     #
     # This does not handle the case where providers like 'yum' and 'rpm' should

data/lib/puppet/type/schedule.rb

@@ -220,10 +220,6 @@ module Puppet
 
         See the `periodmatch` attribute for tuning whether to match
         times by their distance apart or by their specific value.
-        
-        > **Tip**: You can use `period => never,` to prevent a resource from being applied
-        in the given `range`. This is useful if you need to create a blackout window to
-        perform sensitive operations without interruption.
       EOT
 
       newvalues(:hourly, :daily, :weekly, :monthly, :never)

data/lib/puppet/type/service.rb

@@ -45,6 +45,8 @@ module Puppet
     feature :maskable, "The provider can 'mask' the service.",
       :methods => [:mask]
 
+    feature :configurable_timeout, "The provider can specify a minumum timeout for syncing service properties"
+
     newproperty(:enable, :required_features => :enableable) do
       desc "Whether a service should be enabled to start at boot.
         This property behaves quite differently depending on the platform;
@@ -237,6 +239,16 @@ module Puppet
       desc "Specify a command to config a service, or a path to a manifest to do so."
     end
 
+    newparam(:timeout, :required_features => :configurable_timeout) do
+      desc "Specify an optional minimum timeout (in seconds) for puppet to wait when syncing service properties"
+      defaultto { provider.class.respond_to?(:default_timeout) ? provider.default_timeout : 10 }
+      validate do |value|
+        if (not value.is_a? Integer) || value < 1
+          raise Puppet::Error.new(_("\"%{value}\" is not a positive integer: the timeout parameter must be specified as a positive integer") % { value: value })
+        end
+      end
+    end
+
     # Basically just a synonym for restarting.  Used to respond
     # to events.
     def refresh

data/lib/puppet/type/user.rb

@@ -558,7 +558,7 @@ module Puppet
     newparam(:auth_membership) do
       desc "Whether specified auths should be considered the **complete list**
         (`inclusive`) or the **minimum list** (`minimum`) of auths the user
-        has."
+        has. This setting is specific to managing Solaris authorizations."
 
       newvalues(:inclusive, :minimum)
 

data/lib/puppet/util/command_line.rb

@@ -64,12 +64,8 @@ module Puppet
       #
       # @return [void]
       def execute
-        require_config = true
-        if @argv.first =~ /help|-h|--help|-V|--version/
-          require_config = false
-        end
         Puppet::Util.exit_on_fail(_("Could not initialize global default settings")) do
-          Puppet.initialize_settings(args, require_config)
+          Puppet.initialize_settings(args)
         end
 
         setpriority(Puppet[:priority])

data/lib/puppet/util/connection.rb

@@ -22,17 +22,15 @@ module Puppet::Util
     # @return [String] the name of the server for use in the request
     def self.determine_server(setting)
       if setting && setting != :server && Puppet.settings.set_by_config?(setting)
-        Puppet.debug _("Selected server from the %{setting} setting: %{server}") % {setting: setting, server: Puppet.settings[setting]}
         Puppet[setting]
       else
         server = Puppet.lookup(:server) do
           if primary_server = Puppet.settings[:server_list][0]
-            #TRANSLATORS 'server_list' is the name of a setting and should not be translated
-            Puppet.debug _("Dynamically-bound server lookup failed; using first entry from the `server_list` setting: %{server}") % {server: primary_server[0]}
+            Puppet.debug "Dynamically-bound server lookup failed; using first entry"
             primary_server[0]
           else
             setting ||= :server
-            Puppet.debug _("Dynamically-bound server lookup failed, falling back to %{setting} setting: %{server}") % {setting: setting, server: Puppet.settings[setting]}
+            Puppet.debug "Dynamically-bound server lookup failed, falling back to #{setting} setting"
             Puppet.settings[setting]
           end
         end
@@ -53,26 +51,19 @@ module Puppet::Util
     def self.determine_port(port_setting, server_setting)
       if (port_setting && port_setting != :masterport && Puppet.settings.set_by_config?(port_setting)) ||
          (server_setting && server_setting != :server && Puppet.settings.set_by_config?(server_setting))
-        Puppet.debug _("Selected port from the %{setting} setting: %{port}") % {setting: port_setting, port: Puppet.settings[port_setting].to_i}
         Puppet.settings[port_setting].to_i
       else
         port = Puppet.lookup(:serverport) do
           if primary_server = Puppet.settings[:server_list][0]
+            Puppet.debug "Dynamically-bound port lookup failed; using first entry"
+
             # Port might not be set, so we want to fallback in that
             # case. We know we don't need to use `setting` here, since
             # the default value of every port setting is `masterport`
-            if primary_server[1]
-              #TRANSLATORS 'server_list' is the name of a setting and should not be translated
-              Puppet.debug _("Dynamically-bound port lookup failed; using first entry from the `server_list` setting: %{port}") % {port: primary_server[1]}
-              primary_server[1]
-            else
-              #TRANSLATORS 'masterport' is the name of a setting and should not be translated
-              Puppet.debug _("Dynamically-bound port lookup failed; falling back to `masterport` setting: %{port}") % {port: Puppet.settings[:masterport]}
-              Puppet.settings[:masterport]
-            end
+            (primary_server[1] || Puppet.settings[:masterport])
           else
             port_setting ||= :masterport
-            Puppet.debug _("Dynamically-bound port lookup failed; falling back to %{setting} setting: %{port}") % {setting: port_setting, port: Puppet.settings[port_setting]}
+            Puppet.debug "Dynamically-bound port lookup failed; falling back to #{port_setting} setting"
             Puppet.settings[port_setting]
           end
         end

data/lib/puppet/util/http_proxy.rb

@@ -182,7 +182,6 @@ module Puppet::Util::HttpProxy
       end
 
       response = proxy.send(:head, current_uri.path, headers)
-      Puppet.debug("HTTP HEAD request to #{current_uri} returned #{response.code} #{response.message}")
 
       if [301, 302, 307].include?(response.code.to_i)
         # handle the redirection
@@ -196,10 +195,10 @@ module Puppet::Util::HttpProxy
         else
           response = proxy.send(method, current_uri.path, headers)
         end
-
-        Puppet.debug("HTTP #{method.to_s.upcase} request to #{current_uri} returned #{response.code} #{response.message}")
       end
 
+      Puppet.debug("HTTP #{method.to_s.upcase} request to #{current_uri} returned #{response.code} #{response.message}")
+
       return response
     end
 

data/lib/puppet/util/log.rb

@@ -60,7 +60,7 @@ class Puppet::Util::Log
   end
 
   def self.close_all
-    @destinations.keys.each { |dest|
+    destinations.keys.each { |dest|
       close(dest)
     }
     #TRANSLATORS "Log.close_all" is a method name and should not be translated
@@ -147,12 +147,7 @@ class Puppet::Util::Log
       Puppet.log_exception(detail)
 
       # If this was our only destination, then add the console back in.
-      if destinations.empty? && dest.intern != :console
-        newdestination(:console)
-      end
-
-      # Re-raise (end exit Puppet) because we could not set up logging correctly.
-      raise detail
+      newdestination(:console) if @destinations.empty? and (dest != :console and dest != "console")
     end
   end
 

data/lib/puppet/util/pidlock.rb

@@ -54,21 +54,7 @@ class Puppet::Util::Pidlock
     begin
       Process.kill(0, lock_pid)
     rescue *errors
-      return @lockfile.unlock
-    end
-
-    # Ensure the process associated with this pid is our process. If
-    # not, we can unlock the lockfile. For now this is only done on
-    # POSIX and Windows platforms (PUP-9247).
-    if Puppet.features.posix?
-      procname = Puppet::Util::Execution.execute(["ps", "-p", lock_pid, "-o", "comm="]).strip
-      args     = Puppet::Util::Execution.execute(["ps", "-p", lock_pid, "-o", "args="]).strip
-      @lockfile.unlock unless procname =~ /ruby/ && args =~ /puppet/ || procname =~ /puppet(-.*)?$/
-    elsif Puppet.features.microsoft_windows?
-      # On Windows, we're checking if the filesystem path name of the running
-      # process is our vendored ruby:
-      exe_path = Puppet::Util::Windows::Process::get_process_image_name_by_pid(lock_pid)
-      @lockfile.unlock unless exe_path =~ /\\bin\\ruby.exe$/
+      @lockfile.unlock
     end
   end
   private :clear_if_stale

data/lib/puppet/util/windows/process.rb

@@ -10,10 +10,6 @@ module Puppet::Util::Windows::Process
   WAIT_INTERVAL = 200
   # https://docs.microsoft.com/en-us/windows/desktop/ProcThread/process-creation-flags
   CREATE_NO_WINDOW = 0x08000000
-  # https://docs.microsoft.com/en-us/windows/desktop/ProcThread/process-security-and-access-rights
-  PROCESS_QUERY_INFORMATION = 0x0400
-  # https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#maximum-path-length-limitation
-  MAX_PATH_LENGTH = 32767
 
   def execute(command, arguments, stdin, stdout, stderr)
     create_args = {
@@ -28,10 +24,12 @@ module Puppet::Util::Windows::Process
     if arguments[:suppress_window]
       create_args[:creation_flags] = CREATE_NO_WINDOW
     end
-    if arguments[:cwd]
-      create_args[:cwd] = arguments[:cwd]
+    cwd = arguments[:cwd]
+    if cwd
+      Dir.chdir(cwd) { Process.create(create_args) }
+    else
+      Process.create(create_args)
     end
-    Process.create(create_args)
   end
   module_function :execute
 
@@ -64,26 +62,6 @@ module Puppet::Util::Windows::Process
   end
   module_function :get_current_process
 
-  def open_process(desired_access, inherit_handle, process_id, &block)
-    phandle = nil
-    inherit = inherit_handle ? FFI::WIN32_TRUE : FFI::WIN32_FALSE
-    begin
-      phandle = OpenProcess(desired_access, inherit, process_id)
-      if phandle == FFI::Pointer::NULL_HANDLE
-        raise Puppet::Util::Windows::Error.new(
-          "OpenProcess(#{desired_access.to_s(8)}, #{inherit}, #{process_id})")
-      end
-
-      yield phandle
-    ensure
-      FFI::WIN32.CloseHandle(phandle) if phandle
-    end
-
-    # phandle has had CloseHandle called against it, so nothing to return
-    nil
-  end
-  module_function :open_process
-
   def open_process_token(handle, desired_access, &block)
     token_handle = nil
     begin
@@ -119,32 +97,6 @@ module Puppet::Util::Windows::Process
   end
   module_function :with_process_token
 
-  def get_process_image_name_by_pid(pid)
-    image_name = ""
-
-     open_process(PROCESS_QUERY_INFORMATION, false, pid) do |phandle|
-
-       FFI::MemoryPointer.new(:dword, 1) do |exe_name_length_ptr|
-        # UTF is 2 bytes/char:
-        max_chars = MAX_PATH_LENGTH + 1
-        exe_name_length_ptr.write_dword(max_chars)
-        FFI::MemoryPointer.new(:wchar, max_chars) do |exe_name_ptr|
-          use_win32_path_format = 0
-          result = QueryFullProcessImageNameW(phandle, use_win32_path_format, exe_name_ptr, exe_name_length_ptr)
-          if result == FFI::WIN32_FALSE
-            raise Puppet::Util::Windows::Error.new(
-              "QueryFullProcessImageNameW(phandle, #{use_win32_path_format}, " +
-              "exe_name_ptr, #{max_chars}")
-          end
-          image_name = exe_name_ptr.read_wide_string(exe_name_length_ptr.read_dword)
-        end
-      end
-    end
-
-    image_name
-  end
-  module_function :get_process_image_name_by_pid
-
   def lookup_privilege_value(name, system_name = '', &block)
     FFI::MemoryPointer.new(LUID.size) do |luid_ptr|
       result = LookupPrivilegeValueW(
@@ -414,16 +366,6 @@ module Puppet::Util::Windows::Process
   attach_function_private :SetEnvironmentVariableW,
     [:lpcwstr, :lpcwstr], :win32_bool
 
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/ms684320(v=vs.85).aspx
-  # HANDLE WINAPI OpenProcess(
-  #   _In_   DWORD DesiredAccess,
-  #   _In_   BOOL InheritHandle,
-  #   _In_   DWORD ProcessId
-  # );
-  ffi_lib :kernel32
-  attach_function_private :OpenProcess,
-    [:dword, :win32_bool, :dword], :handle
-
   # https://msdn.microsoft.com/en-us/library/windows/desktop/aa379295(v=vs.85).aspx
   # BOOL WINAPI OpenProcessToken(
   #   _In_   HANDLE ProcessHandle,
@@ -434,16 +376,6 @@ module Puppet::Util::Windows::Process
   attach_function_private :OpenProcessToken,
     [:handle, :dword, :phandle], :win32_bool
 
-  # https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-queryfullprocessimagenamew
-  # BOOL WINAPI QueryFullProcessImageName(
-  #   _In_   HANDLE hProcess,
-  #   _In_   DWORD dwFlags,
-  #   _Out_  LPWSTR lpExeName,
-  #   _In_   PDWORD lpdwSize,
-  # );
-  ffi_lib :kernel32
-  attach_function_private :QueryFullProcessImageNameW,
-    [:handle, :dword, :lpwstr, :pdword], :win32_bool
 
   # https://msdn.microsoft.com/en-us/library/windows/desktop/aa379261(v=vs.85).aspx
   # typedef struct _LUID {

data/lib/puppet/util/windows/registry.rb

@@ -232,7 +232,7 @@ module Puppet::Util::Windows
         begin
           case type
             when Win32::Registry::REG_SZ, Win32::Registry::REG_EXPAND_SZ
-              result = [ type, sanitize(data_ptr.read_wide_string(string_length)) ]
+              result = [ type, data_ptr.read_wide_string(string_length) ]
             when Win32::Registry::REG_MULTI_SZ
               result = [ type, data_ptr.read_wide_string(string_length).split(/\0/) ]
             when Win32::Registry::REG_BINARY
@@ -312,12 +312,6 @@ module Puppet::Util::Windows
       result
     end
 
-    def sanitize(value)
-      # Replace null bytes with a space
-      value.gsub!("\x00", ' ')
-      value
-    end
-
     ffi_convention :stdcall
 
     # https://msdn.microsoft.com/en-us/library/windows/desktop/ms724862(v=vs.85).aspx