Serverul Tomcat care rulează aplicația Springboot închide brusc conexiunea la serverul smtp

Am un server Tomcat care rulează o aplicație Spring Boot pe o gazdă care utilizează CentOS 8 care se conectează la un client de e-mail folosind SMTP. Problema este că se închide brusc conexiunea înainte ca strângerea de mână TLS să aibă loc cu o opțiune STARTTLS. Funcționează OK cu alte noduri care rulează CentOS 7 și serverul Oracle Linux. Problema nu poate fi cu aplicația, altfel nu ar funcționa pe niciun nod. Am verificat folosind Wireshark pentru a vedea că nodul nostru aplicație a terminat conexiunea. Iată transcrierea comunicării TCP pe care am înregistrat-o folosind tcpdump.

220 mta1.***.local ESMTP Postfix
EHLO ****
250-mta1.***.local
250-CONDUCERE
250 - DIMENSIUNEA 69730304
250-VRFY
250-ETRN
250-STARTTLS
250-CODURI DE STARE ÎMBUNĂTĂTATE
250-8BITMIME
250 DSN
STARTTLS
220 2.0.0 Gata pentru pornirea TLS

Și nimic după aceea. Încetarea conexiunii a fost bruscă, fără timeout sau ceva de genul acesta. De asemenea, am verificat pentru fișierul server.xml pentru orice setări, nu a fost menționat nicio mențiune de e-mail sau smtp în niciun fel.

Am încercat același lucru folosind openssl și funcționează, pornind cu succes TLS prin conexiune smtp, deci nu este problema cu serverul care nu acceptă opțiunea. Are cineva idee de ce s-ar fi putut întâmpla asta?

openssl s_client -connect smtp.****.gov.**:587 -starttls smtp

Fișierul meu catalina.sh

#!/bin/sh
cygwin=fals
darwin=fals
os400=fals
hpux=fals
cazul „`uname`” în
CYGWIN*) cygwin=adevărat;;
Darwin*) darwin=adevarat;;
OS400*) os400=adevărat;;
HP-UX*) hpux=true;;
esac

# rezolva link-uri - $0 poate fi un softlink
PRG="$0"

în timp ce [ -h „$PRG” ]; do
  ls=`ls -ld "$PRG"`
  link=`expr "$ls": '.*-> \(.*\)$'`
  if expr "$link": '/.*' > /dev/null; atunci
    PRG="$link"
  altfel
    PRG=`dirname "$PRG"`/"$link"
  fi
Terminat

# Obțineți variabile de mediu standard
PRGDIR=`dirname "$PRG"`

# Setați CATALINA_HOME numai dacă nu este deja setat
[ -z "$CATALINA_HOME" ] && CATALINA_HOME=`cd "$PRGDIR/.." >/dev/null; pwd`

# Copiați CATALINA_BASE din CATALINA_HOME dacă nu este deja setat
[ -z "$CATALINA_BASE" ] && CATALINA_BASE="$CATALINA_HOME"

# Asigurați-vă că nicio variabilă CLASSPATH definită de utilizator nu este utilizată la pornire,
# dar permiteți-le să fie specificate în setenv.sh, în cazuri rare când este necesar.
CLASSPATH=

if [ -r "$CATALINA_BASE/bin/setenv.sh" ]; atunci
  . „$CATALINA_BASE/bin/setenv.sh”
elif [ -r "$CATALINA_HOME/bin/setenv.sh" ]; atunci
  . „$CATALINA_HOME/bin/setenv.sh”
fi

# Pentru Cygwin, asigurați-vă că căile sunt în format UNIX înainte de a atinge orice
if $cygwin; atunci
  [ -n „$JAVA_HOME” ] && JAVA_HOME=`cygpath --unix „$JAVA_HOME”`
  [ -n „$JRE_HOME” ] && JRE_HOME=`cygpath --unix „$JRE_HOME”`
  [ -n "$CATALINA_HOME" ] && CATALINA_HOME=`cygpath --unix "$CATALINA_HOME"`
  [ -n "$CATALINA_BASE" ] && CATALINA_BASE=`cygpath --unix "$CATALINA_BASE"`
  [ -n "$CLASSPATH" ] && CLASSPATH=`cygpath --path --unix "$CLASSPATH"`
