puppet 8.5.0-x86-mingw32 → 8.6.0-x86-mingw32

data/lib/puppet/provider/service/launchd.rb

@@ -84,7 +84,7 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
   #
   # @api private
   def self.launchd_overrides
-    if self.get_os_version < 14
+    if get_os_version < 14
       "/var/db/launchd.db/com.apple.launchd/overrides.plist"
     else
       "/var/db/com.apple.xpc.launchd/disabled.plist"
@@ -107,8 +107,8 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
   # containing the name, provider, path, and status of each service on the
   # system.
   def self.instances
-    jobs = self.jobsearch
-    @job_list ||= self.job_list
+    jobs = jobsearch
+    @job_list ||= job_list
     jobs.keys.collect do |job|
       job_status = @job_list.has_key?(job) ? :running : :stopped
       new(:name => job, :provider => :launchd, :path => jobs[job], :status => job_status)
@@ -135,7 +135,7 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
   #
   # @api private
   def self.make_label_to_path_map(refresh = false)
-    return @label_to_path_map if @label_to_path_map and not refresh
+    return @label_to_path_map if @label_to_path_map and !refresh
 
     @label_to_path_map = {}
     launchd_paths.each do |path|
@@ -165,12 +165,12 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
 
     if label
       if by_label.has_key? label
-        return { label => by_label[label] }
+        { label => by_label[label] }
       else
         # try refreshing the map, in case a plist has been added in the interim
         by_label = make_label_to_path_map(true)
         if by_label.has_key? label
-          return { label => by_label[label] }
+          { label => by_label[label] }
         else
           raise Puppet::Error, "Unable to find launchd plist for job: #{label}"
         end
@@ -187,13 +187,13 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
     @job_list = Hash.new
     begin
       output = launchctl :list
-      raise Puppet::Error.new("launchctl list failed to return any data.") if output.nil?
+      raise Puppet::Error, "launchctl list failed to return any data." if output.nil?
 
       output.split("\n").each do |line|
         @job_list[line.split(/\s/).last] = :running
       end
-    rescue Puppet::ExecutionFailure
-      raise Puppet::Error.new("Unable to determine status of #{resource[:name]}", $!)
+    rescue Puppet::ExecutionFailure => e
+      raise Puppet::Error.new("Unable to determine status of #{resource[:name]}", e)
     end
     @job_list
   end
@@ -212,7 +212,7 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
       Puppet.debug(_("Reading overrides plist, attempt %{i}") % { i: i }) if i > 1
       overrides = read_plist(launchd_overrides)
       break unless overrides.nil?
-      raise Puppet::Error.new(_('Unable to read overrides plist, too many attempts')) if i == 20
+      raise Puppet::Error, _('Unable to read overrides plist, too many attempts') if i == 20
 
       Puppet.info(_('Overrides file could not be read, trying again.'))
       Kernel.sleep(0.1)
@@ -239,7 +239,7 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
     if FileTest.file?(job_path)
       job_plist = self.class.read_plist(job_path)
     else
-      raise Puppet::Error.new("Unable to parse launchd plist at path: #{job_path}")
+      raise Puppet::Error, "Unable to parse launchd plist at path: #{job_path}"
     end
     [job_path, job_plist]
   end
@@ -248,7 +248,7 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
   # status mechanism and fall back to the base provider status method.
   def status
     if @resource && ((@resource[:hasstatus] == :false) || (@resource[:status]))
-      return super
+      super
     elsif @property_hash[:status].nil?
       # property_hash was flushed so the service changed status
       service_name = @resource[:name]
@@ -281,17 +281,17 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
     # always add -w so it always starts the job, it is a noop if it is not needed, this means we do
     # not have to rescan all launchd plists.
     cmds << "-w"
-    if self.enabled? == :false || self.status == :stopped # launchctl won't load disabled jobs
+    if enabled? == :false || status == :stopped # launchctl won't load disabled jobs
       did_enable_job = true
     end
     cmds << job_path
     begin
       execute(cmds)
-    rescue Puppet::ExecutionFailure
-      raise Puppet::Error.new("Unable to start service: #{resource[:name]} at path: #{job_path}", $!)
+    rescue Puppet::ExecutionFailure => e
+      raise Puppet::Error.new("Unable to start service: #{resource[:name]} at path: #{job_path}", e)
     end
     # As load -w clears the Disabled flag, we need to add it in after
-    self.disable if did_enable_job and resource[:enable] == :false
+    disable if did_enable_job and resource[:enable] == :false
   end
 
   def stop
