puppet 0.24.9 → 0.25.0

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

@@ -1,4 +1,5 @@
 require 'puppet/file_collection/lookup'
+require 'puppet/parser/yaml_trimmer'
 
  # The parameters we stick in Resources.
 class Puppet::Parser::Resource::Param
@@ -8,6 +9,7 @@ class Puppet::Parser::Resource::Param
     include Puppet::Util::MethodHelper
 
     include Puppet::FileCollection::Lookup
+    include Puppet::Parser::YamlTrimmer
 
     def initialize(hash)
         set_options(hash)
@@ -15,87 +17,11 @@ class Puppet::Parser::Resource::Param
         @name = symbolize(@name)
     end
 
-    def inspect
-        "#<#{self.class} @name => #{name}, @value => #{value}, @source => #{source.name}, @line => #{line}>"
-    end
-
     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 = 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,
-                                           :line => line_number,
-                                           :param_name => param_name)
-        end
-    end
-
-    def modify_rails_values(db_values)
-        #dev_warn if db_values.nil? || db_values.empty?
-
-        values_to_remove(db_values).each { |remove_me|
-            Puppet::Rails::ParamValue.delete(remove_me['id'])
-        }
-        line_number = line_to_i()
-        db_param_name = db_values[0]['param_name_id']
-        values_to_add(db_values).each { |add_me|
-            Puppet::Rails::ParamValue.create(:value => add_me,
-                                           :line => line_number,
-                                           :param_name_id => db_param_name,
-                                           :resource_id => db_values[0]['resource_id'] )
-        }
-    end
-    
     def to_s
         "%s => %s" % [self.name, self.value]
     end
-
-    def compare(v,db_value)
-      if (v.is_a?(Puppet::Parser::Resource::Reference))
-        return v.to_s == db_value.to_s
-      else
-        return v == db_value
-      end
-    end
-    
-    def values_to_remove(db_values)
-        values = munge_for_rails(value)
-        line_number = line_to_i()
-        db_values.collect do |db|
-            db unless (db['line'] == line_number && 
-                       values.find { |v| 
-                         compare(v,db['value'])
-                       } )
-        end.compact
-    end
-
-    def values_to_add(db_values)
-        values = munge_for_rails(value)
-        line_number = line_to_i()
-        values.collect do |v|
-            v unless db_values.find { |db| (compare(v,db['value']) && 
-                                         line_number == db['line']) }
-        end.compact
-    end
 end
-

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

@@ -1,8 +1,11 @@
-require 'puppet/resource_reference'
+# A reference to a resource.  Mostly just the type and title.
+require 'puppet/resource/reference'
 require 'puppet/file_collection/lookup'
+require 'puppet/parser/yaml_trimmer'
 
 # A reference to a resource.  Mostly just the type and title.
-class Puppet::Parser::Resource::Reference < Puppet::ResourceReference
+class Puppet::Parser::Resource::Reference < Puppet::Resource::Reference
+    include Puppet::Parser::YamlTrimmer
     include Puppet::FileCollection::Lookup
     include Puppet::Util::MethodHelper
     include Puppet::Util::Errors
@@ -35,22 +38,22 @@ class Puppet::Parser::Resource::Reference < Puppet::ResourceReference
     def definedtype
         unless defined? @definedtype
             case self.type
-            when "Class": # look for host classes
+            when "Class" # look for host classes
                 if self.title == :main
-                    tmp = @scope.findclass("")
+                    tmp = @scope.find_hostclass("")
                 else
-                    unless tmp = @scope.parser.classes[self.title]
+                    unless tmp = @scope.parser.hostclass(self.title)
                         fail Puppet::ParseError, "Could not find class '%s'" % self.title
                     end
                 end
-            when "Node": # look for node definitions
-                unless tmp = @scope.parser.nodes[self.title]
+            when "Node" # look for node definitions
+                unless tmp = @scope.parser.node(self.title)
                     fail Puppet::ParseError, "Could not find node '%s'" % self.title
                 end
             else # normal definitions
                 # The resource type is capitalized, so we have to downcase.  Really,
                 # we should have a better interface for finding these, but eh.