fi

# Asigurați-vă că nici CATALINA_HOME, nici CATALINA_BASE nu conține două puncte
# deoarece acesta este folosit ca separator în classpath și Java oferă nr
# mecanism de scăpare dacă în cale apare același caracter.
cazul $CATALINA_HOME în
  **:*) echo „Utilizarea CATALINA_HOME: $CATALINA_HOME”;
       echo „Nu se poate porni deoarece CATALINA_HOME conține un caracter două puncte (:)”;
       ieșirea 1;
esac
caz $CATALINA_BASE în
  **:*) echo "Utilizarea CATALINA_BASE: $CATALINA_BASE";
       echo „Nu se poate porni deoarece CATALINA_BASE conține un caracter două puncte (:)”;
       ieșirea 1;
esac

# Pentru OS400
dacă $os400; atunci
  # Setați prioritatea jobului la standard pentru interactiv (interactiv - 6) prin utilizarea
  # prioritatea interactivă - 6, firele helper care răspund la solicitări
  # va rula cu aceeași prioritate ca și joburile interactive.
  COMMAND='chgjob job('$JOBNAME') runpty(6)'
  sistem $COMMAND

  # Activați mai multe fire
  exportați QIBM_MULTI_THREADED=Y
fi

# Obțineți variabile de mediu Java standard
dacă $os400; atunci
  # -r va funcționa numai pe os400 dacă fișierele sunt:
  # 1. deținut de utilizator
  # 2. deținut de grupul PRIMAR al utilizatorului
  # acest lucru nu va funcționa dacă utilizatorul aparține unor grupuri secundare
  . „$CATALINA_HOME”/bin/setclasspath.sh
altfel
  if [ -r "$CATALINA_HOME"/bin/setclasspath.sh ]; atunci
    . „$CATALINA_HOME”/bin/setclasspath.sh
  altfel
    echo „Nu se poate găsi $CATALINA_HOME/bin/setclasspath.sh”
    echo „Acest fișier este necesar pentru a rula acest program”
    iesirea 1
  fi
fi

# Adăugați fișiere jar suplimentare în CLASSPATH
dacă [ ! -z „$CLASSPATH” ] ; atunci
  CLASSPATH="$CLASSPATH":
fi
CLASSPATH="$CLASSPATH""$CATALINA_HOME"/bin/bootstrap.jar

if [ -z "$CATALINA_OUT" ] ; atunci
  CATALINA_OUT=/home/*****/logs/catalinalogs/catalina.out
fi

if [ -z "$CATALINA_TMPDIR" ] ; atunci
  # Definiți java.io.tmpdir de utilizat pentru Catalina
  CATALINA_TMPDIR="$CATALINA_BASE"/temp
fi

# Adăugați tomcat-juli.jar la classpath
# tomcat-juli.jar poate fi supraîncărcat în fiecare caz
if [ -r "$CATALINA_BASE/bin/tomcat-juli.jar" ] ; atunci
  CLASSPATH=$CLASSPATH:$CATALINA_BASE/bin/tomcat-juli.jar
altfel
  CLASSPATH=$CLASSPATH:$CATALINA_HOME/bin/tomcat-juli.jar
fi

# Bugzilla 37848: Când nu este disponibil niciun TTY, nu trimiteți la consolă
have_tty=0
dacă [-t 0 ]; atunci
    have_tty=1
fi

# Pentru Cygwin, comutați căile la formatul Windows înainte de a rula java
if $cygwin; atunci
  JAVA_HOME=`cygpath --absolute --windows „$JAVA_HOME”`
  JRE_HOME=`cygpath --absolute --windows „$JRE_HOME”`
  CATALINA_HOME=`cygpath --absolute --windows „$CATALINA_HOME”`
  CATALINA_BASE=`cygpath --absolute --windows „$CATALINA_BASE”`
  CATALINA_TMPDIR=`cygpath --absolute --windows „$CATALINA_TMPDIR”`
  CLASSPATH=`cygpath --path --windows „$CLASSPATH”`
  [ -n „$JAVA_ENDORSED_DIRS” ] && JAVA_ENDORSED_DIRS=`cygpath --path --windows „$JAVA_ENDORSED_DIRS”`
