puppet 0.25.5 → 2.6.0

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

@@ -1,76 +1,76 @@
 # 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:
+  desc "Red Hat's (and probably many others) form of ``init``-style service management:
 
-    Uses ``chkconfig`` for service enabling and disabling.
+  Uses ``chkconfig`` for service enabling and disabling.
 
-    "
+  "
 
-    commands :chkconfig => "/sbin/chkconfig", :service => "/sbin/service"
+  commands :chkconfig => "/sbin/chkconfig", :service => "/sbin/service"
 
-    defaultfor :operatingsystem => [:redhat, :fedora, :suse, :centos, :sles, :oel, :ovm]
+  defaultfor :operatingsystem => [:redhat, :fedora, :suse, :centos, :sles, :oel, :ovm]
 
-    def self.defpath
-        superclass.defpath
-    end
-
-    # Remove the symlinks
-    def disable
-        begin
-            output = chkconfig(@resource[:name], :off)
-        rescue Puppet::ExecutionFailure
-            raise Puppet::Error, "Could not disable %s: %s" %
-                [self.name, output]
-        end
-    end
-
-    def enabled?
-        begin
-            output = chkconfig(@resource[:name])
-        rescue Puppet::ExecutionFailure
-            return :false
-        end
-
-        # If it's disabled on SuSE, then it will print output showing "off"
-        # at the end
-        if output =~ /.* off$/
-            return :false
-        end
-
-        return :true
-    end
-
-    # Don't support them specifying runlevels; always use the runlevels
-    # in the init scripts.
-    def enable
-        begin
-            output = chkconfig(@resource[:name], :on)
-        rescue Puppet::ExecutionFailure => detail
-            raise Puppet::Error, "Could not enable %s: %s" %
-                [self.name, detail]
-        end
-    end
+  def self.instances
+    # this exclude list is all from /sbin/service (5.x), but I did not exclude kudzu
+    self.get_services(['/etc/init.d'], ['functions', 'halt', 'killall', 'single', 'linuxconf'])
+  end
 
-    def initscript
-        raise Puppet::Error, "Do not directly call the init script for '%s'; use 'service' instead" % @resource[:name]
-    end
+  def self.defpath
+    superclass.defpath
+  end
 
-    def statuscmd
-        (@resource[:hasstatus] == :true) && [command(:service), @resource[:name], "status"]
-    end
+  # Remove the symlinks
+  def disable
+      output = chkconfig(@resource[:name], :off)
+  rescue Puppet::ExecutionFailure
+      raise Puppet::Error, "Could not disable #{self.name}: #{output}"
+  end
 
-    def restartcmd
-        (@resource[:hasrestart] == :true) && [command(:service), @resource[:name], "restart"]
+  def enabled?
+    begin
+      output = chkconfig(@resource[:name])
+    rescue Puppet::ExecutionFailure
+      return :false
     end
 
-    def startcmd
-        [command(:service), @resource[:name], "start"]
+    # If it's disabled on SuSE, then it will print output showing "off"
+    # at the end
+    if output =~ /.* off$/
+      return :false
     end
 
-    def stopcmd
-        [command(:service), @resource[:name], "stop"]
-    end
+    :true
+  end
+
+  # Don't support them specifying runlevels; always use the runlevels
+  # in the init scripts.
+  def enable
+      output = chkconfig(@resource[:name], :on)
+  rescue Puppet::ExecutionFailure => detail
+      raise Puppet::Error, "Could not enable #{self.name}: #{detail}"
+  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/lib/puppet/provider/service/runit.rb

@@ -2,102 +2,102 @@
 #
 # author Brice Figureau <brice-puppet@daysofwonder.com>
 Puppet::Type.type(:service).provide :runit, :parent => :daemontools do
-    desc "Runit service management.
+  desc "Runit service management.
 
   This provider manages daemons running supervised by Runit.
   It tries to detect the service directory, with by order of preference:
 
-   * /service
-   * /var/service
-   * /etc/service
+  * /service
+  * /var/service
+  * /etc/service
 
   The daemon directory should be placed in a directory that can be
   by default in:
 
-   * /etc/sv
+  * /etc/sv
 
   or this can be overriden in the service resource parameters::
 
-      service {
-       \"myservice\":
-         provider => \"runit\", path => \"/path/to/daemons\";
-      }
+    service {
+      \"myservice\":
+      provider => \"runit\", path => \"/path/to/daemons\";
+    }
 
   This provider supports out of the box:
 
-   * start/stop
-   * enable/disable
-   * restart
-   * status
+  * start/stop
+  * enable/disable
+  * restart
+  * status
 
 
 "
 
-    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(dummy_argument=:work_arround_for_ruby_GC_bug)
-            unless defined?(@defpath) and @defpath
-                ["/etc/sv", "/var/lib/service"].each do |path|
-                    if FileTest.exist?(path)
-                        @defpath = path
-                        break
-                    end
-                end
-                raise "Could not find the daemon directory (tested [/var/lib/service,/etc])" unless @defpath
-            end
-            @defpath
+  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(dummy_argument=:work_arround_for_ruby_GC_bug)
+      unless @defpath
+        ["/etc/sv", "/var/lib/service"].each do |path|
+          if FileTest.exist?(path)
+            @defpath = path
+            break
+          end
         end
