puppet 0.18.4 → 0.22.4

data/lib/puppet/type/resources.rb

@@ -0,0 +1,150 @@
+#  Created by Luke Kanies on 2006-12-12.
+#  Copyright (c) 2006. All rights reserved.
+
+require 'puppet'
+
+Puppet::Type.newtype(:resources) do
+    @doc = "This is a metatype that can manage other resource types.  Any
+        metaparams specified here will be passed on to any generated resources,
+        so you can purge umanaged resources but set ``noop`` to true so the
+        purging is only logged and does not actually happen."
+    
+    
+    newparam(:name) do
+        desc "The name of the type to be managed."
+        
+        validate do |name|
+            unless Puppet::Type.type(name)
+                raise ArgumentError, "Could not find resource type '%s'" % name
+            end
+        end
+        
+        munge { |v| v.to_s }
+    end
+    
+    newparam(:purge, :boolean => true) do
+        desc "Purge unmanaged resources.  This will delete any resource
+            that is not specified in your configuration
+            and is not required by any specified resources."
+            
+        newvalues(:true, :false)
+        
+        validate do |value|
+            if [:true, true, "true"].include?(value)
+                unless @parent.resource_type.respond_to?(:list)
+                    raise ArgumentError, "Purging resources of type %s is not supported, since they cannot be listed" % @parent[:name]
+                end
+                unless @parent.resource_type.validproperty?(:ensure)
+                    raise ArgumentError, "Purging is only supported on types that accept 'ensure'"
+                end
+            end
+        end
+    end
+    
+    newparam(:unless_system_user) do
+        desc "This keeps system users from being purged.  By default, it
+            does not purge users whose UIDs are less than or equal to 500, but you can specify
+            a different UID as the inclusive limit."
+        
+        newvalues(:true, :false, /^\d+$/)
+        
+        munge do |value|
+            case value
+            when /^\d+/
+                Integer(value)
+            when :true, true
+                500
+            when :false, false
+                false
+            when Integer: value
+            else
+                raise ArgumentError, "Invalid value %s" % value.inspect
+            end
+        end
+        
+        defaultto {
+            if @parent[:name] == "user"
+                500
+            else
+                nil
+            end
+        }
+    end
+    
+    def check(resource)
+        unless defined? @checkmethod
+            @checkmethod = "%s_check" % self[:name]
+        end
+        unless defined? @hascheck
+            @hascheck = respond_to?(@checkmethod)
+        end
+        if @hascheck
+            return send(@checkmethod, resource)
+        else
+            return true
+        end
+    end
+    
+    # Generate any new resources we need to manage.  This is pretty hackish
+    # right now, because it only supports purging.
+    def generate
+        return [] unless self.purge?
+        hascheck = false
+        method = 
+        resource_type.list.find_all do |resource|
+            ! resource.managed?
+        end.find_all do |resource|
+            check(resource)
+        end.each do |resource|
+            begin
+                resource[:ensure] = :absent
+            rescue ArgumentError, Puppet::Error => detail
+                err "The 'ensure' attribute on %s resources does not accept 'absent' as a value" %
+                    [self[:name]]
+                return []
+            end
+            @parameters.each do |name, param|
+                next unless param.metaparam?
+                resource[name] = param.value
+            end
+
+            # Mark that we're purging, so transactions can handle relationships
+            # correctly
+            resource.purging
+        end
+    end
+    
+    def resource_type
+        unless defined? @resource_type
+            unless type = Puppet::Type.type(self[:name])
+                raise Puppet::DevError, "Could not find resource type"
+            end
+            @resource_type = type
+        end
+        @resource_type
+    end
+    
+    def user_check(resource)
+        return true unless self[:name] == "user"
+        return true unless self[:unless_system_user]
+        
+        resource[:check] = :uid
+        resource.retrieve
+        
+        if system_users().include?(resource[:name])
+            return false
+        end
+        
+        if resource.is(:uid) <= self[:unless_system_user]
+            return false
+        else
+            return true
+        end
+    end
+
+    def system_users
+        %w{root nobody bin noaccess daemon sys}
+    end
+end
+
+# $Id: resources.rb 2286 2007-03-17 23:16:37Z luke $

data/lib/puppet/type/schedule.rb

@@ -16,7 +16,7 @@ module Puppet
             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:
+            the hours of two and 4 AM, then you would use this schedule::
                 
                 schedule { maint:
                     range => \"2 - 4\",
@@ -33,7 +33,7 @@ module Puppet
             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:
+            with the following attributes::
 
                 schedule { puppet:
                     period => hourly,
@@ -43,11 +43,9 @@ module Puppet
             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 when assigning it to an object::
                     
                     schedule { daily:
                         period => daily,
@@ -67,7 +65,7 @@ module Puppet
                 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:
+                For instance::
 
                     schedule { maintenance:
                         range => \"1:30 - 4:30\"
@@ -76,7 +74,7 @@ module Puppet
                 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.
+            # This is lame; properties 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)
@@ -104,6 +102,18 @@ module Puppet
                         self.fail "Invalid range %s" % value
                     end
 
+                    # Make sure the hours are valid
+                    [range[0][0], range[1][0]].each do |n|
+                        if n < 0 or n > 23
+                            raise ArgumentError, "Invalid hour '%s'" % n
+                        end
+                    end
+
+                    [range[0][1], range[1][1]].each do |n|
+                        if n and (n < 0 or n > 59)
+                            raise ArgumentError, "Invalid minute '%s'" % n
+                        end
+                    end
                     if range[0][0] > range[1][0]
                         self.fail(("Invalid range %s; " % value) +
                             "ranges cannot span days."
@@ -179,7 +189,7 @@ module Puppet
         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**"
+                60 minutes apart)."
 
             newvalues(:number, :distance)
 
@@ -200,7 +210,7 @@ module Puppet
                 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:
+                specified number of times.  Take this schedule::
 
                     schedule { veryoften:
                         period => hourly,
@@ -218,7 +228,7 @@ module Puppet
                 See the ``periodmatch`` attribute for tuning whether to match
                 times by their distance apart or by their specific value."
 
-            newvalues(:hourly, :daily, :weekly, :monthly)
+            newvalues(:hourly, :daily, :weekly, :monthly, :never)
 
             @@scale = {
                 :hourly => 3600,
@@ -236,6 +246,8 @@ module Puppet
             }
 
             def match?(previous, now)
+                return false if value == :never
+
                 value = self.value
                 case @parent[:periodmatch]
                 when :number
@@ -261,7 +273,7 @@ module Puppet
 
         newparam(:repeat) do
             desc "How often the application gets repeated in a given period.
-                Defaults to 1."
+                Defaults to 1. Must be an integer."
 
             defaultto 1
 
@@ -300,20 +312,24 @@ module Puppet
         end
 
         def self.mkdefaultschedules
-            Puppet.debug "Creating default schedules"
             # Create our default schedule
-            self.create(
-                :name => "puppet",
-                :period => :hourly,
-                :repeat => "2"
-            )
+            unless self["puppet"]
+                Puppet.debug "Creating default schedules"
+                self.create(
+                    :name => "puppet",
+                    :period => :hourly,
+                    :repeat => "2"
+                )
+            end
 
             # And then one for every period
             @parameters.find { |p| p.name == :period }.values.each { |value|
-                self.create(
-                    :name => value.to_s,
-                    :period => value
-                )
+                unless self[value.to_s]
+                    self.create(
+                        :name => value.to_s,
+                        :period => value
+                    )
+                end
             }
         end
 
@@ -342,4 +358,4 @@ module Puppet
     end
 end
 
-# $Id: schedule.rb 1300 2006-06-19 19:12:54Z luke $
+# $Id: schedule.rb 2408 2007-04-24 02:41:16Z luke $

data/lib/puppet/type/service.rb

@@ -15,39 +15,47 @@ module Puppet
             '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."
+            use a platform that has very good service support.
+	    
+            Note that if a ``service`` receives an event from another resource,
+            the service will get restarted. The actual command to restart the
+            service depends on the platform. You can provide a special command
+            for restarting with the ``restart`` attribute."
         
+        feature :enableable, "The provider can enable and disable the service",
+            :methods => [:disable, :enable, :enabled?]
+
         attr_reader :stat
 
-        newstate(:enable) do
+        newproperty(:enable) do
             attr_reader :runlevel
             desc "Whether a service should be enabled to start at boot.
-                This state behaves quite differently depending on the platform;
+                This property behaves quite differently depending on the platform;
                 wherever possible, it relies on local tools to enable or disable
-                a given service.  *true*/*false*/*runlevels*"
+                a given service."
 
-            newvalue(:true) do
-                unless @parent.respond_to?(:enable)
+            newvalue(:true, :event => :service_enabled) do
+                unless provider.respond_to?(:enable)
                     raise Puppet::Error, "Service %s does not support enabling" %
                         @parent.name
                 end
-                @parent.enable
+                provider.enable
             end
 
-            newvalue(:false) do
-                unless @parent.respond_to?(:disable)
+            newvalue(:false, :event => :service_disabled) do
+                unless provider.respond_to?(:disable)
                     raise Puppet::Error, "Service %s does not support enabling" %
                         @parent.name
                 end
-                @parent.disable
+                provider.disable
             end
 
             def retrieve
-                unless @parent.respond_to?(:enabled?)
+                unless provider.respond_to?(:enabled?)
                     raise Puppet::Error, "Service %s does not support enabling" %
                         @parent.name
                 end
-                @is = @parent.enabled?
+                @is = provider.enabled?
             end
 
             validate do |value|
@@ -80,55 +88,55 @@ module Puppet
                 case self.should
                 when :true
                     if @runlevel
-                        @parent.enable(@runlevel)
+                        provider.enable(@runlevel)
                     else
-                        @parent.enable()
+                        provider.enable()
                     end
                     return :service_enabled
                 when :false
-                    @parent.disable
+                    provider.disable
                     return :service_disabled
                 end
             end
         end
 
         # Handle whether the service should actually be running right now.
-        newstate(:ensure) do
-            desc "Whether a service should be running.  **true**/*false*"
+        newproperty(:ensure) do
+            desc "Whether a service should be running."
 
-            newvalue(:stopped) do
-                @parent.stop
+            newvalue(:stopped, :event => :service_stopped) do
+                provider.stop
             end
 
-            newvalue(:running) do
-                @parent.start
+            newvalue(:running, :event => :service_started) do
+                provider.start
             end
 
             aliasvalue(:false, :stopped)
             aliasvalue(:true, :running)
 
             def retrieve
-                self.is = @parent.status
+                self.is = provider.status
             end
 
             def sync
-                event = nil
-                case self.should
-                when :running
-                    @parent.start
-                    event = :service_started
-                when :stopped
-                    @parent.stop
-                    event = :service_stopped
-                else
-                    self.debug "Not running '%s' and shouldn't be running" %
-                        self
-                end
-
-                if state = @parent.state(:enable)
-                    state.retrieve
-                    unless state.insync?
-                        state.sync
+                event = super()
+#                case self.should
+#                when :running
+#                    provider.start
+#                    event = :service_started
+#                when :stopped
+#                    provider.stop
+#                    event = :service_stopped
+#                else
+#                    self.debug "Not running '%s' and shouldn't be running" %
+#                        self
+#                end
+
+                if property = @parent.property(:enable)
+                    property.retrieve
+                    unless property.insync?
+                        property.sync
                     end
                 end
 
@@ -149,41 +157,13 @@ module Puppet
             end
         end
 
-        newparam(:type) do
-            desc "The service type.  For most platforms, it does not make
-                sense to 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 = type.intern
-                end
-                if type.is_a?(Symbol)
-                    typeklass = @parent.class.svctype(type)
-                end
-                @parent.extend(typeklass)
-
-                # Return the name, not the object
-                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
@@ -202,6 +182,16 @@ module Puppet
                 is in."
             isnamevar
         end
+
+        newparam(:type) do
+            desc "Deprecated form of ``provider``."
+
+            munge do |value|
+                warning "'type' is deprecated; use 'provider' instead"
+                @parent[:provider] = value
+            end
+        end
+
         newparam(:path) do
             desc "The search path for finding init scripts."
 
@@ -269,55 +259,21 @@ module Puppet
             desc "Specify a *stop* command manually."
         end
 
-        # 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
-                when "CentOS", "RedHat", "Fedora":
-                    @defsvctype = self.svctype(:redhat)
-                else
-                    if Facter["kernel"] == "Linux"
-                        Puppet.notice "Using service type %s for %s" %
-                            ["init", Facter["operatingsystem"].value]
-                        @defsvctype = self.svctype(:init)
-                    end
-                end
-
-                unless @defsvctype
-                    Puppet.info "Defaulting to base service type"
-                    @defsvctype = self.svctype(:base)
-                end
-            end
-
-            unless defined? @notifieddefault
-                Puppet.debug "Default service type is %s" % @defsvctype.name
-                @notifieddefault = true
-            end
-
-            return @defsvctype.name
+        newparam :hasrestart do
+            desc "Specify that an init script has a ``restart`` option.  Otherwise,
+                the init script's ``stop`` and ``start`` methods are used."
+            newvalues(:true, :false)
         end
 
         # List all available services
         def self.list
-            # First see if the default service type can list services for us
-            deftype = svctype(defaulttype())
+            defprov = defaultprovider
 
             names = []
-            if deftype.respond_to? :list
-                deftype.list(deftype.name)
+            if defprov.respond_to? :list
+                defprov.list(defprov.name)
             else
-                Puppet.debug "Type %s does not respond to list" % deftype.name
+                Puppet.debug "Type %s does not respond to list" % defprov.name
             end
 
             self.collect { |s| s }
@@ -342,139 +298,6 @@ module Puppet
             @paths[type].dup
         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)
-
-            # Add our parent, if it exists
-            if parent
-                mod.send(:include, parent)
-            end
-
-            # And now define the support methods
-            code = %{
-                def self.name
-                    "#{svcname}"
-                end
-
-                def self.inspect
-                    "SvcType(#{svcname})"
-                end
-
-                def self.to_s
-                    "SvcType(#{svcname})"
-                end
-
-                def svctype
-                    "#{svcname}"
-                end
-            }
-
-            mod.module_eval(code)
-
-            mod.module_eval(&block)
-
-            # Extend the service type with the util stuff
-            mod.send(:include, Puppet::Util)
-
-            #unless mod.respond_to? :list
-            #    Puppet.debug "Service type %s has no list method" % name
-            #end
-
-            # "module_function" makes the :list method private, so if the parent
-            # method also called module_function, then it's already private
-            if mod.public_method_defined? :list or mod.private_method_defined? :list
-                mod.send(:module_function, :list)
-            end
-
-            # mark it as a valid type
-            unless defined? @typeparam
-                @typeparam = @parameters.find { |p| p.name == :type }
-
-                unless @typeparam
-                    raise Puppet::DevError, "Could not package type parameter"
-                end
-            end
-            @typeparam.newvalues(name)
-
-            # And add it to our list of types
-            @modules ||= Hash.new do |hash, key|
-                if key.is_a?(String)
-                    key = key.intern
-                end
-
-                if hash.include?(key)
-                    hash[key]
-                else
-                    nil
-                end
-            end
-            @modules[name] = mod
-        end
-
-        # Retrieve a service type.
-        def self.svctype(name)
-            name = name.intern if name.is_a? String
-
-            # Try autoloading lacking service types.
-            unless @modules.include? name
-                begin
-                    require "puppet/type/service/#{name}"
-                    unless @modules.include? name
-                        Puppet.warning(
-                            "Loaded puppet/type/service/#{name} but " +
-                            "service type was not created"
-                        )
-                    end
-                rescue LoadError
-                    # nothing
-                end
-            end
-            @modules[name]
-        end
-
-        # Execute a command.  Basically just makes sure it exits with a 0
-        # code.
-        def execute(type, cmd)
-            self.debug "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
-
-        # 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'"
-                )
-            end
-            regex = Regexp.new(self[: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
-
         # Initialize the service.  This is basically responsible for merging
         # in the right module.
         def initialize(hash)
@@ -486,94 +309,15 @@ module Puppet
             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.debug "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
-                self.debug "PID is %s" % pid
-                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
-
-        # 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
+            # Only restart if we're supposed to be running
+            if ens = @parameters[:ensure] and ens.should == :running and ens.is == :running
+                provider.restart
             end
         end
     end
 end
 
-# Load all of the different service types.  We could probably get away with
-# loading less here, but it's not a big deal to do so.
-require 'puppet/type/service/base'
-require 'puppet/type/service/init'
-require 'puppet/type/service/debian'
-require 'puppet/type/service/redhat'
-require 'puppet/type/service/smf'
-
-# $Id: service.rb 1295 2006-06-17 02:04:50Z luke $
+# $Id: service.rb 2409 2007-04-24 06:20:21Z luke $