bolt 0.24.0 → 0.25.0

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

@@ -1,100 +0,0 @@
-Puppet::Type.type(:service).provide :openbsd, :parent => :init do
-
-  desc "Provider for OpenBSD's rc.d daemon control scripts"
-
-  commands :rcctl => '/usr/sbin/rcctl'
-
-  confine :operatingsystem => :openbsd
-  defaultfor :operatingsystem => :openbsd
-  has_feature :flaggable
-
-  def startcmd
-    [command(:rcctl), '-f', :start, @resource[:name]]
-  end
-
-  def stopcmd
-    [command(:rcctl), :stop, @resource[:name]]
-  end
-
-  def restartcmd
-    (@resource[:hasrestart] == :true) && [command(:rcctl), '-f', :restart, @resource[:name]]
-  end
-
-  def statuscmd
-    [command(:rcctl), :check, @resource[:name]]
-  end
-
-  # @api private
-  # When storing the name, take into account not everything has
-  # '_flags', like 'multicast_host' and 'pf'.
-  def self.instances
-    instances = []
-
-    begin
-      execpipe([command(:rcctl), :getall]) do |process|
-        process.each_line do |line|
-          match = /^(.*?)(?:_flags)?=(.*)$/.match(line)
-          attributes_hash = {
-            :name      => match[1],
-            :flags     => match[2],
-            :hasstatus => true,
-            :provider  => :openbsd,
-          }
-
-          instances << new(attributes_hash);
-        end
-      end
-      instances
-    rescue Puppet::ExecutionFailure
-      return nil
-    end
-  end
-
-  def enabled?
-    output = execute([command(:rcctl), "get", @resource[:name], "status"],
-                     :failonfail => false, :combine => false, :squelch => false)
-
-    if output.exitstatus == 1
-      self.debug("Is disabled")
-      return :false
-    else
-      self.debug("Is enabled")
-      return :true
-    end
-  end
-
-  def enable
-    self.debug("Enabling")
-    rcctl(:enable, @resource[:name])
-    if @resource[:flags]
-      rcctl(:set, @resource[:name], :flags, @resource[:flags])
-    end
-  end
-
-  def disable
-    self.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.match(/\(ok\)/)
-  end
-
-  # Uses the wrapper to prevent failure when the service is not running;
-  # rcctl(8) return non-zero in that case.
-  def flags
-    output = execute([command(:rcctl), "get", @resource[:name], "flags"],
-                     :failonfail => false, :combine => false, :squelch => false).chomp
-    self.debug("Flags are: \"#{output}\"")
-    output
-  end
-
-  def flags=(value)
-    self.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?
-  end
-end

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

@@ -1,71 +0,0 @@
-# Gentoo OpenRC
-Puppet::Type.type(:service).provide :openrc, :parent => :base do
-  desc <<-EOT
-    Support for Gentoo's OpenRC initskripts
-
-    Uses rc-update, rc-status and rc-service to manage services.
-
-  EOT
-
-  defaultfor :operatingsystem => :gentoo
-  defaultfor :operatingsystem => :funtoo
-
-  has_command(:rcstatus, '/bin/rc-status') do
-    environment :RC_SVCNAME => nil
-  end
-  commands :rcservice => '/sbin/rc-service'
-  commands :rcupdate  => '/sbin/rc-update'
-
-  self::STATUSLINE = /^\s+(.*?)\s*\[\s*(.*)\s*\]$/
-
-  def enable
-    rcupdate('-C', :add, @resource[:name])
-  end
-
-  def disable
-    rcupdate('-C', :del, @resource[:name])
-  end
-
-  # rc-status -a shows all runlevels and dynamic runlevels which
-  # are not considered as enabled. We have to find out under which
-  # runlevel our service is listed
-  def enabled?
-    enabled = :false
-    rcstatus('-C', '-a').each_line do |line|
-      case line.chomp
-      when /^Runlevel: /
-        enabled = :true
-      when /^\S+/ # caption of a dynamic runlevel
-        enabled = :false
-      when self.class::STATUSLINE
-        return enabled if @resource[:name] == $1
-      end
-    end
-    :false
-  end
-
-  def self.instances
-    instances = []
-    rcservice('-C', '--list').each_line do |line|
-      instances << new(:name => line.chomp)
-    end
-    instances
-  end
-
-  def restartcmd
-    (@resource[:hasrestart] == :true) && [command(:rcservice), @resource[:name], :restart]
-  end
-
-  def startcmd
-    [command(:rcservice), @resource[:name], :start ]
-  end
-
-  def stopcmd
-    [command(:rcservice), @resource[:name], :stop]
-  end
-
-  def statuscmd
-    ((@resource.provider.get(:hasstatus) == true) || (@resource[:hasstatus] == :true)) && [command(:rcservice), @resource[:name], :status]
-  end
-
-end

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

