puppet 5.5.22 → 6.0.0

data/lib/puppet/type/resources.rb

@@ -87,12 +87,6 @@ Puppet::Type.newtype(:resources) do
     end
   end
 
-  WINDOWS_SYSTEM_SID_REGEXES =
-      # Administrator, Guest, Domain Admins, Schema Admins, Enterprise Admins.
-      # https://support.microsoft.com/en-us/help/243330/well-known-security-identifiers-in-windows-operating-systems
-      [/S-1-5-21.+-500/, /S-1-5-21.+-501/, /S-1-5-21.+-512/, /S-1-5-21.+-518/,
-       /S-1-5-21.+-519/]
-
   def check(resource)
     @checkmethod ||= "#{self[:name]}_check"
     @hascheck ||= respond_to?(@checkmethod)
@@ -151,12 +145,8 @@ Puppet::Type.newtype(:resources) do
 
     return false if system_users.include?(resource[:name])
     return false if unless_uids && unless_uids.include?(current_uid)
-    if current_uid.is_a?(String)
-      # Windows user; is a system user if any regex matches.
-      WINDOWS_SYSTEM_SID_REGEXES.none? { |regex| current_uid =~ regex }
-    else
-      current_uid > self[:unless_system_user]
-    end
+
+    current_uid > self[:unless_system_user]
   end
 
   def system_users

data/lib/puppet/type/schedule.rb

@@ -46,13 +46,6 @@ module Puppet
           }
 
       This will cause resources to be applied every 30 minutes by default.
-
-      The `statettl` setting on the agent affects the ability of a schedule to
-      determine if a resource has already been checked. If the `statettl` is
-      set lower than the span of the associated schedule resource, then a
-      resource could be checked & applied multiple times in the schedule as
-      the information about when the resource was last checked will have
-      expired from the cache.
       EOT
 
     apply_to_all
@@ -119,6 +112,11 @@ module Puppet
 
           self.fail _("Invalid range %{value}") % { value: value } if range.length != 2
 
+          # Fill out 0s for unspecified minutes and seconds
+          range.each do |time_array|
+            (3 - time_array.length).times { |_| time_array << 0 }
+          end
+
           # Make sure the hours are valid
           [range[0][0], range[1][0]].each do |n|
             raise ArgumentError, _("Invalid hour '%{n}'") % { n: n } if n < 0 or n > 23
@@ -134,100 +132,44 @@ module Puppet
         ret
       end
 
+      def weekday_match?(day)
+        if @resource[:weekday]
+          @resource[:weekday].has_key?(day)
+        else
+          true
+        end
+      end
+
       def match?(previous, now)
         # The lowest-level array is of the hour, minute, second triad
         # then it's an array of two of those, to present the limits
         # then it's an array of those ranges
         @value = [@value] unless @value[0][0].is_a?(Array)
+        @value.any? do |range|
+          limit_start = Time.local(now.year, now.month, now.day, *range[0])
+          limit_end = Time.local(now.year, now.month, now.day, *range[1])
 
-        @value.each do |value|
-          limits = value.collect do |range|
-            ary = [now.year, now.month, now.day, range[0]]
-            if range[1]
-              ary << range[1]
-            else
-              ary << 0
-            end
-
-            if range[2]
-              ary << range[2]
+          if limit_start < limit_end
+            # The whole range is in one day, simple case
+            now.between?(limit_start, limit_end) && weekday_match?(now.wday)
+          else
+            # The range spans days. We have to test against a range starting
+            # today, and a range that started yesterday.
+            today = Date.new(now.year, now.month, now.day)
+            tomorrow = today.next_day
+            yesterday = today.prev_day
+
+            # First check a range starting today
+            if now.between?(limit_start, Time.local(tomorrow.year, tomorrow.month, tomorrow.day, *range[1]))
+              weekday_match?(today.wday)
             else
