puppet 0.9.2

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

@@ -0,0 +1,17 @@
+module Puppet
+    module ServiceTypes
+        module BaseSvc
+
+            # The command used to start.  Generated if the 'binary' argument
+            # is passed.
+            def startcmd
+                if self[:binary]
+                    return self[:binary]
+                else
+                    raise Puppet::Error,
+                        "Services must specify a start command or a binary"
+                end
+            end
+        end
+    end
+end

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

@@ -0,0 +1,50 @@
+require 'puppet/type/service/init'
+
+# Manage debian services.  Start/stop is the same as InitSvc, but enable/disable
+# is special.
+module Puppet
+    module ServiceTypes
+        module DebianSvc
+            include Puppet::ServiceTypes::InitSvc
+            
+            # Remove the symlinks
+            def disable
+                output = %x{update-rc.d -f #{self.name} remove 2>/dev/null}
+
+                unless $? == 0
+                    raise Puppet::Error, "Could not disable %s: %s" %
+                        [self.name, output]
+                end
+            end
+
+            def enabled?
+                output = %x{update-rc.d -n -f #{self.name} remove 2>/dev/null}
+                unless $? == 0
+                    raise Puppet::Error, "Could not check %s: %s" %
+                        [self.name, output]
+                end
+
+                # If it's enabled, then it will print output showing removal of
+                # links.
+                if output =~ /etc\/rc\d.d/
+                    return true
+                else
+                    return false
+                end
+            end
+
+            def enable(runlevel)
+                if runlevel
+                    raise Puppet::Error, "Specification of runlevels is not supported"
+                else
+                    output = %x{update-rc.d #{self.name} defaults 2>/dev/null}
+                end
+
+                unless $? == 0
+                    raise Puppet::Error, "Could not check %s: %s" %
+                        [self.name, output]
+                end
+            end
+        end
+    end
+end

data/lib/puppet/type/service/init.rb

@@ -0,0 +1,145 @@
+module Puppet
+    module ServiceTypes
+        module InitSvc
+            # Make sure we've got a search path set up.  If they don't
+            # specify one, try to determine one.
+            def configchk
+                unless defined? @searchpaths
+                    @searchpaths = []
+                end
+                unless @searchpaths.length > 0
+                    if init = self.defaultinit
+                        self.notice "Adding default init"
+                        @searchpaths << init
+                    else
+                        self.notice "No default init for %s" %
+                            Facter["operatingsystem"].value
+
+                        raise Puppet::Error.new(
+                            "You must specify a valid search path for service %s" %
+                            self.name
+                        )
+                    end
+                end
+            end
+
+            # Get the default init path.
+            def defaultinit
+                unless defined? @defaultinit
+                    case Facter["operatingsystem"].value
+                    when "FreeBSD":
+                        @defaultinit = "/etc/rc.d"
+                    else
+                        @defaultinit = "/etc/init.d"
+                        @defaultrc = "/etc/rc%s.d"
+                    end
+                end
+
+                return @defaultinit
+            end
+
+            # Mark that our init script supports 'status' commands.
+            def hasstatus=(value)
+                case value
+                when true, "true": @parameters[:hasstatus] = true
+                when false, "false": @parameters[:hasstatus] = false
+                else
+                    raise Puppet::Error, "Invalid 'hasstatus' value %s" %
+                        value.inspect
+                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)
+                end
+            end
+
+            # Store the search path for init scripts.  This will generally not
+            # be called.
+            def parampath=(ary)
+                unless ary.is_a?(Array)
+                    ary = [ary]
+                end
+                @parameters[:path] = ary
+                @searchpaths = ary.find_all { |dir|
+                    File.directory?(dir)
+                }
+            end
+
+            # Enable a service, so it's started at boot time.  This basically
+            # just creates links in the RC directories, which means that, well,
+            # we need to know where the rc directories are.
+            # FIXME This should probably be a state or something, and
+            # it should actually create use Symlink objects...
+            # At this point, people should just link objects for enabling,
+            # if they're running on a system that doesn't have a tool to
+            # manage init script links.
+            #def enable
+            #end
+
+            #def disable
+            #end
+
+            def search(name)
+                @searchpaths.each { |path|
+                    fqname = File.join(path,name)
+                    begin
+                        stat = File.stat(fqname)
+                    rescue
+                        # should probably rescue specific errors...
+                        self.debug("Could not find %s in %s" % [name,path])
+                        next
+                    end
+
+                    # if we've gotten this far, we found a valid script
+                    return fqname
+                }
+                raise Puppet::Error, "Could not find init script for '%s'" % name
+            end
+
+            # The start command is just the init scriptwith 'start'.
+            def startcmd
+                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"
+                else
+                    return false
+                end
+            end
+
+            # The stop command is just the init script with 'stop'.
+            def stopcmd
+                self.initscript + " stop"
+            end
+        end
+    end
+end

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

@@ -0,0 +1,29 @@
+module Puppet
+    module ServiceTypes
+        module SMFSvc
+            def restartcmd
+            end
+
+            # The start command is just the init scriptwith 'start'.
+            def startcmd
+                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"
+                else
+                    return false
+                end
+            end
+
+            # The stop command is just the init script with 'stop'.
+            def stopcmd
+                self.initscript + " stop"
+            end
+        end
+    end
+end

data/lib/puppet/type/state.rb

@@ -0,0 +1,182 @@
+# The virtual base class for states, which are the self-contained building
+# blocks for actually doing work on the system.
+
+require 'puppet'
+require 'puppet/element'
+require 'puppet/statechange'
+
+module Puppet
+class State < Puppet::Element
+    attr_accessor :is, :parent
+
+    # Because 'should' uses an array, we have a special method for handling
+    # it.  We also want to keep copies of the original values, so that
+    # they can be retrieved and compared later when merging.
+    attr_reader :shouldorig
+
+    @virtual = true
+
+    class << self
+        attr_accessor :unmanaged
+        attr_reader :name
+    end
+
+    # initialize our state
+    def initialize(hash)
+        @is = nil
+
+        unless hash.include?(:parent)
+            raise Puppet::DevError, "State %s was not passed a parent" % self
+        end
+        @parent = hash[:parent]
+
+        if hash.include?(:should)
+            self.should = hash[:should]
+        end
+
+        if hash.include?(:is)
+            self.is = hash[:is]
+        end
+    end
+
+    # Determine whether the state is in-sync or not.  If @should is
+    # not defined or is set to a non-true value, then we do not have
+    # a valid value for it and thus consider the state to be in-sync
+    # since we cannot fix it.  Otherwise, we expect our should value
+    # to be an array, and if @is matches any of those values, then
+    # we consider it to be in-sync.
+    def insync?
+        #debug "%s value is '%s', should be '%s'" %
+        #    [self,self.is.inspect,self.should.inspect]
+        unless defined? @should and @should
+            return true
+        end
+
+        unless @should.is_a?(Array)
+            raise Puppet::DevError, "%s's should is not array" % self.class.name
+        end
+
+        # an empty array is analogous to no should values
+        if @should.empty?
+            return true
+        end
+
+        # Look for a matching value
+        @should.each { |val|
+            if @is == val
+                return true
+            end
+        }
+
+        # otherwise, return false
+        return false
+    end
+
+    def log(msg)
+        unless @parent[:loglevel]
+            raise Puppet::DevError, "Parent %s has no loglevel" %
+                @parent.to_s
+        end
+        Puppet::Log.create(
+            :level => @parent[:loglevel],
+            :message => msg,
+            :source => self
+        )
+    end
+
+    # each state class must define the name() method, and state instances
+    # do not change that name
+    # this implicitly means that a given object can only have one state
+    # instance of a given state class
+    def name
+        return self.class.name
+    end
+
+    # for testing whether we should actually do anything
+    def noop
+        unless defined? @noop
+            @noop = false
+        end
+        tmp = @noop || self.parent.noop || Puppet[:noop] || false
+        #debug "noop is %s" % tmp
+        return tmp
+    end
+
+    # return the full path to us, for logging and rollback; not currently
+    # used
+    def path
+        return [@parent.path, self.name].join("/")
+    end
+
+    # Only return the first value
+    def should
+        if defined? @should
+            unless @should.is_a?(Array)
+                self.warning @should.inspect
+                raise Puppet::DevError, "should for %s on %s is not an array" %
+                    [self.class.name, @parent.name]
+            end
+            return @should[0]
+        else
+            return nil
+        end
+    end
+
+    # Set the should value.
+    def should=(values)
+        unless values.is_a?(Array)
+            values = [values]
+        end
+
+        @shouldorig = values
+
+        if self.respond_to?(:shouldprocess)
+            @should = values.collect { |val|
+                self.shouldprocess(val)
+            }
+        else
+            @should = values
+        end
+    end
+
+
+    # How should a state change be printed as a string?
+    def change_to_s
+        begin
+            if @is == :notfound
+                return "defined '%s' as '%s'" %
+                    [self.name, self.should_to_s]
+            elsif self.should == :notfound
+                return "undefined %s from '%s'" %
+                    [self.name, self.is_to_s]
+            else
+                return "%s changed '%s' to '%s'" %
+                    [self.name, self.is_to_s, self.should_to_s]
+            end
+        rescue Puppet::Error, Puppet::DevError
+            raise
+        rescue => detail
+            raise Puppet::DevError, "Could not convert change %s to string: %s" %
+                [self.name, detail]
+        end
+    end
+
+    # because the @should and @is vars might be in weird formats,
+    # we need to set up a mechanism for pretty printing of the values
+    # default to just the values, but this way individual states can
+    # override these methods
+    def is_to_s
+        @is
+    end
+
+    def should_to_s
+        @should
+    end
+
+    def to_s
+        return "%s(%s)" % [@parent.name,self.name]
+    end
+end
+end
+
+# $Id: state.rb 749 2005-11-22 05:33:42Z luke $

data/lib/puppet/type/symlink.rb

@@ -0,0 +1,183 @@
+#!/usr/local/bin/ruby -w
+
+# $Id: symlink.rb 731 2005-10-26 04:44:25Z luke $
+
+require 'etc'
+require 'puppet/type/state'
+require 'puppet/type/pfile'
+
+module Puppet
+    # okay, how do we deal with parameters that don't have operations
+    # associated with them?
+    class State
+        class SymlinkTarget < Puppet::State
+            require 'etc'
+            attr_accessor :file
+
+            @doc = "Create a link to another file.  Currently only symlinks
+                are supported, and attempts to replace normal files with
+                links will currently fail, while existing but incorrect symlinks
+                will be removed."
+            @name = :target
+
+            def create
+                begin
+                    debug("Creating symlink '%s' to '%s'" %
+                        [self.parent[:path],self.should])
+                    unless File.symlink(self.should,self.parent[:path])
+                        raise TypeError.new("Could not create symlink '%s'" %
+                            self.parent[:path])
+                    end
+                rescue => detail
+                    raise TypeError.new("Cannot create symlink '%s': %s" %
+                        [self.parent[:path],detail])
+                end
+            end
+
+            def remove
+                if FileTest.symlink?(self.parent[:path])
+                    debug("Removing symlink '%s'" % self.parent[:path])
+                    begin
+                        File.unlink(self.parent[:path])
+                    rescue
+                        raise TypeError.new("Failed to remove symlink '%s'" %
+                            self.parent[:path])
+                    end
+                elsif FileTest.exists?(self.parent[:path])
+                    raise TypeError.new("Cannot remove normal file '%s'" %
+                        self.parent[:path])
+                else
+                    debug("Symlink '%s' does not exist" %
+                        self.parent[:path])
+                end
+            end
+
+            def retrieve
+                stat = nil
+
+                if FileTest.symlink?(self.parent[:path])
+                    self.is = File.readlink(self.parent[:path])
+                    debug("link value is '%s'" % self.is)
+                    return
+                else
+                    self.is = nil
+                    return
+                end
+            end
+
+            # this is somewhat complicated, because it could exist and be
+            # a file
+            def sync
+                if self.should.nil?
+                    self.remove()
+                else # it should exist and be a symlink
+                    if FileTest.symlink?(self.parent[:path])
+                        path = File.readlink(self.parent[:path])
+                        if path != self.should
+                            self.remove()
+                            self.create()
+                        end
+                    elsif FileTest.exists?(self.parent[:path])
+                        raise TypeError.new("Cannot replace normal file '%s'" %
+                            self.parent[:path])
+                    else
+                        self.create()
+                    end
+                end
+
+                #self.parent.newevent(:event => :inode_changed)
+            end
+        end
+    end
+
+    class Type
+        class Symlink < Type
+            attr_reader :stat, :path, :params
+            # class instance variable
+            @states = [
+                Puppet::State::SymlinkTarget
+            ]
+
+            @parameters = [
+                :path,
+                :recurse
+            ]
+
+            @paramdoc[:path] = "Path of link to create."
+            @paramdoc[:recurse] = "If target is a directory, recursively create
+                directories (using `file`'s `source` parameter) and link all
+                contained files."
+            @doc = "Create symbolic links to existing files."
+            @name = :symlink
+            @namevar = :path
+
+            def initialize(hash)
+                @arghash = self.argclean(hash.dup)
+                @arghash.delete(self.class.namevar)
+
+                super
+            end
+
+            def paramrecurse=(value)
+                @stat = nil
+                @target = self.state(:target).should
+
+                # we want to remove our state, because we're creating children
+                # to do the links
+                if FileTest.exist?(@target)
+                    @stat = File.stat(@target)
+                else
+                    self.info "Target %s must exist for recursive links" %
+                        @target
+                    return
+                end
+
+                # if we're a directory, then we descend into it; we only actually
+                # link to real files
+                unless @stat.directory?
+                    return
+                end
+
+                self.delete(:target)
+
+                recurse = value
+                # we might have a string, rather than a number
+                if recurse.is_a?(String)
+                    if recurse =~ /^[0-9]+$/
+                        recurse = Integer(recurse)
+                    #elsif recurse =~ /^inf/ # infinite recursion
+                    else # anything else is infinite recursion
+                        recurse = true
+                    end
+                end
+
+                # are we at the end of the recursion?
+                if recurse == 0
+                    return
+                end
+
+                # okay, we're not going to recurse ourselves here; instead, we're
+                # going to rely on the fact that we've already got all of that
+                # working in pfile
+
+                args = {
+                    :name => self.name,
+                    :linkmaker => true,
+                    :recurse => recurse,
+                    :source => @target
+                }
+
+                dir = Puppet::Type::PFile.implicitcreate(args)
+                dir.parent = self
+                self.debug "Got dir %s" % dir.name
+                self.push dir
+                #Dir.foreach(@target) { |file|
+                #    next if file =~ /^\.\.?$/ # skip . and ..
+                #    newtarget = File.join(@target,file)
+                #    #stat = File.stat(File.join(@target,file))
+                #    self.newchild(file, :target => newtarget)
+                #}
+            end
+        end # Puppet::Type::Symlink
+    end # Puppet::Type
+end