puppet 0.18.4 → 0.22.4

data/lib/puppet/provider/port/parsed.rb

@@ -0,0 +1,174 @@
+require 'puppet/provider/parsedfile'
+
+#services = nil
+#case Facter.value(:operatingsystem)
+#when "Solaris": services = "/etc/inet/services"
+#else
+#    services = "/etc/services"
+#end
+#
+#Puppet::Type.type(:port).provide(:parsed,
+#    :parent => Puppet::Provider::ParsedFile,
+#    :default_target => services,
+#    :filetype => :flat
+#) do
+#    text_line :comment, :match => /^\s*#/
+#    text_line :blank, :match => /^\s*$/
+#
+#    # We're cheating horribly here -- we don't support ddp, because it assigns
+#    # the same number to already-used names, and the same name to different
+#    # numbers.
+#    text_line :ddp, :match => /^\S+\s+\d+\/ddp/
+#
+#    # Also, just ignore the lines on OS X that don't have service names.
+#    text_line :funky_darwin, :match => /^\s+\d+\//
+#
+#    # We have to manually parse the line, since it's so darn complicated.
+#    record_line :parsed, :fields => %w{name port protocols alias description},
+#        :optional => %w{alias description} do |line|
+#        if line =~ /\/ddp/
+#            raise "missed ddp in %s" % line
+#        end
+#        # The record might contain multiple port lines separated by \n.
+#        hashes = line.split("\n").collect { |l| parse_port(l) }
+#
+#        # It's easy if there's just one hash.
+#        if hashes.length == 1
+#            return hashes.shift
+#        end
+#
+#        # Else, merge the two records into one.
+#        return port_merge(*hashes)
+#    end
+#
+#    # Override how we split into lines, so that we always treat both protocol
+#    # lines as a single line.  This drastically simplifies merging the two lines
+#    # into one record.
+#    def self.lines(text)
+#        names = {}
+#        lines = []
+#
+#        # We organize by number, because that's apparently how the ports work.
+#        # You'll never be able to use Puppet to manage multiple entries
+#        # with the same name but different numbers, though.
+#        text.split("\n").each do |line|
+#            if line =~ /^([-\w]+)\s+(\d+)\/[^d]/ # We want to skip ddp proto stuff
+#                names[$1] ||= []
+#                names[$1] << line
+#                lines << [:special, $1]
+#            else
+#                lines << line
+#            end
+#        end
+#
+#        # Now, return each line in order, but join the ones with the same name
+#        lines.collect do |line|
+#            if line.is_a?(Array)
+#                name = line[1]
+#                if names[name]
+#                    t = names[name].join("\n")
+#                    names.delete(name)
+#                    t
+#                end
+#            else
+#                line
+#            end
+#        end.reject { |l| l.nil? }
+#    end
+#
+#    # Parse a single port line, returning a hash.
+#    def self.parse_port(line)
+#        hash = {}
+#        if line.sub!(/^(\S+)\s+(\d+)\/(\w+)\s*/, '')
+#            hash[:name] = $1
+#            hash[:number] = $2
+#            hash[:protocols] = [$3]
+#
+#            unless line == ""
+#                line.sub!(/^([^#]+)\s*/) do |value|
+#                    aliases = $1
+#
+#                    # Remove any trailing whitespace
+#                    aliases.strip!
+#                    unless aliases =~ /^\s*$/
+#                        hash[:alias] = aliases.split(/\s+/)
+#                    end
+#
+#                    ""
+#                end
+#
+#                line.sub!(/^\s*#\s*(.+)$/) do |value|
+#                    desc = $1
+#                    unless desc =~ /^\s*$/
+#                        hash[:description] = desc.sub(/\s*$/, '')
+#                    end
+#
+#                    ""
+#                end
+#            end
+#        else
+#            if line =~ /^\s+\d+/ and
+#                Facter["operatingsystem"].value == "Darwin"
+#                    #Puppet.notice "Skipping wonky OS X port entry %s" %
+#                    #    line.inspect
+#                    next
+#            end
+#            Puppet.notice "Ignoring unparseable line '%s' in %s" % [line, self.target]
+#        end
+#
+#        if hash.empty?
+#            return nil
+#        else
+#            return hash
+#        end
+#    end
+#
+#    # Merge two records into one.
+#    def self.port_merge(one, two)
+#        keys = [one.keys, two.keys].flatten.uniq
+#
+#        # We'll be returning the 'one' hash. so make any necessary modifications
+#        # to it.
+#        keys.each do |key|
+#            # The easy case
+#            if one[key] == two[key]
+#                next
+#            elsif one[key] and ! two[key]
+#                next
+#            elsif ! one[key] and two[key]
+#                one[key] = two[key]
+#            elsif one[key].is_a?(Array) and two[key].is_a?(Array)
+#                one[key] = [one[key], two[key]].flatten.uniq
+#            else
+#                # Keep the info from the first hash, so don't do anything
+#                #Puppet.notice "Cannot merge %s in %s with %s" %
+#                #    [key, one.inspect, two.inspect]
+#            end
+#        end
+#
+#        return one
+#    end
+#
+#    # Convert the current object into one or more services entry.
+#    def self.to_line(hash)
+#        unless hash[:record_type] == :parsed
+#            return super
+#        end
+#
+#        # Strangely, most sites seem to use tabs as separators.
+#        hash[:protocols].collect { |proto|
+#            str = "%s\t\t%s/%s" % [hash[:name], hash[:number], proto]
+#
+#            if value = hash[:alias] and value != :absent
+#                str += "\t\t%s" % value.join(" ")
+#            end
+#
+#            if value = hash[:description] and value != :absent
+#                str += "\t# %s" % value
+#            end
+#            str
+#        }.join("\n")
+#    end
+#end
+
+# $Id: parsed.rb 1875 2006-11-13 08:40:35Z luke $

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

