# NGZ install
# ...
function checkPkgAction {
    typeset -n ACTION=$1 TAG=$2
    if [[ ! ${ACTION} =~ ^(install|uninstall|avoid|unavoid|reject)$ ]]; then
        Log.fatal "$3() expects as first argument either 'install'," \
            "'uninstall', 'avoid', 'unavoid' or 'reject'"
        exit 2
    fi
    if [[ ${ACTION} == 'reject' ]]; then
        TAG=${ uname -v ; }
        if [[ ${TAG} == '11.0' ]]; then
            # 11.0 AI does not support pkg install --reject
            ACTION='uninstall'
            TAG='name'
        else
            # since 11.1
            ACTION='install'
            TAG='reject'
        fi
    else
        TAG='name'
    fi
}

# ...

function installZone {
    Log.info 'Preprocessing manifest for AI ...'
    # since "smart" AI developers do not use a real XML parser (but other
    # bogus stuff)/ is unable to handle valid XML manifests, we need to make
    # sure to feed something, what it can handle...
    cat >$TMPDIR/manifest.xslt<<EOF
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="xml" version="1.0" encoding="UTF-8" indent="yes" omit-xml-de
claration="yes" doctype-system="file:///usr/share/install/ai.dtd.1" />

<xsl:strip-space elements="*"/>

<!-- per default identity transform -->
<xsl:template match="@*|node()">
    <xsl:copy><xsl:apply-templates select="@*|node()"/></xsl:copy>
</xsl:template>

<!-- remove comments -->
<xsl:template match="comment()"/>

<!-- remove empty name elements -->
<xsl:template match='software_data/name|software_data/reject'>
    <xsl:if test='text()!=""'>
        <xsl:copy><xsl:apply-templates select="@*|node()"/></xsl:copy>
    </xsl:if>
</xsl:template>

<!-- remove empty software_data element -->
<xsl:template match='software_data'>
    <xsl:variable name="body"><xsl:apply-templates /></xsl:variable>
    <xsl:if test='\$body!=""'>
        <xsl:copy><xsl:apply-templates select="@*"/>
            <xsl:copy-of select="\$body"/>
        </xsl:copy>
    </xsl:if>
</xsl:template>
</xsl:stylesheet>
EOF
    xsltproc -o $MANIFEST.$$ $TMPDIR/manifest.xslt $MANIFEST

    Log.info "Installing zone $ZNAME ..."
    # install [-m manifest] [-c profile.xml | dir]
    # install {-a archive|-d path} {-p|-u} [-s|-v] [-c profile.xml | dir]
    zoneadm -z $ZNAME install -c ${PROFILE_DIR}/ -m $MANIFEST.$$
#...
}


