msm/init/msm

#!/bin/bash

### BEGIN INIT INFO
# Provides:	  msm
# Required-Start: $local_fs $remote_fs
# Required-Stop:  $local_fs $remote_fs
# Should-Start:	  $network
# Should-Stop:	  $network
# Default-Start:  2 3 4 5
# Default-Stop:	  0 1 6
# Short-Description:	
# Description:	  
### END INIT INFO


# See http://www.debian.org/doc/debian-policy/ch-opersys.html#s-sysvinit for
# more information on debain init.d scripts, which may help you understand
# this script.


### The configuration file

# Get the MSM_CONF environment variable or use the default location
CONF="${MSM_CONF:-/etc/msm.conf}"


### The Minecraft Server Manager version, use "msm version" to check yours.
VERSION="0.2.4 Beta"


### Config variables the user should not need/want to change

# Jar group file which contains the download target URL
declare -r JARGROUP_TARGET="target.txt"
# Jar group directory name to download new jars to, is deleted afterwards
declare -r JARGROUP_DOWNLOAD_DIR="downloads"

# The flag which indicates the world should be put in RAM
declare -r WORLD_FLAG_INRAM="inram"
# The flag which indicates the server is active
declare -r SERVER_FLAG_ACTIVE="active"

# The start of a regex to find a log line
declare -r LOG_REGEX="^[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2} \[.*\]"


### Script State Variables

# "true" whilst the script is counting down a delay to stop the server
declare STOP_COUNTDOWN

# "true" whilst the script is counting down a delay to restart the server
declare RESTART_COUNTDOWN


### Utility Functions

# Executes the command "$2" as user "$1"
# $1: The user to execute the command as
# $2: The command to execute
as_user() {
	local user="$(whoami)"
	if [ "$user" == "$1" ]; then
		bash -c "$2"
	else
		if [ "$user" == "root" ]; then
			su - "$1" -s /bin/bash -c "$2"
		else
			echoerr "This command must be executed as the user \"$1\" or \"root\"."
			exit 1
		fi
	fi
}

# Executes the command "$1" as SERVER_USER but returns stderr instead
as_user_stderr() {
	as_user "$@"  > /dev/null 2>&1
}

# Echo to stderr
echoerr() {
	echo "$@" 1>&2
}

# A function used to print debug messages to stdout. Prevents messages from
# appearing unless in debug mode, and allows debug statements to be easily
# distinguished from necessary echo statements.
# $1: The message to output
debug() {
	if [[ "$DEBUG" == "true" ]]; then
		echoerr "$1"
	fi
}

# Determines whether "$1" is a valid name for a server or jar group directory
# It must only contain upper or lower case letters, digits, dashes or
# underscores.
# It must also not be one of a list of reserved names.
is_valid_name() {
	local valid="^[a-zA-Z0-9\_\-]+$"
	local invalid="^(start|stop|restart|version|server|jargroup|all)$"
	
	if [[ "$1" =~ $valid ]]; then
		if [[ "$1" =~ $invalid ]]; then
			echoerr "Invalid name \"$1\": A name may not be any of the following reserved worlds \"start\", \"stop\", \"restart\", \"server\", \"version\", \"jargroup\" or \"all\"."
			return 1
		else
			return 0
		fi
	else
		echoerr "Invalid name \"$1\": A name may only contain letters, numbers, dashes and unscores."
		return 1
	fi
}

# Gets the latest jar from a jar group, based upon the date and time encoded
# in the file name.
# $1: The directory to search
get_latest_file() {
	local best_time=0
	local best_file=""
	
	while IFS= read -r -d $'\0' file; do
		# Remove the path, leaving just the file name
		local date_time="$(basename "$file" | awk -F '-' '{print $1 "-" $2 "-" $3 " " $4 ":" $5 ":" $6}')"
		
		# Get the time in seconds since 1970 from file name
		local seconds="$(date -d "$date_time" "+%s" 2> /dev/null)"
		
		# If that is newer than the current best, override variables
		if [[ "$seconds" -gt "$best_time" ]]; then
			best_time="$seconds"
			best_file="$file"
		fi
	done < <(find "$1" -maxdepth 1 -type f -print0)
	
	echo "$best_file"
}

# Returns the current time as a UNIX timestamp (in seconds since 1970)
now() {
	date +%s
}


### Log Utility Functions

# Gets the UNIX timestamp for a server log line
# $1: A server log line
# returns: Time in seconds since 1970-01-01 00:00:00 UTC
log_line_get_time() {
	time_string="$(echo "$1" | awk '{print $1 " " $2}')"
	date -d "$time_string" "+%s" 2> /dev/null
}


### World Utility Functions

# Moves a world to RAM
# $1: the ID of the world to move
world_to_ram() {
	if [ ! -z "$RAMDISK_STORAGE_PATH" ]; then
		as_user "${server_user_name[${world_server_id[$1]}]}" "mkdir -p \"${world_ramdisk_path[$1]}\" && rsync -rt --exclude '$WORLD_FLAG_INRAM' \"${world_path[$1]}/\" \"${world_ramdisk_path[$1]}\""
	fi
}

# Moves a world in RAM to disk
# $1: the ID of the world to move
world_to_disk() {
	as_user "${server_user_name[${world_server_id[$1]}]}" "rsync -rt --exclude '$WORLD_FLAG_INRAM' \"${world_ramdisk_path[$1]}/\" \"${world_path[$1]}\""
}

# Toggles a worlds ramdisk state
# $1: The ID of the world
world_toggle_ramdisk_state() {
	if [ -f "${world_flag_inram[$1]}" ]; then
		echo -n "Removing RAM flag from world \"${world_name[$1]}\"... "
		as_user "${server_user_name[${world_server_id[$1]}]}" "rm -f \"${world_flag_inram[$1]}\""
		echo "Done."
		
		echo -n "Removing world \"${world_name[$1]}\" from RAM... "
		as_user "${server_user_name[${world_server_id[$1]}]}" "rm -r \"${world_ramdisk_path[$1]}\""
		echo "Done."
	else
		echo -n "Adding RAM flag to world \"${world_name[$1]}\"... "
		as_user "${server_user_name[${world_server_id[$1]}]}" "touch \"${world_flag_inram[$1]}\""
		echo "Done."
		
		echo -n "Copying world to RAM... "
		world_to_ram "$1"
		echo "Done."
	fi
	echo "Changes will only take effect after server is restarted."	
}

# Backs up a world
# $1: The ID of the world
world_backup() {
	echo -n "Backing up world \"${world_name[$1]}\"... "
	
	file_name="$(date "+%F-%H-%M-%S").zip"
	local server_id="${world_server_id[$1]}"
	local containing_dir="$(dirname "${world_path[$1]}")"
	local dir_name="$(basename "${world_path[$1]}")"
	as_user "${server_user_name[$server_id]}" "mkdir -p \"${world_backup_path[$1]}\" && cd \"$containing_dir\" && zip -rq \"${world_backup_path[$1]}/${file_name}\" \"${dir_name}\""

	echo "Done."
}

# Activates a world
# $1: The ID of the world
world_activate() {
	if [ -d "${world_inactive_path[$1]}" ]; then
		echo -n "Moving world \"${world_name[$1]}\" to the active worldstorage directory... "
		local new_path="${world_active_path[$1]}"
		as_user "${server_user_name[${world_server_id[$1]}]}" "mkdir -p \"$new_path\" && mv \"${world_inactive_path[$1]}\" \"$new_path\""
		echo "Done."
	else
		if [ -d "${world_active_path[$1]}" ]; then
			echo "World \"${world_name[$1]}\" is already activate."
		else
			echoerr "Error: Directory \"${world_inactive_path[$1]}\" could not be found."
			return 1
		fi
	fi
}

# Deactivates a world
# $1: The ID of the world
world_deactivate() {
	if server_is_running "${world_server_id[$1]}"; then
		echoerr "Error: Worlds cannot be deactivated whilst the server is running."
		return 1
	else
		if [ -d "${world_active_path[$1]}" ]; then
			echo -n "Moving world \"${world_name[$1]}\" to the inactive worldstorage directory... "
			local new_path="${world_inactive_path[$1]}"
			as_user "${server_user_name[${world_server_id[$1]}]}" "mkdir -p \"$new_path\" && mv \"${world_path[$1]}\" \"$new_path\""
			echo "Done."
		else
			if [ -d "${world_inactive_path[$1]}" ]; then
				echo "World \"${world_name[$1]}\" is already deactivate."
			else
				echoerr "Error: Directory \"${world_active_path[$1]}\" could not be found."
				return 1
			fi
		fi
	fi
}

### Server Utility Functions

# Returns the ID for a server.
# An ID is given to a server when loaded into memory, and can be used to lookup
# config information for that server
# $1: The name of the server
server_get_id() {
	local i=0
	while [[ "$i" -lt "$num_servers" ]]; do
		if [[ "${server_name[$i]}" == "$1" ]]; then
			echo "$i"
			return 0
		fi
		
		i="$(( $i + 1 ))"
	done
	
	return 1
}

# Returns the ID of a server's world.
# $1: The ID of the server
# $2: The name of the world
server_world_get_id() {
	if [ -d "${server_world_storage[$1]}/$2" ] || [ -d "${server_world_storage_inactive[$1]}/$2" ]; then
		# If the directory exists
		
		local start="${server_world_offset[$1]}"
		local max="$(( $i + ${server_num_worlds[$1]} ))"
	
		# For each of the servers worlds:
		for ((i=$start; i<$max; i++)); do
			if [[ "${world_name[$i]}" == "$2" ]]; then
				echo "$i"
				return 0
			fi
		done
	fi
	
	return 1
}

# Returns 0 if the server $1 is running and 1 if not
# $1: The ID of the server
server_is_running() {
	if ps ax | grep -v grep | grep "${server_screen_name[$1]} ${server_invocation[$1]}" > /dev/null
	then
		return 0
	else
		return 1
	fi
}

