path: root/lib/puppet/provider.rb

# The container class for implementations.
class Puppet::Provider
    include Puppet::Util
    include Puppet::Util::Errors
    include Puppet::Util::Warnings
    extend Puppet::Util::Warnings

    require 'puppet/provider/confiner'

    extend Puppet::Provider::Confiner

    Puppet::Util.logmethods(self, true)

    class << self
        # Include the util module so we have access to things like 'binary'
        include Puppet::Util, Puppet::Util::Docs
        include Puppet::Util::Logging
        attr_accessor :name

        # The source parameter exists so that providers using the same
        # source can specify this, so reading doesn't attempt to read the
        # same package multiple times.
        attr_writer :source

        # LAK 2007-05-09: Keep the model stuff around for backward compatibility
        attr_reader :model
        attr_accessor :resource_type
        attr_writer :doc
    end

    # LAK 2007-05-09: Keep the model stuff around for backward compatibility
    attr_reader :model
    attr_accessor :resource

    def self.command(name)
        name = symbolize(name)

        if defined?(@commands) and command = @commands[name]
            # nothing
        elsif superclass.respond_to? :command and command = superclass.command(name)
            # nothing
        else
            raise Puppet::DevError, "No command #{name} defined for provider #{self.name}"
        end

        binary(command)
    end

    # Define commands that are not optional.
    def self.commands(hash)
        optional_commands(hash) do |name, path|
            confine :exists => path, :for_binary => true
        end
    end

    # Is the provided feature a declared feature?
    def self.declared_feature?(name)
        defined?(@declared_features) and @declared_features.include?(name)
    end

    # Does this implementation match all of the default requirements?  If
    # defaults are empty, we return false.
    def self.default?
        return false if @defaults.empty?
        if @defaults.find do |fact, values|
                values = [values] unless values.is_a? Array
                if fval = Facter.value(fact).to_s and fval != ""
                    fval = fval.to_s.downcase.intern
                else
                    return false
                end

                # If any of the values match, we're a default.
                if values.find do |value| fval == value.to_s.downcase.intern end
                    false
                else
                    true
                end
            end
            return false
        else
            return true
        end
    end

    # Store how to determine defaults.
    def self.defaultfor(hash)
        hash.each do |d,v|
            @defaults[d] = v
        end
    end

    def self.specificity
        (@defaults.length * 100) + ancestors.select { |a| a.is_a? Class }.length
    end

    def self.initvars
        @defaults = {}
        @commands = {}
    end

    # The method for returning a list of provider instances.  Note that it returns providers, preferably with values already
    # filled in, not resources.
    def self.instances
        raise Puppet::DevError, "Provider #{self.name} has not defined the 'instances' class method"
    end

    # Create the methods for a given command.
    def self.make_command_methods(name)
        # Now define a method for that command
        unless singleton_class.method_defined?(name)
            meta_def(name) do |*args|
                raise Puppet::Error, "Command #{name} is missing" unless command(name)
                if args.empty?
                    cmd = [command(name)]
                else
                    cmd = [command(name)] + args
                end
                # This might throw an ExecutionFailure, but the system above
                # will catch it, if so.
                return execute(cmd)
            end

            # And then define an instance method that just calls the class method.
            # We need both, so both instances and classes can easily run the commands.
            unless method_defined?(name)
                define_method(name) do |*args|
                    self.class.send(name, *args)
                end
            end
        end
    end

    # Create getter/setter methods for each property our resource type supports.
    # They all get stored in @property_hash.  This method is useful
    # for those providers that use prefetch and flush.
    def self.mkmodelmethods
        warnonce "Provider.mkmodelmethods is deprecated; use Provider.mk_resource_methods"
        mk_resource_methods
    end

    # Create getter/setter methods for each property our resource type supports.
    # They all get stored in @property_hash.  This method is useful
    # for those providers that use prefetch and flush.
    def self.mk_resource_methods
        [resource_type.validproperties, resource_type.parameters].flatten.each do |attr|
            attr = symbolize(attr)
            next if attr == :name
            define_method(attr) do
                @property_hash[attr] || :absent
            end

            define_method(attr.to_s + "=") do |val|
                @property_hash[attr] = val
            end
        end
    end

    self.initvars

    # Define one or more binaries we'll be using.  If a block is passed, yield the name
    # and path to the block (really only used by 'commands').
    def self.optional_commands(hash)
        hash.each do |name, path|
            name = symbolize(name)
            @commands[name] = path

            yield(name, path) if block_given?

            # Now define the class and instance methods.
            make_command_methods(name)
        end
    end

    # Retrieve the data source.  Defaults to the provider name.
    def self.source
        @source ||= self.name
    end

    # Does this provider support the specified parameter?
    def self.supports_parameter?(param)
        if param.is_a?(Class)
            klass = param
        else
            unless klass = resource_type.attrclass(param)
                raise Puppet::DevError, "'#{param}' is not a valid parameter for #{resource_type.name}"
            end
        end
        return true unless features = klass.required_features

        !!satisfies?(*features)
    end

#    def self.to_s
#        unless defined?(@str)
#            if self.resource_type
#                @str = "#{resource_type.name} provider #{self.name}"
#            else
#                @str = "unattached provider #{self.name}"
#            end
#        end
#        @str
#    end

    dochook(:defaults) do
        if @defaults.length > 0
            return "  Default for " + @defaults.collect do |f, v|
                "``#{f}`` == ``#{v}``"
            end.join(" and ") + "."
        end
    end

    dochook(:commands) do
        if @commands.length > 0
            return "  Required binaries: " + @commands.collect do |n, c|
                "``#{c}``"
            end.join(", ") + "."
        end
    end

    dochook(:features) do
        if features().length > 0
            return "  Supported features: " + features().collect do |f|
                "``#{f}``"
            end.join(", ") + "."
        end
    end

    # Remove the reference to the resource, so GC can clean up.
    def clear
        @resource = nil
        @model = nil
    end

    # Retrieve a named command.
    def command(name)
        self.class.command(name)
    end

    # Get a parameter value.
    def get(param)
        @property_hash[symbolize(param)] || :absent
    end

    def initialize(resource = nil)
        if resource.is_a?(Hash)
            # We don't use a duplicate here, because some providers (ParsedFile, at least)
            # use the hash here for later events.
            @property_hash = resource
        elsif resource
            @resource = resource
            # LAK 2007-05-09: Keep the model stuff around for backward compatibility
            @model = resource
            @property_hash = {}
        else
            @property_hash = {}
        end
    end

    def name
        if n = @property_hash[:name]
            return n
        elsif self.resource
            resource.name
        else
            raise Puppet::DevError, "No resource and no name in property hash in #{self.class.name} instance"
        end
    end

    # Set passed params as the current values.
    def set(params)
        params.each do |param, value|
            @property_hash[symbolize(param)] = value
        end
    end

    def to_s
        "#{@resource}(provider=#{self.class.name})"
    end
end