-                tmp = @scope.parser.definitions[self.type.downcase]
+                tmp = @scope.parser.definition(self.type.downcase)
             end
 
             if tmp
@@ -68,6 +71,10 @@ class Puppet::Parser::Resource::Reference < Puppet::ResourceReference
         requiredopts(:type, :title)
     end
 
+    def skip_for_yaml
+        %w{@typeclass @definedtype}
+    end
+
     def to_ref
         # We have to return different cases to provide backward compatibility
         # from 0.24.x to 0.23.x.

data/lib/puppet/parser/scope.rb

@@ -15,9 +15,10 @@ class Puppet::Parser::Scope
 
     include Enumerable
     include Puppet::Util::Errors
-    attr_accessor :parent, :level, :parser, :source, :resource
+    attr_accessor :level, :parser, :source, :resource
     attr_accessor :base, :keyword, :nodescope
     attr_accessor :top, :translated, :compiler
+    attr_writer :parent
 
     # A demeterific shortcut to the catalog.
     def catalog
@@ -48,7 +49,7 @@ class Puppet::Parser::Scope
         unless value.is_a?(Fixnum) or value.is_a?(Bignum) or value.is_a?(Float) or value.is_a?(String)
             return nil
         end
-        
+
         if value.is_a?(String)
             if value =~ /^-?\d+(:?\.\d+|(:?\.\d+)?e\d+)$/
                 return value.to_f
@@ -81,18 +82,18 @@ class Puppet::Parser::Scope
         @level == 1
     end
 
-    def findclass(name)
+    def find_hostclass(name)
         @namespaces.each do |namespace|
-            if r = parser.findclass(namespace, name)
+            if r = parser.find_hostclass(namespace, name)
                 return r
             end
         end
         return nil
     end
 
-    def finddefine(name)
+    def find_definition(name)
         @namespaces.each do |namespace|
-            if r = parser.finddefine(namespace, name)
+            if r = parser.find_definition(namespace, name)
                 return r
             end
         end
@@ -127,6 +128,11 @@ class Puppet::Parser::Scope
         # The symbol table for this scope.  This is where we store variables.
         @symtable = {}
 
+        # the ephemeral symbol tables
+        # those should not persist long, and are used for the moment only
+        # for $0..$xy capture variables of regexes
+        @ephemeral = {}
+
         # All of the defaults set for types.  It's a hash of hashes,
         # with the first key being the type, then the second key being
         # the parameter.
@@ -164,19 +170,21 @@ class Puppet::Parser::Scope
 
     # Look up a defined type.
     def lookuptype(name)
-        finddefine(name) || findclass(name)
+        find_definition(name) || find_hostclass(name)
     end
 
     def lookup_qualified_var(name, usestring)
         parts = name.split(/::/)
         shortname = parts.pop
         klassname = parts.join("::")
-        klass = findclass(klassname)
+        klass = find_hostclass(klassname)
         unless klass
-            raise Puppet::ParseError, "Could not find class %s" % klassname
+            warning "Could not look up qualified variable '%s'; class %s could not be found" % [name, klassname]
+            return usestring ? "" : :undefined
         end
         unless kscope = compiler.class_scope(klass)
-            raise Puppet::ParseError, "Class %s has not been evaluated so its variables cannot be referenced" % klass.classname
+            warning "Could not look up qualified variable '%s'; class %s has not been evaluated" % [name, klassname]
+            return usestring ? "" : :undefined
         end
         return kscope.lookupvar(shortname, usestring)
     end
@@ -186,18 +194,19 @@ class Puppet::Parser::Scope
     # Look up a variable.  The simplest value search we do.  Default to returning
     # an empty string for missing values, but support returning a constant.
     def lookupvar(name, usestring = true)
+        table = ephemeral?(name) ? @ephemeral : @symtable
         # If the variable is qualified, then find the specified scope and look the variable up there instead.
         if name =~ /::/
             return lookup_qualified_var(name, usestring)
         end
-        # We can't use "if @symtable[name]" here because the value might be false
-        if @symtable.include?(name)
-            if usestring and @symtable[name] == :undef
+        # We can't use "if table[name]" here because the value might be false
+        if table.include?(name)
+            if usestring and table[name] == :undef
                 return ""
             else
