Sim Start | Stop script

Code:
#!/usr/bin/env bash

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

# sim_start_stop.sh

# ----------------------------------------------------------

# OpenSimulator Start | Stop | Status Script

#

# Version:        0.5.3

# OpenSim:        0.9.3

# Getestet unter: Ubuntu / Debian (mit MySQL)

#

# Lizenz: BSD (Open Source)

# Autor:  Gau Hax

# Mail:   gauhax@vamp-berlin.de

#

# Zweck:

#  - Starten, Stoppen und Statusabfrage einzelner

#    OpenSimulator-Instanzen in einem Multi-Screen-Setup

#

# Philosophie:

#  - Klar, robust, admin-tauglich

#  - Keine Magie, keine Endlosschleifen

#  - Fehler sichtbar machen, nicht verstecken

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

# -----------------------------

# Parameter ( Start )

# -----------------------------

AKTION="$1"

INSTANZ="$2"



if [[ ! "${AKTION}" =~ ^(start|stop|status)$ ]]; then

    echo "Nutzung: $0 start|stop|status <1-20>"

    exit 1

fi



if [[ ! "${INSTANZ}" =~ ^[0-9]+$ ]] || (( INSTANZ < 1 || INSTANZ > 20 )); then

    echo "Instanz muss eine Zahl von 1 bis 20 sein"

    exit 1

fi



INSTNUM="$(printf "%02d" "${INSTANZ}")"

INSTTAG="Inst_${INSTNUM}"



STATUS_MODUS=false

[[ "${AKTION}" == "status" ]] && STATUS_MODUS=true



abbruch_oder_status() {

    [[ "${STATUS_MODUS}" == false ]] && exit 1

}



# ----------------------------------------------------------

# Statische Konfiguration ( Robust / MySql / Verzeichnisse )

# ----------------------------------------------------------



# --- Robust Grid Service ---

ROBUST_MODE="auto"        # local | remote | auto

ROBUST_HOST="127.0.0.1"   # Host oder IP

ROBUST_PORT_1="8002"

ROBUST_PORT_2="8003"

ROBUST_TAG="Robust"       # -smtag=Robust z.b.



# --- MySQL ---

MYSQL_MODE="auto"         # local | remote | auto

MYSQL_HOST="127.0.0.1"      # Host oder IP

MYSQL_PORT="3306"

MYSQL_DB="opensim-datenbank"    # Anpassen DB



# --- Basis & Pfade ---

#

# Start Verzeichniss von OpenSimulator / Anpassen !

#

BASIS_VERZEICHNIS="/opt/opensim"

ARBEITS_VERZEICHNIS="${BASIS_VERZEICHNIS}/bin_${INSTNUM}"



# PID Verzeichniss = OpenSim.ini / Anpassen !

PID_DATEI="/opt/opensim/run/pid/${INSTTAG}.pid"



# Log Datein Verzeichniss

LOG_VERZEICHNIS="/opt/opensim/log"

LOG_DATEI="${LOG_VERZEICHNIS}/sim_start_stop${INSTNUM}.log"



SCREEN_HAUPT="HAUPSCREEN-NAME"  # z.b. Simss / Simss_01 !!

ERWARTETER_USER="OPENSIMUNSER"  # euer User vom System für Opensim!



mkdir -p "${LOG_VERZEICHNIS}"



# -----------------------------

# Pflichtdateien – Definition

# -----------------------------



# Dateien direkt im Arbeitsverzeichnis (bin_XX)

PFLICHT_DATEIEN_ROOT=(

    "OpenSim.ini"

    "OpenSimDefaults.ini"

)



# Dateien unter config-include/

# Sind hier als vorlage für ... !

PFLICHT_DATEIEN_CONFIG=(

    "GridCommon.ini"

    "FlotsamCache.ini"

)



# Regions-Datei (Sonderpfad)

# Ich gehe hier davon aus, das script, es es mindestens

# eine "Regions.ini" Datei für eine Inst hat

REGION_DATEI="${ARBEITS_VERZEICHNIS}/Regions/Regions.ini"



# -----------------------------

# Pflicht Datein Prüfung (erweiterung)

# ERWEITERUNG !!! in vorbereitung !

# -----------------------------

## PFLICHT_DATEIEN_CONFIG+=( "NeueDatei.ini" )



