puppet 0.24.9 → 0.25.0

data/lib/puppet/{node → resource}/catalog.rb

@@ -1,18 +1,26 @@
+require 'puppet/node'
 require 'puppet/indirector'
-require 'puppet/pgraph'
+require 'puppet/simple_graph'
 require 'puppet/transaction'
 
+require 'puppet/util/cacher'
+require 'puppet/util/json'
+
 require 'puppet/util/tagging'
 
 # This class models a node catalog.  It is the thing
 # meant to be passed from server to client, and it contains all
 # of the information in the catalog, including the resources
 # and the relationships between them.
-class Puppet::Node::Catalog < Puppet::PGraph
+class Puppet::Resource::Catalog < Puppet::SimpleGraph
+    class DuplicateResourceError < Puppet::Error; end
+
     extend Puppet::Indirector
     indirects :catalog, :terminus_class => :compiler
 
     include Puppet::Util::Tagging
+    extend Puppet::Util::Json
+    include Puppet::Util::Cacher::Expirer
 
     # The host name this is a catalog for.
     attr_accessor :name
@@ -27,10 +35,6 @@ class Puppet::Node::Catalog < Puppet::PGraph
     # How we should extract the catalog for sending to the client.
     attr_reader :extraction_format
 
-    # We need the ability to set this externally, so we can yaml-dump the
-    # catalog.
-    attr_accessor :edgelist_class
-
     # Whether this is a host catalog, which behaves very differently.
     # In particular, reports are sent, graphs are made, and state is
     # stored in the state database.  If this is set incorrectly, then you often
@@ -38,11 +42,6 @@ class Puppet::Node::Catalog < Puppet::PGraph
     # that the host catalog needs.
     attr_accessor :host_config
 
-    # Whether this graph is another catalog's relationship graph.
-    # We don't want to accidentally create a relationship graph for another
-    # relationship graph.
-    attr_accessor :is_relationship_graph
-
     # Whether this catalog was retrieved from the cache, which affects
     # whether it is written back out again.
     attr_accessor :from_cache
@@ -58,16 +57,21 @@ class Puppet::Node::Catalog < Puppet::PGraph
     end
 
     # Add one or more resources to our graph and to our resource table.
+    # This is actually a relatively complicated method, because it handles multiple
+    # aspects of Catalog behaviour:
+    # * Add the resource to the resource table
+    # * Add the resource to the resource graph
+    # * Add the resource to the relationship graph
+    # * Add any aliases that make sense for the resource (e.g., name != title)
     def add_resource(*resources)
         resources.each do |resource|
             unless resource.respond_to?(:ref)
-                raise ArgumentError, "Can only add objects that respond to :ref"
+                raise ArgumentError, "Can only add objects that respond to :ref, not instances of %s" % resource.class
             end
-
-            fail_unless_unique(resource)
-
+        end.each { |resource| fail_unless_unique(resource) }.each do |resource|
             ref = resource.ref
 
+            @transient_resources << resource if applying?
             @resource_table[ref] = resource
 
             # If the name and title differ, set up an alias
@@ -76,15 +80,21 @@ class Puppet::Node::Catalog < Puppet::PGraph
                 self.alias(resource, resource.name) if resource.isomorphic?
             end
 
-            resource.catalog = self if resource.respond_to?(:catalog=) and ! is_relationship_graph
+            resource.catalog = self if resource.respond_to?(:catalog=)
 
             add_vertex(resource)
+
+            if @relationship_graph
+                @relationship_graph.add_vertex(resource)
+            end
+
+            yield(resource) if block_given?
         end
     end
 
     # Create an alias for a resource.
     def alias(resource, name)
