puppet 0.13.1 → 0.13.2

data/lib/puppet/parser/scope.rb

@@ -169,9 +169,16 @@ module Puppet
             # Evaluate a specific node's code.  This method will normally be called
             # on the top-level scope, but it actually evaluates the node at the
             # appropriate scope.
-            def evalnode(names, facts)
-                scope = code = nil
+            def evalnode(names, facts, classes = nil, parent = nil)
+                # First make sure there aren't any other node scopes lying around
+                self.nodeclean
 
+                # If they've passed classes in, then just generate from there.
+                if classes
+                    return self.gennode(names, facts, classes, parent)
+                end
+
+                scope = code = nil
                 # Find a node that matches one of our names
                 names.each { |node|
                     if hash = @nodetable[node]
@@ -187,9 +194,6 @@ module Puppet
                         names.join(" or ")
                 end
 
-                # First make sure there aren't any other node scopes lying around
-                self.nodeclean
-
                 # We need to do a little skullduggery here.  We want a
                 # temporary scope, because we don't want this scope to
                 # show up permanently in the scope tree -- otherwise we could
@@ -221,6 +225,40 @@ module Puppet
                 return objects
             end
 
+            # Pull in all of the appropriate classes and evaluate them.  It'd
+            # be nice if this didn't know quite so much about how AST::Node
+            # operated internally.
+            def gennode(names, facts, classes, parent)
+                name = names.shift
+                arghash = {
+                    :name => name,
+                    :code => AST::ASTArray.new(:pin => "[]")
+                }
+
+                if parent
+                    arghash[:parentclass] = parent
+                end
+
+                # Create the node
+                node = AST::Node.new(arghash)
+                node.keyword = "node"
+                node.name = name
+
+                # Now evaluate it, which evaluates the parent but doesn't really
+                # do anything else but does return the nodescope
+                scope = node.safeevaluate(self)
+
+                # And now evaluate each set klass within the nodescope.
+                classes.each { |klass|
+                    if code = scope.lookuptype(klass)
+                        Puppet.warning "evaluating %s" % klass
+                        code.safeevaluate(scope, {}, klass, klass)
+                    end
+                }
+
+                return scope.to_trans
+            end
+
             # Retrieve a specific node.  This is used in ast.rb to find a
             # parent node and in findnode to retrieve and evaluate a node.
             def node(name)
@@ -773,4 +811,4 @@ module Puppet
     end
 end
 
-# $Id: scope.rb 898 2006-02-13 17:13:09Z luke $
+# $Id: scope.rb 909 2006-02-14 06:21:04Z luke $

data/lib/puppet/type.rb

@@ -452,6 +452,8 @@ class Type < Puppet::Element
 
         @@metaparamhash ||= {}
         @@metaparams.each { |p| @@metaparamhash[name] = p }
+
+        return param
     end
 
     def self.eachmetaparam
@@ -486,6 +488,8 @@ class Type < Puppet::Element
         if param.isnamevar?
             @namevar = param.name
         end
+
+        return param
     end
 
     # Create a new state.
@@ -896,13 +900,17 @@ class Type < Puppet::Element
     # in order resolve other questions, such as finding a package
     # in a list
     def managed?
-        if defined? @managed
+        # Once an object is managed, it always stays managed; but an object
+        # that is listed as unmanaged might become managed later in the process,
+        # so we have to check that every time
+        if defined? @managed and @managed
             return @managed
         else
             @managed = false
             states.each { |state|
                 if state.should and ! state.class.unmanaged
                     @managed = true
+                    break
                 end
             }
             return @managed
@@ -1103,10 +1111,16 @@ class Type < Puppet::Element
 
                 return retobj
             else
+                # If only one of the objects is being managed, then merge them
+                if retobj.managed?
+                    raise Puppet::Error, "%s '%s' is already being managed" %
+                        [self.name, name]
+                else
+                    retobj.merge(hash)
+                    return retobj
+                end
                 # We will probably want to support merging of some kind in
                 # the future, but for now, just throw an error.
-                raise Puppet::Error, "%s '%s' is already being managed" %
-                    [self.name, name]
                 #retobj.merge(hash)
 
                 #return retobj
@@ -1337,6 +1351,13 @@ class Type < Puppet::Element
         if self.respond_to?(:validate)
             self.validate
         end
+
+        # Ensure defaults to present for managed objects, but not otherwise.
+        # Because of this complication, we can't use normal defaulting mechanisms
+#        if ! @states.include?(:ensure) and self.managed? and
+#                    self.class.validstate?(:ensure)
+#            self[:ensure] = :present
+#        end
     end
 
     # Figure out of there are any objects we can automatically add as
@@ -1354,12 +1375,19 @@ class Type < Puppet::Element
 
             # Collect the current prereqs
             list.each { |dep|
-                # Skip autorequires that we aren't managing
-                next unless obj = typeobj[dep]
+                obj = nil
+                # Support them passing objects directly, to save some effort.
+                if dep.is_a? Puppet::Type
+                    type = dep.class.name
+                    obj = dep
+                else
+                    # Skip autorequires that we aren't managing
+                    next unless obj = typeobj[dep]
+                end
 
                 # Skip autorequires that we already require
                 next if self.requires?(obj)
-                self.info "Auto-requiring %s" % obj.name
+                #self.info "Auto-requiring %s %s" % [obj.class.name, obj.name]
 
                 self[:require] = [type, dep]
             }
@@ -1469,8 +1497,14 @@ class Type < Puppet::Element
             next if self.attrset?(type, klass.name)
 
             obj = self.newattr(type, klass)
-            #self.debug "defaulting %s to %s" % [obj.name, obj.default]
-            obj.value = obj.default
+            value = obj.default
+            unless value.nil?
+                #self.debug "defaulting %s to %s" % [obj.name, obj.default]
+                obj.value = value
+            else
+                #self.debug "No default for %s" % obj.name
+                self.delete(obj.name)
+            end
         }
 
     end
