##! /bin/bash
#
# ssm-installer
#
# Basic utility to install ssm.

# GPL--start
# This file is part of ssm (Simple Software Manager)
# Copyright (C) 2005-2010 Environment/Environnement Canada
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; version 2
# of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
# GPL--end

printUsage() {
    echo "usage: ssm-installer [options]

Options:
    -h|--help
    --chownDomainHome
        Change ownership of the domain home to current user.
        Default:
            ${changeDomainHome}
    --defaultRepositorySource <source>
        The default repository source that will be used
        by ssm unless overridden. This will be put into
        ${defaultRepositorySource}/etc/ssm.d/sources.list .
    -d|--domainHome <path>
        Domain home to contain the ssm package and
        configuration info for other domain homes.
        Default:
            ${domainHome}
    -G|--groupName <groupName>
        Owner (group) of the domain home.
        Default:
            ${groupName}
    --installAndPublishPython
        Install and publish required python package
        under ssm. This is typically done on systems on
        which python is not already available.
        Default:
            ${installAndPublishPython}
    --L|--label <label>
        The label to associate with the domain.
    --pythonPackageName <name>
        The python package name to install and publish.
        Default:
            ${pythonPackageName}
    --pythonRepositoryUrl <url>
        Repository URL to use to access python package
        to install and publish.
        Default:
            ${pythonRepositoryUrl}
    --ssmPackageName <name>
        Name of the ssm package to be installed.
        Default:
            ${ssmPackageName}
    --ssmRepositoryUrl <name>
        Repository URL to use to access the ssm package.
        Default:
            ${ssmRepositoryUrl}
    --system
        Subscribe the system to the domain being
        created.
        Default:
            ${subscribeSystem}
    --user
        Subscribe the user to the domain being created.
        Default:
            ${subscribeUser}
    -U|--userName <userName>
        Owner (user) of the domain home directory.
        Default:
            ${userName}
    --force
        Force operation. Do not ask questions.
    -v|--verbose
        Print progress information.

Note: This program is not intended to be run as root user.
      Authorization will be requested if required.
"
}

checkForWget() {
    ${wgetExec} --help 2>1 > /dev/null
    if [ $? -ne 0 ]; then
        echo "Cannot find wget. Install it or use the local filesystem."
        exit -1
    fi
}

downloadPackage() {
    packageName=$1
    packageUrl=$2

    if [ "x`echo ${packageUrl} | ${grepExec} -E '^http:|^ftp:'`" != "x" ]; then
        echo "Loading ${packageName} from repository ${packageUrl}."
        checkForWget
        ${wgetExec} ${packageUrl} 2>1 > /dev/null
    else
        echo "Loading ${packageName} from local."
        ${cpExec} ${packageUrl} ${tmpDir}
    fi
}

#
# main
#

# initial settings
baseUrl="http://ssm.cmc.ec.gc.ca"
chownDomainHome="no"
defaultRepositorySource="${baseUrl} all multi linux24 linux26 aix51 aix52 aix53 irix65 base"
domainHome="/opt/ssm"
groupName="ssm"
force="no"
label="Default system domain"
mkdirMode="0755"
pythonExec="python"
subscribeSystem="no"
subscribeUser="no"
tarVerboseFlag=""
uid=`id`
uid=${uid##uid=}
uid=${uid%%\(*}
userName="ssm"
verbose="no"
whoami="`whoami`"

architecture="all"
ssmPackageName="ssm_8.7_all"
ssmRepositoryUrl="${baseUrl}/base"

installAndPublishPython="no"
pythonPackageName="python_2.3.5_linux24-i386"
pythonRepositoryUrl="${baseUrl}/linux24"

cpExec=\cp
grepExec=\grep
mkdirExec=\mkdir
printfExec=\printf
rmExec=\rm
shExec=/bin/sh
suExec=\su
wgetExec=\wget

# parse command line
while [ $# -gt 0 ]; do
    case $1 in
    "--chownDomainHome")
        chownDomainHome="yes"; shift 1
        ;;
    "-D"|"--defaultRepositorySource")
        shift 1
        defaultRepositorySource="$1"; shift 1
        ;;
    "-d"|"--domainHome")
        shift 1
        domainHome="$1"; shift 1
        ;;
    "-G"|"--groupName")
        shift 1
        groupName="$1"; shift 1
        ;;
    "--installAndPublishPython")
        installAndPublishPython="yes"; shift 1
        ;;
    "-L"|"--label")
        shift 1
        label="$1"; shift 1
        ;;
    "--pythonPackageName")
        shift 1
        pythonPackageName="$1"; shift 1
        ;;
    "--pythonRepositoryUrl")
        shift 1
        pythonRepositoryUrl="$1"; shift 1
        ;;
    "--ssmPackageName")
        shift 1
        ssmPackageName="$1"; shift 1
        ;;
    "--ssmRepositoryUrl")
        shift 1
        ssmRepositoryUrl="$1"; shift 1
        ;;
    "--system")
        subscribeSystem="yes"; shift 1
        ;;
    "--user")
        subscribeUser="yes"; shift 1
        ;;
    "-U"|"--userName")
        shift 1
        userName="$1"; shift 1
        ;;
    "--force")
        force="yes"; shift 1
        ;;
    "-v"|"--verbose")
        verbose="yes"; shift 1
        tarVerboseFlag="v"
        ;;
    "-h"|"--help")
        printUsage
        exit 1
        ;;
    *)
        echo "Error: Cannot recognize parameter '$1'"
        echo
        printUsage
        exit 1
        ;;
    esac
done