fi

if [ -z "$JSSE_OPTS" ] ; atunci
  JSSE_OPTS="-Djdk.tls.ephemeralDHKeySize=2048"
fi
JAVA_OPTS="$JAVA_OPTS $JSSE_OPTS"

# Înregistrați handlere de adrese URL personalizate
# Faceți acest lucru aici, astfel încât mânerele URL personalizate (în special „război:...”) să poată fi folosite în politica de securitate
JAVA_OPTS="$JAVA_OPTS -Djava.protocol.handler.pkgs=org.apache.catalina.webresources"

# Setați fișierul de configurare juli LogManager dacă este prezent și nu a fost emisă o modificare
dacă [ -z „$LOGGING_CONFIG” ]; atunci
  if [ -r "$CATALINA_BASE"/conf/logging.properties ]; atunci
    LOGGING_CONFIG="-Djava.util.logging.config.file=$CATALINA_BASE/conf/logging.properties"
  altfel
    # Bugzilla 45585
    LOGGING_CONFIG="-Dnop"
  fi
fi

dacă [ -z „$LOGGING_MANAGER” ]; atunci
  LOGGING_MANAGER="-Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager"
fi

# Setați UMASK dacă nu a fost suprascris
dacă [ -z "$UMASK" ]; atunci
    UMASK="0027"
fi
umask $UMASK

# Java 9 nu mai acceptă java.endorsed.dirs
# proprietatea sistemului. Încearcă să-l folosești doar dacă
# JAVA_ENDORSED_DIRS a fost setat în mod explicit
# sau CATALINA_HOME/aprobat există.
ENDORSED_PROP=ignore.endorsed.dirs
dacă [ -n „$JAVA_ENDORSED_DIRS” ]; atunci
    ENDORSED_PROP=java.endorsed.dirs
fi
if [ -d "$CATALINA_HOME/aprobat" ]; atunci
    ENDORSED_PROP=java.endorsed.dirs
fi

# Faceți umask disponibil când utilizați org.apache.catalina.security.SecurityListener
JAVA_OPTS="$JAVA_OPTS -Dorg.apache.catalina.security.SecurityListener.UMASK=`umask`"

dacă [ -z "$USE_NOHUP" ]; atunci
    dacă $hpux; atunci
        USE_NOHUP="true"
    altfel
        USE_NOHUP="fals"
    fi
fi
dezactivați _NOHUP
if [ "$USE_NOHUP" = "adevărat" ]; atunci
    _NOHUP="nohup"
fi

# Adăugați parametrii specifici de pornire JAVA 9 solicitați de Tomcat
JDK_JAVA_OPTIONS="$JDK_JAVA_OPTIONS --add-opens=java.base/java.lang=ALL-UNNAMED"
JDK_JAVA_OPTIONS="$JDK_JAVA_OPTIONS --add-opens=java.base/java.io=ALL-UNNAMED"
JDK_JAVA_OPTIONS="$JDK_JAVA_OPTIONS --add-opens=java.rmi/sun.rmi.transport=ALL-UNNAMED"
exportați JDK_JAVA_OPTIONS

# ----- Executați comanda solicitată ---------------------------------------- -

# Bugzilla 37848: scoateți acest lucru numai dacă avem un TTY
if [ $have_tty -eq 1 ]; atunci
  echo „Utilizarea CATALINA_BASE: $CATALINA_BASE”
  echo „Utilizarea CATALINA_HOME: $CATALINA_HOME”
  echo „Utilizarea CATALINA_TMPDIR: $CATALINA_TMPDIR”
  if [ "$1" = "depanare" ] ; atunci
    echo „Utilizarea JAVA_HOME: $JAVA_HOME”
  altfel
    echo „Utilizarea JRE_HOME: $JRE_HOME”
  fi
  echo „Utilizarea CLASSPATH: $CLASSPATH”
  dacă [ ! -z "$CATALINA_PID" ]; atunci
    echo „Utilizarea CATALINA_PID: $CATALINA_PID”
  fi
fi

