puppet 0.24.5 → 0.24.6

data/lib/puppet/metatype/metaparams.rb

@@ -1,423 +0,0 @@
-require 'puppet'
-require 'puppet/type'
-
-class Puppet::Type
-    # Add all of the meta parameters.
-    #newmetaparam(:onerror) do
-    #    desc "How to handle errors -- roll back innermost
-    #        transaction, roll back entire transaction, ignore, etc.  Currently
-    #        non-functional."
-    #end
-
-    newmetaparam(:noop) do
-        desc "Boolean flag indicating whether work should actually
-            be done."
-            
-        newvalues(:true, :false)
-        munge do |value|
-            case value
-            when true, :true, "true": @resource.noop = true
-            when false, :false, "false": @resource.noop = false
-            end
-        end
-    end
-
-    newmetaparam(:schedule) do
-        desc "On what schedule the object should be managed.  You must create a
-            schedule object, and then reference the name of that object to use
-            that for your schedule::
-
-                schedule { daily:
-                    period => daily,
-                    range => \"2-4\"
-                }
-
-                exec { \"/usr/bin/apt-get update\":
-                    schedule => daily
-                }
-
-            The creation of the schedule object does not need to appear in the
-            configuration before objects that use it."
-    end
-
-    newmetaparam(:check) do
-        desc "Propertys which should have their values retrieved
-            but which should not actually be modified.  This is currently used
-            internally, but will eventually be used for querying, so that you
-            could specify that you wanted to check the install state of all
-            packages, and then query the Puppet client daemon to get reports
-            on all packages."
-
-        munge do |args|
-            # If they've specified all, collect all known properties
-            if args == :all
-                args = @resource.class.properties.find_all do |property|
-                    # Only get properties supported by our provider
-                    if @resource.provider
-                        @resource.provider.class.supports_parameter?(property)
-                    else
-                        true
-                    end
-                end.collect do |property|
-                    property.name
-                end
-            end
-
-            unless args.is_a?(Array)
-                args = [args]
-            end
-
-            unless defined? @resource
-                self.devfail "No parent for %s, %s?" %
-                    [self.class, self.name]
-            end
-
-            args.each { |property|
-                unless property.is_a?(Symbol)
-                    property = property.intern
-                end
-                next if @resource.propertydefined?(property)
-
-                unless propertyklass = @resource.class.validproperty?(property)
-                    if @resource.class.validattr?(property)
-                        next
-                    else
-                        raise Puppet::Error, "%s is not a valid attribute for %s" %
-                            [property, self.class.name]
-                    end
-                end
-                next unless propertyklass.checkable?
-                @resource.newattr(property)
-            }
-        end
-    end
-    
-    # We've got four relationship metaparameters, so this method is used
-    # to reduce code duplication between them.
-    def munge_relationship(param, values)
-        # We need to support values passed in as an array or as a
-        # resource reference.
-        result = []
-        
-        # 'values' could be an array or a reference.  If it's an array,
-        # it could be an array of references or an array of arrays.
-        if values.is_a?(Puppet::Type)
-            result << [values.class.name, values.title]
-        else
-            unless values.is_a?(Array)
-                devfail "Relationships must be resource references"
-            end
-            if values[0].is_a?(String) or values[0].is_a?(Symbol)
-                # we're a type/title array reference
-                values[0] = symbolize(values[0])
-                result << values
-            else
-                # we're an array of stuff
-                values.each do |value|
-                    if value.is_a?(Puppet::Type)
-                        result << [value.class.name, value.title]
-                    elsif value.is_a?(Array)
-                        value[0] = symbolize(value[0])
-                        result << value
-                    else
-                        devfail "Invalid relationship %s" % value.inspect
-                    end
-                end
-            end
-        end
-        
-        if existing = self[param]
-            result = existing + result
-        end
-        
-        result
-    end
-
-    newmetaparam(:loglevel) do
-        desc "Sets the level that information will be logged.
-             The log levels have the biggest impact when logs are sent to
-             syslog (which is currently the default)."
-        defaultto :notice
-
-        newvalues(*Puppet::Util::Log.levels)
-        newvalues(:verbose)
-
-        munge do |loglevel|
-            val = super(loglevel)
-            if val == :verbose
-                val = :info 
-            end        
-            val
-        end
-    end
-
-    newmetaparam(:alias) do
-        desc "Creates an alias for the object.  Puppet uses this internally when you
-            provide a symbolic name::
-            
-                file { sshdconfig:
-                    path => $operatingsystem ? {
-                        solaris => \"/usr/local/etc/ssh/sshd_config\",
-                        default => \"/etc/ssh/sshd_config\"
-                    },
-                    source => \"...\"
-                }
-
-                service { sshd:
-                    subscribe => file[sshdconfig]
-                }
-
-            When you use this feature, the parser sets ``sshdconfig`` as the name,
-            and the library sets that as an alias for the file so the dependency
-            lookup for ``sshd`` works.  You can use this parameter yourself,
-            but note that only the library can use these aliases; for instance,
-            the following code will not work::
-
-                file { \"/etc/ssh/sshd_config\":
-                    owner => root,
-                    group => root,
-                    alias => sshdconfig
-                }
-
-                file { sshdconfig:
-                    mode => 644
-                }
-
-            There's no way here for the Puppet parser to know that these two stanzas
-            should be affecting the same file.
-
-            See the `LanguageTutorial language tutorial`:trac: for more information.
-            
-            "
-
-        munge do |aliases|
-            unless aliases.is_a?(Array)
-                aliases = [aliases]
-            end
-
-            raise(ArgumentError, "Cannot add aliases without a catalog") unless @resource.catalog
-
-            @resource.info "Adding aliases %s" % aliases.collect { |a| a.inspect }.join(", ")
-
-            aliases.each do |other|
-                if obj = @resource.catalog.resource(@resource.class.name, other)
-                    unless obj.object_id == @resource.object_id
-                        self.fail("%s can not create alias %s: object already exists" % [@resource.title, other])
-                    end
-                    next
-                end
-
-                # LAK:FIXME Old-school, add the alias to the class.
-                @resource.class.alias(other, @resource)
-
-                # Newschool, add it to the catalog.
-                @resource.catalog.alias(@resource, other)
-            end
-        end
-    end
-
-    newmetaparam(:tag) do
-        desc "Add the specified tags to the associated resource.  While all resources
-            are automatically tagged with as much information as possible
-            (e.g., each class and definition containing the resource), it can
-            be useful to add your own tags to a given resource.
-
-            Tags are currently useful for things like applying a subset of a
-            host's configuration::
-                
-                puppetd --test --tags mytag
-
-            This way, when you're testing a configuration you can run just the
-            portion you're testing."
-
-        munge do |tags|
-            tags = [tags] unless tags.is_a? Array
-
-            tags.each do |tag|
-                @resource.tag(tag)
-            end
-        end
-    end
-    
-    class RelationshipMetaparam < Puppet::Parameter
-        class << self
-            attr_accessor :direction, :events, :callback, :subclasses
-        end
-        
-        @subclasses = []
-        
-        def self.inherited(sub)
-            @subclasses << sub
-        end
-        
-        def munge(rels)
-            @resource.munge_relationship(self.class.name, rels)
-        end
-
-        def validate_relationship
-            @value.each do |value|
-                unless @resource.catalog.resource(*value)
-                    description = self.class.direction == :in ? "dependency" : "dependent"
-                    fail Puppet::Error, "Could not find #{description} %s[%s] for %s" % [value[0].to_s.capitalize, value[1], resource.ref]
-                end
-            end
-        end
-        
-        # Create edges from each of our relationships.    :in
-        # relationships are specified by the event-receivers, and :out
-        # relationships are specified by the event generator.  This
-        # way 'source' and 'target' are consistent terms in both edges
-        # and events -- that is, an event targets edges whose source matches
-        # the event's source.  The direction of the relationship determines
-        # which resource is applied first and which resource is considered
-        # to be the event generator.
-        def to_edges
-            @value.collect do |value|
-                # we just have a name and a type, and we need to convert it
-                # to an object...
-                tname, name = value
-                reference = Puppet::ResourceReference.new(tname, name)
-                
-                # Either of the two retrieval attempts could have returned
-                # nil.
-                unless object = reference.resolve
-                    self.fail "Could not retrieve dependency '%s' of %s" % [reference, @resource.ref]
-                end
-
-                # Are we requiring them, or vice versa?  See the method docs
-                # for futher info on this.
-                if self.class.direction == :in
-                    source = object
-                    target = @resource
-                else
-                    source = @resource
-                    target = object
-                end
-
-                if method = self.class.callback
-                    subargs = {
-                        :event => self.class.events,
-                        :callback => method
-                    }
-                    self.debug("subscribes to %s" % [object.ref])
-                else
-                    # If there's no callback, there's no point in even adding
-                    # a label.
-                    subargs = nil
-                    self.debug("requires %s" % [object.ref])
-                end
-                
-                rel = Puppet::Relationship.new(source, target, subargs)
-            end
-        end
-    end
-    
-    def self.relationship_params
-        RelationshipMetaparam.subclasses
-    end
-
-
-    # Note that the order in which the relationships params is defined
-    # matters.  The labelled params (notify and subcribe) must be later,
-    # so that if both params are used, those ones win.  It's a hackish
-    # solution, but it works.
-
-    newmetaparam(:require, :parent => RelationshipMetaparam, :attributes => {:direction => :in, :events => :NONE}) do
-        desc "One or more objects that this object depends on.
-            This is used purely for guaranteeing that changes to required objects
-            happen before the dependent object.  For instance::
-            
-                # Create the destination directory before you copy things down
-                file { \"/usr/local/scripts\":
-                    ensure => directory
-                }
-
-                file { \"/usr/local/scripts/myscript\":
-                    source => \"puppet://server/module/myscript\",
-                    mode => 755,
-                    require => File[\"/usr/local/scripts\"]
-                }
-
-            Multiple dependencies can be specified by providing a comma-seperated list
-            of resources, enclosed in square brackets::
-
-                require => [ File[\"/usr/local\"], File[\"/usr/local/scripts\"] ]
-
-            Note that Puppet will autorequire everything that it can, and
-            there are hooks in place so that it's easy for resources to add new
-            ways to autorequire objects, so if you think Puppet could be
-            smarter here, let us know.
-
-            In fact, the above code was redundant -- Puppet will autorequire
-            any parent directories that are being managed; it will
-            automatically realize that the parent directory should be created
-            before the script is pulled down.
-            
-            Currently, exec resources will autorequire their CWD (if it is
-            specified) plus any fully qualified paths that appear in the
-            command.   For instance, if you had an ``exec`` command that ran
-            the ``myscript`` mentioned above, the above code that pulls the
-            file down would be automatically listed as a requirement to the
-            ``exec`` code, so that you would always be running againts the
-            most recent version.
-            "
-    end
-
-    newmetaparam(:subscribe, :parent => RelationshipMetaparam, :attributes => {:direction => :in, :events => :ALL_EVENTS, :callback => :refresh}) do
-        desc "One or more objects that this object depends on.  Changes in the
-            subscribed to objects result in the dependent objects being
-            refreshed (e.g., a service will get restarted).  For instance::
-            
-                class nagios {
-                    file { \"/etc/nagios/nagios.conf\":
-                        source => \"puppet://server/module/nagios.conf\",
-                        alias => nagconf # just to make things easier for me
-                    }
-                    service { nagios:
-                        running => true,
-                        subscribe => File[nagconf]
-                    }
-                }
-	 		
-            Currently the ``exec``, ``mount`` and ``service`` type support
-            refreshing.
-            "
-    end
-
-    newmetaparam(:before, :parent => RelationshipMetaparam, :attributes => {:direction => :out, :events => :NONE}) do
-        desc %{This parameter is the opposite of **require** -- it guarantees
-            that the specified object is applied later than the specifying
-            object::
-
-                file { "/var/nagios/configuration":
-                    source  => "...",
-                    recurse => true,
-                    before => Exec["nagios-rebuid"]
-                }
-
-                exec { "nagios-rebuild":
-                    command => "/usr/bin/make",
-                    cwd => "/var/nagios/configuration"
-                }
-            
-            This will make sure all of the files are up to date before the
-            make command is run.}
-    end
-    
-    newmetaparam(:notify, :parent => RelationshipMetaparam, :attributes => {:direction => :out, :events => :ALL_EVENTS, :callback => :refresh}) do
-        desc %{This parameter is the opposite of **subscribe** -- it sends events
-            to the specified object::
-
-                file { "/etc/sshd_config":
-                    source => "....",
-                    notify => Service[sshd]
-                }
-
-                service { sshd:
-                    ensure => running
-                }
-            
-            This will restart the sshd service if the sshd config file changes.}
-    end
-end # Puppet::Type
-

data/lib/puppet/metatype/providers.rb

@@ -1,247 +0,0 @@
-require 'puppet/provider'
-require 'puppet/util/provider_features'
-class Puppet::Type
-    # Add the feature handling module.
-    extend Puppet::Util::ProviderFeatures
-
-    attr_reader :provider
-
-    # the Type class attribute accessors
-    class << self
-        attr_accessor :providerloader
-        attr_writer :defaultprovider
-    end
-
-    # Find the default provider.
-    def self.defaultprovider
-        unless defined? @defaultprovider and @defaultprovider
-            suitable = suitableprovider()
-
-            # Find which providers are a default for this system.
-            defaults = suitable.find_all { |provider| provider.default? }
-
-            # If we don't have any default we use suitable providers
-            defaults = suitable if defaults.empty?
-            max = defaults.collect { |provider| provider.defaultnum }.max
-            defaults = defaults.find_all { |provider| provider.defaultnum == max }
-
-            retval = nil
-            if defaults.length > 1
-                Puppet.warning(
-                    "Found multiple default providers for %s: %s; using %s" %
-                    [self.name, defaults.collect { |i| i.name.to_s }.join(", "),
-                        defaults[0].name]
-                )
-                retval = defaults.shift
-            elsif defaults.length == 1
-                retval = defaults.shift
-            else
-                raise Puppet::DevError, "Could not find a default provider for %s" %
-                    self.name
-            end
-
-            @defaultprovider = retval
-        end
-
-        return @defaultprovider
-    end
-
-    # Convert a hash, as provided by, um, a provider, into an instance of self.
-    def self.hash2obj(hash)
-        obj = nil
-        
-        namevar = self.namevar
-        unless hash.include?(namevar) and hash[namevar]
-            raise Puppet::DevError, "Hash was not passed with namevar"
-        end
-
-        # if the obj already exists with that name...
-        if obj = self[hash[namevar]]
-            # We're assuming here that objects with the same name
-            # are the same object, which *should* be the case, assuming
-            # we've set up our naming stuff correctly everywhere.
-
-            # Mark found objects as present
-            hash.each { |param, value|
-                if property = obj.property(param)
-                elsif val = obj[param]
-                    obj[param] = val
-                else
-                    # There is a value on disk, but it should go away
-                    obj[param] = :absent
-                end
-            }
-        else
-            # create a new obj, since no existing one seems to
-            # match
-            obj = self.create(namevar => hash[namevar])
-
-            # We can't just pass the hash in at object creation time,
-            # because it sets the should value, not the is value.
-            hash.delete(namevar)
-            hash.each { |param, value|
-                obj[param] = value unless obj.add_property_parameter(param)
-            }
-        end
-
-        return obj
-    end
-
-    # Retrieve a provider by name.
-    def self.provider(name)
-        name = Puppet::Util.symbolize(name)
-
-        # If we don't have it yet, try loading it.
-        unless @providers.has_key?(name)
-            @providerloader.load(name)
-        end
-        return @providers[name]
-    end
-
-    # Just list all of the providers.
-    def self.providers
-        @providers.keys
-    end
-
-    def self.validprovider?(name)
-        name = Puppet::Util.symbolize(name)
-
-        return (@providers.has_key?(name) && @providers[name].suitable?)
-    end
-
-    # Create a new provider of a type.  This method must be called
-    # directly on the type that it's implementing.
-    def self.provide(name, options = {}, &block)
-        name = Puppet::Util.symbolize(name)
-
-        if obj = @providers[name]
-            Puppet.debug "Reloading %s %s provider" % [name, self.name]
-            unprovide(name)
-        end
-
-        parent = if pname = options[:parent]
-            options.delete(:parent)
-            if pname.is_a? Class
-                pname
-            else
-                if provider = self.provider(pname)
-                    provider
-                else
-                    raise Puppet::DevError,
-                        "Could not find parent provider %s of %s" %
-                            [pname, name]
-                end
-            end
-        else
-            Puppet::Provider
-        end
-
-        options[:resource_type] ||= self
-
-        self.providify
-
-        provider = genclass(name,
-            :parent => parent,
-            :hash => @providers,
-            :prefix => "Provider",
-            :block => block,
-            :include => feature_module,
-            :extend => feature_module,
-            :attributes => options
-        )
-
-        return provider
-    end
-
-    # Make sure we have a :provider parameter defined.  Only gets called if there
-    # are providers.
-    def self.providify
-        return if @paramhash.has_key? :provider
-
-        newparam(:provider) do
-            desc "The specific backend for #{self.name.to_s} to use. You will
-                seldom need to specify this -- Puppet will usually discover the
-                appropriate provider for your platform."
-
-            # This is so we can refer back to the type to get a list of
-            # providers for documentation.
-            class << self
-                attr_accessor :parenttype
-            end
-
-            # We need to add documentation for each provider.
-            def self.doc
-                @doc + "  Available providers are:\n\n" + parenttype().providers.sort { |a,b|
-                    a.to_s <=> b.to_s
-                }.collect { |i|
-                    "* **%s**: %s" % [i, parenttype().provider(i).doc]
-                }.join("\n")
-            end
-
-            defaultto {
-                @resource.class.defaultprovider.name
-            }
-
-            validate do |provider_class|
-                provider_class = provider_class[0] if provider_class.is_a? Array
-                if provider_class.is_a?(Puppet::Provider)
-                    provider_class = provider_class.class.name
-                end
-
-                unless provider = @resource.class.provider(provider_class)
-                    raise ArgumentError, "Invalid %s provider '%s'" % [@resource.class.name, provider_class]
-                end
-            end
-
-            munge do |provider|
-                provider = provider[0] if provider.is_a? Array
-                if provider.is_a? String
-                    provider = provider.intern
-                end
-                @resource.provider = provider
-
-                if provider.is_a?(Puppet::Provider)
-                    provider.class.name
-                else
-                    provider
-                end
-            end
-        end.parenttype = self
-    end
-
-    def self.unprovide(name)
-        if @providers.has_key? name
-            rmclass(name,
-                :hash => @providers,
-                :prefix => "Provider"
-            )
-            if @defaultprovider and @defaultprovider.name == name
-                @defaultprovider = nil
-            end
-        end
-    end
-
-    # Return an array of all of the suitable providers.
-    def self.suitableprovider
-        if @providers.empty?
-            providerloader.loadall
-        end
-        @providers.find_all { |name, provider|
-            provider.suitable?
-        }.collect { |name, provider|
-            provider
-        }.reject { |p| p.name == :fake } # For testing
-    end
-
-    def provider=(name)
-        if name.is_a?(Puppet::Provider)
-            @provider = name
-            @provider.resource = self
-        elsif klass = self.class.provider(name)
-            @provider = klass.new(self)
-        else
-            raise ArgumentError, "Could not find %s provider of %s" %
-                [name, self.class.name]
-        end
-    end
-end