puppet 0.23.0 → 0.23.1

data/lib/puppet/util.rb

@@ -306,12 +306,16 @@ module Util
             output_file = Tempfile.new("puppet")
         end
 
+        oldverb = $VERBOSE
+        $VERBOSE = false
         child_pid = Kernel.fork
+        $VERBOSE = oldverb
         if child_pid
             # Parent process executes this
             child_status = Process.waitpid2(child_pid)[1]
         else
             # Child process executes this
+            Process.setsid
             begin
                 $stdin.reopen("/dev/null")
                 $stdout.reopen(output_file)
@@ -338,9 +342,30 @@ module Util
  	
         # read output in if required
         if ! arguments[:squelch]
-            output = output_file.open.read
-            output_file.close
-            output_file.delete
+
+            # Make sure the file's actually there.  This is
+            # basically a race condition, and is probably a horrible
+            # way to handle it, but, well, oh well.
+            unless FileTest.exists?(output_file.path)
+                Puppet.warning "sleeping"
+                sleep 0.5
+                unless FileTest.exists?(output_file.path)
+                    Puppet.warning "sleeping 2"
+                    sleep 1
+                    unless FileTest.exists?(output_file.path)
+                        Puppet.warning "Could not get output"
+                        output = ""
+                    end
+                end
+            end
+            unless output
+                # We have to explicitly open here, so that it reopens
+                # after the child writes.
+                output = output_file.open.read
+
+                # The 'true' causes the file to get unlinked right away.
+                output_file.close(true)
+            end
         end
 
         if arguments[:failonfail]
@@ -436,4 +461,4 @@ require 'puppet/util/logging'
 require 'puppet/util/package'
 require 'puppet/util/warnings'
 
-# $Id: util.rb 2605 2007-06-18 18:13:23Z luke $
+# $Id: util.rb 2717 2007-07-19 20:02:26Z luke $

data/lib/puppet/util/autoload.rb

@@ -3,20 +3,42 @@ class Puppet::Util::Autoload
     include Puppet::Util
 
     @autoloaders = {}
-
-    attr_accessor :object, :path, :objwarn, :wrap
-
+    @loaded = {}
 
     class << self
         attr_reader :autoloaders
         private :autoloaders
     end
-    Puppet::Util.classproxy self, :autoloaders, "[]", "[]=", :clear
 
-    attr_reader :loaded
-    private :loaded
+    # Send [], []=, and :clear to the @autloaders hash
+    Puppet::Util.classproxy self, :autoloaders, "[]", "[]="
+
+    # Clear the list of autoloaders and loaded files.
+    def self.clear
+        @autoloaders.clear
+        @loaded.clear
+    end
+
+    # List all loaded files.
+    def self.list_loaded
+        @loaded.sort { |a,b| a[0] <=> b[0] }.collect do |path, hash|
+            "%s: %s" % [path, hash[:file]]
+        end
+    end
+
+    # Has a given path been loaded?  This is used for testing whether a
+    # changed file should be loaded or just ignored.
+    def self.loaded?(path)
+        path = path.to_s.sub(/\.rb$/, '')
+        @loaded[path]
+    end
+
+    # Save the fact that a given path has been loaded
+    def self.loaded(path, file, loader)
+        @loaded[path] = {:file => file, :autoloader => loader}
+    end
 
-    Puppet::Util.proxy self, :loaded, :clear
+    attr_accessor :object, :path, :objwarn, :wrap
 
     def initialize(obj, path, options = {})
         @path = path.to_s
@@ -39,11 +61,10 @@ class Puppet::Util::Autoload
         unless defined? @wrap
             @wrap = true
         end
-
-        @loaded = {}
     end
 
-    # Load a single plugin by name.
+    # Load a single plugin by name.  We use 'load' here so we can reload a
+    # given plugin.
     def load(name)
         path = name.to_s + ".rb"
 
@@ -53,7 +74,7 @@ class Puppet::Util::Autoload
             begin
                 Kernel.load file, @wrap
                 name = symbolize(name)
-                @loaded[name] = true
+                loaded name, file
                 return true
             rescue LoadError => detail
                 # I have no idea what's going on here, but different versions