-              ary << 0
-            end
-
-            time = Time.local(*ary)
-
-            unless time.hour == range[0]
-              self.devfail(
-                _("Incorrectly converted time: %{time}: %{hour} vs %{value}") % { time: time, hour: time.hour, value: range[0] }
-              )
+              # Then check a range starting yesterday
+              now.between?(Time.local(yesterday.year, yesterday.month, yesterday.day, *range[0]),
+                           limit_end) &&
+                weekday_match?(yesterday.wday)
             end
-
-            time
-          end
-
-          unless limits[0] < limits[1]
-            self.info(
-            _("Assuming upper limit should be that time the next day")
-            )
-
-            # Find midnight between the two days. Adding one second
-            # to the end of the day is easier than dealing with dates.
-            ary = limits[0].to_a
-            ary[0] = 59
-            ary[1] = 59
-            ary[2] = 23
-            midnight = Time.local(*ary)+1
-
-            # If it is currently between the range start and midnight
-            # we consider that a successful match.
-            if now.between?(limits[0], midnight)
-              # We have to check the weekday match here as it is special-cased
-              # to support day-spanning ranges.
-              if @resource[:weekday]
-                return false unless @resource[:weekday].has_key?(now.wday)
-              end
-              return true
-            end
-
-            # If we didn't match between the starting time and midnight
-            # we must now move our midnight back 24 hours and try
-            # between the new midnight (24 hours prior) and the
-            # ending time.
-            midnight -= 86400
-
-            # Now we compare the current time between midnight and the
-            # end time.
-            if now.between?(midnight, limits[1])
-              # This case is the reason weekday matching is special cased
-              # in the range parameter. If we match a range that has spanned
-              # past midnight we want to match against the weekday when the range
-              # started, not when it currently is.
-              if @resource[:weekday]
-                return false unless @resource[:weekday].has_key?((now - 86400).wday)
-              end
-              return true
-            end
-
-            # If neither of the above matched then we don't match the
-            # range schedule.
-            return false
-          end
-
-          # Check to see if a weekday parameter was specified and, if so,
-          # do we match it or not. If we fail we can stop here.
-          # This is required because spanning ranges forces us to check
-          # weekday within the range parameter.
-          if @resource[:weekday]
-            return false unless @resource[:weekday].has_key?(now.wday)
           end
-
-          return true if now.between?(*limits)
         end
-
-        # Else, return false, since our current time isn't between
-        # any valid times
-        false
       end
     end
 
@@ -271,10 +213,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)
@@ -389,7 +327,7 @@ module Puppet
       end
 
       def weekday_integer?(value)
-        value.is_a?(Integer) && (0..6).cover?(value)
+        value.is_a?(Integer) && (0..6).include?(value)
       end
 
       def weekday_string?(value)

data/lib/puppet/type/service.rb

@@ -73,19 +73,20 @@ module Puppet
         provider.enabled?
       end
 
-      # This only works on Windows systems.
-      newvalue(:delayed, :event => :service_delayed_start) do
-        provider.delayed_start
-      end
-
+      # This only makes sense on systemd systems. Static services cannot be enabled
+      # or disabled manually.
       def insync?(current)
-        return provider.enabled_insync?(current) if provider.respond_to?(:enabled_insync?)
+        if provider.respond_to?(:cached_enabled?) && provider.cached_enabled? == 'static'
+          Puppet.debug("Unable to enable or disable static service #{@resource[:name]}")
+          return true
+        end
+
         super(current)
       end
 
       validate do |value|
-        if (value == :manual || value == :delayed) && !Puppet.features.microsoft_windows?
-          raise Puppet::Error.new(_("Setting enable to %{value} is only supported on Microsoft Windows.") % { value: value.to_s} )
+        if value == :manual && !Puppet::Util::Platform.windows?
+          raise Puppet::Error.new(_("Setting enable to manual is only supported on Microsoft Windows."))
         end
       end
     end
@@ -222,7 +223,7 @@ module Puppet
       desc "The control variable used to manage services (originally for HP-UX).
         Defaults to the upcased service name plus `START` replacing dots with
         underscores, for those providers that support the `controllable` feature."
