bolt 0.24.0 → 0.25.0

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

@@ -1,134 +0,0 @@
-Puppet::Type.type(:service).provide :base, :parent => :service do
-  desc "The simplest form of Unix service support.
-
-  You have to specify enough about your service for this to work; the
-  minimum you can specify is a binary for starting the process, and this
-  same binary will be searched for in the process table to stop the
-  service.  As with `init`-style services, it is preferable to specify start,
-  stop, and status commands.
-
-  "
-
-  commands :kill => "kill"
-
-  # get the proper 'ps' invocation for the platform
-  # ported from the facter 2.x implementation, since facter 3.x
-  # is dropping the fact (for which this was the only use)
-  def getps
-    case Facter.value(:operatingsystem)
-    when 'OpenWrt'
-      'ps www'
-    when 'FreeBSD', 'NetBSD', 'OpenBSD', 'Darwin', 'DragonFly'
-      'ps auxwww'
-    else
-      'ps -ef'
-    end
-  end
-  private :getps
-
-  # Get the process ID for a running process. Requires the 'pattern'
-  # parameter.
-  def getpid
-    @resource.fail "Either stop/status commands or a pattern must be specified" unless @resource[:pattern]
-    regex = Regexp.new(@resource[:pattern])
-    ps = getps
-
-    self.debug "Executing '#{ps}'"
-    table = Puppet::Util::Execution.execute(ps)
-
-    # The output of the PS command can be a mashup of several different
-    # encodings depending on which processes are running and what
-    # arbitrary data has been used to set their name in the process table.
-    #
-    # First, try a polite conversion to in order to match the UTF-8 encoding
-    # of our regular expression.
-    table = Puppet::Util::CharacterEncoding.convert_to_utf_8(table)
-    # If that fails, force to UTF-8 and then scrub as most uses are scanning
-    # for ACII-compatible program names.
-    table.force_encoding(Encoding::UTF_8) unless table.encoding == Encoding::UTF_8
-    table = table.scrub unless table.valid_encoding?
-
-    table.each_line { |line|
-      if regex.match(line)
-        self.debug "Process matched: #{line}"
-        ary = line.sub(/^[[:space:]]+/u, '').split(/[[:space:]]+/u)
-        return ary[1]
-      end
-    }
-
-    nil
-  end
-  private :getpid
-
-  # Check if the process is running.  Prefer the 'status' parameter,
-  # then 'statuscmd' method, then look in the process table.  We give
-  # the object the option to not return a status command, which might
-  # happen if, for instance, it has an init script (and thus responds to
-  # 'statuscmd') but does not have 'hasstatus' enabled.
-  def status
-    if @resource[:status] or statuscmd
-      # Don't fail when the exit status is not 0.
-      ucommand(:status, false)
-
-      # Explicitly calling exitstatus to facilitate testing
-      if $CHILD_STATUS.exitstatus == 0
-        return :running
-      else
-        return :stopped
-      end
-    elsif pid = getpid
-      self.debug "PID is #{pid}"
-      return :running
-    else
-      return :stopped
-    end
-  end
-
-  # There is no default command, which causes other methods to be used
-  def statuscmd
-  end
-
-  # Run the 'start' parameter command, or the specified 'startcmd'.
-  def start
-    ucommand(:start)
-  end
-
-  # The command used to start.  Generated if the 'binary' argument
-  # is passed.
-  def startcmd
-    if @resource[:binary]
-      return @resource[:binary]
-    else
-      raise Puppet::Error,
-        "Services must specify a start command or a binary"
-    end
-  end
-
-  # Stop the service.  If a 'stop' parameter is specified, it
-  # takes precedence; otherwise checks if the object responds to
-  # a 'stopcmd' method, and if so runs that; otherwise, looks
-  # for the process in the process table.
-  # This method will generally not be overridden by submodules.
-  def stop
-    if @resource[:stop] or stopcmd
-      ucommand(:stop)
-    else
-      pid = getpid
-      unless pid
-        self.info _("%{name} is not running") % { name: self.name }
-        return false
-      end
-      begin
-        output = kill pid
-      rescue Puppet::ExecutionFailure
-        @resource.fail Puppet::Error, "Could not kill #{self.name}, PID #{pid}: #{output}", $!
-      end
-      return true
-    end
-  end
-
-  # There is no default command, which causes other methods to be used
-  def stopcmd
-  end
-end
-

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

