puppet 0.16.0 → 0.18.4

data/lib/puppet/type/component.rb

@@ -77,10 +77,18 @@ module Puppet
         # dependencies.  This will get run once on the top-level component,
         # and it will do everything necessary.
         def finalize
+            started = {}
             finished = {}
             
             # First do all of the finish work, which mostly involves
             self.delve do |object|
+                # Make sure we don't get into loops
+                if started.has_key?(object)
+                    debug "Already finished %s" % object.name
+                    next
+                else
+                    started[object] = true
+                end
                 unless finished.has_key?(object)
                     object.finish
                     object.builddepends
@@ -133,20 +141,6 @@ module Puppet
             return @name
         end
 
-        def push(*ary)
-            ary.each { |child|
-                unless child.is_a?(Puppet::Element)
-                    self.debug "Got object of type %s" % child.class
-                    self.devfail(
-                        "Containers can only contain Puppet::Elements, not %s" %
-                        child.class
-                    )
-                end
-                @children.push child
-                child.parent = self
-            }
-        end
-
         def refresh
             @children.collect { |child|
                 if child.respond_to?(:refresh)
@@ -156,16 +150,10 @@ module Puppet
             }
         end
 
-        #def retrieve
-        #    self.collect { |child|
-        #        child.retrieve
-        #    }
-        #end
-
         def to_s
             return "component(%s)" % self.name
         end
 	end
 end
 
-# $Id: component.rb 965 2006-03-02 07:30:14Z luke $
+# $Id: component.rb 1246 2006-06-08 20:38:44Z luke $

data/lib/puppet/type/cron.rb

@@ -10,7 +10,6 @@ module Puppet
     # completely symbolic 'name' paremeter, which gets written to the file
     # and is used to manage the job.
     newtype(:cron) do
-        ensurable
 
         # A base class for all of the Cron parameters, since they all have
         # similar argument checking going on.  We're stealing the base class
@@ -18,20 +17,16 @@ module Puppet
         # but it was just too annoying to do.
         class CronParam < Puppet::State::ParsedParam
             class << self
-                attr_accessor :boundaries
+                attr_accessor :boundaries, :default
             end
 
             # We have to override the parent method, because we consume the entire
             # "should" array
             def insync?
-                if self.class.name == :command
-                    return super
+                if defined? @should and @should
+                    self.is_to_s == self.should_to_s
                 else
-                    if @is.is_a? Array
-                        return @is == @should
-                    else
-                        return @is == @should[0]
-                    end
+                    true
                 end
             end
 
@@ -81,23 +76,35 @@ module Puppet
                 return false
             end
 
-            def is_to_s
-                if @is.empty?
-                    return "*"
-                else
-                    if @is.is_a? Array
-                        return @is.join(",")
+            def should_to_s
+                if @should
+                    unless @should.is_a?(Array)
+                        fail "wtf?"
+                    end
+
+                    if self.name == :command or @should[0].is_a? Symbol
+                        @should[0]
                     else
-                        return @is.to_s
+                        @should.join(",")
                     end
+                else
+                    nil
                 end
             end
 
-            def should_to_s
-                if ! defined? @should or @should.empty?
-                    return "*"
+            def is_to_s
+                if @is
+                    unless @is.is_a?(Array)
+                        return @is
+                    end
+
+                    if self.name == :command or @is[0].is_a? Symbol
+                        @is[0]
+                    else
+                        @is.join(",")
+                    end
                 else
-                    return @should.join(",")
+                    nil
                 end
             end
 
@@ -112,6 +119,21 @@ module Puppet
                 if value == "absent" or value == :absent
                     return :absent
                 end
+
+                # Allow the */2 syntax
+                if value =~ /^\*\/[0-9]+$/
+                    return value
+                end
+
+                # Allow ranges
+                if value =~ /^[0-9]+-[0-9]+$/
+                    return value
+                end
+
+                if value == "*"
+                    return value
+                end
+
                 return value unless self.class.boundaries
                 lower, upper = self.class.boundaries
                 retval = nil
@@ -132,6 +154,15 @@ module Puppet
                 end
             end
         end