@@ -303,26 +303,26 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
     did_disable_job = false
     cmds = []
     cmds << :launchctl << :unload
-    if self.enabled? == :true # keepalive jobs can't be stopped without disabling
+    if enabled? == :true # keepalive jobs can't be stopped without disabling
       cmds << "-w"
       did_disable_job = true
     end
     cmds << job_path
     begin
       execute(cmds)
-    rescue Puppet::ExecutionFailure
-      raise Puppet::Error.new("Unable to stop service: #{resource[:name]} at path: #{job_path}", $!)
+    rescue Puppet::ExecutionFailure => e
+      raise Puppet::Error.new("Unable to stop service: #{resource[:name]} at path: #{job_path}", e)
     end
     # As unload -w sets the Disabled flag, we need to add it in after
-    self.enable if did_disable_job and resource[:enable] == :true
+    enable if did_disable_job and resource[:enable] == :true
   end
 
   def restart
     Puppet.debug("A restart has been triggered for the #{resource[:name]} service")
     Puppet.debug("Stopping the #{resource[:name]} service")
-    self.stop
+    stop
     Puppet.debug("Starting the #{resource[:name]} service")
-    self.start
+    start
   end
 
   # launchd jobs are enabled by default. They are only disabled if the key

data/lib/puppet/provider/service/openbsd.rb

@@ -47,7 +47,7 @@ Puppet::Type.type(:service).provide :openbsd, :parent => :init do
       end
       instances
     rescue Puppet::ExecutionFailure
-      return nil
+      nil
     end
   end
 
@@ -56,16 +56,16 @@ Puppet::Type.type(:service).provide :openbsd, :parent => :init do
                      :failonfail => false, :combine => false, :squelch => false)
 
     if output.exitstatus == 1
-      self.debug("Is disabled")
-      return :false
+      debug("Is disabled")
+      :false
     else
-      self.debug("Is enabled")
-      return :true
+      debug("Is enabled")
+      :true
     end
   end
 
   def enable
-    self.debug("Enabling")
+    debug("Enabling")
     rcctl(:enable, @resource[:name])
     if @resource[:flags]
       rcctl(:set, @resource[:name], :flags, @resource[:flags])
@@ -73,14 +73,14 @@ Puppet::Type.type(:service).provide :openbsd, :parent => :init do
   end
 
   def disable
-    self.debug("Disabling")
+    debug("Disabling")
     rcctl(:disable, @resource[:name])
   end
 
   def running?
     output = execute([command(:rcctl), "check", @resource[:name]],
                      :failonfail => false, :combine => false, :squelch => false).chomp
-    return true if output =~ /\(ok\)/
+    true if output =~ /\(ok\)/
   end
 
   # Uses the wrapper to prevent failure when the service is not running;
@@ -88,12 +88,12 @@ Puppet::Type.type(:service).provide :openbsd, :parent => :init do
   def flags
     output = execute([command(:rcctl), "get", @resource[:name], "flags"],
                      :failonfail => false, :combine => false, :squelch => false).chomp
-    self.debug("Flags are: \"#{output}\"")
+    debug("Flags are: \"#{output}\"")
     output
   end
 
   def flags=(value)
-    self.debug("Changing flags from #{flags} to #{value}")
+    debug("Changing flags from #{flags} to #{value}")
     rcctl(:set, @resource[:name], :flags, value)
     # If the service is already running, force a restart as the flags have been changed.
     rcctl(:restart, @resource[:name]) if running?

data/lib/puppet/provider/service/openrc.rb

@@ -40,7 +40,7 @@ Puppet::Type.type(:service).provide :openrc, :parent => :base do
       when /^\S+/ # caption of a dynamic runlevel
         enabled = :false
       when self.class::STATUSLINE
-        return enabled if @resource[:name] == $1
+        return enabled if @resource[:name] == Regexp.last_match(1)
       end
     end
     :false

data/lib/puppet/provider/service/openwrt.rb

@@ -18,16 +18,16 @@ Puppet::Type.type(:service).provide :openwrt, :parent => :init, :source => :init
   end
 
   def enable
-    system(self.initscript, 'enable')
+    system(initscript, 'enable')
   end
 
   def disable
-    system(self.initscript, 'disable')
+    system(initscript, 'disable')
   end
 
   def enabled?
     # We can't define the "command" for the init script, so we call system?
-    if system(self.initscript, 'enabled') then return :true else return :false end
+    system(initscript, 'enabled') ? (return :true) : (return :false)
   end
 
   # Purposely leave blank so we fail back to ps based status detection

