#!/bin/bash

clean=0
build=0
while [ x"$1" != x ] ; do
    case $1 in
        clean) clean=1
            shift
            continue;;
        build) build=1
            shift
            continue;;
        *)  echo "argument '$1' ignored"
            shift
            continue;;
    esac
done


echo "------------------------ Settings ---------------------------------------"

##
## In case you configured "install-ns.sh" to use a different
## "ns_install_dir", provide this as well to this script via shell
## variables, such one can use
##
##     ns_install_dir=/opt/.... bash install-oacs.sh ...
##
ns_install_dir=${ns_install_dir:-/usr/local/ns}


#
# The following names are CVS tag mostly relevant for checkouts from
# CVS, but as well for naming the service.
#
#   HEAD:
#     the newest version, often not intended to be runable
#
#   oacs-x-y:
#      the newest version of the oacs-x-y branch
#      (not necessarily "released")
#
#   oacs-x-y-compat:
#      the newest "released" version of the oacs-x-y branch
#
#   openacs-x-y-z-final:
#      the version of the packages at the time OpenACS x.y.z was
#      released (similar to a tar file produced at the time of
#      a release of the main OpenACS packages).
#
# One can obtain the OpenACS sources either via tar file or via
# CVS. When "oacs_tar_release_url" is nonempty, it is used and the CVS tags
# are ignored. Otherwise, a checkout from CVS is used based
# on "oacs_core_tag" and "oacs_packages_tag".
#
#oacs_version=5-9-1
oacs_version=${oacs_version:-5-10-0}
#oacs_version=HEAD

#oacs_core_tag=HEAD
#oacs_core_tag=oacs-5-9
#oacs_core_tag=oacs-5-10
oacs_core_tag=${oacs_core_tag:-openacs-5-10-compat}
#oacs_core_tag=openacs-5-9-0-final

#oacs_packages_tag=HEAD
#oacs_packages_tag=oacs-5-9
#oacs_packages_tag=oacs-5-10
oacs_packages_tag=${oacs_packages_tag:-openacs-5-10-compat}
#oacs_packages_tag=openacs-5-9-0-final

oacs_tar_release=${oacs_tar_release:-openacs-5.10.0}
#oacs_tar_release_url=https://openacs.org/projects/openacs/download/download/openacs-full-5.10.0.tar.gz?revision_id=5537440
oacs_tar_release_url=${oacs_tar_release_url:-}

oacs_service=${oacs_service:-oacs-${oacs_version}}
oacs_dir=${oacs_dir:-/var/www/${oacs_service}}
install_dotlrn=${install_dotlrn:-0}

db_name=${db_name:-$oacs_service}
db_host=${db_host:-localhost}
db_port=${db_port:-5432}

#
# Install OpenACS as a service if desired.  As service managers are
# either systemd or upstart (which is mostly outdated by now).
#
install_as_service=${install_as_service:-1}

pg_dir=${pg_dir:-/usr/}
#pg_dir=/usr/local/pgsql

#
# End of configuration block.
#

source ${ns_install_dir}/lib/nsConfig.sh
if [ "$ns_user" = "" ] ; then
    echo "could not determine ns_user from  ${ns_install_dir}/lib/nsConfig.sh"
    exit
fi
echo "Loaded definitions from ${ns_install_dir}/lib/nsConfig.sh"

#
# Inherited/derived variables, you might override some of these here:
#
#build_dir=/usr/local/src
#with_postgres=1
#ns_src_dir=/usr/local/src/naviserver-4.99.29

oacs_user=${ns_user}
oacs_group=${ns_group}

if [ "${version_ns}" = "HEAD" ] || [ "${version_ns}" = "GIT" ] ; then
    ns_src_dir=${build_dir}/naviserver
else
    ns_src_dir=${build_dir}/naviserver-${version_ns}
fi
modules_src_dir=${build_dir}/modules

export LANG=en_US.UTF-8
export LC_ALL=en_US.UTF-8

echo "
OpenACS Installation Script