@@ -0,0 +1,136 @@
+Puppet::Type.type(:service).provide :base do
+    desc "The simplest form of service support.  You have to specify
+        enough about your service for this to work; the minimum you can specify
+        is a binary for starting the process, and this same binary will be searched
+        for in the process table to stop the service.  It is preferable to
+        specify start, stop, and status commands, akin to how you would do
+        so using ``init``."
+
+    commands :kill => "kill"
+
+    # Get the process ID for a running process. Requires the 'pattern'
+    # parameter.
+    def getpid
+        unless @model[:pattern]
+            @model.fail "Either a stop command or a pattern must be specified"
+        end
+        ps = Facter["ps"].value
+        unless ps and ps != ""
+            @model.fail(
+                "You must upgrade Facter to a version that includes 'ps'"
+            )
+        end
+        regex = Regexp.new(@model[:pattern])
+        self.debug "Executing '#{ps}'"
+        IO.popen(ps) { |table|
+            table.each { |line|
+                if regex.match(line)
+                    ary = line.sub(/^\s+/, '').split(/\s+/)
+                    return ary[1]
+                end
+            }
+        }
+
+        return nil
+    end
+
+    # How to restart the process.
+    def restart
+        if @model[:restart] or self.respond_to?(:restartcmd)
+            ucommand(:restart)
+        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 @model[:status] or (
+            self.respond_to?(:statuscmd) and self.statuscmd
+        )
+            # Don't fail when the exit status is not 0.
+            output = ucommand(:status, false)
+
+            self.debug "%s status returned %s" %
+                [self.name, output.inspect]
+            if $? == 0
+                return :running
+            else
+                return :stopped
+            end
+        elsif pid = self.getpid
+            self.debug "PID is %s" % pid
+            return :running
+        else
+            return :stopped
+        end
+    end
+
+    # Run the 'start' parameter command, or the specified 'startcmd'.
+    def start
+        ucommand(:start)
+    end
+
+    # The command used to start.  Generated if the 'binary' argument
+    # is passed.
+    def startcmd
+        if @model[:binary]
+            return @model[:binary]
+        else
+            raise Puppet::Error,
+                "Services must specify a start command or a binary"
+        end
+    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 @model[:stop] or self.respond_to?(:stopcmd)
+            ucommand(:stop)
+        else
+            pid = getpid
+            unless pid
+                self.info "%s is not running" % self.name
+                return false
+            end
+            begin
+                output = kill pid
+            rescue Puppet::ExecutionFailure => detail
+                @model.fail "Could not kill %s, PID %s: %s" %
+                        [self.name, pid, output]
+            end
+            return true
+        end
+    end
+
+    # A simple wrapper so execution failures are a bit more informative.
+    def texecute(type, command, fof = true)
+        begin
+            # #565: Services generally produce no output, so squelch them.
+            execute(command, :failonfail => fof, :squelch => true)
+        rescue Puppet::ExecutionFailure => detail
+            @model.fail "Could not %s %s: %s" % [type, @model.ref, detail]
+        end
+        return nil
+    end
+
+    # Use either a specified command or the default for our provider.
+    def ucommand(type, fof = true)
+        if c = @model[type]
+            cmd = [c]
+        else
+            cmd = self.send("%scmd" % type)
+        end
+        return texecute(type, cmd, fof)
+    end
+end
+
+# $Id: base.rb 2385 2007-04-03 15:51:18Z mccune $

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

