puppet 0.23.2 → 0.24.0

data/lib/puppet/reports.rb

@@ -0,0 +1,51 @@
+require 'puppet/util/instance_loader'
+
+# A simple mechanism for loading and returning reports.
+class Puppet::Reports
+    extend Puppet::Util::ClassGen
+    extend Puppet::Util::InstanceLoader
+
+    # Set up autoloading and retrieving of reports.
+    instance_load :report, 'puppet/reports'
+
+    class << self
+        attr_reader :hooks
+    end
+
+    # Add a new report type.
+    def self.register_report(name, options = {}, &block)
+        name = symbolize(name)
+
+        mod = genmodule(name, :extend => Puppet::Util::Docs, :hash => instance_hash(:report), :block => block)
+
+        if options[:useyaml]
+            mod.useyaml = true
+        end
+
+        mod.send(:define_method, :report_name) do
+            name
+        end
+    end
+
+    # Collect the docs for all of our reports.
+    def self.reportdocs
+        docs = ""
+
+        # Use this method so they all get loaded
+        instance_loader(:report).loadall
+        loaded_instances(:report).sort { |a,b| a.to_s <=> b.to_s }.each do |name|
+            mod = self.report(name)
+            docs += "%s\n%s\n" % [name, "-" * name.to_s.length]
+
+            docs += Puppet::Util::Docs.scrub(mod.doc) + "\n\n"
+        end
+
+        docs
+    end
+
+    # List each of the reports.
+    def self.reports
+        instance_loader(:report).loadall
+        loaded_instances(:report)
+    end
+end

data/lib/puppet/reports/log.rb

@@ -1,6 +1,6 @@
-require 'puppet'
+require 'puppet/reports'
 
-Puppet::Network::Handler.report.newreport(:log) do
+Puppet::Reports.register_report(:log) do
     desc "Send all received logs to the local log destinations.  Usually
         the log destination is syslog."
 
@@ -11,4 +11,3 @@ Puppet::Network::Handler.report.newreport(:log) do
     end
 end
 
-# $Id: log.rb 2367 2007-03-29 18:22:24Z luke $

data/lib/puppet/reports/rrdgraph.rb

@@ -1,6 +1,4 @@
-require 'puppet'
-
-Puppet::Network::Handler.report.newreport(:rrdgraph) do
+Puppet::Reports.register_report(:rrdgraph) do
     desc "Graph all available data about hosts using the RRD library.  You
         must have the Ruby RRDtool library installed to use this report, which
         you can get from `the RubyRRDTool RubyForge page`_.  This package requires
@@ -102,7 +100,7 @@ Puppet::Network::Handler.report.newreport(:rrdgraph) do
 
         unless File.directory?(hostdir) and FileTest.writable?(hostdir)
             # Some hackishness to create the dir with all of the right modes and ownership
-            config = Puppet::Util::Config.new
+            config = Puppet::Util::Settings.new
             config.setdefaults(:reports, :hostdir => {:default => hostdir, :owner => Puppet[:user], :mode => 0755, :group => Puppet[:group], :desc => "eh"})
 
             # This creates the dir.
@@ -135,4 +133,3 @@ Puppet::Network::Handler.report.newreport(:rrdgraph) do
     end
 end
 
-# $Id: rrdgraph.rb 2603 2007-06-18 16:26:22Z luke $

data/lib/puppet/reports/store.rb

@@ -1,7 +1,7 @@
 require 'puppet'
 
-Puppet::Network::Handler.report.newreport(:store, :useyaml => true) do
-    Puppet.config.use(:reporting)
+Puppet::Reports.register_report(:store) do
+    Puppet.settings.use(:reporting)
 
     desc "Store the yaml report on disk.  Each host sends its report as a YAML dump
         and this just stores the file on disk, in the ``reportdir`` directory.
@@ -11,9 +11,9 @@ Puppet::Network::Handler.report.newreport(:store, :useyaml => true) do
         default report)."
 
     def mkclientdir(client, dir)