-      defaultto { resource.name.tr(".","_").upcase + "_START" if resource.provider.controllable? }
+      defaultto { resource.name.gsub(".","_").upcase + "_START" if resource.provider.controllable? }
     end
 
     newparam :hasrestart do

data/lib/puppet/type/tidy.rb

@@ -338,7 +338,7 @@ Puppet::Type.newtype(:tidy) do
     begin
       Puppet::FileSystem.lstat(path)
     rescue Errno::ENOENT
-      info _("File does not exist")
+      debug _("File does not exist")
       return nil
     rescue Errno::EACCES
       #TRANSLATORS "stat" is a program name and should not be translated

data/lib/puppet/type/user.rb

@@ -184,7 +184,7 @@ module Puppet
       # encoding to support concatenation for display.
       # overrides Puppet::Property#change_to_s
       def change_to_s(currentvalue, newvalue)
-        if newvalue.respond_to?(:force_encoding) && !Encoding.compatible?(currentvalue, newvalue)
+        if newvalue.is_a?(String) && !Encoding.compatible?(currentvalue, newvalue)
           return super(currentvalue, newvalue.dup.force_encoding(currentvalue.encoding))
         end
         super(currentvalue, newvalue)
@@ -409,10 +409,7 @@ module Puppet
         resource at the same time. For instance, Puppet creates a home directory for a managed
         user if `ensure => present` and the user does not exist at the time of the Puppet run.
         If the home directory is then deleted manually, Puppet will not recreate it on the next
-        run.
-
-        Note that on Windows, this manages creation/deletion of the user profile instead of the
-        home directory. The user profile is stored in the `C:\Users\<username>` directory."
+        run."
 
       defaultto false
 
@@ -614,8 +611,7 @@ module Puppet
     end
 
     newparam(:ia_load_module, :required_features => :manages_aix_lam) do
-      desc "The name of the I&A module to use to manage this user.
-        This should be set to `files` if managing local users."
+      desc "The name of the I&A module to use to manage this user."
     end
 
     newproperty(:attributes, :parent => Puppet::Property::KeyValue, :required_features => :manages_aix_lam) do
@@ -666,19 +662,28 @@ module Puppet
             :required_features => :libuser,
             :parent => Puppet::Parameter::Boolean) do
       desc "Forces the management of local accounts when accounts are also
-            being managed by some other NSS. For AIX, refer to the
-            `ia_load_module` parameter."
+            being managed by some other NSS"
       defaultto false
     end
 
     def generate
-      return [] if self[:purge_ssh_keys].empty?
-      find_unmanaged_keys
+      if !self[:purge_ssh_keys].empty?
+        if Puppet::Type.type(:ssh_authorized_key).nil?
+          warning _("Ssh_authorized_key type is not available. Cannot purge SSH keys.")
+        else
+          return find_unmanaged_keys
+        end
+      end
+
+      []
     end
 
     newparam(:purge_ssh_keys) do
       desc "Whether to purge authorized SSH keys for this user if they are not managed
-        with the `ssh_authorized_key` resource type. Allowed values are:
+        with the `ssh_authorized_key` resource type. This parameter is a noop if the
+        ssh_authorized_key type is not available.
+        
+        Allowed values are:
 
         * `false` (default) --- don't purge SSH keys for this user.
         * `true` --- look for keys in the `.ssh/authorized_keys` file in the user's
@@ -719,12 +724,19 @@ module Puppet
         value = test_sym if [:true, :false].include? test_sym
 
         return [] if value == :false
-        home = resource[:home] || Dir.home(resource[:name])
+        home = resource[:home]
+        if value == :true and not home
+          raise ArgumentError, _("purge_ssh_keys can only be true for users with a defined home directory")
+        end
 
         return [ "#{home}/.ssh/authorized_keys" ] if value == :true
         # value is an array - munge each value
         [ value ].flatten.map do |entry|