# Creates symbolic links in the server directory (SERVER_STORAGE_PATH) for each
# of the Minecraft worlds located in the world storage directory.
# $1: The id of the server for which links should be ensured
server_ensure_links() {
	echo -n "Maintaining world symbolic links... "
	local start="${server_world_offset[$1]}"
	local max="$(( $start + ${server_num_worlds[$1]} ))"
	local output="false"
	
	for ((i=$start; i<$max; i++)); do
		if [[ "${world_status[$i]}" != "active" ]]; then
			# Remove the symbolic link if it exists
			as_user "${server_user_name[$1]}" "rm -f \"${world_link[$i]}\""
			continue
		fi
		
		# -L checks for the path being a link rather than a file
		# ! -a, since it is within double square brackets means: the negation of
		# the existence of the file. In other words: true if does not exist
		if [[ -L "${world_link[$i]}" || ! -a "${world_link[$i]}" ]]; then
			# If there is a symbolic link in the server direcotry to this world,
			# or there is not a directory in the server directory containing this world.
			
			# Get the original file path the symbolic link is pointing to
			# If there is no link, link_target will contain nothing
			link_target="$(readlink "${world_link[$i]}")"
			
			if "${world_inram[$i]}"; then
				# If this world is marked as loaded into RAM

				if [ "${link_target}" != "${world_ramdisk_path[$i]}" ]; then
					# If the symbolic link does not point to the RAM version of the world

					# Remove the symbolic link if it exists
					as_user "${server_user_name[$1]}" "rm -f \"${world_link[$i]}\""

					# Create a new symbolic link pointing to the RAM version of the world
					as_user "${server_user_name[$1]}" "ln -s \"${world_ramdisk_path[$i]}\" \"${world_link[$i]}\""
				fi
			else
				# Otherwise the world is not loaded into RAM, and is just on disk

				if [ "${link_target}" != "${world_path[$i]}" ]; then
					# If the symbolic link does not point to the disk version of the world

					# Remove the symbolic link if it exists
					as_user "${server_user_name[$1]}" "rm -f \"${world_link[$i]}\""

					# Create a new symbolic link pointing to the disk version of the world
					as_user "${server_user_name[$1]}" "ln -s \"${world_path[$i]}\" \"${world_link[$i]}\""
				fi
			fi
		else
			echoerr -en "\n    Error: Could not create link for world \"${world_name[$i]}\". The file \"${world_link[$i]}\" already exists, and should not be overwritten automatically. Either remove this file, or rename \"${world_name[$i]}\"."
			output="true"
		fi
	done
	
	if [[ "$output" == "true" ]]; then
		echo -e "\nDone."
	else
		echo "Done."
	fi
}

# Moves a servers worlds into RAM
# $1: The ID of the server
server_worlds_to_ram() {
	# Only proceed if there is a ramdisk path set in config
	if [ ! -z "$RAMDISK_STORAGE_PATH" ]; then
		echo -n "Synchronising flagged worlds on disk to RAM... "
		local i="${server_world_offset[$1]}"
		local max="$(( $i + ${server_num_worlds[$1]} ))"
		
		# For each of the servers worlds:
		while [[ "$i" -lt "$max" ]]; do
			if "${world_inram[$i]}" && [ -L "${world_link[$i]}" ]; then
				world_to_ram "$i"
			fi
			
			i="$(( $i + 1 ))"
		done
		echo "Done."
	fi
}

# Moves a servers "in RAM" worlds back to disk
# $1: The ID of the server
server_worlds_to_disk() {
	if [ ! -z "$RAMDISK_STORAGE_PATH" ]; then
		echo -n "Synchronising worlds in RAM to disk... "
		local i="${server_world_offset[$1]}"
		local max="$(( $i + ${server_num_worlds[$1]} ))"
		
		# For each of the servers worlds:
		while [[ "$i" -lt "$max" ]]; do
			if [ -d "${world_ramdisk_path[$i]}" ]; then
				world_to_disk "$i"
			fi
			
			i="$(( $i + 1 ))"
		done
		echo "Done."
	fi
}

# Watches a server's log for a specific line
# $1: The ID for the server
# $2: A UNIX timestamp (seconds since 1970) which the $3 line must be after
# $3->: The line or lines in the log to wait for
# returns: When the line is found
server_log_get_line() {
    # Make sure there is a server log to check
    as_user "${server_user_name[$1]}" "touch ${server_log[$1]}"

	while read line; do
		line_time="$(log_line_get_time "$line")"

		# If the entry is old enough
		if [[ "$line_time" -ge "$2" ]]; then
			for search_line in "${@:3}"; do
				local regex="${LOG_REGEX} ${search_line}"
				# and matches the regular expression
				if [[ "$line" =~ $regex ]]; then
					echo "$line"
					return 0
				fi
			done
		fi
	done < <(as_user "${server_user_name[$1]}" "tail --follow --lines=100 --sleep-interval=0.1 \"${server_log[$1]}\"")
}

# The same as server_log_get_line, but does not print the line to stdout
# when found.
server_log_wait_for_line() {
	server_log_get_line "$@" > /dev/null
}

# Sends as string to a server for execution
# $1: The ID of the server
# $2: The line of text to enter into the server console
server_eval() {
	as_user "${server_user_name[$1]}" "screen -p 0 -S ${server_screen_name[$1]} -X eval 'stuff \"$2\"\015'"
}

# The same as server_eval, but also waits for a log entry before returning
# $1: The ID of the server
# $2: A line of text to enter into the server console
# $3->: The line or lines of text in the log to wait for
# stdout: The full entry found in the logs
server_eval_and_get_line() {
	time_now="$(now)"
	server_eval "$1" "$2"
	server_log_get_line "$1" "$time_now" "${@:3}"
}

# The same as server_eval_and_get_line, but does not print anything to stdout
server_eval_and_wait() {
	server_eval_and_get_line "$@" > /dev/null
}

# Gets the process ID for a server if running, otherwise it outputs nothing
# $1: The ID of the server
server_pid() {
	ps ax | grep -v grep | grep "${server_screen_name[$1]} ${server_invocation[$1]}" | awk '{print $1}'
}

# Waits for a server to stop by polling 10 times a second
# This approach is fairyl intensive, so only use when you are expecting the
# server to stop soon
# $1: The ID of the server to wait for
server_wait_for_stop() {
	local pid="$(server_pid "$1")"
	
	# if the process is still running, wait for it to stop
	if [ ! -z "$pid" ]; then
		while ps -p "$pid" > /dev/null; do
			sleep 0.1
		done
	fi
}

# Sets a server's active/inactive state
# $1: The ID of the server
# $2: A string containing "active" or "inactive"
server_set_active() {
	case "$2" in
		active)
			as_user "${server_user_name[$1]}" "touch \"${server_flag_active[$1]}\""
			server_active[$1]="true"
			;;
		inactive)
			as_user "${server_user_name[$1]}" "rm -f \"${server_flag_active[$1]}\""
			server_active[$1]="false"
			;;
		*)
			return 1
			;;
	esac
}


### Jar Group Functions

# Lists the jar files grouped by jar groups.
jargroup_list() {
	for group in $(ls -1 "$JAR_STORAGE_PATH"); do
		echo "${group}:"
		for jar in $(ls -1r "$JAR_STORAGE_PATH/$group"); do
			if [[ "$jar" =~ ^[0-9]{4}-[0-9]{2}-[0-9]{2}- ]]; then
				echo "    $jar"
			fi
		done
	done
}

# Creates a new jargroup
# $1: The name for the jargroup
jargroup_create() {
	if is_valid_name "$1"; then
		if [[ ! -e "$JAR_STORAGE_PATH/$1" ]]; then
			printf "Creating jar group... "
			
			local error="$(as_user_stderr "$USERNAME" "mkdir -p \"$JAR_STORAGE_PATH/$1\"")"
			if [[ "$error" != "" ]]; then
				echo "Failed."
				echo "Reason: $error"
				return 1
			fi
			
			error="$(as_user "$USERNAME" "echo \"$2\" > \"$JAR_STORAGE_PATH/$1/$JARGROUP_TARGET\"")"
			if [[ "$error" != "" ]]; then
				echo "Failed."
				echo "Reason: $error"
				return 1
			fi
			
			echo "Done."
			
			# Download the latest version now
			jargroup_getlatest "$1"
		else
			echo "A jar group with that name already exists."
			return 1
		fi
	else
		return 1
	fi
}

