puppet 0.18.4 → 0.22.4

data/lib/puppet/metatype/closure.rb

@@ -0,0 +1,111 @@
+class Puppet::Type
+    attr_writer :implicit
+
+    def self.implicitcreate(hash)
+        unless hash.include?(:implicit)
+            hash[:implicit] = true
+        end
+        if obj = self.create(hash)
+            obj.implicit = true
+
+            return obj
+        else
+            return nil
+        end
+    end
+
+    # Is this type's name isomorphic with the object?  That is, if the
+    # name conflicts, does it necessarily mean that the objects conflict?
+    # Defaults to true.
+    def self.isomorphic?
+        if defined? @isomorphic
+            return @isomorphic
+        else
+            return true
+        end
+    end
+
+    def implicit?
+        if defined? @implicit and @implicit
+            return true
+        else
+            return false
+        end
+    end
+
+    # is the instance a managed instance?  A 'yes' here means that
+    # the instance was created from the language, vs. being created
+    # in order resolve other questions, such as finding a package
+    # in a list
+    def managed?
+        # Once an object is managed, it always stays managed; but an object
+        # that is listed as unmanaged might become managed later in the process,
+        # so we have to check that every time
+        if defined? @managed and @managed
+            return @managed
+        else
+            @managed = false
+            properties.each { |property|
+                s = property.should
+                if s and ! property.class.unmanaged
+                    @managed = true
+                    break
+                end
+            }
+            return @managed
+        end
+    end
+
+    # Merge new information with an existing object, checking for conflicts
+    # and such.  This allows for two specifications of the same object and
+    # the same values, but it's pretty limited right now.  The result of merging
+    # properties is very different from the result of merging parameters or
+    # metaparams.  This is currently unused.
+    def merge(hash)
+        hash.each { |param, value|
+            if param.is_a?(String)
+                param = param.intern
+            end
+            
+            # Of course names are the same, duh.
+            next if param == :name or param == self.class.namevar
+
+            unless value.is_a?(Array)
+                value = [value]
+            end
+
+            if @parameters.include?(param) and oldvals = @parameters[param].shouldorig
+                unless oldvals.is_a?(Array)
+                    oldvals = [oldvals]
+                end
+                # If the values are exactly the same, order and everything,
+                # then it's okay.
+                if oldvals == value
+                    return true
+                end
+                # take the intersection
+                newvals = oldvals & value
+                if newvals.empty?
+                    self.fail "No common values for %s on %s(%s)" %
+                        [param, self.class.name, self.title]
+                elsif newvals.length > 1
+                    self.fail "Too many values for %s on %s(%s)" %
+                        [param, self.class.name, self.title]
+                else
+                    self.debug "Reduced old values %s and new values %s to %s" %
+                        [oldvals.inspect, value.inspect, newvals.inspect]
+                    @parameters[param].should = newvals
+                    #self.should = newvals
+                    return true
+                end
+            else
+                self[param] = value
+            end
+        }
+
+        # Set the defaults again, just in case.
+        self.setdefaults
+    end
+end
+
+# $Id: closure.rb 2169 2007-02-07 06:47:10Z luke $

data/lib/puppet/metatype/container.rb

@@ -0,0 +1,94 @@
+class Puppet::Type
+    attr_accessor :children
+
+    # this is a retarded hack method to get around the difference between
+    # component children and file children
+    def self.depthfirst?
+        if defined? @depthfirst
+            return @depthfirst
+        else
+            return false
+        end
+    end
+    
+    def depthfirst?
+        self.class.depthfirst?
+    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 (self == child)
+            debug "parent is equal to child"
+            return true
+        elsif defined? @parent and @parent.parentof?(child)
+            debug "My parent is parent of child"
+            return true
+        elsif @children.include?(child)
+            debug "child is already in children array"
+            return true
+        else
+            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::Element)
+                self.debug "Got object of type %s" % child.class
+                self.devfail(
+                    "Containers can only contain Puppet::Elements, not %s" %
+                    child.class
+                )
+            end
+            @children.push(child)
+            child.parent = self
+        }
+    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
+
+        # This is hackish (mmm, cut and paste), but it works for now, and it's
+        # better than warnings.
+        @parameters.each do |name, obj|
+            obj.remove
+        end
+        @parameters.clear
+        self.class.delete(self)
+
+        @parent = nil
+
+        # Remove the reference to the provider.
+        if self.provider
+            @provider.clear
+            @provider = nil
+        end
+    end
+end
+
+# $Id: container.rb 2169 2007-02-07 06:47:10Z luke $

data/lib/puppet/metatype/evaluation.rb

