#

# CDDL HEADER START

#

# The contents of this file are subject to the terms of the

# Common Development and Distribution License (the "License").

# You may not use this file except in compliance with the License.

#

# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

# or http://www.opensolaris.org/os/licensing.

# See the License for the specific language governing permissions

# and limitations under the License.

#

# When distributing Covered Code, include this CDDL HEADER in each

# file and include the License file at usr/src/OPENSOLARIS.LICENSE.

# If applicable, add the following below this CDDL HEADER, with the

# fields enclosed by brackets "[]" replaced with your own identifying

# information: Portions Copyright [yyyy] [name of copyright owner]

#

# CDDL HEADER END

#

#

#

Puppet::Type.type(:pkg_publisher).provide(:pkg_publisher) do

    desc "Provider for Solaris publishers"

    confine :operatingsystem => [:solaris]

    defaultfor :osfamily => :solaris, :kernelrelease => ['5.11', '5.12']

    commands :pkg => '/usr/bin/pkg'

    def self.instances

        publishers = {}

        publisher_order = []

        pkg(:publisher, "-H", "-F", "tsv").split("\n").collect do |line|

            name, sticky, syspub, enabled, type, status, origin, proxy = \

                line.split("\t")

            # set the order of the publishers

            if not publisher_order.include?("name")

                publisher_order << name

            end

            # strip off any trailing "/" characters

            if origin.end_with?("/")

                origin = origin[0..-2]

            end

                # if we've seen this publisher before, simply update the origin

                # array

                publishers[name]["origin"] << origin

            else

                # create a new hash entry for this publisher

                publishers[name] = {'sticky' => sticky, 'enable' => enabled,

                                    'origin' => Array[origin]}

                publishers[name]["proxy"] = proxy if proxy != "-"

                index = publisher_order.index(name)

                    publishers[name]["searchfirst"] = true

                    publishers[name]["searchafter"] = nil

                else

                    publishers[name]["searchfirst"] = nil

                    publishers[name]["searchafter"] = publisher_order[index-1]

                end

            end

        end

        # create new entries for the system

        publishers.keys.collect do |publisher|

            new(:name => publisher,

                :ensure => :present,

                :sticky => publishers[publisher]["sticky"],

                :enable => publishers[publisher]["enable"],

                :origin => publishers[publisher]["origin"],

                :proxy => publishers[publisher]["proxy"],

                :searchfirst => publishers[publisher]["searchfirst"],

                :searchafter => publishers[publisher]["searchafter"],

                :searchbefore => nil,

                :sslkey => nil,

                :sslcert => nil)

        end

    end

    def self.prefetch(resources)

        # pull the instances on the system

        publishers = instances

        # set the provider for the resource to set the property_hash

        resources.keys.each do |name|

            if provider = publishers.find{ |publisher| publisher.name == name}

                resources[name].provider = provider

            end

        end

    end

    # property getters - each getter does exactly the same thing so create

    # dynamic methods to handle them

    [:sticky, :enable, :origin, :proxy, :searchfirst, :searchafter,

     :searchbefore, :sslkey, :sslcert].each do |property|

        define_method(property) do

            begin

                @property_hash[property]

            rescue

            end

        end

    end

    def exists?

        # only compare against @resource if one is provided via manifests

        if @property_hash[:ensure] == :present and @resource[:origin] != nil

            return @property_hash[:origin].sort() == @resource[:origin].sort()

        end

        @property_hash[:ensure] == :present

    end

    def build_origin

        origins = []

        # add all the origins from the manifest

        for o in @resource[:origin] do

            origins << "-g" << o

        end

        # remove all the existing origins

        if @property_hash != {}

            for o in @property_hash[:origin] do

                origins << "-G" << o

            end

        end

        origins

    end

    def build_flags

        flags = []

        if enable = @resource[:enable] and enable != nil

            if enable == :true

                flags << "--enable"

            elsif enable == :false

                flags << "--disable"

            end

        end

        if searchfirst = @resource[:searchfirst] and searchfirst != ""

            if searchfirst == :true

                flags << "--search-first"

            end

        end

        if sticky = @resource[:sticky] and sticky != nil

            if sticky == :true

                flags << "--sticky"

            elsif sticky == :false

                flags << "--non-sticky"

            end

        end

        if searchafter = @resource[:searchafter] and searchafter != ""

            if pkg(:publisher, "-H", "-F", "tsv").split("\n").detect \

                { |line| line.split()[0] == searchafter }

                    flags << "--search-after" << searchafter

            else

                Puppet.warning "Publisher #{searchafter} not found.  " \

                               "Skipping --search-after argument"

            end

        end

        if searchbefore = @resource[:searchbefore] and searchbefore != ""

            if pkg(:publisher, "-H", "-F", "tsv").split("\n").detect \

                { |line| line.split()[0] == searchbefore }

                    flags << "--search-before" << searchbefore

            else

                Puppet.warning "Publisher #{searchbefore} not found.  " \

                               "Skipping --search-before argument"

            end

        end

        if proxy = @resource[:proxy]

            flags << "--proxy" << proxy

        end

        if sslkey = @resource[:sslkey]

            flags << "-k" << sslkey

        end

        if sslcert = @resource[:sslcert]

            flags << "-c" << sslcert

        end

        flags

    end

    # property setters

    def sticky=(value)

        if value == :true

            pkg("set-publisher", "--sticky", @resource[:name])

        else

            pkg("set-publisher", "--non-sticky", @resource[:name])

        end

    end

    def enable=(value)

        if value == :true

            pkg("set-publisher", "--enable", @resource[:name])

        else

            pkg("set-publisher", "--disable", @resource[:name])

        end

    end

    def searchfirst=(value)

        if value == :true

            pkg("set-publisher", "--search-first", @resource[:name])

        end

    end

    def searchbefore=(value)

        pkg("set-publisher", "--search-before", value, @resource[:name])

    end

    def searchafter=(value)

        pkg("set-publisher", "--search-after", value, @resource[:name])

    end

    def proxy=(value)

        pkg("set-publisher", "--proxy", value, @resource[:name])

    end

    def sslkey=(value)

        pkg("set-publisher", "-k", value, @resource[:name])

    end

    def sslcert=(value)

        pkg("set-publisher", "-c", value, @resource[:name])

    end

    # required puppet functions

    def create

        pkg("set-publisher", build_flags, build_origin, @resource[:name])

    end

    def destroy

        pkg("unset-publisher", @resource[:name])

    end

end