bolt 0.20.0 → 0.20.2

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

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,187 @@
+# 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"
+  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, :operatingsystemmajrelease => ["15.04","15.10","16.04","16.10"]
+  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
+

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

@@ -0,0 +1,359 @@
+Puppet::Type.type(:service).provide :upstart, :parent => :debian do
+  START_ON = /^\s*start\s+on/
+  COMMENTED_START_ON = /^\s*#+\s*start\s+on/
+  MANUAL   = /^\s*manual\s*$/
+
+  desc "Ubuntu service management with `upstart`.
+
+  This provider manages `upstart` jobs on Ubuntu. For `upstart` documentation,
+  see <http://upstart.ubuntu.com/>.
+  "
+
+  confine :any => [
+    Facter.value(:operatingsystem) == 'Ubuntu',
+    (Facter.value(:osfamily) == 'RedHat' and Facter.value(:operatingsystemrelease) =~ /^6\./),
+    (Facter.value(:operatingsystem) == 'Amazon' and Facter.value(:operatingsystemmajrelease) =~ /\d{4}/),
+    Facter.value(:operatingsystem) == 'LinuxMint',
+  ]
+
+  defaultfor :operatingsystem => :ubuntu, :operatingsystemmajrelease => ["10.04", "12.04", "14.04", "14.10"]
+
+  commands :start   => "/sbin/start",
+           :stop    => "/sbin/stop",
+           :restart => "/sbin/restart",
+           :status_exec  => "/sbin/status",
+           :initctl => "/sbin/initctl"
+
+  # upstart developer haven't implemented initctl enable/disable yet:
+  # http://www.linuxplanet.com/linuxplanet/tutorials/7033/2/
+  has_feature :enableable
+
+  def self.instances
+    self.get_services(self.excludes) # Take exclude list from init provider
+  end
+
+  def self.excludes
+    excludes = super
+    if Facter.value(:osfamily) == 'RedHat'
+      # Puppet cannot deal with services that have instances, so we have to
+      # ignore these services using instances on redhat based systems.
+      excludes += %w[serial tty]
+    end
+
+    excludes
+  end
+
+
+  def self.get_services(exclude=[])
+    instances = []
+    execpipe("#{command(:initctl)} list") { |process|
+      process.each_line { |line|
+        # needs special handling of services such as network-interface:
+        # initctl list:
+        # network-interface (lo) start/running
+        # network-interface (eth0) start/running
+        # network-interface-security start/running
+        name = \
+          if matcher = line.match(/^(network-interface)\s\(([^\)]+)\)/)
+            "#{matcher[1]} INTERFACE=#{matcher[2]}"
+          elsif matcher = line.match(/^(network-interface-security)\s\(([^\)]+)\)/)
+            "#{matcher[1]} JOB=#{matcher[2]}"
+          else
+            line.split.first
+          end
+        instances << new(:name => name)
+      }
+    }
+    instances.reject { |instance| exclude.include?(instance.name) }
+  end
+
+  def self.defpath
+    ["/etc/init", "/etc/init.d"]
+  end
+
+  def upstart_version
+    @upstart_version ||= initctl("--version").match(/initctl \(upstart ([^\)]*)\)/)[1]
+  end
+
+  # Where is our override script?
+  def overscript
+    @overscript ||= initscript.gsub(/\.conf$/,".override")
+  end
+
+  def search(name)
+    # Search prefers .conf as that is what upstart uses
+    [".conf", "", ".sh"].each do |suffix|
+      paths.each do |path|
+        service_name = name.match(/^(\S+)/)[1]
+        fqname = File.join(path, service_name + suffix)
+        if Puppet::FileSystem.exist?(fqname)
+          return fqname
+        end
+
+        self.debug("Could not find #{name}#{suffix} in #{path}")
+      end
+    end
+
+    raise Puppet::Error, "Could not find init script or upstart conf file for '#{name}'"
+  end
+
+  def enabled?
+    return super if not is_upstart?
+
+    script_contents = read_script_from(initscript)
+    if version_is_pre_0_6_7
+      enabled_pre_0_6_7?(script_contents)
+    elsif version_is_pre_0_9_0
+      enabled_pre_0_9_0?(script_contents)
+    elsif version_is_post_0_9_0
+      enabled_post_0_9_0?(script_contents, read_override_file)
+    end
+  end
+
+  def enable
+    return super if not is_upstart?
+
+    script_text = read_script_from(initscript)
+    if version_is_pre_0_9_0
+      enable_pre_0_9_0(script_text)
+    else
+      enable_post_0_9_0(script_text, read_override_file)
+    end
+  end
+
+  def disable
+    return super if not is_upstart?
+
+    script_text = read_script_from(initscript)
+    if version_is_pre_0_6_7
+      disable_pre_0_6_7(script_text)
+    elsif version_is_pre_0_9_0
+      disable_pre_0_9_0(script_text)
+    elsif version_is_post_0_9_0
+      disable_post_0_9_0(read_override_file)
+    end
+  end
+
+  def startcmd
+    is_upstart? ? [command(:start), @resource[:name]] : super
+  end
+
+  def stopcmd
+    is_upstart? ? [command(:stop),  @resource[:name]] : super
+  end
+
+  def restartcmd
+    is_upstart? ? (@resource[:hasrestart] == :true) && [command(:restart), @resource[:name]] : super
+  end
+
+  def statuscmd
+    is_upstart? ? nil : super #this is because upstart is broken with its return codes
+  end
+
+  def status
+    if (@resource[:hasstatus] == :false) ||
+        @resource[:status] ||
+        ! is_upstart?
+      return super
+    end
+
+    output = status_exec(@resource[:name].split)
+    if output =~ /start\//
+      return :running
+    else
+      return :stopped
+    end
+  end
+
+private
+  def is_upstart?(script = initscript)
+    Puppet::FileSystem.exist?(script) && script.match(/\/etc\/init\/\S+\.conf/)
+  end
+
+  def version_is_pre_0_6_7
+    Puppet::Util::Package.versioncmp(upstart_version, "0.6.7") == -1
+  end
+
+  def version_is_pre_0_9_0
+    Puppet::Util::Package.versioncmp(upstart_version, "0.9.0") == -1
+  end
+
+  def version_is_post_0_9_0
+    Puppet::Util::Package.versioncmp(upstart_version, "0.9.0") >= 0
+  end
+
+  def enabled_pre_0_6_7?(script_text)
+    # Upstart version < 0.6.7 means no manual stanza.
+    if script_text.match(START_ON)
+      return :true
+    else
+      return :false
+    end
+  end
+
+  def enabled_pre_0_9_0?(script_text)
+    # Upstart version < 0.9.0 means no override files
+    # So we check to see if an uncommented start on or manual stanza is the last one in the file
+    # The last one in the file wins.
+    enabled = :false
+    script_text.each_line do |line|
+      if line.match(START_ON)
+        enabled = :true
+      elsif line.match(MANUAL)
+        enabled = :false
+      end
+    end
+    enabled
+  end
+
+  def enabled_post_0_9_0?(script_text, over_text)
+    # This version has manual stanzas and override files
+    # So we check to see if an uncommented start on or manual stanza is the last one in the
+    # conf file and any override files. The last one in the file wins.
+    enabled = :false
+
+    script_text.each_line do |line|
+      if line.match(START_ON)
+        enabled = :true
+      elsif line.match(MANUAL)
+        enabled = :false
+      end
+    end
+    over_text.each_line do |line|
+      if line.match(START_ON)
+        enabled = :true
+      elsif line.match(MANUAL)
+        enabled = :false
+      end
+    end if over_text
+    enabled
+  end
+
+  def enable_pre_0_9_0(text)
+    # We also need to remove any manual stanzas to ensure that it is enabled
+    text = remove_manual_from(text)
+
+    if enabled_pre_0_9_0?(text) == :false
+      enabled_script =
+        if text.match(COMMENTED_START_ON)
+          uncomment_start_block_in(text)
+        else
+          add_default_start_to(text)
+        end
+    else
+      enabled_script = text
+    end
+
+    write_script_to(initscript, enabled_script)
+  end
+
+  def enable_post_0_9_0(script_text, over_text)
+    over_text = remove_manual_from(over_text)
+
+    if enabled_post_0_9_0?(script_text, over_text) == :false
+      if script_text.match(START_ON)
+        over_text << extract_start_on_block_from(script_text)
+      else
+        over_text << "\nstart on runlevel [2,3,4,5]"
+      end
+    end
+
+    write_script_to(overscript, over_text)
+  end
+
+  def disable_pre_0_6_7(script_text)
+    disabled_script = comment_start_block_in(script_text)
+    write_script_to(initscript, disabled_script)
+  end
+
+  def disable_pre_0_9_0(script_text)
+    write_script_to(initscript, ensure_disabled_with_manual(script_text))
+  end
+
+  def disable_post_0_9_0(over_text)
+    write_script_to(overscript, ensure_disabled_with_manual(over_text))
+  end
+
+  def read_override_file
+    if Puppet::FileSystem.exist?(overscript)
+      read_script_from(overscript)
+    else
+      ""
+    end
+  end
+
+  def uncomment(line)
+    line.gsub(/^(\s*)#+/, '\1')
+  end
+
+  def remove_trailing_comments_from_commented_line_of(line)
+    line.gsub(/^(\s*#+\s*[^#]*).*/, '\1')
+  end
+
+  def remove_trailing_comments_from(line)
+    line.gsub(/^(\s*[^#]*).*/, '\1')
+  end
+
+  def unbalanced_parens_on(line)
+    line.count('(') - line.count(')')
+  end
+
+  def remove_manual_from(text)
+    text.gsub(MANUAL, "")
+  end
+
+  def comment_start_block_in(text)
+    parens = 0
+    text.lines.map do |line|
+      if line.match(START_ON) || parens > 0
+        # If there are more opening parens than closing parens, we need to comment out a multiline 'start on' stanza
+        parens += unbalanced_parens_on(remove_trailing_comments_from(line))
+        "#" + line
+      else
+        line
+      end
+    end.join('')
+  end
+
+  def uncomment_start_block_in(text)
+    parens = 0
+    text.lines.map do |line|
+      if line.match(COMMENTED_START_ON) || parens > 0
+        parens += unbalanced_parens_on(remove_trailing_comments_from_commented_line_of(line))
+        uncomment(line)
+      else
+        line
+      end
+    end.join('')
+  end
+
+  def extract_start_on_block_from(text)
+    parens = 0
+    text.lines.map do |line|
+      if line.match(START_ON) || parens > 0
+        parens += unbalanced_parens_on(remove_trailing_comments_from(line))
+        line
+      end
+    end.join('')
+  end
+
+  def add_default_start_to(text)
+    text + "\nstart on runlevel [2,3,4,5]"
+  end
+
+  def ensure_disabled_with_manual(text)
+    remove_manual_from(text) + "\nmanual"
+  end
+
+  def read_script_from(filename)
+    File.open(filename) do |file|
+      file.read
+    end
+  end
+
+  def write_script_to(file, text)
+    Puppet::Util.replace_file(file, 0644) do |f|
+      f.write(text)
+    end
+  end
+end