puppet 0.24.5 → 0.24.6

data/lib/puppet/util/settings.rb

@@ -114,12 +114,14 @@ class Puppet::Util::Settings
     end
 
     # Do variable interpolation on the value.
-    def convert(value)
+    def convert(value, environment = nil)
         return value unless value
         return value unless value.is_a? String
         newval = value.gsub(/\$(\w+)|\$\{(\w+)\}/) do |value|
             varname = $2 || $1
-            if pval = self.value(varname)
+            if varname == "environment" and environment
+                environment
+            elsif pval = self.value(varname)
                 pval
             else
                 raise Puppet::DevError, "Could not find value for %s" % value
@@ -645,10 +647,6 @@ These parameters affect the required permissions of any files specified after
 their specification.  Puppet will sometimes use these parameters to check its
 own configured state, so they can be used to make Puppet a bit more self-managing.
 
-Note also that the section names are entirely for human-level organizational
-purposes; they don't provide separate namespaces.  All parameters are in a
-single namespace.
-
 Generated on #{Time.now}.
 
 }.gsub(/^/, "# ")
@@ -785,7 +783,7 @@ Generated on #{Time.now}.
         val = @config[param].default if val.nil?
 
         # Convert it if necessary
-        val = convert(val)
+        val = convert(val, environment)
 
         # And cache it
         @cache[environment||"none"][param] = val

data/lib/puppet/util/user_attr.rb

@@ -0,0 +1,21 @@
+class UserAttr
+    def self.get_attributes_by_name(name)
+        attributes = nil
+
+        File.readlines('/etc/user_attr').each do |line|
+            next if line =~ /^#/
+
+            token = line.split(':')
+
+            if token[0] == name
+                attributes = {:name => name}
+                token[4].split(';').each do |attr|
+                    key_value = attr.split('=')
+                    attributes[key_value[0].intern] = key_value[1].strip
+                end
+                break
+            end
+        end
+        return attributes
+    end
+end

data/test/data/providers/ssh_authorized_key/parsed/authorized_keys1

@@ -0,0 +1,3 @@
+1024 35 167576894966720957580065952882142495543043407324667405194097438434880798807651864847570827148390962746149410384891026772700627764845955493549511618975091512997118590589399665757714186775228807376424903966072778732134483862302766419277581465932186641863495699668069439475320990051723279127881281145164415361627 francois@korn
+2048 35 27332429396020032283276339339051507284036000350350092862949624519871013308460312287866673933080560923221560798334008554200019645416448528663000202951887890525621015333936122655294782671001073795264378070156670395703161543893088138531854776737799752600933431638059304355933305878665812555436198516842364330938321746086651639330436648850787370397302524667456837036413634152938122227368132322078811602953517461933179827432019932348409533535942749570969101453655028606209719023224268890314608444789012688070463327764203306501923404494017305972543000091038543051645924928018568725584728655193415567703220002707737714942757 francois@korn
+from="192.168.1.1",command="/bin/false",no-pty,no-port-forwarding 2048 35 27332429396020032283276339339051507284036000350350092862949624519871013308460312287866673933080560923221560798334008554200019645416448528663000202951887890525621015333936122655294782671001073795264378070156670395703161543893088138531854776737799752600933431638059304355933305878665812555436198516842364330938321746086651639330436648850787370397302524667456837036413634152938122227368132322078811602953517461933179827432019932348409533535942749570969101453655028606209719023224268890314608444789012688070463327764203306501923404494017305972543000091038543051645924928018568725584728655193415567703220002707737714942757 francois@korn

data/test/data/snippets/append.pp

@@ -0,0 +1,11 @@
+$var=['/tmp/file1','/tmp/file2']
+
+class arraytest {
+	$var += ['/tmp/file3', '/tmp/file4']
+	file {
+		$var:
+			content => "test"
+	}
+}
+
+include arraytest

data/test/data/snippets/arithmetic_expression.pp