if [ "$1" = "jpda" ] ; atunci
  dacă [ -z "$JPDA_TRANSPORT" ]; atunci
    JPDA_TRANSPORT="dt_socket"
  fi
  dacă [ -z „$JPDA_ADDRESS” ]; atunci
    JPDA_ADDRESS="localhost:8000"
  fi
  dacă [ -z „$JPDA_SUSPEND” ]; atunci
    JPDA_SUSPEND="n"
  fi
  dacă [ -z "$JPDA_OPTS" ]; atunci
    JPDA_OPTS="-agentlib:jdwp=transport=$JPDA_TRANSPORT,address=$JPDA_ADDRESS,server=y,suspend=$JPDA_SUSPEND"
  fi
  CATALINA_OPTS="$JPDA_OPTS $CATALINA_OPTS"
  schimb
fi

# TODO: Bugzilla 63815
# Acest lucru nu funcționează în prezent (și nu poate fi făcut să funcționeze) dacă valorile sunt utilizate în
# CATALINA_OPTS și/sau JAVA_OPTS necesită ghilimele. Vedea:
# https://bugs.openjdk.java.net/browse/JDK-8234808
if [ "$1" = "depanare" ] ; atunci
  dacă $os400; atunci
    echo „Comanda de depanare nu este disponibilă pe OS400”
    iesirea 1
  altfel
    schimb
    if [ "$1" = "-securitate" ] ; atunci
      if [ $have_tty -eq 1 ]; atunci
        echo „Utilizarea Managerului de securitate”
      fi
      schimb
      exec "$_RUNJDB" "$LOGGING_CONFIG" $LOGGING_MANAGER $JAVA_OPTS $CATALINA_OPTS \
        -D$ENDORSED_PROP="$JAVA_ENDORSED_DIRS" \
        -claspath „$CLASSPATH” \
        -sourcepath „$CATALINA_HOME”/../../java \
        -Djava.security.manager \
        -Djava.security.policy=="$CATALINA_BASE"/conf/catalina.policy \
        -Dcatalina.base="$CATALINA_BASE" \
        -Dcatalina.home="$CATALINA_HOME" \
        -Djava.io.tmpdir="$CATALINA_TMPDIR" \
        org.apache.catalina.startup.Bootstrap „$@” începe
    altfel
      exec "$_RUNJDB" "$LOGGING_CONFIG" $LOGGING_MANAGER $JAVA_OPTS $CATALINA_OPTS \
        -D$ENDORSED_PROP="$JAVA_ENDORSED_DIRS" \
        -claspath „$CLASSPATH” \
        -sourcepath „$CATALINA_HOME”/../../java \
        -Dcatalina.base="$CATALINA_BASE" \
        -Dcatalina.home="$CATALINA_HOME" \
        -Djava.io.tmpdir="$CATALINA_TMPDIR" \
        org.apache.catalina.startup.Bootstrap „$@” începe
    fi
  fi

elif [ "$1" = "rulați" ]; atunci

  schimb
  if [ "$1" = "-securitate" ] ; atunci
    if [ $have_tty -eq 1 ]; atunci
      echo „Utilizarea Managerului de securitate”
    fi
    schimb
    eval exec "\"$_RUNJAVA\"" "\"$LOGGING_CONFIG\"" $LOGGING_MANAGER "$JAVA_OPTS" "$CATALINA_OPTS" \
      -D$ENDORSED_PROP="\"$JAVA_ENDORSED_DIRS\"" \
      -claspath "\"$CLASSPATH\"" \
      -Djava.security.manager \
      -Djava.security.policy=="\"$CATALINA_BASE/conf/catalina.policy\"" \
      -Dcatalina.base="\"$CATALINA_BASE\"" \
      -Dcatalina.home="\"$CATALINA_HOME\"" \
      -Djava.io.tmpdir="\"$CATALINA_TMPDIR\"" \
      org.apache.catalina.startup.Bootstrap „$@” începe
  altfel
    eval exec "\"$_RUNJAVA\"" "\"$LOGGING_CONFIG\"" $LOGGING_MANAGER "$JAVA_OPTS" "$CATALINA_OPTS" \
      -D$ENDORSED_PROP="\"$JAVA_ENDORSED_DIRS\"" \
      -claspath "\"$CLASSPATH\"" \
      -Dcatalina.base="\"$CATALINA_BASE\"" \
      -Dcatalina.home="\"$CATALINA_HOME\"" \
      -Djava.io.tmpdir="\"$CATALINA_TMPDIR\"" \
      org.apache.catalina.startup.Bootstrap „$@” începe
  fi