-        config = Puppet::Util::Config.new
+        config = Puppet::Util::Settings.new
         config.setdefaults("reportclient-#{client}",
-            "clientdir-#{client}" => { :default => dir,
+            "client-#{client}-dir" => { :default => dir,
                 :mode => 0750,
                 :desc => "Client dir for %s" % client,
                 :owner => Puppet[:user],
@@ -24,7 +24,7 @@ Puppet::Network::Handler.report.newreport(:store, :useyaml => true) do
         config.use("reportclient-#{client}")
     end
 
-    def process(yaml)
+    def process
         # We don't want any tracking back in the fs.  Unlikely, but there
         # you go.
         client = self.host.gsub("..",".")
@@ -46,7 +46,7 @@ Puppet::Network::Handler.report.newreport(:store, :useyaml => true) do
 
         begin
             File.open(file, "w", 0640) do |f|
-                f.print yaml
+                f.print to_yaml
             end
         rescue => detail
             if Puppet[:trace]
@@ -61,4 +61,3 @@ Puppet::Network::Handler.report.newreport(:store, :useyaml => true) do
     end
 end
 
-# $Id: store.rb 2259 2007-03-06 19:03:05Z luke $

data/lib/puppet/reports/tagmail.rb

@@ -3,7 +3,7 @@ require 'pp'
 
 require 'net/smtp'
 
-Puppet::Network::Handler.report.newreport(:tagmail) do
+Puppet::Reports.register_report(:tagmail) do
     desc "This report sends specific log messages to specific email addresses
         based on the tags in the log messages.  See the
         `UsingTags tag documentation`:trac: for more information
@@ -31,7 +31,7 @@ Puppet::Network::Handler.report.newreport(:tagmail) do
         "
 
 
-    Puppet.config.use(:tagmail)
+    Puppet.settings.use(:tagmail)
 
     # Find all matching messages.
     def match(taglists)
@@ -167,4 +167,3 @@ Puppet::Network::Handler.report.newreport(:tagmail) do
     end
 end
 
-# $Id: tagmail.rb 2463 2007-05-04 23:09:34Z luke $

data/lib/puppet/resource_reference.rb

@@ -0,0 +1,79 @@
+#
+#  Created by Luke Kanies on 2007-11-28.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'puppet'
+
+# A simple class to canonize how we refer to and retrieve
+# resources.
+class Puppet::ResourceReference
+    attr_reader :type
+    attr_accessor :title, :catalog
+
+    def initialize(type, title)
+        # This will set @type if it looks like a resource reference.
+        self.title = title
+
+        # 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
+    end
+
+    # If the title has square brackets, treat it like a reference and
+    # set things appropriately; else, just set it.
+    def title=(value)
+        if value =~ /^(.+)\[(.+)\]$/
+            self.type = $1
+            @title = $2
+        else
+            @title = value
+        end
+    end
+
+    # Canonize the type so we know it's always consistent.
+    def type=(value)
+        if value.nil? or value.to_s.downcase == "component"
+            @type = "Class"
+        else
+            @type = value.to_s.split("::").collect { |s| s.capitalize }.join("::")
+        end
+    end
+
+    # Convert to the standard way of referring to resources.
+    def to_s
+        "%s[%s]" % [@type, @title]
+    end
+
+    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
+            else
+                @builtin_type = false
+            end
+        end
+        @builtin_type
+    end
+end

data/lib/puppet/simple_graph.rb

@@ -0,0 +1,251 @@
+#  Created by Luke A. Kanies on 2007-11-07.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'puppet/external/gratr/dot'
+require 'puppet/relationship'
+require 'puppet/external/gratr/search'
+
+# A hopefully-faster graph class to replace the use of GRATR.
+class Puppet::SimpleGraph
+    include GRATR::Graph::Search
+
+    # An internal class for handling a vertex's edges.
+    class VertexWrapper
+        attr_accessor :in, :out, :vertex
+
+        # Remove all references to everything.
+        def clear
+            @adjacencies[:in].clear
+            @adjacencies[:out].clear
+            @vertex = nil
+        end
+
+        def initialize(vertex)
+            @vertex = vertex
+            @adjacencies = {:in => Hash.new { |h,k| h[k] = [] }, :out => Hash.new { |h,k| h[k] = [] }}
+            #@adjacencies = {:in => [], :out => []}
+        end
+
+        # Find adjacent vertices or edges.
+        def adjacent(options)
+            direction = options[:direction] || :out
+            options[:type] ||= :vertices
+
+            return @adjacencies[direction].values.flatten if options[:type] == :edges
+
+            return @adjacencies[direction].keys
+        end
+
+        # Add an edge to our list.
+        def add_edge(direction, edge)
+            @adjacencies[direction][other_vertex(direction, edge)] << edge
+        end
+
+        # Return all known edges.
+        def edges
+            [:in, :out].collect { |dir| @adjacencies[dir].values }.flatten
+        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 false
+        end
+
+        # The other vertex in the edge.
+        def other_vertex(direction, edge)
+            case direction
+            when :in: edge.source
+            else
+                edge.target
+            end
+        end
+
+        # 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)
+        end
+    end
+
+    def initialize
+        @vertices = {}
+        @edges = []
+    end
+
+    # Clear our graph.
+    def clear
+        @vertices.each { |vertex, wrapper| wrapper.clear }
+        @vertices.clear
+        @edges.clear
+    end
+
+    # Whether our graph is directed.  Always true.  (Used by the GRATR search lib.)
+    def directed?
+        true
+    end
+
+    # Return a reversed version of this graph.
+    def reversal
+        result = self.class.new
+        vertices.each { |vertex| result.add_vertex!(vertex) }
+        edges.each do |edge|
+            newedge = edge.class.new(edge.target, edge.source, edge.label)
+            result.add_edge!(newedge)
+        end
+        result
+    end
+
+    # Return the size of the graph. Used by GRATR.
+    def size
+        @vertices.length
+    end
+
+    # Return the graph as an array.  Again, used by GRATR.
+    def to_a
+        @vertices.keys
+    end
+
+    # Add a new vertex to the graph.
+    def add_vertex!(vertex)
+        return false if vertex?(vertex)
+        setup_vertex(vertex)
+        true # don't return the VertexWrapper instance.
+    end
+
+    # Remove a vertex from the graph.
+    def remove_vertex!(vertex)
+        return nil unless vertex?(vertex)
+        @vertices[vertex].edges.each { |edge| remove_edge!(edge) }
+        @vertices[vertex].clear
+        @vertices.delete(vertex)
+    end
+
+    # Test whether a given vertex is in the graph.
+    def vertex?(vertex)
+        @vertices.include?(vertex)
+    end
+
+    # Return a list of all vertices.
+    def vertices
+        @vertices.keys
+    end
+
+    # 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)
+        if target
+            edge = Puppet::Relationship.new(source, target, label)
+        else
+            edge = source
+        end
+        [edge.source, edge.target].each { |vertex| setup_vertex(vertex) unless vertex?(vertex) }
+        @vertices[edge.source].add_edge :out, edge
+        @vertices[edge.target].add_edge :in, edge
+        @edges << edge
+        true
+    end
+
+    # Find a matching edge.  Note that this only finds the first edge,
+    # not all of them or whatever.
+    def edge(source, target)
+        @edges.each_with_index { |test_edge, index| return test_edge if test_edge.source == source and test_edge.target == target }
+    end
+
+    def edge_label(source, target)
+        return nil unless edge = edge(source, target)
+        edge.label
+    end
+
+    # Is there an edge between the two vertices?
+    def edge?(source, target)
+        return false unless vertex?(source) and vertex?(target)
+
+        @vertices[source].has_edge?(:out, target)
+    end
+
+    def edges
+        @edges.dup
+    end
+
+    # Remove an edge from our graph.
+    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) }
+        nil
+    end
+
+    # Find adjacent edges.
+    def adjacent(vertex, options = {})
+        return [] unless wrapper = @vertices[vertex]
+        return wrapper.adjacent(options)
+    end
+
+    private
+
+    # An internal method that skips the validation, so we don't have
+    # duplicate validation calls.
+    def setup_vertex(vertex)
+        @vertices[vertex] = VertexWrapper.new(vertex)
+    end
+ 
+    public
+
+    # LAK:FIXME This is just a paste of the GRATR code with slight modifications.
+
+    # Return a DOT::DOTDigraph for directed graphs or a DOT::DOTSubgraph for an
+    # undirected Graph.  _params_ can contain any graph property specified in
+    # rdot.rb. If an edge or vertex label is a kind of Hash then the keys
+    # which match +dot+ properties will be used as well.
+    def to_dot_graph (params = {})
+      params['name'] ||= self.class.name.gsub(/:/,'_')
+      fontsize   = params['fontsize'] ? params['fontsize'] : '8'
+      graph      = (directed? ? DOT::DOTDigraph : DOT::DOTSubgraph).new(params)
+      edge_klass = directed? ? DOT::DOTDirectedEdge : DOT::DOTEdge
+      vertices.each do |v|
+        name = v.to_s
+        params = {'name'     => '"'+name+'"',
+                  'fontsize' => fontsize,
+                  'label'    => name}
+        v_label = v.to_s
+        params.merge!(v_label) if v_label and v_label.kind_of? Hash
+        graph << DOT::DOTNode.new(params)
+      end
+      edges.each do |e|
+        params = {'from'     => '"'+ e.source.to_s + '"',
+                  'to'       => '"'+ e.target.to_s + '"',
+                  'fontsize' => fontsize }
+        e_label = e.to_s
+        params.merge!(e_label) if e_label and e_label.kind_of? Hash
+        graph << edge_klass.new(params)
+      end
+      graph
+    end
+    
+    # Output the dot format as a string
+    def to_dot (params={}) to_dot_graph(params).to_s; end
+
+    # Call +dotty+ for the graph which is written to the file 'graph.dot'
+    # in the # current directory.
+    def dotty (params = {}, dotfile = 'graph.dot')
+      File.open(dotfile, 'w') {|f| f << to_dot(params) }
+      system('dotty', dotfile)
+    end
+
+    # Use +dot+ to create a graphical representation of the graph.  Returns the
+    # filename of the graphics file.
+    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
+end