puppet 0.24.9 → 0.25.0

data/lib/puppet/{resource_reference.rb → resource/reference.rb}

@@ -3,34 +3,48 @@
 #  Copyright (c) 2007. All rights reserved.
 
 require 'puppet'
+require 'puppet/resource'
 
 # A simple class to canonize how we refer to and retrieve
 # resources.
-class Puppet::ResourceReference
-    attr_reader :type
-    attr_accessor :title, :catalog
+class Puppet::Resource::Reference
+    attr_reader :type, :title
+    attr_accessor :catalog
 
-    def initialize(type, title)
-        # This will set @type if it looks like a resource reference.
-        self.title = title
+    def ==(other)
+        other.respond_to?(:title) and self.type == other.type and self.title == other.title
+    end
+
+    def builtin_type?
+        builtin_type ? true : false
+    end
+
+    def initialize(argtype, argtitle = nil)
+        if argtitle.nil?
+            if argtype.is_a?(Puppet::Type)
+                self.title = argtype.title
+                self.type = argtype.class.name
+            else
+                self.title = argtype
+                if self.title == argtype
+                    raise ArgumentError, "No title provided and title '%s' is not a valid resource reference" % argtype.inspect
+                end
+            end
+        else
+            # This will set @type if it looks like a resource reference.
+            self.title = argtitle
+
+            # Don't override whatever was done by setting the title.
+            self.type ||= argtype
+        end
 
-        # Don't override whatever was done by setting the title.
-        self.type = type if self.type.nil?
-        
         @builtin_type = nil
     end
 
     # Find our resource.
     def resolve
-        if catalog
-            return catalog.resource(to_s)
-        end
-        # If it's builtin, then just ask for it directly from the type.
-        if t = builtin_type
-            t[@title]
-        else # Else, look for a component with the full reference as the name.
-            Puppet::Type::Component[to_s]
-        end
+        return catalog.resource(to_s) if catalog
+        return nil
     end
 
     # If the title has square brackets, treat it like a reference and
@@ -49,11 +63,23 @@ class Puppet::ResourceReference
         if value.nil? or value.to_s.downcase == "component"
             @type = "Class"
         else
-            # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com] 
+            # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
             x = @type = value.to_s.split("::").collect { |s| s.capitalize }.join("::")
         end
     end
 
+    # Convert to the reference format that TransObject uses.  Yay backward
+    # compatibility.
+    def to_trans_ref
+        # We have to return different cases to provide backward compatibility
+        # from 0.24.x to 0.23.x.
+        if builtin_type?
+            return [type.to_s.downcase, title.to_s]
+        else
+            return [type.to_s, title.to_s]
+        end
+    end
+
     # Convert to the standard way of referring to resources.
     def to_s
         "%s[%s]" % [@type, @title]
@@ -61,16 +87,12 @@ class Puppet::ResourceReference
 
     private
 
-    def builtin_type?
-        builtin_type ? true : false
-    end
-
     def builtin_type
         if @builtin_type.nil?
             if @type =~ /::/
                 @builtin_type = false
             elsif klass = Puppet::Type.type(@type.to_s.downcase)
-                @builtin_type = klass
+                @builtin_type = true
             else
                 @builtin_type = false
             end

data/lib/puppet/simple_graph.rb

@@ -3,6 +3,7 @@
 
 require 'puppet/external/dot'
 require 'puppet/relationship'
+require 'set'
 
 # A hopefully-faster graph class to replace the use of GRATR.
 class Puppet::SimpleGraph
@@ -19,8 +20,7 @@ class Puppet::SimpleGraph
 
         def initialize(vertex)
             @vertex = vertex
-            @adjacencies = {:in => Hash.new { |h,k| h[k] = [] }, :out => Hash.new { |h,k| h[k] = [] }}
-            #@adjacencies = {:in => [], :out => []}
+            @adjacencies = {:in => {}, :out => {}}
         end
 
         # Find adjacent vertices or edges.
@@ -28,24 +28,26 @@ class Puppet::SimpleGraph
             direction = options[:direction] || :out
             options[:type] ||= :vertices
 
-            return @adjacencies[direction].values.flatten if options[:type] == :edges
+            if options[:type] == :edges
+                return send(direction.to_s + "_edges")
+            end
 
-            return @adjacencies[direction].keys
+            return @adjacencies[direction].keys.reject { |vertex| @adjacencies[direction][vertex].empty? }
         end
 
         # Add an edge to our list.
         def add_edge(direction, edge)
-            @adjacencies[direction][other_vertex(direction, edge)] << edge
+            opposite_adjacencies(direction, edge) << edge
         end
 
         # Return all known edges.
         def edges
