terraria

#!/bin/bash
### BEGIN INIT INFO
# Provides:		terraria
# Required-Start:	$local_fs $network $remote_fs
# Required-Stop:	$local_fs $network $remote_fs
# Default-Start:	2 3 4 5
# Default-Stop:		0 1 6
# Short-Description:	Start and stop the Terraria multiplayer server
# Description:		TerrariaService lets you start, stop and save a terraria server without keeping the TUI open
### END INIT INFO
# Source: https://wiki.debian.org/LSBInitScripts


CONFIG_PATH=`readlink -e $0 | sed "s:[^/]*$:config.cfg:"`

## Import configuration file
if [ -f $CONFIG_PATH ]; then
	source $CONFIG_PATH
else
	# Could not find the config, create new one
	cp $CONFIG_PATH.example $CONFIG_PATH

	if ! [ -f $CONFIG_PATH ]; then
		echo "Could not create new config file in: $PWD"
		exit 1
	else
		echo "New file added: config.cfg"
		echo "Edit the config.cfg file and start the script again."
		exit 0
		# source config.cfg
	fi
fi


## Default values
init()
{
	if [ -z "${DEBUGGING}" ]; then
		DEBUGGING=true
	fi

	if [ -z "${WRITE_DIR}" ]; then
		WRITE_DIR=/opt/terraria-service
	fi

	if [ -z "${TERRARIA_PATH}" ]; then
		TERRARIA_PATH=/opt/terraria
	fi

	if [ -z "${TERRARIA_BINARY}" ]; then
		TERRARIA_BINARY=TerrariaServer
	fi

	CURRENT_USER=`whoami`
	
	FIFO="${WRITE_DIR}/server.fifo"		# First in, First out file for commands
	CMDOUT="${WRITE_DIR}/server.out"	# Server output log
	PIDFILE="${WRITE_DIR}/server.pid"	# Server proces ID
	ERRLOG="${WRITE_DIR}/errors.log"	# Error log

	TERRARIA_CONFIG="${TERRARIA_PATH}/serverconfig.txt"

	ARGS="-config serverconfig.txt"		# Server requires a server config to instantly boot
	INVOKE="${TERRARIA_PATH}/${TERRARIA_BINARY} ${ARGS}"
}
init


## Debugger
debug()
{
	echo "Debugger:"
	echo -e "  USERNAME:\t\t${USERNAME}"
	echo -e "  CURRENT_USER:\t\t${CURRENT_USER}"
	echo -e "  TERRARIA_PATH:\t${TERRARIA_PATH}"
	echo -e "  TERRARIA_BINARY:\t${TERRARIA_BINARY}"
	echo -e "  WRITE_DIR:\t\t${WRITE_DIR}"
	echo -e "  PIDFILE:\t\t${PIDFILE}"
	echo -e "  ERRLOG:\t\t${ERRLOG}"
	echo -e "  LOG:\t\t\t${CMDOUT}"
	echo
}


## Usage display
usage()
{
	echo "Usage: $0 <COMMAND>"
	echo
	echo "Commands:"
	echo -e "  start\t\t Starts the server"
	echo -e "  stop\t\t Stops the server without saving"
	echo -e "  save\t\t Saves the world"
	echo -e "  exit\t\t Saves the world and stop the server"
	echo -e "  save-exit\t Alias for 'exit'"
	echo -e "  checkfiles\t Checks the files for any issues"
	echo -e "  state\t\t Displays the server state"
	echo -e "  kill\t\t Kills the server process"
	echo -e "  help\t\t Show this help message"
}


# Check file status
check_files()
{
	PERMISSIONS_ERR=0
	MISSING_CONFIG=false

	# Terraria server
	if ! [ -d ${TERRARIA_PATH} ] ; then
		echo "Could not find the terraria server directory at ${TERRARIA_PATH}."
		echo "Make sure that you have downloaded the terraria dedicated server from https://terraria.org before starting the service."
		exit 1
	fi

	# Service folder permissions
	## Not using the compact [-w ${WRITE_DIR} so i can test the user]
	if ! exec_user "test -w ${WRITE_DIR}" ; then
		echo "Missing write permissions: ${WRITE_DIR}"

		((PERMISSIONS_ERR++))
	fi

	# Server folder permissions
	if ! exec_user "test -w ${TERRARIA_PATH}" ; then
		echo "Missing write permissions: ${TERRARIA_PATH}"
		
		((PERMISSIONS_ERR++))
	fi

	# Terraria server config
	if ! [ -f ${TERRARIA_CONFIG} ] ; then
		echo "Missing file: ${TERRARIA_CONFIG}"
		MISSING_CONFIG=true
	elif ! exec_user "test -r ${TERRARIA_CONFIG}" ; then
		echo "Missing permissions: ${TERRARIA_CONFIG}"
		
		((PERMISSIONS_ERR++))
	fi

	# Terraria executable permissions
	if ! [ -x ${TERRARIA_PATH}/${TERRARIA_BINARY} ] ; then
		echo "Missing executable permissions: ${TERRARIA_PATH}/${TERRARIA_BINARY}"
		
		((PERMISSIONS_ERR++))
	fi

	# Fix permissions
	if ! [ "$PERMISSIONS_ERR" -eq "0" ]; then
		echo "Found ${PERMISSIONS_ERR} errors!"
		fix_permissions
	fi 

	# Create missing files
	if $MISSING_CONFIG ; then
		init_terraria_config
	fi

}

