puppet 0.9.2 → 0.13.0

data/lib/puppet/type/schedule.rb

@@ -0,0 +1,341 @@
+module Puppet
+    newtype(:schedule) do
+        @doc = "Defined schedules for Puppet.  The important thing to understand
+            about how schedules are currently implemented in Puppet is that they
+            can only be used to stop an element from being applied, they never
+            guarantee that it is applied.
+            
+            Every time Puppet applies its configuration, it will collect the
+            list of elements whose schedule does not eliminate them from
+            running right then, but there is currently no system in place to
+            guarantee that a given element runs at a given time.  If you
+            specify a very  restrictive schedule and Puppet happens to run at a
+            time within that schedule, then the elements will get applied;
+            otherwise, that work may never get done.
+            
+            Thus, it behooves you to use wider scheduling (e.g., over a couple of
+            hours) combined with periods and repetitions.  For instance, if you
+            wanted to restrict certain elements to only running once, between
+            the hours of two and 4 AM, then you would use this schedule::
+                
+                schedule { maint:
+                    range => \"2 - 4\",
+                    period => daily,
+                    repeat => 1
+                }
+
+            With this schedule, the first time that Puppet runs between 2 and 4 AM,
+            all elements with this schedule will get applied, but they won't
+            get applied again between 2 and 4 because they will have already
+            run once that day, and they won't get applied outside that schedule
+            because they will be outside the scheduled range.
+            
+            Puppet automatically creates a schedule for each valid period with the
+            same name as that period (e.g., hourly and daily).  Additionally,
+            a schedule named *puppet* is created and used as the default,
+            with the following attributes::
+
+                schedule { puppet:
+                    period => hourly,
+                    repeat => 2
+                }
+
+            This will cause elements to be applied every 30 minutes by default.
+            "
+
+        @states = []
+
+        newparam(:name) do
+            desc "The name of the schedule.  This name is used to retrieve the
+                schedule when assigning it to an object::
+                    
+                    schedule { daily:
+                        period => daily,
+                        range => [2, 4]
+                    }
+
+                    exec { \"/usr/bin/apt-get update\":
+                        schedule => daily
+                    }
+                
+                "
+            isnamevar
+        end
+
+        newparam(:range) do
+            desc "The earliest and latest that an element can be applied.  This
+                is always a range within a 24 hour period, and hours must be
+                specified in numbers between 0 and 23, inclusive.  Minutes and
+                seconds can be provided, using the normal colon as a separator.
+                For instance::
+
+                    schedule { maintenance:
+                        range => \"1:30 - 4:30\"
+                    }
+                
+                This is mostly useful for restricting certain elements to being
+                applied in maintenance windows or during off-peak hours."
+
+            # This is lame; states all use arrays as values, but parameters don't.
+            # That's going to hurt eventually.
+            validate do |values|
+                values = [values] unless values.is_a?(Array)
+                values.each { |value|
+                    unless  value.is_a?(String) and
+                            value =~ /\d+(:\d+){0,2}\s*-\s*\d+(:\d+){0,2}/
+                        self.fail "Invalid range value '%s'" % value
+                    end
+                }
+            end
+
+            munge do |values|
+                values = [values] unless values.is_a?(Array)
+                ret = []
+
+                values.each { |value|
+                    range = []
+                    # Split each range value into a hour, minute, second triad
+                    value.split(/\s*-\s*/).each { |val|
+                        # Add the values as an array.
+                        range << val.split(":").collect { |n| n.to_i }
+                    }
+
+                    if range.length != 2
+                        self.fail "Invalid range %s" % value
+                    end
+
+                    if range[0][0] > range[1][0]
+                        self.fail(("Invalid range %s; " % value) +
+                            "ranges cannot span days."
+                        )
+                    end
+                    ret << range
+                }
+
+                # Now our array of arrays
+                ret
+            end
+
+            def match?(previous, now)
+                # The lowest-level array is of the hour, minute, second triad
+                # then it's an array of two of those, to present the limits
+                # then it's array of those ranges
+                unless @value[0][0].is_a?(Array)
+                    @value = [@value]
+                end
+
+                @value.each do |value|
+                    limits = value.collect do |range|
+                        ary = [now.year, now.month, now.day, range[0]]
+                        if range[1]
+                            ary << range[1]
+                        else
+                            ary << now.min
+                        end
+
+                        if range[2]
+                            ary << range[2]
+                        else
+                            ary << now.sec
+                        end
+
+                        time = Time.local(*ary)
+
+                        unless time.hour == range[0]
+                            self.devfail(
+                                "Incorrectly converted time: %s: %s vs %s" %
+                                    [time, time.hour, range[0]]
+                            )
+                        end
+
+                        time
+                    end
+
+                    unless limits[0] < limits[1]
+                        self.info(
+                        "Assuming upper limit should be that time the next day"
+                        )
+
+                        ary = limits[1].to_a
+                        ary[3] += 1
+                        limits[1] = Time.local(*ary)
+                            
+                        #self.devfail("Lower limit is above higher limit: %s" %
+                        #    limits.inspect
+                        #)
+                    end
+
+                    #self.info limits.inspect
+                    #self.notice now
+                    return now.between?(*limits)
+                end
+
+                # Else, return false, since our current time isn't between
+                # any valid times
+                return false
+            end
+        end
+
+        newparam(:periodmatch) do
+            desc "Whether periods should be matched by number (e.g., the two times
+                are in the same hour) or by distance (e.g., the two times are
+                60 minutes apart). *number*/**distance**"
+
+            newvalues(:number, :distance)
+
+            defaultto :distance
+        end
+
+        newparam(:period) do
+            desc "The period of repetition for an element.  Choose from among
+                a fixed list of *hourly*, *daily*, *weekly*, and *monthly*.
+                The default is for an element to get applied every time that
+                Puppet runs, whatever that period is.
+
+                Note that the period defines how often a given element will get
+                applied but not when; if you would like to restrict the hours
+                that a given element can be applied (e.g., only at night during
+                a maintenance window) then use the ``range`` attribute.
+
+                If the provided periods are not sufficient, you can provide a
+                value to the *repeat* attribute, which will cause Puppet to
+                schedule the affected elements evenly in the period the
+                specified number of times.  Take this schedule::
+
+                    schedule { veryoften:
+                        period => hourly,
+                        repeat => 6
+                    }
+
+                This can cause Puppet to apply that element up to every 10 minutes.
+
+                At the moment, Puppet cannot guarantee that level of
+                repetition; that is, it can run up to every 10 minutes, but
+                internal factors might prevent it from actually running that
+                often (e.g., long-running Puppet runs will squash conflictingly
+                scheduled runs).
+                
+                See the ``periodmatch`` attribute for tuning whether to match
+                times by their distance apart or by their specific value."
+
+            newvalues(:hourly, :daily, :weekly, :monthly)
+
+            @@scale = {
+                :hourly => 3600,
+                :daily => 86400,
+                :weekly => 604800,
+                :monthly => 2592000
+            }
+            @@methods = {
+                :hourly => :hour,
+                :daily => :day,
+                :monthly => :month,
+                :weekly => proc do |prev, now|
+                    prev.strftime("%U") == now.strftime("%U")
+                end
+            }
+
+            def match?(previous, now)
+                value = self.value
+                case @parent[:periodmatch]
+                when :number
+                    method = @@methods[value]
+                    if method.is_a?(Proc)
+                        return method.call(previous, now)
+                    else
+                        # We negate it, because if they're equal we don't run
+                        val = now.send(method) != previous.send(method)
+                        return val
+                    end
+                when :distance
+                    scale = @@scale[value]
+
+                    # If the number of seconds between the two times is greater
+                    # than the unit of time, we match.  We divide the scale
+                    # by the repeat, so that we'll repeat that often within
+                    # the scale.
+                    return (now.to_i - previous.to_i) >= (scale / @parent[:repeat])
+                end
+            end
+        end
+
+        newparam(:repeat) do
+            desc "How often the application gets repeated in a given period.
+                Defaults to 1."
+
+            defaultto 1
+
+            validate do |value|
+                unless value.is_a?(Integer) or value =~ /^\d+$/
+                    raise Puppet::Error,
+                        "Repeat must be a number"
+                end
+
+                # This implicitly assumes that 'periodmatch' is distance -- that
+                # is, if there's no value, we assume it's a valid value.
+                return unless @parent[:periodmatch]
+
+                if value != 1 and @parent[:periodmatch] != :distance
+                    raise Puppet::Error,
+                        "Repeat must be 1 unless periodmatch is 'distance', not '%s'" %
+                            @parent[:periodmatch]
+                end
+            end
+
+            munge do |value|
+                unless value.is_a?(Integer)
+                    value = Integer(value)
+                end
+
+                value
+            end
+
+            def match?(previous, now)
+                true
+            end
+        end
+
+        def self.mkdefaultschedules
+            Puppet.info "Creating default schedules"
+            # Create our default schedule
+            self.create(
+                :name => "puppet",
+                :period => :hourly,
+                :repeat => "2"
+            )
+
+            # And then one for every period
+            @parameters.find { |p| p.name == :period }.values.each { |value|
+                self.create(
+                    :name => value.to_s,
+                    :period => value
+                )
+            }
+        end
+
+        def match?(previous = nil, now = nil)
+
+            # If we've got a value, then convert it to a Time instance
+            if previous
+                previous = Time.at(previous)
+            end
+
+            now ||= Time.now
+
+            # Pull them in order
+            self.class.allattrs.each { |param|
+                if @parameters.include?(param) and
+                    @parameters[param].respond_to?(:match?)
+                    #self.notice "Trying to match %s" % param
+                    return false unless @parameters[param].match?(previous, now)
+                end
+            }
+
+            # If we haven't returned false, then return true; in other words,
+            # any provided schedules need to all match
+            return true
+        end
+    end
+end
+
+# $Id: schedule.rb 848 2006-01-24 06:01:58Z luke $

data/lib/puppet/type/service.rb

@@ -5,58 +5,68 @@
 # which is why they have a search path for initscripts and such
 
 module Puppet
-    class State
-        # Handle whether the service is started at boot time.
-        class ServiceEnabled < State
-            @doc = "Whether a service should be enabled to start at boot.
-                **true**/*false*/*runlevel*"
-            @name = :enabled
 
-            def retrieve
-                unless @parent.respond_to?(:enabled?)
-                    raise Puppet::Error, "Service %s does not support enabling"
-                end
-                @is = @parent.enabled?
-            end
-
-            def shouldprocess(should)
-                @runlevel = nil
-                case should
-                when true: return :enabled
-                when false: return :disabled
-                when /^\d+$/:
-                    @runlevel = should
-                    return :enabled
-                else
-                    raise Puppet::Error, "Invalid 'enabled' value %s" % should
-                end
-            end
-
-            def sync
-                case self.should
-                when :enabled
-                    unless @parent.respond_to?(:enable)
-                        raise Puppet::Error, "Service %s does not support enabling"
-                    end
-                    @parent.enable(@runlevel)
-                    return :service_enabled
-                when :disabled
-                    unless @parent.respond_to?(:disable)
-                        raise Puppet::Error,
-                            "Service %s does not support disabling"
-                    end
-                    @parent.disable
-                    return :service_disabled
-                end
-            end
-        end
+    newtype(:service) do
+        @doc = "Manage running services.  Service support unfortunately varies
+            widely by platform -- some platforms have very little if any
+            concept of a running service, and some have a very codified and
+            powerful concept.  Puppet's service support will generally be able
+            to make up for any inherent shortcomings (e.g., if there is no
+            'status' command, then Puppet will look in the process table for a
+            command matching the service name), but the more information you
+            can provide the better behaviour you will get.  Or, you can just
+            use a platform that has very good service support."
+        
+        attr_reader :stat
+
+#        newstate(:enabled) do
+#            desc "Whether a service should be enabled to start at boot.
+#                **true**/*false*/*runlevel*"
+#
+#            def retrieve
+#                unless @parent.respond_to?(:enabled?)
+#                    raise Puppet::Error, "Service %s does not support enabling"
+#                end
+#                @is = @parent.enabled?
+#            end
+#
+#            munge do |should|
+#                @runlevel = nil
+#                case should
+#                when true: return :enabled
+#                when false: return :disabled
+#                when /^\d+$/:
+#                    @runlevel = should
+#                    return :enabled
+#                else
+#                    raise Puppet::Error, "Invalid 'enabled' value %s" % should
+#                end
+#            end
+#
+#            def sync
+#                case self.should
+#                when :enabled
+#                    unless @parent.respond_to?(:enable)
+#                        raise Puppet::Error, "Service %s does not support enabling"
+#                    end
+#                    @parent.enable(@runlevel)
+#                    return :service_enabled
+#                when :disabled
+#                    unless @parent.respond_to?(:disable)
+#                        raise Puppet::Error,
+#                            "Service %s does not support disabling"
+#                    end
+#                    @parent.disable
+#                    return :service_disabled
+#                end
+#            end
+#        end
 
         # Handle whether the service should actually be running right now.
-        class ServiceRunning < State
-            @doc = "Whether a service should be running.  **true**/*false*"
-            @name = :running
+        newstate(:running) do
+            desc "Whether a service should be running.  **true**/*false*"
 
