puppet 0.23.0 → 0.23.1

data/lib/puppet/parser/resource.rb

@@ -207,9 +207,9 @@ class Puppet::Parser::Resource
         db_resource.ar_hash_merge(db_resource.get_tag_hash(), 
                                   updated_tags,
                                   :create => Proc.new { |name, tag|
-                                      db_resource.add_resource_tag(tag)
-                                  }, :delete => Proc.new { |rt|
-                                      rt.each { |tag| db_resource.resource_tags.delete(tag) }
+                                      db_resource.add_resource_tag(name)
+                                  }, :delete => Proc.new { |tag|
+                                      db_resource.resource_tags.delete(tag)
                                   }, :modify => Proc.new { |db, mem|
                                       # nothing here
                                   })
@@ -263,8 +263,14 @@ class Puppet::Parser::Resource
         paramcheck(param.name)
 
         if current = @params[param.name]
-            # XXX Should we ignore any settings that have the same values?
+            # This is where we'd ignore any equivalent values if we wanted to,
+            # but that would introduce a lot of really bad ordering issues.
             if param.source.child_of?(current.source)
+                if param.add
+                    # Merge with previous value.
+                    param.value = [ current.value, param.value ].flatten
+                end
+
                 # Replace it, keeping all of its info.
                 @params[param.name] = param
             else
@@ -273,17 +279,20 @@ class Puppet::Parser::Resource
                 end
                 msg = "Parameter '%s' is already set on %s" % 
                     [param.name, self.to_s]
-                if param.source.to_s != ""
-                    msg += " by %s" % param.source
+                if current.source.to_s != ""
+                    msg += " by %s" % current.source
                 end
-                if param.file or param.line
+                if current.file or current.line
                     fields = []
-                    fields << param.file if param.file
-                    fields << param.line.to_s if param.line
+                    fields << current.file if current.file
+                    fields << current.line.to_s if current.line
                     msg += " at %s" % fields.join(":")
                 end
                 msg += "; cannot redefine"
-                fail Puppet::ParseError, msg
+                error = Puppet::ParseError.new(msg)
+                error.file = param.file if param.file
+                error.line = param.line if param.line
+                raise error
             end
         else
             if self.source == param.source or param.source.child_of?(self.source)
@@ -393,4 +402,4 @@ class Puppet::Parser::Resource
     end
 end
 
-# $Id: resource.rb 2597 2007-06-17 21:41:50Z luke $
+# $Id: resource.rb 2693 2007-07-14 17:46:37Z luke $

data/lib/puppet/parser/resource/param.rb

@@ -1,6 +1,6 @@
  # The parameters we stick in Resources.
 class Puppet::Parser::Resource::Param
-    attr_accessor :name, :value, :source, :line, :file
+    attr_accessor :name, :value, :source, :line, :file, :add
     include Puppet::Util
     include Puppet::Util::Errors
     include Puppet::Util::MethodHelper
@@ -18,17 +18,30 @@ class Puppet::Parser::Resource::Param
     def line_to_i
         return line ? Integer(line) : nil
     end
+
+    # Make sure an array (or possibly not an array) of values is correctly
+    # set up for Rails.  The main thing is that Resource::Reference objects
+    # should stay objects, so they just get serialized.
+    def munge_for_rails(values)
+        values = value.is_a?(Array) ? value : [value]
+        values.map do |v|
+            if v.is_a?(Puppet::Parser::Resource::Reference)
+                v
+            else
+                v.to_s
+            end
+        end
+    end
     
     # Store a new parameter in a Rails db.
     def to_rails(db_resource)
-        values = value.is_a?(Array) ? value : [value]
-        values = values.map { |v| v.to_s }
+        values = munge_for_rails(value)
 
         param_name = Puppet::Rails::ParamName.find_or_create_by_name(self.name.to_s)
         line_number = line_to_i()
 
         return values.collect do |v|
