puppet 0.24.1 → 0.24.2

data/lib/puppet/type/sshkey.rb

@@ -53,14 +53,14 @@ module Puppet
         end
 
         newparam(:name) do
-            desc "The host name."
+            desc "The host name that the key is associated with."
 
             isnamevar
         end
 
         newproperty(:target) do
-            desc "The file in which to store the mount table.  Only used by
-                those providers that write to disk (i.e., not NetInfo)."
+            desc "The file in which to store the ssh key.  Only used by
+                the ``parsed`` provider."
 
             defaultto { if @resource.class.defaultprovider.ancestors.include?(Puppet::Provider::ParsedFile)
                     @resource.class.defaultprovider.default_target

data/lib/puppet/util/autoload.rb

@@ -1,6 +1,9 @@
+require 'puppet/util/warnings'
+
 # Autoload paths, either based on names or all at once.
 class Puppet::Util::Autoload
     include Puppet::Util
+    include Puppet::Util::Warnings
 
     @autoloaders = {}
     @loaded = []
@@ -109,9 +112,8 @@ class Puppet::Util::Autoload
             Dir.glob("#{dir}/*.rb").each do |file|
                 name = File.basename(file).sub(".rb", '').intern
                 next if loaded?(name)
-                rubypath = File.join(@path, name.to_s)
                 begin
-                    Kernel.require rubypath
+                    Kernel.require file
                     loaded(name, file)
                 rescue => detail
                     if Puppet[:trace]
@@ -123,8 +125,6 @@ class Puppet::Util::Autoload
         end
     end
 
-    private
-
     # Yield each subdir in turn.
     def eachdir
         searchpath.each do |dir|
@@ -137,7 +137,7 @@ class Puppet::Util::Autoload
     def searchpath
         # JJM: Search for optional lib directories in each module bundle.
         module_lib_dirs = Puppet[:modulepath].split(":").collect do |d|
-            Dir.glob("%s/*/lib" % d).select do |f|
+            Dir.glob("%s/*/{plugins,lib}" % d).select do |f|
                 FileTest.directory?(f) 
             end
         end.flatten

data/lib/puppet/util/checksums.rb

@@ -1,37 +1,75 @@
+# A stand-alone module for calculating checksums
+# in a generic way.
 module Puppet::Util::Checksums
+    # Calculate a checksum using Digest::MD5.
     def md5(content)
         require 'digest/md5'
         Digest::MD5.hexdigest(content)
     end
 
-    def md5_file(filename)
+    # Calculate a checksum of the first 500 chars of the content using Digest::MD5.
+    def md5lite(content)
+        md5(content[0..511])
+    end
+
+    # Calculate a checksum of a file's content using Digest::MD5.
+    def md5_file(filename, lite = false)
         require 'digest/md5'
 
-        incr_digest = Digest::MD5.new()
-        File.open(filename, 'r') do |file|
-            file.each_line do |line|
-                incr_digest << line
-            end
-        end
+        digest = Digest::MD5.new()
+        return checksum_file(digest, filename,  lite)
+    end
+
+    # Calculate a checksum of the first 500 chars of a file's content using Digest::MD5.
+    def md5lite_file(filename)
+        md5_file(filename, true)
+    end
 
-        return incr_digest.hexdigest
+    # Return the :mtime timestamp of a file.
+    def mtime_file(filename)
+        File.stat(filename).send(:mtime)
     end
 
+    # Calculate a checksum using Digest::SHA1.
     def sha1(content)
         require 'digest/sha1'
         Digest::SHA1.hexdigest(content)
     end
 
-    def sha1_file(filename)
+    # Calculate a checksum of the first 500 chars of the content using Digest::SHA1.
+    def sha1lite(content)
+        sha1(content[0..511])
+    end
+
+    # Calculate a checksum of a file's content using Digest::SHA1.
+    def sha1_file(filename, lite = false)
         require 'digest/sha1'
 
-        incr_digest = Digest::SHA1.new()
+        digest = Digest::SHA1.new()
+        return checksum_file(digest, filename, lite)
+    end
+
+    # Calculate a checksum of the first 500 chars of a file's content using Digest::SHA1.
+    def sha1lite_file(filename)
+        sha1_file(filename, true)
+    end
+
+    # Return the :ctime of a file.
+    def ctime_file(filename)
+        File.stat(filename).send(:ctime)
+    end
+
+    private
+
+    # Perform an incremental checksum on a file.
+    def checksum_file(digest, filename, lite = false)
         File.open(filename, 'r') do |file|
-            file.each_line do |line|
-                incr_digest << line
+            while content = file.read(512)
+                digest << content
+                break if lite
             end
         end
 
-        return incr_digest.hexdigest
+        return digest.hexdigest
     end
 end

data/lib/puppet/util/constant_inflector.rb

@@ -0,0 +1,14 @@
+# Created on 2008-02-12
+# Copyright Luke Kanies
+
+# A common module for converting between constants and
+# file names.
+module Puppet::Util::ConstantInflector
+    def file2constant(file)
+        file.split("/").collect { |name| name.capitalize }.join("::").gsub(/_+(.)/) { |term| $1.capitalize }
+    end
+
+    def constant2file(constant)
+        constant.to_s.gsub(/([a-z])([A-Z])/) { |term| $1 + "_" + $2 }.gsub("::", "/").downcase
+    end
+end

data/lib/puppet/util/filetype.rb

@@ -165,7 +165,7 @@ class Puppet::Util::FileType
 
         # Remove a specific @path's cron tab.
         def remove
-            if Facter.value("operatingsystem") == "FreeBSD"
+            if %w{Darwin FreeBSD}.include?(Facter.value("operatingsystem"))
                 %x{/bin/echo yes | #{cmdbase()} -r 2>/dev/null}
             else
                 %x{#{cmdbase()} -r 2>/dev/null}

data/lib/puppet/util/graph.rb

@@ -16,21 +16,15 @@ module Puppet::Util::Graph
         
         self.each do |child|
             unless block_given? and ! yield(child)
-                graph.add_edge!(self, child)
-
-                if graph.cyclic?
-                    raise Puppet::Error, "%s created a cyclic graph" % self
-                end
+                graph.add_edge(self, child)
                 
                 if child.respond_to?(:to_graph)
                     child.to_graph(graph, &block)
                 end
             end
         end
-        
-        if graph.cyclic?
-            raise Puppet::Error, "%s created a cyclic graph" % self
-        end
+
+        # Do a topsort, which will throw an exception if the graph is cyclic.
         
         graph
     end

data/lib/puppet/util/nagios_maker.rb

@@ -0,0 +1,57 @@
+require 'puppet/external/nagios'
+require 'puppet/external/nagios/base'
+require 'puppet/provider/naginator'
+
+module Puppet::Util::NagiosMaker
+    # Create a new nagios type, using all of the parameters
+    # from the parser.
+    def self.create_nagios_type(name)
+        name = name.to_sym
+        full_name = ("nagios_" + name.to_s).to_sym
+
+        raise(Puppet::DevError, "No nagios type for %s" % name) unless nagtype = Nagios::Base.type(name)
+
+        type = Puppet::Type.newtype(full_name) {}
+
+        type.ensurable
+
+        type.newparam(nagtype.namevar, :namevar => true) do
+            desc "The name parameter for Nagios type %s" % nagtype.name
+        end
+
+        # We deduplicate the parameters because it makes sense to allow Naginator to have dupes.
+        nagtype.parameters.uniq.each do |param|
+            next if param == nagtype.namevar
+
+            # We can't turn these parameter names into constants, so at least for now they aren't
+            # supported.
+            next if param.to_s =~ /^[0-9]/
+
+            type.newproperty(param) do
+                desc "Nagios configuration file parameter."
+            end
+        end
+
+        type.newproperty(:target) do
+            desc 'target'
+
+            defaultto do
+                resource.class.defaultprovider.default_target
+            end
+        end
+
+        target = "/etc/nagios/#{full_name.to_s}.cfg"
+        provider = type.provide(:naginator, :parent => Puppet::Provider::Naginator, :default_target => target) {}
+
+        type.desc "The Nagios type #{name.to_s}.  This resource type is autogenerated using the
+            model developed in Naginator_, and all of the Nagios types are generated using the
+            same code and the same library.
+
+            This type generates Nagios configuration statements in Nagios-parseable configuration
+            files.  By default, the statements will be added to ``#{target}``, but
+            you can send them to a different file by setting their ``target`` attribute.
+
+            .. _naginator: http://reductivelabs.com/trac/naginator
+        "
+    end
+end

data/lib/puppet/util/settings.rb

@@ -509,19 +509,19 @@ class Puppet::Util::Settings
                 objects += add_user_resources(section, obj, done)
             end
 
+            value = obj.value
+
             # Only files are convertable to transportable resources.
-            if obj.respond_to? :to_transportable
-                next if value(obj.name) =~ /^\/dev/
-                transobjects = obj.to_transportable
-                transobjects = [transobjects] unless transobjects.is_a? Array
-                transobjects.each do |trans|
-                    # transportable could return nil
-                    next unless trans
-                    unless done[:file].include? trans.name
-                        @created << trans.name
-                        objects << trans
-                        done[:file][trans.name] = trans
-                    end
+            next unless obj.respond_to? :to_transportable and transobjects = obj.to_transportable
+
+            transobjects = [transobjects] unless transobjects.is_a? Array
+            transobjects.each do |trans|
+                # transportable could return nil
+                next unless trans
+                unless done[:file].include? trans.name
+                    @created << trans.name
+                    objects << trans
+                    done[:file][trans.name] = trans
                 end
             end
         end
@@ -1124,7 +1124,7 @@ Generated on #{Time.now}.
         # the variable 'dir', or adding a slash at the end.
         def munge(value)
             # If it's not a fully qualified path...
-            if value.is_a?(String) and value !~ /^\$/ and value !~ /^\//
+            if value.is_a?(String) and value !~ /^\$/ and value !~ /^\// and value != 'false'
                 # Make it one
                 value = File.join(Dir.getwd, value)
             end
@@ -1153,12 +1153,15 @@ Generated on #{Time.now}.
         def to_transportable
             type = self.type
             return nil unless type
-            path = @parent.value(self.name).split(File::SEPARATOR)
-            path.shift # remove the leading nil
 
-            objects = []
             path = self.value
 
+            return nil unless path.is_a?(String)
+            return nil if path =~ /^\/dev/
+            return nil if Puppet::Type.type(:file)[path] # skip files that are in our global resource list.
+
+            objects = []
+
             # Skip plain files that don't exist, since we won't be managing them anyway.
             return nil unless self.name.to_s =~ /dir$/ or File.exist?(path) or self.create
             obj = Puppet::TransObject.new(path, "file")

data/lib/puppet/util/tagging.rb

@@ -0,0 +1,39 @@
+# Created on 2008-01-19
+# Copyright Luke Kanies
+
+# A common module to handle tagging.
+module Puppet::Util::Tagging
+    # Add a tag to our current list.  These tags will be added to all
+    # of the objects contained in this scope.
+    def tag(*ary)
+        @tags ||= []
+
+        qualified = []
+
+        ary.collect { |tag| tag.to_s.downcase }.each do |tag|
+            fail(Puppet::ParseError, "Invalid tag %s" % tag.inspect) unless valid_tag?(tag)
+            qualified << tag if tag.include?("::")
+            @tags << tag unless @tags.include?(tag)
+        end
+
+        qualified.collect { |name| name.split("::") }.flatten.each { |tag| @tags << tag unless @tags.include?(tag) }
+    end
+
+    # Are we tagged with the provided tag?
+    def tagged?(tag)
+        defined?(@tags) and @tags.include?(tag.to_s)
+    end
+
+    # Return a copy of the tag list, so someone can't ask for our tags
+    # and then modify them.
+    def tags
+        @tags ||= []
+        @tags.dup
+    end
+
+    private
+
+    def valid_tag?(tag)
+        tag =~ /^\w[-\w:.]*$/
+    end
+end

data/test/executables/puppetbin.rb

@@ -83,5 +83,22 @@ class TestPuppetBin < Test::Unit::TestCase
 
         assert(FileTest.exists?(path), "Failed to create config'ed file")
     end
+
+    def test_parseonly
+        path = tempfile()
+        manifest = tempfile()
+        puppet = %x{which puppet}.chomp
+        if puppet == ""
+            Puppet.info "cannot find puppet; cannot test parseonly"
+            return
+        end
+        code = 'File <<| |>>
+        include nosuchclass'
+
+        assert_nothing_raised {
+            IO.popen("#{puppet} --parseonly", 'w') { |p| p.puts code }
+        }
+        assert($? == 0, "parseonly test exited with code %s" % $?.to_i)
+    end
 end
 

data/test/language/ast.rb

@@ -35,14 +35,14 @@ class TestAST < Test::Unit::TestCase
         # We initialized it to true, so we should get that first
         ret = nil
         assert_nothing_raised {
-            ret = astif.evaluate(:scope => "yay")
+            ret = astif.evaluate("yay")
         }
         assert_equal(:if, ret)
 
         # Now set it to false and check that
         faketest.evaluate = false
         assert_nothing_raised {
-            ret = astif.evaluate(:scope => "yay")
+            ret = astif.evaluate("yay")
         }
         assert_equal(:else, ret)
     end
@@ -57,10 +57,10 @@ class TestAST < Test::Unit::TestCase
         end
 
         Puppet::Parser::Resource.expects(:new).with { |o| o.is_a?(Hash) }.returns(:override)
-        scope.compile.expects(:store_override).with(:override)
+        scope.compiler.expects(:add_override).with(:override)
         ret = nil
         assert_nothing_raised do
-            ret = ref.evaluate :scope => scope
+            ret = ref.evaluate scope
         end
 
         assert_equal(:override, ret, "Did not return override")
@@ -74,7 +74,7 @@ class TestAST < Test::Unit::TestCase
         args = {:source => "/yay/ness", :group => "yayness"}
         assert_nothing_raised do
             obj = defaultobj "file", args
-            obj.evaluate :scope => scope
+            obj.evaluate scope
         end
 
         hash = nil
@@ -93,56 +93,6 @@ class TestAST < Test::Unit::TestCase
         end
     end
 
-    def test_node
-        scope = mkscope
-        parser = scope.compile.parser
-
-        # Define a base node
-        basenode = parser.newnode "basenode", :code => AST::ASTArray.new(:children => [
-            resourcedef("file", "/tmp/base", "owner" => "root")
-        ])
-
-        # Now define a subnode
-        nodes = parser.newnode ["mynode", "othernode"],
-            :code => AST::ASTArray.new(:children => [
-                resourcedef("file", "/tmp/mynode", "owner" => "root"),
-                resourcedef("file", "/tmp/basenode", "owner" => "daemon")
-        ])
-
-        assert_instance_of(Array, nodes)
-
-        # Make sure we can find them all.
-        %w{mynode othernode}.each do |node|
-            assert(parser.nodes[node], "Could not find %s" % node)
-        end
-        mynode = parser.nodes["mynode"]
-
-        # Now try evaluating the node
-        assert_nothing_raised do
-            mynode.evaluate :scope => scope, :resource => scope.resource
-        end
-
-        # Make sure that we can find each of the files
-        myfile = scope.findresource "File[/tmp/mynode]"
-        assert(myfile, "Could not find file from node")
-        assert_equal("root", myfile[:owner])
-
-        basefile = scope.findresource "File[/tmp/basenode]"
-        assert(basefile, "Could not find file from base node")
-        assert_equal("daemon", basefile[:owner])
-
-        # Now make sure we can evaluate nodes with parents
-        child = parser.newnode(%w{child}, :parent => "basenode").shift
-
-        newscope = mkscope :parser => parser
-        assert_nothing_raised do
-            child.evaluate :scope => newscope, :resource => scope.resource
-        end
-
-        assert(newscope.findresource("File[/tmp/base]"),
-            "Could not find base resource")
-    end
-
     def test_collection
         scope = mkscope
 
@@ -155,13 +105,13 @@ class TestAST < Test::Unit::TestCase
 
         ret = nil
         assert_nothing_raised do
-            ret = coll.evaluate :scope => scope
+            ret = coll.evaluate scope
         end
 
         assert_instance_of(Puppet::Parser::Collector, ret)
 
         # Now make sure we get it back from the scope
-        colls = scope.compile.instance_variable_get("@collections")
+        colls = scope.compiler.instance_variable_get("@collections")
         assert_equal([ret], colls, "Did not store collector in config's collection list")
     end
 
@@ -175,7 +125,7 @@ class TestAST < Test::Unit::TestCase
         run_collection_queries(:virtual) do |string, result, query|
             code = nil
             assert_nothing_raised do
-                str, code = query.evaluate :scope => scope
+                str, code = query.evaluate scope
             end
 
             assert_instance_of(Proc, code)