@@ -0,0 +1,118 @@
+class Puppet::Type
+    # This method is responsible for collecting property changes we always
+    # descend into the children before we evaluate our current properties.
+    # This returns any changes resulting from testing, thus 'collect' rather
+    # than 'each'.
+    def evaluate
+        #Puppet.err "Evaluating %s" % self.path.join(":")
+        unless defined? @evalcount
+            self.err "No evalcount defined on '%s' of type '%s'" %
+                [self.title,self.class]
+            @evalcount = 0
+        end
+        @evalcount += 1
+
+        if p = self.provider and p.respond_to?(:prefetch)
+            p.prefetch
+        end
+
+        # this only operates on properties, not properties + children
+        # it's important that we call retrieve() on the type instance,
+        # not directly on the property, because it allows the type to override
+        # the method, like pfile does
+        self.retrieve
+
+        changes = propertychanges().flatten
+
+        # now record how many changes we've resulted in
+        if changes.length > 0
+            self.debug "%s change(s)" %
+                [changes.length]
+        end
+        self.cache(:checked, Time.now)
+        return changes.flatten
+    end
+
+    # Flush the provider, if it supports it.  This is called by the
+    # transaction.
+    def flush
+        if self.provider and self.provider.respond_to?(:flush)
+            self.provider.flush
+        end
+    end
+
+    # if all contained objects are in sync, then we're in sync
+    # FIXME I don't think this is used on the type instances any more,
+    # it's really only used for testing
+    def insync?
+        insync = true
+
+        if property = @parameters[:ensure]
+            if property.insync? and property.should == :absent
+                return true
+            end
+        end
+
+        properties.each { |property|
+            unless property.insync?
+                property.debug("Not in sync: %s vs %s" %
+                    [property.is.inspect, property.should.inspect])
+                insync = false
+            #else
+            #    property.debug("In sync")
+            end
+        }
+
+        #self.debug("%s sync status is %s" % [self,insync])
+        return insync
+    end
+
+    # retrieve the current value of all contained properties
+    def retrieve
+        # it's important to use the method here, as it follows the order
+        # in which they're defined in the object
+        properties().each { |property|
+            property.retrieve
+        }
+    end
+
+    # Retrieve the changes associated with all of the properties.
+    def propertychanges
+        # If we are changing the existence of the object, then none of
+        # the other properties matter.
+        changes = []
+        if @parameters.include?(:ensure) and ! @parameters[:ensure].insync?
+#            self.info "ensuring %s from %s" %
+#                [@parameters[:ensure].should, @parameters[:ensure].is]
+            changes = [Puppet::PropertyChange.new(@parameters[:ensure])]
+        # Else, if the 'ensure' property is correctly absent, then do
+        # nothing
+        elsif @parameters.include?(:ensure) and @parameters[:ensure].is == :absent
+            #            self.info "Object is correctly absent"
+            return []
+        else
+#            if @parameters.include?(:ensure)
+#                self.info "ensure: Is: %s, Should: %s" %
+#                    [@parameters[:ensure].is, @parameters[:ensure].should]
+#            else
+#                self.info "no ensure property"
+#            end
+            changes = properties().find_all { |property|
+                ! property.insync?
+            }.collect { |property|
+                Puppet::PropertyChange.new(property)
+            }
+        end
+
+        if Puppet[:debug] and changes.length > 0
+            self.debug("Changing " + changes.collect { |ch|
+                    ch.property.name
+                }.join(",")
+            )
+        end
+
+        changes
+    end
+end
+
+# $Id: evaluation.rb 2275 2007-03-08 21:18:43Z luke $

data/lib/puppet/metatype/instances.rb

