mscs/msctl

#!/bin/sh

# ---------------------------------------------------------------------------
# Copyright (c) 2011-2015, Jason M. Wood <sandain@hotmail.com>
#
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice,
#    this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ---------------------------------------------------------------------------


# ---------------------------------------------------------------------------
# Minecraft Server Control Script
#
# A powerful command-line control script for Linux-powered Minecraft servers.
# ---------------------------------------------------------------------------

# Get executable name
# ---------------------------------------------------------------------------
PROG=$(basename $0)

# Script Usage
# ---------------------------------------------------------------------------

usage() {
  cat <<EOF
Usage:  $PROG [<options>] <action>

Actions:

  start <world>
    Start the Minecraft world server.  Start all world servers by default.

  stop <world>
    Stop the Minecraft world server.  Stop all world servers by default.

  force-stop <world>
    Forcibly stop the Minecraft world server.  Forcibly stop all world
    servers by default.

  restart <world>
    Restart the Minecraft world server.  Restart all world servers by default.

  force-restart <world>
    Forcibly restart the Minecraft world server.  Forcibly restart all world
    servers by default.

  create <world> <port> [<ip>]
    Create a Minecraft world server.  The world name and port must be
    provided, the IP address is usually blank.  Without arguments, create a
    a default world at the default port.

  delete <world>
    Delete a Minecraft world server.

  disable <world>
    Temporarily disable a world server.

  enable <world>
    Enable a disabled world server.

  ls <option>
    Display a list of worlds.
    Options:
      enabled   Display a list of enabled worlds, default.
      disabled  Display a list of disabled worlds.
      running   Display a list of running worlds.
      stopped   Display a list of stopped worlds.
    If no option, all available worlds are listed.

  list <option>
    Same as 'ls' but more detailed.

  status <world>
    Display the status of the Minecraft world server.  Display the status of
    all world servers by default.

  sync <world>
    Synchronize the data stored in the mirror images of the Minecraft world
    server.  Synchronizes all of the world servers by default.  This option
    is only available when the mirror image option is enabled.

  broadcast <command>
    Broadcast a command to all running Minecraft world servers.

  send <world> <command>
    Send a command to a Minecraft world server.

  console <world>
    Connect to the Minecraft world server's console.  Hit <Ctrl-D> to detach.

  watch <world>
    Watch the log file for the Minecraft world server.

  logrotate <world>
    Rotate the log file for the Minecraft world.  Rotate the log file for
    all worlds by default.

  backup <world>
    Backup the Minecraft world.  Backup all worlds by default.

  list-backups <world>
    List the datetime of the backups for the world.

  restore-backup <world> <datetime>
    Restore a backup for a world that was taken at the datetime.

  map <world>
    Run the Minecraft Overviewer mapping software on the Minecraft world.
    Map all worlds by default.

  update <world>
    Update the server software for the Minecraft world server.  Update
    server software for all worlds by default.

Options:

  -c <config_file>
    Read configuration from <config_files> instead of default locations.

  -l <location>
    Uses <location> as the base path for data.  Overrides configuration file
    options.
EOF
}

# Parse command-line options
# ---------------------------------------------------------------------------
while [ "$1" != "${1#-}" ]; do
  case "$1" in
    -p)
      if [ -n "$2" ]; then
        PROG="$2"
        shift
      else
        echo "$PROG: '-p' needs a program name argument."
        exit 1
      fi
    ;;
    -c)
      if [ -n "$2" ]; then
        MSCS_DEFAULTS_CL="$2"
        shift
      else
        echo "$PROG: '-c' needs a config file argument."
        exit 1
      fi
    ;;
    -l)
      if [ -n "$2" ]; then
        LOCATION_CL="$2"
        shift
      else
        echo "$PROG: '-l' needs a location path argument."
        exit 1
      fi
    ;;
    *)
      echo "$PROG: unknown option '$1'."
      echo "Execute '$PROG' without arguments for usage instructions."
      exit 1
    ;;
  esac
  shift
done

# Override Global Variables
# ---------------------------------------------------------------------------
# Override global variables below by adding them to the specified file.  If
# the file does not exist, the default values below will be used.
# Configuration files are checked in the following order. First file found is
# sourced and the rest are discarded:
#   command line option "-c".
#   $HOME/mscs.conf
#   $HOME/.config/mscs/mscs.conf
if [ -r "$MSCS_DEFAULTS_CL" ]; then
  MSCS_DEFAULTS="$MSCS_DEFAULTS_CL"
elif [ -r "$HOME/mscs.conf" ]; then
  MSCS_DEFAULTS="$HOME/mscs.conf"
elif [ -r "$HOME/.config/mscs/mscs.conf" ]; then
  MSCS_DEFAULTS="$HOME/.config/mscs/mscs.conf"
fi

# Server Location
# ---------------------------------------------------------------------------

# The default location of server software and data.
LOCATION="$HOME/mscs"

# Override the default values if the default file exists.
[ -r "$MSCS_DEFAULTS" ] && . "$MSCS_DEFAULTS"

# Override with command-line location option.
[ -n "$LOCATION_CL" ] && LOCATION="$LOCATION_CL"

# Required Software
# ---------------------------------------------------------------------------
# Detect its presence and location for later.

JAVA=$(which java)
PERL=$(which perl)
PYTHON=$(which python)
WGET=$(which wget)
RDIFF_BACKUP=$(which rdiff-backup)
SOCAT=$(which socat)


# Global Server Configuration
# ---------------------------------------------------------------------------

# Minecraft Versions information
# ---------------------------------------------------------------------------
MINECRAFT_VERSIONS_URL=https://s3.amazonaws.com/Minecraft.Download/versions/versions.json


# Minecraft Server Settings
# ---------------------------------------------------------------------------
# Default settings if not provided in the world's mscs.properties file.

DEFAULT_WORLD='world'
DEFAULT_PORT='25565'
DEFAULT_IP=''
DEFAULT_VERSION_TYPE='release'
DEFAULT_CLIENT_VERSION='$CURRENT_VERSION'
DEFAULT_CLIENT_JAR='$CLIENT_VERSION.jar'
DEFAULT_CLIENT_URL='https://s3.amazonaws.com/Minecraft.Download/versions/$CLIENT_VERSION/$CLIENT_VERSION.jar'
DEFAULT_CLIENT_LOCATION=$LOCATION'/.minecraft/versions/$CLIENT_VERSION'
DEFAULT_SERVER_VERSION='$CURRENT_VERSION'
DEFAULT_SERVER_JAR='minecraft_server.$SERVER_VERSION.jar'
DEFAULT_SERVER_URL='https://s3.amazonaws.com/Minecraft.Download/versions/$SERVER_VERSION/minecraft_server.$SERVER_VERSION.jar'
DEFAULT_SERVER_ARGS='nogui'
DEFAULT_INITIAL_MEMORY='128M'
DEFAULT_MAXIMUM_MEMORY='2048M'
DEFAULT_SERVER_LOCATION=$LOCATION'/server'
DEFAULT_SERVER_COMMAND='$JAVA -Xms$INITIAL_MEMORY -Xmx$MAXIMUM_MEMORY -jar $SERVER_LOCATION/$SERVER_JAR $SERVER_ARGS'

# The server settings for each world can be customized by adding certain
# key/value pairs to the world's mscs.properties file.
#
# The following keys are available:
#   mscs-enabled         - Enable or disable the world server.
#   mscs-version-type    - Assign the version type (release or snapshot).
#   mscs-client-version  - Assign the version of the client software.
#   mscs-client-jar      - Assign the .jar file for the client software.
#   mscs-client-url      - Assign the download URL for the client software.
#   mscs-client-location - Assign the location of the client .jar file.
#   mscs-server-version  - Assign the version of the server software.
#   mscs-server-jar      - Assign the .jar file for the server software.
#   mscs-server-url      - Assign the download URL for the server software.
#   mscs-server-args     - Assign the arguments to the server.
#   mscs-initial-memory  - Assign the initial amount of memory for the server.
#   mscs-maximum-memory  - Assign the maximum amount of memory for the server.
#   mscs-server-location - Assign the location of the server .jar file.
#   mscs-server-command  - Assign the command to run for the server.
#
# The following variables may be used in some of the values of the above
# keys:
#   $JAVA                - The Java virtual machine.
#   $CURRENT_VERSION     - The current Mojang Minecraft release version.
#   $CLIENT_VERSION      - The version of the client software.
#   $SERVER_VERSION      - The version of the server software.
#   $SERVER_JAR          - The .jar file to run for the server.
#   $SERVER_ARGS         - The arguments to the server.
#   $INITIAL_MEMORY      - The initial amount of memory for the server.
#   $MAXIMUM_MEMORY      - The maximum amount of memory for the server.
#   $SERVER_LOCATION     - The location of the server .jar file.
#
# The following example key/value pairs are equivalent to the default values:
#   mscs-enabled=true
#   mscs-version-type=release
#   mscs-client-version=$CURRENT_VERSION
#   mscs-client-jar=$CLIENT_VERSION.jar
#   mscs-client-url=https://s3.amazonaws.com/Minecraft.Download/versions/$CLIENT_VERSION/$CLIENT_VERSION.jar
#   mscs-client-location=/opt/mscs/.minecraft/versions/$CLIENT_VERSION
#   mscs-server-version=$CURRENT_VERSION
#   mscs-server-jar=minecraft_server.$SERVER_VERSION.jar
#   mscs-server-url=https://s3.amazonaws.com/Minecraft.Download/versions/$SERVER_VERSION/minecraft_server.$SERVER_VERSION.jar
#   mscs-server-args=nogui
#   mscs-initial-memory=128M
#   mscs-maximum-memory=2048M
#   mscs-server-location=/opt/mscs/server
#   mscs-server-command=$JAVA -Xms$INITIAL_MEMORY -Xmx$MAXIMUM_MEMORY -jar $SERVER_LOCATION/$SERVER_JAR $SERVER_ARGS


# World (Server Instance) Configuration
# ---------------------------------------------------------------------------

# The location to store files for each world server.
WORLDS_LOCATION="$LOCATION/worlds"

# The location old disabled worlds were stored in previous versions
OLD_DISABLED_WORLDS_LOCATION="$LOCATION/worlds-disabled"

# The location to store the versions.json file.
VERSIONS_JSON="$DEFAULT_SERVER_LOCATION/versions.json"

# The duration (in minutes) to keep the versions.json file before updating.
VERSIONS_DURATION=1440


# Backup Configuration
# ---------------------------------------------------------------------------

# Location to store backups.
BACKUP_LOCATION="$LOCATION/backups"

# Location of the backup log file.
BACKUP_LOG="$BACKUP_LOCATION/backup.log"