@@ -0,0 +1,32 @@
+# Manage debian services.  Start/stop is the same as InitSvc, but enable/disable
+# is special.
+Puppet::Type.type(:service).provide :debian, :parent => :init do
+    desc "Debian's form of ``init``-style management.  The only difference
+        is that this supports service enabling and disabling via ``update-rc.d``."
+
+    commands :update => "/usr/sbin/update-rc.d"
+    defaultfor :operatingsystem => :debian
+
+    # Remove the symlinks
+    def disable
+        update "-f", @model[:name], "remove"
+    end
+
+    def enabled?
+        output = update "-n", "-f", @model[:name], "remove"
+
+        # If it's enabled, then it will print output showing removal of
+        # links.
+        if output =~ /etc\/rc[\dS].d|Nothing to do\./
+            return :true
+        else
+            return :false
+        end
+    end
+
+    def enable
+        update @model[:name], "defaults"
+    end
+end
+
+# $Id: debian.rb 1979 2006-12-28 08:06:46Z luke $

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

@@ -0,0 +1,49 @@
+# Manage gentoo services.  Start/stop is the same as InitSvc, but enable/disable
+# is special.
+Puppet::Type.type(:service).provide :gentoo, :parent => :init do
+    desc "Gentoo's form of ``init``-style service
+        management; uses ``rc-update`` for service enabling and disabling."
+
+    commands :update => "/sbin/rc-update"
+
+    defaultfor :operatingsystem => :gentoo
+
+    def disable
+        begin
+            output = update :del, @model[:name], :default
+        rescue Puppet::ExecutionFailure
+            raise Puppet::Error, "Could not disable %s: %s" %
+                [self.name, output]
+        end
+    end
+
+    def enabled?
+        begin
+            output = update :show
+        rescue Puppet::ExecutionFailure
+            return :false
+        end
+
+        line = output.split(/\n/).find { |l| l.include?(@model[:name]) }
+
+        return :false unless line
+
+        # If it's enabled then it will print output showing service | runlevel
+        if output =~ /#{@model[:name]}\s*|\s*default/
+            return :true
+        else
+            return :false
+        end
+    end
+
+    def enable
+        begin
+            output = update :add, @model[:name], :default
+        rescue Puppet::ExecutionFailure
+            raise Puppet::Error, "Could not enable %s: %s" %
+                [self.name, output]
+        end
+    end
+end
+
+# $Id $

