puppet 0.18.4 → 0.22.4

data/lib/puppet/parser/templatewrapper.rb

@@ -0,0 +1,54 @@
+# A simple wrapper for templates, so they don't have full access to
+# the scope objects.
+class Puppet::Parser::TemplateWrapper
+    attr_accessor :scope, :file
+    include Puppet::Util
+    Puppet::Util.logmethods(self)
+
+    def initialize(scope, file)
+        @scope = scope
+        @file = Puppet::Module::find_template(file)
+
+        unless FileTest.exists?(@file)
+            raise Puppet::ParseError,
+                "Could not find template %s" % file
+        end
+
+        # We'll only ever not have an interpreter in testing, but, eh.
+        if @scope.interp
+            @scope.interp.newfile(@file)
+        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)
+        # We have to tell lookupvar to return :undefined to us when
+        # appropriate; otherwise it converts to "".
+        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
+        end
+    end
+
+    def result
+        result = nil
+        benchmark(:debug, "Interpolated template #{@file}") do
+            template = ERB.new(File.read(@file), 0, "-")
+            result = template.result(binding)
+        end
+
+        result
+    end
+
+    def to_s
+        "template[%s]" % @file
+    end
+end
+
+# $Id: templatewrapper.rb 2277 2007-03-09 00:48:28Z lutter $

data/lib/puppet/pgraph.rb