# GZ install stuff 
# ...
function createManifest {
    . getClientConfig
    typeset MF=${ mktemp -t example.XXXXXX; }
    [[ -z "${MF}" ]] && exit 1
    typeset CONSDEF=${ getConsoleDefs "${C_CONS}"; }
    cat >${MF}<<EOF
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE auto_install SYSTEM "file:///usr/share/install/ai.dtd.1">
<auto_install>
    <ai_instance name="default" auto_reboot="true">
        <boot_mods title="Solaris 11" timeout="6">
            <boot_entry default_entry="false" insert_at="start">
                <title_suffix> (single user)</title_suffix>
                <kernel_args>-s -v -B \$ZFS-BOOTFS,${CONSDEF}</kernel_args>
            </boot_entry>
            <boot_entry default_entry="true" insert_at="start">
                <title_suffix> (default)</title_suffix>
                <kernel_args>-v -B \$ZFS-BOOTFS,${CONSDEF}</kernel_args>
            </boot_entry>
        </boot_mods>
        <target>
EOF
    typeset -a DISKS=( )
    integer I=0 K
    if [[ -n ${C_DISK} ]]; then
        typeset D1=${C_DISK#*;} D0 D X
        if [[ ${D1} != ${C_DISK} ]]; then
            X=${.sh.match}
            D0=${X%;}
            X=${D1#*;}
            if [[ $X != ${D1} ]]; then
                D1=${.sh.match}
                D1=${D1%;}
            else
                D1=$X
            fi
        fi
        for D in ${D0} ${D1} ; do
            if [[ $D == 'boot_disk' ]]; then
                DISKS[$I]='<disk_keyword key="boot_disk"/>'
            else
                X=${D%%:*}
                if [[ $X =~ ^(ctd|volid|devpath|devid|receptacle|wwn)$ ]]; then
                    DISKS[$I]='<disk_name name="'"${D#*:}"'" name_type="'$X'"/>'
                else
                    Log.fatal "Ungültiger disk typ $X - nur (ctd|volid|devpath|d
evid|receptacle|wwn) sind erlaubt."
                    exit 1
                fi
            fi
            I=$((I+1))
        done
    fi
    for (( K=0; K < I; K++ )); do
        cat >>$MF<<EOF
            <disk in_vdev="root" whole_disk="true">
                ${DISKS[$K]}
            </disk>
EOF
    done
    cat >>${MF}<<EOF
            <logical>
                <zpool action="create" name="rpool" is_root="true">
                    <vdev redundancy="mirror" name="root"/>
                    <filesystem name="${CNAMESHORT}/local" mountpoint="/local"/>
                    <filesystem name="${CNAMESHORT}/local/home"/>
                    <filesystem name="${CNAMESHORT}/export" mountpoint="/export"/>
                    <filesystem name="zones" mountpoint="/zones"/>
                    <pool_options>
                        <option name="failmode" value="continue"/>
                    </pool_options>
                    <dataset_options>
                        <option name="compression" value="on"/>
                    </dataset_options>
                </zpool>
            </logical>
        </target>
        <software name="solaris" type="IPS">
            <destination>
                <image>
EOF
    integer MAX=${#C_LOCALE[@]}
    if [[ ${MAX} == 1 && ${C_LOCALE[0]} == 'ALL' ]]; then
        print '<facet set="true">facet.locale.*</facet>' >>${MF}
    else
        print '<facet set="false">facet.locale.*</facet>' >>${MF}
        for (( i=0; i < MAX; i++ )); do
            print "<facet set='true'>facet.locale.${C_LOCALE[$i]}</facet>" \
                >>${MF}
        done
    fi
    MAX=${#C_NODOCS[@]}
    for (( I=0; I < MAX; I++ )); do
        print "<facet set='false'>facet.${C_NODOCS[$I]}</facet>" >>${MF}
    done
    X='/group/system/solaris-small-server'
    # [[ $C_TYPE != server ]] && X='/group/system/solaris-large-server'
    [[ ${C_TYPE} != 'server' ]] && X='/group/system/solaris-desktop'
    (( ${XFER} != ${HTTP} && ${XFER} != ${NFS} )) && XFER=${HTTP}
    [[ ${C_DEVISION} == 'iws' ]] && (( XFER+=2 ))
    Log.info "Benutze entire@${PKG_REL} package ..."
    cat >>$MF<<EOF
                    <property val='true'>flush-content-cache-on-success</property>
                </image>
            </destination>
            <source>
                <publisher name="solaris">
                    <origin name="${SOLARIS_PUBLISHER[${XFER}]}"/>
                </publisher>
<!--
                <publisher name="solarisstudio">
                    <origin name="${STUDIO_PUBLSHER[${XFER}]}"/>
                </publisher>
                <publisher name="fin">
                    <origin="${FIN_PUBLISHER[${XFER}]}"/>
                </publisher>
-->
            </source>
            <software_data action="install">
                <name>pkg:/entire@${PKG_REL}</name>
                <name>pkg:$X</name>
EOF
    # make packages uniq
    typeset -A PKG2ADD
    typeset -A PKG2DEL
    MAX=${#C_ADDPKG[@]}
    for (( I=0; I < MAX; I++ )); do
        PKG2ADD[${C_ADDPKG[$I]}]=1
    done
    MAX=${#C_DELPKG[@]}
    for (( I=0; I < MAX; I++ )); do
        PKG2DEL[${C_DELPKG[$I]}]=1
    done
    typeset PKG
    for PKG in "${!PKG2ADD[@]}"; do
        print "<name>pkg:${PKG}</name>" >>${MF}
    done
    print '</software_data>' >>${MF}
    MAX=${#PKG2DEL[@]}
    if (( MAX )); then
# neither reject nor avoid works reliable
#       if [[ ${ uname -v ; } == '11.0' ]]; then
            print '<software_data action="uninstall">' >>${MF}
#       else
#           print '<software_data action="avoid">' >>${MF}
#       fi
        for PKG in "${!PKG2DEL[@]}"; do
            print "<name>pkg:${PKG}</name>" >>${MF}
        done
        print '</software_data>' >>${MF}
    fi
    cat >>${MF}<<EOF
        </software>
        <software name="lnf" type="IPS">
            <source>
                <publisher name="lnf">
                    <origin name="${LNF_PUBLISHER[${XFER}]}"/>
                </publisher>
            </source>
            <software_data action="install">
                <name>pkg:/primary-admin</name>
                <name>pkg:/first-boot-script</name>
            </software_data>
        </software>
        <!-- Add missing driver packages so an installation can complete. -->
        <add_drivers>
            <search_all addall="true">
                <source>
                    <publisher name="solaris">
                        <origin name="${SOLARIS_PUBLISHER[${XFER}]}"/>
                    </publisher>
                </source>
            </search_all>
        </add_drivers>
    </ai_instance>
</auto_install>
EOF
    print "${MF}"
}
# ...