@@ -1493,7 +1527,7 @@ class Type < Puppet::Element
                 value = [value]
             end
 
-            if oldvals = @states[param].shouldorig
+            if @states.include?(param) and oldvals = @states[param].shouldorig
                 unless oldvals.is_a?(Array)
                     oldvals = [oldvals]
                 end
@@ -1521,6 +1555,9 @@ class Type < Puppet::Element
                 self[param] = value
             end
         }
+
+        # Set the defaults again, just in case.
+        self.setdefaults
     end
 
     # derive the instance name based on class.namevar
@@ -1654,23 +1691,9 @@ class Type < Puppet::Element
             @evalcount = 0
         end
         @@retrieved[self] += 1
-        # if we're a metaclass and we've already evaluated once...
-        #if self.metaclass and @evalcount > 0
-        #    return
-        #end
         @evalcount += 1
 
-        #changes = @children.collect { |child|
-        #    child.evaluate
-        #}
-
         changes = []
-        # collect all of the changes from children and states
-        #if self.class.depthfirst?
-        #    changes << self.collect { |child|
-        #        child.evaluate
-        #    }
-        #end
 
         # this only operates on states, not states + children
         # it's important that we call retrieve() on the type instance,
@@ -1694,16 +1717,6 @@ class Type < Puppet::Element
             child.cache(:checked, now)
             ch
         }
-        #unless self.class.depthfirst?
-        #    changes << self.collect { |child|
-        #        child.evaluate
-        #    }
-        #end
-        # collect changes and return them
-        # these changes could be from child objects or from contained states
-        #self.collect { |child|
-        #    child.evaluate
-        #}
 
         if self.class.depthfirst?
             changes += statechanges()
@@ -1716,9 +1729,6 @@ class Type < Puppet::Element
         if changes.length > 0
             self.info "%s change(s)" %
                 [changes.length]