-          entry.gsub!(/^~\//, "#{home}/")
+          if entry =~ /^~|^%h/ and not home
+            raise ArgumentError, _("purge_ssh_keys value '%{value}' meta character ~ or %{home_placeholder} only allowed for users with a defined home directory") % { value: value, home_placeholder: '%h' }
+          end
+          # make sure frozen value is duplicated by using a gsub, second mutating gsub! is then ok
+          entry = entry.gsub(/^~\//, "#{home}/")
           entry.gsub!(/^%h\//, "#{home}/")
           entry
         end
@@ -771,6 +783,10 @@ module Puppet
     # @return [Array<Puppet::Type::Ssh_authorized_key] a list of resources
     #   representing the found keys
     def unknown_keys_in_file(keyfile)
+      # The ssh_authorized_key type is distributed as a module on the Forge,
+      # so we shouldn't rely on it being available.
+      return [] unless Puppet::Type.type(:ssh_authorized_key)
+
       names = []
       name_index = 0
       # RFC 4716 specifies UTF-8 allowed in public key files per https://www.ietf.org/rfc/rfc4716.txt

data/lib/puppet/util.rb

@@ -22,13 +22,12 @@ module Util
   require 'puppet/util/posix'
   extend Puppet::Util::POSIX
 
-  # Can't use Puppet.features.microsoft_windows? as it may be mocked out in a test.  This can cause test recurring test failures
   require 'puppet/util/windows/process' if Puppet::Util::Platform.windows?
 
   extend Puppet::Util::SymbolicFileMode
 
   def default_env
-    Puppet.features.microsoft_windows? ?
+    Puppet::Util::Platform.windows? ?
       :windows :
       :posix
   end
@@ -272,7 +271,7 @@ module Util
             raise
           end
         else
-          if Puppet.features.microsoft_windows? && File.extname(dest).empty?
+          if Puppet::Util::Platform.windows? && File.extname(dest).empty?
             exts.each do |ext|
               destext = File.expand_path(dest + ext)
               return destext if FileTest.file? destext and FileTest.executable? destext
@@ -322,8 +321,8 @@ module Util
 
     params = { :scheme => 'file' }
 
-    if Puppet.features.microsoft_windows?
-      path = path.tr('\\', '/')
+    if Puppet::Util::Platform.windows?
+      path = path.gsub(/\\/, '/')
 
       if unc = /^\/\/([^\/]+)(\/.+)/.match(path)
         params[:host] = unc[1]
@@ -356,7 +355,7 @@ module Util
     # URI.unescape does, but returns strings in their original encoding
     path = URI.unescape(uri.path.encode(Encoding::UTF_8))
 
-    if Puppet.features.microsoft_windows? and uri.scheme == 'file'
+    if Puppet::Util::Platform.windows? && uri.scheme == 'file'
       if uri.host
         path = "//#{uri.host}" + path # UNC
       else
@@ -479,13 +478,9 @@ module Util
 
   def safe_posix_fork(stdin=$stdin, stdout=$stdout, stderr=$stderr, &block)
     child_pid = Kernel.fork do
-      STDIN.reopen(stdin)
-      STDOUT.reopen(stdout)
-      STDERR.reopen(stderr)
-
-      $stdin = STDIN
-      $stdout = STDOUT
-      $stderr = STDERR
+      $stdin.reopen(stdin)
+      $stdout.reopen(stdout)
+      $stderr.reopen(stderr)
 
       begin
         Dir.foreach('/proc/self/fd') do |f|
@@ -524,44 +519,21 @@ module Util
 
   module_function :thinmark
 
-  PUPPET_STACK_INSERTION_FRAME = /.*puppet_stack\.rb.*in.*`stack'/
-
   # utility method to get the current call stack and format it to a human-readable string (which some IDEs/editors
   # will recognize as links to the line numbers in the trace)
-  def self.pretty_backtrace(backtrace = caller(1), puppetstack = [])
-    format_backtrace_array(backtrace, puppetstack).join("\n")
-  end
-
-  # arguments may be a Ruby stack, with an optional Puppet stack argument,
-  # or just a Puppet stack.
-  # stacks may be an Array of Strings "/foo.rb:0 in `blah'" or
-  # an Array of Arrays that represent a frame: ["/foo.pp", 0]
-  def self.format_backtrace_array(primary_stack, puppetstack = [])
-    primary_stack.flat_map do |frame|
-      frame = format_puppetstack_frame(frame) if frame.is_a?(Array)
-      primary_frame = resolve_stackframe(frame)
-
-      if primary_frame =~ PUPPET_STACK_INSERTION_FRAME && !puppetstack.empty?
-        [resolve_stackframe(format_puppetstack_frame(puppetstack.shift)),
-         primary_frame]
+  def self.pretty_backtrace(backtrace = caller(1))
+    backtrace.collect do |line|
+      _, path, rest = /^(.*):(\d+.*)$/.match(line).to_a
+      # If the path doesn't exist - like in one test, and like could happen in
+      # the world - we should just tolerate it and carry on. --daniel 2012-09-05
+      # Also, if we don't match, just include the whole line.
+      if path
+        path = Pathname(path).realpath rescue path
+        "#{path}:#{rest}"
       else
-        primary_frame
+        line
       end
-    end
-  end
-
-  def self.resolve_stackframe(frame)
-    _, path, rest = /^(.*):(\d+.*)$/.match(frame).to_a
-    if path
-      path = Pathname(path).realpath rescue path
-      "#{path}:#{rest}"
-    else
-      frame
-    end
-  end
-
-  def self.format_puppetstack_frame(file_and_lineno)
-    file_and_lineno.join(':')
+    end.join("\n")
   end
 
   # Replace a file, securely.  This takes a block, and passes it the file
@@ -597,7 +569,7 @@ module Util
 
       mode = symbolic_mode_to_int(normalize_symbolic_mode(default_mode))
     else
-      if Puppet.features.microsoft_windows?
+      if Puppet::Util::Platform.windows?
         mode = DEFAULT_WINDOWS_MODE
       else
         mode = DEFAULT_POSIX_MODE
@@ -610,9 +582,9 @@ module Util
       tempfile = Puppet::FileSystem::Uniquefile.new(Puppet::FileSystem.basename_string(file), Puppet::FileSystem.dir_string(file))
 
       effective_mode =
-      if !Puppet.features.microsoft_windows?
+      if !Puppet::Util::Platform.windows?
         # Grab the current file mode, and fall back to the defaults.
-        
+
         if Puppet::FileSystem.exist?(file)
           stat = Puppet::FileSystem.lstat(file)
           tempfile.chown(stat.uid, stat.gid)
@@ -647,7 +619,7 @@ module Util
 
       tempfile.close
 
-      if Puppet.features.microsoft_windows?
+      if Puppet::Util::Platform.windows?
         # Windows ReplaceFile needs a file to exist, so touch handles this
         if !Puppet::FileSystem.exist?(file)
           Puppet::FileSystem.touch(file)
@@ -660,6 +632,11 @@ module Util
         Puppet::Util::Windows::File.replace_file(FileSystem.path_string(file), tempfile.path)
 
       else
+        # MRI Ruby checks for this and raises an error, while JRuby removes the directory
+        # and replaces it with a file. This makes the our version of replace_file() consistent
+        if Puppet::FileSystem.exist?(file) && Puppet::FileSystem.directory?(file)
+          raise Errno::EISDIR, _("Is a directory: %{directory}") % { directory: file }
+        end
         File.rename(tempfile.path, Puppet::FileSystem.path_string(file))
       end
     ensure
@@ -719,7 +696,6 @@ end
 
 
 require 'puppet/util/errors'
-require 'puppet/util/methodhelper'
 require 'puppet/util/metaid'
 require 'puppet/util/classgen'
 require 'puppet/util/docs'