-            def shouldprocess(should)
+            munge do |should|
                 case should
                 when false,0,"0", "stopped", :stopped:
                     should = :stopped
@@ -64,10 +74,9 @@ module Puppet
                     should = :running
                 else
                     self.warning "%s: interpreting '%s' as false" %
-                        [self.class,should]
+                        [self.class,should.inspect]
                     should = 0
                 end
-                self.debug "Service should is %s" % should
                 return should
             end
 
@@ -81,260 +90,347 @@ module Puppet
                 case self.should
                 when :running
                     @parent.start
-                    event = :service_started
+                    self.info "started"
+                    return :service_started
                 when :stopped
+                    self.info "stopped"
                     @parent.stop
-                    event = :service_stopped
+                    return :service_stopped
                 else
                     self.debug "Not running '%s' and shouldn't be running" %
                         self
                 end
             end
         end
-    end
 
-	class Type
-		class Service < Type
-			attr_reader :stat
-			@states = [
-                Puppet::State::ServiceRunning
-            ]
-			@parameters = [
-                :binary,
-                :hasstatus,
-                :name,
-                :path,
-                :pattern,
-                :restart,
-                :start,
-                :status,
-                :stop,
-                :type
-            ]
-
-            @paramdoc[:binary] = "The path to the daemon.  This is only used for
-                systems that do not support init scripts."
-            @paramdoc[:hasstatus] = "Declare the the service's init script has a
-                functional status command.  This is assumed to be default for
-                most systems, although there might be platforms on which this is
-                assumed to be true."
-            @paramdoc[:name] = "The name of the service to run.  This name
-                is used to find the init script in the search path."
-            @paramdoc[:path] = "The search path for finding init scripts.
-                There is currently no default, but hopefully soon there will
-                be a reasonable default for all platforms."
-            @paramdoc[:pattern] = "The pattern to search for in the process table.
-                This is used for stopping services on platforms that do not
-                support init scripts, and is also used for determining service
-                status on those service whose init scripts do not include a status
-                command."
-            @paramdoc[:restart] = "Specify a *restart* command manually.  If left
-                unspecified, the restart method will be determined automatically."
-            @paramdoc[:start] = "Specify a *start* command manually.  If left
-                unspecified, the start method will be determined automatically."
-            @paramdoc[:status] = "Specify a *status* command manually.  If left
-                unspecified, the status method will be determined automatically."
-            @paramdoc[:stop] = "Specify a *stop* command manually.  If left
-                unspecified, the stop method will be determined automatically."
-
-            @doc = "Manage running services.  Rather than supporting managing
-                individual processes, puppet uses init scripts to simplify
-                specification of how to start, stop, or test processes.  The
-                `path` parameter is provided to enable creation of multiple
-                init script directories, including supporting them for normal
-                users."
-            @name = :service
-			@namevar = :name
-
-            # Return the service type we're using.  Default to the Service
-            # class itself, but could be set to a module.
-            class << self
-                attr_accessor :svctype
+        newparam(:type) do
+            desc "The service type.  For most platforms, it does not make
+                sense to change set this parameter, as the default is based on
+                the builtin service facilities.  The service types available are:
+                
+                * ``base``: You must specify everything.
+                * ``init``: Assumes ``start`` and ``stop`` commands exist, but you
+                  must specify everything else.
+                * ``debian``: Debian's own specific version of ``init``.
+                * ``smf``: Solaris 10's new Service Management Facility.
+                "
+
+            defaultto { @parent.class.defaulttype }
+
+            # Make sure we've got the actual module, not just a string
+            # representing the module.
+            munge do |type|
+                if type.is_a?(String)
+                    type = @parent.class.svctype(type.intern)
+                end
+                Puppet.debug "Service type is %s" % type.name
+                @parent.extend(type)
+
+                return type
             end