# Downloads the latest version for a jargroup, using the target URL for that
# group. Saves the download with the date and time encoded in the start of the
# file name, in the jar group directory in question. Removes the file if there
# is no difference between it and the current version.
# $1: The jargroup name to download the latest version for
jargroup_getlatest() {
	if is_valid_name "$1"; then
		if [[ -e "$JAR_STORAGE_PATH/$1" ]]; then
			if [[ -e "$JAR_STORAGE_PATH/$1/$JARGROUP_TARGET" ]]; then
				printf "Downloading latest version... "
			
				# Try and make 
				local error="$(as_user_stderr "$USERNAME" "mkdir -p '$JAR_STORAGE_PATH/$1/$JARGROUP_DOWNLOAD_DIR'")"
				if [[ "$error" != "" ]]; then
					echo "Failed."
					echo "Reason: $error"
					return 1
				fi
			
				as_user "$USERNAME" "wget --quiet --trust-server-names --no-check-certificate --input-file='$JAR_STORAGE_PATH/$1/$JARGROUP_TARGET' --directory-prefix='$JAR_STORAGE_PATH/$1/$JARGROUP_DOWNLOAD_DIR'"
				echo "Done."
			
				local num_files="$(as_user "$USERNAME" "ls -1 '$JAR_STORAGE_PATH/$1/$JARGROUP_DOWNLOAD_DIR' | wc -l")"
			
				if [[ "$num_files" == 1 ]]; then
					# There was 1 file downloaded
				
					local file_name="$(ls -1 "$JAR_STORAGE_PATH/$1/$JARGROUP_DOWNLOAD_DIR")"
					local new_name="$(date +%F-%H-%M-%S)-$file_name"
					local most_recent_jar="$(get_latest_file "$JAR_STORAGE_PATH/$1")"
					
				
					if [[ ! -e "$most_recent_jar" ]] || ! diff "$most_recent_jar" "$JAR_STORAGE_PATH/$1/$JARGROUP_DOWNLOAD_DIR/$file_name" > /dev/null; then
						# There is not a previous version to do a comparison against, or
						# The previous version is different:
						# Add it to the group
					
						[[ -e "$most_recent_jar" ]]
						local was_previous="$?"
					
						as_user "$USERNAME" "mv '$JAR_STORAGE_PATH/$1/$JARGROUP_DOWNLOAD_DIR/$file_name' '$JAR_STORAGE_PATH/$1/$new_name'"
					
						if [[ ! -z "$most_recent_jar" ]]; then
							echo "Downloaded version was different to previous latest. Saved as \"$JAR_STORAGE_PATH/$1/$new_name\"."
						else
							echo "Saved as \"$JAR_STORAGE_PATH/$1/$new_name\"."
						fi
					else
						echo "Existing version \"$JAR_STORAGE_PATH/$1/$new_name\" was already up to date."
					fi
				
				elif [[ "$num_files" == 0 ]]; then
					# No file was downloaded
					echo "Failed. No files were downloaded."
				else
					# Multiple files were
					echo "Error. URL downloads multiple files."
				fi
			
				# Clean up the temp download folder
				as_user "$USERNAME" "rm -fr '$JAR_STORAGE_PATH/$1/$JARGROUP_DOWNLOAD_DIR'"
			else
				echo "Target URL not found, use $0 jargroup seturl <download-url>"
				return 1
			fi
		else
			echo "There is no jar group with the name \"$1\"."
			return 1
		fi
	else
		return 1
	fi
}

# Deletes an existing jargroup
# $1: The name of the existing jargroup
jargroup_delete() {
	if is_valid_name "$1"; then
		if [[ -e "$JAR_STORAGE_PATH/$1" ]]; then
			printf "Are you sure you want to delete this jar group [y/N]: "
		
			read answer
			if [[ "$answer" =~ ^y|Y|yes$ ]]; then
				as_user "$USERNAME" "rm -rf \"$JAR_STORAGE_PATH/$1\""
				echo "Jar group deleted."
			else
				echo "Jar group was NOT deleted."
			fi
		else
			echo "There is no jar group with the name \"$1\"."
			return 1
		fi
	else
		return 1
	fi
}

# Renames an existing jargroup
# $1: The name of the existing jargroup
# $2: The new name
jargroup_rename() {
	if is_valid_name "$1"; then
		if [[ -e "$JAR_STORAGE_PATH/$1" ]]; then
			# If the jar group name is valid,
			# and there is no other jar group with the name $1
		
			if is_valid_name "$2"; then
				if [[ -e "$JAR_STORAGE_PATH/$2" ]]; then
					echo "Could not be renamed, there is already a jar group with the name \"$2\"."
					return 1
				else
					# TODO: Update any symbolic links which point to a jar in this directory
					as_user "$USERNAME" "mv '$JAR_STORAGE_PATH/$1' '$JAR_STORAGE_PATH/$2'"
					echo "Renamed jar group \"$1\" to \"$2\"."
				fi
			else
				return 1
			fi
		else
			echo "There is no jar group with the name \"$1\"."
			return 1
		fi
	else
		return 1
	fi
}


### Server Functions

# Echos a list of servers in the SERVER_STORAGE_PATH
server_list() {
	ls -1 "$SERVER_STORAGE_PATH"
}

# Creates a new server
# $1: The server name to create
server_create() {
	if is_valid_name "$1"; then
		if [[ -e "$SERVER_STORAGE_PATH/$1" ]]; then
			echo "A server with that name already exists."
			return 1
		else
			printf "Creating server directory... "
			as_user "$USERNAME" "mkdir -p '$SERVER_STORAGE_PATH/$1'"
			as_user "$USERNAME" "touch '$SERVER_STORAGE_PATH/$1/$DEFAULT_WHITELIST'"
			as_user "$USERNAME" "touch '$SERVER_STORAGE_PATH/$1/$DEFAULT_BANNED_IPS'"
			as_user "$USERNAME" "touch '$SERVER_STORAGE_PATH/$1/$DEFAULT_BANNED_PLAYERS'"
			as_user "$USERNAME" "touch '$SERVER_STORAGE_PATH/$1/$DEFAULT_OPS'"
			as_user "$USERNAME" "touch '$SERVER_STORAGE_PATH/$1/$DEFAULT_PROPERTIES'"
			echo "Done."
			
			# Now that the new server has been created, we must call init again
			# to ensure it is recognised.
			init
			
			server_set_jar "$(server_get_id "$1")" "minecraft"
		fi
	else
		return 1
	fi
}

# Deletes an existing server
# $2: The server name to delete
server_delete() {
	if is_valid_name "$1"; then
		if [[ -d "$SERVER_STORAGE_PATH/$1" ]]; then
			printf "Are you sure you want to delete this server and its worlds (note: backups are preserved) [y/N]: "

			read answer
			if [[ "$answer" =~ ^y|Y|yes$ ]]; then
				# TODO: stop the server if running first
				as_user "$USERNAME" "rm -rf '$SERVER_STORAGE_PATH/$1'"
				echo "Server deleted."
			else
				echo "Server was NOT deleted."
			fi
		else
			echo "There is no server with the name \"$1\"."
			return 1
		fi
	else
		return 1
	fi
}

# Renames an existing server
# $1: The server name to change
# $2: The new name for the server
server_rename() {
	if is_valid_name "$1"; then
		if server_is_running "$(server_get_id "$1")"; then
			echoerr "Error: Can only rename a stopped server."
			return 1
		else
			if [[ -e "$SERVER_STORAGE_PATH/$1" ]]; then
				# If the server name is valid and exists
		
				# TODO: Check that the server is not running first, return if it is
		
				if is_valid_name "$2"; then
					# If the server name is valid
					if [[ -e "$SERVER_STORAGE_PATH/$2" ]]; then
						# and there is not already a server with the name $2
						echoerr "Error: Could not be renamed, there is already a server with the name \"$2\"."
						return 1
					else
						as_user "$USERNAME" "mv '$SERVER_STORAGE_PATH/$1' '$SERVER_STORAGE_PATH/$2'"
						echo "Renamed server \"$1\" to \"$2\"."
					fi
				else
					return 1
				fi
			else
				echoerr "Error: There is no server with the name \"$1\"."
				return 1
			fi
		fi
	else
		return 1
	fi
}

# Starts a single server
# $1: The ID of the server
server_start() {
	if server_is_running "$1"; then
		echo "Server \"${server_name[$1]}\" is already running!"
	else
		server_ensure_links "$1"
		server_worlds_to_ram "$1"

		local time_now="$(now)"
		
		printf "Starting server... "
		as_user "${server_user_name[$1]}" "cd \"${server_path[$1]}\" && screen -dmS \"${server_screen_name[$1]}\" ${server_invocation[$1]}"
		server_log_wait_for_line "$1" "$time_now" "${server_confirm_start[$1]}"
		
		echo "Done."
	fi
}

# Sends the "save-all" command to a server
# $1: The ID of the server
server_save_all() {
	if server_is_running "$1"; then
		echo -n "Forcing save... "
		
		# Send the "save-all" command and wait for it to finish
		server_eval_and_wait "$1" "save-all" "${server_confirm_save_all[$1]}"
		
		echo "Done."
	else
		echo "Server \"${server_name[$1]}\" is not running."
	fi
}

# Sends the "save-off" command to a server
# $1: The ID of the server
server_save_off() {
	if server_is_running "$1"; then
		echo -n "Disabling level saving... "
		
		# Send the "save-off" command and wait for it to finish
		server_eval_and_wait "$1" "save-off" "${server_confirm_save_off[$1]}"
		
		echo "Done."
		
		# Writes any in-memory data manged by the kernel to disk
		sync
	else
		echo "Server \"${server_name[$1]}\" is not running."
	fi
}

# Sends the "save-on" command to a server
# $1: The ID of the server
server_save_on() {
	if server_is_running "$1"; then
		echo -n "Enabling level saving... "
		
		# Send the "save-on" command and wait for it to finish
		server_eval_and_wait "$1" "save-on" "${server_confirm_save_on[$1]}"
		
		echo "Done."
	else
		echo "Server \"${server_name[$1]}\" is not running."
	fi
}

# Stops a single server after a delay
# $1: The ID of the server
server_stop() {
	if server_is_running "$1"; then
		# Change the state of the script
		STOP_COUNTDOWN[$id]="true"
	
	    server_eval "$id" "say ${server_stop_message[$id]}"
	    echo "Issued the warning \"${server_stop_message[$id]}\" to players."
	
		echo -n "Shutting down... "
	
		for ((i="${server_stop_delay[$id]}"; i>0; i--)); do
			tput sc # Save cursor position
			echo -n "in $i seconds."
			sleep 1
		
			tput rc # Restore cursor to position of last `sc'
			tput el # Clear to end of line
		done
	
		echo -e "Now."
		
		server_stop_now "$1"
   	else
		echo "Server \"${server_name[$1]}\" is not running."
	fi
}

# Stops a single server right now
# $1: The ID of the server
server_stop_now() {
	if server_is_running "$1"; then
		server_save_all "$1"
		
		echo -n "Stopping the server... "
		
		server_eval "$1" "stop"
		STOP_COUNTDOWN[$1]="false"
		RESTART_COUNTDOWN[$1]="false"
		server_wait_for_stop "$1"
		
		echo "Done."
		
		# Synchronise all worlds in RAM to disk
		server_worlds_to_disk "$1"
	else
		echo "Server \"${server_name[$1]}\" is not running."
	fi
}