@@ -70,11 +91,19 @@ class Puppet::Util::Autoload
         return false
     end
 
+    # Mark the named object as loaded.  Note that this supports unqualified
+    # queries, while we store the result as a qualified query in the class.
+    def loaded(name, file)
+        self.class.loaded(File.join(@path, name.to_s), file, object)
+    end
+
     # Indicate whether the specfied plugin has been loaded.
     def loaded?(name)
-        @loaded[symbolize(name)]
+        self.class.loaded?(File.join(@path, name.to_s))
     end
 
+    # Load all instances that we can.  This uses require, rather than load,
+    # so that already-loaded files don't get reloaded unnecessarily.
     def loadall
         # Load every instance of everything we can find.
         eachdir do |dir|
@@ -84,12 +113,12 @@ class Puppet::Util::Autoload
                 # believe, but it works as long as real classes
                 # aren't used.
                 name = File.basename(file).sub(".rb", '').intern
-                next if @loaded.include? name
+                next if loaded?(name)
                 next if $".include?(File.join(@path, name.to_s + ".rb"))
                 filepath = File.join(@path, name.to_s + ".rb")
                 begin
-                    Kernel.require filepath
-                    @loaded[name] = true
+                    Kernel.require file
+                    loaded(name, file)
                 rescue => detail
                     if Puppet[:trace]
                         puts detail.backtrace
@@ -116,4 +145,4 @@ class Puppet::Util::Autoload
     end
 end
 
-# $Id: autoload.rb 2518 2007-05-16 00:00:47Z luke $
+# $Id: autoload.rb 2668 2007-07-10 04:00:28Z luke $

data/lib/puppet/util/fileparsing.rb

@@ -117,6 +117,11 @@ module Puppet::Util::FileParsing
             meta_def(:pre_gen, &block)
         end
 
+        # Are we a text type?
+        def text?
+            type == :text
+        end
+
         def to_line=(block)
             meta_def(:to_line, &block)
         end
@@ -163,8 +168,12 @@ module Puppet::Util::FileParsing
             if match = regex.match(line)
                 fields = []
                 ret = {}
-                record.fields.zip(match.captures).each do |f, v|
-                    ret[f] = v
+                record.fields.zip(match.captures).each do |field, value|
+                    if value == record.absent 
+                        ret[field] = :absent
+                    else
+                        ret[field] = value
+                    end
                 end
             else
                 nil
@@ -188,7 +197,7 @@ module Puppet::Util::FileParsing
                 end
             end
 
-            unless line_fields.empty? or ! record.rollup
+            if record.rollup and ! line_fields.empty?
                 last_field = record.fields[-1]
                 val = ([ret[last_field]] + line_fields).join(record.joiner)
                 ret[last_field] = val
@@ -219,8 +228,16 @@ module Puppet::Util::FileParsing
 
     # Split a bunch of text into lines and then parse them individually.
     def parse(text)
+        count = 1
         lines(text).collect do |line|
-            parse_line(line)
+            count += 1
+            if val = parse_line(line)
+                val
+            else
+                error = Puppet::Error.new("Could not parse line %s" % line.inspect)
+                error.line = count
+                raise error
+            end
         end
     end
 
@@ -371,10 +388,10 @@ module Puppet::Util::FileParsing
         return record
     end
 
-    # Retrive the record object.
+    # Retrieve the record object.
     def record_type(type)
         @record_types[symbolize(type)]
     end
 end
 
-# $Id: fileparsing.rb 2407 2007-04-23 18:01:36Z luke $
+# $Id: fileparsing.rb 2697 2007-07-14 21:13:04Z luke $

data/lib/puppet/util/filetype.rb

@@ -67,6 +67,16 @@ class Puppet::Util::FileType
         @filetypes[type]
     end
 
+    # Back the file up before replacing it.
+    def backup
+        bucket.backup(@path) if FileTest.exists?(@path)
+    end
+
+    # Pick or create a filebucket to use.
+    def bucket
+        Puppet::Type.type(:filebucket).mkdefaultbucket.bucket
+    end
+
     def initialize(path)
         @path = path
     end