elif [ "$1" = "începe" ] ; atunci

  dacă [ ! -z "$CATALINA_PID" ]; atunci
    if [ -f "$CATALINA_PID" ]; atunci
      if [ -s "$CATALINA_PID" ]; atunci
        echo „Fișier PID existent găsit în timpul pornirii”.
        if [ -r "$CATALINA_PID" ]; atunci
          PID=`cat "$CATALINA_PID"`
          ps -p $PID >/dev/null 2>&1
          dacă [ $? -eq 0]; atunci
            echo „Tomcat pare să ruleze în continuare cu PID $PID.Începe avortat."
            echo „Dacă următorul proces nu este un proces Tomcat, eliminați fișierul PID și încercați din nou:”
            ps -f -p $PID
            iesirea 1
          altfel
            echo „Eliminarea/ștergerea fișierului PID învechit”.
            rm -f "$CATALINA_PID" >/dev/null 2>&1
            dacă [ $? != 0 ]; atunci
              if [ -w "$CATALINA_PID" ]; atunci
                cat /dev/null > „$CATALINA_PID”
              altfel
                echo „Nu se poate șterge sau șterge fișierul PID învechit. Începe avortat.”
                iesirea 1
              fi
            fi
          fi
        altfel
          echo „Nu se poate citi fișierul PID. Începe avortat.”
          iesirea 1
        fi
      altfel
        rm -f "$CATALINA_PID" >/dev/null 2>&1
        dacă [ $? != 0 ]; atunci
          dacă [ ! -w "$CATALINA_PID" ]; atunci
            echo „Nu se poate elimina sau scrie în fișierul PID gol. Începe avortat.”
            iesirea 1
          fi
        fi
      fi
    fi
  fi

  schimb
  atingeți „$CATALINA_OUT”
  if [ "$1" = "-securitate" ] ; atunci
    if [ $have_tty -eq 1 ]; atunci
      echo „Utilizarea Managerului de securitate”
    fi
    schimb
    eval $_NOHUP "\"$_RUNJAVA\"" "\"$LOGGING_CONFIG\"" $LOGGING_MANAGER "$JAVA_OPTS" "$CATALINA_OPTS" \
      -D$ENDORSED_PROP="\"$JAVA_ENDORSED_DIRS\"" \
      -claspath "\"$CLASSPATH\"" \
      -Djava.security.manager \
      -Djava.security.policy=="\"$CATALINA_BASE/conf/catalina.policy\"" \
      -Dcatalina.base="\"$CATALINA_BASE\"" \
      -Dcatalina.home="\"$CATALINA_HOME\"" \
      -Djava.io.tmpdir="\"$CATALINA_TMPDIR\"" \
      org.apache.catalina.startup.Bootstrap „$@” start \
      >> „$CATALINA_OUT” 2>&1 „&”

  altfel
    eval $_NOHUP "\"$_RUNJAVA\"" "\"$LOGGING_CONFIG\"" $LOGGING_MANAGER "$JAVA_OPTS" "$CATALINA_OPTS" \
      -D$ENDORSED_PROP="\"$JAVA_ENDORSED_DIRS\"" \
      -claspath "\"$CLASSPATH\"" \
      -Dcatalina.base="\"$CATALINA_BASE\"" \
      -Dcatalina.home="\"$CATALINA_HOME\"" \
      -Djava.io.tmpdir="\"$CATALINA_TMPDIR\"" \
      org.apache.catalina.startup.Bootstrap „$@” start \
      >> „$CATALINA_OUT” 2>&1 „&”

  fi

  dacă [ ! -z "$CATALINA_PID" ]; atunci
    eco $! > „$CATALINA_PID”
  fi

  echo „Tomcat a început”.