@@ -0,0 +1,8 @@
+
+$one = 1.30
+$two = 2.034e-2
+
+$result = ((( $two + 2) / $one) + 4 * 5.45) - (6 << 7) + (0x800 + -9)
+
+
+notice("result is $result == 1295.87692307692")

data/test/data/snippets/arraytrailingcomma.pp

@@ -0,0 +1,3 @@
+file {
+    ["/tmp/arraytrailingcomma1","/tmp/arraytrailingcomma2", ]: content => "tmp"
+}

data/test/data/snippets/emptyifelse.pp

@@ -0,0 +1,9 @@
+
+if false {
+} else {
+  # nothing here
+}
+
+if true {
+  # still nothing
+}

data/test/data/snippets/funccomma.pp

@@ -0,0 +1,5 @@
+@file {
+    ["/tmp/funccomma1","/tmp/funccomma2"]: content => "1"
+}
+
+realize( File["/tmp/funccomma1"], File["/tmp/funccomma2"] , )

data/test/data/snippets/ifexpression.rb

@@ -0,0 +1,6 @@
+$one = 1
+$two = 2
+
+if ($one < $two) and (($two < 3) or ($two == 2)) {
+    notice("True!")
+}

data/test/language/ast/resource_reference.rb

@@ -23,34 +23,6 @@ class TestASTResourceReference < Test::Unit::TestCase
         @parser = @scope.compiler.parser
     end
 
-    def test_evaluate
-        @parser.newdefine "one::two"
-        @parser.newdefine "one-two"
-        [%w{File /tmp/yay}, %w{One::Two three}, %w{One-two three}].each do |type, title|
-            ref = newref(type, title)
-
-            evaled = nil
-            assert_nothing_raised("Could not evaluate resource ref") do
-                evaled = ref.evaluate(@scope)
-            end
-
-            assert_equal(type, evaled.type, "Type did not translate correctly")
-            assert_equal(title, evaled.title, "Title did not translate correctly")
-        end
-    end
-
-    def test_finding_classes_for_reference
-        @parser.newclass "one"
-        ref = newref("Class", "one")
-        evaled = nil
-        assert_nothing_raised("Could not evaluate resource ref") do
-            evaled = ref.evaluate(@scope)
-        end
-
-        assert_equal("Class", evaled.type, "Did not set type to 'class'")
-        assert_equal("one", evaled.title, "Did not look up class corectly")
-    end
-
     # Related to #706, make sure resource references correctly translate to qualified types.
     def test_scoped_references
         @parser.newdefine "one"

data/test/language/functions.rb

@@ -96,11 +96,12 @@ class TestLangFunctions < Test::Unit::TestCase
         twop = File.join(Puppet[:templatedir], "two")
 
         File.open(onep, "w") do |f|
-            f.puts "template <%= one %>"
+            f.puts "<%- if @one.nil? then raise '@one undefined' end -%>" +
+                "template <%= @one %>"
         end
 
         File.open(twop, "w") do |f|
-            f.puts "template <%= two %>"
+            f.puts "template <%= @two %>"
         end
         func = nil
         assert_nothing_raised do
@@ -116,15 +117,27 @@ class TestLangFunctions < Test::Unit::TestCase
         ast = varobj("output", func)
 
         scope = mkscope
+
+        # Test that our manual exception throw fails the parse
         assert_raise(Puppet::ParseError) do
             ast.evaluate(scope)
         end
 
+        # Test that our use of an undefined instance variable does not throw
+        # an exception, but only safely continues.
         scope.setvar("one", "One")
-        assert_raise(Puppet::ParseError) do
+        assert_nothing_raised do
             ast.evaluate(scope)
         end
+
+        # Ensure that we got the output we expected from that evaluation.
+        assert_equal("template One\ntemplate \n", scope.lookupvar("output"),
+                     "Undefined template variables do not raise exceptions")
+
+        # Now, fill in the last variable and make sure the whole thing
+        # evaluates correctly.
         scope.setvar("two", "Two")
+        scope.unsetvar("output")
         assert_nothing_raised do
             ast.evaluate(scope)
         end
