puppet 0.24.5 → 0.24.6

data/lib/puppet/metatype/closure.rb

@@ -1,49 +0,0 @@
-class Puppet::Type
-    attr_writer :implicit
-
-    # 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
-
-    def isomorphic?
-        self.class.isomorphic?
-    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
-end

data/lib/puppet/metatype/container.rb

@@ -1,50 +0,0 @@
-class Puppet::Type
-
-    # 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
-
-    # 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
-        else
-            return false
-        end
-    end
-
-    # Remove an object.  The argument determines whether the object's
-    # subscriptions get eliminated, too.
-    def remove(rmdeps = true)
-        # 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
-

data/lib/puppet/metatype/evaluation.rb

@@ -1,163 +0,0 @@
-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
-        if self.provider.is_a?(Puppet::Provider)
-            unless provider.class.suitable?
-                raise Puppet::Error, "Provider %s is not functional on this platform" % provider.class.name
-            end
-        end
-        #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
-        currentvalues = self.retrieve
-
-        changes = propertychanges(currentvalues).flatten
-
-        # now record how many changes we've resulted in
-        if changes.length > 0
-            self.debug "%s change(s)" %
-                [changes.length]
-        end
-
-        # If we're in noop mode, we don't want to store the checked time,
-        # because it will result in the resource not getting scheduled if
-        # someone were to apply the catalog in non-noop mode.
-        # We're going to go ahead and record that we checked if there were
-        # no changes, since it's unlikely it will affect the scheduling.
-        noop = noop?
-        if ! noop or (noop && changes.length == 0)
-            self.cache(:checked, Time.now)
-        end
-        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?(is)
-        insync = true
-        
-        if property = @parameters[:ensure]
-            unless is.include? property
-               raise Puppet::DevError,
-                        "The is value is not in the is array for '%s'" %
-                        [property.name]
-            end
-            ensureis = is[property]           
-            if property.insync?(ensureis) and property.should == :absent
-                return true
-            end
-        end
-
-        properties.each { |property|
-            unless is.include? property
-               raise Puppet::DevError,
-                        "The is value is not in the is array for '%s'" %
-                        [property.name]
-            end
-
-            propis = is[property]
-            unless property.insync?(propis)
-                property.debug("Not in sync: %s vs %s" %
-                    [propis.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
-         return currentpropvalues
-    end
-    
-    # get a hash of the current properties.  
-    def currentpropvalues(override_value = nil)
-        # it's important to use the method here, as it follows the order
-        # in which they're defined in the object
-        return properties().inject({}) { | prophash, property|
-                   prophash[property] = override_value.nil? ? 
-                                          property.retrieve : 
-                                             override_value
-                   prophash
-               }
-    end
-
-    # Are we running in noop mode?
-    def noop?
-        if defined?(@noop)
-            @noop
-        else
-            Puppet[:noop]
-        end
-    end
-
-    def noop
-        noop?
-    end
-     
-    # Retrieve the changes associated with all of the properties.
-    def propertychanges(currentvalues)
-        # If we are changing the existence of the object, then none of
-        # the other properties matter.
-        changes = []
-        ensureparam = @parameters[:ensure]
-
-        # This allows resource types to have 'ensure' be a parameter, which allows them to
-        # just pass the parameter on to other generated resources.
-        ensureparam = nil unless ensureparam.is_a?(Puppet::Property)
-        if ensureparam && !currentvalues.include?(ensureparam)
-            raise Puppet::DevError, "Parameter ensure defined but missing from current values"
-        end
-
-        if ensureparam and ! ensureparam.insync?(currentvalues[ensureparam])
-            changes << Puppet::Transaction::Change.new(ensureparam, currentvalues[ensureparam])
-        # Else, if the 'ensure' property is correctly absent, then do
-        # nothing
-        elsif ensureparam and currentvalues[ensureparam] == :absent
-            return []
-        else
-            changes = properties().find_all { |property|
-                currentvalues[property] ||= :absent
-                ! property.insync?(currentvalues[property])
-            }.collect { |property|
-                Puppet::Transaction::Change.new(property, currentvalues[property])
-            }
-        end
-
-        if Puppet[:debug] and changes.length > 0
-            self.debug("Changing " + changes.collect { |ch| ch.property.name }.join(","))
-        end
-
-        changes
-    end
-end
-

data/lib/puppet/metatype/instances.rb

@@ -1,305 +0,0 @@
-require 'puppet/transportable'
-
-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.
-    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? Puppet::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 they've specified a type and called on the base, then
-            # delegate to the subclass.
-            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? Puppet::TransObject
-            hash = self.hash2trans(hash)
-        end
-
-        # XXX This will have to change when transobjects change to using titles
-        title = hash.name
-
-        # 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.debug "Ignoring implicit %s[%s]" % [self.name, title]
-                return nil
-            else
-                raise Puppet::Error, "%s is already being managed" % retobj.ref
-            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(resource)
-        return unless defined? @objects
-        if @objects.include?(resource.title)
-            @objects.delete(resource.title)
-        end
-        if @aliases.include?(resource.title)
-            @aliases.delete(resource.title)
-        end
-        if @aliases.has_value?(resource)
-            names = []
-            @aliases.each do |name, otherres|
-                if otherres == resource
-                    names << name
-                end
-            end
-            names.each { |name| @aliases.delete(name) }
-        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
-
-        if catalog = hash[:catalog]
-            hash.delete(:catalog)
-        end
-
-        raise(Puppet::Error, "You must specify a title for objects of type %s" % self.to_s) unless title
-
-        if hash.include? :type
-            unless self.validattr? :type
-                hash.delete :type
-            end
-        end
-
-        # okay, now make a transobject out of hash
-        begin
-            trans = Puppet::TransObject.new(title, self.name.to_s)
-            trans.catalog = catalog if catalog
-            hash.each { |param, value|
-                trans[param] = value
-            }
-        rescue => detail
-            raise Puppet::Error, "Could not create %s: %s" %
-                [name, detail]
-        end
-
-        return trans
-    end
-
-    # Retrieve all known instances.  Either requires providers or must be overridden.
-    def self.instances
-        unless defined?(@providers) and ! @providers.empty?
-            raise Puppet::DevError, "%s has no providers and has not overridden 'instances'" % self.name
-        end
-
-        # Put the default provider first, then the rest of the suitable providers.
-        provider_instances = {}
-        providers_by_source.collect do |provider|
-            provider.instances.collect do |instance|
-                # First try to get the resource if it already exists
-                # Skip instances that map to a managed resource with a different provider
-                next if resource = self[instance.name] and resource.provider.class != instance.class
-
-                # We always want to use the "first" provider instance we find, unless the resource
-                # is already managed and has a different provider set
-                if other = provider_instances[instance.name]
-                    Puppet.warning "%s %s found in both %s and %s; skipping the %s version" %
-                        [self.name.to_s.capitalize, instance.name, other.class.name, instance.class.name, instance.class.name]
-                    next
-                end
-                provider_instances[instance.name] = instance
-
-                if resource
-                    resource.provider = instance
-                    resource
-                else
-                    create(:name => instance.name, :provider => instance, :check => :all)
-                end
-            end
-        end.flatten.compact
-    end
-
-    # Return a list of one suitable provider per source, with the default provider first.
-    def self.providers_by_source
-        # Put the default provider first, then the rest of the suitable providers.
-        sources = []
-        [defaultprovider, suitableprovider].flatten.uniq.collect do |provider|
-            next if sources.include?(provider.source)
-
-            sources << provider.source
-            provider
-        end.compact
-    end
-
-    # Create the path for logging and such.
-    def pathbuilder
-        if p = parent
-            [p.pathbuilder, self.ref].flatten
-        else
-            [self.ref]
-        end
-    end
-end
-