puppet 0.24.4 → 0.24.5

data/lib/puppet/parser/templatewrapper.rb

@@ -20,6 +20,15 @@ class Puppet::Parser::TemplateWrapper
         end
     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
+            true
+        else
+            false
+        end
+    end
+
     # Ruby treats variables like methods, so we can cheat here and
     # trap missing vars like they were missing methods.
     def method_missing(name, *args)

data/lib/puppet/pgraph.rb

@@ -58,7 +58,7 @@ class Puppet::PGraph < Puppet::SimpleGraph
             # to, which is the same thing as saying all edges directly below
             # This vertex in the graph.
             adjacent(source, :direction => :out, :type => :edges).find_all do |edge|
-                edge.match?(event.event)
+                edge.match?(event.name)
             end
         end.compact.flatten
     end

data/lib/puppet/property.rb

@@ -2,7 +2,6 @@
 # blocks for actually doing work on the system.
 
 require 'puppet'
-require 'puppet/propertychange'
 require 'puppet/parameter'
 
 module Puppet

data/lib/puppet/provider.rb

@@ -5,6 +5,10 @@ class Puppet::Provider
     include Puppet::Util::Warnings
     extend Puppet::Util::Warnings
 
+    require 'puppet/provider/confiner'
+
+    extend Puppet::Provider::Confiner
+
     Puppet::Util.logmethods(self, true)
 
     class << self
@@ -40,27 +44,13 @@ class Puppet::Provider
                 [name, self.name]
         end
 
-        if command == :missing
-            return nil
-        end
-
-        command
+        return binary(command)
     end
 
     # Define commands that are not optional.
     def self.commands(hash)
         optional_commands(hash) do |name, path|
-            confine :exists => path
-        end
-    end
-
-    def self.confine(hash)
-        hash.each do |p,v|
-            if v.is_a? Array
-                @confines[p] += v
-            else
-                @confines[p] << v
-            end
+            confine :exists => path, :for_binary => true
         end
     end
 
@@ -108,10 +98,6 @@ class Puppet::Provider
     def self.initvars
         @defaults = {}
         @commands = {}
-        @origcommands = {}
-        @confines = Hash.new do |hash, key|
-            hash[key] = []
-        end
     end
 
     # The method for returning a list of provider instances.  Note that it returns providers, preferably with values already
@@ -180,16 +166,7 @@ class Puppet::Provider
     def self.optional_commands(hash)
         hash.each do |name, path|
             name = symbolize(name)
-            @origcommands[name] = path
-
-            # Try to find the full path (or verify already-full paths); otherwise
-            # store that the command is missing so we know it's defined but absent.
-            if tmp = binary(path)
-                path = tmp
-                @commands[name] = path
-            else
-                @commands[name] = :missing
-            end
+            @commands[name] = path
 
             if block_given?
                 yield(name, path)
@@ -208,69 +185,6 @@ class Puppet::Provider
         @source
     end
 
-    # Check whether this implementation is suitable for our platform.
-    def self.suitable?(short = true)
-        # A single false result is sufficient to turn the whole thing down.
-        # We don't return 'true' until the very end, though, so that every
-        # confine is tested.
-        missing = {}
-        @confines.each do |check, values|
-            case check
-            when :exists:
-                values.each do |value|
-                    unless value and FileTest.exists? value
-                        debug "Not suitable: missing %s" % value
-                        return false if short
-                        missing[:exists] ||= []
-                        missing[:exists] << value
-                    end
-                end
-            when :true:
-                values.each do |v|
-                    debug "Not suitable: false value"
-                    unless v
-                        return false if short
-                        missing[:true] ||= 0
-                        missing[:true] += 1
-                    end
-                end
-            when :false:
-                values.each do |v|
-                    debug "Not suitable: true value"
-                    if v and short
-                        return false if short
-                        missing[:false] ||= 0
-                        missing[:false] += 1
-                    end
-                end
-            else # Just delegate everything else to facter
-                if result = Facter.value(check)
-                    result = result.to_s.downcase.intern
-
-                    found = values.find do |v|
-                        result == v.to_s.downcase.intern
-                    end
-                    unless found
-                        debug "Not suitable: %s not in %s" % [check, values]
-                        return false if short
-                        missing[:facter] ||= {}
-                        missing[:facter][check] = values
-                    end
-                else
-                    return false if short
-                    missing[:facter] ||= {}
-                    missing[:facter][check] = values
-                end
-            end
-        end
-
-        if short
-            return true
-        else
-            return missing
-        end
-    end
-
     # Does this provider support the specified parameter?
     def self.supports_parameter?(param)
         if param.is_a?(Class)