-        #set $1 
+        #set $1
         resource.ref =~ /^(.+)\[/
 
         newref = "%s[%s]" % [$1 || resource.class.name, name]
@@ -99,6 +109,7 @@ class Puppet::Node::Catalog < Puppet::PGraph
             raise(ArgumentError, "Cannot alias %s to %s; resource %s already exists" % [resource.ref, name, newref])
         end
         @resource_table[newref] = resource
+        @aliases[resource.ref] ||= []
         @aliases[resource.ref] << newref
     end
 
@@ -111,18 +122,23 @@ class Puppet::Node::Catalog < Puppet::PGraph
     def apply(options = {})
         @applying = true
 
+        # Expire all of the resource data -- this ensures that all
+        # data we're operating against is entirely current.
+        expire()
+
         Puppet::Util::Storage.load if host_config?
         transaction = Puppet::Transaction.new(self)
 
         transaction.tags = options[:tags] if options[:tags]
         transaction.ignoreschedules = true if options[:ignoreschedules]
 
-        transaction.addtimes :config_retrieval => @retrieval_duration
+        transaction.addtimes :config_retrieval => self.retrieval_duration
 
 
         begin
             transaction.evaluate
         rescue Puppet::Error => detail
+            puts detail.backtrace if Puppet[:trace]
             Puppet.err "Could not apply complete catalog: %s" % detail
         rescue => detail
             puts detail.backtrace if Puppet[:trace]
@@ -134,7 +150,7 @@ class Puppet::Node::Catalog < Puppet::PGraph
         end
 
         yield transaction if block_given?
-        
+
         transaction.send_report if host_config and (Puppet[:report] or Puppet[:summarize])
 
         return transaction
@@ -148,7 +164,7 @@ class Puppet::Node::Catalog < Puppet::PGraph
     def applying?
         @applying
     end
-    
+
     def clear(remove_resources = true)
         super()
         # We have to do this so that the resources clean themselves up.
@@ -156,7 +172,7 @@ class Puppet::Node::Catalog < Puppet::PGraph
         @resource_table.clear
 
         if defined?(@relationship_graph) and @relationship_graph
-            @relationship_graph.clear(false)
+            @relationship_graph.clear
             @relationship_graph = nil
         end
     end
@@ -165,48 +181,25 @@ class Puppet::Node::Catalog < Puppet::PGraph
         @classes.dup
     end
 
-    # Create an implicit resource, meaning that it will lose out
-    # to any explicitly defined resources.  This method often returns
-    # nil.
-    #  The quirk of this method is that it's not possible to create
-    # an implicit resource before an explicit resource of the same name,
-    # because all explicit resources are created before any generate()
-    # methods are called on the individual resources.  Thus, this
-    # method can safely just check if an explicit resource already exists
-    # and toss this implicit resource if so.
-    def create_implicit_resource(type, options)
-        unless options.include?(:implicit)
-            options[:implicit] = true
-        end
-
-        # This will return nil if an equivalent explicit resource already exists.
-        # When resource classes no longer retain references to resource instances,
-        # this will need to be modified to catch that conflict and discard
-        # implicit resources.
-        if resource = create_resource(type, options)
-            resource.implicit = true
-
-            return resource
-        else
-            return nil
-        end
-    end
-
     # Create a new resource and register it in the catalog.
     def create_resource(type, options)
         unless klass = Puppet::Type.type(type)
             raise ArgumentError, "Unknown resource type %s" % type
         end
-        return unless resource = klass.create(options)
+        return unless resource = klass.new(options)
 
-        @transient_resources << resource if applying?
         add_resource(resource)
-        if @relationship_graph
-            @relationship_graph.add_resource(resource) unless @relationship_graph.resource(resource.ref)
-        end
         resource
     end
 
+    def dependent_data_expired?(ts)
+        if applying?
+            return super
+        else
+            return true
+        end
+    end
+
     # Make sure we support the requested extraction format.
     def extraction_format=(value)
         unless respond_to?("extract_to_%s" % value)
@@ -221,7 +214,8 @@ class Puppet::Node::Catalog < Puppet::PGraph
     end
 
     # Create the traditional TransBuckets and TransObjects from our catalog
-    # graph.  This will hopefully be deprecated soon.
+    # graph.  LAK:NOTE(20081211): This is a  pre-0.25 backward compatibility method.
+    # It can be removed as soon as xmlrpc is killed.
     def extract_to_transportable
         top = nil
         current = nil
@@ -279,7 +273,7 @@ class Puppet::Node::Catalog < Puppet::PGraph
         make_default_resources
 
         @resource_table.values.each { |resource| resource.finish }
-        
+
         write_graph(:resources)
     end
 
@@ -297,7 +291,7 @@ class Puppet::Node::Catalog < Puppet::PGraph
         @applying = false
         @relationship_graph = nil
 
-        @aliases = Hash.new { |hash, key| hash[key] = [] }
+        @aliases = {}
 
         if block_given?
             yield(self)
@@ -312,27 +306,23 @@ class Puppet::Node::Catalog < Puppet::PGraph
 
         # First create the default scheduling objects
         Puppet::Type.type(:schedule).mkdefaultschedules.each { |res| add_resource(res) unless resource(res.ref) }
-        
+
         # And filebuckets
         if bucket = Puppet::Type.type(:filebucket).mkdefaultbucket
-            add_resource(bucket)
+            add_resource(bucket) unless resource(bucket.ref)
         end
     end
-    
+
     # Create a graph of all of the relationships in our catalog.
     def relationship_graph
-        raise(Puppet::DevError, "Tried get a relationship graph for a relationship graph") if self.is_relationship_graph
-
         unless defined? @relationship_graph and @relationship_graph
             # It's important that we assign the graph immediately, because
             # the debug messages below use the relationships in the
             # relationship graph to determine the path to the resources
             # spitting out the messages.  If this is not set,
             # then we get into an infinite loop.
-            @relationship_graph = Puppet::Node::Catalog.new
-            @relationship_graph.host_config = host_config?
-            @relationship_graph.is_relationship_graph = true
-            
+            @relationship_graph = Puppet::SimpleGraph.new
+
             # First create the dependency graph
             self.vertices.each do |vertex|
                 @relationship_graph.add_vertex vertex
@@ -340,10 +330,10 @@ class Puppet::Node::Catalog < Puppet::PGraph
                     @relationship_graph.add_edge(edge)
                 end
             end
-            
+
             # Lastly, add in any autorequires
             @relationship_graph.vertices.each do |vertex|
-                vertex.autorequire.each do |edge|
+                vertex.autorequire(self).each do |edge|
                     unless @relationship_graph.edge?(edge.source, edge.target) # don't let automatic relationships conflict with manual ones.
                         unless @relationship_graph.edge?(edge.target, edge.source)
                             vertex.debug "Autorequiring %s" % [edge.source]
@@ -354,13 +344,12 @@ class Puppet::Node::Catalog < Puppet::PGraph
                     end
                 end
             end
-            
-            @relationship_graph.write_graph(:relationships)
-            
+            @relationship_graph.write_graph(:relationships) if host_config?
+
             # Then splice in the container information
             @relationship_graph.splice!(self, Puppet::Type::Component)
 
-            @relationship_graph.write_graph(:expanded_relationships)
+            @relationship_graph.write_graph(:expanded_relationships) if host_config?
         end
         @relationship_graph
     end
@@ -371,8 +360,10 @@ class Puppet::Node::Catalog < Puppet::PGraph
     def remove_resource(*resources)
         resources.each do |resource|
             @resource_table.delete(resource.ref)
-            @aliases[resource.ref].each { |res_alias| @resource_table.delete(res_alias) }
-            @aliases[resource.ref].clear
+            if aliases = @aliases[resource.ref]
+                aliases.each { |res_alias| @resource_table.delete(res_alias) }
+                @aliases.delete(resource.ref)
+            end
             remove_vertex!(resource) if vertex?(resource)
             @relationship_graph.remove_vertex!(resource) if @relationship_graph and @relationship_graph.vertex?(resource)
             resource.remove
@@ -384,18 +375,14 @@ class Puppet::Node::Catalog < Puppet::PGraph
         # Always create a resource reference, so that it always canonizes how we
         # are referring to them.
         if title
-            ref = Puppet::ResourceReference.new(type, title).to_s
+            ref = Puppet::Resource::Reference.new(type, title).to_s
         else
             # If they didn't provide a title, then we expect the first
             # argument to be of the form 'Class[name]', which our
             # Reference class canonizes for us.
-            ref = Puppet::ResourceReference.new(nil, type).to_s
-        end
-        if resource = @resource_table[ref]
-            return resource
-        elsif defined?(@relationship_graph) and @relationship_graph
-            @relationship_graph.resource(ref)
+            ref = Puppet::Resource::Reference.new(nil, type).to_s
         end
+        @resource_table[ref]
     end
 
     # Return an array of all resources.
@@ -403,41 +390,108 @@ class Puppet::Node::Catalog < Puppet::PGraph
         @resource_table.keys
     end
 
+    def self.from_json(data)
+        result = new(data['name'])
+
+        if tags = data['tags'] 
+            result.tag(*tags)
+        end
+
+        if version = data['version'] 
+            result.version = version
+        end
+
+        if resources = data['resources']
+            resources = JSON.parse(resources) if resources.is_a?(String)
+            resources.each do |res|
+                resource_from_json(result, res)
+            end
+        end
+
+        if edges = data['edges']
+            edges = JSON.parse(edges) if edges.is_a?(String)
+            edges.each do |edge|
+                edge_from_json(result, edge)
+            end
+        end
+
+        result
+    end
+
+    def self.edge_from_json(result, edge)
+        # If no json_class information was presented, we manually find
+        # the class.
+        edge = Puppet::Relationship.from_json(edge) if edge.is_a?(Hash)
+        unless source = result.resource(edge.source)
+            raise ArgumentError, "Could not convert from json: Could not find relationship source '%s'" % source
+        end
+        edge.source = source
+
+        unless target = result.resource(edge.target)
+            raise ArgumentError, "Could not convert from json: Could not find relationship target '%s'" % target
+        end
+        edge.target = target
+
+        result.add_edge(edge)
+    end
+
+    def self.resource_from_json(result, res)
+        # If no json_class information was presented, we manually find
+        # the class.
+        if res.is_a?(Hash)
+            res = res['data'] if res['json_class']
+            res = Puppet::Resource.from_json(res)
+        end
+        result.add_resource(res)
+    end
+
+    def to_json(*args)
+        {
+            'json_class' => 'Puppet::Resource::Catalog',
+            'data' => {
+                'tags' => tags,
+                'name' => name,
+                'version' => version,
+                'resources' => vertices.to_json(*args),
+                'edges' => edges.to_json(*args)
+            }
+        }.to_json(*args)
+    end
+
     # Convert our catalog into a RAL catalog.
     def to_ral
-        to_catalog :to_type
+        to_catalog :to_ral
     end
 
-    # Turn our parser catalog into a transportable catalog.
-    def to_transportable
-        to_catalog :to_transobject
+    # Convert our catalog into a catalog of Puppet::Resource instances.
+    def to_resource
+        to_catalog :to_resource
+    end
+
+    # filter out the catalog, applying +block+ to each resource. 
+    # If the block result is false, the resource will
+    # be kept otherwise it will be skipped
+    def filter(&block)
+        to_catalog :to_resource, &block
+    end
+
+    # Store the classes in the classfile.
+    def write_class_file
+        begin
+            ::File.open(Puppet[:classfile], "w") do |f|
+                f.puts classes.join("\n")
+            end
+        rescue => detail
+            Puppet.err "Could not create class file %s: %s" % [Puppet[:classfile], detail]
+        end
     end
 
     # Produce the graph files if requested.
     def write_graph(name)
         # We only want to graph the main host catalog.
         return unless host_config?
-        
-        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
 
-    # LAK:NOTE We cannot yaml-dump the class in the edgelist_class, because classes cannot be
-    # dumped by default, nor does yaml-dumping # the edge-labels work at this point (I don't
-    # know why).
-    #  Neither of these matters right now, but I suppose it could at some point.
-    # We also have to have the vertex_dict dumped after the resource table, because yaml can't
-    # seem to handle the output of yaml-dumping the vertex_dict.
-    def to_yaml_properties
-        props = instance_variables.reject { |v| %w{@edgelist_class @edge_labels @vertex_dict}.include?(v) }
-        props << "@vertex_dict"
-        props
+        super
     end
 
     private
@@ -448,13 +502,18 @@ class Puppet::Node::Catalog < Puppet::PGraph
             @transient_resources.clear
             @relationship_graph = nil
         end
+
+        # Expire any cached data the resources are keeping.
+        expire()
     end
 
     # Verify that the given resource isn't defined elsewhere.
     def fail_unless_unique(resource)
-        # Short-curcuit the common case, 
+        # Short-curcuit the common case,
         return unless existing_resource = @resource_table[resource.ref]
 
+        # If we've gotten this far, it's a real conflict
+
         # Either it's a defined type, which are never
         # isomorphic, or it's a non-isomorphic type, so
         # we should throw an exception.
@@ -469,7 +528,7 @@ class Puppet::Node::Catalog < Puppet::PGraph
             msg << "; cannot redefine"
         end
 
-        raise ArgumentError.new(msg)
+        raise DuplicateResourceError.new(msg)
     end
 
     # An abstracted method for converting one catalog into another type of catalog.
@@ -478,23 +537,33 @@ class Puppet::Node::Catalog < Puppet::PGraph
     def to_catalog(convert)
         result = self.class.new(self.name)
 
+        result.version = self.version
+
         map = {}
         vertices.each do |resource|
-            next if resource.respond_to?(:virtual?) and resource.virtual?
+            next if virtual_not_exported?(resource)
+            next if block_given? and yield resource
 
             #This is hackity hack for 1094
             #Aliases aren't working in the ral catalog because the current instance of the resource
             #has a reference to the catalog being converted. . . So, give it a reference to the new one
             #problem solved. . .
-            if resource.is_a?(Puppet::TransObject)
+            if resource.is_a?(Puppet::Resource)
+                resource = resource.dup
+                resource.catalog = result
+            elsif resource.is_a?(Puppet::TransObject)
                 resource = resource.dup
                 resource.catalog = result
             elsif resource.is_a?(Puppet::Parser::Resource)
-                resource = resource.to_transobject
+                resource = resource.to_resource
                 resource.catalog = result
             end
 
-            newres = resource.send(convert)
+            if resource.is_a?(Puppet::Resource) and convert.to_s == "to_resource"
+                newres = resource
+            else
+                newres = resource.send(convert)
+            end
 
             # We can't guarantee that resources don't munge their names
             # (like files do with trailing slashes), so we have to keep track
@@ -507,8 +576,11 @@ class Puppet::Node::Catalog < Puppet::PGraph
         message = convert.to_s.gsub "_", " "
         edges.each do |edge|
             # Skip edges between virtual resources.
-            next if edge.source.respond_to?(:virtual?) and edge.source.virtual?
-            next if edge.target.respond_to?(:virtual?) and edge.target.virtual?
+            next if virtual_not_exported?(edge.source)
+            next if block_given? and yield edge.source
+
+            next if virtual_not_exported?(edge.target)
+            next if block_given? and yield edge.target
 
             unless source = map[edge.source.ref]
                 raise Puppet::DevError, "Could not find resource %s when converting %s resources" % [edge.source.ref, message]
@@ -528,4 +600,8 @@ class Puppet::Node::Catalog < Puppet::PGraph
 
         return result
     end
+
+    def virtual_not_exported?(resource)
+        resource.respond_to?(:virtual?) and resource.virtual? and (resource.respond_to?(:exported?) and not resource.exported?)
+    end
 end