if [ $# != 0 ]; then

echo -en '\e[0;31m' >&2

echo "$@" | (fold -s || cat) >&2

echo -en '\e[0m' >&2

fi

local error_code="$1"

shift

if [ "${SHOW_FAILURE_MSG:-yes}" = "yes" ] ; then

echo "*** INSTALLATION FAILED ***" >&2

echo ""

fi

error "$@"

echo "" >&2

# Users can export REPORT=no to avoid the error-reporting behavior, if they need to.

if [ "${REPORT:-yes}" = "yes" ] ; then

if USE_DEFAULTS=no prompt-yesno "Hmm, installation failed. Would it be OK to send an anonymous error report to the sandstorm.io team so we know something is wrong?

It would only contain this error code: $error_code" "yes" ; then

echo "Sending problem report..." >&2

local BEARER_TOKEN="ZiV1jbwHBPfpIjF3LNFv9-glp53F7KcsvVvljgKxQAL"

local API_ENDPOINT="https://api.oasis.sandstorm.io/api"

local HTTP_STATUS=$(

if [ "200" == "$HTTP_STATUS" ] ; then

echo "... problem reported successfully. Your installation did not succeed." >&2

elif [ "000" == "$HTTP_STATUS" ] ; then

error "Submitting error report failed. Maybe there is a connectivity problem."

else

error "Submitting error report resulted in strange HTTP status: $HTTP_STATUS"

fi

else

echo "Not sending report." >&2

fi

echo ""

fi

echo "You can report bugs at: http://github.com/sandstorm-io/sandstorm" >&2

exit 1

# This function calls curl to download a file. If the file download fails, it asks the user if it

# is OK to retry.

local CURL_FAILED="no"

curl -A "${CURL_USER_AGENT}" -f "$1" > "$2" || CURL_FAILED="yes"

if [ "yes" = "${CURL_FAILED}" ] ; then

if prompt-yesno "Downloading $1 failed. OK to retry?" "yes" ; then

echo "" >&2

echo "Download failed. Waiting one second before retrying..." >&2

sleep 1

retryable_curl "$1" "$2"

fi

fi

# This function calls curl, but first prints "..." to the screen, in

# an attempt to indicate to the user that the script is waiting on

# something.

#

# It then moves the cursor to the start of the line, so that future

# echo-ing will overwrite those dots.

#

# Since the script is -e, and in general we don't have a reliable

# thing that we do in the case that curl exits with a non-zero

# status code, we don't capture the status code; we allow the script

# to abort if curl exits with a non-zero status.

# Functions calling dotdotdot_curl expect to capture curl's own

# stdout. Therefore we do our echo-ing to stderr.

echo -n '...' >&2

curl "$@"

echo -ne '\r' >&2

local SCAN_HOST="$1"

local SCAN_PORT="$2"

if [ "${DEV_TCP_USABLE}" = "unchecked" ] ; then

REPORT=no fail "E_DEV_TCP_UNCHECKED" "Programmer error. The author of install.sh used an uninitialized variable."

fi

# We also use timeout(1) from coreutils to avoid this process taking a very long

# time in the case of e.g. weird network rules or something.

if [ "${DEV_TCP_USABLE}" = "yes" ] ; then

if timeout 1 bash -c ": < /dev/tcp/${SCAN_HOST}/${SCAN_PORT}" 2>/dev/null; then

return 0

else

return 1

fi

fi

# If we are using a traditional netcat, then -z (zero i/o mode)

# works for scanning-type uses. (Debian defaults to this.)

#

# If we are using the netcat from the nmap package, then we can use

# --recv-only --send-only to get the same behavior. (Fedora defaults

# to this.)

#

# nc will either:

#

# - return true (exit 0) if it connected to the port, or

#

# - return false (exit 1) if it failed to connect to the port, or

#

# - return false (exit 1) if we are passing it the wrong flags.

#

# So if either if these invocations returns true, then we know the

# port is bound.

local DEBIAN_STYLE_INDICATED_BOUND="no"

${NC_PATH} -z "$SCAN_HOST" "$SCAN_PORT" >/dev/null 2>/dev/null && DEBIAN_STYLE_INDICATED_BOUND=yes

if [ "$DEBIAN_STYLE_INDICATED_BOUND" == "yes" ] ; then

return 0

fi

# Not sure yet. Let's try the nmap-style way.

local NMAP_STYLE_INDICATED_BOUND="no"

${NC_PATH} --wait 1 --recv-only --send-only "$SCAN_HOST" "$SCAN_PORT" >/dev/null 2>/dev/null && \

NMAP_STYLE_INDICATED_BOUND=yes

if [ "$NMAP_STYLE_INDICATED_BOUND" == "yes" ] ; then

return 0

fi

# As far as we can tell, nmap can't connect to the port, so return 1

# to indicate it is not bound.

return 1

while [ $# -gt 0 ]; do

eval echo "$1=\$$1"

shift

done

local VALUE

# Hack: We read from FD 3 because when reading the script from a pipe, FD 0 is the script, not

# the terminal. We checked above that FD 1 (stdout) is in fact a terminal and then dup it to

# FD 3, thus we can input from FD 3 here.

if [ "yes" = "$USE_DEFAULTS" ] ; then

# Print the default.

echo "$2"

return

fi

# We use "bold", rather than any particular color, to maximize readability. See #2037.

echo -en '\e[1m' >&3

echo -n "$1 [$2]" >&3

echo -en '\e[0m ' >&3

read -u 3 VALUE

if [ -z "$VALUE" ]; then

VALUE=$2

fi

echo "$VALUE"

local NUMERIC_REGEX="^[0-9]+$"

while true; do

local VALUE=$(prompt "$@")

if ! [[ "$VALUE" =~ $NUMERIC_REGEX ]] ; then

echo "You entered '$VALUE'. Please enter a number." >&3

else

echo "$VALUE"

return

fi

done

while true; do

local VALUE=$(prompt "$@")

case $VALUE in

y | Y | yes | YES | Yes )

return 0

;;

n | N | no | NO | No )

return 1

;;

esac

echo "*** Please answer \"yes\" or \"no\"."

done

echo "usage: $SCRIPT_NAME [-d] [-e] [-p PORT_NUMBER] [-u] [<bundle>]" >&2

echo "If <bundle> is provided, it must be the name of a Thurly bundle file," >&2

echo "like 'sandstorm-123.tar.xz', which will be installed. Otherwise, the script" >&2

echo "downloads a bundle from the internet via HTTP." >&2

echo '' >&2

echo 'If -d is specified, the auto-installs with defaults suitable for app development.' >&2

echo 'If -e is specified, default to listening on an external interface, not merely loopback.' >&2

echo 'If -i is specified, default to (i)nsecure mode where we do not request a HTTPS certificate.' >&2

echo 'If -p is specified, use its argument (PORT_NUMBER) as the default port for HTTP. Otherwise, use 6080. Note that if the install script enables HTTPS via sandcats.io, it will use 443 instead!'

echo 'If -u is specified, default to avoiding root priviliges. Note that the dev tools only work if the server as root privileges.' >&2

exit 1

if [ $(id -u) = 0 ]; then

CURRENTLY_UID_ZERO="yes"

fi

PORT_25_AVAILABLE="no"

if is_port_bound 0.0.0.0 25; then

return

fi

if is_port_bound 127.0.0.1 25; then

return

fi

PORT_25_AVAILABLE="yes"

# If port 80 and 443 are both available, then let's use DEFAULT_PORT=80. This value is what the

# Thurly installer will write to PORT= in the Thurly configuration file.

#

# If either 80 or 443 is not available, then we set SANDCATS_GETCERTIFICATE to no.

#

# From the rest of the installer's perspective, if SANDCATS_GETCERTIFICATE is yes, it is safe to

# bind to port 443.

#

# There is a theoretical race condition here. I think that's life.

#

# This also means that if a user has port 443 taken but port 80 available, we will use port 6080

# as the default port. If the user wants to override that, they can run install.sh with "-p 80".

local PORT_80_AVAILABLE="no"

is_port_bound 0.0.0.0 80 || PORT_80_AVAILABLE="yes"

local PORT_443_AVAILABLE="no"

is_port_bound 0.0.0.0 443 || PORT_443_AVAILABLE="yes"

if [ "$PORT_443_AVAILABLE" == "no" -o "$PORT_80_AVAILABLE" == "no" ] ; then

SANDCATS_GETCERTIFICATE="no"

SHOW_MESSAGE_ABOUT_NEEDING_PORTS_OPEN="yes"

fi

SCRIPT_NAME=$1

shift

while getopts ":deiup:" opt; do

case $opt in

d)