@@ -1,51 +0,0 @@
-Puppet::Type.type(:service).provide :bsd, :parent => :init do
-  desc <<-EOT
-    Generic BSD form of `init`-style service management with `rc.d`.
-
-    Uses `rc.conf.d` for service enabling and disabling.
-  EOT
-
-  confine :operatingsystem => [:freebsd, :dragonfly]
-
-  def rcconf_dir
-    '/etc/rc.conf.d'
-  end
-
-  def self.defpath
-    superclass.defpath
-  end
-
-  # remove service file from rc.conf.d to disable it
-  def disable
-    rcfile = File.join(rcconf_dir, @resource[:name])
-    File.delete(rcfile) if Puppet::FileSystem.exist?(rcfile)
-  end
-
-  # if the service file exists in rc.conf.d then it's already enabled
-  def enabled?
-    rcfile = File.join(rcconf_dir, @resource[:name])
-    return :true if Puppet::FileSystem.exist?(rcfile)
-
-    :false
-  end
-
-  # enable service by creating a service file under rc.conf.d with the
-  # proper contents
-  def enable
-    Dir.mkdir(rcconf_dir) if not Puppet::FileSystem.exist?(rcconf_dir)
-    rcfile = File.join(rcconf_dir, @resource[:name])
-    File.open(rcfile, File::WRONLY | File::APPEND | File::CREAT, 0644) { |f|
-      f << "%s_enable=\"YES\"\n" % @resource[:name]
-    }
-  end
-
-  # Override stop/start commands to use one<cmd>'s and the avoid race condition
-  # where provider tries to stop/start the service before it is enabled
-  def startcmd
-    [self.initscript, :onestart]
-  end
-
-  def stopcmd
-    [self.initscript, :onestop]
-  end
-end

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