# Length in days that backups survive.
BACKUP_DURATION=15


# Server Log Configuration
# ---------------------------------------------------------------------------

# Length in days that logs survive.
LOG_DURATION=15


# Listing options
# ---------------------------------------------------------------------------

# Server properties for detailed listing (list).
DETAILED_LISTING_PROPERTIES="motd server-ip server-port max-players level-type online-mode"


# Mirror Image Options
# ---------------------------------------------------------------------------

# Create a mirror image of the world data on system startup, and
# update that mirror image on system shutdown.
#
# IMPORTANT: If using this option, the admin should schedule
# periodic synchronizations of the mirror image using cron
# to avoid data loss. To do this, add a cron task to call
# the "sync" option on a VERY regular basis (e.g.,
# every 5-10 minutes).
#
# 0 - Do not use a mirror image, default.
# 1 - Use a mirror image.
ENABLE_MIRROR=0

# The location to store the mirror image.
#
# NOTE: This is usually a ramdisk, e.g. /dev/shm on Debian/Ubuntu.
MIRROR_PATH="/dev/shm/mscs"


# Minecraft Overviewer Mapping Software Options
# ---------------------------------------------------------------------------

OVERVIEWER_BIN=$(which overviewer.py)
OVERVIEWER_URL="http://overviewer.org"
MAPS_URL="http://minecraft.server.com/maps"
MAPS_LOCATION="$LOCATION/maps"

# Do additional overrides if the default file exists.
# Override the default values if the default file exists.
[ -r "$MSCS_DEFAULTS" ] && . "$MSCS_DEFAULTS"

# Override with command-line location option.
[ -n "$LOCATION_CL" ] && LOCATION="$LOCATION_CL"


# ---------------------------------------------------------------------------
# Internal Methods
# ---------------------------------------------------------------------------
#
# NOTE: Nothing below this point should need to be edited directly.
# ---------------------------------------------------------------------------

# ---------------------------------------------------------------------------
# Get the PID of the Java process for the world server.
#
# @param 1 The world server of interest.
# @return The Java PID.
# ---------------------------------------------------------------------------
getJavaPID() {
  local PID MCUSER
  MCUSER=$(whoami)
  PID=$(
    ps -a -U $MCUSER -o pid,comm,args -ww |
    $PERL -ne 'if ($_ =~ /^\s*(\d+)\s+java.+mscs-world='$1'$/) { print $1; }'
  )
  printf "%d\n" $PID
}

# ---------------------------------------------------------------------------
# Check to see if the world server is running.
#
# @param 1 The world server of interest.
# @return A 0 if the server is thought to be running, a 1 otherwise.
# ---------------------------------------------------------------------------
serverRunning() {
  # Try to determine if the world is running.
  if [ $(getJavaPID "$1") -gt 0 ]; then
    return 0
  else
    return 1
  fi
}