-            #changes.each { |change|
-            #    self.debug "change: %s" % change.state.name
-            #}
         end
         self.cache(:checked, now)
         return changes.flatten
@@ -2199,4 +2209,4 @@ require 'puppet/type/user'
 require 'puppet/type/tidy'
 require 'puppet/type/parsedtype'
 
-# $Id: type.rb 900 2006-02-13 18:00:17Z luke $
+# $Id: type.rb 914 2006-02-15 21:04:14Z luke $

data/lib/puppet/type/cron.rb

@@ -103,6 +103,11 @@ module Puppet
             # a boolean of whether to do alpha checking, and if so requires
             # the ary against which to do the checking.
             munge do |value|
+                # Support 'absent' as a value, so that they can remove
+                # a value
+                if value == "absent" or value == :absent
+                    return :absent
+                end
                 return value unless self.class.boundaries
                 lower, upper = self.class.boundaries
                 retval = nil
@@ -135,7 +140,10 @@ module Puppet
                 provided to the command varies by local system rules, and it is
                 best to always provide a fully qualified command.  The user's
                 profile is not sourced when the command is run, so if the
-                user's environment is desired it should be sourced manually."
+                user's environment is desired it should be sourced manually.
+                
+                All cron parameters support ``absent`` as a value; this will
+                remove any existing values for that field."
         end
 
         newstate(:minute, CronParam) do
@@ -178,12 +186,13 @@ module Puppet
 
         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 adds), but it is at least possible that converting
-                from unmanaged jobs to managed jobs might require manual intervention."
+                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
+                adds), but it is at least possible that converting from
+                unmanaged jobs to managed jobs might require manual
+                intervention."
 
             isnamevar
         end
@@ -487,7 +496,9 @@ module Puppet
 
         def exists?
             val = false
-            if @states.include?(:command) and @states[:command].is != :absent
+            if @states.include?(:command) and
+                @states[:command].is != :absent and
+                ! @states[:command].is.nil?
                 val = true
             end
             return val
@@ -523,10 +534,14 @@ module Puppet
 
             return "# Puppet Name: %s\n" % self.name +
                 self.class.fields.collect { |f|
-                    hash[f] || "*"
+                    if hash[f] and hash[f] != :absent
+                        hash[f]
+                    else
+                        "*"
+                    end
                 }.join(" ")
         end
     end
 end
 
-# $Id: cron.rb 898 2006-02-13 17:13:09Z luke $
+# $Id: cron.rb 910 2006-02-15 07:20:36Z luke $

data/lib/puppet/type/exec.rb

@@ -17,14 +17,16 @@ module Puppet
 
                 # defined in the production class
                 exec { \"make\":
-                    cwd => \"/prod/build/dir\"
+                    cwd => \"/prod/build/dir\",
+                    path => \"/usr/bin:/usr/sbin:/bin\"
                 }
 
                 . etc. .
 
                 # defined in the test class
                 exec { \"make\":
-                    cwd => \"/test/build/dir\"
+                    cwd => \"/test/build/dir\",
+                    path => \"/usr/bin:/usr/sbin:/bin\"
                 }
 
             Any other type would throw an error, complaining that you had
@@ -45,6 +47,19 @@ module Puppet
         require 'open3'
         require 'puppet/type/state'
 
+        # Create a new check mechanism.  It's basically just a parameter that provides
+        # one extra 'check' method.
+        def self.newcheck(name, &block)
+            @checks ||= {}
+
+            check = newparam(name, &block)
+            @checks[name] = check
+        end
+
+        def self.checks
+            @checks.keys
+        end
+
         newstate(:returns) do |state|
             munge do |value|
                 value.to_s
@@ -96,25 +111,14 @@ module Puppet
                 end
             end
 
-            # because this command always runs,
-            # we're just using retrieve to verify that the command
-            # exists and such
+            # First verify that all of our checks pass.
             def retrieve
-                if file = @parent[:creates]
-                    if FileTest.exists?(file)
-                        @is = true
-                        @should = [true]
-                        return
-                    end
-                end
+                # Default to somethinng
 