@@ -0,0 +1,208 @@
+#  Created by Luke A. Kanies on 2006-11-24.
+#  Copyright (c) 2006. All rights reserved.
+
+require 'puppet/external/gratr/digraph'
+require 'puppet/external/gratr/import'
+require 'puppet/external/gratr/dot'
+require 'puppet/relationship'
+
+# This class subclasses a graph class in order to handle relationships
+# among resources.
+class Puppet::PGraph < GRATR::Digraph
+    # This is the type used for splicing.
+    attr_accessor :container_type
+
+    include Puppet::Util
+
+    def add_edge!(*args)
+        @reversal = nil
+        super
+    end
+
+    def add_vertex!(*args)
+        @reversal = nil
+        super
+    end
+    
+    def clear
+        @vertex_dict.clear
+        if defined? @edge_number
+            @edge_number.clear
+        end
+    end
+
+    # Make sure whichever edge has a label keeps the label
+    def copy_label(source, target, label)
+        # 'require' relationships will not have a label,
+        # and all 'subscribe' relationships have the same
+        # label, at least for now.
+
+        # Labels default to {}, so we can't just test for nil.
+        newlabel = label || {}
+        oldlabel = edge_label(source, target) || {}
+        if ! newlabel.empty? and oldlabel.empty?
+            edge_label_set(source, target, label)
+            # We should probably check to see if the labels both exist
+            # and don't match, but we'd just throw an error which the user
+            # couldn't do anyting about.
+        end
+    end
+
+    # Fail in a somewhat informative way if the graph has become cyclic.
+    def check_cycle(sorted)
+        return true if sorted.size == size()
+
+        bad = []
+        vertices.each do |v|
+            bad << v unless sorted.include?(v)
+        end
+
+        if bad.length > 0
+            raise Puppet::Error,
+                "Found dependency cycle involving %s" % bad.collect do |v|
+                    v.to_s
+            end.join(", ")
+        else
+            raise Puppet::Error,
+                "Found dependency cycle but could not find the cause"
+        end
+    end
+
+    # Which resources a given resource depends upon.
+    def dependents(resource)
+        tree_from_vertex2(resource).keys
+    end
+    
+    # Which resources depend upon the given resource.
+    def dependencies(resource)
+        # Cache the reversal graph, because it's somewhat expensive
+        # to create.
+        unless defined? @reversal and @reversal
+            @reversal = reversal
+        end
+        # Strangely, it's significantly faster to search a reversed
+        # tree in the :out direction than to search a normal tree
+        # in the :in direction.
+        @reversal.tree_from_vertex2(resource, :out).keys
+        #tree_from_vertex2(resource, :in).keys
+    end
+    
+    # Override this method to use our class instead.
+    def edge_class()
+        Puppet::Relationship
+    end
+    
+    # Determine all of the leaf nodes below a given vertex.
+    def leaves(vertex, type = :dfs)
+        tree = tree_from_vertex(vertex, type)
+        l = tree.keys.find_all { |c| adjacent(c, :direction => :out).empty? }
+        return l
+    end
+    
+    # Collect all of the edges that the passed events match.  Returns
+    # an array of edges.
+    def matching_edges(events, base = nil)
+        events.collect do |event|
+            source = base || event.source
+            
+            unless vertex?(source)
+                Puppet.warning "Got an event from invalid vertex %s" % source.ref
+                next
+            end
+            # Get all of the edges that this vertex should forward events
+            # 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)
+            end
+        end.flatten
+    end
+    
+    # Take container information from another graph and use it
+    # to replace any container vertices with their respective leaves.
+    # This creates direct relationships where there were previously
+    # indirect relationships through the containers. 
+    def splice!(other, type)
+        # We have to get the container list via a topological sort on the
+        # configuration graph, because otherwise containers that contain
+        # other containers will add those containers back into the
+        # graph.  We could get a similar affect by only setting relationships
+        # to container leaves, but that would result in many more
+        # relationships.
+        containers = other.topsort.find_all { |v| v.is_a?(type) and vertex?(v) }
+        containers.each do |container|
+            # Get the list of children from the other graph.
+            children = other.adjacent(container, :direction => :out)
+
+            # Just remove the container if it's empty.
+            if children.empty?
+                remove_vertex!(container)
+                next
+            end
+            
+            # First create new edges for each of the :in edges
+            [:in, :out].each do |dir|
+                edges = adjacent(container, :direction => dir, :type => :edges)
+                edges.each do |edge|
+                    children.each do |child|
+                        if dir == :in
+                            s = edge.source
+                            t = child
+                        else
+                            s = child
+                            t = edge.target
+                        end
+
+                        # We don't want to add multiple copies of the
+                        # same edge, but we *do* want to make sure we
+                        # keep labels around.
+                        # XXX This will *not* work when we support multiple
+                        # types of labels, and only works now because
+                        # you can only do simple subscriptions.
+                        if edge?(s, t)
+                            copy_label(s, t, edge.label)
+                            next
+                        end
+                        add_edge!(s, t, edge.label)
+                    end
+
+                    # Now get rid of the edge, so remove_vertex! works correctly.
+                    remove_edge!(edge)
+                    Puppet.debug "%s: %s => %s: %s" % [container,
+                        edge.source, edge.target, edge?(edge)]
+                end
+            end
+            remove_vertex!(container)
+        end
+    end
+    
+    # For some reason, unconnected vertices do not show up in
+    # this graph.
+    def to_jpg(path, name)
+        gv = vertices()
+        Dir.chdir(path) do
+            induced_subgraph(gv).write_to_graphic_file('jpg', name)
+        end
+    end
+
+    # A different way of walking a tree, and a much faster way than the
+    # one that comes with GRATR.
+    def tree_from_vertex2(start, direction = :out)
+        predecessor={}
+        walk(start, direction) do |parent, child|
+            predecessor[child] = parent
+        end
+        predecessor       
+    end
+
+    # A support method for tree_from_vertex2.  Just walk the tree and pass
+    # the parents and children.
+    def walk(source, direction, &block)
+        adjacent(source, :direction => direction).each do |target|
+            yield source, target
+            walk(target, direction, &block)
+        end
+    end
+end
+
+# $Id: pgraph.rb 2308 2007-03-19 04:40:25Z luke $

data/lib/puppet/propertychange.rb