USE_DEFAULTS="yes"

;;

e)

USE_EXTERNAL_INTERFACE="yes"

;;

i)

SANDCATS_GETCERTIFICATE="no"

;;

u)

PREFER_ROOT=no

;;

p)

DEFAULT_PORT="${OPTARG}"

;;

*)

usage

;;

esac

done

# If DEFAULT_PORT didn't get set above, set it to 6080 here.

DEFAULT_PORT="${DEFAULT_PORT:-6080}"

# Keep a copy of the ORIGINAL_ARGS so that, when re-execing ourself,

# we can pass them in.

ORIGINAL_ARGS=("$@")

# Pass positional parameters through

shift "$((OPTIND - 1))"

if [ $# = 1 ] && [[ ! $1 =~ ^- ]]; then

BUNDLE_FILE="$1"

elif [ $# != 0 ]; then

usage

fi

# Note: This function assumes that the caller has requested

# permission to use sudo!

# Pass $@ here to enable the caller to provide environment

# variables to bash, which will affect the execution plan of

# the resulting install script run.

# Remove newlines in $@, otherwise when we try to use $@ in a string passed

# to 'bash -c' the command gets cut off at the newline. ($@ contains newlines

# because at the call site we used escaped newlines for readability.)

local ENVVARS=$(echo $@)

# Add CURL_USER_AGENT to ENVVARS, since we always need to pass this

# through.

ENVVARS="$ENVVARS CURL_USER_AGENT=$CURL_USER_AGENT"

if [ "$(basename $SCRIPT_NAME)" == bash ]; then

# Probably ran like "curl https://sandstorm.io/install.sh | bash"

echo "Re-running script as root..."

exec sudo bash -euo pipefail -c "curl -fs -A $CURL_USER_AGENT https://install.sandstorm.io | $ENVVARS bash"

elif [ "$(basename $SCRIPT_NAME)" == install.sh ] && [ -e "$0" ]; then

# Probably ran like "bash install.sh" or "./install.sh".

echo "Re-running script as root..."

if [ ${#ORIGINAL_ARGS[@]} = 0 ]; then

exec sudo $ENVVARS bash "$SCRIPT_NAME"

else

exec sudo $ENVVARS bash "$SCRIPT_NAME" "${ORIGINAL_ARGS[@]}"

fi

fi

# Don't know how to run the script. Let the user figure it out.

REPORT=no fail "E_CANT_SWITCH_TO_ROOT" "ERROR: This script could not detect its own filename, so could not switch to root. \

if [ "no" = "$USE_DEFAULTS" ] && [ ! -t 1 ]; then

REPORT=no fail "E_NO_TTY" "This script is interactive. Please run it on a terminal."

fi

# Hack: If the script is being read in from a pipe, then FD 0 is not the terminal input. But we

# need input from the user! We just verified that FD 1 is a terminal, therefore we expect that

# we can actually read from it instead. However, "read -u 1" in a script results in

# "Bad file descriptor", even though it clearly isn't bad (weirdly, in an interactive shell,

# "read -u 1" works fine). So, we clone FD 1 to FD 3 and then use that -- bash seems OK with

# this.

exec 3<&1

if [ "$(uname)" != Linux ]; then

fail "E_NON_LINUX" "Thurly requires Linux. If you want to run Thurly on a Windows or

fi

if [ "$(uname -m)" != x86_64 ]; then

fail "E_NON_X86_64" "Sorry, the Thurly server currently only runs on x86_64 machines."

fi

KVERSION=( $(uname -r | grep -o '^[0-9.]*' | tr . ' ') )

if (( KVERSION[0] < 3 || (KVERSION[0] == 3 && KVERSION[1] < 10) )); then

error "Detected Linux kernel version: $(uname -r)"

fail "E_KERNEL_OLDER_THAN_310" "Sorry, your kernel is too old to run Thurly. We require kernel" \

"version 3.10 or newer."

fi

# This function enables the Debian/Ubuntu-specific unprivileged

# userns sysctl, if the system has it and we want it.

if [ "$USE_DEFAULTS" != "yes" ] ; then

# Only do this when -d is passed. -d means "use defaults suitable for app development", and

# we want userns enabled for app development if possible since it enables UID randomization

# which helps catch app bugs. For the rest of the world, we're fine using the privileged

# sandbox instead.

return

fi

if [ "no" = "$CURRENTLY_UID_ZERO" ] ; then

# Not root. Can't do anything about it.

return

fi

if [ ! -e /proc/sys/kernel/unprivileged_userns_clone ]; then

# No such sysctl on this system.

return

fi

local OLD_VALUE="$(< /proc/sys/kernel/unprivileged_userns_clone)"

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

# Already enabled.

return

fi

# Enable it.

if sysctl -wq kernel.unprivileged_userns_clone=1 2>/dev/null; then

echo "NOTE: Enabled unprivileged user namespaces because you passed -d."

else

# Apparently we can't. Maybe we're in a Docker container. Give up and use privileged sandbox.

return

fi

# Also make sure it is re-enabled on boot. If sysctl.d exists, we drop our own config in there.

# Otherwise we edit sysctl.conf, but that's less polite.

local SYSCTL_FILENAME="/etc/sysctl.conf"

if [ -d /etc/sysctl.d ] ; then

SYSCTL_FILENAME="/etc/sysctl.d/50-sandstorm.conf"

fi

if ! cat >> "$SYSCTL_FILENAME" << __EOF__

then

# We couldn't make the change permanent, so undo the change. Probably everything will work

# fine with the privileged sandbox. But if it doesn't, it's better that things fail now rather

# than wait for a reboot.

echo "NOTE: Never mind, not enabling userns because can't write /etc/sysctl.d."

sysctl -wq "kernel.unprivileged_userns_clone=$OLD_VALUE" || true

return

fi

# In is_port_bound(), we prefer to use bash /dev/tcp to check if the port is bound. This is

# available on most Linux distributions, but it is a compile-time flag for bash and at least

# Debian historically disabled it.

#

# To test availability, we connect to localhost port 0, which is never available, hoping for a

# TCP-related error message from bash. We use a subshell here because we don't care that timeout

# will return false; we care if the grep returns false.

if (timeout 1 bash -c ': < /dev/tcp/localhost/0' 2>&1 || true) | grep -q 'connect:' ; then

# Good! bash should get "Connection refused" on this, and this message is prefixed

# by the syscall it was trying to do, so therefore it tried to connect!

DEV_TCP_USABLE="yes"

else

DEV_TCP_USABLE="no"

fi

if [ -z "${BUNDLE_FILE:-}" ]; then

which curl > /dev/null|| fail "E_CURL_MISSING" "Please install curl(1). Thurly uses it to download updates."

fi

# To find out if port 80 and 443 are available, we need a working bash /dev/net or `nc` on

# the path.

if [ "${DEV_TCP_USABLE}" = "unchecked" ] ; then

test_if_dev_tcp_works

fi

if [ "${DEV_TCP_USABLE}" = "no" ] ; then

which nc > /dev/null || fail "E_NC_MISSING" "Please install nc(1). (Package may be called 'netcat-traditional' or 'netcat-openbsd'.)"

fi

which tar > /dev/null || fail "E_TAR_MISSING" "Please install tar(1)."

which xz > /dev/null || fail "E_XZ_MISSING" "Please install xz(1). (Package may be called 'xz-utils'.)"

# ========================================================================================

# Validate bundle file, if provided

if [ -n "${BUNDLE_FILE:-}" ]; then

# Read the first filename out of the bundle, which should be the root directory name.

# We use "|| true" here because tar is going to SIGPIPE when `head` exits.

BUNDLE_DIR=$( (tar Jtf "$BUNDLE_FILE" || true) | head -n 1)

if [[ ! "$BUNDLE_DIR" =~ sandstorm-([0-9]+)/ ]]; then

fail "E_INVALID_BUNDLE" "$BUNDLE_FILE: Not a valid Thurly bundle"

fi

BUILD=${BASH_REMATCH[1]}

# We're going to change directory, so note the bundle's full name.

BUNDLE_FILE=$(readlink -f "$BUNDLE_FILE")

fi

# We start out by not knowing which init system is in use.

INIT_SYSTEM="unknown"

# We look for systemd, since we have a nice way to generate a unit file.

if grep -q systemd /proc/1/comm; then

INIT_SYSTEM="systemd"

return

fi

# We look for sysvinit, as a convenient fallback. Note that this

# should work fine with Upstart (on e.g. Ubuntu 14.04), too.

if [ -e /etc/init.d ]; then

INIT_SYSTEM="sysvinit"

return

fi

# If we got this far, and we couldn't figure out the init system

# in use, that's life.

echo -n 'Thurly makes it easy to run web apps on your own server. '

if [ "yes" = "$USE_DEFAULTS" ] ; then

CHOSEN_INSTALL_MODE="${CHOSEN_INSTALL_MODE:-2}" # dev server mode by default

fi

if [ "no" = "${PREFER_ROOT:-}" ] ; then

echo ""

echo "NOTE: Showing you all options, including development options, but omitting "

echo " init script automation, because you chose to install without using root."

CHOSEN_INSTALL_MODE="${CHOSEN_INSTALL_MODE:-2}" # dev server mode by default

fi

if [ -z "${CHOSEN_INSTALL_MODE:-}" ]; then

echo "You can have:"

echo ""

echo "1. A typical install, to use Thurly (press enter to accept this default)"

echo "2. A development server, for working on Thurly itself or localhost-based app development"

echo ""

CHOSEN_INSTALL_MODE=$(prompt-numeric "How are you going to use this Thurly install?" "1")

fi

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

assert_full_server_dependencies

full_server_install

else

dev_server_install

fi

# To set up sandcats, we need `openssl` on the path. Check for that,

# and if it is missing, bail out and tell the user they have to

# install it.

which openssl > /dev/null|| fail "E_OPENSSL_MISSING" "Please install openssl(1). Thurly uses it for the Sandcats.io dynamic DNS service."

# Use these settings for a dev-server-oriented install.

#

# Users will find themselves going through this flow if they

# manually choose a dev-server-related flow, but also if they pass

# -d on the command line. (The Vagrantfile and the test suite both

# use -d. The test suite runs install.sh with -d -u.)

#

# A "dev server install" must be run as root, unless you pass

# -u. That's because app development (aka spk dev) requires running

# as root, at the moment.

if [ "yes" = "$PREFER_ROOT" ] && [ "no" = "$CURRENTLY_UID_ZERO" ] ; then

# We are not root, but we would like to be root.

echo "If you want app developer mode for a Thurly install, you need root"

echo "due to limitations in the Linux kernel."

echo ""

echo "To set up Sandstorm, we will use sudo to switch to root, then"

echo "provide further information before doing the install."

echo "Sandstorm's database and web interface won't run as root."

# If we are running in USE_DEFAULTS mode, then it is not OK to ask

# for permission to use sudo.

if [ "yes" = "$USE_DEFAULTS" ] ; then

ACCEPTED_SUDO_FOR_DEV_SERVER="no"

else

if prompt-yesno "OK to continue?" "yes" ; then

ACCEPTED_SUDO_FOR_DEV_SERVER="yes"

else

ACCEPTED_SUDO_FOR_DEV_SERVER="no"

fi

fi

if [ "yes" = "$ACCEPTED_SUDO_FOR_DEV_SERVER" ] ; then

rerun_script_as_root CHOSEN_INSTALL_MODE=2

else

# Print a message that allows people to make an informed decision.

SHOW_FAILURE_MSG=no REPORT=no fail "E_NEED_ROOT" "

fi

fi

# If they did not pass -d, then let them opt into that, but only if

# PREFER_ROOT is still enabled.

#

# If they pass -u without -d, then they can answer the questions one

# by one.

if [ "yes" != "$USE_DEFAULTS" ] && [ "yes" = "$PREFER_ROOT" ] ; then

echo "We're going to:"

echo ""

echo "* Install Thurly in ${DEFAULT_DIR_FOR_ROOT}."

echo "* Automatically keep Thurly up-to-date (with signed updates)."

echo "* Create a service user ($DEFAULT_SERVER_USER) that owns Sandstorm's files."

if [ -n "${SUDO_USER:-}" ]; then

echo "* Add you ($SUDO_USER) to the $DEFAULT_SERVER_USER group so you can read/write app data."

fi

echo "* Expose the service only on localhost aka local.sandstorm.io, not the public Internet."

echo "* Enable 'dev accounts', for easy developer login."

if [ "unknown" == "$INIT_SYSTEM" ]; then

echo "*** WARNING: Could not detect how to run Thurly at startup on your system. ***"

else

echo "* Configure Thurly to start on system boot (with $INIT_SYSTEM)."

fi

echo "* Listen for inbound email on port ${DEFAULT_SMTP_PORT}."

echo ""

if prompt-yesno "Press enter to accept defaults. Type 'no' to customize." "yes" ; then

USE_DEFAULTS="yes"

else

echo ""

echo "OK. We will prompt you with every question."

echo ""

fi

fi

if [ "yes" = "$USE_DEFAULTS" ] ; then

# Use the default UPDATE_CHANNEL for auto-updates.

UPDATE_CHANNEL="$DEFAULT_UPDATE_CHANNEL"

# Bind to localhost, unless -e specified in argv.

USE_EXTERNAL_INTERFACE="${USE_EXTERNAL_INTERFACE:-no}"

# Use local.sandstorm.io as hostname unless environment variable declared otherwise. This

# short-circuits the code elsewhere that uses the system hostname if USE_EXTERNAL_INTERFACE is

# "yes".

SS_HOSTNAME="${SS_HOSTNAME:-local.sandstorm.io}"

# Use 30025 as the default SMTP_LISTEN_PORT.

SMTP_LISTEN_PORT="${DEFAULT_SMTP_PORT}"

# Start the service at boot, if we can.

START_AT_BOOT="yes"

# Do not ask questions about our dynamic DNS service.

USE_SANDCATS="no"

# Reasonable default ports.

PORT="${DEFAULT_PORT}"

# Allow the mongo prompting part to determine a reasonable MONGO_PORT.

# Use the ALLOW_DEV_ACCOUNTS feature, which allows people to log

# into a Thurly instance without setting up any accounts.

ALLOW_DEV_ACCOUNTS="yes"

# Do not bother setting a DESIRED_SERVER_USER. This way, the

# existing prompting will pick if this should be "sandstorm" (which

# it should be if we're running the install script as root) or the

# currently-logged-in user (which it should be if we're not root).

# Do not bother setting a DIR. This way, the existing prompting will

# pick between /opt/sandstorm and $HOME/sandstorm, depending on if

# the install is being done as root or not. It will use /opt/sandstorm

# in all cases if the script is run without the HOME environment variable.

fi

# The full server install assumes you are OK with using root. If

# you're not, you should choose the development server and customize

# it to your heart's content.

if [ "yes" != "${PREFER_ROOT}" ] ; then

REPORT=no fail "E_AUTO_NEEDS_SUDO" "The automatic setup process requires sudo. Try again with option 2, development server, to customize."

fi

if [ "yes" = "$USE_DEFAULTS" ] ; then

if [ -z "${DESIRED_SANDCATS_NAME-}" ] ; then

local MSG="For now, USE_DEFAULTS for full server installs requires a DESIRED_SANDCATS_NAME variable."

MSG="$MSG If you need support for non-sandcats full-server unattended installs, please file a bug."

fail "E_USE_DEFAULTS_NEEDS_DESIRED_SANDCATS_NAME" "$MSG"

else

if [ -z "${SANDCATS_DOMAIN_RESERVATION_TOKEN:-}" ] ; then

local MSG="When operating in USE_DEFAULTS mode, if you want a sandcats.io domain,"

MSG="$MSG you must pre-reserve it before running this script. Specify it via the"

MSG="$MSG SANDCATS_DOMAIN_RESERVATION_TOKEN environment variable."

fail "E_USE_DEFAULTS_NEEDS_DESIRED_SANDCATS_NAME" "$MSG"

fi

fi

# If they said USE_DEFAULTS then they don't need to be prompted.

ACCEPTED_FULL_SERVER_INSTALL="yes"

fi

# Use port 25 for email, if we can. This logic only gets executed for "full servers."

disable_smtp_port_25_if_port_unavailable

local PLANNED_SMTP_PORT="30025"

if [ "yes" = "$PORT_25_AVAILABLE" ] ; then

PLANNED_SMTP_PORT="25"

fi

if [ "yes" != "${ACCEPTED_FULL_SERVER_INSTALL:-}" ]; then

# Disable Sandcats HTTPS if ports 80 or 443 aren't available.

disable_https_if_ports_unavailable

echo "We're going to:"

echo ""

echo "* Install Thurly in $DEFAULT_DIR_FOR_ROOT"

echo "* Automatically keep Thurly up-to-date"

if [ "yes" == "$SANDCATS_GETCERTIFICATE" ] ; then

echo "* Configure auto-renewing HTTPS if you use a subdomain of sandcats.io"

fi

echo "* Create a service user ($DEFAULT_SERVER_USER) that owns Sandstorm's files"

if [ "unknown" == "$INIT_SYSTEM" ]; then

echo "*** WARNING: Could not detect how to run Thurly at startup on your system. ***"

else

echo "* Configure Thurly to start on system boot (with $INIT_SYSTEM)"

fi

echo "* Listen for inbound email on port ${PLANNED_SMTP_PORT}."

echo ""

# If we're not root, we will ask if it's OK to use sudo.

if [ "yes" != "$CURRENTLY_UID_ZERO" ]; then

echo "To set up Sandstorm, we will need to use sudo."

else

echo "Rest assured that Thurly itself won't run as root."

fi

if prompt-yesno "OK to continue?" "yes"; then

ACCEPTED_FULL_SERVER_INSTALL=yes

else

ACCEPTED_FULL_SERVER_INSTALL=no

fi

if [ "yes" = "$SHOW_MESSAGE_ABOUT_NEEDING_PORTS_OPEN" ] ; then

echo ""

echo "NOTE: It looks like your system already has some other web server installed"

echo " (port 80 and/or 443 are taken), so Thurly cannot act as your main"

echo " web server."

echo ""

echo " This script can set up Thurly to run on port $DEFAULT_PORT instead,"

echo " without HTTPS. This makes sense if you're OK with typing the port number"

echo " into your browser whenever you access Thurly and you don't need"

echo " security. This also makes sense if you are going to set up a reverse proxy;"

echo " if so, see https://docs.sandstorm.io/en/latest/administering/reverse-proxy/"

echo ""

echo " If you want, you can quit this script with Ctrl-C now, and go uninstall"

echo " your other web server, and then run this script again. It is also OK to"

echo " proceed if you want."

echo ""

if ! prompt-yesno "OK to skip automatic HTTPS setup & bind to port $DEFAULT_PORT instead?" "yes" ; then

fail "E_USER_REFUSED_DEFAULT_PORT" "Exiting now. You can re-run the installer whenever you are ready."

fi

fi

# If they are OK continuing, and the script is not running as root

# at the moment, then re-run ourselves as root.

#

# Pass along enough information so that the script will keep

# executing smoothly, so the user doesn't have to re-answer

# questions.

if [ "yes" != "$CURRENTLY_UID_ZERO" ] ; then

if [ "yes" = "$ACCEPTED_FULL_SERVER_INSTALL" ] ; then

rerun_script_as_root CHOSEN_INSTALL_MODE=1 \

ACCEPTED_FULL_SERVER_INSTALL=yes \

OVERRIDE_SANDCATS_BASE_DOMAIN="${OVERRIDE_SANDCATS_BASE_DOMAIN:-}" \

OVERRIDE_SANDCATS_API_BASE="${OVERRIDE_SANDCATS_API_BASE:-}" \

OVERRIDE_SANDCATS_GETCERTIFICATE="${SANDCATS_GETCERTIFICATE}" \

OVERRIDE_NC_PATH="${OVERRIDE_NC_PATH:-}" \

OVERRIDE_SANDCATS_CURL_PARAMS="${OVERRIDE_SANDCATS_CURL_PARAMS:-}"

fi

# If we're still around, it means they declined to run us as root.

echo ""

echo "The automatic setup script needs root in order to:"

echo "* Create a separate user to run Thurly as, and"

echo "* Set up Thurly to start on system boot."

fail "E_DECLINED_AUTO_SETUP_DETAILS" "For a customized install, please re-run install.sh, and choose option (2) "\

"to do a development install."

fi

fi

# Accepting this indicates a few things.

if [ "yes" = "${ACCEPTED_FULL_SERVER_INSTALL}" ]; then

UPDATE_CHANNEL="$DEFAULT_UPDATE_CHANNEL"

DIR="$DEFAULT_DIR_FOR_ROOT"

USE_EXTERNAL_INTERFACE="yes"

USE_SANDCATS="yes"

START_AT_BOOT="yes"

DESIRED_SERVER_USER="$DEFAULT_SERVER_USER"

PORT="${DEFAULT_PORT}"

MONGO_PORT="6081"

SMTP_LISTEN_PORT="${PLANNED_SMTP_PORT}"

else

REPORT=no fail "E_USER_WANTS_CUSTOM_SETTINGS" "If you prefer a more manual setup experience, try installing in development mode."

fi

# We generate the public key before prompting for a desired hostname

# so that when the user presses enter, we can try to register the

# hostname, and if that succeeds, we are totally done. This avoids a

# possible time-of-check-time-of-use race.

echo -n "As a Thurly user, you are invited to use a free Internet hostname "

echo "as a subdomain of sandcats.io,"

echo "a service operated by the Thurly development team."

sandcats_generate_keys

echo ""

echo "Sandcats.io protects your privacy and is subject to terms of use. By using it,"

echo "you agree to the terms of service & privacy policy available here:"

echo "https://sandcats.io/terms https://sandcats.io/privacy"

echo ""

# Having set up the keys, we run the function to register a name

# with Sandcats. This function handles tail-recursing itself until

# it succeeds and/or returning when the user expresses a desire to

# cancel the process.

sandcats_register_name

# If appropriate, we configure HTTPS. We always call the function,

# allowing it to determine if any action is required.

sandcats_configure_https

if [ "yes" = "$USE_SANDCATS" ] ; then

# If we're lucky, the user will be happy with the Sandcats

# hostname configuration. If not, then we'll have to actually

# prompt them.

sandcats_configure

fi

# Ask the user for port number information. (These functions

# optionally skip the questions if the details have already been

# filled in.)

choose_port

choose_mongo_port

# If we are supposed to use the external network interface, then

# configure the hostname and IP address accordingly.

if [ "yes" = "$USE_EXTERNAL_INTERFACE" ]; then

BIND_IP=0.0.0.0

SS_HOSTNAME="${SS_HOSTNAME:-$(hostname -f 2>/dev/null || hostname)}"

else

BIND_IP=127.0.0.1

SS_HOSTNAME=local.sandstorm.io

if [ "yes" != "$USE_DEFAULTS" ] ; then

echo "Note: local.sandstorm.io maps to 127.0.0.1, i.e. your local machine."

echo "For reasons that will become clear in the next step, you should use this"

echo "instead of 'localhost'."

fi

fi

# A typical server's DEFAULT_BASE_URL is its hostname plus port over HTTP. If the port is 80, then

# don't add it to BASE_URL to avoid triggering this bug:

# https://github.com/sandstorm-io/sandstorm/issues/2252

local PORT_SUFFIX=""

if [ "$PORT" = "80" ] ; then

PORT_SUFFIX=""

else

PORT_SUFFIX=":${PORT}"

fi

DEFAULT_BASE_URL="http://${SS_HOSTNAME}${PORT_SUFFIX}"

# If SANDCATS_HTTPS_SUCCESSFUL is true, then use a HTTPS URL.

if [ "$SANDCATS_HTTPS_SUCCESSFUL" = "yes" ]; then

DEFAULT_BASE_URL="https://$SS_HOSTNAME"

HTTPS_PORT=443

PORT=80

fi

if [ "yes" = "$SANDCATS_SUCCESSFUL" ] ; then

# Do not prompt for BASE_URL configuration if Sandcats bringup

# succeeded.

BASE_URL="$DEFAULT_BASE_URL"

else

BASE_URL=$(prompt "URL users will enter in browser:" "$DEFAULT_BASE_URL")

if ! [[ "$BASE_URL" =~ ^http(s?):// ]] ; then

local PROPOSED_BASE_URL="http://${BASE_URL}"

echo "** You entered ${BASE_URL}, which needs http:// at the front. I can use:" >&2

echo " ${PROPOSED_BASE_URL}" >&2

if prompt-yesno "Is this OK?" yes; then

BASE_URL="${PROPOSED_BASE_URL}"

else

configure_hostnames

fi

fi