# -----------------------------

# Farben (Konsole)

# muss ja schön aussehen

# Danke an Manfred Aabye für die Inspiration

# -----------------------------

## C_RESET="\033[0m"

## C_INFO="\033[1;34m"

## C_WARN="\033[1;33m"

## C_ERR="\033[1;31m"

## C_OK="\033[1;32m"

C_RESET="\033[0m"

C_INFO="\033[1;33m"

C_WARN="\033[33;1m"

C_ERR="\033[31m"

C_OK="\033[32m"



# -----------------------------

# Logging

# Console mit Farbe, Datei mit Datum und Uhrzeit

# -----------------------------

log_console() {

    echo -e "$2[$1]${C_RESET} $3"

}



log_file() {

    echo "[ $(date '+%Y-%m-%d %H:%M:%S') ] [$1] $2" >> "${LOG_DATEI}"

}



log_info() { log_console INFO "${C_INFO}" "$1"; log_file INFO "$1"; }

log_warn() { log_console WARN "${C_WARN}" "$1"; log_file WARN "$1"; }

log_err()  { log_console FEHLER "${C_ERR}" "$1"; log_file FEHLER "$1"; }

log_ok()   { log_console OK "${C_OK}" "$1"; log_file OK "$1"; }



# -----------------------------

# Robust Prüfung

# -----------------------------



check_robust() {



    log_info "Robust-Prüfung gestartet (Modus: ${ROBUST_MODE})"



    # -------------------------

    # Port-Check Funktion

    # -------------------------

    check_ports() {

        local ok=true



        for port in "${ROBUST_PORT_1}" "${ROBUST_PORT_2}"; do

            if timeout 2 bash -c "</dev/tcp/${ROBUST_HOST}/${port}" 2>/dev/null; then

                log_ok "Robust-Port erreichbar: ${ROBUST_HOST}:${port}"

            else

                log_err "Robust-Port NICHT erreichbar: ${ROBUST_HOST}:${port}"

                ok=false

            fi

        done



        [[ "${ok}" == true ]]

    }



    # -------------------------

    # Prozess-Check Funktion

    # -------------------------

    check_process() {

        local found=false



        while read -r pid; do

            CMD="$(tr '\0' ' ' < /proc/${pid}/cmdline 2>/dev/null)"

            if echo "${CMD}" | grep -qi "Robust" && echo "${CMD}" | grep -q -- "-smtag=${ROBUST_TAG}"; then

                log_ok "Robust-Prozess gefunden (PID=${pid})"

                found=true

                break

            fi

        done < <(pgrep -f dotnet || true)



        [[ "${found}" == true ]]

    }



    # -------------------------

    # Modus-Auswertung

    # -------------------------

    case "${ROBUST_MODE}" in



        local)

            log_info "Robust LOCAL: Prozessprüfung"

            check_process || {

                log_err "Lokaler Robust läuft nicht"

                return 1

            }

            ;;



        remote)

            log_info "Robust REMOTE: Portprüfung"

            check_ports || {

                log_err "Remote Robust nicht erreichbar"

                return 1

            }

            ;;



        auto)

            log_info "Robust AUTO: Erkennung local / remote"



            if check_process; then

                log_ok "Robust lokal erkannt"

                return 0

            fi



            log_warn "Kein lokaler Robust – prüfe Remote"

            check_ports || {

                log_err "Robust weder lokal noch remote erreichbar"

                return 1

            }

            ;;



        *)

            log_err "Unbekannter ROBUST_MODE: ${ROBUST_MODE}"

            return 1

            ;;

    esac



    log_ok "Robust-Prüfung erfolgreich"

    return 0

}



# ----------------------------------------------------------

# MySQL-Prüfung (analog Robust)

# ----------------------------------------------------------

