openvox 8.19.0

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

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+
+require 'timeout'
+
+# Solaris 10 SMF-style services.
+Puppet::Type.type(:service).provide :smf, :parent => :base do
+  desc <<-EOT
+    Support for Sun's new Service Management Framework.
+
+    When managing the enable property, this provider will try to preserve
+    the previous ensure state per the enableable semantics. On Solaris,
+    enabling a service starts it up while disabling a service stops it. Thus,
+    there's a chance for this provider to execute two operations when managing
+    the enable property. For example, if enable is set to true and the ensure
+    state is stopped, this provider will manage the service using two operations:
+    one to enable the service which will start it up, and another to stop the
+    service (without affecting its enabled status).
+
+    By specifying `manifest => "/path/to/service.xml"`, the SMF manifest will
+    be imported if it does not exist.
+  EOT
+
+  defaultfor 'os.family' => :solaris
+
+  confine 'os.family' => :solaris
+
+  commands :adm => "/usr/sbin/svcadm",
+           :svcs => "/usr/bin/svcs",
+           :svccfg => "/usr/sbin/svccfg"
+
+  has_feature :refreshable
+
+  def self.instances
+    service_instances = svcs("-H", "-o", "state,fmri").split("\n")
+
+    # Puppet does not manage services in the legacy_run state, so filter those out.
+    service_instances.reject! { |line| line =~ /^legacy_run/ }
+
+    service_instances.collect! do |line|
+      state, fmri = line.split(/\s+/)
+
+      status =  case state
+                when /online/; :running
+                when /maintenance/; :maintenance
+                when /degraded/; :degraded
+                else :stopped
+                end
+      new({ :name => fmri, :ensure => status })
+    end
+
+    service_instances
+  end
+
+  def initialize(*args)
+    super(*args)
+
+    # This hash contains the properties we need to sync. in our flush method.
+    #
+    # TODO (PUP-9051): Should we use @property_hash here? It seems like
+    # @property_hash should be empty by default and is something we can
+    # control so I think so?
+    @properties_to_sync = {}
+  end
+
+  def service_exists?
+    service_fmri
+    true
+  rescue Puppet::ExecutionFailure
+    false
+  end
+
+  def setup_service
+    return unless @resource[:manifest]
+    return if service_exists?
+
+    Puppet.notice("Importing #{@resource[:manifest]} for #{@resource[:name]}")
+    svccfg(:import, @resource[:manifest])
+  rescue Puppet::ExecutionFailure => detail
+    raise Puppet::Error.new("Cannot config #{@resource[:name]} to enable it: #{detail}", detail)
+  end
+
+  # Returns the service's FMRI. We fail if multiple FMRIs correspond to
+  # @resource[:name].
+  #
+  # If the service does not exist or we fail to get any FMRIs from svcs,
+  # this method will raise a Puppet::Error
+  def service_fmri
+    return @fmri if @fmri
+
+    # `svcs -l` is better to use because we can detect service instances
+    # that have not yet been activated or enabled (i.e. it lets us detect
+    # services that svcadm has not yet touched). `svcs -H -o fmri` is a bit
+    # more limited.
+    lines = svcs("-l", @resource[:name]).chomp.lines.to_a
+    lines.select! { |line| line =~ /^fmri/ }
+    fmris = lines.map! { |line| line.split(' ')[-1].chomp }
+    unless fmris.length == 1
+      raise Puppet::Error, _("Failed to get the FMRI of the %{service} service: The pattern '%{service}' matches multiple FMRIs! These are the FMRIs it matches: %{all_fmris}") % { service: @resource[:name], all_fmris: fmris.join(', ') }
+    end
+
+    @fmri = fmris.first
+  end
+
+  # Returns true if the provider supports incomplete services.
+  def supports_incomplete_services?
+    Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value('os.release.full'), '11.1') >= 0
+  end
+
+  # Returns true if the service is complete. A complete service is a service that
+  # has the general/complete property defined.
+  def complete_service?
+    unless supports_incomplete_services?
+      raise Puppet::Error, _("Cannot query if the %{service} service is complete: The concept of complete/incomplete services was introduced in Solaris 11.1. You are on a Solaris %{release} machine.") % { service: @resource[:name], release: Puppet.runtime[:facter].value('os.release.full') }
+    end
+
+    return @complete_service if @complete_service
+
+    # We need to use the service's FMRI when querying its config. because
+    # general/complete is an instance-specific property.
+    fmri = service_fmri
+
+    # Check if the general/complete property is defined. If it is undefined,
+    # then svccfg will not print anything to the console.
+    property_defn = svccfg("-s", fmri, "listprop", "general/complete").chomp
+    @complete_service = !property_defn.empty?
+  end
+
+  def enable
+    @properties_to_sync[:enable] = true
+  end
+
+  def enabled?
+    return :false unless service_exists?
+
+    _property, _type, value = svccfg("-s", service_fmri, "listprop", "general/enabled").split(' ')
+    value == 'true' ? :true : :false
+  end
+
+  def disable
+    @properties_to_sync[:enable] = false
+  end
+
+  def restartcmd
+    if Puppet::Util::Package.versioncmp(Puppet.runtime[:facter].value('os.release.full'), '11.2') >= 0
+      [command(:adm), :restart, "-s", service_fmri]
+    else
+      # Synchronous restart only supported in Solaris 11.2 and above
+      [command(:adm), :restart, service_fmri]
+    end
+  end
+
+  def service_states
+    # 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", service_fmri).chomp.split(' ')
+
+    {
+      :current => current_state,
+      :next => next_state == "-" ? nil : next_state
+    }
+  end
+
+  # Wait for the service to transition into the specified state before returning.
+  # This is necessary due to the asynchronous nature of SMF services.
+  # desired_states should include only online, offline, disabled, or uninitialized.
+  # See PUP-5474 for long-term solution to this issue.
+  def wait(*desired_states)
+    Timeout.timeout(60) do
+      loop do
+        states = service_states
+        break if desired_states.include?(states[:current]) && states[:next].nil?
+
+        Kernel.sleep(1)
+      end
+    end
+  rescue Timeout::Error
+    raise Puppet::Error, "Timed out waiting for #{@resource[:name]} to transition states"
+  end
+
+  def start
+    @properties_to_sync[:ensure] = :running
+  end
+
+  def stop
+    @properties_to_sync[:ensure] = :stopped
+  end
+
+  def restart
+    # Wait for the service to actually start before returning.
+    super
+    wait('online')
+  end
+
+  def status
+    return super if @resource[:status]
+
+    begin
+      if supports_incomplete_services?
+        unless complete_service?
+          debug _("The %{service} service is incomplete so its status will be reported as :stopped. See `svcs -xv %{fmri}` for more details.") % { service: @resource[:name], fmri: service_fmri }
+
+          return :stopped
+        end
+      end
+
+      # Get the current state and the next state. If there is a next state,
+      # use that for the state comparison.
+      states = service_states
+      state = states[:next] || states[:current]
+    rescue Puppet::ExecutionFailure => e
+      # TODO (PUP-8957): Should this be set back to INFO ?
+      debug "Could not get status on service #{name} #{e}"
+      return :stopped
+    end
+
+    case state
+    when "online"
+      :running
+    when "offline", "disabled", "uninitialized"
+      :stopped
+    when "maintenance"
+      :maintenance
+    when "degraded"
+      :degraded
+    when "legacy_run"
+      raise Puppet::Error,
+            "Cannot manage legacy services through SMF"
+    else
+      raise Puppet::Error,
+            "Unmanageable state '#{state}' on service #{name}"
+    end
+  end
+
+  # Helper that encapsulates the clear + svcadm [enable|disable]
+  # logic in one place. Makes it easy to test things out and also
+  # cleans up flush's code.
+  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', 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
+  # properties are not independent operations like they are in most of our other service
+  # providers.
+  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_ = @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.
+    return if enable_.nil? and ensure_.nil?
+
+    # Set-up our service so that we know it will exist and so we can collect its fmri. Also
+    # 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 = service_fmri
+
+    # Useful constants for operations involving multiple states
+    stopped = %w[offline disabled uninitialized]
+
+    # Get the current state of the service.
+    cur_state = status
+
+    if enable_.nil?
+      # Only ensure needs to be syncd. The -t flag tells svcadm to temporarily
+      # enable/disable the service, where the temporary status is gone upon
+      # reboot. This is exactly what we want, because we do not want to touch
+      # the enable property.
+      if ensure_ == :stopped
+        maybe_clear_service_then_svcadm(cur_state, 'disable', '-st')
+        wait(*stopped)
+      else # ensure == :running
+        maybe_clear_service_then_svcadm(cur_state, 'enable', '-rst')
+        wait('online')
+      end
+
+      return
+    end
+
+    # Here, enable is being syncd. svcadm starts the service if we enable it, or shuts it down if we
+    # disable it. However, we want our service to be in a final state, which is either whatever the
+    # new ensured value is, or what our original state was prior to enabling it.
+    #
+    # NOTE: Even if you try to set the general/enabled property with svccfg, SMF will still
+    # try to start or shut down the service. Plus, setting general/enabled with svccfg does not
+    # enable the service's dependencies, while svcadm handles this correctly.
+    #
+    # NOTE: We're treating :running and :degraded the same. The reason is b/c an SMF managed service
+    # can only enter the :degraded state if it is online. Since disabling the service also shuts it
+    # off, we cannot set it back to the :degraded state. Thus, it is best to lump :running and :degraded
+    # into the same category to maintain a consistent postcondition on the service's final state when
+    # enabling and disabling it.
+    final_state = ensure_ || cur_state
+    final_state = :running if final_state == :degraded
+
+    if enable_
+      maybe_clear_service_then_svcadm(cur_state, 'enable', '-rs')
+    else
+      maybe_clear_service_then_svcadm(cur_state, 'disable', '-s')
+    end
+
+    # We're safe with 'whens' here since self.status already errors on any
+    # unmanageable states.
+    case final_state
+    when :running
+      adm('enable', '-rst', fmri) unless enable_
+      wait('online')
+    when :stopped
+      adm('disable', '-st', fmri) if enable_
+      wait(*stopped)
+    when :maintenance
+      adm('mark', '-I', 'maintenance', fmri)
+      wait('maintenance')
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'timeout'
+
+# AIX System Resource controller (SRC)
+Puppet::Type.type(:service).provide :src, :parent => :base do
+  desc "Support for AIX's System Resource controller.
+
+  Services are started/stopped based on the `stopsrc` and `startsrc`
+  commands, and some services can be refreshed with `refresh` command.
+
+  Enabling and disabling services is not supported, as it requires
+  modifications to `/etc/inittab`. Starting and stopping groups of subsystems
+  is not yet supported.
+  "
+
+  defaultfor 'os.name' => :aix
+  confine 'os.name' => :aix
+
+  optional_commands :stopsrc => "/usr/bin/stopsrc",
+                    :startsrc => "/usr/bin/startsrc",
+                    :refresh => "/usr/bin/refresh",
+                    :lssrc => "/usr/bin/lssrc",
+                    :lsitab => "/usr/sbin/lsitab",
+                    :mkitab => "/usr/sbin/mkitab",
+                    :rmitab => "/usr/sbin/rmitab",
+                    :chitab => "/usr/sbin/chitab"
+
+  has_feature :refreshable
+
+  def self.instances
+    services = lssrc('-S')
+    services.split("\n").reject { |x| x.strip.start_with? '#' }.collect do |line|
+      data = line.split(':')
+      service_name = data[0]
+      new(:name => service_name)
+    end
+  end
+
+  def startcmd
+    [command(:startsrc), "-s", @resource[:name]]
+  end
+
+  def stopcmd
+    [command(:stopsrc), "-s", @resource[:name]]
+  end
+
+  def default_runlevel
+    "2"
+  end
+
+  def default_action
+    "once"
+  end
+
+  def enabled?
+    output = execute([command(:lsitab), @resource[:name]], { :failonfail => false, :combine => true })
+    output.exitstatus == 0 ? :true : :false
+  end
+
+  def enable
+    mkitab("%s:%s:%s:%s" % [@resource[:name], default_runlevel, default_action, startcmd.join(" ")])
+  end
+
+  def disable
+    rmitab(@resource[:name])
+  end
+
+  # Wait for the service to transition into the specified state before returning.
+  # This is necessary due to the asynchronous nature of AIX services.
+  # desired_state should either be :running or :stopped.
+  def wait(desired_state)
+    Timeout.timeout(60) do
+      loop do
+        status = self.status
+        break if status == desired_state.to_sym
+
+        sleep(1)
+      end
+    end
+  rescue Timeout::Error
+    raise Puppet::Error, "Timed out waiting for #{@resource[:name]} to transition states"
+  end
+
+  def start
+    super
+    wait(:running)
+  end
+
+  def stop
+    super
+    wait(:stopped)
+  end
+
+  def restart
+    execute([command(:lssrc), "-Ss", @resource[:name]]).each_line do |line|
+      args = line.split(":")
+
+      next unless args[0] == @resource[:name]
+
+      # Subsystems with the -K flag can get refreshed (HUPed)
+      # While subsystems with -S (signals) must be stopped/started
+      method = args[11]
+      do_refresh = case method
+                   when "-K" then :true
+                   when "-S" then :false
+                   else self.fail("Unknown service communication method #{method}")
+                   end
+
+      begin
+        if do_refresh == :true
+          execute([command(:refresh), "-s", @resource[:name]])
+        else
+          stop
+          start
+        end
+        return :true
+      rescue Puppet::ExecutionFailure => detail
+        raise Puppet::Error.new("Unable to restart service #{@resource[:name]}, error was: #{detail}", detail)
+      end
+    end
+    self.fail("No such service found")
+  rescue Puppet::ExecutionFailure => detail
+    raise Puppet::Error.new("Cannot get status of #{@resource[:name]}, error was: #{detail}", detail)
+  end
+
+  def status
+    execute([command(:lssrc), "-s", @resource[:name]]).each_line do |line|
+      args = line.split
+
+      # This is the header line
+      next unless args[0] == @resource[:name]
+
+      # PID is the 3rd field, but inoperative subsystems
+      # skip this so split doesn't work right
+      state = case args[-1]
+              when "active"      then :running
+              when "inoperative" then :stopped
+              end
+      Puppet.debug("Service #{@resource[:name]} is #{args[-1]}")
+      return state
+    end
+  rescue Puppet::ExecutionFailure => detail
+    debug(detail.message)
+    :stopped
+  end
+end

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

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+# Manage systemd services using systemctl
+
+require_relative '../../../puppet/file_system'
+
+Puppet::Type.type(:service).provide :systemd, :parent => :base do
+  desc "Manages `systemd` services using `systemctl`.
+
+  Because `systemd` defaults to assuming the `.service` unit type, the suffix
+  may be omitted.  Other unit types (such as `.path`) may be managed by
+  providing the proper suffix."
+
+  commands :systemctl => "systemctl"
+
+  confine :true => Puppet::FileSystem.exist?('/proc/1/comm') && Puppet::FileSystem.read('/proc/1/comm').include?('systemd')
+
+  defaultfor 'os.family' => [:archlinux]
+  defaultfor 'os.family' => :redhat
+  notdefaultfor 'os.name' => :redhat, 'os.release.major' => (4..6).to_a # Use the "RedHat" service provider
+  defaultfor 'os.family' => :redhat, 'os.name' => :fedora
+  defaultfor 'os.family' => :suse
+  defaultfor 'os.family' => :coreos
+  defaultfor 'os.family' => :gentoo
+  notdefaultfor 'os.name' => :amazon, 'os.release.major' => %w[2017 2018]
+  defaultfor 'os.name' => :amazon, 'os.release.major' => %w[2 2023]
+  defaultfor 'os.name' => :debian
+  notdefaultfor 'os.name' => :debian, 'os.release.major' => %w[5 6 7] # These are using the "debian" method
+  defaultfor 'os.name' => :LinuxMint
+  notdefaultfor 'os.name' => :LinuxMint, 'os.release.major' => %w[10 11 12 13 14 15 16 17] # These are using upstart
+  defaultfor 'os.name' => :ubuntu
+  notdefaultfor 'os.name' => :ubuntu, 'os.release.major' => ["10.04", "12.04", "14.04", "14.10"] # These are using upstart
+  defaultfor 'os.name' => :cumuluslinux, 'os.release.major' => %w[3 4]
+  defaultfor 'os.name' => :raspbian, 'os.release.major' => %w[12]
+
+  def self.instances
+    i = []
+    output = systemctl('list-unit-files', '--type', 'service', '--full', '--all', '--no-pager')
+    output.scan(/^(\S+)\s+(disabled|enabled|masked|indirect|bad|static)\s*([^-]\S+)?\s*$/i).each do |m|
+      Puppet.debug("#{m[0]} marked as bad by `systemctl`. It is recommended to be further checked.") if m[1] == "bad"
+      i << new(:name => m[0])
+    end
+    i
+  rescue Puppet::ExecutionFailure
+    []
+  end
+
+  # Static services cannot be enabled or disabled manually. Indirect services
+  # should not be enabled or disabled due to limitations in systemd (see
+  # https://github.com/systemd/systemd/issues/6681).
+  def enabled_insync?(current)
+    case cached_enabled?[:output]
+    when 'static'
+      # masking static services is OK, but enabling/disabling them is not
+      if @resource[:enable] == :mask
+        current == @resource[:enable]
+      else
+        Puppet.debug("Unable to enable or disable static service #{@resource[:name]}")
+        true
+      end
+    when 'indirect'
+      Puppet.debug("Service #{@resource[:name]} is in 'indirect' state and cannot be enabled/disabled")
+      true
+    else
+      current == @resource[:enable]
+    end
+  end
+
+  # This helper ensures that the enable state cache is always reset
+  # after a systemctl enable operation. A particular service state is not guaranteed
+  # after such an operation, so the cache must be emptied to prevent inconsistencies
+  # in the provider's believed state of the service and the actual state.
+  # @param action [String,Symbol] One of 'enable', 'disable', 'mask' or 'unmask'
+  def systemctl_change_enable(action)
+    output = systemctl(action, '--', @resource[:name])
+  rescue => e
+    raise Puppet::Error, "Could not #{action} #{name}: #{output}", e.backtrace
+  ensure
+    @cached_enabled = nil
+  end
+
+  def disable
+    systemctl_change_enable(:disable)
+  end
+
+  def get_start_link_count
+    # Start links don't include '.service'. Just search for the service name.
+    if @resource[:name] =~ /\.service/
+      link_name = @resource[:name].split('.')[0]
+    else
+      link_name = @resource[:name]
+    end
+
+    Dir.glob("/etc/rc*.d/S??#{link_name}").length
+  end
+
+  def cached_enabled?
+    return @cached_enabled if @cached_enabled
+
+    cmd = [command(:systemctl), 'is-enabled', '--', @resource[:name]]
+    result = execute(cmd, :failonfail => false)
+    @cached_enabled = { output: result.chomp, exitcode: result.exitstatus }
+  end
+
+  def enabled?
+    output = cached_enabled?[:output]
+    code = cached_enabled?[:exitcode]
+
+    # The masked state is equivalent to the disabled state in terms of
+    # comparison so we only care to check if it is masked if we want to keep
+    # it masked.
+    #
+    # We only return :mask if we're trying to mask the service. This prevents
+    # flapping when simply trying to disable a masked service.
+    return :mask if (@resource[:enable] == :mask) && (output == 'masked')
+
+    # The indirect state indicates that the unit is not enabled.
+    return :false if output == 'indirect'
+    return :true if code == 0
+
+    if output.empty? && (code > 0) && Puppet.runtime[:facter].value('os.family').casecmp('debian').zero?
+      ret = debian_enabled?
+      return ret if ret
+    end
+
+    :false
+  end
+
+  # This method is required for Debian systems due to the way the SysVInit-Systemd
+  # compatibility layer works. When we are trying to manage a service which does not
+  # have a Systemd unit file, we need to go through the old init script to determine
+  # whether it is enabled or not. See PUP-5016 for more details.
+  #
+  def debian_enabled?
+    status = execute(["/usr/sbin/invoke-rc.d", "--quiet", "--query", @resource[:name], "start"], :failonfail => false)
+    if [104, 106].include?(status.exitstatus)
+      :true
+    elsif [101, 105].include?(status.exitstatus)
+      # 101 is action not allowed, which means we have to do the check manually.
+      # 105 is unknown, which generally means the initscript does not support query
+      # The debian policy states that the initscript should support methods of query
+      # For those that do not, perform the checks manually
+      # http://www.debian.org/doc/debian-policy/ch-opersys.html
+      if get_start_link_count >= 4
+        :true
+      else
+        :false
+      end
+    else
+      :false
+    end
+  end
+
+  # Define the daemon_reload? function to check if the unit is requiring to trigger a "systemctl daemon-reload"
+  # If the unit file is flagged with NeedDaemonReload=yes, then a systemd daemon-reload will be run.
+  # If multiple unit files have been updated, the first one flagged will trigger the daemon-reload for all of them.
+  # The others will be then flagged with NeedDaemonReload=no. So the command will run only once in a puppet run.
+  # This function is called only on start & restart unit options.
+  # Reference: (PUP-3483) Systemd provider doesn't scan for changed units
+  def daemon_reload?
+    cmd = [command(:systemctl), 'show', '--property=NeedDaemonReload', '--', @resource[:name]]
+    daemon_reload = execute(cmd, :failonfail => false).strip.split('=').last
+    if daemon_reload == 'yes'
+      daemon_reload_cmd = [command(:systemctl), 'daemon-reload']
+      execute(daemon_reload_cmd, :failonfail => false)
+    end
+  end
+
+  def enable
+    unmask
+    systemctl_change_enable(:enable)
+  end
+
+  def mask
+    disable if exist?
+    systemctl_change_enable(:mask)
+  end
+
+  def exist?
+    result = execute([command(:systemctl), 'cat', '--', @resource[:name]], :failonfail => false)
+    result.exitstatus == 0
+  end
+
+  def unmask
+    systemctl_change_enable(:unmask)
+  end
+
+  def restartcmd
+    [command(:systemctl), "restart", '--', @resource[:name]]
+  end
+
+  def startcmd
+    unmask
+    [command(:systemctl), "start", '--', @resource[:name]]
+  end
+
+  def stopcmd
+    [command(:systemctl), "stop", '--', @resource[:name]]
+  end
+
+  def statuscmd
+    [command(:systemctl), "is-active", '--', @resource[:name]]
+  end
+
+  def restart
+    daemon_reload?
+    super
+  rescue Puppet::Error => e
+    raise Puppet::Error, prepare_error_message(@resource[:name], 'restart', e)
+  end
+
+  def start
+    daemon_reload?
+    super
+  rescue Puppet::Error => e
+    raise Puppet::Error, prepare_error_message(@resource[:name], 'start', e)
+  end
+
+  def stop
+    super
+  rescue Puppet::Error => e
+    raise Puppet::Error, prepare_error_message(@resource[:name], 'stop', e)
+  end
+
+  def prepare_error_message(name, action, exception)
+    error_return = "Systemd #{action} for #{name} failed!\n"
+    journalctl_command = "journalctl -n 50 --since '5 minutes ago' -u #{name} --no-pager"
+    Puppet.debug("Running journalctl command to get logs for systemd #{action} failure: #{journalctl_command}")
+    journalctl_output = execute(journalctl_command)
+    error_return << "journalctl log for #{name}:\n#{journalctl_output}"
+  end
+end