@@ -91,6 +101,7 @@ class Puppet::Util::FileType
 
         # Overwrite the file.
         def write(text)
+            backup()
             File.open(@path, "w") { |f| f.print text; f.flush }
         end
     end
@@ -297,4 +308,4 @@ class Puppet::Util::FileType
     end
 end
 
-# $Id: filetype.rb 2178 2007-02-07 23:56:59Z luke $
+# $Id: filetype.rb 2679 2007-07-11 20:23:49Z luke $

data/lib/puppet/util/log.rb

@@ -518,7 +518,7 @@ class Puppet::Util::Log
         # We can't store the actual source, we just store the path.
         # We can't just check for whether it responds to :path, because
         # plenty of providers respond to that in their normal function.
-        if source.is_a?(Puppet::Element) and source.respond_to?(:path)
+        if (source.is_a?(Puppet::Type) or source.is_a?(Puppet::Parameter)) and source.respond_to?(:path)
             @objectsource = true
             @source = source.path
         else
@@ -546,4 +546,4 @@ class Puppet::Util::Log
 end
 Puppet::Log = Puppet::Util::Log
 
-# $Id: log.rb 2340 2007-03-21 20:39:36Z luke $
+# $Id: log.rb 2647 2007-07-04 22:25:23Z luke $

data/lib/puppet/util/log_paths.rb

@@ -0,0 +1,16 @@
+#  Created by Luke Kanies on 2007-07-04.
+#  Copyright (c) 2007. All rights reserved.
+
+module Puppet::Util::LogPaths
+    # return the full path to us, for logging and rollback
+    # some classes (e.g., FileTypeRecords) will have to override this
+    def path
+        unless defined? @path
+            @path = pathbuilder
+        end
+
+        return "/" + @path.join("/")
+    end
+end
+
+# $Id: log_paths.rb 2647 2007-07-04 22:25:23Z luke $

data/lib/puppet/util/reference.rb

@@ -173,7 +173,7 @@ class Puppet::Util::Reference
         end
 
         puts "Writing %s reference to trac as %s" % [@name, @page]