data/lib/puppet/provider/service/rcng.rb

@@ -31,7 +31,7 @@ Puppet::Type.type(:service).provide :rcng, :parent => :bsd do
   # enable service by creating a service file under rc.conf.d with the
   # proper contents, or by modifying it's contents to to enable the service.
   def enable
-    Dir.mkdir(rcconf_dir) if not Puppet::FileSystem.exist?(rcconf_dir)
+    Dir.mkdir(rcconf_dir) unless Puppet::FileSystem.exist?(rcconf_dir)
     rcfile = File.join(rcconf_dir, @resource[:name])
     if Puppet::FileSystem.exist?(rcfile)
       newcontents = []
@@ -41,11 +41,11 @@ Puppet::Type.type(:service).provide :rcng, :parent => :bsd do
         end
         newcontents.push(line)
       end
-      Puppet::Util.replace_file(rcfile, 0644) do |f|
+      Puppet::Util.replace_file(rcfile, 0o644) do |f|
         f.puts newcontents
       end
     else
-      Puppet::Util.replace_file(rcfile, 0644) do |f|
+      Puppet::Util.replace_file(rcfile, 0o644) do |f|
         f.puts "%s=${%s:=YES}\n" % [@resource[:name], @resource[:name]]
       end
     end

data/lib/puppet/provider/service/redhat.rb

@@ -10,9 +10,9 @@ Puppet::Type.type(:service).provide :redhat, :parent => :init, :source => :init
 
   commands :chkconfig => "/sbin/chkconfig", :service => "/sbin/service"
 
-  defaultfor 'os.name' => :amazon, 'os.release.major' => ["2017", "2018"]
+  defaultfor 'os.name' => :amazon, 'os.release.major' => %w[2017 2018]
   defaultfor 'os.name' => :redhat, 'os.release.major' => (4..6).to_a
-  defaultfor 'os.family' => :suse, 'os.release.major' => ["10", "11"]
+  defaultfor 'os.family' => :suse, 'os.release.major' => %w[10 11]
 
   # Remove the symlinks
   def disable
@@ -23,7 +23,7 @@ Puppet::Type.type(:service).provide :redhat, :parent => :init, :source => :init
     # and --del removes the service from chkconfig management
     chkconfig("--level", "0123456", @resource[:name], :off)
   rescue Puppet::ExecutionFailure => detail
-    raise Puppet::Error, "Could not disable #{self.name}: #{detail}", detail.backtrace
+    raise Puppet::Error, "Could not disable #{name}: #{detail}", detail.backtrace
   end
 
   def enabled?
@@ -49,7 +49,7 @@ Puppet::Type.type(:service).provide :redhat, :parent => :init, :source => :init
     chkconfig("--add", @resource[:name])
     chkconfig(@resource[:name], :on)
   rescue Puppet::ExecutionFailure => detail
-    raise Puppet::Error, "Could not enable #{self.name}: #{detail}", detail.backtrace
+    raise Puppet::Error, "Could not enable #{name}: #{detail}", detail.backtrace
   end
 
   def initscript

data/lib/puppet/provider/service/runit.rb

@@ -65,7 +65,7 @@ Puppet::Type.type(:service).provide :runit, :parent => :daemontools do
 
   def status
     begin
-      output = sv "status", self.daemon
+      output = sv "status", daemon
       return :running if output =~ /^run: /
     rescue Puppet::ExecutionFailure => detail
       unless detail.message =~ /(warning: |runsv not running$)/
@@ -76,7 +76,7 @@ Puppet::Type.type(:service).provide :runit, :parent => :daemontools do
   end
 
   def stop
-    sv "stop", self.service
+    sv "stop", service
   end
 
   def start
@@ -86,14 +86,14 @@ Puppet::Type.type(:service).provide :runit, :parent => :daemontools do
       # runsvdir takes up to 5 seconds to recognize
       # the symlink created by this call to enable
       # TRANSLATORS 'runsvdir' is a linux service name and should not be translated
-      Puppet.info _("Waiting 5 seconds for runsvdir to discover service %{service}") % { service: self.service }
+      Puppet.info _("Waiting 5 seconds for runsvdir to discover service %{service}") % { service: service }
       sleep 5
     end
-    sv "start", self.service
+    sv "start", service
   end
 
   def restart
-    sv "restart", self.service
+    sv "restart", service
   end
 
   # disable by removing the symlink so that runit
