API tools faq
paste
Advertisement
masa-

masa's Minecraft server script, 2014-07-15

masa-
Jul 14th, 2014
319
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Bash 29.41 KB | None | 0 0
raw download clone embed print report
  1. ##################################################
  2. #  minecraft_server_ftb_agrarian_skies_3.sh:
  3. ##################################################
  4.  
  5. #!/bin/bash
  6. # version x.x.x 2013-11-14 (YYYY-MM-DD)
  7.  
  8. #########################
  9. #       Settings        #
  10. #########################
  11. INSTANCE='ftb_agrarian_skies_3' # Server instance name (used in several places, such as the path, the server process (file)name, etc.)
  12. WORLD_NAME='world'  # World directory name
  13. HOST="localhost"    # Host address used for pinging the server
  14. PORT="25606"        # Server port, used when running the check_ping command
  15.  
  16. ALLOW_UPDATES='false'           # Allow upgrading the server version using the mc_update() function?
  17. ALLOW_DOWNGRADES='false'        # Allow downgrading the server version using the mc_update() function?
  18. DISABLE_AUTOSAVE='false'        # Run the save-off command after start?
  19.  
  20. SCREEN_SESSION="mc_${INSTANCE}" # The screen session name that will be used for this server instance
  21. BACKUP_PREFIX="${INSTANCE}" # filename prefix (<prefix>_YYYY-mm-dd_HH.MM.SS.tar.gz)
  22. BACKUP_SERVICE='false'      # backup the server file (jar)?
  23. BACKUP_USING_TAR='false'    # Create a tarball of the server instance (or the world)?
  24. BACKUP_USING_GIT='true'     # Create backups using git?
  25.                 # NOTE: You have to run git init manually in the instance path (or the world path) before first backup
  26.                 # NOTE 2: There must NOT be a world-only git repo under the world directory when doing
  27.                 # full-server backups using git! Otherwise the world directory will not get backed up!
  28. BACKUP_WORLD_ONLY='false'   # Backup only the world directory, not the full server instance?
  29.  
  30. #########################
  31. #       Paths           #
  32. #########################
  33. BASE_PATH="/data/game_servers/minecraft"
  34. INSTANCE_PATH="${BASE_PATH}/servers/${INSTANCE}"
  35. WORLD_PATH="${INSTANCE_PATH}/${WORLD_NAME}"
  36. SERVICE="minecraft_server_${INSTANCE}.jar"  # Server filename (symlink filename) in the INSTANCE directory
  37.  
  38. BACKUP_PATH="/mnt/640_jemma/mc_backups/${INSTANCE}"
  39. STATE_FILE="/tmp/mc_server_${INSTANCE}_running.txt"
  40. EVENT_LOG_FILE="${BASE_PATH}/event_logs/${INSTANCE}_events.log"
  41. BACKUP_LOG_FILE="${BASE_PATH}/event_logs/${INSTANCE}_backups.log"
  42.  
  43. COMMON_FUNCTIONS_SCRIPT="${BASE_PATH}/scripts/mc_common_functions.sh"
  44. PING_SCRIPT="${BASE_PATH}/scripts/ping.py"
  45. PING_INVOCATION="python ${PING_SCRIPT} ${HOST} ${PORT} 1.6 2" # host, port, timeout, protocol [1|2|3]
  46.  
  47. # Update related things (mc_update()):
  48. SERVER_FILES_PATH="/data/minecraft/server"  # Path where all the server jar files are saved (used when running mc_update())
  49. SERVER_FILE_PREFIX="minecraft_server_"      # Filename prefix used for the server files in SERVER_FILES_PATH directory
  50. VERSIONS_JSON="/tmp/minecraft_versions.json" # The path where the version json is saved, used for upgrades/downgrades
  51.  
  52. # Server process invocation and JVM arguments:
  53. OPTIONS='nogui'
  54. #OPTIONS='nogui --log-strip-color'  # Spigot/Bukkit
  55. USERNAME='masa'
  56. CPU_COUNT=2
  57.  
  58. # From MC bug tracker [Mod] Talven81:
  59. #JVM_OPTS="-Xincgc -XX:+UseParNewGC -XX:+DisableExplicitGC -XX:+UseConcMarkSweepGC -XX:ParallelGCThreads=2 -XX:MaxGCPauseMillis=100 -XX:+AggressiveOpts"
  60.  
  61. #JVM_OPTS="-Xincgc -XX:+UseParNewGC -XX:+UseConcMarkSweepGC"
  62. JVM_OPTS="-XX:+UseConcMarkSweepGC"
  63. JVM_MEM_OPTS="-Xms2048M -Xmx2048M -XX:PermSize=128m"
  64. INVOCATION="java ${JVM_MEM_OPTS} ${JVM_OPTS} -jar ${SERVICE} ${OPTIONS}"
  65.  
  66. #########################
  67. #       Delays          #
  68. #########################
  69.  
  70. POST_START_DELAY=3      # Delay after the command, before entering the check loop
  71. START_GRACE_DELAY=20    # How many times to loop/how long to wait for the server to come up
  72.  
  73. START_TO_DISABLE_AUTOSAVE_DELAY=30  # Delay after server start before issuing the save-off command (if DISABLE_AUTOSAVE='true')
  74.  
  75. POST_STOP_DELAY=5       # Delay after the command, before entering the check loop
  76. STOP_GRACE_DELAY=20     # How many times to loop/how long to wait for the server to shut down
  77.  
  78. POST_SAVEALL_DELAY=5    # How long to wait after a save-all command before continuing
  79. SAVEALL_BACKUP_INTERVAL=5   # How long to wait after doing a save-all, before starting the backup
  80.  
  81. RESTART_FIRST_WARNING=5 # Broadcast a warning message on the server and wait this long before restarting
  82. RESTART_LAST_WARNING=5  # The second and last warning is broadcast this long before restarting
  83.  
  84. SAVEALL_STOP_INTERVAL=5 # How long to wait after the save-all command, before the stop command
  85.  
  86. POST_KILL_DELAY=5       # How long to wait after issuing the kill signal, before entering the check loop
  87. KILL_GRACE_DELAY=30     # How many times to loop/how long to wait for the server to die, before throwing an error
  88.  
  89. PING_RETRY_DELAY=10     # How long to wait before ping commands
  90. PING_RETRY_COUNT=3      # How many times to try the ping, before killing and restarting the server
  91. KILL_TO_START_DELAY=20  # How long to wait after killing the server and before restarting it
  92.  
  93. #########################
  94. #### End of settings ####
  95. #########################
  96.  
  97. source ${COMMON_FUNCTIONS_SCRIPT}
  98.  
  99.  
  100. # Process the commands
  101. case "${1}" in
  102.     start)
  103.         mc_start
  104.         ;;
  105.     stop)
  106.         mc_stop
  107.         ;;
  108.     restart)
  109.         mc_restart ${2} ${3}
  110.         ;;
  111.     restartifup)
  112.         mc_restart_if_up ${2} ${3}
  113.         ;;
  114.     check)
  115.         mc_startifcrashed_basic
  116.         ;;
  117.     check_ping)
  118.         mc_startifcrashed_ping
  119.         ;;
  120.     backup)
  121.         mc_backup_wrapper "${2}"
  122.         ;;
  123.     saveoff)
  124.         mc_saveoff
  125.         ;;
  126.     saveon)
  127.         mc_saveon
  128.         ;;
  129.     saveall)
  130.         mc_saveall
  131.         ;;
  132.     kill)
  133.         mc_kill
  134.         ;;
  135.     update)
  136.         mc_update "${2}"
  137.         ;;
  138.     say)
  139.         mc_say "${2}"
  140.         ;;
  141.     status)
  142.         L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  143.         L_PREFIX="[${L_TIMESTAMP}]"
  144.  
  145.         if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  146.         then
  147.             echo "${L_PREFIX} [INFO] ${SERVICE} is running"
  148.         else
  149.             echo "${L_PREFIX} [INFO] ${SERVICE} is not running"
  150.         fi
  151.         ;;
  152.     command)
  153.         mc_command "${2}"
  154.         ;;
  155.  
  156.     *)
  157.         echo "Usage: /etc/init.d/minecraft {start|stop|restart|restartifup|check|check_ping|backup|saveoff|saveon|saveall|kill|update|say|status|command \"server command\"}"
  158.         exit 1
  159.         ;;
  160. esac
  161.  
  162. exit 0
  163.  
  164.  
  165.  
  166.  
  167.  
  168.  
  169.  
  170.  
  171.  
  172.  
  173.  
  174.  
  175. ##################################################
  176.  # mc_common_functions.sh
  177. ##################################################
  178. #!/bin/bash
  179. # Initial version from Minecraft wiki
  180. # Heavily modified, customized and expanded by masa (kiesus@gmail.com)
  181. # version x.x.x 2013-11-07 (YYYY-MM-DD)
  182.  
  183. export LANG=en_US.UTF-8
  184. export LC_ALL=en_US.UTF-8
  185.  
  186. as_user() {
  187.     ME=`whoami`
  188.  
  189.     if [ ${ME} == ${USERNAME} ] ; then
  190.         bash -c "${1}"
  191.     else
  192.         su - ${USERNAME} -c "${1}"
  193.     fi
  194. }
  195.  
  196.  
  197. mc_start() {
  198.     L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  199.     L_PREFIX="${L_TIMESTAMP}"
  200.  
  201.     # Check that the server is not already running
  202.     if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  203.     then
  204.         echo "${L_PREFIX} [WARNING] mc_start(): ${SERVICE} is already running" | tee -a ${EVENT_LOG_FILE}
  205.     else
  206.         echo "${L_PREFIX} [INFO] mc_start(): Starting ${SERVICE}..." | tee -a ${EVENT_LOG_FILE}
  207.  
  208.         # Start the server process
  209.         as_user "cd ${INSTANCE_PATH} && screen -dmS ${SCREEN_SESSION} ${INVOCATION}"
  210.         sleep ${POST_START_DELAY}
  211.  
  212.         # Verify that the server process was started successfully, by checking a few times in a delayed loop
  213.         COUNTER=0
  214.         while [ $COUNTER -lt ${START_GRACE_DELAY} ]; do
  215.  
  216.             if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  217.             then
  218.                 L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  219.                 L_PREFIX="${L_TIMESTAMP}"
  220.  
  221.                 echo "${L_PREFIX} [INFO] mc_start(): ${SERVICE} is now running" | tee -a ${EVENT_LOG_FILE}
  222.  
  223.                 # Create the state file to indicate that the server is/should be running
  224.                 as_user "touch ${STATE_FILE}"
  225.  
  226.                 # Disable automatic saving?
  227.                 if [ "${DISABLE_AUTOSAVE}" = "true" ]
  228.                 then
  229.                     sleep ${START_TO_DISABLE_AUTOSAVE_DELAY}
  230.                     mc_saveoff
  231.                 fi
  232.  
  233.                 break
  234.             fi
  235.  
  236.             sleep 1
  237.  
  238.             ((COUNTER += 1))
  239.         done
  240.  
  241.         # If the loop counter hit the max value, the process was not started successfully
  242.         if [ ${COUNTER} -ge ${START_GRACE_DELAY} ]
  243.         then
  244.             L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  245.             L_PREFIX="${L_TIMESTAMP}"
  246.  
  247.             echo "${L_PREFIX} [ERROR] mc_start(): Could not start ${SERVICE}" | tee -a ${EVENT_LOG_FILE}
  248.         fi
  249.     fi
  250. }
  251.  
  252.  
  253. mc_stop() {
  254.     L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  255.     L_PREFIX="${L_TIMESTAMP}"
  256.  
  257.     # Check that the process is running
  258.     if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  259.     then
  260.         echo "${L_PREFIX} [INFO] mc_stop(): Stopping ${SERVICE}" | tee -a ${EVENT_LOG_FILE}
  261.  
  262.         if [ "${1}" = "broadcast" ]
  263.         then
  264.             as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"say §dSERVER SHUTTING DOWN NOW. Saving the map...\"\015'"
  265.         fi
  266.  
  267.         as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"save-all\"\015'"
  268.         sleep ${SAVEALL_STOP_INTERVAL}
  269.  
  270.         as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"stop\"\015'"
  271.         sleep ${POST_STOP_DELAY}
  272.  
  273.         # Check if the process was successfully stopped
  274.         COUNTER=0
  275.         while [ ${COUNTER} -lt ${STOP_GRACE_DELAY} ]; do
  276.  
  277.             if ! pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  278.             then
  279.                 # Remove the state file to indicate that the server has been stopped gracefully
  280.                 as_user "rm ${STATE_FILE} > /dev/null 2>&1"
  281.  
  282.                 L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  283.                 L_PREFIX="${L_TIMESTAMP}"
  284.                 echo "${L_PREFIX} [INFO] mc_stop(): ${SERVICE} has been stopped" | tee -a ${EVENT_LOG_FILE}
  285.  
  286.                 break
  287.             fi
  288.  
  289.             sleep 1
  290.  
  291.             ((COUNTER += 1))
  292.         done
  293.  
  294.         if [ ${COUNTER} -ge ${STOP_GRACE_DELAY} ]
  295.         then
  296.             L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  297.             L_PREFIX="${L_TIMESTAMP}"
  298.  
  299.             echo "${L_PREFIX} [ERROR] mc_stop(): ${SERVICE} could not be stopped" | tee -a ${EVENT_LOG_FILE}
  300.         fi
  301.     else
  302.         echo "${L_PREFIX} [WARNING] mc_stop(): ${SERVICE} was not running" | tee -a ${EVENT_LOG_FILE}
  303.     fi
  304. }
  305.  
  306.  
  307. mc_restart() {
  308.     # Use the arguments as override delay values, if they exist
  309.     if [ -n "${1}" ]
  310.     then
  311.         RESTART_FIRST_WARNING=${1}
  312.  
  313.         if [ -n "${2}" ]
  314.         then
  315.             RESTART_LAST_WARNING=${2}
  316.         fi
  317.     fi
  318.  
  319.     # Check if the server process is running, and broadcast warning messages before stopping the server
  320.     if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  321.     then
  322.         if [ ${RESTART_FIRST_WARNING} -gt ${RESTART_LAST_WARNING} ]
  323.         then
  324.             as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"say §dSERVER RESTARTING IN ${RESTART_FIRST_WARNING} SECONDS\"\015'"
  325.             ((DELAY = ${RESTART_FIRST_WARNING} - ${RESTART_LAST_WARNING}))
  326.             sleep ${DELAY}
  327.         fi
  328.  
  329.         as_user "screen -p 0 -S $SCREEN_SESSION -X eval 'stuff \"say §dSERVER RESTARTING IN ${RESTART_LAST_WARNING} SECONDS\"\015'"
  330.         sleep ${RESTART_LAST_WARNING}
  331.  
  332.         L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  333.         L_PREFIX="${L_TIMESTAMP}"
  334.         echo "${L_PREFIX} [INFO] mc_restart(): Stopping ${SERVICE}" | tee -a ${EVENT_LOG_FILE}
  335.  
  336.         mc_stop
  337.  
  338.         if ! pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  339.         then
  340.             L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  341.             L_PREFIX="${L_TIMESTAMP}"
  342.             echo "${L_PREFIX} [INFO] mc_restart(): ${SERVICE} has been stopped" | tee -a ${EVENT_LOG_FILE}
  343.         fi
  344.     fi
  345.  
  346.     # (Re-)Start the server
  347.     if ! pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  348.     then
  349.         L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  350.         L_PREFIX="${L_TIMESTAMP}"
  351.         echo "${L_PREFIX} [INFO] mc_restart(): (Re-)starting ${SERVICE}..." | tee -a ${EVENT_LOG_FILE}
  352.  
  353.         mc_start
  354.  
  355.         L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  356.         L_PREFIX="${L_TIMESTAMP}"
  357.  
  358.         if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  359.         then
  360.             echo "${L_PREFIX} [INFO] mc_restart(): ${SERVICE} is now running" | tee -a ${EVENT_LOG_FILE}
  361.         else
  362.             echo "${L_PREFIX} [ERROR] mc_restart(): Could not start ${SERVICE}" | tee -a ${EVENT_LOG_FILE}
  363.         fi
  364.  
  365.     else
  366.         echo "${L_PREFIX} [ERROR] mc_restart(): ${SERVICE} could not be stopped" | tee -a ${EVENT_LOG_FILE}
  367.     fi
  368. }
  369.  
  370.  
  371. mc_restart_if_up() {
  372.     # Use the arguments as override delay values, if they exist
  373.     if [ -n "${1}" ]
  374.     then
  375.         RESTART_FIRST_WARNING=${1}
  376.  
  377.         if [ -n "${2}" ]
  378.         then
  379.             RESTART_LAST_WARNING=${2}
  380.         fi
  381.     fi
  382.  
  383.     # First check if the server is supposed to be running
  384.     if [ -f "${STATE_FILE}" ]
  385.     then
  386.         # Check if the server process is running, and broadcast warning messages before stopping the server
  387.         if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  388.         then
  389.             if [ ${RESTART_FIRST_WARNING} -gt ${RESTART_LAST_WARNING} ]
  390.             then
  391.                 as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"say §dSERVER RESTARTING IN ${RESTART_FIRST_WARNING} SECONDS\"\015'"
  392.                 ((DELAY = ${RESTART_FIRST_WARNING} - ${RESTART_LAST_WARNING}))
  393.                 sleep ${DELAY}
  394.             fi
  395.  
  396.             as_user "screen -p 0 -S $SCREEN_SESSION -X eval 'stuff \"say §dSERVER RESTARTING IN ${RESTART_LAST_WARNING} SECONDS\"\015'"
  397.             sleep ${RESTART_LAST_WARNING}
  398.  
  399.             L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  400.             L_PREFIX="${L_TIMESTAMP}"
  401.             echo "${L_PREFIX} [INFO] mc_restart_if_up(): Stopping ${SERVICE}" | tee -a ${EVENT_LOG_FILE}
  402.  
  403.             mc_stop
  404.         fi
  405.  
  406.         # The server was running and was successfully stopped, or at least is supposed to be running. Now we start it up again.
  407.         if ! pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  408.         then
  409.             L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  410.             L_PREFIX="${L_TIMESTAMP}"
  411.  
  412.             echo "${L_PREFIX} [INFO] mc_restart_if_up(): ${SERVICE} has been stopped" | tee -a ${EVENT_LOG_FILE}
  413.             echo "${L_PREFIX} [INFO] mc_restart_if_up(): Restarting ${SERVICE}..." | tee -a ${EVENT_LOG_FILE}
  414.  
  415.             mc_start
  416.  
  417.             L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  418.             L_PREFIX="${L_TIMESTAMP}"
  419.  
  420.             if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  421.             then
  422.                 echo "${L_PREFIX} [INFO] mc_restart_if_up(): ${SERVICE} is now running" | tee -a ${EVENT_LOG_FILE}
  423.             else
  424.                 echo "${L_PREFIX} [ERROR] mc_restart_if_up(): Could not start ${SERVICE}" | tee -a ${EVENT_LOG_FILE}
  425.             fi
  426.  
  427.         else
  428.             echo "${L_PREFIX} [ERROR] mc_restart_if_up(): ${SERVICE} could not be stopped" | tee -a ${EVENT_LOG_FILE}
  429.         fi
  430. #   else
  431. #       L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  432. #       L_PREFIX="${L_TIMESTAMP}"
  433. #       echo "${L_PREFIX} [WARNING] mc_restart_if_up(): ${SERVICE} was not running" | tee -a ${EVENT_LOG_FILE}
  434.     fi
  435. }
  436.  
  437.  
  438. mc_saveoff() {
  439.     if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  440.     then
  441.         if [ "${1}" = "broadcast" ];
  442.         then
  443.             as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"say §dServer going read-only...\"\015'"
  444.         fi
  445.  
  446.         as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"save-off\"\015'"
  447.     fi
  448. }
  449.  
  450.  
  451. mc_saveon() {
  452.     if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  453.     then
  454.         if [ "${1}" = "broadcast" ];
  455.         then
  456.             as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"say §dServer going read-write...\"\015'"
  457.         fi
  458.  
  459.         as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"save-on\"\015'"
  460.     fi
  461. }
  462.  
  463.  
  464. mc_saveall() {
  465.     if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  466.     then
  467.         if [ "${1}" = "broadcast" ];
  468.         then
  469.             as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"say §dSaving the map...\"\015'"
  470.         fi
  471.  
  472.         as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"save-all\"\015'"
  473.         sleep ${POST_SAVEALL_DELAY}
  474.     fi
  475. }
  476.  
  477.  
  478. mc_backup() {
  479.     TIMESTAMP_TAR=`date '+%Y-%m-%d_%H.%M.%S'`
  480.     TIMESTAMP_GIT=`date '+%Y-%m-%d %H:%M'`
  481.  
  482.     if [ "${BACKUP_USING_TAR}" = "true" ]
  483.     then
  484.         L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  485.         L_PREFIX="${L_TIMESTAMP}"
  486.  
  487.         if [ "${BACKUP_WORLD_ONLY}" = "true" ]
  488.         then
  489.             echo "${L_PREFIX} [INFO] mc_backup(): Starting a backup of the world of '${INSTANCE}' using tar" | tee -a ${EVENT_LOG_FILE} > /dev/null
  490.             echo "${L_PREFIX} [INFO] mc_backup(): Starting a backup of the world of '${INSTANCE}' using tar" | tee -a ${BACKUP_LOG_FILE} > /dev/null
  491.  
  492.             as_user "cd ${INSTANCE_PATH} && tar --exclude '.git' -czpf ${BACKUP_PATH}/${BACKUP_PREFIX}_world_${TIMESTAMP_TAR}.tar.gz ${WORLD_NAME} | tee -a ${BACKUP_LOG_FILE} > /dev/null 2>&1"
  493.         else
  494.             echo "${L_PREFIX} [INFO] mc_backup(): Starting a backup of the server '${INSTANCE}' using tar" | tee -a ${EVENT_LOG_FILE} > /dev/null
  495.             echo "${L_PREFIX} [INFO] mc_backup(): Starting a backup of the server '${INSTANCE}' using tar" | tee -a ${BACKUP_LOG_FILE} > /dev/null
  496.  
  497.             as_user "cd `dirname ${INSTANCE_PATH}` && tar --exclude '.git' -czpf ${BACKUP_PATH}/${BACKUP_PREFIX}_${TIMESTAMP_TAR}.tar.gz `basename ${INSTANCE_PATH}` | tee -a ${BACKUP_LOG_FILE} > /dev/null 2>&1"
  498.         fi
  499.     fi
  500.  
  501.     if [ "${BACKUP_USING_GIT}" = "true" ]
  502.     then
  503.         # Do we have an additional commit message?
  504.         if [ -n "${1}" ]
  505.         then
  506.             MSG=" ${1}"
  507.         else
  508.             MSG=""
  509.         fi
  510.  
  511.         L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  512.         L_PREFIX="${L_TIMESTAMP}"
  513.  
  514.         if [ "${BACKUP_WORLD_ONLY}" = "true" ]
  515.         then
  516.             echo "${L_PREFIX} [INFO] mc_backup(): Starting a backup of the world of '${INSTANCE}' using git" | tee -a ${EVENT_LOG_FILE} > /dev/null
  517.             echo "${L_PREFIX} [INFO] mc_backup(): Starting a backup of the world of '${INSTANCE}' using git" | tee -a ${BACKUP_LOG_FILE} > /dev/null
  518.  
  519.             as_user "cd ${WORLD_PATH} && git add -A . | tee -a ${BACKUP_LOG_FILE} && git commit -m \"${TIMESTAMP_GIT}${MSG}\" | tee -a ${BACKUP_LOG_FILE}"
  520.         else
  521.             echo "${L_PREFIX} [INFO] mc_backup(): Starting a backup of the server '${INSTANCE}' using git" | tee -a ${EVENT_LOG_FILE} > /dev/null
  522.             echo "${L_PREFIX} [INFO] mc_backup(): Starting a backup of the server '${INSTANCE}' using git" | tee -a ${BACKUP_LOG_FILE} > /dev/null
  523.  
  524.             as_user "cd ${INSTANCE_PATH} && git add -A . | tee -a ${BACKUP_LOG_FILE} && git commit -m \"${TIMESTAMP_GIT}${MSG}\" | tee -a ${BACKUP_LOG_FILE}"
  525.         fi
  526.     fi
  527.  
  528.     if [ "${BACKUP_SERVICE}" = "true" ]
  529.     then
  530.         L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  531.         L_PREFIX="${L_TIMESTAMP}"
  532.  
  533.         echo "${L_PREFIX} [INFO] mc_backup(): Backing up service ${SERVICE}" | tee -a ${EVENT_LOG_FILE} > /dev/null
  534.         as_user "cd ${INSTANCE_PATH} && cp -pn ${SERVICE} ${BACKUP_PATH}/${BACKUP_PREFIX}_${TIMESTAMP_TAR}.jar > /dev/null 2>&1"
  535.     fi
  536.  
  537.     L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  538.     L_PREFIX="${L_TIMESTAMP}"
  539.     echo "${L_PREFIX} [INFO] mc_backup(): Backup of server instance '${INSTANCE}' complete" | tee -a ${EVENT_LOG_FILE} > /dev/null
  540.     echo "${L_PREFIX} [INFO] mc_backup(): Backup of server instance '${INSTANCE}' complete" | tee -a ${BACKUP_LOG_FILE} > /dev/null
  541. }
  542.  
  543.  
  544. mc_backup_wrapper() {
  545.     if [ "${DISABLE_AUTOSAVE}" == "true" ]
  546.     then
  547.         mc_say "§dSERVER BACKUP STARTING"
  548.         mc_saveall
  549.         sleep ${SAVEALL_BACKUP_INTERVAL}
  550.  
  551.         mc_backup "${1}"
  552.  
  553.         mc_say "§dSERVER BACKUP FINISHED"
  554.     else
  555.         mc_say "§dSERVER BACKUP STARTING, server going read-only"
  556.         mc_saveoff
  557.         mc_saveall
  558.         sleep ${SAVEALL_BACKUP_INTERVAL}
  559.  
  560.         mc_backup "${1}"
  561.  
  562.         mc_say "§dSERVER BACKUP FINISHED, server going read-write"
  563.         mc_saveon
  564.     fi
  565. }
  566.  
  567.  
  568. mc_startifcrashed_basic() {
  569.     L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  570.     L_PREFIX="${L_TIMESTAMP}"
  571.  
  572.     # If the state file is present, then the server is supposed to be running
  573.     if [ -f "${STATE_FILE}" ]
  574.     then
  575.         # If the state file was present, but the process is not found, we assume that the server has crashed
  576.         if ! pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  577.         then
  578.             echo "${L_PREFIX} [WARNING] mc_startifcrashed_basic(): ${SERVICE} is not running (crashed?)" | tee -a ${EVENT_LOG_FILE}
  579.             echo "${L_PREFIX} [INFO] mc_startifcrashed_basic(): Attempting to start ${SERVICE}..." | tee -a ${EVENT_LOG_FILE}
  580.  
  581.             mc_start
  582.  
  583.             L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  584.             L_PREFIX="${L_TIMESTAMP}"
  585.  
  586.             if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  587.             then
  588.                 echo "${L_PREFIX} [INFO] mc_startifcrashed_basic(): ${SERVICE} is now running" | tee -a ${EVENT_LOG_FILE}
  589.             else
  590.                 echo "${L_PREFIX} [ERROR] mc_startifcrashed_basic(): Could not start ${SERVICE}" | tee -a ${EVENT_LOG_FILE}
  591.             fi
  592.         else
  593.             echo "${L_PREFIX} [INFO] mc_startifcrashed_basic(): ${SERVICE} is running" | tee -a ${EVENT_LOG_FILE}
  594.         fi
  595.     else
  596.         echo "${L_PREFIX} [INFO] mc_startifcrashed_basic(): ${SERVICE} has been stopped gracefully" | tee -a ${EVENT_LOG_FILE}
  597.     fi
  598. }
  599.  
  600.  
  601. mc_startifcrashed_ping() {
  602.     L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  603.     L_PREFIX="${L_TIMESTAMP}"
  604.  
  605.     # If the state file is present, then the server is supposed to be running
  606.     if [ -f "${STATE_FILE}" ]
  607.     then
  608.         # If the state file was present, and the process is found, we try to ping the server
  609.         if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  610.         then
  611.             echo "${L_PREFIX} [INFO] mc_startifcrashed_ping(): ${SERVICE} is running, pinging it..." | tee -a ${EVENT_LOG_FILE}
  612.  
  613.             # We try the ping a maximum of PING_RETRY_COUNT times, to try and avoid false positive failures and restarts
  614.             COUNTER=0
  615.             while [ ${COUNTER} -lt ${PING_RETRY_COUNT} ]; do
  616.  
  617.                 if ${PING_INVOCATION} | grep ': OK' > /dev/null
  618.                 then
  619.                     L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  620.                     L_PREFIX="${L_TIMESTAMP}"
  621.  
  622.                     echo "${L_PREFIX} [INFO] mc_startifcrashed_ping(): ${SERVICE} responded to ping" | tee -a ${EVENT_LOG_FILE}
  623.                     break
  624.                 fi
  625.  
  626.                 sleep ${PING_RETRY_DELAY}
  627.             done
  628.  
  629.             # If the ping failed every time, then we assume that the server has crashed and we will kill it and start it up again
  630.             if [ ${COUNTER} -ge ${PING_RETRY_COUNT} ]
  631.             then
  632.                 L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  633.                 L_PREFIX="${L_TIMESTAMP}"
  634.  
  635.                 echo "${L_PREFIX} [WARNING] mc_startifcrashed_ping(): ${SERVICE} doesn't respond to ping (crashed?)" | tee -a ${EVENT_LOG_FILE}
  636.                 echo "${L_PREFIX} [INFO] mc_startifcrashed_ping(): Killing and (re-)starting ${SERVICE}" | tee -a ${EVENT_LOG_FILE}
  637.  
  638.                 mc_kill
  639.                 sleep ${KILL_TO_START_DELAY}
  640.                 mc_start
  641.  
  642.                 L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  643.                 L_PREFIX="${L_TIMESTAMP}"
  644.  
  645.                 if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  646.                 then
  647.                     echo "${L_PREFIX} [INFO] mc_startifcrashed_ping(): ${SERVICE} is now running" | tee -a ${EVENT_LOG_FILE}
  648.                 else
  649.                     echo "${L_PREFIX} [ERROR] mc_startifcrashed_ping(): Could not start ${SERVICE}" | tee -a ${EVENT_LOG_FILE}
  650.                 fi
  651.             fi
  652.         else
  653.             # Process not found (crashed?), we try to start the server
  654.             echo "${L_PREFIX} [WARNING] mc_startifcrashed_ping(): ${SERVICE} not running (crashed?)" | tee -a ${EVENT_LOG_FILE}
  655.             echo "${L_PREFIX} [INFO] mc_startifcrashed_ping(): Attempting to start ${SERVICE}" | tee -a ${EVENT_LOG_FILE}
  656.  
  657.             mc_start
  658.  
  659.             L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  660.             L_PREFIX="${L_TIMESTAMP}"
  661.  
  662.             if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  663.             then
  664.                 echo "${L_PREFIX} [INFO] mc_startifcrashed_ping(): ${SERVICE} is now running" | tee -a ${EVENT_LOG_FILE}
  665.             else
  666.                 echo "${L_PREFIX} [ERROR] mc_startifcrashed_ping(): Could not start ${SERVICE}" | tee -a ${EVENT_LOG_FILE}
  667.             fi
  668.         fi
  669.     else
  670.         # No state file present, the server is supposed to be down
  671.         echo "${L_PREFIX} [INFO] mc_check(): ${SERVICE} has been stopped gracefully" | tee -a ${EVENT_LOG_FILE}
  672.     fi
  673. }
  674.  
  675.  
  676. mc_kill() {
  677.     L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  678.     L_PREFIX="${L_TIMESTAMP}"
  679.  
  680.     if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  681.     then
  682.         echo "${L_PREFIX} [INFO] mc_kill(): Killing minecraft server instance '${INSTANCE}'..." | tee -a ${EVENT_LOG_FILE}
  683.  
  684.         as_user "pkill -SIGKILL -u ${USERNAME} -f ${SERVICE}"
  685.         sleep ${POST_KILL_DELAY}
  686.  
  687.         COUNTER=0
  688.         while [ ${COUNTER} -lt ${KILL_GRACE_DELAY} ]; do
  689.             if ! pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  690.             then
  691.                 L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  692.                 L_PREFIX="${L_TIMESTAMP}"
  693.                 echo "${L_PREFIX} [INFO] mc_kill(): Server instance '${INSTANCE}' has been killed" | tee -a ${EVENT_LOG_FILE}
  694.  
  695.                 # FIXME: Could this be done cleaner?
  696.                 screen -wipe
  697.  
  698.                 break
  699.             fi
  700.  
  701.             sleep 1
  702.  
  703.             ((COUNTER += 1))
  704.         done
  705.  
  706.         if [ ${COUNTER} -ge ${KILL_GRACE_DELAY} ]
  707.         then
  708.             echo "${L_PREFIX} [ERROR] mc_kill(): Unable to kill minecraft server '${INSTANCE}'" | tee -a ${EVENT_LOG_FILE}
  709.         fi
  710.     else
  711.         echo "${L_PREFIX} [WARNING] mc_kill(): Minecraft server instance '${INSTANCE}' was not running" | tee -a ${EVENT_LOG_FILE}
  712.     fi
  713. }
  714.  
  715.  
  716. mc_download_server() {
  717.     # Only do something if we have a version argument
  718.     if [ -n "${1}" ]
  719.     then
  720.         VERSION="${1}"
  721.         # If the requested server version doesn't yet exist, we download it
  722.         if [ ! -f "${SERVER_FILES_PATH}/${SERVER_FILE_PREFIX}${VERSION}.jar" ]
  723.         then
  724.             MC_SERVER_URL="https://s3.amazonaws.com/Minecraft.Download/versions/${VERSION}/minecraft_server.${VERSION}.jar"
  725.             as_user "wget -q -O \"${SERVER_FILES_PATH}/${SERVER_FILE_PREFIX}${VERSION}.jar\" ${MC_SERVER_URL}"
  726.  
  727.             # If wget returns 0
  728.             if [ "$?" -eq "0" ]
  729.             then
  730.                 L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  731.                 L_PREFIX="${L_TIMESTAMP}"
  732.                 echo "${L_PREFIX} [INFO] mc_download_server(): Downloaded ${MC_SERVER_URL} to ${SERVER_FILES_PATH}/${SERVER_FILE_PREFIX}${VERSION}.jar" | tee -a ${EVENT_LOG_FILE}
  733.             else
  734.                 # Download failed
  735.                 echo "${L_PREFIX} [ERROR] mc_download_server(): Download of ${MC_SERVER_URL} failed" | tee -a ${EVENT_LOG_FILE}
  736.                 # Remove the empty file just created
  737.                 as_user "rm ${SERVER_FILES_PATH}/${SERVER_FILE_PREFIX}${VERSION}.jar"
  738.                 exit 1
  739.             fi
  740.         fi
  741.     fi
  742. }
  743.  
  744.  
  745. mc_update() {
  746.     # Any version change via this script on this server instance is forbidden
  747.     if [ "${ALLOW_UPDATES}" = 'false' ] && [ "${ALLOW_DOWNGRADES}" = 'false' ]
  748.     then
  749.         L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  750.         L_PREFIX="${L_TIMESTAMP}"
  751.         echo "${L_PREFIX} [ERROR] mc_update(): Any updates or downgrades of '${SERVICE}' are not allowed (@ ${CURRENT_VERSION})" | tee -a ${EVENT_LOG_FILE}
  752.         return
  753.     fi
  754.  
  755.     if [ -z "${1}" ]
  756.     then
  757.         # No version specified, assume we want the latest stable release
  758.         VERSIONS_URL="https://s3.amazonaws.com/Minecraft.Download/versions/versions.json"
  759.  
  760.         as_user "wget -q -O ${VERSIONS_JSON} ${VERSIONS_URL}"
  761.  
  762.         # Get the latest[release] value
  763.         VERSION=`tr '\r\n' ' ' < ${VERSIONS_JSON} | sed "s/ //g" | sed 's/.*\("latest[^}]\+}\).*/\1/' | sed 's/.*"release":"\([^"]\+\)"}/\1/'`
  764.     else    # Use the version given as an argument
  765.         VERSION="${1}"
  766.     fi
  767.  
  768.     CURRENT_VERSION=`readlink -f "${INSTANCE_PATH}/${SERVICE}" | sed "s/.*\/${SERVER_FILE_PREFIX}\(.*\)\.jar/\1/"`
  769. #   echo "VERSION:${VERSION} CURRENT_VERSION:${CURRENT_VERSION}"
  770.  
  771.     # If the requested version is different from the current version
  772.     if [ "${CURRENT_VERSION}" != "${VERSION}" ]
  773.     then
  774.         # Check that the requested version change is permitted
  775.         # FIXME This won't work correctly with alpha, beta etc. prefixed versions
  776.         if [[ "${VERSION}" < "${CURRENT_VERSION}" ]] && [ "${ALLOW_DOWNGRADES}" != 'true' ]
  777.         then
  778.             L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  779.             L_PREFIX="${L_TIMESTAMP}"
  780.             echo "${L_PREFIX} [ERROR] mc_update(): Downgrades of '${SERVICE}' are not allowed (${CURRENT_VERSION} -> ${VERSION})" | tee -a ${EVENT_LOG_FILE}
  781.             return
  782.         fi
  783.         # FIXME This won't work correctly with alpha, beta etc. prefixed versions
  784.         if [[ "${VERSION}" > "${CURRENT_VERSION}" ]] && [ "${ALLOW_UPDATES}" != 'true' ]
  785.         then
  786.             L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  787.             L_PREFIX="${L_TIMESTAMP}"
  788.             echo "${L_PREFIX} [ERROR] mc_update(): Updates of '${SERVICE}' are not allowed (${CURRENT_VERSION} -> ${VERSION})" | tee -a ${EVENT_LOG_FILE}
  789.             return
  790.         fi
  791.  
  792.         # If the server is currently running, broadcast a message before starting the update process
  793.         if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  794.         then
  795.             RUNNING="true"
  796.  
  797.             L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  798.             L_PREFIX="${L_TIMESTAMP}"
  799.             echo "${L_PREFIX} [INFO] mc_update(): ${SERVICE} is running, stopping it and starting the update" | tee -a ${EVENT_LOG_FILE}
  800.  
  801.             mc_say "§d=== SERVER UPDATE STARTING ==="
  802.             sleep 5
  803.             mc_stop "broadcast"
  804.         else
  805.             RUNNING="false"
  806.  
  807.             L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  808.             L_PREFIX="${L_TIMESTAMP}"
  809.             echo "${L_PREFIX} [INFO] mc_update(): ${SERVICE} is stopped, starting the update" | tee -a ${EVENT_LOG_FILE}
  810.         fi
  811.  
  812.         mc_backup "Backup before updating to version ${VERSION} (@ ${CURRENT_VERSION})"
  813.         mc_download_server ${VERSION}
  814.  
  815.         # If the requested server file exists, update the symlink
  816.         if [ -f "${SERVER_FILES_PATH}/${SERVER_FILE_PREFIX}${VERSION}.jar" ]
  817.         then
  818.             as_user "ln -fs \"${SERVER_FILES_PATH}/${SERVER_FILE_PREFIX}${VERSION}.jar\" \"${INSTANCE_PATH}/${SERVICE}\""
  819.  
  820.             if [ "${RUNNING}" = "true" ]
  821.             then
  822.                 L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  823.                 L_PREFIX="${L_TIMESTAMP}"
  824.                 echo "${L_PREFIX} [INFO] mc_update(): Updated '${SERVICE}' to version '${VERSION}', starting ${SERVICE}..." | tee -a ${EVENT_LOG_FILE}
  825.  
  826.                 mc_start
  827.             else
  828.                 L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  829.                 L_PREFIX="${L_TIMESTAMP}"
  830.                 echo "${L_PREFIX} [INFO] mc_update(): Updated '${SERVICE}' to version '${VERSION}'" | tee -a ${EVENT_LOG_FILE}
  831.             fi
  832.         else
  833.             # Download failed
  834.             L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  835.             L_PREFIX="${L_TIMESTAMP}"
  836.             echo "${L_PREFIX} [ERROR] mc_update(): Update of '${SERVICE}' to version '${VERSION}' failed" | tee -a ${EVENT_LOG_FILE}
  837.         fi
  838.     else
  839.         L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  840.         L_PREFIX="${L_TIMESTAMP}"
  841.         echo "${L_PREFIX} [WARNING] mc_update(): '${SERVICE}' is already at version '${VERSION}', not doing anything" | tee -a ${EVENT_LOG_FILE}
  842.     fi
  843. }
  844.  
  845.  
  846. mc_say() {
  847.     L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  848.     L_PREFIX="${L_TIMESTAMP}"
  849.  
  850.     if [ -n "${1}" ]
  851.     then
  852.         MSG="${1}"
  853.  
  854.         if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  855.         then
  856. #           echo "${L_PREFIX} [INFO] mc_say(): ${SERVICE} is running, saying '${MSG}'" | tee -a ${EVENT_LOG_FILE}
  857.             as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"say ${MSG}\"\015'"
  858. #       else
  859. #           echo "${L_PREFIX} [WARNING] mc_say(): ${SERVICE} is not running" | tee -a ${EVENT_LOG_FILE}
  860.         fi
  861.     else
  862.         echo "${L_PREFIX} [ERROR] mc_say(): You must specify a message" | tee -a ${EVENT_LOG_FILE}
  863.     fi
  864. }
  865.  
  866.  
  867. mc_command() {
  868.     L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
  869.     L_PREFIX="${L_TIMESTAMP}"
  870.  
  871.     if [ "${1}" ]
  872.     then
  873.         command="${1}"
  874.  
  875.         if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
  876.         then
  877.             echo "${L_PREFIX} [INFO] mc_command(): ${SERVICE} is running, executing command '${command}'" | tee -a ${EVENT_LOG_FILE}
  878.             as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"${command}\"\015'"
  879.         fi
  880.     else
  881.         echo "${L_PREFIX} [ERROR] mc_command(): You must specify a server command" | tee -a ${EVENT_LOG_FILE}
  882.     fi
  883. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!