puppet 0.23.2 → 0.24.0

data/lib/puppet/transaction/report.rb

@@ -1,10 +1,15 @@
 require 'puppet'
+require 'puppet/indirector'
 
 # A class for reporting what happens on each client.  Reports consist of
 # two types of data:  Logs and Metrics.  Logs are the output that each
 # change produces, and Metrics are all of the numerical data involved
 # in the transaction.
 class Puppet::Transaction::Report
+    extend Puppet::Indirector
+
+    indirects :report, :terminus_class => :processor
+
     attr_accessor :logs, :metrics, :time, :host
     
     def <<(msg)
@@ -76,4 +81,3 @@ class Puppet::Transaction::Report
     end
 end
 
-# $Id: report.rb 2459 2007-05-04 05:04:29Z luke $

data/lib/puppet/transportable.rb

@@ -1,4 +1,5 @@
 require 'puppet'
+require 'puppet/resource_reference'
 require 'yaml'
 
 module Puppet
@@ -8,7 +9,7 @@ module Puppet
     # YAML.
     class TransObject
         include Enumerable
-        attr_accessor :type, :name, :file, :line, :collectable, :collected
+        attr_accessor :type, :name, :file, :line, :catalog
 
         attr_writer :tags
 
@@ -23,9 +24,8 @@ module Puppet
         end
 
         def initialize(name,type)
-            @type = type
+            @type = type.to_s.downcase
             @name = name
-            @collectable = false
             @params = {}
             @tags = []
         end
@@ -34,10 +34,28 @@ module Puppet
             return [@type,@name].join('--')
         end
 
+        def ref
+            unless defined? @ref
+                @ref = Puppet::ResourceReference.new(@type, @name)
+            end
+            @ref.to_s
+        end
+
         def tags
             return @tags
         end
 
+        # Convert a defined type into a component.
+        def to_component
+            trans = TransObject.new(ref, :component)
+            @params.each { |param,value|
+                next unless Puppet::Type::Component.validattr?(param)
+                Puppet.debug "Defining %s on %s" % [param, ref]
+                trans[param] = value
+            }
+            Puppet::Type::Component.create(trans)
+        end
+
         def to_hash
             @params.dup
         end
@@ -57,28 +75,19 @@ module Puppet
         end
 
         def to_yaml_properties
-            instance_variables
+            instance_variables.reject { |v| %w{@ref}.include?(v) }
+        end
+
+        def to_ref
+            ref
         end
 
-        def to_type(parent = nil)
+        def to_type
             retobj = nil
             if typeklass = Puppet::Type.type(self.type)
-                # FIXME This should really be done differently, but...
-                if retobj = typeklass[self.name]
-                    self.each do |param, val|
-                        retobj[param] = val
-                    end
-                else
-                    unless retobj = typeklass.create(self)
-                        return nil
-                    end
-                end
+                return typeklass.create(self)
             else
-                raise Puppet::Error.new("Could not find object type %s" % self.type)
-            end
-
-            if parent
-                parent.push retobj
+                return to_component
             end
 
             return retobj
@@ -90,7 +99,7 @@ module Puppet
     class TransBucket
         include Enumerable
 
-        attr_accessor :name, :type, :file, :line, :classes, :keyword, :top
+        attr_accessor :name, :type, :file, :line, :classes, :keyword, :top, :catalog
 
         %w{delete shift include? length empty? << []}.each { |method|
             define_method(method) do |*args|
@@ -100,20 +109,6 @@ module Puppet
             end
         }
 
-        # Remove all collectable objects from our tree, since the client
-        # should not see them.
-        def collectstrip!
-            @children.dup.each do |child|
-                if child.is_a? self.class
-                    child.collectstrip!
-                else
-                    if child.collectable and ! child.collected
-                        @children.delete(child)
-                    end
-                end
-            end
-        end
-
         # Recursively yield everything.
         def delve(&block)
             @children.each do |obj|
@@ -167,12 +162,7 @@ module Puppet
                 end
             end
 