-            [:in, :out].collect { |dir| @adjacencies[dir].values }.flatten
+            in_edges + out_edges
         end
 
         # Test whether we share an edge with a given vertex.
         def has_edge?(direction, vertex)
-            return true if @adjacencies[direction][vertex].length > 0
+            return true if vertex_adjacencies(direction, vertex).length > 0
             return false
         end
 
@@ -58,14 +60,14 @@ class Puppet::SimpleGraph
             # as expensive as just getting the edge list, so I've decided
             # to only add this method.
             define_method("%s_edges" % direction) do
-                @adjacencies[direction].values.flatten
+                @adjacencies[direction].values.inject([]) { |total, adjacent| total += adjacent.to_a; total }
             end
         end
 
         # The other vertex in the edge.
         def other_vertex(direction, edge)
             case direction
-            when :in: edge.source
+            when :in; edge.source
             else
                 edge.target
             end
@@ -74,12 +76,29 @@ class Puppet::SimpleGraph
         # Remove an edge from our list.  Assumes that we've already checked
         # that the edge is valid.
         def remove_edge(direction, edge)
-            @adjacencies[direction][other_vertex(direction, edge)].delete(edge)
+            opposite_adjacencies(direction, edge).delete(edge)
         end
 
         def to_s
             vertex.to_s
         end
+
+        private
+
+        # These methods exist so we don't need a Hash with a default proc.
+
+        # Look up the adjacencies for a vertex at the other end of an
+        # edge.
+        def opposite_adjacencies(direction, edge)
+            opposite_vertex = other_vertex(direction, edge)
+            vertex_adjacencies(direction, opposite_vertex)
+        end
+
+        # Look up the adjacencies for a given vertex.
+        def vertex_adjacencies(direction, vertex)
+            @adjacencies[direction][vertex] ||= Set.new
+            @adjacencies[direction][vertex]
+        end
     end
 
     def initialize
@@ -94,11 +113,55 @@ class Puppet::SimpleGraph
         @edges.clear
     end
 