@@ -138,7 +151,7 @@ class TestLangFunctions < Test::Unit::TestCase
         template = tempfile()
 
         File.open(template, "w") do |f|
-            f.puts "template <%= yayness %>"
+            f.puts "template <%= @yay.nil?() ? raise('yay undefined') : @yay %>"
         end
 
         func = nil
@@ -158,17 +171,77 @@ class TestLangFunctions < Test::Unit::TestCase
             ast.evaluate(scope)
         end
 
-        scope.setvar("yayness", "this is yayness")
+        scope.setvar("yay", "this is yay")
 
         assert_nothing_raised do
             ast.evaluate(scope)
         end
 
-        assert_equal("template this is yayness\n", scope.lookupvar("output"),
+        assert_equal("template this is yay\n", scope.lookupvar("output"),
             "Templates were not handled correctly")
 
     end
 
+    # Make sure that legacy template variable access works as expected.
+    def test_legacyvariables
+        template = tempfile()
+
+        File.open(template, "w") do |f|
+            f.puts "template <%= deprecated %>"
+        end
+
+        func = nil
+        assert_nothing_raised do
+            func = Puppet::Parser::AST::Function.new(
+                :name => "template",
+                :ftype => :rvalue,
+                :arguments => AST::ASTArray.new(
+                    :children => [stringobj(template)]
+                )
+            )
+        end
+        ast = varobj("output", func)
+
+        # Verify that we get an exception using old-style accessors.
+        scope = mkscope
+        assert_raise(Puppet::ParseError) do
+            ast.evaluate(scope)
+        end
+
+        # Verify that we evaluate and return their value correctly.
+        scope.setvar("deprecated", "deprecated value")
+        assert_nothing_raised do
+            ast.evaluate(scope)
+        end
+
+        assert_equal("template deprecated value\n", scope.lookupvar("output"),
+                     "Deprecated template variables were not handled correctly")
+    end
+
+    # Make sure that problems with kernel method visibility still exist.
+    def test_kernel_module_shadows_deprecated_var_lookup
+        template = tempfile()
+        File.open(template, "w").puts("<%= binding %>")
+
+        func = nil
+        assert_nothing_raised do
+            func = Puppet::Parser::AST::Function.new(
+                :name => "template",
+                :ftype => :rvalue,
+                :arguments => AST::ASTArray.new(
+                    :children => [stringobj(template)]
+                )
+            )
+        end
+        ast = varobj("output", func)
+
+        # Verify that Kernel methods still shadow deprecated variable lookups.
+        scope = mkscope
+        assert_nothing_raised("No exception for Kernel shadowed variable names") do
+            ast.evaluate(scope)
+        end
+    end
+
     def test_tempatefunction_cannot_see_scopes
         template = tempfile()
 
@@ -205,7 +278,7 @@ class TestLangFunctions < Test::Unit::TestCase
         file = tempfile()
 
         Puppet[:code] = %{file { "#{file}": content => template("#{template}") }}
-        Puppet[:environments] = "yay"
+        Puppet[:environment] = "yay"
         interp = Puppet::Parser::Interpreter.new
         node = mknode
         node.stubs(:environment).returns("yay")
@@ -243,7 +316,7 @@ class TestLangFunctions < Test::Unit::TestCase
         template = tempfile()
 
         File.open(template, "w") do |f|
-            f.puts "template <%= yayness %>"
+            f.puts "template <%= @yayness %>"
         end
 
         func = nil
@@ -263,10 +336,6 @@ class TestLangFunctions < Test::Unit::TestCase
             false => "false",
         }.each do |string, value|
             scope = mkscope
-            assert_raise(Puppet::ParseError) do
-                ast.evaluate(scope)
-            end
-
             scope.setvar("yayness", string)
             assert_equal(string, scope.lookupvar("yayness", false))
 
@@ -310,6 +379,8 @@ class TestLangFunctions < Test::Unit::TestCase
         scope = mkscope
         parser = scope.compiler.parser
     
+        realize = Puppet::Parser::Functions.function(:realize)
+
         # Make a definition
         parser.newdefine("mytype")
         