elif [ "$1" = "oprire" ] ; atunci

  schimb

  SOMMN=5
  dacă [ ! -z „$1” ]; atunci
    ecou $1 | grep „[^0-9]” >/dev/null 2>&1
    dacă [ $? -gt 0 ]; atunci
      SOMMN=1 USD
      schimb
    fi
  fi

  FORTA=0
  if [ "$1" = "-force" ]; atunci
    schimb
    FORTA=1
  fi

  dacă [ ! -z "$CATALINA_PID" ]; atunci
    if [ -f "$CATALINA_PID" ]; atunci
      if [ -s "$CATALINA_PID" ]; atunci
        kill -0 `cat "$CATALINA_PID"` >/dev/null 2>&1
        dacă [ $? -gt 0 ]; atunci
          echo "Fișierul PID a fost găsit, dar fie nu a fost găsit niciun proces care se potrivește, fie utilizatorul actual nu are permisiunea de a opri procesul. Stop avortat."
          iesirea 1
        fi
      altfel
        echo "Fișierul PID este gol și a fost ignorat."
      fi
    altfel
      echo "\$CATALINA_PID a fost setat, dar fișierul specificat nu există. Tomcat rulează? Stop avortat."
      iesirea 1
    fi
  fi

  eval "\"$_RUNJAVA\"" $LOGGING_MANAGER "$JAVA_OPTS" \
    -D$ENDORSED_PROP="\"$JAVA_ENDORSED_DIRS\"" \
    -claspath "\"$CLASSPATH\"" \
    -Dcatalina.base="\"$CATALINA_BASE\"" \
    -Dcatalina.home="\"$CATALINA_HOME\"" \
    -Djava.io.tmpdir="\"$CATALINA_TMPDIR\"" \
    org.apache.catalina.startup.Bootstrap „$@” oprire

  # oprire a eșuat. Portul de închidere este dezactivat? Încercați o ucidere normală.
  dacă [ $? != 0 ]; atunci
    dacă [ ! -z "$CATALINA_PID" ]; atunci
      echo "Comanda de oprire a eșuat. Încercarea de a semnala procesului de oprire prin semnalul sistemului de operare."
      kill -15 `cat "$CATALINA_PID"` >/dev/null 2>&1
    fi
  fi

  dacă [ ! -z "$CATALINA_PID" ]; atunci
    if [ -f "$CATALINA_PID" ]; atunci
      în timp ce [ $SLEEP -ge 0 ]; do
        kill -0 `cat "$CATALINA_PID"` >/dev/null 2>&1
        dacă [ $? -gt 0 ]; atunci
          rm -f "$CATALINA_PID" >/dev/null 2>&1
          dacă [ $? != 0 ]; atunci
            if [ -w "$CATALINA_PID" ]; atunci
              cat /dev/null > „$CATALINA_PID”
              # Dacă Tomcat s-a oprit, nu încercați să forțați o oprire cu un fișier PID gol
              FORTA=0
            altfel
              echo „Fișierul PID nu a putut fi șters sau șters.”
            fi
          fi
          ecou „Tomcat sa oprit”.
          pauză
        fi
        if [ $SLEEP -gt 0 ]; atunci
          somn 1
        fi
        if [ $SLEEP -eq 0 ]; atunci
          ecou „Tomcat nu s-a oprit la timp”.
          dacă [ $FORȚĂ -eq 0 ]; atunci
            echo "Fișierul PID nu a fost eliminat."
          fi
          echo „Pentru a ajuta la diagnosticare, a fost scrisă o descărcare a firului în ieșirea standard.”
          kill -3 `cat "$CATALINA_PID"`
        fi
        SLEEP=`expr $SLEEP - 1`
      Terminat
    fi
  fi

  KILL_SLEEP_INTERVAL=5
  dacă [ $FORȚĂ -eq 1 ]; atunci
    if [ -z "$CATALINA_PID" ]; atunci
      echo „Uciderea a eșuat: \$CATALINA_PID nu a fost setat”
    altfel
      if [ -f "$CATALINA_PID" ]; atunci
        PID=`cat "$CATALINA_PID"`
        echo „Uciderea lui Tomcat cu PID: $PID”
        ucide -9 $PID
        în timp ce [ $KILL_SLEEP_INTERVAL -ge 0 ]; do
            kill -0 `cat "$CATALINA_PID"` >/dev/null 2>&1
            dacă [ $? -gt 0 ]; atunci
                rm -f "$CATALINA_PID" >/dev/null 2>&1
                dacă [ $? != 0 ]; atunci
                    if [ -w "$CATALINA_PID" ]; atunci
                        cat /dev/null > „$CATALINA_PID”
                    altfel
                        echo „Fișierul PID nu a putut fi șters.”
                    fi
                fi
                echo "Procesul Tomcat a fost ucis."
                pauză
            fi
            dacă [ $KILL_SLEEP_INTERVAL -gt 0 ]; atunci
                somn 1
            fi
            KILL_SLEEP_INTERVAL=`expr $KILL_SLEEP_INTERVAL - 1 `
        Terminat
        dacă [ $KILL_SLEEP_INTERVAL -lt 0 ]; atunci
            echo "Tomcat nu a fost ucis complet încă. Procesul ar putea fi în așteptare la un apel de sistem sau ar putea fi NEÎNTRERUPTĂ."
        fi
      fi
    fi
  fi