+
+
+        # Override 'newstate' so that all states default to having the
+        # correct parent type
+        def self.newstate(name, parent = nil, &block)
+            parent ||= Puppet::State::CronParam
+            super(name, parent, &block)
+        end
+
         # Somewhat uniquely, this state does not actually change anything -- it
         # just calls +@parent.sync+, which writes out the whole cron tab for
         # the user in question.  There is no real way to change individual cron
@@ -148,6 +179,33 @@ module Puppet
                 
                 All cron parameters support ``absent`` as a value; this will
                 remove any existing values for that field."
+
+            def should
+                if @should
+                    if @should.is_a? Array
+                        @should[0]
+                    else
+                        devfail "command is not an array"
+                    end
+                else
+                    nil
+                end
+            end
+        end
+
+        newstate(:special, Puppet::State::ParsedParam) do
+            desc "Special schedules only supported on FreeBSD."
+
+            def specials
+                %w{reboot yearly annually monthly weekly daily midnight hourly}
+            end
+
+            validate do |value|
+                unless specials().include?(value)
+                    raise ArgumentError, "Invalid special schedule %s" %
+                        value.inspect
+                end
+            end
         end
 
         newstate(:minute, CronParam) do
@@ -188,17 +246,58 @@ module Puppet
                 command.  Optional; if specified, must be between 1 and 31."
         end
 
+        newstate(:environment, Puppet::State::ParsedParam) do
+            desc "Any environment settings associated with this cron job.  They
+                will be stored between the header and the job in the crontab.  There
+                can be no guarantees that other, earlier settings will not also
+                affect a given cron job.
+
+                Also, Puppet cannot automatically determine whether an existing,
+                unmanaged environment setting is associated with a given cron
+                job.  If you already have cron jobs with environment settings,
+                then Puppet will keep those settings in the same place in the file,
+                but will not associate them with a specific job."
+
+            validate do |value|
+                unless value =~ /^\s*(\w+)\s*=\s*(.+)\s*$/
+                    raise ArgumentError, "Invalid environment setting %s" %
+                        value.inspect
+                end
+            end
+
+            def insync?
+                if @is.is_a? Array
+                    return @is.sort == @should.sort
+                else
+                    return @is == @should[0]
+                end
+            end
+
+            def should
+                @should
+            end
+        end
+
         newparam(:name) do
             desc "The symbolic name of the cron job.  This name
                 is used for human reference only and is generated automatically
                 for cron jobs found on the system.  This generally won't
                 matter, as Puppet will do its best to match existing cron jobs
