bolt 0.0.1 → 0.5.0

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

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

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

@@ -0,0 +1,71 @@
+# 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' to see if it is enabled
+    return :false unless Facter.value(:osfamily) != 'Suse' || output =~ /^#{name}\s+on$/
+
+    :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

@@ -0,0 +1,111 @@
+# 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
+        Puppet.info "Waiting 5 seconds for runsvdir to discover 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

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

@@ -0,0 +1,167 @@
+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]
+        [command(:svcs), "-l", @resource[:name]]
+        if $CHILD_STATUS.exitstatus == 1
+          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
+      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
+