-                if self.parent[:refreshonly]
-                    # if refreshonly is enabled, then set things so we
-                    # won't sync
-                    self.is = self.should
+                if @parent.check
+                    self.is = :notrun
                 else
-                    # else, just set it to something we know it won't be
-                    self.is = nil
+                    self.is = self.should
                 end
             end
 
@@ -129,53 +133,24 @@ module Puppet
                 tmppath = ENV["PATH"]
 
                 event = :executed_command
-                begin
-                    # Do our chdir
-                    Dir.chdir(dir) {
-                        if self.parent[:path]
-                            ENV["PATH"] = self.parent[:path].join(":")
-                        end
 
-                        # The user and group default to nil, which 'asuser'
-                        # handlers correctly
-                        Puppet::Util.asuser(@parent[:user], @parent[:group]) {
-                            # capture both stdout and stderr
-                            if @parent[:user]
-                                unless defined? @@alreadywarned
-                                    Puppet.warning(
-                            "Cannot capture STDERR when running as another user"
-                                    )
-                                    @@alreadywarned = true
-                                end
-                                @output = %x{#{self.parent[:command]}}
-                            else
-                                @output = %x{#{self.parent[:command]} 2>&1}
-                            end
-                        }
-                        status = $?
+                @output, status = @parent.run(self.parent[:command])
 
-                        loglevel = @parent[:loglevel]
-                        if status.exitstatus.to_s != self.should.to_s
-                            err("%s returned %s" %
-                                [self.parent[:command],status.exitstatus])
+                loglevel = @parent[:loglevel]
+                if status.exitstatus.to_s != self.should.to_s
+                    err("%s returned %s instead of %s" %
+                        [self.parent[:command], status.exitstatus, self.should.to_s])
 
-                            # if we've had a failure, up the log level
-                            loglevel = :err
-                            event = :failed_command
-                        end
-
-                        # and log
-                        @output.split(/\n/).each { |line|
-                            self.send(loglevel, line)
-                        }
-                    }
-                rescue Errno::ENOENT => detail
-                    self.fail detail.to_s
-                ensure
-                    # reset things to how we found them
-                    ENV["PATH"] = tmppath
+                    # if we've had a failure, up the log level
+                    loglevel = :err
+                    event = :failed_command
                 end
 
+                # and log
+                @output.split(/\n/).each { |line|
+                    self.send(loglevel, line)
+                }
+
                 return event
             end
         end
@@ -276,7 +251,7 @@ module Puppet
             end
         end
 
-        newparam(:refreshonly) do
+        newcheck(:refreshonly) do
             desc "The command should only be run as a
                 refresh mechanism for when a dependent object is changed.  It only
                 makes sense to use this option when this command depends on some
@@ -295,9 +270,15 @@ module Puppet
                     }
                 
                 "
+
+            # We always fail this test, because we're only supposed to run
+            # on refresh.
+            def check
+                false
+            end
         end
 
-        newparam(:creates) do 
+        newcheck(:creates) do 
             desc "A file that this command creates.  If this
                 parameter is provided, then the command will only be run
                 if the specified file does not exist.
@@ -319,6 +300,59 @@ module Puppet
                     self.fail "'creates' files must be fully qualified."
                 end
             end
+
+            # If the file exists, return false (i.e., don't run the command),
+            # else return true
+            def check
+                return ! FileTest.exists?(self.value)
+            end
+        end
+
+        newcheck(:unless) do
+            desc "If this parameter is set, then this +exec+ will run unless
+                the command returns 0.  For example::
+                    
+                    exec { \"/bin/echo root >> /usr/lib/cron/cron.allow\":
+                        path => \"/usr/bin:/usr/sbin:/bin\",
+                        unless => \"grep root /usr/lib/cron/cron.allow 2>/dev/null\"
+                    }
+
+                This would add +root+ to the cron.allow file (on Solaris) unless
+                +grep+ determines it's already there.
+
+                Note that this command follows the same rules as the main command,
+                which is to say that it must be fully qualified if the path is not set.
+                "
+
+            # Return true if the command does not return 0.
+            def check
+                output, status = @parent.run(self.value)
+
+                return status.exitstatus != 0
+            end
+        end
+
+        newcheck(:onlyif) do
+            desc "If this parameter is set, then this +exec+ will only run if
+                the command returns 0.  For example::
+                    
+                    exec { \"logrotate\":
+                        path => \"/usr/bin:/usr/sbin:/bin\",
+                        onlyif => \"test `du /var/log/messages | cut -f1` -gt 100000\"
+                    }
+
+                This would run +logrotate+ only if that test returned true.
+
+                Note that this command follows the same rules as the main command,
+                which is to say that it must be fully qualified if the path is not set.
+                "
+
+            # Return true if the command returns 0.
+            def check
+                output, status = @parent.run(self.value)
+
+                return status.exitstatus == 0
+            end
         end
 
         # Exec names are not isomorphic with the objects.
@@ -341,19 +375,38 @@ module Puppet
                 reqs << self[:cwd]
             end
 
-            tmp = self[:command].dup
+            [:command, :onlyif, :unless].each { |param|
+                next unless tmp = self[param]
 
-            # And search the command line for files, adding any we find.  This
-            # will also catch the command itself if it's fully qualified.  It might
-            # not be a bad idea to add unqualified files, but, well, that's a
-            # bit more annoying to do.
-            while tmp.sub!(%r{(#{File::SEPARATOR}\S+)}, '')
-                reqs << $1
-            end
+                # And search the command line for files, adding any we find.  This
+                # will also catch the command itself if it's fully qualified.  It might
+                # not be a bad idea to add unqualified files, but, well, that's a
+                # bit more annoying to do.
+                reqs += tmp.scan(%r{(#{File::SEPARATOR}\S+)})
+            }
+
+            # For some reason, the += isn't causing a flattening
+            reqs.flatten!
 
             reqs
         end
 
+        # Verify that we pass all of the checks.
+        def check
+            self.class.checks.each { |check|
+                if @parameters.include?(check)
+                    if @parameters[check].check
+                        self.debug "%s returned true" % check
+                    else
+                        self.debug "%s returned false" % check
+                        return false
+                    end
+                end
+            }
+
+            return true
+        end
+
         def output
             if self.state(:returns).nil?
                 return nil
@@ -367,10 +420,51 @@ module Puppet
             self.state(:returns).sync
         end
 
+        # Run a command.
+        def run(command)
+            output = nil
+            status = nil
+            tmppath = ENV["PATH"]
+            dir = self[:cwd] || Dir.pwd
+            begin
+                # Do our chdir
+                Dir.chdir(dir) {
+                    if self[:path]
+                        ENV["PATH"] = self[:path].join(":")
+                    end
+
+                    # The user and group default to nil, which 'asuser'
+                    # handlers correctly
+                    Puppet::Util.asuser(self[:user], self[:group]) {
+                        # capture both stdout and stderr
+                        if self[:user]
+                            unless defined? @@alreadywarned
+                                Puppet.warning(
+                        "Cannot capture STDERR when running as another user"
+                                )
+                                @@alreadywarned = true
+                            end
+                            output = %x{#{command}}
+                        else
+                            output = %x{#{command} 2>&1}
+                        end
+                    }
+                    status = $?.dup
+                }
+            rescue Errno::ENOENT => detail
+                self.fail detail.to_s
+            ensure
+                # reset things to how we found them
+                ENV["PATH"] = tmppath
+            end
+
+            return output, status
+        end
+
         def to_s
             "exec(%s)" % self.name
         end
     end
 end
 
-# $Id: exec.rb 841 2006-01-18 17:24:15Z luke $
+# $Id: exec.rb 907 2006-02-13 21:58:40Z luke $