check_mysql() {



    log_info "MySQL-Prüfung gestartet (Modus: ${MYSQL_MODE})"



    # -------------------------

    # Port-Check Funktion

    # -------------------------

    check_port() {

        if timeout 2 bash -c "</dev/tcp/${MYSQL_HOST}/${MYSQL_PORT}" 2>/dev/null; then

            log_ok "MySQL-Port erreichbar: ${MYSQL_HOST}:${MYSQL_PORT}"

            return 0

        else

            log_err "MySQL-Port NICHT erreichbar: ${MYSQL_HOST}:${MYSQL_PORT}"

            return 1

        fi

    }



    # -------------------------

    # Lokaler Dienst-Check

    # -------------------------

    check_local_service() {

        if mysqladmin ping --silent >/dev/null 2>&1; then

            log_ok "Lokaler MySQL-Dienst erreichbar"

            return 0

        else

            log_err "Lokaler MySQL-Dienst nicht erreichbar"

            return 1

        fi

    }



    # -------------------------

    # Datenbank-Check

    # -------------------------

    check_database() {

        if mysql -e "USE ${MYSQL_DB};" >/dev/null 2>&1; then

            log_ok "MySQL-Datenbank '${MYSQL_DB}' erreichbar"

            return 0

        else

            log_err "MySQL-Datenbank '${MYSQL_DB}' nicht erreichbar"

            return 1

        fi

    }



    # -------------------------

    # Modus-Auswertung

    # -------------------------

    case "${MYSQL_MODE}" in



        local)

            log_info "MySQL LOCAL: Dienstprüfung"

            check_local_service || return 1

            ;;



        remote)

            log_info "MySQL REMOTE: Portprüfung"

            check_port || return 1

            ;;



        auto)

            log_info "MySQL AUTO: Erkennung local / remote"



            if check_local_service; then

                log_ok "MySQL lokal erkannt"

            else

                log_warn "Kein lokaler MySQL – prüfe Remote"

                check_port || {

                    log_err "MySQL weder lokal noch remote erreichbar"

                    return 1

                }

            fi

            ;;



        *)

            log_err "Unbekannter MYSQL_MODE: ${MYSQL_MODE}"

            return 1

            ;;

    esac



    # -------------------------

    # Datenbank immer prüfen

    # -------------------------

    check_database || return 1



    log_ok "MySQL-Datenbank-Prüfung erfolgreich"

    return 0

}



# -----------------------------

# Benutzerprüfung

# Läuft OpenSim unter dem richtigen SystemBenutzer

# -----------------------------

AKTUELLER_USER="$(whoami)"

if [[ "${AKTUELLER_USER}" != "${ERWARTETER_USER}" ]]; then

    log_warn "Script läuft als '${AKTUELLER_USER}', erwartet '${ERWARTETER_USER}'"

else

    log_ok "Script läuft unter korrektem Benutzer '${ERWARTETER_USER}'"

fi





# -----------------------------

# Host & IP

# Hier prüfen / ermitteln IP / Host

# -----------------------------

HOST="$(hostname)"

HOSTIP="$(

    ip route get 1.1.1.1 2>/dev/null \

    | awk '{for(i=1;i<=NF;i++) if ($i=="src") {print $(i+1); exit}}'

)"



[[ -n "${HOSTIP}" ]] \

    && log_ok "System: HOST=${HOST}, IP=${HOSTIP}" \

    || log_err "System-IP konnte nicht ermittelt werden"





# -----------------------------

# Arbeitsverzeichnis

# -----------------------------

if [[ ! -d "${ARBEITS_VERZEICHNIS}" ]]; then

    log_err "Arbeitsverzeichnis fehlt: ${ARBEITS_VERZEICHNIS}"

    abbruch_oder_status

else

    log_ok "Arbeitsverzeichnis vorhanden"

fi



# -----------------------------

# Pflichtdateien prüfen

# -----------------------------



# Root-Dateien

for datei in "${PFLICHT_DATEIEN_ROOT[@]}"; do

    pfad="${ARBEITS_VERZEICHNIS}/${datei}"



    if [[ ! -f "${pfad}" ]]; then

        log_err "Pflichtdatei fehlt: ${pfad}"

        abbruch_oder_status

    elif [[ ! -s "${pfad}" ]]; then

        log_err "Pflichtdatei ist leer: ${pfad}"

        abbruch_oder_status

    else

        log_ok "Pflichtdatei geprüft: ${datei}"

    fi

done



# config-include-Dateien

for datei in "${PFLICHT_DATEIEN_CONFIG[@]}"; do

    pfad="${ARBEITS_VERZEICHNIS}/config-include/${datei}"



    if [[ ! -f "${pfad}" ]]; then

        log_err "Pflichtdatei fehlt: ${pfad}"

        abbruch_oder_status

    elif [[ ! -s "${pfad}" ]]; then

        log_err "Pflichtdatei ist leer: ${pfad}"

        abbruch_oder_status

    else

        log_ok "Pflichtdatei geprüft: config-include/${datei}"

    fi