# Restarts a single server after a delay
# $1: The ID of the server 
server_restart() {
	# Restarts the server if it is already running
	if server_is_running "$1"; then
		# Change the state of the script
		RESTART_COUNTDOWN[$id]="true"
	
	    server_eval "$id" "say ${server_restart_message[$id]}"
	    echo "Issued the warning \"${server_restart_message[$id]}\" to players."
	
		echo -n "Restarting... "
	
		for ((i="${server_stop_delay[$id]}"; i>0; i--)); do
			tput sc # Save cursor position
			echo -n "in $i seconds."
			sleep 1
		
			tput rc # Restore cursor to position of last `sc'
			tput el # Clear to end of line
		done
	
		echo -e "Now."
		
		server_stop_now "$1"
	fi
	
	server_start "$1"
}

# Restarts a single server right away
# $1: The ID of the server
server_restart_now() {
	# Restarts the server if it is already running
	if server_is_running "$1"; then
		server_stop_now "$1"
	fi
	
	server_start "$1"
}

# List the worlds available for a server
# $1: The ID of the server
server_worlds_list() {
	local i="${server_world_offset[$1]}"
	local max="$(( $i + ${server_num_worlds[$1]} ))"
	
	# For each of the servers worlds:
	while [[ "$i" -lt "$max" ]]; do
		if "${world_inram[$i]}"; then
			echo "[RAM] ${world_name[$i]}"
		else
			echo "[DSK] ${world_name[$i]}"
		fi
		
		i="$(( $i + 1 ))"
	done
}

# Backs up the worlds for a server
# $1: The ID of the server
server_worlds_backup() {
	local i="${server_world_offset[$1]}"
	local max="$(( $i + ${server_num_worlds[$1]} ))"

	# For each of the servers worlds:
	while [[ "$i" -lt "$max" ]]; do
		world_backup "$i"
		i="$(( $i + 1 ))"
	done
}

# Moves a servers log into another file, leaving the original log file empty
# $1: The ID of the server
server_log_roll() {
	# Moves and Gzips the logfile, a big log file slows down the
	# server A LOT (what was notch thinking?)

	printf "Rolling server logs... "
	
	if [ -e "${server_log[$1]}" ]; then
		file_name="${server_name[$1]}-$(date +%F-%H-%M-%S).log"
		as_user "${server_user_name[$1]}" "mkdir -p \"${server_log_archive_path[$1]}\" && cp \"${server_log[$1]}\" \"${server_log_archive_path[$1]}/${file_name}\" && gzip \"${server_log_archive_path[$1]}/${file_name}\""
		
		if [ -e "${server_log_archive_path[$1]}/${file_name}.gz" ]; then
			as_user "${server_user_name[$1]}" "cp \"/dev/null\" \"${server_log[$1]}\""
			as_user "${server_user_name[$1]}" "echo \"Previous logs can be found at \\\"${server_log_archive_path[$1]}\\\"\" > \"${server_log[$1]}\""
		else
			echoerr "Failed."
			return 1
		fi
	fi
	
	echo "Done."
}

# Backups a server's directory
# $1: The ID of the server
server_backup() {
	echo -n "Backing up the entire server directory... "
	
	zip_flags="-rq"
	# Add the "y" flag if symbolic links should not be followed
	if [ "${server_complete_backup_follow_symlinks[$1]}" != "true" ]; then
		zip_flags="${zip_flags}y"
	fi
	
	# Zip up the server directory
	file_name="${server_backup_path[$1]}/$(date "+%F-%H-%M-%S").zip"
	as_user "${server_user_name[$1]}" "mkdir -p \"${server_backup_path[$1]}\" && cd \"$SERVER_STORAGE_PATH\" && zip ${zip_flags} \"${file_name}\" \"${server_name[$1]}\""
	
	echo "Done."
}

# Sets a server's jar file
# $1: The ID of the server
# $2: The name of the jar group
# $3: Optionally, a specific jar to use.
server_set_jar() {
	if [ -e "$JAR_STORAGE_PATH/$2" ]; then
		
		if [ -z "$3" ]; then
			# If a specific jar file is not mentioned
			
			# Download the latest version
			jargroup_getlatest "$2"
			local jar="$(get_latest_file "$JAR_STORAGE_PATH/$2")"
		else
			# If a specific jar IS mentioned use that
			local jar="$JAR_STORAGE_PATH/$2/$3"
			
			if [[ ! -e "$jar" ]]; then
				echo "There is no jar named \"$3\" in jargroup \"$2\"."
				return 1
			fi
		fi
		
		if [[ ! -z "$jar" ]]; then
			as_user "${server_user[$1]}" "ln -sf \"$jar\" \"${server_jar[$1]}\""
			echo "Server \"${server_name[$1]}\" is now using \"$jar\"."
		fi
	else
		echo "There is no jargorup named \"$2\"."
	fi
}

# Lists the players currently connected to a server
# $1: The ID of the server
server_connected() {
	if server_is_running "$1"; then
		local line="$(server_eval_and_get_line "$1" "list" "Connected players:")"
		
		# Cuts the start off the line, and the last three (invisible)
		# characters from the end.
		local players="${line:46}"
		
		if [ -z "$players" ]; then
			echo "No players are connected."
		else
			echo "$players"
		fi
	else
		echo "Server \"${server_name[$id]}\" is not running. No users are connected."
	fi
}


### Manager Functions

# Stops all running servers after a servers specified delay
# $1: String containing "stop" or "restart". Represents whether the stop is 
#     with a mind to stop the server, or just to restart it. And effects
#     the message issued to players on a server.
manager_stop_all_servers() {
	# An array of true/false for each server
	local was_running
	# False if no servers were running at all
	local any_running="false"
	
	# For all running servers issue the stop warning
	local max_countdown=0
	
	for ((server=0; server<${num_servers}; server++)); do
		if server_is_running "$server"; then
			any_running="true"
			was_running[$server]="true"
			STOP_COUNTDOWN[$server]="true"
			if [[ "${server_stop_delay[$i]}" -gt "$max_countdown" ]]; then
				max_countdown="${server_stop_delay[$server]}"
			fi
			
			# Send a warning message to the server
			case "$1" in
				stop) server_eval "$server" "say ${server_stop_message[$server]}";;
				restart) server_eval "$server" "say ${server_restart_message[$server]}";;
			esac
			
			# Send message to stdout
			echo "Server \"${server_name[$server]}\" was running, now stopping:"
			
			case "$1" in
				stop) echo "    Issued the warning \"${server_stop_message[$server]}\" to players.";;
				restart) echo "    Issued the warning \"${server_restart_message[$server]}\" to players.";;
			esac
			
			case "${server_stop_delay[$server]}" in
				0) echo "    Stopping without delay.";;
				1) echo "    Stopping after 1 second.";;
				*) echo "    Stopping after ${server_stop_delay[$server]} seconds.";;
			esac
		else
			echo "Server \"${server_name[$server]}\" was NOT running."
			was_running[$server]="false"
		fi
	done
	
	if "$any_running"; then
		# Wait for the maximum possible delay, stopping servers
		# at the correct times
		echo -n "All servers will have been issued the stop command... "
		for ((tick="${max_countdown}"; tick>=0; tick--)); do
			tput sc # Save cursor position
		
			if [[ "$tick" -le 1 ]]; then
				echo -n "in $tick second."
			else
				echo -n "in $tick seconds."
			fi
		
			# Each second check all server, to see if its their time to
			# stop. If so issue the stop command, and don't hang.
			for ((server=0; server<${num_servers}; server++)); do
				if server_is_running "$server"; then
					stop_tick="$(( ${max_countdown} - ${server_stop_delay[$server]} ))"
					if [[ "$stop_tick" == "$tick" ]]; then
						server_eval "$server" "stop"
						STOP_COUNTDOWN[$server]="false"
					fi
				fi
			done
		
			if [[ "$tick" > 0 ]]; then
				sleep 1
			fi

			tput rc # Restore cursor to position of last `sc'
			tput el # Clear to end of line
		done
	
		# Start a new line
		echo "Now."
	
		# Finally check all servers have stopped
		for ((server=0; server<${num_servers}; server++)); do
			if "${was_running[$server]}"; then
				echo -n "Ensuring server \"${server_name[$server]}\" has stopped... "
				server_wait_for_stop "$server"
				echo "Done."
			fi
		done
	else
		echo "No servers were running."
	fi
}

# Stops all running servers without delay
manager_stop_all_servers_now() {
	# An array of true/false for each server
	local was_running
	# False if no servers were running at all
	local any_running="false"
	
	# Stop all servers at the same time
	for ((server=0; server<${num_servers}; server++)); do
		if server_is_running "$server"; then
			was_running[$server]="true"
			any_running="true"
			echo "Server \"${server_name[$server]}\" was running, now stopping."
			server_eval "$server" "stop"
		else
			echo "Server \"${server_name[$server]}\" was NOT running."
			was_running[$server]="false"
		fi
	done
	
	if "$any_running"; then
		# Ensure all the servers have stopped
		for ((server=0; server<${num_servers}; server++)); do
			if "${was_running[$server]}"; then
				echo -n "Ensuring server \"${server_name[$server]}\" has stopped... "
				server_wait_for_stop "$server"
				echo "Done."
			fi
		done
	else
		echo "No servers were running."
	fi
}


### Main Functions

