puppet 0.24.5 → 0.24.6

data/lib/puppet/parser/parser_support.rb

@@ -95,11 +95,10 @@ class Puppet::Parser::Parser
                 raise Puppet::Error, "Could not find file %s" % file
             end
         end
-        if @files.detect { |f| f.file == file }
-            raise Puppet::AlreadyImportedError.new("Import loop detected")
-        else
-            @files << Puppet::Util::LoadedFile.new(file)
+        if check_and_add_to_watched_files(file)
             @lexer.file = file
+        else
+            raise Puppet::AlreadyImportedError.new("Import loop detected")
         end
     end
 
@@ -216,7 +215,7 @@ class Puppet::Parser::Parser
     # Initialize or reset all of our variables.
     def initvars
         @lexer = Puppet::Parser::Lexer.new()
-        @files = []
+        @files = {}
         @loaded = []
     end
 
@@ -435,8 +434,8 @@ class Puppet::Parser::Parser
 
     # See if any of the files have changed.
     def reparse?
-        if file = @files.detect { |file| file.changed?  }
-            return file.stamp
+        if file = @files.detect { |name, file| file.changed?  }
+            return file[1].stamp
         else
             return false
         end
@@ -449,12 +448,18 @@ class Puppet::Parser::Parser
     # Add a new file to be checked when we're checking to see if we should be
     # reparsed.  This is basically only used by the TemplateWrapper to let the
     # parser know about templates that should be parsed.
-    def watch_file(*files)
-        files.each do |file|
-            unless file.is_a? Puppet::Util::LoadedFile
-                file = Puppet::Util::LoadedFile.new(file)
-            end
-            @files << file
+    def watch_file(filename)
+            check_and_add_to_watched_files(filename)
+    end
+
+    private
+
+    def check_and_add_to_watched_files(filename)
+        unless @files.include?(filename)    
+            @files[filename] = Puppet::Util::LoadedFile.new(filename)
+            return true
+        else
+            return false
         end
     end
 end

data/lib/puppet/parser/resource.rb

@@ -369,7 +369,7 @@ class Puppet::Parser::Resource
             next unless val = scope.lookupvar(name.to_s, false) and val != :undefined
 
             # The default case: just set the value
-            return set_parameter(name, val) unless @params[name]
+            set_parameter(name, val) and next unless @params[name]
 
             # For relationship params, though, join the values (a la #446).
             @params[name].value = [@params[name].value, val].flatten

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

@@ -66,6 +66,14 @@ class Puppet::Parser::Resource::Param
     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)
@@ -73,7 +81,7 @@ class Puppet::Parser::Resource::Param
         db_values.collect do |db|
             db unless (db.line == line_number && 
                        values.find { |v| 
-                         v == db.value 
+                         compare(v,db.value)
                        } )
         end.compact
     end
@@ -82,7 +90,7 @@ class Puppet::Parser::Resource::Param
         values = munge_for_rails(value)
         line_number = line_to_i()
         values.collect do |v|