@@ -1,194 +0,0 @@
-# Daemontools service management
-#
-# author Brice Figureau <brice-puppet@daysofwonder.com>
-Puppet::Type.type(:service).provide :daemontools, :parent => :base do
-  desc <<-'EOT'
-    Daemontools service management.
-
-    This provider manages daemons supervised by D.J. Bernstein daemontools.
-    When detecting the service directory it will check, in order of preference:
-
-    * `/service`
-    * `/etc/service`
-    * `/var/lib/svscan`
-
-    The daemon directory should be in one of the following locations:
-
-    * `/var/lib/service`
-    * `/etc`
-
-    ...or this can be overridden in the resource's attributes:
-
-        service { 'myservice':
-          provider => 'daemontools',
-          path     => '/path/to/daemons',
-        }
-
-    This provider supports out of the box:
-
-    * start/stop (mapped to enable/disable)
-    * enable/disable
-    * restart
-    * status
-
-    If a service has `ensure => "running"`, it will link /path/to/daemon to
-    /path/to/service, which will automatically enable the service.
-
-    If a service has `ensure => "stopped"`, it will only shut down the service, not
-    remove the `/path/to/service` link.
-
-  EOT
-
-  commands :svc  => "/usr/bin/svc", :svstat => "/usr/bin/svstat"
-
-  class << self
-    attr_writer :defpath
-
-    # Determine the daemon path.
-    def defpath
-      unless @defpath
-        ["/var/lib/service", "/etc"].each do |path|
-          if Puppet::FileSystem.exist?(path)
-            @defpath = path
-            break
-          end
-        end
-        raise "Could not find the daemon directory (tested [/var/lib/service,/etc])" unless @defpath
-      end
-      @defpath
-    end
-  end
-
-  attr_writer :servicedir
-
-  # returns all providers for all existing services in @defpath
-  # ie enabled or not
-  def self.instances
-    path = self.defpath
-    unless FileTest.directory?(path)
-      Puppet.notice "Service path #{path} does not exist"
-      return
-    end
-
-    # reject entries that aren't either a directory
-    # or don't contain a run file
-    Dir.entries(path).reject { |e|
-      fullpath = File.join(path, e)
-      e =~ /^\./ or ! FileTest.directory?(fullpath) or ! Puppet::FileSystem.exist?(File.join(fullpath,"run"))
-    }.collect do |name|
-      new(:name => name, :path => path)
-    end
-  end
-
-  # returns the daemon dir on this node
-  def self.daemondir
-    self.defpath
-  end
-
-  # find the service dir on this node
-  def servicedir
-    unless @servicedir
-      ["/service", "/etc/service","/var/lib/svscan"].each do |path|
-        if Puppet::FileSystem.exist?(path)
-          @servicedir = path
-          break
-        end
-      end
-      raise "Could not find service directory" unless @servicedir
-    end
-    @servicedir
-  end
-
-  # returns the full path of this service when enabled
-  # (ie in the service directory)
-  def service
-    File.join(self.servicedir, resource[:name])
-  end
-
-  # returns the full path to the current daemon directory
-  # note that this path can be overridden in the resource
-  # definition
-  def daemon
-    File.join(resource[:path], resource[:name])
-  end
-
-  def status
-    begin
-      output = svstat self.service
-      if output =~ /:\s+up \(/
-        return :running
-      end
-    rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error.new( "Could not get status for service #{resource.ref}: #{detail}", detail)
-    end
-    :stopped
-  end
-
-  def setupservice
-      if resource[:manifest]
-        Puppet.notice "Configuring #{resource[:name]}"
-        command = [ resource[:manifest], resource[:name] ]
-        #texecute("setupservice", command)
-        system("#{command}")
-      end
-  rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error.new( "Cannot config #{self.service} to enable it: #{detail}", detail)
-  end
-
-  def enabled?
-    case self.status
-    when :running
-      # obviously if the daemon is running then it is enabled
-      return :true
-    else
-      # the service is enabled if it is linked
-      return Puppet::FileSystem.symlink?(self.service) ? :true : :false
-    end
-  end
-
-  def enable
-    if ! FileTest.directory?(self.daemon)
-      Puppet.notice "No daemon dir, calling setupservice for #{resource[:name]}"
-      self.setupservice
-    end
-    if self.daemon
-      if ! Puppet::FileSystem.symlink?(self.service)
-        Puppet.notice "Enabling #{self.service}: linking #{self.daemon} -> #{self.service}"
-        Puppet::FileSystem.symlink(self.daemon, self.service)
-      end
-    end
-rescue Puppet::ExecutionFailure
-    raise Puppet::Error.new( "No daemon directory found for #{self.service}", $!)
-  end
-
-  def disable
-    begin
-      if ! FileTest.directory?(self.daemon)
-        Puppet.notice "No daemon dir, calling setupservice for #{resource[:name]}"
-        self.setupservice
-      end
-      if self.daemon
-        if Puppet::FileSystem.symlink?(self.service)
-          Puppet.notice "Disabling #{self.service}: removing link #{self.daemon} -> #{self.service}"
-          Puppet::FileSystem.unlink(self.service)
-        end
-      end
-    rescue Puppet::ExecutionFailure
-      raise Puppet::Error.new( "No daemon directory found for #{self.service}", $!)
-    end
-    self.stop
-  end
-
-  def restart
-    svc "-t", self.service
-  end
-
-  def start
-    enable unless enabled? == :true
-    svc "-u", self.service
-  end
-
-  def stop
-    svc "-d", self.service
-  end
-end

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

@@ -1,75 +0,0 @@
-# Manage debian services.  Start/stop is the same as InitSvc, but enable/disable
-# is special.
-Puppet::Type.type(:service).provide :debian, :parent => :init do
-  desc <<-EOT
-    Debian's form of `init`-style management.
-
-    The only differences from `init` are support for enabling and disabling
-    services via `update-rc.d` and the ability to determine enabled status via
-    `invoke-rc.d`.
-
-  EOT
-
-  commands :update_rc => "/usr/sbin/update-rc.d"
-  # note this isn't being used as a command until
-  # https://projects.puppetlabs.com/issues/2538
-  # is resolved.
-  commands :invoke_rc => "/usr/sbin/invoke-rc.d"
-  commands :service => "/usr/sbin/service"
-
-  defaultfor :operatingsystem => :cumuluslinux, :operatingsystemmajrelease => ['1','2']
-  defaultfor :operatingsystem => :debian, :operatingsystemmajrelease => ['5','6','7']
-  defaultfor :operatingsystem => :devuan
-
-  # Remove the symlinks
-  def disable
-    if `dpkg --compare-versions $(dpkg-query -W --showformat '${Version}' sysv-rc) ge 2.88 ; echo $?`.to_i == 0
-      update_rc @resource[:name], "disable"
-    else
-      update_rc "-f", @resource[:name], "remove"
-      update_rc @resource[:name], "stop", "00", "1", "2", "3", "4", "5", "6", "."
-    end
-  end
-
-  def enabled?
-    # TODO: Replace system call when Puppet::Util::Execution.execute gives us a way
-    # to determine exit status.  https://projects.puppetlabs.com/issues/2538
-    system("/usr/sbin/invoke-rc.d", "--quiet", "--query", @resource[:name], "start")
-
-    # 104 is the exit status when you query start an enabled service.
-    # 106 is the exit status when the policy layer supplies a fallback action
-    # See x-man-page://invoke-rc.d
-    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 get_start_link_count
-    Dir.glob("/etc/rc*.d/S??#{@resource[:name]}").length
-  end
-
-  def enable
-    update_rc "-f", @resource[:name], "remove"
-    update_rc @resource[:name], "defaults"
-  end
-
-  def statuscmd
-      # /usr/sbin/service provides an abstraction layer which is able to query services
-      # independent of the init system used.
-      # See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=775795
-    (@resource[:hasstatus] == :true) && [command(:service), @resource[:name], "status"]
-  end
-end