# Initialises a server's world
# $1: The server id
# $2: The world id to use
# $3: The name of the world
server_world_init() {
	world_server_id[$2]="$1"
	world_name[$2]="$3"
	world_active_path[$2]="${server_world_storage[$1]}/${world_name[$2]}"
	world_inactive_path[$2]="${server_world_storage_inactive[$1]}/${world_name[$2]}"
	
	# Set the status of this world (active/inactive)
	if [ -d "${world_active_path[$2]}" ]; then
		world_status[$2]="active"
		world_path[$2]="${world_active_path[$2]}"
	else
		if [ -d "${world_inactive_path[$2]}" ]; then
			world_status[$2]="inactive"
			world_path[$2]="${world_inactive_path[$2]}"
		else
			world_status[$2]="unknown"
			
			echoerr "Error: World cannot be found in either \"${world_active_path[$2]}\" or \"${world_inactive_path[$2]}\"."
			return 1
		fi
	fi
	
	world_link[$2]="${server_path[$1]}/${world_name[$2]}"
	world_flag_inram[$2]="${world_path[$2]}/$WORLD_FLAG_INRAM"
	world_backup_path[$2]="$WORLD_ARCHIVE_PATH/${server_name[$1]}/${world_name[$2]}"

	# If the ramdisk path is set, get the path for this world
	if [ ! -z "$RAMDISK_STORAGE_PATH" ]; then
		world_ramdisk_path[$2]="${RAMDISK_STORAGE_PATH}/${server_name[$1]}/${world_name[$2]}"
	fi

	# Detect whether this world should be in ram
	if [[ -e "${world_path[$2]}/$WORLD_FLAG_INRAM" ]]; then
		world_inram[$2]="true"
	else
		world_inram[$2]="false"
	fi
}

# Load a config file for a server
# $1: The id of the server to laod
server_load_config() {
	local name value
	
	if [[ -f "${server_conf[$1]}" ]]; then
		while read line; do 
		 	# ignore comment lines
			echo "$line" | grep "^#" >/dev/null 2>&1 && continue

		   	# if not empty, set the property using declare
		   	if [ ! -z "$line" ]; then
			 	name="$(echo $line | awk -F '=' '{print $1}')"
				value="$(echo $line | awk -F '\"' '{print $2}')"
			fi

			case "$name" in
				SERVER_USER) server_user_name[$1]="$value";;
				SCREEN_NAME) server_screen_name[$1]="$value";;
				WORLD_STORAGE_PATH) server_world_storage[$1]="${server_path[$1]}/$value";;
				WORLD_STORAGE_INACTIVE_PATH) server_world_storage_inactive[$1]="${server_path[$1]}/$value";;

				LOG) server_log[$1]="${server_path[$1]}/$value";;
				PROPERTIES) server_properties[$1]="$value";;
				WHITELIST) server_whitelist[$1]="$value";;
				BANNED_PLAYERS) server_banned_players[$1]="$value";;
				BANNED_IPS) server_banned_ips[$1]="$value";;

				OPS) server_ops[$1]="$value";;
				JAR) server_jar[$1]="${server_path[$1]}/$value";;
				RAM) server_ram[$1]="$value";;
				INVOCATION) server_invocation[$1]="$value";;

				STOP_DELAY) server_stop_delay[$1]="$value";;
				RESTART_DELAY) server_restart_delay[$1]="$value";;
				STOP_MESSAGE) server_stop_message[$1]="$value";;
				STOP_ABORT) server_stop_abort[$1]="$value";;
				RESTART_MESSAGE) server_restart_message[$1]="$value";;
				RESTART_ABORT) server_restart_abort[$1]="$value";;
				WORLD_BACKUP_STARTED) server_world_backup_started[$1]="$value";;
				WORLD_BACKUP_FINISHED) server_world_backup_finished[$1]="$value";;

				COMPLETE_BACKUP_STARTED) server_complete_backup_started[$1]="$value";;
				COMPLETE_BACKUP_FINISHED) server_complete_backup_finished[$1]="$value";;
				CONFIRM_SAVE_ON) server_confirm_save_on[$1]="$value";;
				CONFIRM_SAVE_OFF) server_confirm_save_off[$1]="$value";;
				CONFIRM_SAVE_ALL) server_confrim_save_all[$1]="$value";;
				CONFIRM_START) server_confrim_start[$1]="$value";;
				CONFIRM_WHITELIST_LIST) server_confirm_whitelist_list[$1]="$value";;
				CONFIRM_KICK) server_confirm_kick[$1]="$value";;
				CONFIRM_KICK_FAIL) server_confirm_kick_fail[$1]="$value";;
				CONFIRM_TIME_SET) server_confirm_time_set[$1]="$value";;
				CONFIRM_TIME_SET_FAIL) server_confirm_time_set_fail[$1]="$value";;
				CONFIRM_TIME_ADD) server_confirm_time_add[$1]="$value";;
				CONFIRM_TIME_ADD_FAIL) server_confirm_time_add_fail[$1]="$value";;
				CONFIRM_TOGGLEDOWNFALL) server_confirm_toggledownfall[$1]="$value";;
				CONFIRM_TOGGLEDOWNFALL_FAIL) server_confirm_toggledownfall_fail[$1]="$value";;
				CONFIRM_GAMEMODE) server_confirm_gamemode[$1]="$value";;
				CONFIRM_GAMEMODE_FAIL_NO_USER) server_confirm_gamemode_fail_no_user[$1]="$value";;
				CONFIRM_GAMEMODE_FAIL_NO_CHANGE) server_confirm_gamemode_fail_no_change[$1]="$value";;
				COMPLETE_BACKUP_FOLLOW_SYMLINKS) server_complete_backup_follow_symlinks[$1]="$value";;
			esac
		done < "${server_conf[$1]}"
	fi
}

# Initialise a server's variables
# $1: The id to use for this server
# $2: The name of the server
server_init() {
	server_name[$1]="$2"
	server_path[$1]="$SERVER_STORAGE_PATH/$2"
	server_conf[$1]="${server_path[$1]}/$DEFAULT_SERVER_CONF"
	server_flag_active[$1]="${server_path[$1]}/$SERVER_FLAG_ACTIVE"
	server_backup_path[$1]="$BACKUP_ARCHIVE_PATH/${server_name[$1]}"
	server_log_archive_path[$1]="$LOG_ARCHIVE_PATH/${server_name[$1]}"
	
	if [[ -e "${server_flag_active[$1]}" ]]; then
		server_active[$1]="true"
	else
		server_active[$1]="false"
	fi
	
	# Setup defaults
	# Note: screen_name will at this stage have the {SERVER_NAME} tag in it
	# which needs to be replaced.
	# Invocation may also the {RAM} and {JAR} tags.
	
	server_user_name[$1]="$DEFAULT_SERVER_USER"
	server_screen_name[$1]="${DEFAULT_SCREEN_NAME//\{SERVER_NAME\}/${server_name[$1]}}" # Replace tags now, they cannot change
	server_world_storage[$1]="${server_path[$1]}/$DEFAULT_WORLD_STORAGE_PATH"
	server_world_storage_inactive[$1]="${server_path[$1]}/$DEFAULT_WORLD_STORAGE_INACTIVE_PATH"
	server_log[$1]="${server_path[$1]}/$DEFAULT_LOG"
	server_properties[$1]="${server_path[$1]}/$DEFAULT_PROPERTIES"
	server_whitelist[$1]="${server_path[$1]}/$DEFAULT_WHITELIST"
	server_banned_players[$1]="${server_path[$1]}/$DEFAULT_BANNED_PLAYERS"
	server_banned_ips[$1]="${server_path[$1]}/$DEFAULT_BANNED_IPS"
	server_ops[$1]="${server_path[$1]}/$DEFAULT_OPS"
	server_jar[$1]="${server_path[$1]}/$DEFAULT_JAR"
	server_ram[$1]="$DEFAULT_RAM"
	server_invocation[$1]="$DEFAULT_INVOCATION" # Don't replace tags yet, they may change
	server_stop_delay[$1]="$DEFAULT_STOP_DELAY"
	server_restart_delay[$1]="$DEFAULT_RESTART_DELAY"
	server_stop_message[$1]="$DEFAULT_STOP_MESSAGE"
	server_stop_abort[$1]="$DEFAULT_STOP_ABORT"
	server_restart_message[$1]="$DEFAULT_RESTART_MESSAGE"
	server_restart_abort[$1]="$DEFAULT_RESTART_ABORT"
	server_world_backup_started[$1]="$DEFAULT_WORLD_BACKUP_STARTED"
	server_world_backup_finished[$1]="$DEFAULT_WORLD_BACKUP_FINISHED"
	server_complete_backup_started[$1]="$DEFAULT_COMPLETE_BACKUP_STARTED"
	server_complete_backup_finished[$1]="$DEFAULT_COMPLETE_BACKUP_FINISHED"
	server_confirm_save_on[$1]="$DEFAULT_CONFIRM_SAVE_ON"
	server_confirm_save_off[$1]="$DEFAULT_CONFIRM_SAVE_OFF"
	server_confirm_save_all[$1]="$DEFAULT_CONFIRM_SAVE_ALL"
	server_confirm_start[$1]="$DEFAULT_CONFIRM_START"
	server_confirm_kick[$1]="$DEFAULT_CONFIRM_KICK"
	server_confirm_kick_fail[$1]="$DEFAULT_CONFIRM_KICK_FAIL"
	server_confirm_time_set[$1]="$DEFAULT_CONFIRM_TIME_SET"
	server_confirm_time_set_fail[$1]="$DEFAULT_CONFIRM_TIME_SET_FAIL"
	server_confirm_time_add[$1]="$DEFAULT_CONFIRM_TIME_ADD"
	server_confirm_time_add_fail[$1]="$DEFAULT_CONFIRM_TIME_ADD_FAIL"
	server_confirm_toggledownfall[$1]="$DEFAULT_CONFIRM_TOGGLEDOWNFALL"
	server_confirm_toggledownfall_fail[$1]="$DEFAULT_CONFIRM_TOGGLEDOWNFALL_FAIL"
	server_confirm_gamemode[$1]="$DEFAULT_CONFIRM_GAMEMODE"
	server_confirm_gamemode_fail_no_user[$1]="$DEFAULT_CONFIRM_GAMEMODE_FAIL_NO_USER"
	server_confirm_gamemode_fail_no_change[$1]="$DEFAULT_CONFIRM_GAMEMODE_FAIL_NO_CHANGE"
	server_complete_backup_follow_symlinks[$1]="$DEFAULT_COMPLETE_BACKUP_FOLLOW_SYMLINKS"
	
	
	# Load config overrides from server config file if present
	server_load_config "$1"
	
	
	# Replace tags in delay messages
	server_stop_message[$1]="${server_stop_message[$1]//\{DELAY\}/${server_stop_delay[$1]}}"
	server_restart_message[$1]="${server_restart_message[$1]//\{DELAY\}/${server_restart_delay[$1]}}"
	
	# Replace tags in server invocation
	server_invocation[$1]="${server_invocation[$1]//\{RAM\}/${server_ram[$1]}}"
	server_invocation[$1]="${server_invocation[$1]//\{JAR\}/${server_jar[$1]}}"
	
	
	# Load worlds if there is a world storage directory present
	server_world_offset[$1]=0
	server_num_worlds[$1]=0
	
	# Start world id's for this server's worlds at the end of the array
	local id="$num_worlds"
	
	# Record the index at which worlds for this server start
	server_world_offset[$1]="$id"
	
	if [[ -d "${server_world_storage[$1]}" ]]; then
		# Load active worlds
		while IFS= read -r -d $'\0' path; do
			local name="$(basename "$path")"
			server_world_init "$1" "$id" "$name"
			
			# Build the server_worlds comma separated list
			if [[ "$id" == "${server_world_offset[$1]}" ]]; then
				server_worlds[$1]="$name"
			else
				server_worlds[$1]="${server_worlds[$1]}, $name"
			fi
			
			id="$(($id+1))"
			num_worlds="$id"
		done < <(find "${server_world_storage[$1]}" -mindepth 1 -maxdepth 1 -type d -print0)
	fi
	
	if [[ -d "${server_world_storage_inactive[$1]}" ]]; then
		# Load inactive worlds
		while IFS= read -r -d $'\0' path; do
			local name="$(basename "$path")"
			server_world_init "$1" "$id" "$name"
			
			# Build the server_worlds_inactive comma separated list
			if [[ "$id" == "${server_world_offset[$1]}" ]]; then
				server_worlds[$1]="$name"
			else
				server_worlds[$1]="${server_worlds[$1]}, $name"
			fi
			
			id="$(($id+1))"
			num_worlds="$id"
		done < <(find "${server_world_storage_inactive[$1]}" -mindepth 1 -maxdepth 1 -type d -print0)
	fi
	
	# Record the number of worlds this server has
	server_num_worlds[$1]="$(( $id - ${server_world_offset[$1]} ))"
}