This script configures a pre-installed PostgreSQL instance for OpenACS
and installs the core system along with the essential OpenACS
packages. For CVS-based installations, it also installs xowiki, xowf,
and optionally dotlrn; for tar-based installations, these packages can
be added using the “install from repository” option. Additionally, the
script generates a configuration file and startup scripts for the
Debian (Ubuntu) family and the RedHat family (Fedora Core, Roxy
Linux). It assumes that NaviServer is already installed via install-ns.sh,
since it uses its installation variables.

Tested on Ubuntu 12.04, 13.04, 14.04, 16.04, 18.04, 20.04, 22.04,
Debian bookworm, Fedora Core 18, 20, 32, 35, CentOS 7, Roxy Linux 8.4

(c) 2013-2025 Gustaf Neumann

LICENSE    This program comes with ABSOLUTELY NO WARRANTY;
           This is free software, and you are welcome to redistribute it under certain conditions;
           For details see http://www.gnu.org/licenses.

SETTINGS   OpenACS version tag          ${oacs_core_tag}
           OpenACS packages tag         ${oacs_packages_tag}
           OpenACS tar release URL      ${oacs_tar_release_url}
           OpenACS directory            ${oacs_dir}
           OpenACS service              ${oacs_service}
           OpenACS user                 ${oacs_user}
           OpenACS group                ${oacs_group}
           PostgreSQL directory         ${pg_dir}
           Database name                ${db_name}
           NaviServer install directory ${ns_install_dir}
           NaviServer src directory     ${ns_src_dir}
           NaviServer modules directory ${modules_src_dir}
           Install DotLRN               ${install_dotlrn}
           With PostgreSQL              ${with_postgres}
           PostgreSQL user              ${pg_user}
           Make command                 ${make}
           Type command                 ${type}
           Install as a service         ${install_as_service}
"

if [ "$build" = "0" ] ; then
    echo "
WARNING    Check Settings AND Cleanup section before running this script!
           If you know what you're doing then call the call the script as
              bash $0 build
"
exit
fi

echo "------------------------ Cleanup -----------------------------------------"
# First we clean up

# The cleanup on ${oacs_dir} might be optional, since it can
# delete something else not from our installation.

#rm -r ${oacs_dir}

# just clean?
if [ "$clean" = "1" ] ; then
  exit
fi

echo "------------------------ Check System ----------------------------"
if  [ "$macosx" = "1" ] ; then
    group_listcmd="dscl . list /Groups | grep ${oacs_group}"
    group_addcmd="dscl . create /Groups/${oacs_group}"
    oacs_user_addcmd="dscl . create /Users/${oacs_user};dseditgroup -o edit -a ${oacs_user} -t user ${oacs_group}"
    pg_user_addcmd="dscl . create /Users/${pg_user};dscl . create /Users/${pg_user} UserShell /bin/bash"
    pg_dir=/opt/local
else
    group_listcmd="grep ${oacs_group} /etc/group"
    group_addcmd="groupadd ${oacs_group}"
    oacs_user_addcmd="useradd -g ${oacs_group} ${oacs_user}"
    pg_user_addcmd="useradd -s /bin/bash ${pg_user}"
    if  [ "$sunos" = "1" ] ; then
       pkg install pkg:/omniti/database/postgresql-927/hstore
       pg_dir=/opt/pgsql927
    fi
fi

if [ "$redhat" = "1" ] ; then

    if [ -x "/usr/bin/dnf" ] ; then
        pkgmanager=/usr/bin/dnf
    else
        pkgmanager=yum
    fi

    if [ "$with_postgres" = "1" ] ; then
        ${pkgmanager} install postgresql-server
    fi
    running=$(ps ax|fgrep postgres:)
    if [ "$running" = "" ] ; then
        echo "PostgreSQL is not running. You might consider to initialize PostgreSQL"
        echo "    service postgresql initdb"
        echo "and/or to start the database"
        echo "    service postgresql start"
        echo "and rerun this script"
        exit
    fi
elif [ "$debian" = "1" ] ; then
    if [ "$with_postgres" = "1" ] ; then
        apt-get install postgresql postgresql-contrib
    fi
elif  [ "$sunos" = "1" ] ; then
    if [ "$with_postgres" = "1" ] ; then
        running=$(ps ax|fgrep "/postgres ")
        if [ "$running" = "" ] ; then
            echo "Postgres is NOT running. Please start the PostgreSQL server first"
        fi
    fi
