#
# 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
#

#
# Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
#


Puppet::Type.type(:evs_ipnet).provide(:evs_ipnet) do
    desc "Provider for managing EVS IPnet setup in the Solaris OS"
    confine :operatingsystem => [:solaris]
    defaultfor :osfamily => :solaris, :kernelrelease => ["5.11", "5.12"]
    commands :evsadm => "/usr/sbin/evsadm"

    mk_resource_methods

    def initialize(value={})
        super(value)
        @property_flush = {}
    end

    def self.get_ipnet_prop_list
        begin
            ipnet_list = evsadm("show-ipnet", "-c", "-o", 
                "name,tenant").split("\n")
        rescue Puppet::ExecutionFailure => e
            raise Puppet::Error,  "Unable to populate IPnet: \n"\
                "#{e.inspect}"
        end
        ipnet_list
    end

    def self.get_ipnet_properties(ipnet_name, tenant,  ensure_val)
        ipnet_properties = {}
        ipnet_fullname = tenant + "/" + ipnet_name

        ipnet_properties[:name] = ipnet_fullname
        ipnet_properties[:ensure] = ensure_val

        evsadm("show-ipnetprop", "-f", "tenant=#{tenant}", "-c", "-o",
            "property,value", ipnet_name).split("\n").collect do |each_ipnet|
            property, value = each_ipnet.split(":")
            value = "" if value.nil?
            case property
            # read-only properties (settable upon creation)
            when "subnet"
                ipnet_properties[:subnet] = value
            when "defrouter"
                ipnet_properties[:defrouter] = value
            when "uuid"
                ipnet_properties[:uuid] = value
            # read/write property (always updatable)
            when "pool"
                ipnet_properties[:pool] = value
            end
        end

        Puppet.debug "IPnet Properties: #{ipnet_properties.inspect}"
        ipnet_properties
    end

    def self.instances
        get_ipnet_prop_list.collect do |each_ipnet|
            ipnet, tenant, subnet = each_ipnet.strip.split(":")
            ipnet_properties = get_ipnet_properties(
                ipnet, tenant, :present)
            new(ipnet_properties) # Create a provider instance
        end
    end

    def self.prefetch(resources)
        instances.each do |inst|
            if resource = resources[inst.name]
                resource.provider = inst
            end
        end
    end

    def exists?
        @property_hash[:ensure] == :present
    end

    def create
        # Subnet value is required to create an IPnet instance
        if @resource[:subnet].nil?
            raise Puppet::Error, "Subnet value is missing"
        end
        
        tenant, ipnet_name = get_tenant_and_ipnet_name
        begin 
            create_ipnet(tenant, ipnet_name, add_properties(@resource))
        rescue Puppet::ExecutionFailure => e
            raise Puppet::Error, "Cannot add the IPnet: \n #{e.inspect}"
        end
    end

    def destroy
        tenant, ipnet_name = get_tenant_and_ipnet_name
        begin
            delete_ipnet(tenant, ipnet_name)
        rescue Puppet::ExecutionFailure => e
            raise Puppet::Error, "Cannot remove the IPnet: \n #{e.inspect}"
        end
    end
   
    ## read-only properties (settable upon creation) ##
    def defrouter=(value)
        raise Puppet::Error, "defrouter property is settable only upon creation"
    end

    def subnet=(value)
        raise Puppet::Error, "subnet property is settable only upon creation"
    end

    def uuid=(value)
        raise Puppet::Error, "uuid property is settable only upon creation"
    end
    
    ## read/write property (always updatable) ##
    def pool=(value)
        @property_flush[:pool] = value
    end
   
    ## Create IPnet instance ##
    def create_ipnet(tenant, ipnet_name, properties)
        begin
            evsadm("add-ipnet", "-T", tenant, properties, ipnet_name)
        rescue Puppet::ExecutionFailure => e
            # Pass up the exception to upper level
            raise
        end
    end

    ## Remove IPnet instance ##
    def delete_ipnet(tenant, ipnet_name)
        begin
            evsadm("remove-ipnet", "-T", tenant, ipnet_name)
        rescue Puppet::ExecutionFailure => e
            # Pass up the exception to upper level
            raise
        end
    end

    ## Set IPnet prop (pool property only) ##
    def set_ipnet(tenant, ipnet_name, property)
        begin
            evsadm("set-ipnetprop", "-T", tenant, property, ipnet_name)
        rescue Puppet::ExecutionFailure => e
            # Pass up the exception to upper level
            raise
        end
    end
    
    ## Parse the "name" value from user and yield tenant and IPnet name ##
    def get_tenant_and_ipnet_name
        fullname = @resource[:name]
        
        parsed_val = fullname.strip.split("/")
        if (parsed_val.length != 3)
            raise Puppet::Error, "Invalid IPnet name"
        end
        tenant, evs, ipnet = parsed_val
        return tenant, evs + "/" + ipnet
    end

    ## property setter for IPnet creation ##
    def add_properties(source)
        p = []
        prop_list = {
            "defrouter" => source[:defrouter],
            "pool" => source[:pool],
            "subnet" => source[:subnet],
            "uuid" => source[:uuid]
            }
        prop_list.each do |key, value|
            next if (value == nil) || (value == "")
            p << "#{key}=#{value}"
        end
        return [] if p.empty?
        properties = Array["-p", p.join(",")]
    end
    
    ## Flush when existing property value is updatable ##
    def flush
        tenant, ipnet_name = get_tenant_and_ipnet_name

        unless @property_flush.empty?
        # Update read/write property (pool)
            pool_prop = ["-p", "pool=#{@property_flush[:pool]}"]
            begin
                set_ipnet(tenant, ipnet_name, pool_prop)
            rescue Puppet::ExecutionFailure => e
                raise Puppet::Error, "Cannot update the pool property. \n" \
                    "#{e.inspect}"
            end
        end

        # Synchronize all the SHOULD values to IS values
        @property_hash = resource.to_hash
    end
end