bolt 0.24.0 → 0.25.0

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

@@ -1,42 +0,0 @@
-Puppet::Type.type(:service).provide :service do
-  desc "The simplest form of service support."
-
-  def self.instances
-    []
-  end
-
-  # How to restart the process.
-  def restart
-    if @resource[:restart] or restartcmd
-      ucommand(:restart)
-    else
-      self.stop
-      self.start
-    end
-  end
-
-  # There is no default command, which causes other methods to be used
-  def restartcmd
-  end
-
-  # A simple wrapper so execution failures are a bit more informative.
-  def texecute(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
-    nil
-  end
-
-  # Use either a specified command or the default for our provider.
-  def ucommand(type, fof = true)
-    if c = @resource[type]
-      cmd = [c]
-    else
-      cmd = [send("#{type}cmd")].flatten
-    end
-    texecute(type, cmd, fof)
-  end
-end
-

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

@@ -1,169 +0,0 @@
-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.
-
-    Starting a service is effectively equivalent to enabling it, so there is
-    only support for starting and stopping services, which also enables and
-    disables them, respectively.
-
-    By specifying `manifest => "/path/to/service.xml"`, the SMF manifest will
-    be imported if it does not exist.
-
-  EOT
-
-  defaultfor :osfamily => :solaris
-
-  confine :osfamily => :solaris
-
-  commands :adm => "/usr/sbin/svcadm", :svcs => "/usr/bin/svcs"
-  commands :svccfg => "/usr/sbin/svccfg"
-
-  has_feature :refreshable
-
-  def setupservice
-      if resource[:manifest]
-        begin
-          svcs("-l", @resource[:name])
-        rescue Puppet::ExecutionFailure
-          Puppet.notice "Importing #{@resource[:manifest]} for #{@resource[:name]}"
-          svccfg :import, resource[:manifest]
-        end
-      end
-  rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error.new( "Cannot config #{self.name} to enable it: #{detail}", detail )
-  end
-
-  def self.instances
-   svcs("-H", "-o", "state,fmri" ).split("\n").select{|l| l !~ /^legacy_run/ }.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
-  end
-
-  def enable
-    self.start
-  end
-
-  def enabled?
-    case self.status
-    when :running
-      return :true
-    else
-      return :false
-    end
-  end
-
-  def disable
-    self.stop
-  end
-
-  def restartcmd
-    if Puppet::Util::Package.versioncmp(Facter.value(:operatingsystemrelease), '11.2') >= 0
-      [command(:adm), :restart, "-s", @resource[:name]]
-    else
-      # Synchronous restart only supported in Solaris 11.2 and above
-      [command(:adm), :restart, @resource[:name]]
-    end
-  end
-
-  def startcmd
-    self.setupservice
-    case self.status
-    when :maintenance, :degraded
-      [command(:adm), :clear, @resource[:name]]
-    else
-      [command(:adm), :enable, "-rs", @resource[:name]]
-    end
-  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_state should be online, offline, disabled, or uninitialized.
-  # See PUP-5474 for long-term solution to this issue.
-  def wait(*desired_state)
-    Timeout.timeout(60) do
-      loop do
-        states = self.service_states
-        break if desired_state.include?(states[0]) && states[1] == '-'
-        sleep(1)
-      end
-    end
-  rescue Timeout::Error
-    raise Puppet::Error.new("Timed out waiting for #{@resource[:name]} to transition states")
-  end
-
-  def start
-    # Wait for the service to actually start before returning.
-    super
-    self.wait('online')
-  end
-
-  def stop
-    # Wait for the service to actually stop before returning.
-    super
-    self.wait('offline', 'disabled', 'uninitialized')
-  end
-
-  def restart
-    # Wait for the service to actually start before returning.
-    super
-    self.wait('online')
-  end
-
-  # Determine the current and next states of a service.
-  def service_states
-    svcs("-H", "-o", "state,nstate", @resource[:name]).chomp.split
-  end
-
-  def status
-    if @resource[:status]
-      super
-      return
-    end
-
-    begin
-      # get the current state and the next state, and if the next
-      # state is set (i.e. not "-") use it for state comparison
-      states = service_states
-      state = states[1] == "-" ? states[0] : states[1]
-    rescue Puppet::ExecutionFailure
-      # TODO (PUP-8957): Should this be set back to INFO ?
-      debug "Could not get status on service #{self.name} #{$!}"
-      return :stopped
-    end
-
-    case state
-    when "online"
-      #self.warning "matched running #{line.inspect}"
-      return :running
-    when "offline", "disabled", "uninitialized"
-      #self.warning "matched stopped #{line.inspect}"
-      return :stopped
-    when "maintenance"
-      return :maintenance
-    when "degraded"
-      return :degraded
-    when "legacy_run"
-      raise Puppet::Error,
-        "Cannot manage legacy services through SMF"
-    else
-      raise Puppet::Error,
-        "Unmanageable state '#{state}' on service #{self.name}"
-    end
-
-  end
-
-  def stopcmd
-    [command(:adm), :disable, "-s", @resource[:name]]
-  end
-end
-

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

@@ -1,147 +0,0 @@
-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 :operatingsystem => :aix
-  confine :operatingsystem => :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?
-    execute([command(:lsitab), @resource[:name]], {:failonfail => false, :combine => true})
-    $CHILD_STATUS.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.new("Timed out waiting for #{@resource[:name]} to transition states")
-  end
-
-  def start
-    super
-    self.wait(:running)
-  end
-
-  def stop
-    super
-    self.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
-          self.stop
-          self.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
-    self.debug(detail.message)
-    return :stopped
-  end
-
-end
-

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

@@ -1,189 +0,0 @@
-# Manage systemd services using systemctl
-
-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"
-
-  if Facter.value(:osfamily).downcase == 'debian'
-    # With multiple init systems on Debian, it is possible to have
-    # pieces of systemd around (e.g. systemctl) but not really be
-    # using systemd.  We do not do this on other platforms as it can
-    # cause issues when running in a chroot without /run mounted
-    # (PUP-5577)
-    confine :exists => "/run/systemd/system"
-  end
-
-  defaultfor :osfamily => [:archlinux]
-  defaultfor :osfamily => :redhat, :operatingsystemmajrelease => ["7", "8"]
-  defaultfor :osfamily => :redhat, :operatingsystem => :fedora
-  defaultfor :osfamily => :suse
-  defaultfor :osfamily => :coreos
-  defaultfor :operatingsystem => :amazon, :operatingsystemmajrelease => ["2"]
-  defaultfor :operatingsystem => :debian, :operatingsystemmajrelease => ["8", "stretch/sid", "9", "buster/sid"]
-
-  defaultfor :operatingsystem => :ubuntu
-  notdefaultfor :operatingsystem => :ubuntu, :operatingsystemmajrelease => ["10.04", "12.04", "14.04", "14.10"] # These are using upstart
-  defaultfor :operatingsystem => :cumuluslinux, :operatingsystemmajrelease => ["3"]
-
-  def self.instances
-    i = []
-    output = systemctl('list-unit-files', '--type', 'service', '--full', '--all',  '--no-pager')
-    output.scan(/^(\S+)\s+(disabled|enabled|masked|indirect)\s*$/i).each do |m|
-      i << new(:name => m[0])
-    end
-    return i
-  rescue Puppet::ExecutionFailure
-    return []
-  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
-    raise Puppet::Error, "Could not #{action} #{self.name}: #{output}", $!.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].match(/\.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]]
-    @cached_enabled = execute(cmd, :failonfail => false).strip
-  end
-
-  def enabled?
-    output = cached_enabled?
-    code = $CHILD_STATUS.exitstatus
-
-    # 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) && (Facter.value(:osfamily).downcase == 'debian')
-      ret = debian_enabled?
-      return ret if ret
-    end
-
-    return :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?
-    system("/usr/sbin/invoke-rc.d", "--quiet", "--query", @resource[:name], "start")
-    if [104, 106].include?($CHILD_STATUS.exitstatus)
-      return :true
-    elsif [101, 105].include?($CHILD_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
-        return :true
-      else
-        return :false
-      end
-    else
-      return :false
-    end
-  end
-
-  def enable
-    self.unmask
-    systemctl_change_enable(:enable)
-  end
-
-  def mask
-    self.disable
-    systemctl_change_enable(:mask)
-  end
-
-  def unmask
-    systemctl_change_enable(:unmask)
-  end
-
-  def restartcmd
-    [command(:systemctl), "restart", @resource[:name]]
-  end
-
-  def startcmd
-    self.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
-    begin
-      super
-    rescue Puppet::Error => e
-      raise Puppet::Error.new(prepare_error_message(@resource[:name], 'restart', e))
-    end
-  end
-
-  def start
-    begin
-      super
-    rescue Puppet::Error => e
-      raise Puppet::Error.new(prepare_error_message(@resource[:name], 'start', e))
-    end
-  end
-
-  def stop
-    begin
-      super
-    rescue Puppet::Error => e
-      raise Puppet::Error.new(prepare_error_message(@resource[:name], 'stop', e))
-    end
-  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
-