bolt 0.19.1 → 0.20.0

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
-

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,170 +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
-    # Don't try to stop non-existing services (PUP-8167)
-    return if self.status == :absent
-    # 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
-      debug "Could not get status on service #{self.name} #{$!}"
-      return :absent
-    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
-