data/lib/puppet/{type → provider}/service/init.rb

@@ -1,23 +1,35 @@
 # The standard init-based service type.  Many other service types are
 # customizations of this module.
-Puppet.type(:service).newsvctype(:init) do
-    def self.defpath
-        case Facter["operatingsystem"].value
-        when "FreeBSD":
-            "/etc/rc.d"
-        else
-            "/etc/init.d"
-        end
+Puppet::Type.type(:service).provide :init, :parent => :base do
+    desc "Standard init service management.  This provider assumes that the
+        init script has not ``status`` command, because so few scripts do,
+        so you need to either provide a status command or specify via ``hasstatus``
+        that one already exists in the init script."
+
+    class << self
+        attr_accessor :defpath
     end
 
-    Puppet.type(:service).newpath(:init, defpath())
+    case Facter["operatingsystem"].value
+    when "FreeBSD":
+        @defpath = "/etc/rc.d"
+    else
+        @defpath = "/etc/init.d"
+    end
 
-    # Set the default init directory.
-    Puppet.type(:service).attrclass(:path).defaultto defpath()
+    # We can't confine this here, because the init path can be overridden.
+    #confine :exists => @defpath
 
-    # List all services of this type.  This has to be an instance method
-    # so that it's inherited by submodules.
-    def list(name)
+    if self.suitable?
+        # Add it to the search paths
+        Puppet.type(:service).newpath(:init, defpath())
+
+        # Set the default init directory.
+        Puppet.type(:service).attrclass(:path).defaultto defpath()
+    end
+
+    # List all services of this type.
+    def self.list(name)
         # We need to find all paths specified for our type or any parent types
         paths = Puppet.type(:service).paths(name)
 
@@ -70,36 +82,26 @@ Puppet.type(:service).newsvctype(:init) do
         end
     end
 
-    # it'd be nice if i didn't throw the output away...
-    # this command returns true if the exit code is 0, and returns
-    # false otherwise
-    def initcmd(cmd)
-        script = self.initscript
-
-        self.debug "Executing '%s %s' as initcmd for '%s'" %
-            [script,cmd,self]
-
-        rvalue = Kernel.system("%s %s" %
-                [script,cmd])
-
-        self.debug "'%s' ran with exit status '%s'" %
-            [cmd,rvalue]
-
-
-        rvalue
-    end
-
     # Where is our init script?
     def initscript
         if defined? @initscript
             return @initscript
         else
-            @initscript = self.search(self[:name])
+            @initscript = self.search(@model[:name])
+        end
+    end
+
+    def restart
+        if @model[:hasrestart] == :true
+            command = [self.initscript, :restart]
+            texecute("restart", command)
+        else
+            super
         end
     end
 
     def search(name)
-        self[:path].each { |path|
+        @model[:path].each { |path|
             fqname = File.join(path,name)
             begin
                 stat = File.stat(fqname)
@@ -117,15 +119,15 @@ Puppet.type(:service).newsvctype(:init) do
 
     # The start command is just the init scriptwith 'start'.
     def startcmd
-        self.initscript + " start"
+        [self.initscript, :start]
     end
 
     # If it was specified that the init script has a 'status' command, then
     # we just return that; otherwise, we return false, which causes it to
     # fallback to other mechanisms.
     def statuscmd
-        if self[:hasstatus]
-            return self.initscript + " status"
+        if @model[:hasstatus]
+            return [self.initscript, :status]
         else
             return false
         end
@@ -133,8 +135,8 @@ Puppet.type(:service).newsvctype(:init) do
 
     # The stop command is just the init script with 'stop'.
     def stopcmd
-        self.initscript + " stop"
+        [self.initscript, :stop]
     end
 end
 
-# $Id: init.rb 1125 2006-04-20 19:38:48Z luke $
+# $Id: init.rb 1979 2006-12-28 08:06:46Z luke $