+        end
+        newparam(:binary) do
+            desc "The path to the daemon.  This is only used for
+                systems that do not support init scripts.  This binary will be
+                used to start the service if no ``start`` parameter is
+                provided."
+        end
+        newparam(:hasstatus) do
+            desc "Declare the the service's init script has a
+                functional status command.  Based on testing, it was found
+                that a large number of init scripts on different platforms do
+                not support any kind of status command; thus, you must specify
+                manually whether the service you are running has such a
+                command (or you can specify a specific command using the
+                ``status`` parameter).
+                
+                If you do not specify anything, then the service name will be
+                looked for in the process table."
+        end
+        newparam(:name) do
+            desc "The name of the service to run.  This name
+                is used to find the service in whatever service subsystem it
+                is in."
+            isnamevar
+        end
+        newparam(:path) do
+            desc "The search path for finding init scripts."
+
+            munge do |value|
+                paths = []
+                if value.is_a?(Array)
+                    paths += value.flatten.collect { |p|
+                        p.split(":")
+                    }.flatten
+                else
+                    paths = value.split(":")
+                end
 
-            # Retrieve the default type for the current platform.
-            def self.defaulttype
-                unless defined? @defsvctype
-                    @defsvctype = nil
-                    os = Facter["operatingsystem"].value
-                    case os
-                    when "Linux":
-                        case Facter["distro"].value
-                        when "Debian":
-                            @defsvctype = Puppet::ServiceTypes::DebianSvc
-                        end
-                    when "SunOS":
-                        release = Float(Facter["operatingsystemrelease"].value)
-                        if release < 5.10
-                            @defsvctype = Puppet::ServiceTypes::InitSvc
-                        else
-                            @defsvctype = Puppet::ServiceTypes::SMFSvc
-                        end
+                paths.each do |path|
+                    if FileTest.directory?(path)
+                        next
                     end