@@ -0,0 +1,143 @@
+# the class responsible for actually doing any work
+
+# enables no-op and logging/rollback
+
+module Puppet
+    # Handle all of the work around performing an actual change,
+    # including calling 'sync' on the properties and producing events.
+	class PropertyChange
+        attr_accessor :is, :should, :type, :path, :property, :transaction, :changed, :proxy
+        
+        # The log file generated when this object was changed.
+        attr_reader :report
+        
+        # Switch the goals of the property, thus running the change in reverse.
+        def backward
+            @property.should = @is
+            @property.retrieve
+
+            unless defined? @transaction
+                raise Puppet::Error,
+                    "PropertyChange '%s' tried to be executed outside of transaction" %
+                    self
+            end
+            unless @property.insync?
+                @property.info "Backing %s" % self
+                return self.go
+            else
+                @property.debug "rollback is already in sync: %s vs. %s" %
+                    [@property.is.inspect, @property.should.inspect]
+                return nil
+            end
+        end
+        
+        def changed?
+            self.changed
+        end
+
+        # Create our event object.
+        def event(name)
+            # default to a simple event type
+            unless name.is_a?(Symbol)
+                @property.warning("Property '%s' returned invalid event '%s'; resetting to default" %
+                    [@property.class,event])
+
+                event = @property.parent.class.name.id2name + "_changed"
+            end
+            
+            Puppet::Event.new(
+                :event => name,
+                :transaction => @transaction,
+                :source => self.source
+            )
+        end
+
+        def initialize(property)
+            unless property.is_a?(Puppet::Type::Property)
+                raise Puppet::DevError, "Got a %s instead of a property" %
+                    property.class
+            end
+            @property = property
+            @path = [property.path,"change"].flatten
+            @is = property.is
+
+            @should = property.should
+
+            @changed = false
+        end
+
+        # Perform the actual change.  This method can go either forward or
+        # backward, and produces an event.
+        def go
+            if skip?
+                if self.noop
+                    return [event(:noop)]
+                else
+                    return nil
+                end
+            end
+
+            # The transaction catches any exceptions here.
+            events = @property.sync
+            if events.nil?
+                return nil
+            end
+
+            if events.is_a?(Array)
+                if events.empty?
+                    return nil
+                end
+            else
+                events = [events]
+            end
+            
+            return events.collect { |name|
+                @report = @property.log(@property.change_to_s)
+                event(name)
+            }
+        end
+
+        def forward
+            #@property.debug "moving change forward"
+
+            unless defined? @transaction
+                raise Puppet::Error,
+                    "PropertyChange '%s' tried to be executed outside of transaction" %
+                    self
+            end
+
+            return self.go
+        end
+        
+        def noop
+            return @property.noop
+        end
+        
+        def skip?
+            if @property.insync?
+                @property.info "Already in sync"
+                return true
+            end
+
+            if @property.noop
+                @property.log "is %s, should be %s (noop)" %
+                    [property.is_to_s, property.should_to_s]
+                #@property.debug "%s is noop" % @property
+                return true
+            end
+            return false
+        end
+        
+        def source
+            self.proxy || @property.parent
+        end
+
+        def to_s
+            return "change %s.%s(%s)" %
+                [@transaction.object_id, self.object_id, @property.change_to_s]
+            #return "change %s.%s" % [@transaction.object_id, self.object_id]
+        end
+	end
+end
+
+# $Id: propertychange.rb 2286 2007-03-17 23:16:37Z luke $

data/lib/puppet/provider.rb