# Attempt to fix the permissions
fix_permissions()
{
	read -r -p "Attempt to auto-fix permissions? [y/N] " response
	case "$response" in
		[yY][eE][sS]|[yY]) 
			
			# Set user permissions to the whole terraria path
			sudo chown -R $USERNAME:$USERNAME ${TERRARIA_PATH}

			# Set user permissions to the whole service path
			sudo chown -R $USERNAME:$USERNAME ${WRITE_DIR}

			# Set executable permissions on the binary
			sudo chmod +x ${TERRARIA_PATH}/${TERRARIA_BINARY}

			# Check again
			check_files
			;;
		*)
			exit 1
			;;
	esac
}

# Init new server config
init_terraria_config()
{
	read -r -p "Want to generate a new simple terraria config? [y/N] " response
	case "$response" in
		[yY][eE][sS]|[yY]) 
			
			# Create new file
			echo "maxplayers=8" > ${TERRARIA_CONFIG}
			echo "world=${TERRARIA_PATH}/Worlds/NewWorld.wld" >> ${TERRARIA_CONFIG}
			echo "worldname=NewWorld" >> ${TERRARIA_CONFIG}
			echo "worldpath=${TERRARIA_PATH}/Worlds/" >> ${TERRARIA_CONFIG}

			echo "autocreate=2" >> ${TERRARIA_CONFIG}
			echo "difficulty=0" >> ${TERRARIA_CONFIG}

			echo "Created new file: ${TERRARIA_CONFIG}"

			# Check again
			check_files
			;;
		*)
			exit 1
			;;
	esac
}


# Execute for User
## Helper function
## Executes the provided command
exec_user()
{
	if [ $CURRENT_USER == $USERNAME ]; then 		# Are you the terraria user?
		if $DEBUGGING; then
			echo "Executing: ${1}"
		fi

		bash -c "$1"
	elif [ "$(id -u)" == "0" ]; then			# Are you root?
		if $DEBUGGING; then
			echo "Executing as ROOT: ${1}"
		fi

		su $USERNAME -s /bin/bash -c "$1"
	else							# You are neither
		echo "Run this script as the $USERNAME user or edit the config.cfg file!"
		exit 1
	fi
}


# Start script
## Creates a new PID file
start_service()
{
	# Check if file exists
	if [ -f ${PIDFILE} ]; then
		echo "File already exists!"
		return 1
	fi

	# Create new PIDFILE
	if ! exec_user "touch ${PIDFILE}" ; then
		echo "Could not create a new PID file"
		return 1
	fi

	# Create error log
	if ! [ -f ${ERRLOG} ]; then
		echo "Error log does not exist! Making a new one"
		if ! exec_user "touch ${ERRLOG}"; then
			echo "Could not make a error log file!"
			return 1;
		fi
	fi

	# FIFO file?
	if ! [ -f ${FIFO} ]; then
		exec_user "touch ${FIFO}"
	fi
	
	# Attempt to start the process along with the PID into the PIDFILE
	exec_user "tail -f ${FIFO} | ${INVOKE} >> ${CMDOUT} 2>&1 & echo \$! > ${PIDFILE}"

	# Check if online
	if [ "$?" -ne "0" ]; then
		echo "Unable to start ${SERVICE_NAME}"
		return 1
	else
		echo "Started the server, please see log for details (${CMDOUT})"
	fi
}


# Stop service
stop_service()
{
	echo "Stopping server.."
	terraria_command "exit"

	## TODO: Cleanly close FIFO tail
}


# Kill service
kill_service()
{
	if is_running ; then
		echo "Killing server process.."
		exec_user "kill -TERM $(cat ${PIDFILE} 2> /dev/null) 2> /dev/null"
		exec_user "rm ${PIDFILE} 2> /dev/null"
	fi
}


# Check if server is running
## Why is 0 true and 1 false?
is_running()
{
	# Check if file does not exists
	if ! [ -r ${PIDFILE} ]; then
		return 1
	fi

	# Check if the process is still running
	if ! ps --pid $(cat ${PIDFILE}) > /dev/null ; then

		# Process is not running and the PIDFILE should not be here
		exec_user "rm ${PIDFILE} 2> /dev/null"
		return 1
	
	fi

	# Server up and running
	return 0
}


# Save game
## TODO: Check if server is running
save()
{
	echo "Saving game.."
	terraria_command "save"
}


# Execute server command
terraria_command()
{
	echo $1 >> ${FIFO}	# Send command to file
	sleep 1s
	> ${FIFO}		# Clear file
}


## Middleware
if $DEBUGGING; then
	debug
fi


## Routing
case "$1" in
	start)
		check_files

		if is_running; then
			echo "Could not start the terraria server: Server is already running"
			exit 1
		elif ! start_service; then
			echo "Could not start the terraria server"
			exit 1
		else
			exit 0
		fi
		;;
	stop)
		## A service handles stop on its own by killing the process PID
		;;
	save-exit)
		stop_service
		;;
	exit)
		stop_service
		;;
	save)
		save
		;;
	checkfiles)
		check_files
		;;
	state)
		if is_running ; then
			echo "Server is up and running"
		else
			echo "Server is offline"
		fi
		;;
	help|--help|-h)
		usage
		;;
	kill)
		kill_service
		;;
	*)
		echo "Unknown command"
		usage
		exit 1
		;;
esac

exit 0