elif [ "$1" = "configtest" ] ; atunci

    eval "\"$_RUNJAVA\"" $LOGGING_MANAGER "$JAVA_OPTS" \
      -D$ENDORSED_PROP="\"$JAVA_ENDORSED_DIRS\"" \
      -claspath "\"$CLASSPATH\"" \
      -Dcatalina.base="\"$CATALINA_BASE\"" \
      -Dcatalina.home="\"$CATALINA_HOME\"" \
      -Djava.io.tmpdir="\"$CATALINA_TMPDIR\"" \
      org.apache.catalina.startup.Bootstrap configtest
    rezultat=$?
    if [ $rezultat -ne 0 ]; atunci
        echo "Eroare de configurare detectată!"
    fi
    exit $result

elif [ "$1" = "versiune" ] ; atunci

    „$_RUNJAVA” \
      -claspath „$CATALINA_HOME/lib/catalina.jar” \
      org.apache.catalina.util.ServerInfo

altfel

  echo „Utilizare: catalina.sh (comenzi...)”
  echo "comenzi:"
  dacă $os400; atunci
    echo " debug Porniți Catalina într-un depanator (nu este disponibil pe OS400)"
    echo " debug -security Debug Catalina cu un manager de securitate (nu este disponibil pe OS400)"
  altfel
    echo " debug Porniți Catalina într-un depanator"
    echo " debug -security Debug Catalina cu un manager de securitate"
  fi
  echo " jpda start Start Catalina sub JPDA debugger"
  echo " rulați Start Catalina în fereastra curentă"
  echo " run -security Începe în fereastra curentă cu managerul de securitate"
  echo " începe Porniți Catalina într-o fereastră separată"
  echo " start -security Începe într-o fereastră separată cu managerul de securitate"
  echo " stop Stop Catalina, asteptand pana la 5 secunde pentru ca procesul sa se termine"
  echo „ stop n Stop Catalina, așteptând până la n secunde până la încheierea procesului”
  echo " stop -force Stop Catalina, așteptați până la 5 secunde și apoi folosiți kill -KILL dacă încă rulați"
  echo " stop n -force Opriți Catalina, așteptați până la n secunde și apoi folosiți kill -KILL dacă încă rulați"
  echo " configtest Rulați o verificare de bază a sintaxei pe server.xml - verificați codul de ieșire pentru rezultat"
  echo " versiune Ce versiune de tomcat rulezi?"
  echo „Notă: așteptarea încheierii procesului și utilizarea opțiunii -force necesită definirea \$CATALINA_PID”
  iesirea 1

fi

Fișierul meu setenv.sh

# -Xms/Xmx
# Xms Setează dimensiunea inițială a Heap-ului
# Xmx setează dimensiunea maximă a heap-ului.
# http://stackoverflow.com/questions/16087153/what-happens-when-we-set-xmx-and-xms-equal-size
# http://crunchify.com/jvm-tuning-heapsize-stacksize-garbage-collection-fundamental/
export JAVA_OPTS="$JAVA_OPTS -Xms3072m -Xmx3072m"