-            v unless db_values.find { |db| (v == db.value && 
+            v unless db_values.find { |db| (compare(v,db.value) && 
                                          line_number == db.line) }
         end.compact
     end

data/lib/puppet/parser/scope.rb

@@ -43,6 +43,29 @@ class Puppet::Parser::Scope
         end
     end
 
+    # Is the value a number?, return the correct object or nil if not a number
+    def self.number?(value)
+        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
+            elsif value =~ /^0x\d+/i
+                return value.to_i(16)
+            elsif value =~ /^0\d+/i
+                return value.to_i(8)
+            elsif value =~ /^-?\d+/
+                return value.to_i
+            else
+                return nil
+            end
+        end
+        # it is one of Fixnum,Bignum or Float
+        return value
+    end
+
     # Add to our list of namespaces.
     def add_namespace(ns)
         return false if @namespaces.include?(ns)
@@ -183,6 +206,25 @@ class Puppet::Parser::Scope
         end
     end
 
+    # Return a hash containing our variables and their values, optionally (and
+    # by default) including the values defined in our parent.  Local values
+    # shadow parent values.
+    def to_hash(recursive = true)
+        if recursive and parent then
+            target = parent.to_hash(recursive)
+        end
+        target ||= Hash.new
+        @symtable.keys.each { |name| 
+            value = @symtable[name]
+            if value == :undef then
+                target.delete(name)
+            else
+                target[name] = value 
+            end
+        }
+        return target
+    end
+
     def namespaces
         @namespaces.dup
     end
@@ -241,11 +283,15 @@ 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)
-        #Puppet.debug "Setting %s to '%s' at level %s" %
-        #    [name.inspect,value,self.level]
+    def setvar(name,value, file = nil, line = nil, append = false)
+        #Puppet.debug "Setting %s to '%s' at level %s mode append %s" %
+        #    [name.inspect,value,self.level, append]
         if @symtable.include?(name)
-            error = Puppet::ParseError.new("Cannot reassign variable %s" % name)
+            unless 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
             end
@@ -254,7 +300,19 @@ class Puppet::Parser::Scope
             end
             raise error
         end
-        @symtable[name] = value
+        
+        unless append
+            @symtable[name] = value
+        else # append case
+            # lookup the value in the scope if it exists and insert the var
+            @symtable[name] = lookupvar(name)
+            # concatenate if string, append if array, nothing for other types
+            if value.is_a?(Array)
+                @symtable[name] += value
+            else
+                @symtable[name] << value
+            end
+        end
     end
 
     # Return an interpolated string.

data/lib/puppet/parser/templatewrapper.rb

@@ -5,50 +5,96 @@ class Puppet::Parser::TemplateWrapper
     include Puppet::Util
     Puppet::Util.logmethods(self)
 
-    def initialize(scope, file)
-        @scope = scope
-        @file = Puppet::Module::find_template(file, @scope.compiler.environment)
+    def initialize(scope, filename)
+        @__scope__ = scope
+        @__file__ = Puppet::Module::find_template(filename, scope.compiler.environment)
 
-        unless FileTest.exists?(@file)
+        unless FileTest.exists?(file)
             raise Puppet::ParseError,
                 "Could not find template %s" % file
         end
 
         # We'll only ever not have a parser in testing, but, eh.
-        if @scope.parser
-            @scope.parser.watch_file(@file)
+        if scope.parser
+            scope.parser.watch_file(file)
         end
     end
 
+    def scope
+        @__scope__
+    end
+
+    def file
+        @__file__
+    end
+
     # Should return true if a variable is defined, false if it is not
     def has_variable?(name)
-        if @scope.lookupvar(name.to_s, false) != :undefined
+        if scope.lookupvar(name.to_s, false) != :undefined
             true
         else
             false
         end
     end
 
-    # Ruby treats variables like methods, so we can cheat here and
-    # trap missing vars like they were missing methods.
+    # Allow templates to access the defined classes
+    def classes
+        return scope.catalog.classes
+    end
+
+    # Allow templates to access the tags defined in the current scope
+    def tags
+        return scope.tags
+    end
+
+    # Allow templates to access the all the defined tags
+    def all_tags
+        return scope.catalog.tags
+    end
+
+    # Ruby treats variables like methods, so we used to expose variables
+    # within scope to the ERB code via method_missing.  As per RedMine #1427,
+    # though, this means that conflicts between methods in our inheritance
+    # tree (Kernel#fork) and variable names (fork => "yes/no") could arise.
+    #
+    # Worse, /new/ conflicts could pop up when a new kernel or object method
+    # was added to Ruby, causing templates to suddenly fail mysteriously when
+    # Ruby was upgraded.
+    #
+    # To ensure that legacy templates using unqualified names work we retain
+    # the missing_method definition here until we declare the syntax finally
+    # dead.
     def method_missing(name, *args)
         # We have to tell lookupvar to return :undefined to us when
         # appropriate; otherwise it converts to "".
-        value = @scope.lookupvar(name.to_s, false)
+        value = scope.lookupvar(name.to_s, false)
         if value != :undefined
             return value
         else
             # Just throw an error immediately, instead of searching for
             # other missingmethod things or whatever.
-            raise Puppet::ParseError,
-                "Could not find value for '%s'" % name
+            raise Puppet::ParseError, "Could not find value for '%s'" % name
         end
     end
 
     def result
+        # Expose all the variables in our scope as instance variables of the
+        # current object, making it possible to access them without conflict
+        # to the regular methods.
+        benchmark(:debug, "Bound template variables for #{file}") do
+            scope.to_hash.each { |name, value| 
+                if name.kind_of?(String)
+                    realname = name.gsub(/[^\w]/, "_")
+                else
+                    realname = name
+                end
+                instance_variable_set("@#{realname}", value)
+            }
+        end
+
         result = nil
-        benchmark(:debug, "Interpolated template #{@file}") do
-            template = ERB.new(File.read(@file), 0, "-")
+        benchmark(:debug, "Interpolated template #{file}") do
+            template = ERB.new(File.read(file), 0, "-")
             result = template.result(binding)
         end
 
@@ -56,7 +102,7 @@ class Puppet::Parser::TemplateWrapper
     end
 
     def to_s
-        "template[%s]" % @file
+        "template[%s]" % file
     end
 end
 

data/lib/puppet/property.rb

@@ -441,7 +441,13 @@ class Property < Puppet::Parameter
         return "%s(%s)" % [@resource.name,self.name]
     end
 
-    # Provide a common hook for setting @should, just like params.
+    # Just return any should value we might have.
+    def value
+        self.should
+    end
+
+    # Match the Parameter interface, but we really just use 'should' internally.
+    # Note that the should= method does all of the validation and such.
     def value=(value)
         self.should = value
     end

data/lib/puppet/property/keyvalue.rb

@@ -0,0 +1,96 @@
+#This subclass of property manages string key value pairs.
+
+#In order to use this property:
+# - the @should value must be an array of keyvalue pairs separated by the 'separator'
+# - the retrieve method should return a hash with the keys as symbols
+# IMPORTANT NOTE: In order for this property to work there must also be a 'membership' parameter
+# The class that inherits from property should override that method with the symbol for the membership
+
+require 'puppet/property'
+
+module Puppet
+    class Property
+        class KeyValue < Property
+
+            def hash_to_key_value_s(hash)
+                hash.select { |k,v| true }.map { |pair| pair.join(separator) }.join(delimiter)
+            end
+
+            def should_to_s(should_value)
+                hash_to_key_value_s(should_value)
+            end
+
+            def is_to_s(current_value)
+                hash_to_key_value_s(current_value)
+            end
+
+            def membership
+                :key_value_membership
+            end
+
+            def inclusive?
+                @resource[membership] == :inclusive
+            end
+
+            def hashify(key_value_array)
+                #turns string array into a hash
+                key_value_array.inject({}) do |hash, key_value|
+                    tmp = key_value.split(separator)
+                    hash[tmp[0].intern] = tmp[1]
+                    hash
+                end
+            end
+
+            def process_current_hash(current)
+                return {} if current == :absent
+
+                #inclusive means we are managing everything so if it isn't in should, its gone
+                if inclusive?
+                    current.each_key { |key| current[key] = nil }
+                end
+                current
+            end
+
+            def should
+                unless defined? @should and @should
+                    return nil
+                end
+
+                members = hashify(@should)
+                current = process_current_hash(retrieve)
+
+                #shared keys will get overwritten by members
+                current.merge(members)
+            end
+
+            def separator
+                "="
+            end
+
+            def delimiter
+                ";"
+            end
+
+            def retrieve
+                #ok, some 'convention' if the keyvalue property is named properties, provider should implement a properties method
+                if key_hash = provider.send(name) and key_hash != :absent
+                    return key_hash
+                else
+                    return :absent
+                end
+            end
+
+            def insync?(is)
+                unless defined? @should and @should
+                    return true
+                end
+
+                unless is
+                    return true
+                end
+
+                return (is == self.should)
+            end
+        end
+    end
+end

data/lib/puppet/property/list.rb

@@ -0,0 +1,78 @@
+require 'puppet/property'
+
+module Puppet
+    class Property
+        class List < Property
+
+            def should_to_s(should_value)
+                #just return the should value
+                should_value
+            end
+
+            def is_to_s(currentvalue)
+                currentvalue.join(delimiter)
+            end
+
+            def membership
+                :membership
+            end
+
+            def add_should_with_current(should, current)
+                if current.is_a?(Array)
+                    should += current
+                end
+                should.uniq
+            end
+
+            def inclusive?
+                @resource[membership] == :inclusive
+            end
+
+            def should
+                unless defined? @should and @should
+                    return nil
+                end
+
+                members = @should
+                #inclusive means we are managing everything so if it isn't in should, its gone
+                if ! inclusive?
+                    members = add_should_with_current(members, retrieve)
+                end
+
+                members.sort.join(delimiter)
+            end
+
+            def delimiter
+                ","
+            end
+
+            def retrieve
+                #ok, some 'convention' if the list property is named groups, provider should implement a groups method
+                if tmp = provider.send(name) and tmp != :absent
+                    return tmp.split(delimiter)
+                else
+                    return :absent
+                end
+            end
+
+            def prepare_is_for_comparison(is)
+                if is.is_a? Array
+                    is = is.sort.join(delimiter)
+                end
+                is
+            end
+
+            def insync?(is)
+                unless defined? @should and @should
+                    return true
+                end
+
+                unless is
+                    return true
+                end
+
+                return (prepare_is_for_comparison(is) == self.should)
+            end
+        end
+    end
+end