Untitled

cat repo.rb
# Define the different repository system.  Each repository system is implemented
# in a module, which then gets used to individually extend each repository object.
# This allows repositories to exist on the same machine using different repository
# systems.

require 'puppet'

Puppet::Type.newtype(:repo) do
        @doc = "Manage repositories.
            Puppet will automatically guess the packaging format that you are
            using based on the platform you are on, but you can override it
            using the ``provider`` parameter; each provider defines what it
            requires in order to function, and you must meet those requirements
            to use a given provider."

        ensurable do
            desc "What state the repository should be in."

            attr_accessor :latest

            newvalue(:present, :event => :package_installed) do
                provider.install
            end

            newvalue(:absent, :event => :package_removed) do
                provider.uninstall
            end

            # Alias the 'present' value.
            aliasvalue(:installed, :present)

            defaultto :installed
        end


        newparam(:name) do
            desc "The repository name."
            isnamevar
        end

        newparam(:source) do
            desc "The repository source."
        end

        newproperty(:refresh) do
            desc "The repository is automatically refreshed."
            newvalues(:Yes, :No)
        end

        newproperty(:enabled) do
            desc "The repository is enabled."
            newvalues(:Yes, :No)
            defaultto(:Yes)
        end

        newproperty(:priority) do
            desc "The repository priority."
            newvalues(/^\d+$/)
            validate do |value|
                if value.is_a?(String) and value =~ /^[-0-9]+$/
                    value = Integer(value)
                end
                if value > 100 or value < 1
                        raise ArgumentError, "Priority must be a value 1-99"
                else
                        super
                end

            end

        end

        newproperty(:keep_packages) do
            desc "Keep packages."
            newvalues(:Yes, :No)
            defaultto(:No)
        end

        # Override retrieve method to be able to call providors properties method
        # Seems to be used only for spec testing
        #def retrieve
        #       provider.properties[:ensure]
        #end
#
        # This only exists for testing.
#        def clear
#            if obj = @parameters[:ensure]
#                obj.latest = nil
#            end
#        end

end # Puppet::Type.type(:repo)


#### zypper repository
--------------------------------------------------------------------------


lib/puppet/provider/repo # cat zypper.rb
require 'puppet/provider/repo'
require 'uri'
require 'ruby-debug'

# Zypper repository.
Puppet::Type.type(:repo).provide :zypper, :source => :zypper, :parent => Puppet::Provider::Repo do
    desc "Zypper repository support"

    confine :operatingsystem => [:suse, :opensuse]
    defaultfor :operatingsystem => [:suse, :opensuse]

    commands :zypper => "/usr/bin/zypper"

    # We are going to use flush and precaching
    # type better override the retrieve method
    # type.retrieve -> provider.properties
    mk_resource_methods

    # Prefetch our repositoris. yo.
    def self.prefetch(repos)
        instances.each do |prov|
                if repo = repos[prov.name] || repos[prov.name.downcase]
                        repo.provider = prov
                end
        end
    end

    ZYPPER_REPO_REGEX = %r{^\d+\s+.*$}
    # | Alias      | Name   | Enabled | Refresh | Priority | Type  | URI   | Service

    def self.instances
        repos = []
        zypper(:lr, "-d").split("\n").each do |line|
                if match = ZYPPER_REPO_REGEX.match(line)
                        hash = {}
                        results = line.split(/\s+\|\s+/)
                        hash[:name] = results[1]
                        # This sucks but we need to find the keep packages per repo individually
                        data = zypper(:lr, "-d",results[1]).split(/\n/).detect { |line| line.split(/\s:\s/)[0].strip == "Keep Packages" }
                        if data
                                key,value = data.split(/\s+:\s+/)
                                if value.strip == "On"
                                        hash[:keep_packages] = "Yes"
                                else
                                        hash[:keep_packages] = "No"
                                end
                        end
                        hash[:enabled] = results[3]
                        hash[:refresh] = results[4]
                        hash[:priority] = results[5]
                        hash[:provider] = self.name
                        hash[:ensure] = :present
                        repos << new(hash)
                end
        end
        return repos
    end


    # Does our object exist?
    def exists?
        if zypper(:lr).split("\n").detect { |line| line.split("\s")[2] == @resource[:name] }
            self.debug "#{@resource[:name]} exists"
            return true
        else
            self.debug "#{@resource[:name]} does not exist"
            return false
        end
    end

    # install repository
    def install
        should = @resource.should(:ensure)
        self.debug "Ensuring => #{should}"
        zypper(:ar, @resource[:source], @resource[:name])
        is = self.status
        unless is
            raise Puppet::Error, "Could not find repository %s" % self.name
        end
    end

    def uninstall
        zypper(:rr, @resource[:name])
    end

    def update
        args = []
        if @resource[:refresh] == :Yes
            args << '--refresh'
        else
            args << '--no-refresh'
        end
        if @resource[:enabled] == :Yes
            args << '--enable'
        else
            args << '--disable'
        end
        if @resource[:priority]
            args << "-p#{@resource[:priority]}"
        end
        if @resource[:keep_packages] == :Yes
            args << '-k'
        else
            args << '-K'
        end
        args << @resource[:name]
        zypper(:mr,*args)
    end

    # Apply our changes to zypper, yo.
    def flush
        self.debug "Flushing"
        # Actually modify the repository
        self.update

        # Clear the cache
        @property_hash.clear
    end


    def query
        self.status
    end

    # Look up the current status.
    def status
        main = {}
        zypper(:lr, "-d", @resource[:name]).split("\n").each do |line|
                results = line.split(/\s+\:\s+/)
                if results[1]
                        value = results[1].strip
                        case results[0]
                        when "Name"
                                main[:name] = value
                        when "Enabled"
                                main[:enabled] = value
                        when "Priority"
                                main[:priority] = value
                        when "Auto-refresh"
                                if value == "On"
                                        main[:refresh] = "Yes"
                                else
                                        main[:refresh] = "No"
                                end
                        when "Keep Packages"
                                if value == "On"
                                        main[:keep_packages] = "Yes"
                                else
                                        main[:keep_packages] = "No"
                                end
                        end
                end
                main[:ensure] = :present
        end
        @property_hash.update(main)
        return @property_hash.dup
    end

    def properties
        if @property_hash.empty?
            @property_hash = self.status || {:ensure => :absent}
            if @property_hash.empty?
                @property_hash[:ensure] = :absent
            end
        end
        @property_hash.dup
    end
end