-            db_resource.param_values.create(:value => v.to_s,
+            db_resource.param_values.create(:value => v,
                                            :line => line_number,
                                            :param_name => param_name)
         end
@@ -44,7 +57,7 @@ class Puppet::Parser::Resource::Param
         values_to_add(db_values).each { |add_me| 
             db_resource = db_values[0].resource
             db_param_name = db_values[0].param_name
-            db_resource.param_values.create(:value => add_me.to_s,
+            db_resource.param_values.create(:value => add_me,
                                            :line => line_number,
                                            :param_name => db_param_name)
         }
@@ -55,8 +68,7 @@ class Puppet::Parser::Resource::Param
     end
     
     def values_to_remove(db_values)
-        values = value.is_a?(Array) ? value : [value]
-        values = values.map { |v| v.to_s }
+        values = munge_for_rails(value)
         line_number = line_to_i()
         db_values.collect do |db|
             db unless (db.line == line_number && 
@@ -67,8 +79,7 @@ class Puppet::Parser::Resource::Param
     end
 
     def values_to_add(db_values)
-        values = value.is_a?(Array) ? value : [value]
-        values = values.map { |v| v.to_s }
+        values = munge_for_rails(value)
         line_number = line_to_i()
         values.collect do |v|
             v unless db_values.find { |db| (v == db.value && 
@@ -77,4 +88,4 @@ class Puppet::Parser::Resource::Param
     end
 end
 
-# $Id: param.rb 2597 2007-06-17 21:41:50Z luke $
+# $Id: param.rb 2706 2007-07-18 19:47:09Z luke $

data/lib/puppet/parser/resource/reference.rb

@@ -32,7 +32,7 @@ class Puppet::Parser::Resource::Reference
             if tmp = @scope.finddefine(self.type)
                 @definedtype = tmp
             else
-                fail Puppet::ParseError, "Could not find definition %s" % self.type
+                fail Puppet::ParseError, "Could not find resource type '%s'" % self.type
             end
         end
 
@@ -68,4 +68,4 @@ class Puppet::Parser::Resource::Reference
     end
 end
 
-# $Id: reference.rb 1967 2006-12-23 06:26:39Z luke $
+# $Id: reference.rb 2664 2007-07-09 20:54:35Z luke $

data/lib/puppet/parser/scope.rb

@@ -115,11 +115,19 @@ class Puppet::Parser::Scope
     # that subclasses can set their parent scopes to be the scope of
     # their parent class.
     def class_scope(klass)
-        if klass.respond_to?(:classname)
+        scope = if klass.respond_to?(:classname)
             @classtable[klass.classname]
         else
             @classtable[klass]
         end
+
+        return nil unless scope
+
+        if scope.nodescope? and ! klass.is_a?(AST::Node)
+            raise Puppet::ParseError, "Node %s has already been evaluated; cannot evaluate class with same name" % [klass.classname]
+        end
+
+        scope
     end
 
     # Return the list of collections.
@@ -442,6 +450,14 @@ class Puppet::Parser::Scope
         return Puppet::Parser::Scope.new(hash)
     end
 
+    # Is this class for a node?  This is used to make sure that
+    # nodes and classes with the same name conflict (#620), which
+    # is required because of how often the names are used throughout
+    # the system, including on the client.
+    def nodescope?
+        defined?(@nodescope) and @nodescope
+    end
+
     # Return the list of remaining overrides.
     def overrides
         #@overridetable.collect { |name, overs| overs }.flatten
@@ -452,14 +468,6 @@ class Puppet::Parser::Scope
         @definedtable.values
     end
 
-    def setclass?(obj)
-        if obj.respond_to?(:classname)
-            @classtable.has_key?(obj.classname)
-        else
-            @classtable[obj]
-        end
-    end
-
     # Store the fact that we've evaluated a given class.  We use a hash
     # that gets inherited from the top scope down, rather than a global
     # hash.  We store the object ID, not class name, so that we
@@ -474,6 +482,10 @@ class Puppet::Parser::Scope
         else
             raise Puppet::DevError, "Invalid class %s" % obj.inspect
         end
+        if obj.is_a?(AST::Node)
+            @nodescope = true
+        end
+        nil
     end
 
     # Set all of our facts in the top-level scope.
@@ -728,4 +740,4 @@ class Puppet::Parser::Scope
     end
 end
 
-# $Id: scope.rb 2562 2007-06-11 21:54:37Z luke $
+# $Id: scope.rb 2646 2007-07-04 21:06:26Z luke $

data/lib/puppet/{type/property.rb → property.rb}

@@ -2,7 +2,6 @@
 # blocks for actually doing work on the system.
 
 require 'puppet'
-require 'puppet/element'
 require 'puppet/propertychange'
 require 'puppet/parameter'
 
@@ -14,10 +13,30 @@ class Property < Puppet::Parameter
     # they can be retrieved and compared later when merging.
     attr_reader :shouldorig
 
+    attr_writer :noop
+
     class << self
         attr_accessor :unmanaged
         attr_reader :name
 
+        # Return array matching info, defaulting to just matching
+        # the first value.
+        def array_matching
+            unless defined?(@array_matching)
+                @array_matching = :first
+            end
+            @array_matching
+        end
+
+        # Set whether properties should match all values or just the first one.
+        def array_matching=(value)
+            value = value.intern if value.is_a?(String)
+            unless [:first, :all].include?(value)
+                raise ArgumentError, "Supported values for Property#array_matching are 'first' and 'all'"
+            end
+            @array_matching = value
+        end
+
         def checkable
             @checkable = true
         end
@@ -254,11 +273,15 @@ class Property < Puppet::Parameter
         end
 
         # Look for a matching value
-        @should.each { |val|
-            if is == val or is == val.to_s
-                return true
-            end
-        }
+        if match_all?
+            return (is == @should or is == @should.collect { |v| v.to_s })
+        else
+            @should.each { |val|
+                if is == val or is == val.to_s
+                    return true
+                end
+            }
+        end
 
         # otherwise, return false
         return false
@@ -285,6 +308,11 @@ class Property < Puppet::Parameter
         )
     end
 
+    # Should we match all values, or just the first?
+    def match_all?
+        self.class.array_matching == :all
+    end
+
     # each property class must define the name() method, and property instances
     # do not change that name
     # this implicitly means that a given object can only have one property
@@ -295,15 +323,16 @@ class Property < Puppet::Parameter
 
     # for testing whether we should actually do anything
     def noop
-        unless defined? @noop
-            @noop = false
-        end
-        if self.resource.respond_to?(:noop)
-            tmp = @noop || self.resource.noop || Puppet[:noop] || false
+        # This is only here to make testing easier.
+        if @resource.respond_to?(:noop?)
+            @resource.noop?
         else
-            tmp = @noop || Puppet[:noop] || false
+            if defined?(@noop)
+                @noop
+            else
+                Puppet[:noop]
+            end
         end
-        return tmp
     end
 
     # By default, call the method associated with the property name on our
@@ -351,7 +380,11 @@ class Property < Puppet::Parameter
                 self.devfail "should for %s on %s is not an array" %
                     [self.class.name, @resource.name]
             end
-            return @should[0]
+            if match_all?
+                return @should
+            else
+                return @should[0]
+            end
         else
             return nil
         end
@@ -524,4 +557,4 @@ class Property < Puppet::Parameter
 end
 end
 
-# $Id: property.rb 2500 2007-05-09 22:05:32Z luke $
+# $Id: property.rb 2678 2007-07-11 19:30:42Z luke $

data/lib/puppet/propertychange.rb

@@ -40,7 +40,7 @@ module Puppet
             # default to a simple event type
             unless name.is_a?(Symbol)
                 @property.warning("Property '%s' returned invalid event '%s'; resetting to default" %
-                    [@property.class,event])
+                    [@property.class, name])
 
                 event = @property.resource.class.name.id2name + "_changed"
             end
@@ -53,7 +53,7 @@ module Puppet
         end
 
         def initialize(property, currentvalue)
-            unless property.is_a?(Puppet::Type::Property)
+            unless property.is_a?(Puppet::Property)
                 raise Puppet::DevError, "Got a %s instead of a property" %
                     property.class
             end
@@ -140,4 +140,4 @@ module Puppet
 	end
 end
 
-# $Id: propertychange.rb 2500 2007-05-09 22:05:32Z luke $
+# $Id: propertychange.rb 2678 2007-07-11 19:30:42Z luke $

data/lib/puppet/provider/cron/crontab.rb

@@ -14,9 +14,9 @@ Puppet::Type.type(:cron).provide(:crontab,
 ) do
     commands :crontab => "crontab"
 
-    text_line :comment, :match => %r{^#}, :post_parse => proc { |hash|
-        if hash[:line] =~ /Puppet Name: (.+)\s*$/
-            hash[:name] = $1
+    text_line :comment, :match => %r{^#}, :post_parse => proc { |record|
+        if record[:line] =~ /Puppet Name: (.+)\s*$/
+            record[:name] = $1
         end
     }
 
@@ -25,11 +25,12 @@ Puppet::Type.type(:cron).provide(:crontab,
     text_line :environment, :match => %r{^\w+=}
 
     record_line :freebsd_special, :fields => %w{special command},
-        :match => %r{^@(\w+)\s+(.+)$}, :pre_gen => proc { |hash|
-            hash[:special] = "@" + hash[:special]
+        :match => %r{^@(\w+)\s+(.+)$}, :pre_gen => proc { |record|
+            record[:special] = "@" + record[:special]
         }
 
     crontab = record_line :crontab, :fields => %w{minute hour monthday month weekday command},
+        :match => %r{^(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(.+)$},
         :optional => %w{minute hour weekday month monthday}, :absent => "*"
 
     class << crontab
@@ -38,37 +39,37 @@ Puppet::Type.type(:cron).provide(:crontab,
         end
         # Do some post-processing of the parsed record.  Basically just
         # split the numeric fields on ','.
-        def post_parse(details)
+        def post_parse(record)
             numeric_fields.each do |field|
-                if val = details[field] and val != :absent
-                    details[field] = details[field].split(",")
+                if val = record[field] and val != :absent
+                    record[field] = record[field].split(",")
                 end
             end
         end
 
         # Join the fields back up based on ','.
-        def pre_gen(details)
+        def pre_gen(record)
             numeric_fields.each do |field|
-                if vals = details[field] and vals.is_a?(Array)
-                    details[field] = vals.join(",")
+                if vals = record[field] and vals.is_a?(Array)
+                    record[field] = vals.join(",")
                 end
             end
         end
 
 
         # Add name and environments as necessary.
-        def to_line(details)
+        def to_line(record)
             str = ""
-            if details[:name]
-                str = "# Puppet Name: %s\n" % details[:name]
+            if record[:name]
+                str = "# Puppet Name: %s\n" % record[:name]
             end
-            if details[:environment] and details[:environment] != :absent and details[:environment] != [:absent]
-                details[:environment].each do |env|
+            if record[:environment] and record[:environment] != :absent and record[:environment] != [:absent]
+                record[:environment].each do |env|
                     str += env + "\n"
                 end
             end
 
-            str += join(details)
+            str += join(record)
             str
         end
     end
@@ -83,47 +84,48 @@ Puppet::Type.type(:cron).provide(:crontab,
 # HEADER not be deleted, as doing so could cause duplicate cron jobs.\n}
     end
 
-    # See if we can match the hash against an existing cron job.
-    def self.match(hash, resources)
-        resources.each do |name, obj|
-            # we now have a cron job whose command exactly matches
-            # let's see if the other fields match
+    # See if we can match the record against an existing cron job.
+    def self.match(record, resources)
+        resources.each do |name, resource|
+            # Match the command first, since it's the most important one.
+            next unless record[:target] == resource.value(:target)
+            next unless record[:command] == resource.value(:command)
 
-            # First check the @special stuff
-            if hash[:special]
-                next unless obj.value(:special) == hash[:special]
+            # Then check the @special stuff
+            if record[:special]
+                next unless resource.value(:special) == record[:special]
             end
 
             # Then the normal fields.
             matched = true
-            record_type(hash[:record_type]).fields().each do |field|
+            record_type(record[:record_type]).fields().each do |field|
                 next if field == :command
-                if hash[field] and ! obj.value(field)
+                next if field == :special
+                if record[field] and ! resource.value(field)
                     Puppet.info "Cron is missing %s: %s and %s" %
-                        [field, hash[field].inspect, obj.value(field).inspect]
+                        [field, record[field].inspect, resource.value(field).inspect]
                     matched = false
                     break
                 end
 
-                if ! hash[field] and obj.value(field)
+                if ! record[field] and resource.value(field)
                     Puppet.info "Hash is missing %s: %s and %s" %
-                        [field, obj.value(field).inspect, hash[field].inspect]
+                        [field, resource.value(field).inspect, record[field].inspect]
                     matched = false
                     break
                 end
 
                 # Yay differing definitions of absent.
-                next if (hash[field] == :absent and obj.value(field) == "*")
+                next if (record[field] == :absent and resource.value(field) == "*")
 
                 # Everything should be in the form of arrays, not the normal text.
-                next if (hash[field] == obj.value(field))
+                next if (record[field] == resource.value(field))
                 Puppet.info "Did not match %s: %s vs %s" %
-                    [field, obj.value(field).inspect, hash[field].inspect]
+                    [field, resource.value(field).inspect, record[field].inspect]
                 matched = false 
                 break
             end
-            next unless matched
-            return obj
+            return resource if matched
         end
 
         return false
@@ -183,4 +185,4 @@ Puppet::Type.type(:cron).provide(:crontab,
     end
 end
 
-# $Id: crontab.rb 2624 2007-06-19 01:49:19Z luke $
+# $Id: crontab.rb 2697 2007-07-14 21:13:04Z luke $