-        cmd = %{sudo trac-admin /export/svn/trac/puppet wiki import %s /tmp/puppetdoc.txt} % self.page
+        cmd = %{sudo trac-admin /opt/rl/trac/puppet wiki import %s /tmp/puppetdoc.txt} % self.page
         output = %x{#{cmd}}
         unless $? == 0
             $stderr.puts "trac-admin failed"
@@ -186,4 +186,4 @@ class Puppet::Util::Reference
     end
 end
 
-# $Id: reference.rb 2485 2007-05-08 19:29:38Z luke $
+# $Id: reference.rb 2636 2007-06-19 23:52:34Z luke $

data/test/language/ast/hostclass.rb

@@ -8,6 +8,7 @@ $:.unshift("../../lib") if __FILE__ =~ /\.rb$/
 require 'puppettest'
 require 'puppettest/parsertesting'
 require 'puppettest/resourcetesting'
+require 'mocha'
 
 class TestASTHostClass < Test::Unit::TestCase
 	include PuppetTest
@@ -34,7 +35,7 @@ class TestASTHostClass < Test::Unit::TestCase
             klass.evaluate(:scope => scope)
         end
 
-        assert(scope.setclass?(klass), "Class was not considered evaluated")
+        assert(scope.class_scope(klass), "Class was not considered evaluated")
 
         tmp = scope.findresource("File[/tmp]")
         assert(tmp, "Could not find file /tmp")
@@ -74,8 +75,8 @@ class TestASTHostClass < Test::Unit::TestCase
             moresub.evaluate(:scope => scope)
         end
 
-        assert(scope.setclass?(newbase), "Did not eval newbase")
-        assert(scope.setclass?(newsub), "Did not eval newsub")
+        assert(scope.class_scope(newbase), "Did not eval newbase")
+        assert(scope.class_scope(newsub), "Did not eval newsub")
 
         yay = scope.findresource("File[/tmp/yay]")
         assert(yay, "Did not find file /tmp/yay")
@@ -157,6 +158,22 @@ class TestASTHostClass < Test::Unit::TestCase
         assert(result, "could not find parent-defined definition from sub")
         assert(fun == result, "found incorrect parent-defined definition from sub")
     end
+
+    # Make sure the subscopes we generate get the right type and name
+    def test_subscope
+        interp = mkinterp
+
+        klass = interp.newclass("base")
+        scope = mkscope(:interp => interp)
+        scope.expects(:newscope).with(:name => "base", :type => "class", :namespace => "base").returns(mkscope(:interp => interp))
+        klass.subscope(scope)
+
+        # Now make sure it works for namespaces
+        klass = interp.newclass("sub::type")
+        scope = mkscope(:interp => interp)
+        scope.expects(:newscope).with(:name => "sub::type", :type => "class", :namespace => "sub::type").returns(mkscope(:interp => interp))
+        klass.subscope(scope)
+    end
 end
 
-# $Id: hostclass.rb 2259 2007-03-06 19:03:05Z luke $
+# $Id: hostclass.rb 2715 2007-07-19 19:23:56Z luke $

data/test/language/ast/resourceref.rb

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke A. Kanies on 2007-07-8.
+#  Copyright (c) 2007. All rights reserved.
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppettest/parsertesting'
+
+class TestASTResourceRef < Test::Unit::TestCase
+	include PuppetTest
+	include PuppetTest::ParserTesting
+	AST = Puppet::Parser::AST
+    
+    def newref(type, title)
+        AST::ResourceRef.new(:type => type, :title => AST::String.new(:value => title))
+    end
+
+    def setup
+        super
+        @interp = mkinterp
+        @scope = mkscope :interp => @interp
+    end
+
+    def test_evaluate
+        @interp.newdefine "one::two"
+        @interp.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 => @scope)
+            end
+
+            assert_equal(type, evaled.type, "Type did not translate correctly")
+            assert_equal(title, evaled.title, "Title did not translate correctly")
+        end
+    end
+
+    # Related to #706, make sure resource references correctly translate to qualified types.
+    def test_scoped_references
+        @interp.newdefine "one"
+        @interp.newdefine "one::two"
+        @interp.newdefine "three"
+        twoscope = @scope.newscope(:type => "one", :namespace => "one")
+        assert(twoscope.finddefine("two"), "Could not find 'two' definition")
+        title = "title"
+
+        # First try a qualified type
+        assert_equal("one::two", newref("two", title).evaluate(:scope => twoscope).type,
+            "Defined type was not made fully qualified")
+
+        # Then try a type that does not need to be qualified
+        assert_equal("one", newref("one", title).evaluate(:scope => twoscope).type,
+            "Unqualified defined type was not handled correctly")
+
+        # Then an unqualified type from within the one namespace
+        assert_equal("three", newref("three", title).evaluate(:scope => twoscope).type,
+            "Defined type was not made fully qualified")
+
+        # Then a builtin type
+        assert_equal("file", newref("file", title).evaluate(:scope => twoscope).type,
+            "Builtin type was not handled correctly")
+
+        # Now try a type that does not exist, which should throw an error.
+        assert_raise(Puppet::ParseError, "Did not fail on a missing type in a resource reference") do
+            newref("nosuchtype", title).evaluate(:scope => twoscope)
+        end
+
+        # Now run the same tests, but with the classes
+        @interp.newclass "four"
+        @interp.newclass "one::five"
+
+        # First try an unqualified type
+        assert_equal("four", newref("class", "four").evaluate(:scope => twoscope).title,
+            "Unqualified class was not found")
+
+        # Then a qualified class
+        assert_equal("one::five", newref("class", "five").evaluate(:scope => twoscope).title,
+            "Class was not made fully qualified")
+
+        # Then try a type that does not need to be qualified
+        assert_equal("four", newref("class", "four").evaluate(:scope => twoscope).title,
+            "Unqualified class was not handled correctly")
+
+        # Now try a type that does not exist, which should throw an error.
+        assert_raise(Puppet::ParseError, "Did not fail on a missing type in a resource reference") do
+            newref("class", "nosuchclass").evaluate(:scope => twoscope)
+        end
+    end
+end
+
+# $Id: resourceref.rb 2715 2007-07-19 19:23:56Z luke $