# Asserts that a variable has been set in the config file
# $1: The name of the variable to test
# $2: The message to print to stderr if the variable is unset
assert_is_set_in_config() {
    [[ ! ${!1} && ${!1-_} ]] && {
        echoerr "Error: $1 must be set in $CONF"
		exit 1
    }
}

# Ensures all non-optional settings have been set
init_ensure_settings() {
	assert_is_set_in_config USERNAME
	assert_is_set_in_config SERVER_STORAGE_PATH
	assert_is_set_in_config JAR_STORAGE_PATH
	assert_is_set_in_config RAMDISK_STORAGE_PATH
	
	assert_is_set_in_config WORLD_ARCHIVE_PATH
	assert_is_set_in_config LOG_ARCHIVE_PATH
	assert_is_set_in_config BACKUP_ARCHIVE_PATH
	
	assert_is_set_in_config DEFAULT_SERVER_CONF
	assert_is_set_in_config DEFAULT_SERVER_USER
	assert_is_set_in_config DEFAULT_SCREEN_NAME
	assert_is_set_in_config DEFAULT_WORLD_STORAGE_PATH
	assert_is_set_in_config DEFAULT_WORLD_STORAGE_INACTIVE_PATH
	assert_is_set_in_config DEFAULT_COMPLETE_BACKUP_FOLLOW_SYMLINKS
	
	assert_is_set_in_config DEFAULT_LOG
	assert_is_set_in_config DEFAULT_PROPERTIES
	assert_is_set_in_config DEFAULT_WHITELIST
	assert_is_set_in_config DEFAULT_BANNED_PLAYERS
	assert_is_set_in_config DEFAULT_BANNED_IPS
	assert_is_set_in_config DEFAULT_OPS

	assert_is_set_in_config DEFAULT_JAR
	assert_is_set_in_config DEFAULT_RAM
	assert_is_set_in_config DEFAULT_INVOCATION
	
	assert_is_set_in_config DEFAULT_STOP_DELAY
	assert_is_set_in_config DEFAULT_RESTART_DELAY
	assert_is_set_in_config DEFAULT_STOP_MESSAGE
	assert_is_set_in_config DEFAULT_STOP_ABORT
	assert_is_set_in_config DEFAULT_RESTART_MESSAGE
	assert_is_set_in_config DEFAULT_RESTART_ABORT
	assert_is_set_in_config DEFAULT_WORLD_BACKUP_STARTED
	assert_is_set_in_config DEFAULT_WORLD_BACKUP_FINISHED
	assert_is_set_in_config DEFAULT_COMPLETE_BACKUP_STARTED
	assert_is_set_in_config DEFAULT_COMPLETE_BACKUP_FINISHED
	assert_is_set_in_config DEFAULT_CONFIRM_SAVE_ON
	assert_is_set_in_config DEFAULT_CONFIRM_SAVE_OFF
	assert_is_set_in_config DEFAULT_CONFIRM_SAVE_ALL
	assert_is_set_in_config DEFAULT_CONFIRM_START
	assert_is_set_in_config DEFAULT_CONFIRM_KICK
	assert_is_set_in_config DEFAULT_CONFIRM_KICK_FAIL
	assert_is_set_in_config DEFAULT_CONFIRM_TIME_SET
	assert_is_set_in_config DEFAULT_CONFIRM_TIME_SET_FAIL
	assert_is_set_in_config DEFAULT_CONFIRM_TIME_ADD
	assert_is_set_in_config DEFAULT_CONFIRM_TIME_ADD_FAIL
	assert_is_set_in_config DEFAULT_CONFIRM_TOGGLEDOWNFALL
	assert_is_set_in_config DEFAULT_CONFIRM_TOGGLEDOWNFALL_FAIL
	assert_is_set_in_config DEFAULT_CONFIRM_GAMEMODE
	assert_is_set_in_config DEFAULT_CONFIRM_GAMEMODE_FAIL_NO_USER
	assert_is_set_in_config DEFAULT_CONFIRM_GAMEMODE_FAIL_NO_CHANGE
}

init() {
	# Sourcing $CONF will override the previous defaults, with new values
	source "$CONF"
	
	init_ensure_settings
	
	num_worlds=0
	num_servers=0
	
	if [ -d "$SERVER_STORAGE_PATH" ]; then
		local id=0
		while IFS= read -r -d $'\0' path; do
			local name="$(basename "$path")"
			server_init "$id" "$name"
			id="$(($id+1))"
			num_servers="$id"
		done < <(find "$SERVER_STORAGE_PATH" -mindepth 1 -maxdepth 1 -type d -print0)
	fi
}

# Called if the script is interrupted before exiting naturally
interrupt() {
	local exit_message="false"
	for ((i=0; $i<$num_servers; i++)); do
		if [[ "${STOP_COUNTDOWN[$i]}" == "true" ]] && server_is_running "$i"; then
			if [[ "$exit_message" == "false" ]]; then
				echo -e "\nInterrupted..."
				exit_message="true"
			fi
			server_eval "$i" "say ${server_stop_abort[$i]}"
			echo "Server \"${server_name[$i]}\" shutdown was aborted."
		fi
		
		if [[ "${RESTART_COUNTDOWN[$i]}" == "true" ]] && server_is_running "$i"; then
			if [[ "$exit_message" == "false" ]]; then
				echo -e "\nInterrupted..."
				exit_message="true"
			fi
			server_eval "$i" "say ${server_restart_abort[$i]}"
			echo "Server \"${server_name[$i]}\" restart was aborted."
		fi
	done
	exit
}