@@ -102,6 +102,6 @@ Puppet::Type.type(:service).provide :runit, :parent => :daemontools do
   # before a disable
   def disable
     # unlink the daemon symlink to disable it
-    Puppet::FileSystem.unlink(self.service) if Puppet::FileSystem.symlink?(self.service)
+    Puppet::FileSystem.unlink(service) if Puppet::FileSystem.symlink?(service)
   end
 end

data/lib/puppet/provider/service/service.rb

@@ -13,8 +13,8 @@ Puppet::Type.type(:service).provide :service do
       service_command(:restart)
       nil
     else
-      self.stop
-      self.start
+      stop
+      start
     end
   end
 
@@ -47,11 +47,9 @@ Puppet::Type.type(:service).provide :service do
   #
   # @return [Puppet::Util::Execution::ProcessOutput]
   def service_execute(type, command, fof = true, squelch = false, combine = true)
-    begin
-      execute(command, :failonfail => fof, :override_locale => false, :squelch => squelch, :combine => combine)
-    rescue Puppet::ExecutionFailure => detail
-      @resource.fail Puppet::Error, "Could not #{type} #{@resource.ref}: #{detail}", detail
-    end
+    execute(command, :failonfail => fof, :override_locale => false, :squelch => squelch, :combine => combine)
+  rescue Puppet::ExecutionFailure => detail
+    @resource.fail Puppet::Error, "Could not #{type} #{@resource.ref}: #{detail}", detail
   end
 
   # Use either a specified command or the default for our provider.

data/lib/puppet/provider/service/smf.rb

@@ -63,7 +63,7 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
   end
 
   def service_exists?
-    self.service_fmri
+    service_fmri
     true
   rescue Puppet::ExecutionFailure
     false
@@ -71,7 +71,7 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
 
   def setup_service
     return unless @resource[:manifest]
-    return if self.service_exists?
+    return if service_exists?
 
     Puppet.notice("Importing #{@resource[:manifest]} for #{@resource[:name]}")
     svccfg(:import, @resource[:manifest])
@@ -132,7 +132,7 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
   def enabled?
     return :false unless service_exists?
 
-    _property, _type, value = svccfg("-s", self.service_fmri, "listprop", "general/enabled").split(' ')
+    _property, _type, value = svccfg("-s", service_fmri, "listprop", "general/enabled").split(' ')
     value == 'true' ? :true : :false
   end
 
@@ -142,10 +142,10 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
 
   def restartcmd
     if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value('os.release.full'), '11.2') >= 0
-      [command(:adm), :restart, "-s", self.service_fmri]
+      [command(:adm), :restart, "-s", service_fmri]
     else
       # Synchronous restart only supported in Solaris 11.2 and above
-      [command(:adm), :restart, self.service_fmri]
+      [command(:adm), :restart, service_fmri]
     end
   end
 
@@ -153,7 +153,7 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
     # Gets the current and next state of the service. We have a next state because SMF
     # manages services asynchronously. If there is no 'next' state, svcs will put a '-'
     # to indicate as such.