@@ -309,8 +223,8 @@ class Puppet::Provider
     end
 
     dochook(:commands) do
-        if @origcommands.length > 0
-            return "  Required binaries: " + @origcommands.collect do |n, c|
+        if @commands.length > 0
+            return "  Required binaries: " + @commands.collect do |n, c|
                 "``#{c}``"
             end.join(", ") + "."
         end

data/lib/puppet/provider/confine.rb

@@ -0,0 +1,77 @@
+# The class that handles testing whether our providers
+# actually work or not.
+require 'puppet/util'
+
+class Puppet::Provider::Confine
+    include Puppet::Util
+
+    @tests = {}
+
+    class << self
+        attr_accessor :name
+    end
+
+    def self.inherited(klass)
+        name = klass.to_s.split("::").pop.downcase.to_sym
+        raise "Test %s is already defined" % name if @tests.include?(name)
+
+        klass.name = name
+
+        @tests[name] = klass
+    end
+
+    def self.test(name)
+        unless @tests[name]
+            begin
+                require "puppet/provider/confine/%s" % name
+            rescue LoadError => detail
+                unless detail.to_s.include?("no such file")
+                    warn "Could not load confine test '%s': %s" % [name, detail]
+                end
+                # Could not find file
+            end
+        end
+        return @tests[name]
+    end
+
+    attr_reader :values
+
+    # Mark that this confine is used for testing binary existence.
+    attr_accessor :for_binary
+    def for_binary?
+        for_binary
+    end
+
+    def initialize(values)
+        values = [values] unless values.is_a?(Array)
+        @values = values
+    end
+
+    # Provide a hook for the message when there's a failure.
+    def message(value)
+        ""
+    end
+
+    # Collect the results of all of them.
+    def result
+        values.collect { |value| pass?(value) }
+    end
+
+    # Test whether our confine matches.
+    def valid?
+        values.each do |value|
+            unless pass?(value)
+                Puppet.debug message(value)
+                return false
+            end
+        end
+
+        return true
+    ensure
+        reset
+    end
+
+    # Provide a hook for subclasses.
+    def reset
+    end
+end

data/lib/puppet/provider/confine/exists.rb

@@ -0,0 +1,22 @@
+require 'puppet/provider/confine'
+
+class Puppet::Provider::Confine::Exists < Puppet::Provider::Confine
+    def self.summarize(confines)
+        confines.inject([]) { |total, confine| total + confine.summary }
+    end
+
+    def pass?(value)
+        if for_binary?
+            return false unless value = binary(value)
+        end
+        value and FileTest.exist?(value)
+    end
+
+    def message(value)
+        "file %s does not exist" % value
+    end
+
+    def summary
+        result.zip(values).inject([]) { |array, args| val, f = args; array << f unless val; array }
+    end
+end

data/lib/puppet/provider/confine/false.rb

@@ -0,0 +1,19 @@
+require 'puppet/provider/confine'
+
+class Puppet::Provider::Confine::False < Puppet::Provider::Confine
+    def self.summarize(confines)
+        confines.inject(0) { |count, confine| count + confine.summary }
+    end
+
+    def pass?(value)
+        ! value
+    end
+
+    def message(value)
+        "true value when expecting false"
+    end
+
+    def summary
+        result.find_all { |v| v == false }.length
+    end
+end

data/lib/puppet/provider/confine/feature.rb