@@ -0,0 +1,261 @@
+class Puppet::Type
+    # Make 'new' private, so people have to use create instead.
+    class << self
+        private :new
+    end
+
+    # retrieve a named instance of the current type
+    def self.[](name)
+        @objects[name] || @aliases[name]
+    end
+
+    # add an instance by name to the class list of instances
+    def self.[]=(name,object)
+        newobj = nil
+        if object.is_a?(Puppet::Type)
+            newobj = object
+        else
+            raise Puppet::DevError, "must pass a Puppet::Type object"
+        end
+
+        if exobj = @objects[name] and self.isomorphic?
+            msg = "Object '%s[%s]' already exists" %
+                [newobj.class.name, name]
+
+            if exobj.file and exobj.line
+                msg += ("in file %s at line %s" %
+                    [object.file, object.line])
+            end
+            if object.file and object.line
+                msg += ("and cannot be redefined in file %s at line %s" %
+                    [object.file, object.line])
+            end
+            error = Puppet::Error.new(msg)
+            raise error
+        else
+            #Puppet.info("adding %s of type %s to class list" %
+            #    [name,object.class])
+            @objects[name] = newobj
+        end
+    end
+
+    # Create an alias.  We keep these in a separate hash so that we don't encounter
+    # the objects multiple times when iterating over them.
+    def self.alias(name, obj)
+        if @objects.include?(name)
+            unless @objects[name] == obj
+                raise Puppet::Error.new(
+                    "Cannot create alias %s: object already exists" %
+                    [name]
+                )
+            end
+        end
+
+        if @aliases.include?(name)
+            unless @aliases[name] == obj
+                raise Puppet::Error.new(
+                    "Object %s already has alias %s" %
+                    [@aliases[name].name, name]
+                )
+            end
+        end
+
+        @aliases[name] = obj
+    end
+
+    # remove all of the instances of a single type
+    def self.clear
+        if defined? @objects
+            @objects.each do |name, obj|
+                obj.remove(true)
+            end
+            @objects.clear
+        end
+        if defined? @aliases
+            @aliases.clear
+        end
+    end
+
+    # Force users to call this, so that we can merge objects if
+    # necessary.  FIXME This method should be responsible for most of the
+    # error handling.
+    def self.create(args)
+        # Don't modify the original hash; instead, create a duplicate and modify it.
+        # We have to dup and use the ! so that it stays a TransObject if it is
+        # one.
+        hash = args.dup
+        symbolizehash!(hash)
+
+        # If we're the base class, then pass the info on appropriately
+        if self == Puppet::Type
+            type = nil
+            if hash.is_a? TransObject
+                type = hash.type
+            else
+                # If we're using the type to determine object type, then delete it
+                if type = hash[:type]
+                    hash.delete(:type)
+                end
+            end
+
+            if type
+                if typeklass = self.type(type)
+                    return typeklass.create(hash)
+                else
+                    raise Puppet::Error, "Unknown type %s" % type
+                end
+            else
+                raise Puppet::Error, "No type found for %s" % hash.inspect
+            end
+        end
+
+        # Handle this new object being implicit
+        implicit = hash[:implicit] || false
+        if hash.include?(:implicit)
+            hash.delete(:implicit)
+        end
+
+        name = nil
+        unless hash.is_a? TransObject
+            hash = self.hash2trans(hash)
+        end
+
+        # XXX This will have to change when transobjects change to using titles
+        title = hash.name
+
+        #Puppet.debug "Creating %s[%s]" % [self.name, title]
+
+        # if the object already exists
+        if self.isomorphic? and retobj = self[title]
+            # if only one of our objects is implicit, then it's easy to see
+            # who wins -- the non-implicit one.
+            if retobj.implicit? and ! implicit
+                Puppet.notice "Removing implicit %s" % retobj.title
+                # Remove all of the objects, but do not remove their subscriptions.
+                retobj.remove(false)
+
+                # now pass through and create the new object
+            elsif implicit
+                Puppet.notice "Ignoring implicit %s" % title
+
+                return retobj
+            else
+                # If only one of the objects is being managed, then merge them
+                if retobj.managed?
+                    raise Puppet::Error, "%s '%s' is already being managed" %
+                        [self.name, title]
+                else
+                    retobj.merge(hash)
+                    return retobj
+                end
+                # We will probably want to support merging of some kind in
+                # the future, but for now, just throw an error.
+                #retobj.merge(hash)
+
+                #return retobj
+            end
+        end
+
+        # create it anew
+        # if there's a failure, destroy the object if it got that far, but raise
+        # the error.
+        begin
+            obj = new(hash)
+        rescue => detail
+            Puppet.err "Could not create %s: %s" % [title, detail.to_s]
+            if obj
+                obj.remove(true)
+            elsif obj = self[title]
+                obj.remove(true)
+            end
+            raise
+        end
+
+        if implicit
+            obj.implicit = true
+        end
+
+        # Store the object by title
+        self[obj.title] = obj
+
+        return obj
+    end
+
+    # remove a specified object
+    def self.delete(object)
+        return unless defined? @objects
+        if @objects.include?(object.title)
+            @objects.delete(object.title)
+        end
+        if @aliases.include?(object.title)
+            @aliases.delete(object.title)
+        end
+    end
+
+    # iterate across each of the type's instances
+    def self.each
+        return unless defined? @objects
+        @objects.each { |name,instance|
+            yield instance
+        }
+    end
+
+    # does the type have an object with the given name?
+    def self.has_key?(name)
+        return @objects.has_key?(name)
+    end
+
+    # Convert a hash to a TransObject.
+    def self.hash2trans(hash)
+        title = nil
+        if hash.include? :title
+            title = hash[:title]
+            hash.delete(:title)
+        elsif hash.include? self.namevar
+            title = hash[self.namevar]
+            hash.delete(self.namevar)
+
+            if hash.include? :name
+                raise ArgumentError, "Cannot provide both name and %s to %s" %
+                    [self.namevar, self.name]
+            end
+        elsif hash[:name]
+            title = hash[:name]
+            hash.delete :name
+        end
+
+        unless title
+            raise Puppet::Error,
+                "You must specify a title for objects of type %s" % self.to_s
+        end
+
+        if hash.include? :type
+            unless self.validattr? :type
+                hash.delete :type
+            end
+        end
+        # okay, now make a transobject out of hash
+        begin
+            trans = TransObject.new(title, self.name.to_s)
+            hash.each { |param, value|
+                trans[param] = value
+            }
+        rescue => detail
+            raise Puppet::Error, "Could not create %s: %s" %
+                [name, detail]
+        end
+
+        return trans
+    end
+
+    # Create the path for logging and such.
+    def pathbuilder
+        if defined? @parent and @parent
+            [@parent.pathbuilder, self.ref].flatten
+        else
+            [self.ref]
+        end
+    end
+end
+
+# $Id: instances.rb 1977 2006-12-28 06:49:03Z luke $