done



# Regions.ini

if [[ ! -f "${REGION_DATEI}" ]]; then

    log_err "Regions-Datei fehlt: ${REGION_DATEI}"

    abbruch_oder_status

elif [[ ! -s "${REGION_DATEI}" ]]; then

    log_err "Regions-Datei ist leer: ${REGION_DATEI}"

    abbruch_oder_status

else

    log_ok "Regions-Datei geprüft: Regions.ini"

fi



# -----------------------------

# Regions.ini auswerten

# -----------------------------

REGIONS_NAME="$(

    awk -F'[][]' '/^\[/{print $2; exit}' "${REGION_DATEI}" \

    | sed 's/^[[:space:]]*//; s/[[:space:]]*$//'

)"



REGIONS_UUID="$(

    grep -E '^RegionUUID[[:space:]]*=' "${REGION_DATEI}" \

    | awk -F '=' '{gsub(/[[:space:]]/, "", $2); print $2}' \

    | head -n1

)"



[[ -n "${REGIONS_NAME}" ]] \

    && log_ok "Regionsname: ${REGIONS_NAME}" \

    || log_warn "Kein Regionsname gefunden"



[[ -n "${REGIONS_UUID}" ]] \

    && log_ok "RegionUUID: ${REGIONS_UUID}" \

    || log_warn "Keine RegionUUID gefunden"





# -----------------------------

# Port-Prüfung

# -----------------------------

OS_PORT="$(

    grep -E '^[[:space:]]*http_listener_port[[:space:]]*=' \

    "${ARBEITS_VERZEICHNIS}/OpenSim.ini" \

    | awk -F '=' '{gsub(/[[:space:]]/, "", $2); print $2}' \

    | head -n1

)"



REGION_PORTS="$(

    grep -E '^[[:space:]]*InternalPort[[:space:]]*=' "${REGION_DATEI}" \

    | awk -F '=' '{gsub(/[[:space:]]/, "", $2); print $2}'

)"



[[ -n "${OS_PORT}" ]] \

    && log_ok "OpenSim Listener-Port: ${OS_PORT}" \

    || { log_err "Kein http_listener_port gefunden"; abbruch_oder_status; }



for rport in ${REGION_PORTS}; do

    [[ "${rport}" == "${OS_PORT}" ]] \

        && log_ok "Region-Port ${rport} passt" \

        || log_warn "Region-Port ${rport} weicht ab"

done





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

# PIDFile Prüfung (OpenSim.ini) – robust (mit/ohne Anführungszeichen)

#

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

PIDFILE_INI_RAW="$(

    grep -E '^[[:space:]]*PIDFile[[:space:]]*=' \

    "${ARBEITS_VERZEICHNIS}/OpenSim.ini" \

    | head -n1 \

    | awk -F '=' '{print $2}'

)"



PIDFILE_INI="$(

    echo "${PIDFILE_INI_RAW}" \

    | sed 's/^[[:space:]]*//; s/[[:space:]]*$//' \

    | sed 's/^"//; s/"$//'

)"



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

    log_err "PIDFile ist nicht in OpenSim.ini gesetzt"

    abbruch_oder_status

elif [[ "${PIDFILE_INI}" != "${PID_DATEI}" ]]; then

    log_err "PIDFile stimmt nicht"

    log_err "Gefunden : ${PIDFILE_INI}"

    log_err "Erwartet: ${PID_DATEI}"

    abbruch_oder_status

else

    log_ok "PIDFile korrekt gesetzt (${PIDFILE_INI})"

fi





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

# AKTIONEN ( start | stop | status )

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

case "${AKTION}" in



# -----------------------------

# STATUS

# Läuft komplett durch, auch bei Fehlern !

# -----------------------------