@@ -0,0 +1,302 @@
+# The container class for implementations.
+class Puppet::Provider
+    include Puppet::Util
+    include Puppet::Util::Errors
+
+    Puppet::Util.logmethods(self, true)
+
+    class << self
+        # Include the util module so we have access to things like 'binary'
+        include Puppet::Util, Puppet::Util::Docs
+        include Puppet::Util::Logging
+        attr_accessor :name
+        attr_reader :model
+        attr_writer :doc
+    end
+
+    attr_accessor :model
+    
+    def self.command(name)
+        name = symbolize(name)
+
+        if defined?(@commands) and command = @commands[name]
+            # nothing
+        elsif superclass.respond_to? :command and command = superclass.command(name)
+            # nothing
+        else
+            raise Puppet::DevError, "No command %s defined for provider %s" %
+                [name, self.name]
+        end
+
+        if command == :missing
+            return nil
+        end
+
+        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
+        end
+    end
+
+    # Does this implementation match all of the default requirements?  If
+    # defaults are empty, we return false.
+    def self.default?
+        return false if @defaults.empty?
+        if @defaults.find do |fact, values|
+                values = [values] unless values.is_a? Array
+                if fval = Facter.value(fact).to_s and fval != ""
+                    fval = fval.to_s.downcase.intern
+                else
+                    return false
+                end
+
+                # If any of the values match, we're a default.
+                if values.find do |value| fval == value.to_s.downcase.intern end
+                    false
+                else
+                    true
+                end
+            end
+            return false
+        else
+            return true
+        end
+    end
+
+    # Store how to determine defaults.
+    def self.defaultfor(hash)
+        hash.each do |d,v|
+            @defaults[d] = v
+        end
+    end
+
+    def self.defaultnum
+        @defaults.length
+    end
+
+    def self.initvars
+        @defaults = {}
+        @commands = {}
+        @origcommands = {}
+        @confines = Hash.new do |hash, key|
+            hash[key] = []
+        end
+    end
+
+    # Create the methods for a given command.
+    def self.make_command_methods(name)
+        # Now define a method for that command
+        unless metaclass.method_defined? name
+            meta_def(name) do |*args|
+                unless command(name)
+                    raise Puppet::Error, "Command %s is missing" % name
+                end
+                if args.empty?
+                    cmd = [command(name)]
+                else
+                    cmd = [command(name)] + args
+                end
+                # This might throw an ExecutionFailure, but the system above
+                # will catch it, if so.
+                return execute(cmd)
+            end
+            
+            # And then define an instance method that just calls the class method.
+            # We need both, so both instances and classes can easily run the commands.
+            unless method_defined? name
+                define_method(name) do |*args|
+                    self.class.send(name, *args)
+                end
+            end
+        end
+    end
+
+    # Create getter/setter methods for each property our model supports.
+    # They all get stored in @property_hash.  This method is useful
+    # for those providers that use prefetch and flush.
+    def self.mkmodelmethods
+        [model.validproperties, model.parameters].flatten.each do |attr|
+            attr = symbolize(attr)
+            define_method(attr) do
+                @property_hash[attr] || :absent
+            end
+
+            define_method(attr.to_s + "=") do |val|
+                @property_hash[attr] = val
+            end
+        end
+    end
+
+    # Add the feature module immediately, so its methods are available to the
+    # providers.
+    def self.model=(model)
+        @model = model
+        #if mod = model.feature_module
+        #    extend(mod)
+        #    include(mod)
+        #end
+    end
+
+    self.initvars
+
+    # Define one or more binaries we'll be using.  If a block is passed, yield the name
+    # and path to the block (really only used by 'commands').
+    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
+
+            if block_given?
+                yield(name, path)
+            end
+
+            # Now define the class and instance methods.
+            make_command_methods(name)
+        end
+    end
+
+    # Check whether this implementation is suitable for our platform.
+    def self.suitable?
+        # 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.
+        @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
+                    end
+                end
+            when :true:
+                values.each do |v|
+                    debug "Not suitable: false value"
+                    return false unless v
+                end
+            when :false:
+                values.each do |v|
+                    debug "Not suitable: true value"
+                    return false if v
+                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
+                    end
+                else
+                    return false
+                end
+            end
+        end
+
+        return true
+    end
+
+    # Does this provider support the specified parameter?
+    def self.supports_parameter?(param)
+        if param.is_a?(Class)
+            klass = param
+        else
+            unless klass = @model.attrclass(param)
+                raise Puppet::DevError, "'%s' is not a valid parameter for %s" % [param, @model.name]
+            end
+        end
+        return true unless features = klass.required_features
+
+        if satisfies?(*features)
+            return true
+        else
+            return false
+        end
+    end
+
+    def self.to_s
+        unless defined? @str
+            if self.model
+                @str = "%s provider %s" % [@model.name, self.name]
+            else
+                @str = "unattached provider %s" % [self.name]
+            end
+        end
+        @str
+    end
+
+    dochook(:defaults) do
+        if @defaults.length > 0
+            return "  Default for " + @defaults.collect do |f, v|
+                "``#{f}`` == ``#{v}``"
+            end.join(" and ") + "."
+        end
+    end
+
+    dochook(:commands) do
+        if @origcommands.length > 0
+            return "  Required binaries: " + @origcommands.collect do |n, c|
+                "``#{c}``"
+            end.join(", ") + "."
+        end
+    end
+
+    dochook(:features) do
+        if features().length > 0
+            return "  Supported features: " + features().collect do |f|
+                "``#{f}``"
+            end.join(", ") + "."
+        end
+    end
+
+    # Remove the reference to the model, so GC can clean up.
+    def clear
+        @model = nil
+    end
+
+    # Retrieve a named command.
+    def command(name)
+        self.class.command(name)
+    end
+
+    def initialize(model)
+        @model = model
+        @property_hash = {}
+    end
+
+    def name
+        @model.name
+    end
+
+    def to_s
+        "%s(provider=%s)" % [@model.to_s, self.class.name]
+    end
+end
+
+# $Id: provider.rb 2444 2007-05-01 03:14:09Z luke $