@@ -365,6 +436,8 @@ class TestLangFunctions < Test::Unit::TestCase
     def test_defined
         scope = mkscope
         parser = scope.compiler.parser
+
+        defined = Puppet::Parser::Functions.function(:defined)
         
         parser.newclass("yayness")
         parser.newdefine("rahness")
@@ -422,6 +495,8 @@ class TestLangFunctions < Test::Unit::TestCase
         scope = mkscope
         parser = scope.compiler.parser
 
+        include = Puppet::Parser::Functions.function(:include)
+
         assert_raise(Puppet::ParseError, "did not throw error on missing class") do
             scope.function_include("nosuchclass")
         end
@@ -439,6 +514,8 @@ class TestLangFunctions < Test::Unit::TestCase
         parser = mkparser
         scope = mkscope(:parser => parser)
 
+        file = Puppet::Parser::Functions.function(:file)
+
         file1 = tempfile
         file2 = tempfile
         file3 = tempfile
@@ -479,6 +556,8 @@ class TestLangFunctions < Test::Unit::TestCase
         assert_equal("yay\n", %x{#{command}}, "command did not work")
         assert_equal("yay-foo\n", %x{#{command} foo}, "command did not work")
 
+        generate = Puppet::Parser::Functions.function(:generate)
+
         scope = mkscope
         parser = scope.compiler.parser
 

data/test/language/parser.rb

@@ -66,6 +66,19 @@ class TestParser < Test::Unit::TestCase
         }
     end
 
+    def test_arrayrvalueswithtrailingcomma
+        parser = mkparser
+        ret = nil
+        file = tempfile()
+        assert_nothing_raised {
+            parser.string = "file { \"#{file}\": mode => [755, 640,] }"
+        }
+
+        assert_nothing_raised {
+            ret = parser.parse
+        }
+    end
+
     def mkmanifest(file)
         name = File.join(tmpdir, "file%s" % rand(100))
         @@tmpfiles << name
@@ -1208,5 +1221,13 @@ file { "/tmp/yayness":
             parser.import("test") 
         end
     end
+
+    def test_watch_file_only_once
+        FileTest.stubs(:exists?).returns(true)
+        parser = mkparser
+        parser.watch_file("doh")
+        parser.watch_file("doh")
+        assert_equal(1, parser.files.select { |name, file| file.file == "doh" }.length, "Length of watched 'doh' files was not 1")
+    end
 end
 

data/test/language/scope.rb

@@ -53,6 +53,34 @@ class TestScope < Test::Unit::TestCase
             assert_equal(:undefined, scopes[name].lookupvar("third", false), "Found child var in top scope")
         end
         assert_equal("botval", scopes[:bot].lookupvar("third", false), "Could not find var in bottom scope")
+
+
+        # Test that the scopes convert to hash structures correctly.
+        # For topscope recursive vs non-recursive should be identical
+        assert_equal(topscope.to_hash(false), topscope.to_hash(true),
+                     "Recursive and non-recursive hash is identical for topscope")
+
+        # Check the variable we expect is present.
+        assert_equal({"first" => "topval"}, topscope.to_hash(),
+                     "topscope returns the expected hash of variables")
+
+        # Now, check that midscope does the right thing in all cases.
+        assert_equal({"second" => "midval"},
+                     midscope.to_hash(false),
+                     "midscope non-recursive hash contains only midscope variable")
+        assert_equal({"first" => "topval", "second" => "midval"},
+                     midscope.to_hash(true),
+                     "midscope recursive hash contains topscope variable also")
+
+        # Finally, check the ability to shadow symbols by adding a shadow to
+        # bottomscope, then checking that we see the right stuff.
+        botscope.setvar("first", "shadowval")
+        assert_equal({"third" => "botval", "first" => "shadowval"},
+                     botscope.to_hash(false),
+                     "botscope has the right non-recursive hash")
+        assert_equal({"third" => "botval", "first" => "shadowval", "second" => "midval"},
+                     botscope.to_hash(true),
+                     "botscope values shadow parent scope values")
     end
 
     def test_lookupvar