# (re)configure settings based on command line
ssmPackageUrl="${ssmRepositoryUrl}/${ssmPackageName}.ssm"
pythonPackageUrl="${pythonRepositoryUrl}/${pythonPackageName}.ssm"

if [ ${verbose} = "yes" ]; then
    verboseOption="--verbose"
else
    verboseOption=""
fi

#
# main
#

# show settings
echo "                       Domain home: ${domainHome}"
echo "                             Label: ${label}"
echo "         Default repository source: ${defaultRepositorySource}"
echo "        Master Domain Owner (user): ${userName}"
echo "       Master Domain Owner (group): ${groupName}"
echo "                  Subscribe System: ${subscribeSystem}"
echo "                    Subscribe User: ${subscribeUser}"
echo
echo "                SSM Repository URL: ${ssmRepositoryUrl}"
echo "                  SSM package Name: ${ssmPackageName}"
echo
echo "       Install and publish python?: ${installAndPublishPython}"
echo "             Python repository URL: ${pythonRepositoryUrl}"
echo "               Python package Name: ${pythonPackageName}"
echo
echo "                Running as user/id: ${whoami}/${uid}"
echo

# get authorization (must use sh)
if [ ${force} != "yes" ]; then
    #read "Continue [y/n]? " reply
    ${printfExec} "Continue [y/n]? "
    read reply

    if [ ${reply} != "y" -a ${reply} != "Y" ]; then
        echo "Exiting."
        exit 1
    fi
fi

# setup su command
#if [ ${whoami} = "root" ]; then
if [ ${uid} = "0" ]; then
    userSuCmd="${suExec} ${userName} -c"
else
    userSuCmd="${shExec} -c"
fi

# create temporary working area
tmpDir="/tmp/ssm-install.$$"
${mkdirExec} ${tmpDir}
cd ${tmpDir}

# download ssm
downloadPackage "${ssmPackageName}" "${ssmPackageUrl}"
ssmPackageFilePath="${tmpDir}/${ssmPackageName}.ssm"

# download python
if [ "${installAndPublishPython}" = "yes" ]; then
    downloadPackage "${pythonPackageName}" "${pythonPackageUrl}"
    pythonPackageFilePath="${tmpDir}/${pythonPackageName}.ssm"
fi

# create domain home (need to be root?)
echo "Creating partial domain at ${domainHome} (executing as root)."
if [ ${chownDomainHome} = "yes" ]; then
    ${suExec} root -c "${mkdirExec} -p ${domainHome}; chown ${userName}:${groupName} ${domainHome}"
else
    ${mkdirExec} -p ${domainHome}
fi

# install ssm
echo "Installing ssm."
${userSuCmd} "cd ${domainHome}; gzip -dc ${ssmPackageFilePath} | tar xf${tarVerboseFlag} -"
#echo "Adding ssm to PATH."
#export PATH=${domainHome}/${ssmPackageName}/bin:${PATH}

# install python
if [ "${installAndPublishPython}" = "yes" ]; then
    echo "Installing python."
    ${userSuCmd} "cd ${domainHome}; gzip -dc ${pythonPackageFilePath} | tar xf${tarVerboseFlag} -; mv ${pythonPackageName} ${pythonPackageName}_x"
    #echo "Adding python to PATH."
    #export PATH=${domainHome}/${pythonPackageName}_x/bin:${PATH}
    pythonExec="${domainHome}/${pythonPackageName}_x/bin/python"
fi

# configure for ssm executable
ssmExec="${pythonExec} ${domainHome}/${ssmPackageName}/bin/ssm"

# create domain using ssm
echo "Creating full domain at ${domainHome}."
export SSM_SYSTEM_DOMAIN_HOME=${domainHome} # special case for installer, force to use domainHome
${userSuCmd} "${ssmExec} created --domainHome \"${domainHome}\" --label \"${label}\" --defaultRepositorySource \"${defaultRepositorySource}\" --force ${verboseOption}"
if [ $? -ne 0 ]; then
    echo "Error: Exiting."
    exit -1
fi

if [ "${subscribeSystem}" = "yes" ]; then
    echo "Subscribing domain with system (executing as root)."
    # hack to compile ssm_subscribe as user, not root
    ${userSuCmd} "${ssmExec} subscribe -h > /dev/null 2>&1"
    ${suExec} root -c "${ssmExec} subscribe -d \"${domainHome}\" --system --force ${verboseOption}"
elif [ "${subscribeUser}" = "yes" ]; then
    echo "Subscribing domain with user."
    ${userSuCmd} "${ssmExec} subscribe -d \"${domainHome}\" --user --force ${verboseOption}"
fi

# re-install ssm
echo "Reinstalling ssm."
${userSuCmd} "${ssmExec} install --domainHome \"${domainHome}\" -p \"${ssmPackageName}\" -u \"${ssmRepositoryUrl}\" --force --clobber ${verboseOption}"
echo "Publishing ssm."
${userSuCmd} "${ssmExec} publish --domainHome \"${domainHome}\" -p \"${ssmPackageName}\" --force ${verboseOption}"

# re-install python
if [ "${installAndPublishPython}" = "yes" ]; then
    echo "Reinstalling python."
    ${userSuCmd} "${ssmExec} install --domainHome=\"${domainHome}\" -p \"${pythonPackageName}\" -u \"${pythonRepositoryUrl}\" --force --clobber ${verboseOption}"
    echo "Publishing python."
    ${userSuCmd} "${ssmExec} publish --domainHome=\"${domainHome}\" -p \"${pythonPackageName}\" --force ${verboseOption}"
fi

# clean up
echo "Cleaning up."
cd /tmp
${rmExec} -rf "${domainHome}/${pythonPackageName}_x"
${rmExec} -rf "${tmpDir}"