-                against specified jobs (and Puppet adds a tag to cron jobs it
+                against specified jobs (and Puppet adds a comment to cron jobs it
                 adds), but it is at least possible that converting from
                 unmanaged jobs to managed jobs might require manual
-                intervention."
+                intervention.
+                
+                The names can only have alphanumeric characters plus the '-'
+                character."
 
             isnamevar
+
+            validate do |value|
+                unless value =~ /^[-\w]+$/
+                    raise ArgumentError, "Invalid name format '%s'" % value
+                end
+            end
         end
 
         newparam(:user) do
@@ -232,7 +331,7 @@ module Puppet
             association is made and synced to disk, you can then manage the job
             normally (e.g., change the schedule of the job).
             
-            Example::
+            Example:
                 
                 cron { logrotate:
                     command => \"/usr/sbin/logrotate\",
@@ -247,17 +346,18 @@ module Puppet
 
         class << self
             attr_accessor :filetype
+
+            def cronobj(name)
+                if defined? @tabs
+                    return @tabs[name]
+                else
+                    return nil
+                end
+            end
         end
 
         attr_accessor :uid
 
-        # Override the Puppet::Type#[]= method so that we can store the instances
-        # in per-user arrays.  Then just call +super+.
-        def self.[]=(name, object)
-            self.instance(object)
-            super
-        end
-
         # In addition to removing the instances in @objects, Cron has to remove
         # per-user cron tab information.
         def self.clear
@@ -293,6 +393,55 @@ module Puppet
             return [:minute, :hour, :monthday, :month, :weekday, :command]
         end
 
+        # Convert our hash to an object
+        def self.hash2obj(hash)
+            obj = nil
+            namevar = self.namevar
+            unless hash.include?(namevar) and hash[namevar]
+                Puppet.info "Autogenerating name for %s" % hash[:command]
+                hash[:name] = "autocron-%s" % hash.object_id
+            end
+
+            unless hash.include?(:command)
+                raise Puppet::DevError, "No command for %s" % name
+            end
+            # if the cron already exists with that name...
+            if obj = (self[hash[:name]] || match(hash))
+                # Mark the cron job as present
+                obj.is = [:ensure, :present]
+
+                # Mark all of the values appropriately
+                hash.each { |param, value|
+                    if state = obj.state(param)
+                        state.is = value
+                    elsif val = obj[param]
+                        obj[param] = val
+                    else    
+                        # There is a value on disk, but it should go away
+                        obj.is = [param, value]
+                        obj[param] = :absent
+                    end
+                }
+            else
+                # create a new cron job, since no existing one
+                # seems to match
+                obj = self.create(
+                    :name => hash[namevar]
+                )
+
+                obj.is = [:ensure, :present]
+
+                obj.notice "created"
+
+                hash.delete(namevar)
+                hash.each { |param, value|
+                    obj.is = [param, value]
+                }
+            end
+
+            instance(obj)
+        end
+
         # Return the header placed at the top of each generated file, warning
         # users that modifying this file manually is probably a bad idea.
         def self.header
@@ -302,16 +451,13 @@ module Puppet
 # HEADER not be deleted, as doing so could cause duplicate cron jobs.\n}
         end
 
-        # Store a new instance of a cron job.  Called from Cron#initialize.
         def self.instance(obj)
             user = obj[:user]
-            if @instances.include?(user)
-                unless @instances[obj[:user]].include?(obj)
-                    @instances[obj[:user]] << obj
-                end
-            else
-                @instances[obj[:user]] = [obj]
+            unless @instances.include?(user)
+                @instances[user] = []
             end
+
+            @instances[user] << obj
         end
 
         def self.list
@@ -323,6 +469,53 @@ module Puppet
             self.collect { |c| c }
         end
 
+        # See if we can match the hash against an existing cron job.
+        def self.match(hash)
+            self.find_all { |obj|
+                obj[:user] == hash[:user] and obj.value(:command) == hash[:command][0]
+            }.each do |obj|
+                # we now have a cron job whose command exactly matches
+                # let's see if the other fields match
+
+                # First check the @special stuff
+                if hash[:special]
+                    next unless obj.value(:special) == hash[:special]
+                end
+
+                # Then the normal fields.
+                matched = true
+                fields().each do |field|
+                    next if field == :command
+                    if hash[field] and ! obj.value(field)
+                        #Puppet.info "Cron is missing %s: %s and %s" %
+                        #    [field, hash[field].inspect, obj.value(field).inspect]
+                        matched = false
+                        break
+                    end
+
+                    if ! hash[field] and obj.value(field)
+                        #Puppet.info "Hash is missing %s: %s and %s" %
+                        #    [field, obj.value(field).inspect, hash[field].inspect]
+                        matched = false
+                        break
+                    end
+
+                    # FIXME It'd be great if I could somehow reuse how the
+                    # fields are turned into text, but....
+                    next if (hash[field] == [:absent] and obj.value(field) == "*")
+                    next if (hash[field].join(",") == obj.value(field))
+                    #Puppet.info "Did not match %s: %s vs %s" %
+                    #    [field, obj.value(field).inspect, hash[field].inspect]
+                    matched = false 
+                    break
+                end
+                next unless matched
+                return obj
+            end
+
+            return false
+        end
+
         # Parse a user's cron job into individual cron objects.
         #
         # Autogenerates names for any jobs that don't already have one; these
@@ -334,74 +527,67 @@ module Puppet
         def self.parse(user, text)
             count = 0
             hash = {}
-            name = nil
-            unless @instances.include?(user)
-                @instances[user] = []
-            end
+
+            envs = []
             text.chomp.split("\n").each { |line|
                 case line
-                when /^# Puppet Name: (\w+)$/: name = $1
+                when /^# Puppet Name: (.+)$/
+                    hash[:name] = $1
+                    next
                 when /^#/:
                     # add other comments to the list as they are
                     @instances[user] << line 
+                    next
+                when /^\s*(\w+)\s*=\s*(.+)\s*$/:
+                    # Match env settings.
+                    if hash[:name]
+                        envs << line
+                    else
+                        @instances[user] << line 
+                    end
+                    next
+                when /^@(\w+)\s+(.+)/ # FreeBSD special cron crap
+                    fields().each do |field|
+                        next if field == :command
+                        hash[field] = :absent
+                    end
+                    hash[:special] = $1
+                    hash[:command] = $2
                 else
                     if match = /^(\S+) (\S+) (\S+) (\S+) (\S+) (.+)$/.match(line)
                         fields().zip(match.captures).each { |param, value|
-                            unless value == "*"
-                                unless param == :command
+                            if value == "*"
+                                hash[param] = [:absent]
+                            else
+                                if param == :command
+                                    hash[param] = [value]
+                                else
                                     # We always want the 'is' value to be an
                                     # array
-                                    value = value.split(",")
+                                    hash[param] = value.split(",")
                                 end
-                                hash[param] = value
                             end
                         }
                     else
-                        raise Puppet::Error, "Could not match '%s'" % line
+                        # Don't fail on unmatched lines, just warn on them
+                        # and skip them.
+                        Puppet.warning "Could not match '%s'" % line
+                        next
                     end
+                end
 
-                    cron = nil
-                    unless name
-                        Puppet.info "Autogenerating name for %s" % hash[:command]
-                        name = "cron-%s" % hash.object_id
-                    end
+                unless envs.empty?
+                    hash[:environment] = envs
+                end
 
-                    unless hash.include?(:command)
-                        raise Puppet::DevError, "No command for %s" % name
-                    end
-                    # if the cron already exists with that name...
-                    if cron = Puppet.type(:cron)[name]
-                        # Mark the cron job as present
-                        cron.is = [:ensure, :present]
-                    elsif tmp = @instances[user].reject { |obj|
-                                ! obj.is_a?(self)
-                            }.find { |obj|
-                                obj.should(:command) == hash[:command]
-                            }
-                        # if we can find a cron whose spec exactly matches
-
-                        # we now have a cron job whose command exactly matches
-                        # let's see if the other fields match
-                        txt = tmp.to_record.sub(/#.+\n/,'')
-
-                        if txt == line
-                            cron = tmp
-                        end
-                    else
-                        # create a new cron job, since no existing one
-                        # seems to match
-                        cron = self.create(
-                            :name => name
-                        )
-                    end
+                hash[:user] = user
 
-                    hash.each { |param, value|
-                        cron.is = [param, value]
-                    }
-                    hash.clear
-                    name = nil
-                    count += 1
-                end
+                # Now convert our hash to an object.
+                hash2obj(hash)
+
+                hash = {}
+                envs.clear
+                count += 1
             }
         end
 
@@ -427,10 +613,16 @@ module Puppet
                 self.find_all { |obj|
                     obj[:user] == user
                 }.each { |obj|
-                    obj.each { |state|
-                        state.is = :absent
-                    }
+                    obj.is = [:ensure, :absent]
                 }
+
+                # Get rid of the old instances, so we don't get duplicates
+                if @instances.include?(user)
+                    @instances[user].clear
+                else
+                    @instances[user] = []
+                end
+
                 self.parse(user, text)
             end
         end
@@ -443,14 +635,24 @@ module Puppet
 
         # Store the user's cron tab.  Collects the text of the new tab and
         # sends it to the +@filetype+ module's +write+ function.  Also adds
-        # header warning users not to modify the file directly.
+        # header, warning users not to modify the file directly.
         def self.store(user)
-            @tabs[user] ||= @filetype.new(user)
-            if @instances.include?(user)
-                @tabs[user].write(self.tab(user))
-            else
+            unless @instances.include?(user) or @objects.find do |n,o|
+                o[:user] == user
+            end
                 Puppet.notice "No cron instances for %s" % user
+                return
+            end
+
+            @tabs[user] ||= @filetype.new(user)
+
+            self.each do |inst|
+                unless (@instances[user] and @instances[user].include? inst)
+                    @instances[user] ||= []
+                    @instances[user] << inst
+                end
             end
+            @tabs[user].write(self.tab(user))
         end
 
         # Collect all Cron instances for a given user and convert them
@@ -460,8 +662,6 @@ module Puppet
             if @instances.include?(user)
                 return self.header() + @instances[user].reject { |obj|
                     if obj.is_a?(self) and obj.should(:ensure) == :absent
-                        #obj.log "now absent"
-                        #obj.is = [:ensure, :absent]
                         true
                     else
                         false
@@ -502,21 +702,11 @@ module Puppet
         def destroy
             # nothing, since the 'Cron.tab' method just doesn't write out
             # crons whose 'ensure' states are set to 'absent'.
-            #@states.each { |n, state|
-            #    next if n == :ensure
-            #    state.should == :absent
-            #}
             self.store
         end
 
         def exists?
-            val = false
-            if @states.include?(:command) and
-                @states[:command].is != :absent and
-                ! @states[:command].is.nil?
-                val = true
-            end
-            return val
+            @states.include?(:ensure) and @states[:ensure].is == :present
         end
 
         # Override the default Puppet::Type method because we need to call
@@ -527,7 +717,15 @@ module Puppet
             end
 
             self.class.retrieve(self[:user])
-            self.eachstate { |st| st.retrieve }
+            if withtab = self.class["testwithtab"]
+                Puppet.info withtab.is(:ensure).inspect
+            end
+            self.eachstate { |st|
+                st.retrieve
+            }
+            if withtab = self.class["testwithtab"]
+                Puppet.info withtab.is(:ensure).inspect
+            end
         end
 
         # Write the entire user's cron tab out.
@@ -538,25 +736,78 @@ module Puppet
         # Convert the current object a cron-style string.  Adds the cron name
         # as a comment above the cron job, in the form '# Puppet Name: <name>'.
         def to_record
-            hash = {:command => @states[:command].should || @states[:command].is }
+            hash = {}
 
             # Collect all of the values that we have
-            self.class.fields().reject { |f| f == :command }.each { |param|
-                if @states.include?(param)
-                    hash[param] = @states[param].should_to_s
+            self.class.fields().each { |param|
+                hash[param] = self.value(param)
+
+                unless hash[param]
+                    devfail "Got no value for %s" % param
                 end
             }
 
-            return "# Puppet Name: %s\n" % self.name +
-                self.class.fields.collect { |f|
+            str = ""
+
+            str = "# Puppet Name: %s\n" % self.name
+
+            if @states.include?(:environment) and
+                @states[:environment].should != :absent
+                    envs = @states[:environment].should
+                    unless envs.is_a? Array
+                        envs = [envs]
+                    end
+
+                    envs.each do |line| str += (line + "\n") end
+            end
+
+            line = nil
+            if special = self.value(:special)
+                line = str + "@%s %s" %
+                    [special, self.value(:command)]
+            else
+                line = str + self.class.fields.collect { |f|
                     if hash[f] and hash[f] != :absent
                         hash[f]
                     else
                         "*"
                     end
                 }.join(" ")
+            end
+
+            return line
+        end
+
+        def value(name)
+            name = name.intern if name.is_a? String
+            ret = nil
+            if @states.include?(name)
+                ret = @states[name].should_to_s
+
+                if ret == :absent or ret.nil?
+                    ret = @states[name].is_to_s
+                end
+
+                if ret == :absent
+                    ret = nil
+                end
+            end
+
+            unless ret
+                case name
+                when :command
+                    devfail "No command, somehow"
+                when :special
+                    # nothing
+                else
+                    #ret = (self.class.validstate?(name).default || "*").to_s
+                    ret = "*"
+                end
+            end
+
+            ret
         end
     end
 end
 
-# $Id: cron.rb 1127 2006-04-21 02:36:30Z luke $
+# $Id: cron.rb 1402 2006-07-18 15:35:15Z luke $