-
-                    unless @defsvctype
-                        Puppet.notice "Defaulting to base service type"
-                        @defsvctype = Puppet::ServiceTypes::BaseSvc
+                    unless FileTest.directory?(path)
+                        @parent.info("Search path %s is not a directory" % [path])
+                    end
+                    unless FileTest.exists?(path)
+                        @parent.info("Search path %s does not exist" % [path])
                     end
+                    paths.delete(path)
                 end
 
-                return @defsvctype
+                paths
+            end
+        end
+        newparam(:pattern) do
+            desc "The pattern to search for in the process table.
+                This is used for stopping services on platforms that do not
+                support init scripts, and is also used for determining service
+                status on those service whose init scripts do not include a status
+                command.
+                
+                If this is left unspecified and is needed to check the status
+                of a service, then the service name will be used instead.
+                
+                The pattern can be a simple string or any legal Ruby pattern."
+            defaultto { @parent.name }
+        end
+        newparam(:restart) do
+            desc "Specify a *restart* command manually.  If left
+                unspecified, the service will be stopped and then started."
+        end
+        newparam(:start) do
+            desc "Specify a *start* command manually.  Most service subsystems
+                support a ``start`` command, so this will not need to be
+                specified."
+        end
+        newparam(:status) do
+            desc "Specify a *status* command manually.  If left
+                unspecified, the status method will be determined
+                automatically, usually by looking for the service int he
+                process table."
+        end
+
+        newparam(:stop) do
+            desc "Specify a *stop* command manually."
+        end
+
+        # Create new subtypes of service management.
+        def self.newsvctype(name, parent = nil, &block)
+            if parent
+                parent = self.svctype(parent)
             end