-    current_state, next_state = svcs("-H", "-o", "state,nstate", self.service_fmri).chomp.split(' ')
+    current_state, next_state = svcs("-H", "-o", "state,nstate", service_fmri).chomp.split(' ')
 
     {
       :current => current_state,
@@ -168,14 +168,14 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
   def wait(*desired_states)
     Timeout.timeout(60) do
       loop do
-        states = self.service_states
+        states = service_states
         break if desired_states.include?(states[:current]) && states[:next].nil?
 
         Kernel.sleep(1)
       end
     end
   rescue Timeout::Error
-    raise Puppet::Error.new("Timed out waiting for #{@resource[:name]} to transition states")
+    raise Puppet::Error, "Timed out waiting for #{@resource[:name]} to transition states"
   end
 
   def start
@@ -189,7 +189,7 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
   def restart
     # Wait for the service to actually start before returning.
     super
-    self.wait('online')
+    wait('online')
   end
 
   def status
@@ -206,29 +206,29 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
 
       # Get the current state and the next state. If there is a next state,
       # use that for the state comparison.
-      states = self.service_states
+      states = service_states
       state = states[:next] || states[:current]
-    rescue Puppet::ExecutionFailure
+    rescue Puppet::ExecutionFailure => e
       # TODO (PUP-8957): Should this be set back to INFO ?
-      debug "Could not get status on service #{self.name} #{$!}"
+      debug "Could not get status on service #{name} #{e}"
       return :stopped
     end
 
     case state
     when "online"
-      return :running
+      :running
     when "offline", "disabled", "uninitialized"
-      return :stopped
+      :stopped
     when "maintenance"
-      return :maintenance
+      :maintenance
     when "degraded"
-      return :degraded
+      :degraded
     when "legacy_run"
       raise Puppet::Error,
             "Cannot manage legacy services through SMF"
     else
       raise Puppet::Error,
-            "Unmanageable state '#{state}' on service #{self.name}"
+            "Unmanageable state '#{state}' on service #{name}"
     end
   end
 
@@ -238,8 +238,8 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
   def maybe_clear_service_then_svcadm(cur_state, subcmd, flags)
     # If the cur_state is maint or degraded, then we need to clear the service
     # before we enable or disable it.
-    adm('clear', self.service_fmri) if [:maintenance, :degraded].include?(cur_state)
-    adm(subcmd, flags, self.service_fmri)
+    adm('clear', service_fmri) if [:maintenance, :degraded].include?(cur_state)
+    adm(subcmd, flags, service_fmri)
   end
 
   # The flush method is necessary for the SMF provider because syncing the enable and ensure
@@ -248,7 +248,8 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
   def flush
     # We append the "_" because ensure is a Ruby keyword, and it is good to keep property
     # variable names consistent with each other.
-    enable_, ensure_ = @properties_to_sync[:enable], @properties_to_sync[:ensure]
+    enable_ = @properties_to_sync[:enable]
+    ensure_ = @properties_to_sync[:ensure]
 
     # All of the relevant properties are in sync., so we do not need to do
     # anything here.
@@ -258,13 +259,13 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
     # simplifies the code. For a nonexistent service, one of enable or ensure will be true
     # here (since we're syncing them), so we can fail early if setup_service fails.
     setup_service
-    fmri = self.service_fmri
+    fmri = service_fmri
 
     # Useful constants for operations involving multiple states
-    stopped = ['offline', 'disabled', 'uninitialized']
+    stopped = %w[offline disabled uninitialized]
 
     # Get the current state of the service.
-    cur_state = self.status
+    cur_state = status
 
     if enable_.nil?
       # Only ensure needs to be syncd. The -t flag tells svcadm to temporarily
@@ -272,10 +273,10 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
       # reboot. This is exactly what we want, because we do not want to touch
       # the enable property.
       if ensure_ == :stopped
-        self.maybe_clear_service_then_svcadm(cur_state, 'disable', '-st')
+        maybe_clear_service_then_svcadm(cur_state, 'disable', '-st')
         wait(*stopped)
       else # ensure == :running
-        self.maybe_clear_service_then_svcadm(cur_state, 'enable', '-rst')
+        maybe_clear_service_then_svcadm(cur_state, 'enable', '-rst')
         wait('online')
       end
 
@@ -299,9 +300,9 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
     final_state = :running if final_state == :degraded
 
     if enable_
-      self.maybe_clear_service_then_svcadm(cur_state, 'enable', '-rs')
+      maybe_clear_service_then_svcadm(cur_state, 'enable', '-rs')
     else
-      self.maybe_clear_service_then_svcadm(cur_state, 'disable', '-s')
+      maybe_clear_service_then_svcadm(cur_state, 'disable', '-s')
     end
 
     # We're safe with 'whens' here since self.status already errors on any

data/lib/puppet/provider/service/src.rb

@@ -79,17 +79,17 @@ Puppet::Type.type(:service).provide :src, :parent => :base do
       end
     end
   rescue Timeout::Error
-    raise Puppet::Error.new("Timed out waiting for #{@resource[:name]} to transition states")
+    raise Puppet::Error, "Timed out waiting for #{@resource[:name]} to transition states"
   end
 
   def start
     super
-    self.wait(:running)
+    wait(:running)
   end
 
   def stop
     super
-    self.wait(:stopped)
+    wait(:stopped)
   end
 
   def restart
@@ -111,8 +111,8 @@ Puppet::Type.type(:service).provide :src, :parent => :base do
         if do_refresh == :true
           execute([command(:refresh), "-s", @resource[:name]])
         else
-          self.stop
-          self.start
+          stop
+          start
         end
         return :true
       rescue Puppet::ExecutionFailure => detail
@@ -141,7 +141,7 @@ Puppet::Type.type(:service).provide :src, :parent => :base do
       return state
     end
   rescue Puppet::ExecutionFailure => detail
-    self.debug(detail.message)
-    return :stopped
+    debug(detail.message)
+    :stopped
   end
 end