@@ -0,0 +1,17 @@
+require 'puppet/provider/confine'
+
+class Puppet::Provider::Confine::Feature < Puppet::Provider::Confine
+    def self.summarize(confines)
+        confines.collect { |c| c.values }.flatten.uniq.find_all { |value| ! confines[0].pass?(value) }
+    end
+
+    # Is the named feature available?
+    def pass?(value)
+        Puppet.features.send(value.to_s + "?")
+    end
+
+    def message(value)
+        "feature %s is missing" % value
+    end
+end
+

data/lib/puppet/provider/confine/true.rb

@@ -0,0 +1,20 @@
+require 'puppet/provider/confine'
+
+class Puppet::Provider::Confine::True < Puppet::Provider::Confine
+    def self.summarize(confines)
+        confines.inject(0) { |count, confine| count + confine.summary }
+    end
+
+    def pass?(value)
+        # Double negate, so we only get true or false.
+        ! ! value
+    end
+
+    def message(value)
+        "false value when expecting true"
+    end
+
+    def summary
+        result.find_all { |v| v == true }.length
+    end
+end

data/lib/puppet/provider/confine/variable.rb

@@ -0,0 +1,42 @@
+require 'puppet/provider/confine'
+
+class Puppet::Provider::Confine::Variable < Puppet::Provider::Confine
+    def self.summarize(confines)
+        result = Hash.new { |hash, key| hash[key] = [] }
+        confines.inject(result) { |total, confine| total[confine.fact] += confine.values unless confine.valid?; total }
+    end
+
+    attr_accessor :name
+
+    # Retrieve the value from facter
+    def facter_value
+        unless defined?(@facter_value) and @facter_value
+            @facter_value = ::Facter.value(name).to_s.downcase
+        end
+        @facter_value
+    end
+
+    def message(value)
+        "facter value '%s' for '%s' not in required list '%s'" % [value, self.name, values.join(",")]
+    end
+
+    def pass?(value)
+        test_value.downcase.to_s == value.to_s.downcase
+    end
+
+    def reset
+        # Reset the cache.  We want to cache it during a given
+        # run, but across runs.
+        @facter_value = nil
+    end
+
+    private
+
+    def setting?
+        Puppet.settings.valid?(name)
+    end
+
+    def test_value
+        setting? ? Puppet.settings[name] : facter_value 
+    end
+end

data/lib/puppet/provider/confine_collection.rb

@@ -0,0 +1,47 @@
+# Manage a collection of confines, returning a boolean or
+# helpful information.
+require 'puppet/provider/confine'
+
+class Puppet::Provider::ConfineCollection
+    def confine(hash)
+        if hash.include?(:for_binary)
+            for_binary = true
+            hash.delete(:for_binary)
+        else
+            for_binary = false
+        end
+        hash.each do |test, values|
+            if klass = Puppet::Provider::Confine.test(test)
+                @confines << klass.new(values)
+                @confines[-1].for_binary = true if for_binary
+            else
+                confine = Puppet::Provider::Confine.test(:variable).new(values)
+                confine.name = test
+                @confines << confine
+            end
+        end
+    end
+
+    def initialize
+        @confines = []
+    end
+
+    # Return a hash of the whole confine set, used for the Provider
+    # reference.
+    def summary
+        confines = Hash.new { |hash, key| hash[key] = [] }
+        @confines.each { |confine| confines[confine.class] << confine }
+        result = {}
+        confines.each do |klass, list|
+            value = klass.summarize(list)
+            next if (value.respond_to?(:length) and value.length == 0) or (value == 0)
+            result[klass.name] = value
+
+        end
+        result
+    end
+
+    def valid?
+        ! @confines.detect { |c| ! c.valid? }
+    end
+end

data/lib/puppet/provider/confiner.rb

@@ -0,0 +1,20 @@
+require 'puppet/provider/confine_collection'
+
+module Puppet::Provider::Confiner
+    def confine(hash)
+        confine_collection.confine(hash)
+    end
+
+    def confine_collection
+        unless defined?(@confine_collection)
+            @confine_collection = Puppet::Provider::ConfineCollection.new
+        end
+        @confine_collection
+    end
+
+    # Check whether this implementation is suitable for our platform.
+    def suitable?(short = true)
+        return confine_collection.valid? if short
+        return confine_collection.summary
+    end
+end