+            svcname = name
+            mod = Module.new
+            const_set("SvcType" + name.to_s.capitalize,mod)
 
-            # Execute a command.  Basically just makes sure it exits with a 0
-            # code.
-            def execute(type, cmd)
-                output = %x(#{cmd} 2>&1)
-                unless $? == 0
-                    raise Puppet::Error, "Could not %s %s: %s" %
-                        [type, self.name, output.chomp]
-                end
+            # Add our parent, if it exists
+            if parent
+                mod.send(:include, parent)
             end
 
-            # Get the process ID for a running process. Requires the 'pattern'
-            # parameter.
-            def getpid
-                unless self[:pattern]
-                    raise Puppet::Error,
-                        "Either a stop command or a pattern must be specified"
-                end
-                ps = Facter["ps"].value
-                unless ps and ps != ""
-                    raise Puppet::Error,
-                        "You must upgrade Facter to a version that includes 'ps'"
+            # And now define the support methods
+            code = %{
+                def self.name
+                    "#{svcname}"
                 end
-                regex = Regexp.new(self[:pattern])
-                IO.popen(ps) { |table|
-                    table.each { |line|
-                        if regex.match(line)
-                            ary = line.sub(/^\s+/, '').split(/\s+/)
-                            return ary[1]
-                        end
-                    }
-                }
 
-                return nil
-            end
+                def self.inspect
+                    "SvcType(#{svcname})"
+                end
 
-            # Initialize the service.  This is basically responsible for merging
-            # in the right module.
-            def initialize(hash)
-                # We have to extend the object before we call 'super', so that
-                # the parameter methods are called correctly.
-                type =  hash[:type] ||
-                        hash["type"] ||
-                        self.class.defaulttype
+                def self.to_s
+                    "SvcType(#{svcname})"
+                end
 
-                if type.is_a?(String)
-                    type = type2module(type)
+                def svctype
+                    "#{svcname}"
                 end
+            }
 
-                # Extend the object with the service type
-                #self.info "extending with %s" % type
-                self.extend(type)
+            mod.module_eval(code)
 
-                super
+            mod.module_eval(&block)
 
-                unless @parameters.include?(:pattern)
-                    # default to using the service name as the pattern
-                    self[:pattern] = self.name
+            @modules ||= Hash.new do |hash, key|
+                if key.is_a?(String)
+                    key = key.intern
                 end
 
-                # and then see if it needs to be checked
-                if self.respond_to?(:configchk)
-                    self.configchk
+                if hash.include?(key)
+                    hash[key]
+                else
+                    nil
                 end
             end
+            @modules[name] = mod
+        end
+
+        # Retrieve a service type.
+        def self.svctype(name)
+            @modules[name]
+        end
 
-            # Retrieve the service type.
-            def type2module(type)
-                case type
-                when "smf":
-                    return Puppet::ServiceTypes::SMFSvc
-                when "init":
-                    return Puppet::ServiceTypes::InitSvc
-                when "launchd":
-                    #return Puppet::ServiceTypes::LaunchDSvc
+        # Retrieve the default type for the current platform.
+        def self.defaulttype
+            unless defined? @defsvctype
+                @defsvctype = nil
+                os = Facter["operatingsystem"].value
+                case os
+                when "Debian":
+                    @defsvctype = self.svctype(:debian)
+                when "Solaris":
+                    release = Facter["operatingsystemrelease"].value
+                    if release.sub(/5\./,'').to_i < 10
+                        @defsvctype = self.svctype(:init)
+                    else
+                        @defsvctype = self.svctype(:smf)
+                    end
                 else
-                    raise Puppet::Error, "Invalid service type %s" % type
+                    if Facter["kernel"] == "Linux"
+                        Puppet.notice "Using service type %s for %s" %
+                            ["init", Facter["operatingsystem"].value]
+                        @defsvctype = self.svctype(:init)
+                    end
                 end
-            end
 
-            # Basically just a synonym for restarting.  Used to respond
-            # to events.
-            def refresh
-                self.restart
+                unless @defsvctype
+                    Puppet.notice "Defaulting to base service type"
+                    @defsvctype = self.svctype(:base)
+                end
             end
 
-            # How to restart the process.
-            def restart
-                if self[:restart] or self.respond_to?(:restartcmd)
-                    cmd = self[:restart] || self.restartcmd
-                    self.execute("restart", cmd)
-                else
-                    self.stop
-                    self.start
-                end
+            Puppet.debug "Default service type is %s" % @defsvctype.name
+
+            return @defsvctype
+        end
+
+        # Execute a command.  Basically just makes sure it exits with a 0
+        # code.
+        def execute(type, cmd)
+            self.info "Executing %s" % cmd.inspect
+            output = %x(#{cmd} 2>&1)
+            unless $? == 0
+                self.fail "Could not %s %s: %s" %
+                    [type, self.name, output.chomp]
             end
+        end
 
-            # 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 self[:status] or (
-                    self.respond_to?(:statuscmd) and self.statuscmd
+        # Get the process ID for a running process. Requires the 'pattern'
+        # parameter.
+        def getpid
+            unless self[:pattern]
+                self.fail "Either a stop command or a pattern must be specified"
+            end
+            ps = Facter["ps"].value
+            unless ps and ps != ""
+                self.fail(
+                    "You must upgrade Facter to a version that includes 'ps'"
                 )
-                    cmd = self[:status] || self.statuscmd
-                    output = %x(#{cmd} 2>&1)
-                    self.debug "%s status returned %s" %
-                        [self.name, output]
-                    if $? == 0
-                        return :running
-                    else
-                        return :stopped
+            end
+            regex = Regexp.new(self[:pattern])
+            IO.popen(ps) { |table|
+                table.each { |line|
+                    if regex.match(line)
+                        ary = line.sub(/^\s+/, '').split(/\s+/)
+                        return ary[1]
                     end
-                elsif pid = self.getpid
+                }
+            }
+
+            return nil
+        end
+
+        # Initialize the service.  This is basically responsible for merging
+        # in the right module.
+        def initialize(hash)
+            super
+
+            # and then see if it needs to be checked
+            if self.respond_to?(:configchk)
+                self.configchk
+            end
+        end
+
+        # Retrieve the service type.
+        def type2module(type)
+            self.class.svctype(type)
+        end
+
+        # Basically just a synonym for restarting.  Used to respond
+        # to events.
+        def refresh
+            self.restart
+        end
+
+        # How to restart the process.
+        def restart
+            if self[:restart] or self.respond_to?(:restartcmd)
+                cmd = self[:restart] || self.restartcmd
+                self.execute("restart", cmd)
+            else
+                self.stop
+                self.start
+            end
+        end
+
+        # 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 self[:status] or (
+                self.respond_to?(:statuscmd) and self.statuscmd
+            )
+                cmd = self[:status] || self.statuscmd
+                self.info "Executing %s" % cmd.inspect
+                output = %x(#{cmd} 2>&1)
+                self.debug "%s status returned %s" %
+                    [self.name, output.inspect]
+                if $? == 0
                     return :running
                 else
                     return :stopped
                 end
+            elsif pid = self.getpid
+                return :running
+            else
+                return :stopped
             end
+        end
 
-            # Run the 'start' parameter command, or the specified 'startcmd'.
-            def start
-                cmd = self[:start] || self.startcmd
-                self.execute("start", cmd)
-            end
+        # Run the 'start' parameter command, or the specified 'startcmd'.
+        def start
+            cmd = self[:start] || self.startcmd
+            self.execute("start", cmd)
+        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 self[:stop]
-                    return self[:stop]
-                elsif self.respond_to?(:stopcmd)
-                    self.execute("stop", self.stopcmd)
-                else
-                    pid = getpid
-                    unless pid
-                        self.info "%s is not running" % self.name
-                        return false
-                    end
-                    output = %x("kill #{pid} 2>&1")
-                    if $? != 0
-                        raise Puppet::Error,
-                            "Could not kill %s, PID %s: %s" %
-                                [self.name, pid, output]
-                    end
-                    return true
+        # 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 self[:stop]
+                return self[:stop]
+            elsif self.respond_to?(:stopcmd)
+                self.execute("stop", self.stopcmd)
+            else
+                pid = getpid
+                unless pid
+                    self.info "%s is not running" % self.name
+                    return false
                 end
+                output = %x("kill #{pid} 2>&1")
+                if $? != 0
+                    self.fail "Could not kill %s, PID %s: %s" %
+                            [self.name, pid, output]
+                end
+                return true
             end
-		end
-	end
+        end
+    end
 end
 
 # Load all of the different service types.  We could probably get away with
@@ -344,4 +440,4 @@ require 'puppet/type/service/init'
 require 'puppet/type/service/debian'
 require 'puppet/type/service/smf'
 
-# $Id: service.rb 742 2005-11-16 17:12:11Z luke $
+# $Id: service.rb 887 2006-02-08 22:56:56Z luke $