# The main function which starts the script
main() {
	# Initialise variables that represent system state
	init
	
	# Trap interrupts to the script by calling the interrupt function
	trap interrupt EXIT
	
	case "$1" in
		start)
			# Required start option, for debian init.d scripts
			for ((server=0; server<${num_servers}; server++)); do
				# Only starts active servers
				if "${server_active[$server]}"; then
					if server_is_running "$server"; then
						echo "[ACTIVE] Server \"${server_name[$server]}\" already started."
					else
						echo "[ACTIVE] Server \"${server_name[$server]}\" starting:"
						server_start "$server"
					fi
				else
					if server_is_running "$server"; then
						echo "[INACTIVE] Server \"${server_name[$server]}\" already started. It should not be running! Use \"$0 ${server_name[$server]} stop\" to stop this server."
					else
						echo "[INACTIVE] Server \"${server_name[$server]}\" leaving stopped, as this server is inactive."
					fi
				fi
			done
			;;
		stop)
			if [ "$2" != "now" ]; then
				# If the the now flag is not specified
				manager_stop_all_servers "stop"
			else
				# If the now flag is specified
				manager_stop_all_servers_now
			fi
			;;
		restart)
			# Required restart option, for debian init.d scripts
			
			# Stop any running servers, now if specified
			echo "Stopping servers:"
			main "stop" "$2"
			
			echo "Starting servers:"
			main "start"
			;;
		version)
			echo "Minecraft Server Manager $VERSION"
			;;
		server)
			case "$2" in
				list)
					# Lists the existing servers
					server_list
					;;
				create)
					if [ -z "$3" ]; then
						# If a server name is not provided
						echo "Invalid command."
					else
						# Create a new server
						server_create "$3"
					fi
					;;
				delete)
					if [ -z "$3" ]; then
						# If a server name is not provided
						echo "Invalid command."
					else
						# Delete an existing server, with confirmation
						server_delete "$3"
					fi
					;;
				rename)
					if [ -z "$3" ] || [ -z "$4" ]; then
						# If a server name is not provided
						echo "Invalid command."
					else
						# Rename an existing server
						server_rename "$3" "$4"
					fi
					;;
				*)
					# "server" is not a valid command
					echo "Invalid command."
					;;
			esac
			;;
		jargroup)
			case "$2" in
				list)
					# Lists the jars grouped by jargroup
					jargroup_list
					;;
				create)
					if [ -z "$3" ] || [ -z "$4" ]; then
						echo "Invlaid command."
					else
						jargroup_create "$3" "$4"
					fi
					;;
				delete)
					if [ -z "$3" ]; then
						echo "Invalid command."
					else
						jargroup_delete "$3"
					fi

					;;
				rename)
					if [ -z "$3" ] || [ -z "$4" ]; then
						echo "Invalid command."
					else
						jargroup_rename "$3" "$4"
					fi
					;;
				changetarget)
					if [ -z "$3" ] || [ -z "$4" ]; then
						echo "Invalid command."
					else
						jargroup_settarget "$3" "$4"
					fi
					;;
				getlatest)
					if [ -z "$3" ]; then
						echo "Invalid command."
					else
						jargroup_getlatest "$3"
					fi
					;;
				*)
					# "jargroup" is not a valid command
					echo "Invalid command."
					;;
			esac
			;;
		help)
			# Outputs a list of all commands
			echo -e "Usage: $0 command:"
			echo -e
			echo -e "--Setup Commands------------------------------------------------"
			echo -e "  server list                                   List servers"
			echo -e "  server create <name>                          Creates a new Minecraft server"
			echo -e "  server delete <name>                          Deletes an existing Minecraft server"
			echo -e "  server rename <name> <new-name>               Renames an existing Minecraft server"
			echo -e
			echo -e "--Server Mangement Commands-------------------------------------"
			echo -e "  <server> start                                Starts a server"
			echo -e "  <server> stop [now]                           Stops a server after warning players, or right now"
			echo -e "  <server> restart [now]                        Restarts a server after warning players, or right now"
			echo -e "  <server> status                               Show the running/stopped status of a server"
			echo -e "  <server> connected                            List a servers connected players"
			echo -e "  <server> worlds list                          Lists the worlds a server has"
			echo -e "  <server> worlds load                          Creates links to worlds in storage for a server"
			echo -e "  <server> worlds ram <world>                   Toggles a world's \"in RAM\" status"
			echo -e "  <server> worlds todisk                        Synchronises any \"in RAM\" worlds to disk a server has"
			echo -e "  <server> worlds backup                        Makes a backup of all worlds a server has"
			echo -e "  <server> worlds on|off <world>                Activate or deactivate a world, inactive worlds are not backed up"
			echo -e "  <server> logroll                              Move a server log to a gziped archive, to reduce lag"
			echo -e "  <server> backup                               Makes a backup of an entire server directory"
			echo -e "  <server> jar <jargroup> [<file>]              Sets a server's jar file"
			echo -e
			echo -e "--Server Pass Through Commands----------------------------------"
			echo -e "  <server> wl on|off                            Enables/disables server whitelist checking"
			echo -e "  <server> wl add|remove <player>               Add/remove a player to/from a server's whitelist"
			echo -e "  <server> wl list                              List the players whitelisted for a server"
			echo -e "  <server> bl player add|remove <player>        Ban/pardon a player from/for a server"
			echo -e "  <server> bl ip add|remove <ip address>        Ban/pardon an IP address from/for a server"
			echo -e "  <server> bl list                              Lists the banned players and IP address for a server"
			echo -e "  <server> op add|remove <player>               Add/remove operator status for a player on a server"
			echo -e "  <server> op list                              Lists the operator players for a server"
			echo -e "  <server> gm survival|creative <player>        Change the game mode for a player on a server"
			echo -e "  <server> kick <player>                        Forcibly disconnect a player from a server"
			echo -e "  <server> say <message>                        Broadcast a (pink) message to all players on a server"
			echo -e "  <server> time set|add <number>                Set/increment time on a server (0-24000)"
			echo -e "  <server> toggledownfall                       Toggles rain and snow on a server"
			echo -e "  <server> save on|off                          Enable/disable writing world changes to file"
			echo -e "  <server> save all                             Force the writing of all non-saved world changes to file"
			echo -e "  <server> cmd <command>                        Send a command string to the server and return"
			echo -e "  <server> cmdlog <command>                     Same as 'cmd' but shows log output afterwards (Ctrl+C to exit)"
			echo -e
			echo -e "--Jar Commands--------------------------------------------------"
			echo -e "  jargroup list                                 List the stored jar files."
			echo -e "  jargroup create <name> <download-url>         Create a new jar group, with a URL for new downloads"
			echo -e "  jargroup delete <name>                        Delete a jar group"
			echo -e "  jargroup rename <name> <new-name>             Rename a jar group"
			echo -e "  jargroup changeurl <name> <download-url>      Change the download URL for a jar group"
			echo -e "  jargroup getlatest <name>                     Download the latest jar file for a jar group"
			echo -e
			echo -e "--Global Commands-----------------------------------------------"
			echo -e "  start                                         Starts all active servers"
			echo -e "  stop [now]                                    Stops all running servers"
			echo -e "  restart [now]                                 Restarts all active servers"
			echo -e "  version                                       Prints the Minecraft Server Manager version installed8"
			;;
		"")
			echo "No such command see: $0 help"
			;;
		*)	
			if [[ "$1" == "all" ]] || [[ -e "$SERVER_STORAGE_PATH/$1" ]]; then
				
				local id="$(server_get_id "$1")"
				
				case "$2" in
					start)
						server_set_active "$id" "active"
						server_start "$id"
						;;
					stop)
						server_set_active "$id" "inactive"
						if [[ "$3" != "now" ]]; then
							server_stop "$id"
						else
							server_stop_now "$id"
						fi
						;;
					restart)
						server_set_active "$1" "active"
						if [[ "$3" != "now" ]]; then
							server_restart "$id"
						else
							server_restart_now "$id"
						fi
						;;
					status)
						if server_is_running "$id"; then
							echo "Server \"${server_name[$id]}\" is running."
						else
							echo "Server \"${server_name[$id]}\" is stopped."
						fi
						;;
					connected)
						server_connected "$id"
						;;
					worlds)
						case "$3" in
							list)
								server_worlds_list "$id"
								;;
							load)
								server_ensure_links "$id"
								;;
							ram)
								if [ -z "$4" ]; then
									echo "Invalid command."
								else
									world_id="$(server_world_get_id "$id" "$4")"
									
									if [ ! -z "$world_id" ]; then
										world_toggle_ramdisk_state "$world_id"
									else
										echo "Server \"${server_name[$id]}\" has no world with that name."
									fi
								fi
								;;
							todisk)
								server_save_off "$id"
								server_save_all "$id"
								server_worlds_to_disk "$id"
								server_save_on "$id"
								;;
							backup)
								if server_is_running "$id"; then
									server_eval "$id" "say ${server_world_backup_started[$id]}"
									server_save_off "$id"
									server_save_all "$id"
								fi
								
								server_worlds_to_disk "$id"
								server_worlds_backup "$id"
								
								if server_is_running "$id"; then
									server_save_on "$id"
									server_eval "$id" "say ${server_world_backup_finished[$id]}"
								fi
								
								echo "Backup took $SECONDS seconds".
								;;
							on)
								if [ -z "$4" ]; then
									echo "Invalid command."
								else
									world_activate "$(server_world_get_id "$id" "$4")"
								fi
								;;
							off)
								if [ -z "$4" ]; then
									echo "Invalid command."
								else
									world_deactivate "$(server_world_get_id "$id" "$4")"
								fi
								;;
							*)
								echo "Invalid command."
								;;
						esac
						;;
					logroll)
						server_log_roll "$id"
						;;
					backup)
						if server_is_running "$id"; then
							server_eval "$id" "say ${server_complete_backup_started[$id]}"
							server_save_off "$id"
							server_save_all "$id"
						fi
						
						server_worlds_to_disk "$id"
						server_backup "$id"
						
						if server_is_running "$id"; then
							server_save_on "$id"
							server_eval "$id" "say ${server_complete_backup_finished[$id]}"
						fi
						
						echo "Backup took $SECONDS seconds".
						;;
					jar)
						if [ -z "$3" ]; then
							echo "Invalid command."
						else
							server_set_jar "$id" "$3" "$4"
						fi
						;;
					whitelist|wl)
						case "$3" in
							on)
								if server_is_running "$id"; then
									server_eval "$id" "whitelist on"
									echo "Whitelist enabled"
								else
									echo "Server \"${server_name[$id]}\" is not running."
								fi
								;;
							off)
								if server_is_running "$id"; then
									server_eval "$id" "whitelist off"
									echo "Whitelist disabled"
								else
									echo "Server \"${server_name[$id]}\" is not running."
								fi
								;;
							add)
								if [ -z "$4" ]; then
									echo "Invalid command."
								else
									if server_is_running "$id"; then
										server_eval "$id" "whitelist add $4"
										echo "Added \"$4\" to the whitelist."
									else
										echo "Server \"${server_name[$id]}\" is not running."
									fi
								fi
								;;
							remove)
								if [ -z "$4" ]; then
									echo "Invalid command."
								else
									if server_is_running "$id"; then
										server_eval "$id" "whitelist remove $4"
										echo "Removed \"$4\" from the whitelist."
									else
										echo "Server \"${server_name[$id]}\" is not running."
									fi
								fi
								;;
							list)
								local players="$(cat "${server_whitelist[$id]}")"

								if [ -z "$players" ]; then
									echo "No players are whitelisted."
								else
									echo "$players"
								fi
								;;
							*)
								echo "Invalid command."
								;;
						esac
						;;
					blacklist|bl)
						case "$3" in
							player)
								if [ -z "$5" ]; then
									echo "Invalid command."
								else
									case "$4" in
										add)
											for player in ${*:5}; do
											 	server_eval "$id" "ban $player"
											done
											if [[ $# -gt 5 ]]; then
												echo -n "Blacklisted the following players: "
												echo -n "$5"
												for player in ${*:6}; do
												 	echo -n ", $player"
												done
												echo "."
											else
												echo "Blacklisted \"$5\"."
											fi
											;;
										remove)
											for player in ${*:5}; do
											 	server_eval "$id" "pardon $player"
											done
											if [[ $# -gt 5 ]]; then
												echo -n "Removed the following players from the blacklist: "
												echo -n "$5"
												for player in ${*:6}; do
												 	echo -n ", $player"
												done
												echo "."
											else
												echo "Removed \"$5\" from the blacklist."
											fi
											;;
										*)
											echo "Invalid command."
											;;
									esac
								fi
								;;
							ip)
								case "$4" in
									add)
										for address in ${*:5}; do
										 	server_eval "$id" "ban-ip $address"
										done
										if [[ $# > 5 ]]; then
											echo -n "Blacklisted the following ip addresses: "
											echo -n "$5"
											for player in ${*:6}; do
											 	echo -n ", $address"
											done
											echo "."
										else
											echo "Blacklisted \"$5\"."
										fi
										;;
									remove)
										for address in ${*:5}; do
										 	server_eval "$id" "pardon-ip $address"
										done
										if [[ $# > 5 ]]; then
											echo -n "Removed the following ip addresses from the blacklist: "
											echo -n "$5"
											for player in ${*:6}; do
											 	echo -n ", $address"
											done
											echo "."
										else
											echo "Removed \"$5\" from the ip blacklist."
										fi
										;;
									*)
										echo "Invalid command."
										;;
								esac
								;;
							list)
								local players="$(cat "${server_banned_players[$id]}")"
								
								local ips="$(cat "${server_banned_ips[$id]}")"

								if [[ -z "$players" && -z "$ips" ]]; then
									echo "The blacklist is empty."
								else
									if [[ ! -z "$players" ]]; then
										echo "Players:"
										for name in $players; do
											echo "    $name"
										done
									fi
									
									if [[ ! -z "$ips" ]]; then
										echo "IP Addresses:"
										for address in $ips; do
											echo "    $address"
										done
									fi
								fi
								;;
							*)
								echo "Invalid command."
								;;
						esac
						;;
					operator|op)
						case "$3" in
							add)
								if server_is_running "$id"; then
									server_eval "$id" "op $4"
									echo "The player \"$4\" is now an operator for the server."
								else
									echo "Server \"${server_name[$id]}\" is not running."
								fi
								;;
							remove)
								if server_is_running "$id"; then
									server_eval "$id" "deop $4"
									echo "The player \"$4\" is no longer an operator for the server."
								else
									echo "Server \"${server_name[$id]}\" is not running."
								fi
								;;
							list)
								local players="$(cat "${server_ops[$id]}")"

								if [ -z "$players" ]; then
									echo "No players are operators."
								else
									echo "$players"
								fi
								;;
							*)
								echo "Invalid command"
								;;
						esac
						;;
					gamemode|gm)
						case "$3" in
							survival|creative|0|1)
								if [ -z "$4" ]; then
									echo "Invalid command."
								else
									if server_is_running "$id"; then
										case "$3" in
											creative|1) local mode=1;;
											survival|0) local mode=0;;
											*) echoerr "Invalid mode"; exit 1;;
										esac
										
										local line="$(server_eval_and_get_line "$id" "gamemode $4 $mode" "${server_confirm_gamemode[$id]}" "${server_confirm_gamemode_fail_no_user[$id]}" "${server_confirm_gamemode_fail_no_change[$id]}")"

										local regex="${LOG_REGEX} ${server_confirm_gamemode[$id]}"
										if [[ "$line" =~ $regex ]]; then
											echo "Changed game mode of \"$4\" to \"$3\"."
										fi
										local regex="${LOG_REGEX} ${server_confirm_gamemode_fail_no_user[$id]}"
										if [[ "$line" =~ $regex ]]; then
											echo "The player \"$4\" was not found to be logged on."
										fi
										local regex="${LOG_REGEX} ${server_confirm_gamemode_fail_no_change[$id]}"
										if [[ "$line" =~ $regex ]]; then
											echo "The player \"$4\" was already in mode \"$3\"."
										fi
									else
										echo "Server \"${server_name[$id]}\" is not running."
									fi
								fi
								;;
							*)
								echo "Invalid command."
								;;
						esac
						;;
					kick)
						if [ -z "$3" ]; then
							echo "Invalid command."
						else
							if server_is_running "$id"; then
								local line="$(server_eval_and_get_line "$id" "kick $3" "${server_confirm_kick[$id]}" "${server_confirm_kick_fail[$id]}")"
								
								local regex="${LOG_REGEX} ${server_confirm_kick[$id]}"
								if [[ "$line" =~ $regex ]]; then
									echo "Kicked \"$3\" from game."
								fi
								local regex="${LOG_REGEX} ${server_confirm_kick_fail[$id]}"
								if [[ "$line" =~ $regex ]]; then
									echo "The player \"$3\" is not connected."
								fi
							else
								echo "Server \"${server_name[$id]}\" is not running."
							fi
						fi
						;;
					say)
						if [ -z "$3" ]; then
							echo "Invalid command."
						else
							if server_is_running "$id"; then
								server_eval "$id" "say ${*:3}"
								echo "Message sent to players."
							else
								echo "Server \"${server_name[$id]}\" is not running."
							fi
						fi
						;;
					time)
						case "$3" in
							set)
								if [ -z "$4" ]; then
									echo "Invalid command."
								else
									if server_is_running "$id"; then
										local line="$(server_eval_and_get_line "$id" "time set $4" "${server_confirm_time_set[$id]}" "${server_confirm_time_set_fail[$id]}")"
										
										local regex="${LOG_REGEX} ${server_confirm_time_set[$id]}"
										if [[ "$line" =~ $regex ]]; then
											echo "Set time to \"$4\"."
										fi
										local regex="${LOG_REGEX} ${server_confirm_time_set_fail[$id]}"
										if [[ "$line" =~ $regex ]]; then
											echo "Unable to convert \"$4\" to a time."
										fi
									else
										echo "Server \"${server_name[$id]}\" is not running."
									fi
								fi
								;;
							add)
								if [ -z "$4" ]; then
									echo "Invalid command."
								else
									if server_is_running "$id"; then
										local line="$(server_eval_and_get_line "$id" "time add $4" "${server_confirm_time_add[$id]}" "${server_confirm_time_add_fail[$id]}")"
										
										local regex="${LOG_REGEX} ${server_confirm_time_add[$id]}"
										if [[ "$line" =~ $regex ]]; then
											echo "Added \"$4\" to time."
										fi
										local regex="${LOG_REGEX} ${server_confirm_time_add_fail[$id]}"
										if [[ "$line" =~ $regex ]]; then
											echo "Unable to convert \"$4\" to a time."
										fi
									else
										echo "Server \"${server_name[$id]}\" is not running."
									fi
								fi
								;;
							*)
								echo "Invalid command."
								;;
						esac
						;;
					toggledownfall|tdf)
						if server_is_running "$id"; then
							local line="$(server_eval_and_get_line "$id" "toggledownfall $3" "${server_confirm_toggledownfall[$id]}" "${server_confirm_toggledownfall_fail[$id]}")"
							
							local regex="${LOG_REGEX} ${server_confirm_toggledownfall[$id]}"
							if [[ "$line" =~ $regex ]]; then
								echo "${line:36:(-3)}"
							fi
							local regex="${LOG_REGEX} ${server_confirm_toggledownfall_fail[$id]}"
							if [[ "$line" =~ $regex ]]; then
								echo "${line:34:(-3)}"
							fi
						else
							echo "Server \"${server_name[$id]}\" is not running."
						fi
						;;
					save)
						case "$3" in
							on)
								server_save_on "$id"
								;;
							off)
								server_save_off "$id"
								;;
							all)
								server_save_all "$id"
								;;
							*)
								echo "Invalid command."
								;;
						esac
						;;
					cmd)
						if [ -z "$3" ]; then
							echo "Invalid command."
						else
							if server_is_running "$id"; then
								server_eval "$id" "${*:3}"
								echo "Command sent."
							else
								echo "Server \"${server_name[$id]}\" is not running."
							fi
						fi
						;;
					cmdlog)
						if [ -z "$3" ]; then
							echo "Invalid command."
						else
							if server_is_running "$id"; then
								server_eval "$id" "${*:3}"
								echo "Now watching logs (press Ctrl+C to exit):"
								as_user "${server_user_name[$id]}" "tail --follow --lines=0 --sleep-interval=0.1 ${server_log[$id]}"
							else
								echo "Server \"${server_name[$id]}\" is not running."
							fi
						fi
						;;
					console)
						if server_is_running "$id"; then
							as_user "${server_user_name[$1]}" "screen -r ${server_screen_name[$1]}"
						else
							echo "Server \"${server_name[$id]}\" is not running."
						fi
						;;
					*)
						echo "Invalid command."
						;;
				esac
			else
				echo "No server with that name."
			fi
			;;
	esac
}


### Start point

main "$@"
exit 0