fi

echo "------------------------ Check Userids ----------------------------"

group=$(eval ${group_listcmd})
echo "${group_listcmd} => $group"
if [ "x$group" = "x" ] ; then
    eval ${group_addcmd}
fi

id=$(id -u ${oacs_user})
if [ $? != "0" ] ; then
    if  [ "$debian" = "1" ] ; then
        eval ${oacs_user_addcmd}
    else
        echo "User ${oacs_user} does not exist; you might add it with something like"
        echo "     ${oacs_user_addcmd}"
        exit
    fi
fi

if [ "$with_postgres" != "0" ] ; then
    id=$(id -u ${pg_user})
    if [ $? != "0" ] ; then
        echo "User ${pg_user} does not exist; you should add it via installing postgres"
        echo "like e.g. under Ubuntu with "
        echo "     apt-get install postgresql postgresql-contrib"
        echo "alternatively you might create the use with e.g."
        echo "     ${pg_user_addcmd}"
        exit
    fi
fi

#
# Perform this setup only, when we are sure to connect later to the
# same database.  We assume, that PostgreSQL is installed and
# already running on port 5432, and users ${pg_user} and ${oacs_user}
# and group ${oacs_group} are created
#
if [ "$with_postgres" != "0" ] ; then

    echo "------------------------ Setup Database ----------------------------"

    cd /tmp
    set -o errexit

    echo "Checking if oacs_user ${oacs_user} exists in db."
    dbuser_exists=$(su ${pg_user} -c "${pg_dir}/bin/psql -h $db_host -p $db_port template1 -tAc \"SELECT 1 FROM pg_roles WHERE rolname='${oacs_user}'\"")
    if [ "$dbuser_exists" != "1" ] ; then
        echo "Creating oacs_user ${oacs_user}."
        su ${pg_user} -c "${pg_dir}/bin/createuser -h $db_host -p $db_port -s -d ${oacs_user}"
    fi

    echo "Checking if db ${db_name} exists."
    db_exists=$(su ${pg_user} -c "${pg_dir}/bin/psql -h $db_host -p $db_port template1 -tAc \"SELECT 1 FROM pg_database WHERE datname='${db_name}'\"")
    if [ "$db_exists" != "1" ] ; then
        echo "Creating db ${db_name}."
        su ${pg_user} -c "${pg_dir}/bin/createdb -h $db_host -p $db_port -E UNICODE ${db_name}"
        #
        # The preferred way is to install via create extension
        #
        #hstoreSql=${pg_dir}/share/postgresql/contrib/hstore.sql
        #if [ -f ${hstoreSql} ] ; then
        #	su ${pg_user} -c "${pg_dir}/bin/psql -h $db_host -p $db_port -d ${db_name} -f ${hstoreSql}"
        #fi
        su ${pg_user} -c "${pg_dir}/bin/psql -h $db_host -p $db_port -d $db_name -tAc \"create extension hstore\""
    fi
fi

echo "------------------------ Download OpenACS ----------------------------"
set +o errexit

if [ "$oacs_tar_release_url" = "" ] ; then
    #
    # We use CVS for obtaining OpenACS
    #
    cvspath=$(${type} cvs)
    if [ "$cvspath" = "" ] ; then
        if [ "$debian" = "1" ] ; then
            apt-get install cvs
        elif [ "$redhat" = "1" ] ; then
            ${pkgmanager} install cvs
        elif [ "$archlinux" = "1" ] ; then
            pacman -Sy --noconfirm cvs
        elif [ "$sunos" = "1" ] ; then
            # why is there no CVS available via "pkg install" ?
            cd ${build_dir}
            if [ ! -f cvs-1.11.23.tar.gz ] ; then
                wget http://ftp.gnu.org/non-gnu/cvs/source/stable/1.11.23/cvs-1.11.23.tar.gz
            fi
            tar zxvf cvs-1.11.23.tar.gz
            cd cvs-1.11.23
            ./configure --prefix=/usr/gnu
            ${make}
            ${make} install
        else
            echo "CVS is not installed; you might install it with"
            echo "    apt-get install cvs"
            exit
        fi
    fi
fi