# ---------------------------------------------------------------------------
# Send a command to the world server.
#
# @param 1 The world server of interest.
# @param 2 The command to send.
# ---------------------------------------------------------------------------
sendCommand() {
  echo "$2" | $PERL -e '
    while (<>) { $_ =~ s/[\r\n]+//g; $cmd .= $_; } print "$cmd\r";
  ' >> $WORLDS_LOCATION/$1/console.in
}

# ---------------------------------------------------------------------------
# Check whether the item is in the list.
#
# @param 1 The item being searched for.
# @param 2 The list being searched.
# @return A 0 if the list contains the item, a 1 otherwise.
# ---------------------------------------------------------------------------
listContains() {
  local MATCH ITEM
  MATCH=1
  for ITEM in $2; do
    if [ "$ITEM" = "$1" ]; then
      MATCH=0
    fi
  done
  return $MATCH
}

# ---------------------------------------------------------------------------
# Compare two datetime strings.
#
# @param 1 The first datetime string.
# @param 2 The second datetime string.
# @return The result of the comparison: -1, 0, 1.
# ---------------------------------------------------------------------------
compareTime() {
  local T1 T2
  T1=$(date --date="$1" +%s)
  T2=$(date --date="$2" +%s)
  echo $(($T1 < $T2 ? -1 : $T1 > $T2 ? 1 : 0))
}

# ---------------------------------------------------------------------------
# Compare two Minecraft version numbers.
#
# @param 1 The first Minecraft version number.
# @param 2 The second Minecraft version number.
# @return The result of the comparison: -1, 0, 1.
# ---------------------------------------------------------------------------
compareMinecraftVersions() {
  local T1 T2
  T1=$(getMinecraftVersionReleaseTime "$1")
  T2=$(getMinecraftVersionReleaseTime "$2")
  compareTime "$T1" "$T2"
}

# ---------------------------------------------------------------------------
# Create a world.
#
# @param 1 The world server to create.
# @param 2 The port of the world server.
# @param 3 The IP address of the world server.
# ---------------------------------------------------------------------------
createWorld() {
  # Create a basic server.properties file.  Values not supplied here
  # will use default values when the world server is first started.
  mkdir -p "$WORLDS_LOCATION/$1"
  setServerPropertiesValue "$1" "level-name" "$1"
  setServerPropertiesValue "$1" "server-port" "$2"
  setServerPropertiesValue "$1" "server-ip" "$3"
  setServerPropertiesValue "$1" "enable-query" "true"
  setServerPropertiesValue "$1" "query.port" "$2"
  setMSCSValue "$1" "mscs-enabled" "true"
}

# ---------------------------------------------------------------------------
# Delete a world.
#
# @param 1 The world server to delete.
# ---------------------------------------------------------------------------
deleteWorld() {
  # Delete the world directory.
  rm -Rf "$WORLDS_LOCATION/$1"
}

# ---------------------------------------------------------------------------
# Disable a world.
#
# @param 1 The world server to disable.
# ---------------------------------------------------------------------------
disableWorld() {
  # Disable the world.
  setMSCSValue "$1" "mscs-enabled" "false"
}

# ---------------------------------------------------------------------------
# Enable a world.
#
# @param 1 The world server to enable.
# ---------------------------------------------------------------------------
enableWorld() {
  # Enable the world.
  setMSCSValue "$1" "mscs-enabled" "true"
}

# ---------------------------------------------------------------------------
# Grab the list of enabled worlds.
#
# @return The list of enabled worlds.
# ---------------------------------------------------------------------------
getEnabledWorlds() {
  local WORLD WORLDS
  mkdir -p "$WORLDS_LOCATION"
  WORLDS=""
  for WORLD in $(ls $WORLDS_LOCATION); do
    if [ -d $WORLDS_LOCATION/$WORLD ]; then
      if [ "$(getMSCSValue $WORLD 'mscs-enabled' 'true')" = "true" ]; then
        WORLDS="$WORLDS $WORLD"
      fi
    fi
  done
  echo $WORLDS
}

# ---------------------------------------------------------------------------
# Grab the list of disabled worlds.
#
# @return The list of disabled worlds.
# ---------------------------------------------------------------------------
getDisabledWorlds() {
  local WORLD WORLDS
  WORLDS=""
  for WORLD in $(ls $WORLDS_LOCATION); do
    if [ -d $WORLDS_LOCATION/$WORLD ]; then
      if [ "$(getMSCSValue $WORLD 'mscs-enabled' 'true')" != "true" ]; then
        WORLDS="$WORLDS $WORLD"
      fi
    fi
  done
  echo $WORLDS
}

# ---------------------------------------------------------------------------
# Grab the list of all available worlds.
#
# @return The list of all available worlds.
# ---------------------------------------------------------------------------
getAvailableWorlds() {
  echo $(getEnabledWorlds) $(getDisabledWorlds)
}

# ---------------------------------------------------------------------------
# Check to see if the world is enabled.
#
# @param 1 The world of interest.
# @return A 0 if the world is enabled, a 1 otherwise.
# ---------------------------------------------------------------------------
isWorldEnabled() {
  local WORLDS
  WORLDS=$(getEnabledWorlds)
  if [ -n "$1" ] && listContains "$1" "$WORLDS"; then
    return 0
  else
    return 1
  fi
}

# ---------------------------------------------------------------------------
# Check to see if the world is available (exists).
#
# @param 1 The world of interest.
# @return A 0 if the world is available, a 1 otherwise.
# ---------------------------------------------------------------------------
isWorldAvailable() {
  local WORLDS
  WORLDS=$(getAvailableWorlds)
  if [ -n "$1" ] && listContains "$1" "$WORLDS"; then
    return 0
  else
    return 1
  fi
}

# ---------------------------------------------------------------------------
# Get the value of a key from the provided file.
#
# @param 1 The file containing the key/value combo.
# @param 2 The key to get.
# @param 3 The default value.
# ---------------------------------------------------------------------------
getValue() {
  local KEY VALUE
  # Make sure the file exists.
  if [ -e "$1" ]; then
    # Find the key/value combo.
    KEY=$($PERL -ne '
      $_ =~ s/[\r]//;
      if ($_ =~ /^('$2')=.*$/i) { print lc $1; }
    ' $1)
    VALUE=$($PERL -ne '
      $_ =~ s/[\r]//;
      if ($_ =~ /^'$2'=(.*)$/i) { print $1; }
    ' $1)
  fi
  # Return the value if found, the default value if not.
  if [ -n "$KEY" ] && [ -n "$VALUE" ]; then
    echo "$VALUE"
  else
    echo "$3"
  fi
}

# ---------------------------------------------------------------------------
# Modify the value of a key/value combo in the provided file.
#
# @param 1 The file containing the key/value combo.
# @param 2 The key to modify.
# @param 3 The value to assign to the key.
# ---------------------------------------------------------------------------
setValue() {
  local KEY_VALUE
  # Make sure that the file exists.
  touch "$1"
  # Replace the key/value combo if it already exists, otherwise just
  # append it to the end of the file.
  KEY_VALUE=$($PERL -ne '
    $_ =~ s/[\r]//;
    if ($_ =~ /^('$2'=.*)$/) { print "$1"; }
  ' $1)
  if [ -n "$KEY_VALUE" ]; then
    $PERL -i -ne '
      $_ =~ s/[\r]//;
      if ($_ =~ /^'$2'=.*$/) { print "'$2'='$3'\n"; } else { print; }
    ' $1
  else
    printf "$2=$3\n" >> "$1"
  fi
}

# ---------------------------------------------------------------------------
# Get the value of the EULA boolean.
#
# @param 1 The world server of interest.
# ---------------------------------------------------------------------------
getEULAValue() {
  local EULA_FILE
  EULA_FILE=$WORLDS_LOCATION/$1/eula.txt
  getValue "$EULA_FILE" "eula" "true" | $PERL -ne 'print lc'
}

# ---------------------------------------------------------------------------
# Get the value of a key in a mscs.properties file.
#
# @param 1 The world server of interest.
# @param 2 The key to get.
# @param 3 The default value.
# ---------------------------------------------------------------------------
getMSCSValue() {
  local PROPERTY_FILE
  PROPERTY_FILE=$WORLDS_LOCATION/$1/mscs.properties
  getValue "$PROPERTY_FILE" "$2" "$3"
}

# ---------------------------------------------------------------------------
# Modify the value of a key/value combo in a mscs.properties file.
#
# @param 1 The world server of interest.
# @param 2 The key to modify.
# @param 3 The value to assign to the key.
# ---------------------------------------------------------------------------
setMSCSValue() {
  local PROPERTY_FILE
  PROPERTY_FILE=$WORLDS_LOCATION/$1/mscs.properties
  setValue "$PROPERTY_FILE" "$2" "$3"
}

# ---------------------------------------------------------------------------
# Get the value of a key in a server.properties file.
#
# @param 1 The world server of interest.
# @param 2 The key to get.
# @param 3 The default value.
# ---------------------------------------------------------------------------
getServerPropertiesValue() {
  local PROPERTY_FILE
  PROPERTY_FILE="$WORLDS_LOCATION/$1/server.properties"
  getValue "$PROPERTY_FILE" "$2" "$3"
}

# ---------------------------------------------------------------------------
# Modify the value of a key/value combo in a server.properties file.
#
# @param 1 The world server of interest.
# @param 2 The key to modify.
# @param 3 The value to assign to the key.
# ---------------------------------------------------------------------------
setServerPropertiesValue() {
  local PROPERTY_FILE
  PROPERTY_FILE=$WORLDS_LOCATION/$1/server.properties
  setValue "$PROPERTY_FILE" "$2" "$3"
}

# ---------------------------------------------------------------------------
# Get the current Minecraft version number.
#
# @param 1 The world server.
# @return The current Minecraft version number.
# ---------------------------------------------------------------------------
getCurrentMinecraftVersion() {
  local VERSION TYPE
  # Make sure the server software directory exists.
  mkdir -p "$DEFAULT_SERVER_LOCATION"
  # Determine the version type for the current world.
  TYPE=$(getMSCSValue "$1" "mscs-version-type" "$DEFAULT_VERSION_TYPE")
  if [ -s $VERSIONS_JSON ]; then
    # Make a backup copy of the versions.json file.
    cp -p "$VERSIONS_JSON" "$VERSIONS_JSON.bak"
    # Delete the versions.json file if it is old.
    find "$VERSIONS_JSON" -mmin +"$VERSIONS_DURATION" -delete
  fi
  # Download the versions.json file if it does not exist.
  if [ ! -s $VERSIONS_JSON ]; then
    $WGET --no-use-server-timestamps -qO "$VERSIONS_JSON" "$MINECRAFT_VERSIONS_URL"
    if [ $? -ne 0 ]; then
      if [ -s $VERSIONS_JSON.bak ]; then
        printf "Error downloading the Minecraft versions.json file, using an old copy.\n"
        cp -p "$VERSIONS_JSON.bak" "$VERSIONS_JSON"
      else
        printf "Error downloading the Minecraft versions.json file.\n"
        exit 1
      fi
    fi
  fi
  # Extract the current version information.
  VERSION=$(
    $PERL -ne 'if ($_ =~ /^\s+\"'$TYPE'\": \"([\w\.-]+)\"/) { print $1; }' $VERSIONS_JSON
  )
  # Print an error and exit if the version string is empty.
  if [ -z "$VERSION" ]; then
    printf "Error detecting the current Minecraft version.\n"
    exit 1
  fi
  echo "$VERSION"
}

# ---------------------------------------------------------------------------
# Get the release time of the Minecraft version number.
#
# @param 1 The Minecraft version number.
# @return The release time of the Minecraft version number.
# ---------------------------------------------------------------------------
getMinecraftVersionReleaseTime() {
  cat $VERSIONS_JSON | $PERL -e '
    $id = null;
    while (<>) {
      if ($_ =~ /\"id\":\s+\"('$1')\"/) {
        $id = $1;
      }
      elsif ($id != null && $_ =~ /\"releaseTime\":\s+\"([\w:+-]+)\"/) {
        print $1;
        last;
      }
    }
  '
}

# ---------------------------------------------------------------------------
# Retrieve the version of the client for the world.
#
# @param 1 The world server.
# @return CLIENT_VERSION
# ---------------------------------------------------------------------------
getClientVersion() {
  local CURRENT_VERSION
  CURRENT_VERSION=$(getCurrentMinecraftVersion "$1")
  if [ $? -ne 0 ]; then
    printf "$CURRENT_VERSION\n"
    exit 1
  fi
  # Get the client version, use the default version if not provided.
  getMSCSValue "$1" "mscs-client-version" "$DEFAULT_CLIENT_VERSION" |
  $PERL -ne '
    $current_version="'$CURRENT_VERSION'";
    $_ =~ s/\$CURRENT_VERSION/$current_version/g;
    print;
  '
}

# ---------------------------------------------------------------------------
# Retrieve the .jar file name for the client for the world.
#
# @param 1 The world server.
# @return CLIENT_JAR
# ---------------------------------------------------------------------------
getClientJar() {
  local CURRENT_VERSION CLIENT_VERSION
  CURRENT_VERSION=$(getCurrentMinecraftVersion "$1")
  if [ $? -ne 0 ]; then
    printf "$CURRENT_VERSION\n"
    exit 1
  fi
  CLIENT_VERSION=$(getClientVersion "$1")
  if [ $? -ne 0 ]; then
    printf "$CLIENT_VERSION\n"
    exit 1
  fi
  # Get the client jar, use the default value if not provided.
  getMSCSValue "$1" "mscs-client-jar" "$DEFAULT_CLIENT_JAR" |
  $PERL -ne '
    $current_version="'$CURRENT_VERSION'";
    $client_version="'$CLIENT_VERSION'";
    $_ =~ s/\$CURRENT_VERSION/$current_version/g;
    $_ =~ s/\$CLIENT_VERSION/$client_version/g;
    print;
  '
}

# ---------------------------------------------------------------------------
# Retrieve the location of the client files for the world.
#
# @param 1 The world server.
# @return CLIENT_LOCATION
# ---------------------------------------------------------------------------
getClientLocation() {
  local CURRENT_VERSION CLIENT_VERSION
  CURRENT_VERSION=$(getCurrentMinecraftVersion "$1")
  if [ $? -ne 0 ]; then
    printf "$CURRENT_VERSION\n"
    exit 1
  fi
  CLIENT_VERSION=$(getClientVersion "$1")
  if [ $? -ne 0 ]; then
    printf "$CLIENT_VERSION\n"
    exit 1
  fi
  # Get the client location, use the default value if not provided.
  getMSCSValue "$1" "mscs-client-location" "$DEFAULT_CLIENT_LOCATION" |
  $PERL -ne '
    $current_version="'$CURRENT_VERSION'";
    $client_version="'$CLIENT_VERSION'";
    $_ =~ s/\$CURRENT_VERSION/$current_version/g;
    $_ =~ s/\$CLIENT_VERSION/$client_version/g;
    print;
  '
}

# ---------------------------------------------------------------------------
# Retrieve the URL to download the client for the world.
#
# @param 1 The world server.
# @return CLIENT_URL
# ---------------------------------------------------------------------------
getClientURL() {
  local CURRENT_VERSION CLIENT_VERSION
  CURRENT_VERSION=$(getCurrentMinecraftVersion "$1")
  if [ $? -ne 0 ]; then
    printf "$CURRENT_VERSION\n"
    exit 1
  fi
  CLIENT_VERSION=$(getClientVersion "$1")
  if [ $? -ne 0 ]; then
    printf "$CLIENT_VERSION\n"
    exit 1
  fi
  # Get the client download URL, use the default value if not provided.
  getMSCSValue "$1" "mscs-client-url" "$DEFAULT_CLIENT_URL" |
  $PERL -ne '
    $current_version="'$CURRENT_VERSION'";
    $client_version="'$CLIENT_VERSION'";
    $_ =~ s/\$CURRENT_VERSION/$current_version/g;
    $_ =~ s/\$CLIENT_VERSION/$client_version/g;
    $_ =~ s/\\\:/\:/g;
    print;
  '
}

# ---------------------------------------------------------------------------
# Retrieve the version of the server running the world.
#
# @param 1 The world server.
# @return SERVER_VERSION
# ---------------------------------------------------------------------------
getServerVersion() {
  local CURRENT_VERSION
  CURRENT_VERSION=$(getCurrentMinecraftVersion "$1")
  if [ $? -ne 0 ]; then
    printf "$CURRENT_VERSION\n"
    exit 1
  fi
  # Get the server version, use the default version if not provided.
  getMSCSValue "$1" "mscs-server-version" "$DEFAULT_SERVER_VERSION" |
  $PERL -ne '
    $current_version="'$CURRENT_VERSION'";
    $_ =~ s/\$CURRENT_VERSION/$current_version/g;
    print;
  '
}

# ---------------------------------------------------------------------------
# Retrieve the .jar file name for the server running the world.
#
# @param 1 The world server.
# @return SERVER_JAR
# ---------------------------------------------------------------------------
getServerJar() {
  local CURRENT_VERSION SERVER_VERSION SERVER_JAR
  CURRENT_VERSION=$(getCurrentMinecraftVersion "$1")
  if [ $? -ne 0 ]; then
    printf "$CURRENT_VERSION\n"
    exit 1
  fi
  SERVER_VERSION=$(getServerVersion "$1")
  if [ $? -ne 0 ]; then
    printf "$SERVER_VERSION\n"
    exit 1
  fi
  # Get the server jar, use the default value if not provided.
  getMSCSValue "$1" "mscs-server-jar" "$DEFAULT_SERVER_JAR" |
  $PERL -ne '
    $current_version="'$CURRENT_VERSION'";
    $server_version="'$SERVER_VERSION'";
    $_ =~ s/\$CURRENT_VERSION/$current_version/g;
    $_ =~ s/\$SERVER_VERSION/$server_version/g;
    print;
  '
}

# ---------------------------------------------------------------------------
# Retrieve the location of the server files for the server running the world.
#
# @param 1 The world server.
# @return SERVER_LOCATION
# ---------------------------------------------------------------------------
getServerLocation() {
  local CURRENT_VERSION SERVER_VERSION
  CURRENT_VERSION=$(getCurrentMinecraftVersion "$1")
  if [ $? -ne 0 ]; then
    printf "$CURRENT_VERSION\n"
    exit 1
  fi
  SERVER_VERSION=$(getServerVersion "$1")
  if [ $? -ne 0 ]; then
    printf "$SERVER_VERSION\n"
    exit 1
  fi
  # Get the server location, use the default value if not provided.
  getMSCSValue "$1" "mscs-server-location" "$DEFAULT_SERVER_LOCATION" |
  $PERL -ne '
    $current_version="'$CURRENT_VERSION'";
    $server_version="'$SERVER_VERSION'";
    $_ =~ s/\$CURRENT_VERSION/$current_version/g;
    $_ =~ s/\$SERVER_VERSION/$server_version/g;
    print;
  '
}

# ---------------------------------------------------------------------------
# Retrieve the URL to download the server running the world.
#
# @param 1 The world server.
# @return SERVER_URL
# ---------------------------------------------------------------------------
getServerURL() {
  local CURRENT_VERSION SERVER_VERSION
  CURRENT_VERSION=$(getCurrentMinecraftVersion "$1")
  if [ $? -ne 0 ]; then
    printf "$CURRENT_VERSION\n"
    exit 1
  fi
  SERVER_VERSION=$(getServerVersion "$1")
  if [ $? -ne 0 ]; then
    printf "$SERVER_VERSION\n"
    exit 1
  fi
  # Get the server download URL, use the default value if not provided.
  getMSCSValue "$1" "mscs-server-url" "$DEFAULT_SERVER_URL" |
  $PERL -ne '
    $current_version="'$CURRENT_VERSION'";
    $server_version="'$SERVER_VERSION'";
    $_ =~ s/\$CURRENT_VERSION/$current_version/g;
    $_ =~ s/\$SERVER_VERSION/$server_version/g;
    $_ =~ s/\\\:/\:/g;
    print;
  '
}

# ---------------------------------------------------------------------------
# Retrieve the command to start the server running the world.
#
# @param 1 The world server.
# @return SERVER_COMMAND
# ---------------------------------------------------------------------------
getServerCommand() {
  local CURRENT_VERSION SERVER_VERSION SERVER_JAR SERVER_LOCATION
  local SERVER_ARGS INITIAL_MEMORY MAXIMUM_MEMORY
  CURRENT_VERSION=$(getCurrentMinecraftVersion "$1")
  if [ $? -ne 0 ]; then
    printf "$CURRENT_VERSION\n"
    exit 1
  fi
  SERVER_VERSION=$(getServerVersion "$1")
  if [ $? -ne 0 ]; then
    printf "$SERVER_VERSION\n"
    exit 1
  fi
  SERVER_JAR=$(getServerJar "$1")
  if [ $? -ne 0 ]; then
    printf "$SERVER_JAR\n"
    exit 1
  fi
  SERVER_LOCATION=$(getServerLocation "$1")
  if [ $? -ne 0 ]; then
    printf "$SERVER_LOCATION\n"
    exit 1
  fi
  # Get the server arguments, use the default value if not provided.
  SERVER_ARGS=$(
    getMSCSValue "$1" "mscs-server-args" "$DEFAULT_SERVER_ARGS"
  )
  # Get the initial memory, use the default value if not provided.
  INITIAL_MEMORY=$(
    getMSCSValue "$1" "mscs-initial-memory" "$DEFAULT_INITIAL_MEMORY"
  )
  # Get the maximum memory, use the default value if not provided.
  MAXIMUM_MEMORY=$(
    getMSCSValue "$1" "mscs-maximum-memory" "$DEFAULT_MAXIMUM_MEMORY"
  )
  # Get the server command, use the default value if not provided.
  getMSCSValue "$1" "mscs-server-command" "$DEFAULT_SERVER_COMMAND" |
  $PERL -ne '
    $java = "'$JAVA'";
    $current_version="'$CURRENT_VERSION'";
    $server_version="'$SERVER_VERSION'";
    $server_jar = "'$SERVER_JAR'";
    $server_location = "'$SERVER_LOCATION'";
    $server_args = "'$SERVER_ARGS'";
    $initial_memory = "'$INITIAL_MEMORY'";
    $maximum_memory = "'$MAXIMUM_MEMORY'";
    $_ =~ s/\$JAVA/$java/g;
    $_ =~ s/\$CURRENT_VERSION/$current_version/g;
    $_ =~ s/\$SERVER_VERSION/$server_version/g;
    $_ =~ s/\$SERVER_JAR/$server_jar/g;
    $_ =~ s/\$SERVER_LOCATION/$server_location/g;
    $_ =~ s/\$SERVER_ARGS/$server_args/g;
    $_ =~ s/\$INITIAL_MEMORY/$initial_memory/g;
    $_ =~ s/\$MAXIMUM_MEMORY/$maximum_memory/g;
    print;
  '
}

# ---------------------------------------------------------------------------
# Remove old world log files and rotate log files from old servers (v < 1.7).
#
# @param 1 The world server generating the log to rotate.
# ---------------------------------------------------------------------------
rotateLog() {
  local WORLD_DIR DATE LOG NUMBER
  WORLD_DIR="$WORLDS_LOCATION/$1"
  # Make sure the log directory exists.
  mkdir -p "$WORLD_DIR/logs"
  # Delete old log files.
  find "$WORLD_DIR/logs" -type f -mtime +"$LOG_DURATION" -delete
  # Archive and rotate the log files for old Minecraft servers (Versions 1.7
  # and greater do this automatically).
  if [ -e "$WORLD_DIR/server.log" ] &&
    [ $(wc -l < $WORLD_DIR/server.log) -ge 1 ]; then
    # Make a copy of the log file in the world's logs directory.
    DATE=$(date +%F)
    cp "$WORLD_DIR/server.log" "$WORLD_DIR/logs/$DATE-0.log"
    gzip "$WORLD_DIR/logs/$DATE-0.log"
    # Empty the contents of the worlds log file.
    cp /dev/null "$WORLD_DIR/server.log"
    # Rotate the files in the world's logs directory.
    for LOG in $(ls -r $WORLD_DIR/logs/$DATE-*.log.gz); do
      NUMBER=$(echo $LOG | cut -d "." -f 1 | cut -d "-" -f 4)
      NUMBER=$(($NUMBER+1))
      mv -f $LOG "$WORLD_DIR/logs/$DATE-$NUMBER.log.gz"
    done
  fi
}

# ---------------------------------------------------------------------------
# Watch the world latest.log file.
#
# @param 1 The world server generating the log to watch.
# ---------------------------------------------------------------------------
watchLog() {
  local WORLD_DIR
  WORLD_DIR="$WORLDS_LOCATION/$1"
  # Make sure that the latest.log file exists.
  if [ -e "$WORLD_DIR/logs/latest.log" ]; then
    # Watch the log file of worlds running Minecraft 1.7 +.
    tail -n0 -f --pid=$(getJavaPID "$1") $WORLD_DIR/logs/latest.log
  elif [ -e "$WORLD_DIR/server.log" ]; then
    # Watch the log file of worlds running older Minecraft servers.
    tail -n0 -f --pid=$(getJavaPID "$1") $WORLD_DIR/server.log
  fi
}

# ---------------------------------------------------------------------------
# Synchronizes the data stored in the mirror images.
#
# @param 1 The world server to sync.
# ---------------------------------------------------------------------------
syncMirrorImage() {
  # Sync the world server.
  cp -Ru "$WORLDS_LOCATION/$1/$1/*" "$WORLDS_LOCATION/$1/$1-original"
  if [ $? -ne 0 ]; then
    printf "Error synchronizing mirror images for world $1.\n"
    exit 1
  fi
}

# ---------------------------------------------------------------------------
# Display the server console.
#
# @param 1 The world server to connect to.
# ---------------------------------------------------------------------------
serverConsole() {
  local LINE WORLD_DIR
  # Make sure that the world's directory exists.
  WORLD_DIR="$WORLDS_LOCATION/$1"
  # Follow the console output buffer file.
  sh -c "tail --pid=\$$ -f '$WORLD_DIR/console.out'" &
  # Copy user input to the console input buffer file.
  while read LINE; do
    echo "$LINE" >> $WORLD_DIR/console.in
  done
}

# ---------------------------------------------------------------------------
# Start the world server.  Generate the appropriate environment for the
# server if it doesn't already exist.
#
# @param 1 The world server to start.
# ---------------------------------------------------------------------------
start() {
  local EULA PID SERVER_COMMAND WORLD_DIR
  # Make sure that the server software exists.
  updateServerSoftware "$1"
  # Make sure that the world's directory exists.
  WORLD_DIR="$WORLDS_LOCATION/$1"
  mkdir -p "$WORLD_DIR"
  # Make sure the EULA has been set to true.
  EULA=$(getEULAValue "$1")
  if [ $EULA != "true" ]; then
    printf "\nError, the EULA has not been accepted for world %s.\n" "$1"
    printf "To accept the EULA, modify %s/eula.txt file.\n" "$WORLD_DIR"
    exit 1
  fi
  # Rotate the world's log files.
  rotateLog "$1"
  # Make a mirror image of the world directory if requested.
  if [ $ENABLE_MIRROR -eq 1 ]; then
    mkdir -p "$MIRROR_PATH/$1"
    if [ $? -ne 0 ]; then
      printf "Error copying world data, path %s not found.\n" $MIRROR_PATH/$1
      exit 1
    fi
    # Check for a clean dismount from the previous server run.  If we have a
    # <world>-original directory within <world> we didn't stop cleanly.
    if [ -d "WORLDS_LOCATION/$1/$1-original" ]; then
      # Remove the symlink to the world-file mirror image.
      rm -r "$WORLDS_LOCATION/$1/$1"
      # Move the world files back to their original path name.
      mv "$WORLDS_LOCATION/$1/$1-original" "$WORLDS_LOCATION/$1/$1"
    fi
    # Copy the world files over to the mirror.
    cp -R "$WORLDS_LOCATION/$1/$1/*" "$MIRROR_PATH/$1"
    # Rename the original world file directory.
    mv "$WORLDS_LOCATION/$1/$1" "$WORLDS_LOCATION/$1/$1-original"
    # Create a symlink from the world file directory's original name to the mirrored files.
    ln -s "$MIRROR_PATH/$1" "$WORLDS_LOCATION/$1/$1"
  fi
  # Change to the world's directory.
  cd $WORLD_DIR
  # Delete any old console.in or console.out buffer files.
  rm -f "$WORLD_DIR/console.in" "$WORLD_DIR/console.out"
  # Initialize the console.in buffer file.
  printf '' > $WORLD_DIR/console.in
  # Get the server command for this world.
  SERVER_COMMAND=$(getServerCommand "$1")
  if [ $? -ne 0 ]; then
    printf "$SERVER_COMMAND\n"
    exit 1
  fi
  # Start the server.
  sh -c "tail -f --pid=\$$ '$WORLD_DIR/console.in' | {
    $SERVER_COMMAND mscs-world='$1' > '$WORLD_DIR/console.out' 2>&1; kill \$$;
    }" &
  # Verify the server is running.
  if [ $? -ne 0 ]; then
    printf "Error starting the server.\n"
    exit 1
  fi
  sleep 1
  PID=$(getJavaPID "$1")
  if [ $PID -eq 0 ]; then
    printf "Error starting the server: couldn't retrieve the server's process ID.\n"
    exit 1
  fi
  # Start the Query handler if enabled.
  if [ "$(getServerPropertiesValue $1 'enable-query')" = "true" ]; then
    queryStart "$1" &
  fi
  # Create a PID file for the world server.
  echo $PID > "$WORLDS_LOCATION/$1.pid"
}

# ---------------------------------------------------------------------------
# Stop the world server.
#
# @param 1 The world server to stop.
# ---------------------------------------------------------------------------
stop() {
  local WORLD NUM
  sendCommand $1 "stop"
  sendCommand $1 "end"
  # Synchronize the mirror image of the world prior to closing, if
  # required.
  if [ $ENABLE_MIRROR -eq 1 ] && [ -d $MIRROR_PATH ]; then
    syncMirrorImage $1
    # Remove the symlink to the world-file mirror image.
    rm -r "$WORLDS_LOCATION/$1/$1"
    # Move the world files back to their original path name.
    mv "$WORLDS_LOCATION/$1/$1-original" "$WORLDS_LOCATION/$1/$1"
  fi
  # Remove the PID file for the world server.
  rm -f "$WORLDS_LOCATION/$1.pid"
}

# ---------------------------------------------------------------------------
# Forcibly stop the world server.
#
# @param 1 The world server to forcibly stop.
# ---------------------------------------------------------------------------
forceStop() {
  # Try to stop the server cleanly first.
  stop "$1"
  sleep 5
  # Kill the process id of the world server.
  kill -9 $(getJavaPID "$1") > /dev/null 2>&1
}

# ---------------------------------------------------------------------------
# Backup the world server.
#
# @param 1 The world server to backup.
# @return A 0 if backup successful, a 1 otherwise
# ---------------------------------------------------------------------------
worldBackup() {
  # Make sure that the backup location exists.
  if ! mkdir -p "$BACKUP_LOCATION"; then
    echo "Error creating backup dir $BACKUP_LOCATION"
    return 1
  fi
  # Create the backup.
  if ! $RDIFF_BACKUP -v5 --print-statistics "$WORLDS_LOCATION/$1" "$BACKUP_LOCATION/$1" >> "$BACKUP_LOG"; then
    echo "Error doing backup of world $1"
    return 1
  fi
  # Cleanup old backups.
  if [ $BACKUP_DURATION -gt 0 ]; then
    if ! $RDIFF_BACKUP --remove-older-than ${BACKUP_DURATION}D --force "$BACKUP_LOCATION/$1" >> "$BACKUP_LOG"; then
      echo "Error cleaning old backups of world $1"
      return 1
    fi
  fi
  return 0
}

# ---------------------------------------------------------------------------
# List the backups for the world server.
#
# @param 1 The world server of interest.
# ---------------------------------------------------------------------------
worldBackupList() {
  local SEC TYPE
  if [ -d $BACKUP_LOCATION/$1 ]; then
    # Grab the list of backups for the world server.
    $RDIFF_BACKUP --parsable-output -l $BACKUP_LOCATION/$1 |
    while read SEC TYPE; do
      date --date=\@$SEC --rfc-3339=seconds | tr ' ' T
    done
  fi
}

# ---------------------------------------------------------------------------
# Restore a backup for the world server.
#
# @param 1 The world server of interest.
# @param 2 The datetime of the backup to restore.
# @return A 0 on success, a 1 otherwise.
# ---------------------------------------------------------------------------
worldBackupRestore() {
  local TARGET TARGET_TMP
  TARGET="$WORLDS_LOCATION/$1"
  TARGET_TMP="${TARGET}_bktmp"
  rm -rf "$TARGET_TMP"
  if [ -d $BACKUP_LOCATION/$1 ]; then
    if $RDIFF_BACKUP -r $2 "$BACKUP_LOCATION/$1" "$TARGET_TMP"; then
      rm -r "$TARGET"
      mv "$TARGET_TMP" "$TARGET"
    else
      echo "Restoring backup failed: $1 $2"
      rm -rf "$TARGET_TMP"
      return 1
    fi
  else
    echo "No backups found for world $1"
    return 1
  fi
}

# ---------------------------------------------------------------------------
# Update the Minecraft client software.
#
# @param 1 The world to update.
# ---------------------------------------------------------------------------
updateClientSoftware() {
  local CLIENT_JAR CLIENT_LOCATION CLIENT_URL
  CLIENT_JAR=$(getClientJar "$1")
  if [ $? -ne 0 ]; then
    printf "$CLIENT_JAR\n"
    exit 1
  fi
  CLIENT_LOCATION=$(getClientLocation "$1")
  if [ $? -ne 0 ]; then
    printf "$CLIENT_LOCATION\n"
    exit 1
  fi
  CLIENT_URL=$(getClientURL "$1")
  if [ $? -ne 0 ]; then
    printf "$CLIENT_URL\n"
    exit 1
  fi
  # Make sure the client software directory exists.
  mkdir -p "$CLIENT_LOCATION"
  # Download the client jar if it is missing.
  if [ ! -s "$CLIENT_LOCATION/$CLIENT_JAR" ]; then
    # Download the Minecraft client software.
    $WGET -qO "$CLIENT_LOCATION/$CLIENT_JAR" "$CLIENT_URL"
    # Report any errors.
    if [ $? -ne 0 ]; then
      printf "Error updating the Minecraft client software.\n"
      exit 1
    fi
  fi
}

# ---------------------------------------------------------------------------
# Update the Minecraft server software.
#
# @param 1 The world server to update.
# ---------------------------------------------------------------------------
updateServerSoftware() {
  local SERVER_JAR SERVER_LOCATION SERVER_URL
  SERVER_JAR=$(getServerJar "$1")
  if [ $? -ne 0 ]; then
    printf "$SERVER_JAR\n"
    exit 1
  fi
  SERVER_LOCATION=$(getServerLocation "$1")
  if [ $? -ne 0 ]; then
    printf "$SERVER_LOCATION\n"
    exit 1
  fi
  SERVER_URL=$(getServerURL "$1")
  if [ $? -ne 0 ]; then
    printf "$SERVER_URL\n"
    exit 1
  fi
  # Make sure the server software directory exists.
  mkdir -p "$SERVER_LOCATION"
  # Download the server jar if it is missing.
  if [ ! -s "$SERVER_LOCATION/$SERVER_JAR" ]; then
    # Download the Minecraft server software.
    $WGET -qO "$SERVER_LOCATION/$SERVER_JAR" "$SERVER_URL"
    # Report any errors.
    if [ $? -ne 0 ]; then
      printf "Error updating the Minecraft server software.\n"
      exit 1
    fi
  fi
}

# ---------------------------------------------------------------------------
# Run Minecraft Overviewer mapping software on the world.  Generates an
# index.html file using the Google Maps API.
#
# @param 1 The world server to map with Overviewer.
# ---------------------------------------------------------------------------
overviewer() {
  local CLIENT_JAR CLIENT_LOCATION SERVER_RUNNING
  if serverRunning $1; then
    SERVER_RUNNING=1
  else
    SERVER_RUNNING=0
  fi
  # Announce the mapping of the world to players.
  if [ $SERVER_RUNNING -eq 1 ]; then
    if [ $(compareMinecraftVersions $(getServerVersion $1) 1.7) -ge 0 ]; then
        sendCommand $WORLD 'tellraw @a {
          "text" : "",
          "extra" : [
            {
              "text" : "[Server] The world is about to be mapped with "
            },
            {
              "text" : "Overviewer",
              "color" : "aqua",
              "clickEvent" : {
                "action" : "open_url",
                "value" : "'$OVERVIEWER_URL'"
              }
            },
            {
              "text" : "."
            }
          ]
        }'
    else
      sendCommand $1 "say The world is about to be mapped with Overviewer."
    fi
    sendCommand $1 "save-all"
    sendCommand $1 "save-off"
    sleep 20
  fi
  # Run a backup of the world.
  worldBackup $1
  # Make sure the maps directory exists.
  mkdir -p "$MAPS_LOCATION/$1"
  # Make sure the Minecraft client is available.
  updateClientSoftware "$1"
  # Make sure that the world files are actually there before mapping.
  if [ -e "$WORLDS_LOCATION/$1/server.properties" ]; then
    # Check for Overviewer settings file.
    if [ ! -e "$WORLDS_LOCATION/$1/overviewer-settings.py" ]; then
      touch "$WORLDS_LOCATION/$1/overviewer-settings.py"
      printf "worlds['$1'] = \"$WORLDS_LOCATION/$1/$1\"\n" >> $WORLDS_LOCATION/$1/overviewer-settings.py
      printf "\n" >> $WORLDS_LOCATION/$1/overviewer-settings.py
      printf "renders['normalrender'] = {\n" >> $WORLDS_LOCATION/$1/overviewer-settings.py
      printf "  'world': '$1',\n" >> $WORLDS_LOCATION/$1/overviewer-settings.py
      printf "  'title': 'Normal',\n" >> $WORLDS_LOCATION/$1/overviewer-settings.py
      printf "  'dimension': 'overworld',\n" >> $WORLDS_LOCATION/$1/overviewer-settings.py
      printf "  'rendermode': 'normal'\n" >> $WORLDS_LOCATION/$1/overviewer-settings.py
      printf "}\n" >> $WORLDS_LOCATION/$1/overviewer-settings.py
      printf "\n" >> $WORLDS_LOCATION/$1/overviewer-settings.py
      printf "renders['caverender'] = {\n" >> $WORLDS_LOCATION/$1/overviewer-settings.py
      printf "  'world': '$1',\n" >> $WORLDS_LOCATION/$1/overviewer-settings.py
      printf "  'title': 'Caves',\n" >> $WORLDS_LOCATION/$1/overviewer-settings.py
      printf "  'dimension': 'overworld',\n" >> $WORLDS_LOCATION/$1/overviewer-settings.py
      printf "  'rendermode': 'cave'\n" >> $WORLDS_LOCATION/$1/overviewer-settings.py
      printf "}\n" >> $WORLDS_LOCATION/$1/overviewer-settings.py
      printf "\n" >> $WORLDS_LOCATION/$1/overviewer-settings.py
      printf "outputdir = \"$MAPS_LOCATION/$1\"\n" >> $WORLDS_LOCATION/$1/overviewer-settings.py
    fi
    # Generate the map and POI.
    $OVERVIEWER_BIN --config="$WORLDS_LOCATION/$1/overviewer-settings.py" >> "$WORLDS_LOCATION/$1/logs/overviewer.log" 2>&1
    $OVERVIEWER_BIN --config="$WORLDS_LOCATION/$1/overviewer-settings.py" --genpoi >> "$WORLDS_LOCATION/$1/logs/overviewer.log" 2>&1
  fi
  # Announce the location to access the world map to players.
  if [ $SERVER_RUNNING -eq 1 ]; then
    sendCommand $1 "save-on"
    if [ $(compareMinecraftVersions $(getServerVersion $1) 1.7) -ge 0 ]; then
        sendCommand $WORLD 'tellraw @a {
          "text" : "",
          "extra" : [
            {
              "text" : "[Server] Mapping is complete. You can access the maps "
            },
            {
              "text" : "here",
              "color" : "aqua",
              "clickEvent" : {
                "action" : "open_url",
                "value" : "'$MAPS_URL'/'$WORLD'"
              }
            },
            {
              "text" : "."
            }
          ]
        }'
    else
        sendCommand $1 "say Mapping is complete.  You can access the maps at:"
        sendCommand $1 "say $MAPS_URL/$WORLD"
    fi
  fi
}

# ---------------------------------------------------------------------------
# Start a Query handler for a world server.
#
# @param 1 The world server to start a Query handler for.
# ---------------------------------------------------------------------------
queryStart() {
  local WORLD_DIR SERVER_IP QUERY_PORT
  # Grab the location of the world's directory.
  WORLD_DIR="$WORLDS_LOCATION/$1"
  # Determine the IP address and port used by the query server.
  SERVER_IP=$(getServerPropertiesValue $1 'server-ip' '127.0.0.1')
  QUERY_PORT=$(getServerPropertiesValue $1 'query.port')
  # Delete any old query.in or query.out buffer files.
  rm -Rf "$WORLD_DIR/query.in" "$WORLD_DIR/query.out"
  # Give the server a moment to start before initializing the
  # Query handler.
  sleep 20
  # Initialize the query.in and query.out buffer files.
  printf '' > "$WORLD_DIR/query.in"
  printf '' > "$WORLD_DIR/query.out"
  # Start a tail process to watch for changes to the query.in file to pipe
  # to the Minecraft query server via socat.  The response from the query
  # server is piped into the query.out file.
  tail -f --pid=$(getJavaPID $1) "$WORLD_DIR/query.in" | \
    $SOCAT - UDP:$SERVER_IP:$QUERY_PORT > "$WORLD_DIR/query.out"
  # Verify the connection to the query server worked.
  if [ $? -ne 0 ]; then
    printf "Error connecting to the query server.\n"
  fi

}

# ---------------------------------------------------------------------------
# Pack a hex string into a buffer file that is piped to the Minecraft query
# server.
#
# @param 1 The world server of interest.
# @param 2 The packet type.
# @param 3 The packet payload.
# @param 4 The response format.
# @return The response from the Query server in the requested format.
# ---------------------------------------------------------------------------
querySendPacket() {
  local ID PACKET RESPONSE WORLD_DIR
  # The packet identifier.
  ID="00000001"
  # The world's directory.
  WORLD_DIR="$WORLDS_LOCATION/$1"
  # Make sure the query.in and query.out buffer files exist before
  # preparing and sending the packet to the Query server.
  if [ -e "$WORLD_DIR/query.in" ] && [ -e "$WORLD_DIR/query.out" ]; then
    # Add the magic bytes to the incoming packet.
    PACKET=$(printf "FEFD%s%s%s" "$2" "$ID" "$3")
    # Remove any old responses from the query.out buffer file.
    printf '' > "$WORLD_DIR/query.out"
    # Pack the hex string packet and write it to the query.in buffer file.
    $PERL -e "
      print map { pack (\"C\", hex(\$_)) } (\"$PACKET\" =~ /(..)/g);
    " >> "$WORLD_DIR/query.in"
    # Give the Query server a moment to respond.
    sleep 1
    # Unpack the token from the query.out buffer file.  There are a
    # variable amount of null bytes at the start of the response string, so
    # find the start of the packet by searching for the packet type and ID.
    RESPONSE=$($PERL -ne '
      $hex .= sprintf "%.2x", $_ foreach (unpack "C*", $_);
      $hex =~ s/^0*'$2$ID'/'$2$ID'/;
      print $hex;
    ' $WORLD_DIR/query.out)
  fi
  if [ -n "$RESPONSE" ]; then
    # Return the response in the format requested.
    $PERL -e '
      $packed = join "", map { pack ("C", hex($_)) } ("'$RESPONSE'" =~ /(..)/g);
      printf "%s\n", join "\t", unpack ("'$4'", $packed);
    '
  fi
}

# ---------------------------------------------------------------------------
# Send a challenge packet to the Minecraft query server.
#
# @param 1 The world server of interest.
# @return Tab separated values:
#           type       - The packet type.
#           id         - The packet identifier.
#           token      - The token.
# ---------------------------------------------------------------------------
querySendChallengePacket() {
  local PACKET RESPONSE
  # Use an empty packet.
  PACKET="00000000"
  # Send the challenge packet to the Minecraft query server.
  RESPONSE=$(querySendPacket "$1" "09" "$PACKET" "Cl>Z*")
  # Return the response.
  printf "$RESPONSE\n"
}

# ---------------------------------------------------------------------------
# Send a status query to the Minecraft query server.
#
# @param 1 The world server of interest.
# @return Tab separated values:
#           type       - The packet type.
#           id         - The packet identifier.
#           MOTD       - The world's message of the day.
#           gametype   - The world's game type.
#           map        - The name of the world.
#           numplayers - The current number of players.
#           maxplayers - The maximum number of players.
#           hostport   - The host's port
#           hostip     - The host's IP address.
# ---------------------------------------------------------------------------
queryStatus() {
  local PACKET RESPONSE TOKEN
  if [ "$(getServerPropertiesValue $1 'enable-query')" = "true" ]; then
    # Send a challenge packet to the Minecraft query server.
    TOKEN=$(querySendChallengePacket $1 | cut -f 3)
    if [ -n "$TOKEN" ]; then
      # Use the challenge token for the packet.
      PACKET=$(printf "%08x" $TOKEN)
      # Send the information request packet to the Minecraft query server.
      RESPONSE=$(querySendPacket "$1" "00" "$PACKET" "Cl>Z*Z*Z*Z*Z*s<Z*")
    fi
  fi
  # Return the response.
  printf "$RESPONSE\n"
}

# ---------------------------------------------------------------------------
# Send a detailed status query to the Minecraft query server.
#
# @param 1 The world server of interest.
# @return Tab separated values:
#           type       - The packet type.
#           id         - The packet identifier.
#           *          - The string 'splitnum'.
#           *          - The value 128.
#           *          - The value 0.
#           *          - The string 'hostname'.
#           MOTD       - The world's message of the day.
#           *          - The string 'gametype'.
#           gametype   - The world's game type, hardcoded to 'SMP'.
#           *          - The string 'game_id'.
#           gameid     - The world's game ID, hardcoded to 'MINECRAFT'.
#           *          - The string 'version'.
#           version    - The world's Minecraft version.
#           *          - The string 'plugins'.
#           plugins    - The world's plugins.
#           *          - The string 'map'.
#           map        - The world's name.
#           *          - The string 'numplayers'.
#           numplayers - The world's current number of players.
#           *          - The string 'maxplayers'.
#           maxplayers - The world's maximum number of players.
#           *          - The string 'hostport'.
#           hostport   - The world's host port.
#           *          - The string 'hostip'.
#           hostip     - The world's host IP address.
#           *          - The value 0.
#           *          - The value 1.
#           *          - The string 'player_'.
#           *          - The value 0.
#           players    - The players currently logged onto the world.
# ---------------------------------------------------------------------------
queryDetailedStatus() {
  local CHALLENGE ID PACKET RESPONSE TOKEN
  if [ "$(getServerPropertiesValue $1 'enable-query')" = "true" ]; then
    # Send a challenge packet to the Minecraft query server.
    CHALLENGE=$(querySendChallengePacket $1)
    ID=$(echo "$CHALLENGE" | cut -f 2)
    TOKEN=$(echo "$CHALLENGE" | cut -f 3)
    if [ -n "$ID" ] && [ -n "$TOKEN" ]; then
      # Use the challenge token for the packet, with the ID on the end.
      PACKET=$(printf "%08x%08x" $TOKEN $ID)
      # Send the information request packet to the Minecraft query server.
      RESPONSE=$(querySendPacket "$1" "00" "$PACKET" \
        "Cl>Z*CCZ*Z*Z*Z*Z*Z*Z*Z*Z*Z*Z*Z*Z*Z*Z*Z*Z*Z*Z*Z*CCZ*C(Z*)*")
    fi
  fi
  # Return the response.
  printf "$RESPONSE\n"
}

# ---------------------------------------------------------------------------
# Query the number of active users from the query server.
#
# @param 1 The world server of interest.
# @return Number of active users.
# ---------------------------------------------------------------------------
queryNumUsers() {
  local NUM_USERS
  NUM_USERS=$(queryStatus $1 | cut -f6)
  # Return 0 if query server not available
  [ -z "$NUM_USERS" ] && NUM_USERS=0
  echo "$NUM_USERS"
}

# ---------------------------------------------------------------------------
# Display the status of a Minecraft world server.
#
# @param 1 The world server of interest.
# ---------------------------------------------------------------------------
worldStatus() {
  local STATUS NUM MAX PLAYERS COUNTER VERSION
  if serverRunning $1; then
    STATUS=$(queryDetailedStatus $1)
    if [ -n "$STATUS" ]; then
      NUM=$(echo "$STATUS" | cut -f 19)
      MAX=$(echo "$STATUS" | cut -f 21)
      VERSION=$(echo "$STATUS" | cut -f 13)
      printf "running version %s (%d of %d users online).\n" $VERSION $NUM $MAX
      if [ $NUM -gt 0 ]; then
        PLAYERS=$(echo "$STATUS" | cut -f 30)
        COUNTER=1
        while [ $COUNTER -lt $NUM ]; do
          PLAYERS=$(printf "%s, %s" "$PLAYERS" $(echo "$STATUS" | cut -f $((30+$COUNTER))))
          COUNTER=$(($COUNTER+1))
        done
        printf "    Players: %s.\n" "$PLAYERS"
      fi
    elif [ "$(getServerPropertiesValue $1 'enable-query')" = "true" ]; then
      printf "running (query server offline).\n"
    else
      printf "running.\n"
    fi
    printf "    Process ID: %d.\n" $(getJavaPID "$1")
  elif [ "$(getMSCSValue $1 'mscs-enabled')" = "false" ]; then
    printf "disabled.\n"
  else
    printf "not running.\n"
  fi
}

# ---------------------------------------------------------------------------
# Migrate world from old-style MSCS configuration if necessary.
#
# @param 1 The world to be migrated.
# ---------------------------------------------------------------------------
migrateOldMSCSConfig() {
  local SERVER_PROPERTY_FILE MSCS_PROPERTY_FILE TMP_PROPERTY_FILE
  if isWorldAvailable "$1"; then
    SERVER_PROPERTY_FILE="$WORLDS_LOCATION/$1/server.properties"
    MSCS_PROPERTY_FILE="$WORLDS_LOCATION/$1/mscs.properties"
    TMP_PROPERTY_FILE="$WORLDS_LOCATION/$1/tmp.properties"
    if [ ! -f "$MSCS_PROPERTY_FILE" ]; then
      grep ^mscs "$SERVER_PROPERTY_FILE" > "$MSCS_PROPERTY_FILE"
      grep -v ^mscs "$SERVER_PROPERTY_FILE" > "$TMP_PROPERTY_FILE"
      mv "$TMP_PROPERTY_FILE" "$SERVER_PROPERTY_FILE"
    fi
  else
     echo "World $1 not found."
  fi
}

# ---------------------------------------------------------------------------
# Migrate all worlds from old-style MSCS configuration if necessary.
# ---------------------------------------------------------------------------
migrateWorldsConfig() {
	if [ ! -f "$WORLDS_LOCATION/mscs-worlds-config-migrated" ]; then
		echo "Migrating worlds to new mscs.properties config file if needed"
		for WORLD in $(getAvailableWorlds); do
		  migrateOldMSCSConfig "$WORLD"
		done
		touch "$WORLDS_LOCATION/mscs-worlds-config-migrated"
		echo "Remove file '$WORLDS_LOCATION/mscs-worlds-config-migrated' to repeat"
		echo "the migration process in the next execution."
	fi
}

# ---------------------------------------------------------------------------
# Migrate old disabled worlds if any.
# ---------------------------------------------------------------------------
migrateOldDisabledWorlds() {
  local WORLD WORLDS
  if [ -d "$OLD_DISABLED_WORLDS_LOCATION" ]; then
    # Be sure worlds directory exists
    mkdir -p "$WORLDS_LOCATION"

    for WORLD in $(ls "$OLD_DISABLED_WORLDS_LOCATION"); do
      if [ -d "$OLD_DISABLED_WORLDS_LOCATION/$WORLD" ]; then
        echo "Migrating old version's disabled world: $WORLD"
        mv "$OLD_DISABLED_WORLDS_LOCATION/$WORLD" "$WORLDS_LOCATION"
        migrateOldMSCSConfig "$WORLD"
        setMSCSValue "$WORLD" mscs-enabled false
      fi
    done
    # Try to remove old disabled worlds dir if empty
    if ! rmdir "$OLD_DISABLED_WORLDS_LOCATION" > /dev/null 2>&1; then
      echo "Warning: old version's disabled world dir not emty after migration"
      echo "    Dir: $OLD_DISABLED_WORLDS_LOCATION"
    fi
  fi
}

# ---------------------------------------------------------------------------
# Begin.
# ---------------------------------------------------------------------------

# Migrate old config.
# Migrate config of not already migrated worlds
migrateWorldsConfig
# Migrate old version's disabled worlds if any
migrateOldDisabledWorlds

# Make sure that Java, Perl, Python, Wget, Rdiff-backup, and Socat are installed.
if [ ! -e "$JAVA" ]; then
  printf "ERROR: Java not found!\n"
  printf "Try installing this with:\n"
  printf "sudo apt-get install default-jre"
  exit 1
fi
if [ ! -e "$PERL" ]; then
  printf "ERROR: Perl not found!\n"
  printf "Try installing this with:\n"
  printf "sudo apt-get install perl\n"
  exit 1
fi
if [ ! -e "$PYTHON" ]; then
  printf "ERROR: Python not found!\n"
  printf "Try installing this with:\n"
  printf "sudo apt-get install python\n"
  exit 1
fi
if [ ! -e "$WGET" ]; then
  printf "ERROR: GNU Wget not found!\n"
  printf "Try installing this with:\n"
  printf "sudo apt-get install wget\n"
  exit 1
fi
if [ ! -e "$RDIFF_BACKUP" ]; then
  printf "ERROR: rdiff-backup not found!\n"
  printf "Try installing this with:\n"
  printf "sudo apt-get install rdiff-backup\n"
  exit 1
fi
if [ ! -e "$SOCAT" ]; then
  printf "ERROR: socat not found!\n"
  printf "Try installing this with:\n"
  printf "sudo apt-get install socat\n"
  exit 1
fi


# Respond to the command line arguments.
case "$1" in
  start)
    # Figure out which worlds to start.
    WORLDS=$(getEnabledWorlds)
    if [ -z "$WORLDS" ]; then
      echo "There are no worlds to start."
      echo "You may want to enable a world:"
      echo "  $PROG enable <world>"
      echo "Or create a new world:"
      echo "  $PROG create <world> <port>"
      echo "Or create the default world at the default port:"
      echo "  $PROG create"
      exit 1
    elif [ -n "$2" ]; then
      if isWorldEnabled "$2"; then
        WORLDS="$2"
      elif [ -n "$2" ]; then
        printf "World '$2' not recognized.\n"
        printf "  Usage:  $PROG $1 <world>\n"
        exit 1
      fi
    fi
    # Start each world requested, if not already running.
    printf "Starting Minecraft Server:"
    for WORLD in $WORLDS; do
      if ! serverRunning $WORLD; then
        printf " $WORLD"
        start $WORLD
      fi
    done
    printf ".\n"
  ;;
  stop|force-stop)
    # Figure out which worlds to stop.
    if isWorldEnabled "$2"; then
      WORLDS="$2"
    elif [ -n "$2" ]; then
      printf "World '$2' not recognized.\n"
      printf "  Usage:  $PROG $1 <world>\n"
      exit 1
    else
      WORLDS=$(getEnabledWorlds)
    fi
    # Stop each world requested, if running.
    printf "Stopping Minecraft Server:"
    for WORLD in $WORLDS; do
      # Try to stop the world cleanly.
      if serverRunning $WORLD; then
        printf " $WORLD"
        if [ $(queryNumUsers $WORLD) -gt 0 ]; then
          sendCommand $WORLD "say The server admin has initiated a server shut down."
          sendCommand $WORLD "say The server will shut down in 1 minute..."
          sleep 60
          sendCommand $WORLD "say The server is now shutting down."
        fi
        sendCommand $WORLD "save-all"
        sendCommand $WORLD "save-off"
        if [ "$1" = "force-stop" ]; then
          forceStop $WORLD
        else
          stop $WORLD
        fi
      elif [ "$1" = "force-stop" ]; then
        printf " $WORLD"
        forceStop $WORLD
      fi
    done
    printf ".\n"
  ;;
  restart|reload|force-restart|force-reload)
    # Figure out which worlds to restart.
    if isWorldEnabled "$2"; then
      WORLDS="$2"
    elif [ -n "$2" ]; then
      printf "World '$2' not recognized.\n"
      printf "  Usage:  $PROG $1 <world>\n"
      exit 1
    else
      WORLDS=$(getEnabledWorlds)
    fi
    # Restart each world requested, start those not already
    # running.
    printf "Restarting Minecraft Server:"
    for WORLD in $WORLDS; do
      printf " $WORLD"
      if serverRunning $WORLD; then
        if [ $(queryNumUsers $WORLD) -gt 0 ]; then
          sendCommand $WORLD "say The server admin has initiated a server restart."
          sendCommand $WORLD "say The server will restart in 1 minute..."
          sleep 60
          sendCommand $WORLD "say The server is now restarting."
        fi
        sendCommand $WORLD "save-all"
        sendCommand $WORLD "save-off"
        if [ "$(echo \"$1\" | cut -d '-' -f1)" = "force" ]; then
          forceStop $WORLD
        else
          stop $WORLD
        fi
        sleep 5
      fi
      start $WORLD
    done
    printf ".\n"
  ;;
  create|new)
    if [ -n "$2" ]; then
      if [ -z "$3" ]; then
        printf "A name and port for the new world must be supplied.\n"
        printf "An IP address is optional and usually not needed.\n"
        printf "  Usage: $PROG create <world> <port> [<ip>]\n"
        exit 1
      else
        printf "Creating Minecraft world: $2"
        createWorld "$2" "$3" "$4"
        printf ".\n"
      fi
    elif [ -z "$(getAvailableWorlds)" ]; then
      printf 'Creating default world "%s" at default port %s' \
        $DEFAULT_WORLD $DEFAULT_PORT
      createWorld "$DEFAULT_WORLD" "$DEFAULT_PORT"
      printf ".\n"
    fi

  ;;
  delete|remove)
    # Get list of enabled worlds.
    if ! isWorldAvailable "$2"; then
      printf "World not found, unable to delete world '$2'.\n"
      exit 1
    fi
    printf "Deleting Minecraft world: $2"
    if serverRunning "$2"; then
      # If the world server has users logged in, announce that the world is
      # being deleted.
      if [ $(queryNumUsers "$2") -gt 0 ]; then
        sendCommand "$2" "say The server admin is deleting this world."
        sendCommand "$2" "say The server will be deleted in 1 minute..."
        sleep 60
        sendCommand "$2" "say The server is now shutting down."
      fi
      # Stop the world server.
      stop "$2"
      sleep 5
    fi
    # Delete the world.
    deleteWorld "$2"
    printf ".\n"
  ;;
  disable)
    # Get list of enabled worlds.
    if ! isWorldEnabled "$2"; then
      printf "World not found, unable to disable world '$2'.\n"
      exit 1
    fi
    printf "Disabling Minecraft world: $2"
    if serverRunning "$2"; then
      # If the world server has users logged in, announce that the world is
      # being disabled.
      if [ $(queryNumUsers "$2") -gt 0 ]; then
        sendCommand "$2" "say The server admin is disabling this world."
        sendCommand "$2" "say The server will be disabled in 1 minute..."
        sleep 60
        sendCommand "$2" "say The server is now shutting down."
      fi
      # Stop the world server.
      stop "$2"
      sleep 5
    fi
    # Disable the world.
    disableWorld "$2"
    printf ".\n"
  ;;
  enable)
    # Get list of disabled worlds.
    if ! isWorldAvailable "$2"; then
      printf "World not found, unable to enable world '$2'.\n"
      exit 1
    elif isWorldEnabled "$2"; then
      printf "Unable to enable already enabled world '$2'.\n"
      exit 1
    fi
    printf "Enabling Minecraft world: $2"
    # Enable the world.
    enableWorld "$2"
    # Start the world.
    start "$2"
    printf ".\n"
  ;;
  ls|list)
    # Grab the desired list of worlds.
    WORLDS=""
    case "$2" in
      enabled)
        WORLDS=$(getEnabledWorlds)
      ;;
      disabled)
        WORLDS=$(getDisabledWorlds)
      ;;
      running)
        for WORLD in $(getEnabledWorlds); do
          if serverRunning $WORLD; then
            WORLDS="$WORLDS $WORLD"
          fi
        done
      ;;
      stopped)
        for WORLD in $(getEnabledWorlds); do
          if ! serverRunning $WORLD; then
            WORLDS="$WORLDS $WORLD"
          fi
        done
      ;;
      "")
        WORLDS=$(getAvailableWorlds)
      ;;
      *)
        echo "Unknown list option: $2."
        echo "  Try '$PROG help' for help."
        exit 1
      ;;
    esac

    case "$1" in
      ls)
        # Simple list
        for WORLD in $WORLDS; do
          WPORT=$(getServerPropertiesValue "$WORLD" server-port "")
          printf "  $WORLD: $WPORT"
          if isWorldEnabled "$WORLD"; then
            printf '\n'
          else
            printf ' (disabled)\n'
          fi
        done
      ;;
      list)
        # Detailed list
        for WORLD in $WORLDS; do
          printf "  $WORLD:"
          if isWorldEnabled "$WORLD"; then
            printf '\n'
          else
            printf ' (disabled)\n'
          fi
          for PROP in $DETAILED_LISTING_PROPERTIES; do
            printf "    $PROP="
            getServerPropertiesValue "$WORLD" "$PROP" ""
          done
        done
      ;;
    esac
  ;;
  status|show)
    # Figure out which worlds to show the status for.
    if isWorldAvailable "$2"; then
      WORLDS="$2"
    elif [ -n "$2" ]; then
      printf "World '$2' not recognized.\n"
      printf "  Usage:  $PROG $1 <world>\n"
      exit 1
    else
      WORLDS=$(getAvailableWorlds)
    fi
    # Show the status of each world requested.
    printf "Minecraft Server Status:\n"
    for WORLD in $WORLDS; do
      printf "  $WORLD: "
      worldStatus $WORLD
    done
  ;;
  sync|synchronize)
    # Figure out which worlds to synchronize.
    if isWorldEnabled "$2"; then
      WORLDS="$2"
    elif [ -n "$2" ]; then
      printf "World '$2' not recognized.\n"
      printf "  Usage:  $PROG $1 <world>\n"
      exit 1
    else
      WORLDS=$(getEnabledWorlds)
    fi
    # Synchronize the images for each world.
    printf "Synchronizing Minecraft Server:"
    for WORLD in $WORLDS; do
      if serverRunning $WORLD; then
        printf " $WORLD"
        sendCommand $WORLD "save-all"
        if [ $ENABLE_MIRROR -eq 1 ]; then
          sendCommand $WORLD "save-off"
          sleep 20
          syncMirrorImage $WORLD
          sendCommand $WORLD "save-on"
        fi
      fi
    done
    printf ".\n"
  ;;
  broadcast)
    # Get list of enabled worlds.
    WORLDS=$(getEnabledWorlds)
    if [ -n "$2" ]; then
      # Remove broadcast from the command line arguments.
      shift 1
      # Broadcast the message to all of the enabled worlds.
      printf "Broadcasting command to world:"
      for WORLD in $WORLDS; do
        if serverRunning $WORLD; then
          printf " $WORLD"
          sendCommand $WORLD "$*"
        fi
      done
      printf ".\n"
    else
      printf "Usage:  $PROG $1 <command>\n"
      printf "   ie:  $PROG $1 say Hello World!\n"
      exit 1
    fi
  ;;
  send)
    # Check for the world command line argument.
    if isWorldEnabled "$2" && [ -n "$3" ]; then
      WORLD=$2
      shift 2
      printf "Sending command to world: $WORLD - '$*'.\n"
      sendCommand $WORLD "$*"
    else
      printf "Usage:  $PROG $1 <world> <command>\n"
      printf "   ie:  $PROG $1 world say Hello World!\n"
      exit 1
    fi
  ;;
  console)
    # Check for the world command line argument.
    if isWorldEnabled "$2"; then
      printf "Connecting to server console: $2.\n"
      printf "  Hit <Ctrl-D> to detach.\n"
      sleep 3
      serverConsole $2
    else
      if [ -n "$2" ]; then
        printf "Minecraft world $2 not found!\n"
      else
        printf "Minecraft world not provided!\n"
      fi
      printf "  Usage:  $PROG $1 <world>\n"
      exit 1
    fi
  ;;
  watch)
    # Check for the world command line argument.
    if isWorldEnabled "$2"; then
      printf "Monitoring Minecraft Server: $2.\n"
      watchLog $2
    else
      if [ -n "$2" ]; then
        printf "Minecraft world $2 not found!\n"
      else
        printf "Minecraft world not provided!\n"
      fi
      printf "  Usage:  $PROG $1 <world>\n"
      exit 1
    fi
  ;;
  logrotate)
    # Figure out which worlds to rotate the log.
    if isWorldEnabled "$2"; then
      WORLDS="$2"
    elif [ -n "$2" ]; then
      printf "World '$2' does not exist or not enabled.\n"
      printf "  Usage:  $PROG $1 <world>\n"
      exit 1
    else
      WORLDS=$(getEnabledWorlds)
    fi
    # Backup each world requested.
    printf "Rotating Minecraft Server Log:"
    for WORLD in $WORLDS; do
      printf " $WORLD"
      rotateLog $WORLD
    done
    printf ".\n"
  ;;
  backup)
    # Figure out which worlds to backup.
    if isWorldEnabled "$2"; then
      WORLDS="$2"
    elif [ -n "$2" ]; then
      printf "World '$2' does not exist or not enabled.\n"
      printf "  Usage:  $PROG $1 <world>\n"
      exit 1
    else
      WORLDS=$(getEnabledWorlds)
    fi
    # Backup each world requested.
    printf "Backing up Minecraft Server:"
    for WORLD in $WORLDS; do
      printf " $WORLD"
      if serverRunning $WORLD; then
        sendCommand $WORLD "say Backing up the world."
        sendCommand $WORLD "save-all"
        sendCommand $WORLD "save-off"
        sleep 20
        worldBackup $WORLD
        sendCommand $WORLD "save-on"
        sendCommand $WORLD "say Backup complete."
      else
        worldBackup $WORLD
      fi
    done
    printf ".\n"
  ;;
  list-backups)
    if isWorldEnabled "$2"; then
      worldBackupList "$2"
    elif [ -n "$2" ]; then
      printf "World '$2' does not exist or not enabled.\n"
      printf "  Usage:  $PROG $1 <world>\n"
      exit 1
    else
      printf "World not supplied.\n"
      printf "  Usage:  $PROG $1 <world>\n"
      exit 1
    fi
  ;;
  restore-backup)
    if [ -z $2 ]; then
      printf "World not supplied.\n"
      printf "  Usage:  $PROG $1 <world>\n"
      exit 1
    elif ! isWorldAvailable "$2"; then
      printf "World '$2' not recognized.\n"
      printf "  Usage:  $PROG $1 <world>\n"
      exit 1
    elif serverRunning "$2"; then
      printf "World '$2' is running. Stop it first\n"
      printf "  $PROG stop $2\n"
      exit 1
    elif worldBackup "$2"; then
      worldBackupRestore "$2" "$3"
    else
      echo "Current world's state backup failed. Restore cancelled."
      exit 1
    fi
  ;;
  update)
    # Figure out which worlds to update.
    if isWorldEnabled "$2"; then
      WORLDS="$2"
    elif [ -n "$2" ]; then
      printf "World '$2' does not exist or not enabled.\n"
      printf "  Usage:  $PROG $1 <world>\n"
      exit 1
    else
      WORLDS=$(getEnabledWorlds)
    fi
    # Stop all of the world servers and backup the worlds.
    RUNNING=
    printf "Stopping Minecraft Server:"
    for WORLD in $WORLDS; do
      if serverRunning $WORLD; then
        RUNNING="$RUNNING $WORLD"
        printf " $WORLD"
        if [ $(queryNumUsers $WORLD) -gt 0 ]; then
          sendCommand $WORLD "say The server admin has initiated a software update."
          sendCommand $WORLD "say The server will restart and update in 1 minute..."
          sleep 60
          sendCommand $WORLD "say The server is now restarting."
        fi
        sendCommand $WORLD "save-all"
        sendCommand $WORLD "save-off"
        stop $WORLD
      fi
    done
    printf ".\n"
    printf "Backing up Minecraft Server:"
    for WORLD in $WORLDS; do
      printf " $WORLD"
      worldBackup $WORLD
    done
    printf ".\n"
    # Update the server software.
    printf "Updating Server Software:"
    for WORLD in $WORLDS; do
      printf " $WORLD"
      updateServerSoftware "$WORLD"
    done
    printf ".\n"
    printf "Restarting Minecraft Server:"
    for WORLD in $RUNNING; do
      printf " $WORLD"
      start $WORLD
    done
    printf ".\n"
  ;;
  map|overviewer)
    # Make sure that the Minecraft Overviewer software exists.
    if [ ! -e "$OVERVIEWER_BIN" ]; then
      printf "Minecraft Overviewer software not found.\n"
      exit 1
    fi
    # Figure out which worlds to map.
    if isWorldEnabled "$2"; then
      WORLDS="$2"
    elif [ -n "$2" ]; then
      printf "World '$2' does not exist or not enabled.\n"
      printf "  Usage:  $PROG $1 <world>\n"
      exit 1
    else
      WORLDS=$(getEnabledWorlds)
    fi
    # Run Minecraft Overviewer on each world requested.
    printf "Running Minecraft Overviewer mapping:"
    for WORLD in $WORLDS; do
      printf " $WORLD"
      overviewer "$WORLD"
    done
    printf ".\n"
  ;;
  usage|help)
    printf "Minecraft Server Control Script\n"
    printf "\n"
    usage
  ;;
  *)
    printf "Error in command line usage.\n"
    printf "\n"
    usage
    exit 1
  ;;
esac
exit 0