-            str = nil
-            if self.top
-                str = "%s"
-            else
-                str = "#{@keyword} #{@type} {\n%s\n}"
-            end
+            str = "#{@keyword} #{@name} {\n%s\n}"
             str % @children.collect { |child|
                 child.to_manifest
             }.collect { |str|
@@ -188,95 +178,61 @@ module Puppet
             instance_variables
         end
 
-        def to_type(parent = nil)
-            # this container will contain the equivalent of all objects at
-            # this level
-            #container = Puppet::Component.new(:name => @name, :type => @type)
-            #unless defined? @name
-            #    raise Puppet::DevError, "TransBuckets must have names"
-            #end
-            unless defined? @type
-                Puppet.debug "TransBucket '%s' has no type" % @name
-            end
-            usetrans = true
-
-            if usetrans
-                tmpname = nil
-
-                # Nodes have the same name and type
-                if self.name
-                    tmpname = "%s[%s]" % [@type, self.name]
-                else
-                    tmpname = @type
-                end
-                trans = TransObject.new(tmpname, :component)
-                if defined? @parameters
-                    @parameters.each { |param,value|
-                        Puppet.debug "Defining %s on %s of type %s" %
-                            [param,@name,@type]
-                        trans[param] = value
-                    }
-                else
-                    #Puppet.debug "%s[%s] has no parameters" % [@type, @name]
+        # Create a resource graph from our structure.
+        def to_catalog
+            catalog = Puppet::Node::Catalog.new(Facter.value("hostname")) do |config|
+                delver = proc do |obj|
+                    obj.catalog = config
+                    unless container = config.resource(obj.to_ref)
+                        container = obj.to_type
+                        config.add_resource container
+                    end
+                    obj.each do |child|
+                        child.catalog = config
+                        unless resource = config.resource(child.to_ref)
+                            next unless resource = child.to_type
+                            config.add_resource resource
+                        end
+                        config.add_edge!(container, resource)
+                        if child.is_a?(self.class)
+                            delver.call(child)
+                        end
+                    end
                 end
-                container = Puppet::Type::Component.create(trans)
-            else
-                hash = {
-                    :name => self.name,
-                    :type => @type
-                }
-                if defined? @parameters
-                    @parameters.each { |param,value|
-                        Puppet.debug "Defining %s on %s of type %s" %
-                            [param,@name,@type]
-                        hash[param] = value
-                    }
+                
+                delver.call(self)
+            end
+            
+            return catalog
+        end
+
+        def to_ref
+            unless defined? @ref
+                if self.type and self.name
+                    @ref = Puppet::ResourceReference.new(self.type, self.name)
+                elsif self.type and ! self.name # This is old-school node types
+                    @ref = Puppet::ResourceReference.new("node", self.type)
+                elsif ! self.type and self.name
+                    @ref = Puppet::ResourceReference.new("component", self.name)
                 else
-                    #Puppet.debug "%s[%s] has no parameters" % [@type, @name]
+                    @ref = nil
                 end
-
-                #if parent
-                #    hash[:parent] = parent
-                #end
-                container = Puppet::Type::Component.create(hash)
             end
-            #Puppet.info container.inspect
+            @ref.to_s if @ref
+        end
 
-            if parent
-                parent.push container
-            end
+        def to_type
+            Puppet.debug("TransBucket '%s' has no type" % @name) unless defined? @type
 
-            # unless we successfully created the container, return an error
-            unless container
-                Puppet.warning "Got no container back"
-                return nil
+            # Nodes have the same name and type
+            trans = TransObject.new(to_ref, :component)
+            if defined? @parameters
+                @parameters.each { |param,value|
+                    Puppet.debug "Defining %s on %s" % [param, to_ref]
+                    trans[param] = value
+                }
             end
-
-            self.each { |child|
-                # the fact that we descend here means that we are
-                # always going to execute depth-first
-                # which is _probably_ a good thing, but one never knows...
-                unless  child.is_a?(Puppet::TransBucket) or
-                        child.is_a?(Puppet::TransObject)
-                    raise Puppet::DevError,
-                        "TransBucket#to_type cannot handle objects of type %s" %
-                            child.class
-                end
-
-                # Now just call to_type on them with the container as a parent
-                begin
-                    child.to_type(container)
-                rescue => detail
-                    if Puppet[:trace] and ! detail.is_a?(Puppet::Error)
-                        puts detail.backtrace
-                    end
-                    Puppet.err detail.to_s
-                end
-            }
-
-            # at this point, no objects at are level are still Transportable
-            # objects
-            return container
+            return Puppet::Type::Component.create(trans)
         end
 
         def param(param,value)
@@ -287,7 +243,5 @@ module Puppet
         end
 
     end
-    #------------------------------------------------------------
 end
 
-# $Id: transportable.rb 2068 2007-01-10 03:25:25Z lutter $

data/lib/puppet/type.rb

@@ -10,6 +10,7 @@ require 'puppet/metatype/manager'
 require 'puppet/util/errors'
 require 'puppet/util/log_paths'
 require 'puppet/util/logging'
+require 'puppet/resource_reference'
 
 # see the bottom of the file for the rest of the inclusions
 
@@ -44,7 +45,6 @@ class Type
     # that it is clear whether it operates on all attributes (thus has 'attr' in
     # the method name, or whether it operates on a specific type of attributes.
     attr_accessor :file, :line
-    attr_reader :parent
 
     attr_writer :title
     attr_writer :noop
@@ -117,6 +117,9 @@ class Type
         define_method(:validate, &block)
         #@validate = block
     end
+
+    # The catalog that this resource is stored in.
+    attr_accessor :catalog
     
     # create a log at specified level
     def log(msg)
@@ -179,8 +182,11 @@ class Type
         # If we got passed a transportable object, we just pull a bunch of info
         # directly from it.  This is the main object instantiation mechanism.
         if hash.is_a?(Puppet::TransObject)
+            # XXX This will need to change when transobjects change to titles.
+            self.title = hash.name
+
             #self[:name] = hash[:name]
-            [:file, :line, :tags].each { |getter|
+            [:file, :line, :tags, :catalog].each { |getter|
                 if hash.respond_to?(getter)
                     setter = getter.to_s + "="
                     if val = hash.send(getter)
@@ -189,13 +195,12 @@ class Type
                 end
             }
 
-            # XXX This will need to change when transobjects change to titles.
-            @title = hash.name
             hash = hash.to_hash
-        elsif hash[:title]
-            # XXX This should never happen
-            @title = hash[:title]
-            hash.delete(:title)
+        else
+            if hash[:title]
+                @title = hash[:title]
+                hash.delete(:title)
+            end
         end
 
         # Before anything else, set our parent if it was included
@@ -219,7 +224,7 @@ class Type
             if attrs.include?(namevar)
                 attrs.delete(namevar)
             else
-                self.devfail "My namevar isn\'t a valid attribute...?"
+                self.devfail "My namevar isn't a valid attribute...?"
             end
         else
             self.devfail "I was not passed a namevar"
@@ -282,6 +287,14 @@ class Type
         # Scheduling has to be done when the whole config is instantiated, so
         # that file order doesn't matter in finding them.
         self.schedule
+
+        # Make sure all of our relationships are valid.  Again, must be done
+        # when the entire catalog is instantiated.
+        self.class.relationship_params.collect do |klass|
+            if param = @parameters[klass.name]
+                param.validate_relationship
+            end
+        end.flatten.reject { |r| r.nil? }
     end
 
     # Return a cached value
@@ -310,6 +323,28 @@ class Type
         return self[:name]
     end
 
+    # Look up our parent in the catalog, if we have one.
+    def parent
+        return nil unless catalog
+
+        unless defined?(@parent)
+            # This is kinda weird.
+            if implicit?
+                parents = catalog.relationship_graph.adjacent(self, :direction => :in)
+            else
+                parents = catalog.adjacent(self, :direction => :in)
+            end
+            if parents
+                # We should never have more than one parent, so let's just ignore
+                # it if we happen to.
+                @parent = parents.shift
+            else
+                @parent = nil
+            end
+        end
+        @parent
+    end
+
     # Return the "type[name]" style reference.
     def ref
         "%s[%s]" % [self.class.name.to_s.capitalize, self.title]
@@ -394,4 +429,3 @@ require 'puppet/type/tidy'
 
 
 
-# $Id: type.rb 2684 2007-07-12 16:39:47Z luke $

data/lib/puppet/type/component.rb

@@ -48,16 +48,6 @@ Puppet::Type.newtype(:component) do
         @children.each { |child| yield child }
     end
 
-    # flatten all children, sort them, and evaluate them in order
-    # this is only called on one component over the whole system
-    # this also won't work with scheduling, but eh
-    def evaluate
-        self.finalize unless self.finalized?
-        transaction = Puppet::Transaction.new(self)
-        transaction.component = self
-        return transaction
-    end
-
     # Do all of the polishing off, mostly doing autorequires and making
     # dependencies.  This will get run once on the top-level component,
     # and it will do everything necessary.
@@ -92,14 +82,14 @@ Puppet::Type.newtype(:component) do
     end
 
     # Initialize a new component
-    def initialize(args)
+    def initialize(*args)
         @children = []
-        super(args)
+        super
+
+        @reference = Puppet::ResourceReference.new(:component, @title)
 
-        # If the title isn't a full resource reference, assume
-        # we're a class and make an alias for that.
-        unless @title.to_s.include?("[")
-            self.class.alias("class[%s]" % @title, self)
+        unless self.class[@reference.to_s]
+            self.class.alias(@reference.to_s, self)
         end
     end
 
@@ -108,14 +98,6 @@ Puppet::Type.newtype(:component) do
         @children = []
     end
 
-    def parent=(parent)
-        if self.parentof?(parent)
-            devfail "%s[%s] is already the parent of %s[%s]" %
-                [self.class.name, self.title, parent.class.name, parent.title]
-        end
-        @parent = parent
-    end
-
     # Add a hook for testing for recursion.
     def parentof?(child)
         if super(child)
@@ -127,113 +109,46 @@ Puppet::Type.newtype(:component) do
             return false
         end
     end
-
-    def push(*childs)
-        unless defined? @children
-            @children = []
-        end
-        childs.each { |child|
-            # Make sure we don't have any loops here.
-            if parentof?(child)
-                devfail "Already the parent of %s[%s]" % [child.class.name, child.title]
-            end
-            unless child.is_a?(Puppet::Type)
-                self.debug "Got object of type %s" % child.class
-                self.devfail(
-                    "Containers can only contain Puppet resources, not %s" %
-                    child.class
-                )
-            end
-            @children.push(child)
-            child.parent = self
-        }
-    end
     
     # Component paths are special because they function as containers.
     def pathbuilder
-        tmp = []
-        if defined? @parent and @parent
-            tmp += [@parent.pathbuilder, self.title]
-        else
-            # The top-level name is always main[top], so we don't bother with
-            # that.
-            if self.title == "main[top]"
-                tmp << "" # This empty field results in "//" in the path
+        if @reference.type == "Class"
+            # 'main' is the top class, so we want to see '//' instead of
+            # its name.
+            if @reference.title == "main"
+                myname = ""
             else
-                tmp << self.title
+                myname = @reference.title
             end
+        else
+            myname = @reference.to_s
+        end
+        if p = self.parent
+            return [p.pathbuilder, myname]
+        else
+            return [myname]
         end
-        
-        tmp
     end
 
-    # Remove an object.  The argument determines whether the object's
-    # subscriptions get eliminated, too.
-    def remove(rmdeps = true)
-        # Our children remove themselves from our @children array (else the object
-        # we called this on at the top would not be removed), so we duplicate the
-        # array and iterate over that.  If we don't do this, only half of the
-        # objects get removed.
-        @children.dup.each { |child|
-            child.remove(rmdeps)
-        }
-
-        @children.clear
-
-        # Get rid of params and provider, too.
-        super
-
-        @parent = nil
+    def ref
+        @reference.to_s
     end
 
-    # We have a different way of setting the title
+    # We want our title to just be the whole reference, rather than @title.
     def title
-        unless defined? @title
-            if self[:type] == self[:name] # this is the case for classes
-                @title = self[:type]
-            elsif self[:name] =~ /\[.+\]/ # most components already have ref info in the name
-                @title = self[:name]
-            else # else, set it up
-                @title = "%s[%s]" % [self[:type].capitalize, self[:name]]
-            end
-        end
-        return @title
+        @reference.to_s
     end
 
     def refresh
-        @children.collect { |child|
+        catalog.adjacent(self).each do |child|
             if child.respond_to?(:refresh)
                 child.refresh
                 child.log "triggering %s" % :refresh
             end
-        }
-    end
-    
-    # Convert to a graph object with all of the container info.
-    def to_graph
-        graph = Puppet::PGraph.new
-        
-        delver = proc do |obj|
-            obj.each do |child|
-                graph.add_edge!(obj, child)
-                if child.is_a?(self.class)
-                    delver.call(child)
-                end
-            end
         end
-        
-        delver.call(self)
-        
-        return graph
     end
 
     def to_s
-        if self.title =~ /\[/
-            return self.title
-        else
-            return "component(%s)" % self.title
-        end
+        @reference.to_s
     end
 end
-
-# $Id: component.rb 2715 2007-07-19 19:23:56Z luke $