mkdir -p ${oacs_dir}
mkdir -p ${oacs_dir}/log
cd ${oacs_dir}

if [ "$oacs_tar_release_url" = "" ] ; then

    cvs -q -d:pserver:anonymous@cvs.openacs.org:/cvsroot checkout -r ${oacs_core_tag} acs-core
    if [ ! -d "www" ] ; then
        ln -sf $(echo openacs-4/[a-z]*) .
    fi

    cd ${oacs_dir}/packages
    cvs -d:pserver:anonymous@cvs.openacs.org:/cvsroot -q checkout -r ${oacs_packages_tag} xotcl-all
    cvs -d:pserver:anonymous@cvs.openacs.org:/cvsroot -q checkout -r ${oacs_packages_tag} xowf
    cvs -d:pserver:anonymous@cvs.openacs.org:/cvsroot -q checkout -r ${oacs_packages_tag} acs-developer-support ajaxhelper attachments richtext-ckeditor4

    if [ "$install_dotlrn" = "1" ] ; then
        cvs -d:pserver:anonymous@cvs.openacs.org:/cvsroot -q checkout -r ${oacs_packages_tag} dotlrn-all
    fi
    cd ${oacs_dir}

    cp ${oacs_dir}/packages/acs-bootstrap-installer/installer/www/*.* ${oacs_dir}/www/
    mkdir -p ${oacs_dir}/www/SYSTEM/
    cp ${oacs_dir}/packages/acs-bootstrap-installer/installer/www/SYSTEM/*.* ${oacs_dir}/www/SYSTEM
    cp ${oacs_dir}/packages/acs-bootstrap-installer/installer/tcl/*.* ${oacs_dir}/tcl/
else
    curl -L -s -k -o ${oacs_tar_release}.tar.gz ${oacs_tar_release_url}
    tar zxvf ${oacs_tar_release}.tar.gz
    ln -sf ${oacs_tar_release}/* .
fi


# install nsstats
mkdir -p ${oacs_dir}/www/admin/
cp ${modules_src_dir}/nsstats/nsstats.tcl ${oacs_dir}/www/admin/

#
# add self-signed certificate
#
certfile=${oacs_dir}/etc/certfile.pem
echo "check for certfile ${certfile}"
if [ ! -f "${certfile}" ] ; then
    echo "certfile ${certfile} does not exist"
    cd /tmp
    openssl genrsa 1024 > host.key
    openssl req -new -x509 -nodes -sha1 -days 365 -key host.key -subj /CN=localhost > host.cert
    cat host.cert host.key > server.pem
    rm -rf host.cert host.key
    #openssl dhparam 2048 >> server.pem
    mv server.pem ${certfile}
    cd ${oacs_dir}
fi

chown -R ${oacs_user}:${oacs_group} ${oacs_dir}
chmod -R g+w ${oacs_dir}


#
# Install and adapt NaviServer config file and
# install startup file, if desired
#
if [ "$install_as_service" = "1" ] ; then
    echo "Writing ${ns_install_dir}/config-${oacs_service}.tcl"
    cp ${ns_src_dir}/openacs-config.tcl ${ns_install_dir}/config-${oacs_service}.tcl
    cat << EOF > /tmp/subst.tcl
 set fn ${ns_install_dir}/config-${oacs_service}.tcl
 set file [open \$fn]; set c [read \$file] ; close \$file
 regsub -all {"openacs"} \$c {"${oacs_service}"} c
 regsub -all {/usr/local/ns} \$c {${ns_install_dir}} c
 regsub -all {(\\s+)db_user\\s+\\\$server} \$c {\\1db_user ${oacs_user}} c
 set file [open \$fn w]; puts -nonewline \$file \$c; close \$file
EOF
    ${ns_install_dir}/bin/tclsh /tmp/subst.tcl

    systemd=0
    upstart=0

    if [ "$redhat" = "1" ] || [ "$archlinux" = "1" ] ; then
        systemd=1
    fi

    if [ "$debian" = "1" ] ; then
        #
        # Check, if the debian release still has /etc/init. If so, on can
        # generate the upstart file.
        #
        if [ -d "/etc/init" ] ; then
            upstart=1
        fi

        #
        # Nowadays, most debian releases support systemd.
        #
        if [ -f "/etc/lsb-release" ] ; then
            . /etc/lsb-release
            if dpkg --compare-versions "$DISTRIB_RELEASE" "ge" "15.04" ; then
                systemd=1
            fi
        elif [ -d "/lib/systemd/system" ] ; then
            systemd=1
        fi
    fi


    if [ "$systemd" = "1" ] ; then
        echo "Writing /lib/systemd/system/${oacs_service}.service"
        cat <<EOF > /lib/systemd/system/${oacs_service}.service
[Unit]
Description=OpenACS/Naviserver
After=network.target postgresql.service
Wants=postgresql.service

[Service]
Type=forking
PIDFile=${oacs_dir}/log/nsd.pid
Environment="LANG=en_US.UTF-8"
# In case, a site is using Google Perfortools malloc with the system-malloc patch for Tcl:
# Environment="LD_PRELOAD=/usr/lib64/libtcmalloc.so"
ExecStartPre=/bin/rm -f ${oacs_dir}/log/nsd.pid

# standard startup (non-privileged port, like 8000)
ExecStart=${ns_install_dir}/bin/nsd -u ${oacs_user} -g ${oacs_group} -t ${ns_install_dir}/config-${oacs_service}.tcl

# startup for privileged port, like 80
# ExecStart=${ns_install_dir}/bin/nsd -u ${oacs_user} -g ${oacs_group} -t ${ns_install_dir}/config-${oacs_service}.tcl -b YOUR.IP.ADDRESS:80

# Use "Restart=always" to make the instance start up again after it has stopped via ns_shutdown (e.g. /acs-admin/server-restart).
Restart=on-abnormal
KillMode=process

[Install]
# Uncomment this if the service should start automatically after system reboots.
#WantedBy=multi-user.target
EOF
    fi

    if [ "$upstart" = "1" ] ; then
        # Create automatically a configured upstart script into /etc/init/ ...
        echo "Writing /etc/init/${oacs_service}.conf"
        cat <<EOF > /etc/init/${oacs_service}.conf
# /http://upstart.ubuntu.com/wiki/Stanzas

description "OpenACS/NaviServer"
start on stopped rc
stop on runlevel S

respawn
umask 002
env LANG=en_US.UTF-8

pre-start script
  until sudo -u ${pg_user} ${pg_dir}/bin/psql -h $db_host -p $db_port -l ; do sleep 1; done
end script

script

  # In case, a site is using Google Perfortools malloc with the system-malloc patch for Tcl:
  # export LD_PRELOAD="/usr/lib/libtcmalloc.so"

  # standard startup (non-privileged port, like 8000)
  exec ${ns_install_dir}/bin/nsd -i -t ${ns_install_dir}/config-${oacs_service}.tcl -u ${oacs_user} -g ${oacs_group}

  # startup for privileged port, like 80
  #exec /usr/local/oo2/bin/nsd -i -t /usr/local/oo2/config-wi1.tcl -u ${oacs_user} -g ${oacs_group} -b YOUR.IP.ADDRESS:80

end script
EOF
    fi
fi


echo "
Congratulations, you have installed OpenACS with NaviServer on your machine.
You might start the server manually with

    sudo ${ns_install_dir}/bin/nsd -t ${ns_install_dir}/config-${oacs_service}.tcl -u ${oacs_user} -g ${oacs_group}"
if [ "$systemd" = "1" ] ; then
echo "
or you can manage your installation with systemd. In this case,
you might use the following commands

    systemctl status ${oacs_service}
    systemctl start ${oacs_service}
    systemctl stop ${oacs_service}
"
elif [ "$upstart" = "1" ] ; then
echo "
or you can manage your installation with upstart (Ubuntu/Debian). In this case,
you might use the following commands

    status ${oacs_service}
    start ${oacs_service}
    stop ${oacs_service}
"
fi

if [ "$install_as_service" = "1" ] ; then
    echo "
After starting the server, you can use OpenACS by loading
http://localhost:8000/ from a browser. The NaviServer
configuration file  is ${ns_install_dir}/config-${oacs_service}.tcl
and might be tailored to your needs. The access.log and error.log
of this instance are in ${oacs_dir}/log

"
fi