+        raise "Could not find the daemon directory (tested [/var/lib/service,/etc])" unless @defpath
+      end
+      @defpath
     end
-
-    # find the service dir on this node
-    def servicedir
-        unless defined?(@servicedir) and @servicedir
-            ["/service", "/etc/service","/var/service"].each do |path|
-                if FileTest.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 %s: %s" % [ resource.ref, detail] )
-            end
+  end
+
+  # find the service dir on this node
+  def servicedir
+    unless @servicedir
+      ["/service", "/etc/service","/var/service"].each do |path|
+        if FileTest.exist?(path)
+          @servicedir = path
+          break
         end
-        return :stopped
-    end
-
-    def stop
-        sv "stop", self.service
+      end
+      raise "Could not find service directory" unless @servicedir
     end
-
-    def start
-        enable unless enabled? == :true
-        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
-        File.unlink(self.service) if FileTest.symlink?(self.service)
+    @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}" )
+      end
     end
+    :stopped
+  end
+
+  def stop
+    sv "stop", self.service
+  end
+
+  def start
+    enable unless enabled? == :true
+    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
+    File.unlink(self.service) if FileTest.symlink?(self.service)
+  end
 end
 

data/lib/puppet/provider/service/smf.rb

@@ -1,107 +1,103 @@
 # Solaris 10 SMF-style services.
 Puppet::Type.type(:service).provide :smf, :parent => :base do
-    desc "Support for Sun's new Service Management Framework.
+  desc "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.
+  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.
+  By specifying manifest => \"/path/to/service.xml\", the SMF manifest will
+  be imported if it does not exist.
 
-    "
+  "
 
-    defaultfor :operatingsystem => :solaris
+  defaultfor :operatingsystem => :solaris
 
-    confine :operatingsystem => :solaris
+  confine :operatingsystem => :solaris
 
-    commands :adm => "/usr/sbin/svcadm", :svcs => "/usr/bin/svcs"
-    commands :svccfg => "/usr/sbin/svccfg"
+  commands :adm => "/usr/sbin/svcadm", :svcs => "/usr/bin/svcs"
+  commands :svccfg => "/usr/sbin/svccfg"
 
-    def setupservice
-        begin
-            if resource[:manifest]
-                [command(:svcs), "-l", @resource[:name]]
-                if $?.exitstatus == 1
-                    Puppet.notice "Importing %s for %s" % [ @resource[:manifest], @resource[:name] ]
-                    svccfg :import, resource[:manifest]
-                end
-            end
-        rescue Puppet::ExecutionFailure => detail
-            raise Puppet::Error.new( "Cannot config %s to enable it: %s" % [ self.service, detail ] )
+  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.service} to enable it: #{detail}" )
+  end
+
+  def enable
+    self.start
+  end
+
+  def enabled?
+    case self.status
+    when :running
+      return :true
+    else
+      return :false
     end
-
-    def enable
-        self.start
+  end
+
+  def disable
+    self.stop
+  end
+
+  def restartcmd
+    [command(:adm), :restart, @resource[:name]]
+  end
+
+  def startcmd
+    self.setupservice
+    case self.status
+    when :stopped
+      [command(:adm), :enable, @resource[:name]]
+    when :maintenance
+      [command(:adm), :clear, @resource[:name]]
     end
+  end
 
-    def enabled?
-        case self.status
-        when :running
-            return :true
-        else
-            return :false
-        end
+  def status
+    if @resource[:status]
+      super
+      return
     end
 
-    def disable
-        self.stop
+    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 = svcs("-H", "-o", "state,nstate", @resource[:name]).chomp.split
+      state = states[1] == "-" ? states[0] : states[1]
+    rescue Puppet::ExecutionFailure
+      info "Could not get status on service #{self.name}"
+      return :stopped
     end
 
-    def restartcmd
-        [command(:adm), :restart, @resource[:name]]
+    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 "legacy_run"
+      raise Puppet::Error,
+        "Cannot manage legacy services through SMF"
+    else
+      raise Puppet::Error,
+        "Unmanageable state '#{state}' on service #{self.name}"
     end
 
-    def startcmd
-        self.setupservice
-        case self.status
-        when :stopped
-            [command(:adm), :enable, @resource[:name]]
-        when :maintenance
-            [command(:adm), :clear, @resource[:name]]
-        end
-    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 = svcs("-H", "-o", "state,nstate", @resource[:name]).chomp.split
-            state = states[1] == "-" ? states[0] : states[1]
-        rescue Puppet::ExecutionFailure
-            info "Could not get status on service %s" % self.name
-            return :stopped
-        end
-
-
-        case state
-        when "online"
-            #self.warning "matched running %s" % line.inspect
-            return :running
-        when "offline", "disabled", "uninitialized"
-            #self.warning "matched stopped %s" % line.inspect
-            return :stopped
-        when "maintenance"
-            return :maintenance
-        when "legacy_run"
-            raise Puppet::Error,
-              "Cannot manage legacy services through SMF"
-        else
-            raise Puppet::Error,
-              "Unmanageable state '%s' on service %s" %
-              [state, self.name]
-        end
+  end
 
-    end
-
-    def stopcmd
-        [command(:adm), :disable, @resource[:name]]
-    end
+  def stopcmd
+    [command(:adm), :disable, @resource[:name]]
+  end
 end