-                return @symtable[name]
+                return table[name]
             end
-        elsif self.parent 
+        elsif self.parent
             return parent.lookupvar(name, usestring)
         elsif usestring
             return ""
@@ -214,12 +223,12 @@ class Puppet::Parser::Scope
             target = parent.to_hash(recursive)
         end
         target ||= Hash.new
-        @symtable.keys.each { |name| 
+        @symtable.keys.each { |name|
             value = @symtable[name]
             if value == :undef then
                 target.delete(name)
             else
-                target[name] = value 
+                target[name] = value
             end
         }
         return target
@@ -283,34 +292,35 @@ class Puppet::Parser::Scope
     # Set a variable in the current scope.  This will override settings
     # in scopes above, but will not allow variables in the current scope
     # to be reassigned.
-    def setvar(name,value, file = nil, line = nil, append = false)
+    def setvar(name,value, options = {})
+        table = options[:ephemeral] ? @ephemeral : @symtable
         #Puppet.debug "Setting %s to '%s' at level %s mode append %s" %
         #    [name.inspect,value,self.level, append]
-        if @symtable.include?(name)
-            unless append
+        if table.include?(name)
+            unless options[:append]
                 error = Puppet::ParseError.new("Cannot reassign variable %s" % name)
             else
                 error = Puppet::ParseError.new("Cannot append, variable %s is defined in this scope" % name)
             end
-            if file
-                error.file = file
+            if options[:file]
+                error.file = options[:file]
             end
-            if line
-                error.line = line
+            if options[:line]
+                error.line = options[:line]
             end
             raise error
         end
-        
-        unless append
-            @symtable[name] = value
+
+        unless options[:append]
+            table[name] = value
         else # append case
             # lookup the value in the scope if it exists and insert the var
-            @symtable[name] = lookupvar(name)
+            table[name] = lookupvar(name)
             # concatenate if string, append if array, nothing for other types
             if value.is_a?(Array)
-                @symtable[name] += value
+                table[name] += value
             else
-                @symtable[name] << value
+                table[name] << value
             end
         end
     end
@@ -321,12 +331,17 @@ class Puppet::Parser::Scope
         ss = StringScanner.new(string)
         out = ""
         while not ss.eos?
-            if ss.scan(/^\$\{((\w*::)*\w+)\}|^\$((\w*::)*\w+)/) 
+            if ss.scan(/^\$\{((\w*::)*\w+|[0-9]+)\}|^\$([0-9])|^\$((\w*::)*\w+)/)
                 # If it matches the backslash, then just retun the dollar sign.
                 if ss.matched == '\\$'
                     out << '$'
                 else # look the variable up
-                    out << lookupvar(ss[1] || ss[3]).to_s || ""
+                    # make sure $0-$9 are lookupable only if ephemeral
+                    var = ss[1] || ss[3] || ss[4]
+                    if var and var =~ /^[0-9]+$/ and not ephemeral?(var)
+                        next
+                    end
+                    out << lookupvar(var).to_s || ""
                 end
             elsif ss.scan(/^\\(.)/)
                 # Puppet.debug("Got escape: pos:%d; m:%s" % [ss.pos, ss.matched])
@@ -356,7 +371,7 @@ class Puppet::Parser::Scope
                 out << '$'
             elsif ss.scan(/^\\\n/) # an escaped carriage return
                 next
-            else 
+            else
                 tmp = ss.scan(/[^\\$]+/)
                 # Puppet.debug("Got other: pos:%d; m:%s" % [ss.pos, tmp])
                 unless tmp
@@ -388,8 +403,26 @@ class Puppet::Parser::Scope
 
     # Undefine a variable; only used for testing.
     def unsetvar(var)
-        if @symtable.include?(var)
-            @symtable.delete(var)
+        table = ephemeral?(var) ? @ephemeral : @symtable
+        if table.include?(var)
+            table.delete(var)
+        end
+    end
+
+    def unset_ephemeral_var
+        @ephemeral = {}
+    end
+
+    def ephemeral?(name)
+        @ephemeral.include?(name)
+    end
+
+    def ephemeral_from(match, file = nil, line = nil)
+        raise(ArgumentError,"Invalid regex match data") unless match.is_a?(MatchData)
+
+        setvar("0", match[0], :file => file, :line => line, :ephemeral => true)
+        match.captures.each_with_index do |m,i|
+            setvar("#{i+1}", m, :file => file, :line => line, :ephemeral => true)
         end
     end
 end

data/lib/puppet/parser/templatewrapper.rb

@@ -1,7 +1,11 @@
 # A simple wrapper for templates, so they don't have full access to
 # the scope objects.
+require 'puppet/parser/files'
+
 class Puppet::Parser::TemplateWrapper
-    attr_accessor :scope, :file, :string
+    attr_writer :scope
+    attr_reader :file
+    attr_accessor :string
     include Puppet::Util
     Puppet::Util.logmethods(self)
 
@@ -63,11 +67,8 @@ class Puppet::Parser::TemplateWrapper
     end
 
     def file=(filename)
-        @file = Puppet::Module::find_template(filename, scope.compiler.environment)
-
-        unless FileTest.exists?(file)
-            raise Puppet::ParseError,
-                "Could not find template %s" % file
+        unless @file = Puppet::Parser::Files.find_template(filename, scope.compiler.environment)
+            raise Puppet::ParseError, "Could not find template '%s'" % filename
         end
 
         # We'll only ever not have a parser in testing, but, eh.
@@ -90,7 +91,7 @@ class Puppet::Parser::TemplateWrapper
         # current object, making it possible to access them without conflict
         # to the regular methods.
         benchmark(:debug, "Bound template variables for #{template_source}") do
-            scope.to_hash.each { |name, value| 
+            scope.to_hash.each { |name, value|
                 if name.kind_of?(String)
                     realname = name.gsub(/[^\w]/, "_")
                 else
@@ -113,4 +114,3 @@ class Puppet::Parser::TemplateWrapper
         "template[%s]" % (file ? file : "inline")
     end
 end
-

data/lib/puppet/parser/yaml_trimmer.rb

@@ -0,0 +1,11 @@
+module Puppet::Parser::YamlTrimmer
+    REMOVE = %w{@scope @source}
+
+    def to_yaml_properties
+        r = instance_variables - REMOVE
+        if respond_to?(:skip_for_yaml)
+            r -= skip_for_yaml()
+        end
+        r
+    end
+end

data/lib/puppet/property.rb

@@ -4,8 +4,7 @@
 require 'puppet'
 require 'puppet/parameter'
 
-module Puppet
-class Property < Puppet::Parameter
+class Puppet::Property < Puppet::Parameter
 
     # Because 'should' uses an array, we have a special method for handling
     # it.  We also want to keep copies of the original values, so that
@@ -54,92 +53,39 @@ class Property < Puppet::Parameter
     end
 
     # Look up a value's name, so we can find options and such.
-    def self.value_name(value)
-        if value != '' and name = symbolize(value) and @parametervalues.include?(name)
-            return name
-        elsif ary = self.match?(value)
-            return ary[0]
-        else
-            return nil
+    def self.value_name(name)
+        if value = value_collection.match?(name)
+            value.name
         end
     end
 
     # Retrieve an option set when a value was defined.
     def self.value_option(name, option)
-        option = option.to_sym
-        if hash = @parameteroptions[name]
-            hash[option]
-        else
-            nil
+        if value = value_collection.value(name)
+            value.send(option)
         end
     end
 
-    # Create the value management variables.
-    def self.initvars
-        @parametervalues = {}
-        @aliasvalues = {}
-        @parameterregexes = {}
-        @parameteroptions = {}
-    end
-
     # Define a new valid value for a property.  You must provide the value itself,
     # usually as a symbol, or a regex to match the value.
     #
     # The first argument to the method is either the value itself or a regex.
     # The second argument is an option hash; valid options are:
+    # * <tt>:method</tt>: The name of the method to define.  Defaults to 'set_<value>'.
+    # * <tt>:required_features</tt>: A list of features this value requires.
     # * <tt>:event</tt>: The event that should be returned when this value is set.
     # * <tt>:call</tt>: When to call any associated block.  The default value
     #   is ``instead``, which means to call the value instead of calling the
-    #   provider.  You can also specify ``before`` or ``after``, which will 
+    #   provider.  You can also specify ``before`` or ``after``, which will
     #   call both the block and the provider, according to the order you specify
     #   (the ``first`` refers to when the block is called, not the provider).
     def self.newvalue(name, options = {}, &block)
-        name = name.intern if name.is_a? String
-
-        @parameteroptions[name] = {}
-        paramopts = @parameteroptions[name]
+        value = value_collection.newvalue(name, options, &block)
 
-        # Symbolize everything
-        options.each do |opt, val|
-            paramopts[symbolize(opt)] = symbolize(val)
-        end
-
-        # By default, call the block instead of the provider.
-        if block_given?
-            paramopts[:call] ||= :instead
-        else
-            paramopts[:call] ||= :none
-        end
-        # If there was no block given, we still want to store the information
-        # for validation, but we won't be defining a method
-        block ||= true
-
-        case name
-        when Symbol
-            if @parametervalues.include?(name)
-                Puppet.warning "%s reassigning value %s" % [self.name, name]
-            end
-            @parametervalues[name] = block
-
-            if block_given?
-                method = "set_" + name.to_s
-                settor = paramopts[:settor] || (self.name.to_s + "=")
-                define_method(method, &block)
-                paramopts[:method] = method
-            end
-        when Regexp
-            # The regexes are handled in parameter.rb.  This value is used
-            # for validation.
-            @parameterregexes[name] = block
-
-            # This is used for looking up the block for execution.
-            if block_given?
-                paramopts[:block] = block
-            end
-        else
-            raise ArgumentError, "Invalid value %s of type %s" %
-                [name, name.class]
+        if value.method and value.block
+            define_method(value.method, &value.block)
         end
+        value
     end
 
     # Call the provider method.
@@ -175,9 +121,9 @@ class Property < Puppet::Parameter
         elsif block = self.class.value_option(name, :block)
             # FIXME It'd be better here to define a method, so that
             # the blocks could return values.
-            # If the regex was defined with no associated block, then just pass
-            # through and the correct event will be passed back.
             event = self.instance_eval(&block)
+        else
+            devfail "Could not find method for value '%s'" % name
         end
         return event, name
     end
@@ -206,7 +152,7 @@ class Property < Puppet::Parameter
     # Figure out which event to return.
     def event(name, event = nil)
         if value_event = self.class.value_option(name, :event)
-            return value_event 
+            return value_event
         end
 
         if event and event.is_a?(Symbol)
@@ -219,8 +165,8 @@ class Property < Puppet::Parameter
 
         if self.class.name == :ensure
             event = case self.should
-            when :present: (@resource.class.name.to_s + "_created").intern
-            when :absent: (@resource.class.name.to_s + "_removed").intern
+            when :present; (@resource.class.name.to_s + "_created").intern
+            when :absent; (@resource.class.name.to_s + "_removed").intern
             else
                 (@resource.class.name.to_s + "_changed").intern
             end
@@ -230,19 +176,15 @@ class Property < Puppet::Parameter
 
         return event
     end
-    
+
+    attr_reader :shadow
+
     # initialize our property
     def initialize(hash = {})
         super
-    end
-
-    def inspect
-        str = "Property('%s', " % self.name
 
-        if defined? @should and @should
-            str += "@should = '%s')" % @should.join(", ")
-        else
-            str += "@should = nil)"
+        if ! self.metaparam? and klass = Puppet::Type.metaparamclass(self.class.name)
+            setup_shadow(klass)
         end
     end
 
@@ -308,6 +250,13 @@ class Property < Puppet::Parameter
         self.class.array_matching == :all
     end
 
+    # Execute our shadow's munge code, too, if we have one.
+    def munge(value)
+        self.shadow.munge(value) if self.shadow
+
+        super
+    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
@@ -342,29 +291,39 @@ class Property < Puppet::Parameter
         # Set a name for looking up associated options like the event.
         name = self.class.value_name(value)
 
-        call = self.class.value_option(name, :call)
+        call = self.class.value_option(name, :call) || :none
 
-        # If we're supposed to call the block first or instead, call it now
-        if call == :before or call == :instead
-            event, tmp = call_valuemethod(name, value) 
-        end
-        unless call == :instead
+        if call == :instead
+            event, tmp = call_valuemethod(name, value)
+        elsif call == :none
             if @resource.provider
                 call_provider(value)
             else
                 # They haven't provided a block, and our parent does not have
                 # a provider, so we have no idea how to handle this.
-                self.fail "%s cannot handle values of type %s" %
-                    [self.class.name, value.inspect]
+                self.fail "%s cannot handle values of type %s" % [self.class.name, value.inspect]
             end
-        end
-        if call == :after
-            event, tmp = call_valuemethod(name, value) 
+        else
+            # LAK:NOTE 20081031 This is a change in behaviour -- you could
+            # previously specify :call => [;before|:after], which would call
+            # the setter *in addition to* the block.  I'm convinced this
+            # was never used, and it makes things unecessarily complicated.
+            # If you want to specify a block and still call the setter, then
+            # do so in the block.
+            devfail "Cannot use obsolete :call value '%s' for property '%s'" % [call, self.class.name]
         end
 
         return event(name, event)
     end
 
+    # If there's a shadowing metaparam, instantiate it now.
+    # This allows us to create a property or parameter with the
+    # same name as a metaparameter, and the metaparam will only be
+    # stored as a shadow.
+    def setup_shadow(klass)
+        @shadow = klass.new(:resource => self.resource)
+    end
+
     # Only return the first value
     def should
         if defined? @should
@@ -373,9 +332,9 @@ class Property < Puppet::Parameter
                     [self.class.name, @resource.name]
             end
             if match_all?
-                return @should
+                return @should.collect { |val| self.unmunge(val) }
             else
-                return @should[0]
+                return self.unmunge(@should[0])
             end
         else
             return nil
@@ -390,18 +349,8 @@ class Property < Puppet::Parameter
 
         @shouldorig = values
 
-        if self.respond_to?(:validate)
-            values.each { |val|
-                validate(val)
-            }
-        end
-        if self.respond_to?(:munge)
-            @should = values.collect { |val|
-                self.munge(val)
-            }
-        else
-            @should = values
-        end
+        values.each { |val| validate(val) }
+        @should = values.collect { |val| self.munge(val) }
     end
 
     def should_to_s(newvalue)
@@ -413,10 +362,7 @@ class Property < Puppet::Parameter
         end
     end
 
-    # The default 'sync' method only selects among a list of registered # values.
     def sync
-        self.devfail("No values defined for %s" % self.class.name) unless self.class.values
-
         if value = self.should
             set(value)
         else
@@ -424,23 +370,24 @@ class Property < Puppet::Parameter
         end
     end
 
-    # The properties need to return tags so that logs correctly collect them.
-    def tags
-        unless defined? @tags
-            @tags = []
-            # This might not be true in testing
-            if @resource.respond_to? :tags
-                @tags = @resource.tags
-            end
-            @tags << self.name
-        end
-        @tags
-    end
-
     def to_s
         return "%s(%s)" % [@resource.name,self.name]
     end
 
+    # Verify that the passed value is valid.
+    # If the developer uses a 'validate' hook, this method will get overridden.
+    def unsafe_validate(value)
+        super
+        validate_features_per_value(value)
+    end
+
+    # Make sure that we've got all of the required features for a given value.
+    def validate_features_per_value(value)
+        if features = self.class.value_option(self.class.value_name(value), :required_features)
+            raise ArgumentError, "Provider must have features '%s' to set '%s' to '%s'" % [features.collect { |f| f.to_s }.join(", "), self.class.name, value] unless provider.satisfies?(features)
+        end
+    end
+
     # Just return any should value we might have.
     def value
         self.should
@@ -545,5 +492,3 @@ class Property < Puppet::Parameter
         end
     end
 end
-end
-