@@ -1,36 +0,0 @@
-Puppet::Type.type(:service).provide :openwrt, :parent => :init, :source => :init do
-  desc <<-EOT
-    Support for OpenWrt flavored init scripts.
-
-    Uses /etc/init.d/service_name enable, disable, and enabled.
-
-  EOT
-
-  defaultfor :operatingsystem => :openwrt
-  confine :operatingsystem => :openwrt
-
-  has_feature :enableable
-
-  def self.defpath
-    ["/etc/init.d"]
-  end
-
-  def enable
-    system(self.initscript, 'enable')
-  end
-
-  def disable
-    system(self.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
-  end
-
-  # Purposely leave blank so we fail back to ps based status detection
-  # As OpenWrt init script do not have status commands
-  def statuscmd
-  end
-
-end

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

@@ -1,51 +0,0 @@
-Puppet::Type.type(:service).provide :rcng, :parent => :bsd do
-  desc <<-EOT
-    RCng service management with rc.d
-  EOT
-
-  defaultfor :operatingsystem => [:netbsd, :cargos]
-  confine :operatingsystem => [:netbsd, :cargos]
-
-  def self.defpath
-    "/etc/rc.d"
-  end
-
-  # if the service file exists in rc.conf.d AND matches an expected pattern
-  # then it's already enabled
-  def enabled?
-    rcfile = File.join(rcconf_dir, @resource[:name])
-    if Puppet::FileSystem.exist?(rcfile)
-      File.open(rcfile).readlines.each do |line|
-        # Now look for something that looks like "service=${service:=YES}" or "service=YES"
-        if line.match(/^\s*#{@resource[:name]}=(?:YES|\${#{@resource[:name]}:=YES})/)
-          return :true
-        end
-      end
-    end
-
-    :false
-  end
-
-  # 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)
-    rcfile = File.join(rcconf_dir, @resource[:name])
-    if Puppet::FileSystem.exist?(rcfile)
-      newcontents = []
-      File.open(rcfile).readlines.each do |line|
-        if line.match(/^\s*#{@resource[:name]}=(NO|\$\{#{@resource[:name]}:NO\})/)
-          line = "#{@resource[:name]}=${#{@resource[:name]}:=YES}"
-        end
-        newcontents.push(line)
-      end
-      Puppet::Util.replace_file(rcfile, 0644) do |f|
-        f.puts newcontents
-      end
-    else
-      Puppet::Util.replace_file(rcfile, 0644) do |f|
-        f.puts "%s=${%s:=YES}\n" % [@resource[:name], @resource[:name]]
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-# Manage Red Hat services.  Start/stop uses /sbin/service and enable/disable uses chkconfig
-
-Puppet::Type.type(:service).provide :redhat, :parent => :init, :source => :init do
-  desc "Red Hat's (and probably many others') form of `init`-style service
-    management. Uses `chkconfig` for service enabling and disabling.
-
-  "
-
-  commands :chkconfig => "/sbin/chkconfig", :service => "/sbin/service"
-
-  defaultfor :osfamily => :redhat
-  defaultfor :osfamily => :suse, :operatingsystemmajrelease => ["10", "11"]
-
-  # Remove the symlinks
-  def disable
-    # The off method operates on run levels 2,3,4 and 5 by default We ensure
-    # all run levels are turned off because the reset method may turn on the
-    # service in run levels 0, 1 and/or 6
-    # We're not using --del here because we want to disable the service only,
-    # 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
-  end
-
-  def enabled?
-    name = @resource[:name]
-
-    begin
-      output = chkconfig name
-    rescue Puppet::ExecutionFailure
-      return :false
-    end
-
-    # For Suse OS family, chkconfig returns 0 even if the service is disabled or non-existent
-    # Therefore, check the output for '<name>  on' (or '<name>  B for boot services)
-    # to see if it is enabled
-    return :false unless Facter.value(:osfamily) != 'Suse' || output =~ /^#{name}\s+(on|B)$/
-
-    :true
-  end
-
-  # Don't support them specifying runlevels; always use the runlevels
-  # in the init scripts.
-  def enable
-      chkconfig("--add", @resource[:name])
-      chkconfig(@resource[:name], :on)
-  rescue Puppet::ExecutionFailure => detail
-    raise Puppet::Error, "Could not enable #{self.name}: #{detail}", detail.backtrace
-  end
-
-  def initscript
-    raise Puppet::Error, "Do not directly call the init script for '#{@resource[:name]}'; use 'service' instead"
-  end
-
-  # use hasstatus=>true when its set for the provider.
-  def statuscmd
-    ((@resource.provider.get(:hasstatus) == true) || (@resource[:hasstatus] == :true)) && [command(:service), @resource[:name], "status"]
-  end
-
-  def restartcmd
-    (@resource[:hasrestart] == :true) && [command(:service), @resource[:name], "restart"]
-  end
-
-  def startcmd
-    [command(:service), @resource[:name], "start"]
-  end
-
-  def stopcmd
-    [command(:service), @resource[:name], "stop"]
-  end
-end

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

@@ -1,112 +0,0 @@
-# Daemontools service management
-#
-# author Brice Figureau <brice-puppet@daysofwonder.com>
-Puppet::Type.type(:service).provide :runit, :parent => :daemontools do
-  desc <<-'EOT'
-    Runit service management.
-
-    This provider manages daemons running supervised by Runit.
-    When detecting the service directory it will check, in order of preference:
-
-    * `/service`
-    * `/etc/service`
-    * `/var/service`
-
-    The daemon directory should be in one of the following locations:
-
-    * `/etc/sv`
-    * `/var/lib/service`
-
-    or this can be overridden in the service resource parameters:
-
-        service { 'myservice':
-          provider => 'runit',
-          path     => '/path/to/daemons',
-        }
-
-    This provider supports out of the box:
-
-    * start/stop
-    * enable/disable
-    * restart
-    * status
-
-
-  EOT
-
-  commands :sv => "/usr/bin/sv"
-
-  class << self
-    # this is necessary to autodetect a valid resource
-    # default path, since there is no standard for such directory.
-    def defpath
-      unless @defpath
-        ["/etc/sv", "/var/lib/service"].each do |path|
-          if Puppet::FileSystem.exist?(path)
-            @defpath = path
-            break
-          end
-        end
-        raise "Could not find the daemon directory (tested [/etc/sv,/var/lib/service])" unless @defpath
-      end
-      @defpath
-    end
-  end
-
-  # find the service dir on this node
-  def servicedir
-    unless @servicedir
-      ["/service", "/etc/service","/var/service"].each do |path|
-        if Puppet::FileSystem.exist?(path)
-          @servicedir = path
-          break
-        end
-      end
-      raise "Could not find service directory" unless @servicedir
-    end
-    @servicedir
-  end
-
-  def status
-    begin
-      output = sv "status", self.daemon
-      return :running if output =~ /^run: /
-    rescue Puppet::ExecutionFailure => detail
-      unless detail.message =~ /(warning: |runsv not running$)/
-        raise Puppet::Error.new( "Could not get status for service #{resource.ref}: #{detail}", detail )
-      end
-    end
-    :stopped
-  end
-
-  def stop
-    sv "stop", self.service
-  end
-
-  def start
-    if enabled? != :true
-        enable
-        # Work around issue #4480
-        # 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 }
-        sleep 5
-    end
-    sv "start", self.service
-  end
-
-  def restart
-    sv "restart", self.service
-  end
-
-  # disable by removing the symlink so that runit
-  # doesn't restart our service behind our back
-  # note that runit doesn't need to perform a stop
-  # before a disable
-  def disable
-    # unlink the daemon symlink to disable it
-    Puppet::FileSystem.unlink(self.service) if Puppet::FileSystem.symlink?(self.service)
-  end
-end
-