status)

    if [[ -f "${PID_DATEI}" ]]; then

        PID="$(cat "${PID_DATEI}")"

        if [[ -n "${PID}" && -d "/proc/${PID}" ]]; then

            CMD="$(tr '\0' ' ' < /proc/${PID}/cmdline)"

            if echo "${CMD}" | grep -q -- "-smtag=${INSTTAG}"; then

                log_ok "Instanz läuft (PID=${PID})"

            else

                log_warn "PID aktiv, aber falscher Prozess"

            fi

        else

            log_warn "Verwaiste PID-Datei gefunden"

        fi

    else

        log_info "Instanz läuft nicht"

    fi

    if [[ "${AKTION}" == "status" ]]; then

        check_robust \

            && log_ok "Robust-Status: OK" \

            || log_warn "Robust-Status: NICHT erreichbar"

        check_mysql \

        && log_ok "MySQL-Status: OK" \

        || log_warn "MySQL-Status: FEHLER"

    fi

    ;;



# -----------------------------

# START

# Hier muss alles passen

# ansonsten abbruch

# -----------------------------

start)

    log_ok "Startbefehl gesendet - Anfang"

#    check_robust || { log_err "Start abgebrochen: Robust nicht verfügbar"; exit 1; }

    check_mysql  || { log_err "Start abgebrochen: MySQL nicht verfügbar"; exit 1; }

        if [[ "${AKTION}" == "start" ]]; then

            check_robust || {

                log_err "Start abgebrochen: Robust nicht verfügbar"

                exit 1

            }

        fi

    if [[ -f "${PID_DATEI}" ]]; then

        PID="$(cat "${PID_DATEI}")"

        if [[ -n "${PID}" && -d "/proc/${PID}" ]]; then

            log_warn "Instanz läuft bereits (PID=${PID})"

            exit 0

        else

            log_warn "Verwaiste PID-Datei entfernt"

            rm -f "${PID_DATEI}"

        fi

    fi



    if ! screen -list | grep -q "\.${SCREEN_HAUPT}"; then

        log_err "Hauptscreen '${SCREEN_HAUPT}' existiert nicht"

        exit 1

    fi



    log_info "Starte Instanz ${INSTTAG} (${REGIONS_NAME})"



    screen -S "${SCREEN_HAUPT}" -p 0 -X screen -t "${REGIONS_NAME}" "${INSTNUM}"

    sleep 0.5



    screen -S "${SCREEN_HAUPT}" -p "${INSTNUM}" -X stuff \

        "cd ${ARBEITS_VERZEICHNIS} && dotnet OpenSim.dll -smtag=${INSTTAG}^M"



    log_ok "Startbefehl gesendet - Ende"

    ;;



# -----------------------------

# STOP

# mit kontrolle auf sauberes ENDE

# -----------------------------

stop)

    if [[ ! -f "${PID_DATEI}" ]]; then

        log_warn "Keine PID-Datei – Instanz läuft nicht"

        exit 0

    fi



    PID="$(cat "${PID_DATEI}")"



    log_info "Stoppe Instanz ${INSTTAG} (${REGIONS_NAME})"



    screen -S "${SCREEN_HAUPT}" -p "${INSTNUM}" -X stuff \

        "alert Die Region ${REGIONS_NAME} wird in 2 Minuten gestoppt.^M"

    sleep 0.3

    screen -S "${SCREEN_HAUPT}" -p "${INSTNUM}" -X stuff "login disable^M"

    sleep 120



    screen -S "${SCREEN_HAUPT}" -p "${INSTNUM}" -X stuff \

        "alert Die Region ${REGIONS_NAME} wird in 1 Minute gestoppt.^M"

    sleep 45



    screen -S "${SCREEN_HAUPT}" -p "${INSTNUM}" -X stuff \

        "alert Die Region ${REGIONS_NAME} wird in 15 Sekunden gestoppt.^M"

    sleep 15



    screen -S "${SCREEN_HAUPT}" -p "${INSTNUM}" -X stuff "quit^M"

    sleep 5



    screen -S "${SCREEN_HAUPT}" -p "${INSTNUM}" -X stuff "exit^M"



    # -------------------------

    # Warte Zyklus auf sauber Stop

    # -------------------------

    for ((i=0;i<20;i++)); do

        sleep 15

        [[ ! -d "/proc/${PID}" ]] && break

    done



    if [[ -d "/proc/${PID}" ]]; then

        log_warn "Prozess hängt – hartes KILL"

        kill -9 "${PID}"

    fi



    rm -f "${PID_DATEI}"

    log_ok "Instanz sauber gestoppt"

    ;;

esac



exit 0