+    # Which resources a given resource depends upon.
+    def dependents(resource)
+        tree_from_vertex(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_vertex(resource, :out).keys
+    end
+
     # Whether our graph is directed.  Always true.  Used to produce dot files.
     def directed?
         true
     end
 
+    # Determine all of the leaf nodes below a given vertex.
+    def leaves(vertex, direction = :out)
+        tree = tree_from_vertex(vertex, direction)
+        l = tree.keys.find_all { |c| adjacent(c, :direction => direction).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.name)
+            end
+        end.compact.flatten
+    end
+
     # Return a reversed version of this graph.
     def reversal
         result = self.class.new
@@ -146,7 +209,7 @@ class Puppet::SimpleGraph
         # If we have any vertices left with non-zero in-degrees, then we've found a cycle.
         if cycles = degree.find_all { |vertex, edges| edges.length > 0 } and cycles.length > 0
             message = cycles.collect { |vertex, edges| edges.collect { |e| e.to_s }.join(", ") }.join(", ")
-            raise Puppet::Error, "Found dependency cycles in the following relationships: %s" % message
+            raise Puppet::Error, "Found dependency cycles in the following relationships: %s; try using the '--graph' option and open the '.dot' files in OmniGraffle or GraphViz" % message
         end
 
         return result
@@ -154,6 +217,7 @@ class Puppet::SimpleGraph
 
     # Add a new vertex to the graph.
     def add_vertex(vertex)
+        @reversal = nil
         return false if vertex?(vertex)
         setup_vertex(vertex)
         true # don't return the VertexWrapper instance.
@@ -163,6 +227,7 @@ class Puppet::SimpleGraph
     def remove_vertex!(vertex)
         return nil unless vertex?(vertex)
         @vertices[vertex].edges.each { |edge| remove_edge!(edge) }
+        @edges -= @vertices[vertex].edges
         @vertices[vertex].clear
         @vertices.delete(vertex)
     end
@@ -180,6 +245,7 @@ class Puppet::SimpleGraph
     # Add a new edge.  The graph user has to create the edge instance,
     # since they have to specify what kind of edge it is.
     def add_edge(source, target = nil, label = nil)
+        @reversal = nil
         if target
             edge = Puppet::Relationship.new(source, target, label)
         else
@@ -218,11 +284,8 @@ class Puppet::SimpleGraph
     def remove_edge!(edge)
         @vertices[edge.source].remove_edge(:out, edge)
         @vertices[edge.target].remove_edge(:in, edge)
-        
-        # Here we are looking for an exact edge, so we don't want to use ==, because
-        # it's too darn expensive (in testing, deleting 3000 edges went from 6 seconds to
-        # 0.05 seconds with this change).
-        @edges.each_with_index { |test_edge, index| @edges.delete_at(index) and break if edge.equal?(test_edge) }
+
+        @edges.delete(edge)
         nil
     end
 
@@ -239,9 +302,9 @@ class Puppet::SimpleGraph
     def setup_vertex(vertex)
         @vertices[vertex] = VertexWrapper.new(vertex)
     end
- 
+
     public
-    
+
 #    # For some reason, unconnected vertices do not show up in
 #    # this graph.
 #    def to_jpg(path, name)
@@ -251,16 +314,79 @@ class Puppet::SimpleGraph
 #        end
 #    end
 
-    def to_yaml_properties
-        instance_variables
+    # 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
+
+                        add_edge(s, t, edge.label)
+                    end
+
+                    # Now get rid of the edge, so remove_vertex! works correctly.
+                    remove_edge!(edge)
+                end
+            end
+            remove_vertex!(container)
+        end
     end
 
     # Just walk the tree and pass each edge.
-    def walk(source, direction, &block)
-        adjacent(source, :direction => direction).each do |target|
-            yield source, target
-            walk(target, direction, &block)
+    def walk(source, direction)
+        # Use an iterative, breadth-first traversal of the graph. One could do
+        # this recursively, but Ruby's slow function calls and even slower
+        # recursion make the shorter, recursive algorithm cost-prohibitive.
+        stack = [source]
+        seen = Set.new
+        until stack.empty?
+            node = stack.shift
+            next if seen.member? node
+            connected = adjacent(node, :direction => direction)
+            connected.each do |target|
+                yield node, target
+            end
+            stack.concat(connected)
+            seen << node
+        end
+    end
+
+    # A different way of walking a tree, and a much faster way than the
+    # one that comes with GRATR.
+    def tree_from_vertex(start, direction = :out)
+        predecessor={}
+        walk(start, direction) do |parent, child|
+            predecessor[child] = parent
         end
+        predecessor
     end
 
     # LAK:FIXME This is just a paste of the GRATR code with slight modifications.
@@ -293,7 +419,7 @@ class Puppet::SimpleGraph
       end
       graph
     end
-    
+
     # Output the dot format as a string
     def to_dot (params={}) to_dot_graph(params).to_s; end
 
@@ -309,10 +435,22 @@ class Puppet::SimpleGraph
     def write_to_graphic_file (fmt='png', dotfile='graph')
       src = dotfile + '.dot'
       dot = dotfile + '.' + fmt
-      
+
       File.open(src, 'w') {|f| f << self.to_dot << "\n"}
-      
+
       system( "dot -T#{fmt} #{src} -o #{dot}" )
       dot
     end
+
+    # Produce the graph files if requested.
+    def write_graph(name)
+        return unless Puppet[:graph]
+
+        Puppet.settings.use(:graphing)
+
+        file = File.join(Puppet[:graphdir], "%s.dot" % name.to_s)
+        File.open(file, "w") { |f|
+            f.puts to_dot("name" => name.to_s.capitalize)
+        }
+    end
 end

data/lib/puppet/ssl.rb

@@ -0,0 +1,7 @@
+# Just to make the constants work out.
+require 'puppet'
+require 'openssl'
+
+module Puppet::SSL # :nodoc:
+    require 'puppet/ssl/host'
+end

data/lib/puppet/ssl/base.rb

@@ -0,0 +1,62 @@
+require 'puppet/ssl'
+
+# The base class for wrapping SSL instances.
+class Puppet::SSL::Base
+    # For now, use the YAML separator.
+    SEPARATOR = "\n---\n"
+
+    def self.from_multiple_s(text)
+        text.split(SEPARATOR).collect { |inst| from_s(inst) }
+    end
+
+    def self.to_multiple_s(instances)
+        instances.collect { |inst| inst.to_s }.join(SEPARATOR)
+    end
+
+    def self.wraps(klass)
+        @wrapped_class = klass
+    end
+
+    def self.wrapped_class
+        raise(Puppet::DevError, "%s has not declared what class it wraps" % self) unless defined?(@wrapped_class)
+        @wrapped_class
+    end
+
+    attr_accessor :name, :content
+
+    # Is this file for the CA?
+    def ca?
+        name == Puppet::SSL::Host.ca_name
+    end
+
+    def generate
+        raise Puppet::DevError, "%s did not override 'generate'" % self.class
+    end
+
+    def initialize(name)
+        @name = name.to_s.downcase
+    end
+
+    # Read content from disk appropriately.
+    def read(path)
+        @content = wrapped_class.new(File.read(path))
+    end
+
+    # Convert our thing to pem.
+    def to_s
+        return "" unless content
+        content.to_pem
+    end
+
+    # Provide the full text of the thing we're dealing with.
+    def to_text
+        return "" unless content
+        content.to_text
+    end
+
+    private
+
+    def wrapped_class
+        self.class.wrapped_class
+    end
+end