Enfrentando algunos problemas relacionados con el arranque y apagado de tomcat en Ubuntu 10.04

Question

Tengo algunos problemas relacionados con el arranque y el cierre de tomcat.

estoy usando

1. Tomcat v.6.0.32 (utilizando el extraída del paquete descargado desde el sitio web de Apache y no el distribuido por Ubuntu 10.04)
2. Ubuntu v.10.04

comienzo al gato con el comando:

$./catalina.sh jpda start 

entonces trato de detenerlo con el comando :

$./catalina.sh stop 

y obtener el siguiente mensaje:

SEVERE: Catalina.stop: 
java.net.ConnectException: Connection refused 
    at java.net.PlainSocketImpl.socketConnect(Native Method) 
    at java.net.PlainSocketImpl.doConnect(PlainSocketImpl.java:351) 
    at java.net.PlainSocketImpl.connectToAddress(PlainSocketImpl.java:213) 
    at java.net.PlainSocketImpl.connect(PlainSocketImpl.java:200) 
    at java.net.SocksSocketImpl.connect(SocksSocketImpl.java:366) 
    at java.net.Socket.connect(Socket.java:529) 
    at java.net.Socket.connect(Socket.java:478) 
    at java.net.Socket.<init>(Socket.java:375) 
    at java.net.Socket.<init>(Socket.java:189) 
    at org.apache.catalina.startup.Catalina.stopServer(Catalina.java:422) 
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) 
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39) 
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25) 
    at java.lang.reflect.Method.invoke(Method.java:597) 
    at org.apache.catalina.startup.Bootstrap.stopServer(Bootstrap.java:338) 
    at org.apache.catalina.startup.Bootstrap.main(Bootstrap.java:416) 

También intenté detenerlo con el comando:

$./catalina.sh stop -force 

pero me dio el mensaje:

Kill failed: $CATALINA_PID not set 

Entonces Una vez más intenté comenzar a usar Tomcat comando:

$./catalina.sh jpda start 

en el directorio/carpeta de registros se genera solamente con catalina.out siguiente mensaje de error:

ERROR: transport error 202: bind failed: Address already in use 
ERROR: JDWP Transport dt_socket failed to initialize, TRANSPORT_INIT(510) 
JDWP exit error AGENT_ERROR_TRANSPORT_INIT(197): No transports initialized [../../../src/share/back/debugInit.c:690] 
FATAL ERROR in native method: JDWP No transports initialized, jvmtiError=AGENT_ERROR_TRANSPORT_INIT(197) 

Como se indica en el error "Dirección ya utilizada" He verificado ninguna otra aplicación está configurado para ejecutarse en el puerto 8080. Cada vez que elimino el ID del proceso y lo reinicio, el inicio funciona bien. Esto requiere que elimine el proceso manualmente usando el comando "KILL", cuando necesito detener el servidor de tomcat. Este mismo comportamiento me encuentro en otras máquinas también donde se configura el mismo entorno que se mencionó anteriormente.

¿Alguien puede decirme qué está causando esto y cómo resolverlo?

Gracias,
Jignesh

Answer 1

fija el cierre Tomcat issue.Posting la solución aquí por referencia.

hacer lo siguiente para fijarlo en su máquina:

1) Replace $CATALINA_HOME/bin/catalina.sh with catalina.sh shown below. 
2) Open /etc/bash.bashrc for edit 
3) Add following into it, (AFTER export CATALINA_HOME) 
      export CATALINA_PID="$CATALINA_HOME/catalina_pid.txt", 

      where $CATALINA_HOME is the tomcat home path 

4) Execute following : 
     $ source /etc/bash.bashrc 

5) Start tomcat: $CATALINA_HOME/bin/catalina.sh start (or catalina.sh jpda start) 

6) Shutdown tomcat using following command only for proper shutdown: 
     $CATALINA_HOME/bin/catalina.sh stop -force 

catalina.sh - contiene mi línea comenta

 #!/bin/sh 

     # Licensed to the Apache Software Foundation (ASF) under one or more 
     # contributor license agreements. See the NOTICE file distributed with 
     # this work for additional information regarding copyright ownership. 
     # The ASF licenses this file to You under the Apache License, Version 2.0 
     # (the "License"); you may not use this file except in compliance with 
     # the License. You may obtain a copy of the License at 
     # 
     #  http://www.apache.org/licenses/LICENSE-2.0 
     # 
     # Unless required by applicable law or agreed to in writing, software 
     # distributed under the License is distributed on an "AS IS" BASIS, 
     # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
     # See the License for the specific language governing permissions and 
     # limitations under the License. 

     # ----------------------------------------------------------------------------- 
     # Start/Stop Script for the CATALINA Server 
     # 
     # Environment Variable Prerequisites 
     # 
     # CATALINA_HOME May point at your Catalina "build" directory. 
     # 
     # CATALINA_BASE (Optional) Base directory for resolving dynamic portions 
     #     of a Catalina installation. If not present, resolves to 
     #     the same directory that CATALINA_HOME points to. 
     # 
     # CATALINA_OUT (Optional) Full path to a file where stdout and stderr 
     #     will be redirected. 
     #     Default is $CATALINA_BASE/logs/catalina.out 
     # 
     # CATALINA_OPTS (Optional) Java runtime options used when the "start", 
     #     or "run" command is executed. 
     # 
     # CATALINA_TMPDIR (Optional) Directory path location of temporary directory 
     #     the JVM should use (java.io.tmpdir). Defaults to 
     #     $CATALINA_BASE/temp. 
     # 
     # JAVA_HOME  Must point at your Java Development Kit installation. 
     #     Required to run the with the "debug" argument. 
     # 
     # JRE_HOME  Must point at your Java Development Kit installation. 
     #     Defaults to JAVA_HOME if empty. 
     # 
     # JAVA_OPTS  (Optional) Java runtime options used when the "start", 
     #     "stop", or "run" command is executed. 
     # 
     # JAVA_ENDORSED_DIRS (Optional) Lists of of colon separated directories 
     #     containing some jars in order to allow replacement of APIs 
     #     created outside of the JCP (i.e. DOM and SAX from W3C). 
     #     It can also be used to update the XML parser implementation. 
     #     Defaults to $CATALINA_HOME/endorsed. 
     # 
     # JPDA_TRANSPORT (Optional) JPDA transport used when the "jpda start" 
     #     command is executed. The default is "dt_socket". 
     # 
     # JPDA_ADDRESS (Optional) Java runtime options used when the "jpda start" 
     #     command is executed. The default is 8000. 
     # 
     # JPDA_SUSPEND (Optional) Java runtime options used when the "jpda start" 
     #     command is executed. Specifies whether JVM should suspend 
     #     execution immediately after startup. Default is "n". 
     # 
     # JPDA_OPTS  (Optional) Java runtime options used when the "jpda start" 
     #     command is executed. If used, JPDA_TRANSPORT, JPDA_ADDRESS, 
     #     and JPDA_SUSPEND are ignored. Thus, all required jpda 
     #     options MUST be specified. The default is: 
     # 
     #     -agentlib:jdwp=transport=$JPDA_TRANSPORT, 
     #      address=$JPDA_ADDRESS,server=y,suspend=$JPDA_SUSPEND 
     # 
     # CATALINA_PID (Optional) Path of the file which should contains the pid 
     #     of catalina startup java process, when start (fork) is used 
     # 
     # LOGGING_CONFIG (Optional) Override Tomcat's logging config file 
     #     Example (all one line) 
     #     LOGGING_CONFIG="-Djava.util.logging.config.file=$CATALINA_BASE/conf/logging.properties" 
     # 
     # LOGGING_MANAGER (Optional) Override Tomcat's logging manager 
     #     Example (all one line) 
     #     LOGGING_MANAGER="-Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager" 
     # 
     # $Id: catalina.sh 1040547 2010-11-30 14:47:49Z markt $ 
     # ----------------------------------------------------------------------------- 

     # OS specific support. $var _must_ be set to either true or false. 
     cygwin=false 
     os400=false 
     darwin=false 
     case "`uname`" in 
     CYGWIN*) cygwin=true;; 
     OS400*) os400=true;; 
     Darwin*) darwin=true;; 
     esac 

     # resolve links - $0 may be a softlink 
     PRG="$0" 

     while [ -h "$PRG" ]; do 
      ls=`ls -ld "$PRG"` 
      link=`expr "$ls" : '.*-> \(.*\)$'` 
      if expr "$link" : '/.*' > /dev/null; then 
       PRG="$link" 
      else 
       PRG=`dirname "$PRG"`/"$link" 
      fi 
     done 

     # Get standard environment variables 
     PRGDIR=`dirname "$PRG"` 

     # Only set CATALINA_HOME if not already set 
     [ -z "$CATALINA_HOME" ] && CATALINA_HOME=`cd "$PRGDIR/.." >/dev/null; pwd` 

     # Ensure that any user defined CLASSPATH variables are not used on startup, 
     # but allow them to be specified in setenv.sh, in rare case when it is needed. 
     CLASSPATH= 

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

     # For Cygwin, ensure paths are in UNIX format before anything is touched 
     if $cygwin; then 
      [ -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 

     # For OS400 
     if $os400; then 
      # Set job priority to standard for interactive (interactive - 6) by using 
      # the interactive priority - 6, the helper threads that respond to requests 
      # will be running at the same priority as interactive jobs. 
      COMMAND='chgjob job('$JOBNAME') runpty(6)' 
      system $COMMAND 

      # Enable multi threading 
      export QIBM_MULTI_THREADED=Y 
     fi 

     # Get standard Java environment variables 
     if $os400; then 
      # -r will Only work on the os400 if the files are: 
      # 1. owned by the user 
      # 2. owned by the PRIMARY group of the user 
      # this will not work if the user belongs in secondary groups 
      BASEDIR="$CATALINA_HOME" 
      . "$CATALINA_HOME"/bin/setclasspath.sh 
     else 
      if [ -r "$CATALINA_HOME"/bin/setclasspath.sh ]; then 
       BASEDIR="$CATALINA_HOME" 
       . "$CATALINA_HOME"/bin/setclasspath.sh 
      else 
       echo "Cannot find $CATALINA_HOME/bin/setclasspath.sh" 
       echo "This file is needed to run this program" 
       exit 1 
      fi 
     fi 

     if [ -z "$CATALINA_BASE" ] ; then 
      CATALINA_BASE="$CATALINA_HOME" 
     fi 

     # Add tomcat-juli.jar and bootstrap.jar to classpath 
     # tomcat-juli.jar can be over-ridden per instance 
     if [ ! -z "$CLASSPATH" ] ; then 
      CLASSPATH="$CLASSPATH": 
     fi 
     if [ "$CATALINA_BASE" != "$CATALINA_HOME" ] && [ -r "$CATALINA_BASE/bin/tomcat-juli.jar" ] ; then 
      CLASSPATH="$CLASSPATH""$CATALINA_BASE"/bin/tomcat-juli.jar:"$CATALINA_HOME"/bin/bootstrap.jar 
     else 
      CLASSPATH="$CLASSPATH""$CATALINA_HOME"/bin/bootstrap.jar 
     fi 

     if [ -z "$CATALINA_OUT" ] ; then 
      CATALINA_OUT="$CATALINA_BASE"/logs/catalina.out 
     fi 

     if [ -z "$CATALINA_TMPDIR" ] ; then 
      # Define the java.io.tmpdir to use for Catalina 
      CATALINA_TMPDIR="$CATALINA_BASE"/temp 
     fi 

     # Bugzilla 37848: When no TTY is available, don't output to console 
     have_tty=0 
     if [ "`tty`" != "not a tty" ]; then 
       have_tty=1 
     fi 

     # For Cygwin, switch paths to Windows format before running java 
     if $cygwin; then 
      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"` 
      JAVA_ENDORSED_DIRS=`cygpath --path --windows "$JAVA_ENDORSED_DIRS"` 
     fi 

     # Set juli LogManager config file if it is present and an override has not been issued 
     if [ -z "$LOGGING_CONFIG" ]; then 
      if [ -r "$CATALINA_BASE"/conf/logging.properties ]; then 
       LOGGING_CONFIG="-Djava.util.logging.config.file=$CATALINA_BASE/conf/logging.properties" 
      else 
       # Bugzilla 45585 
       LOGGING_CONFIG="-Dnop" 
      fi 
     fi 

     if [ -z "$LOGGING_MANAGER" ]; then 
      JAVA_OPTS="$JAVA_OPTS -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager" 
     else 
      JAVA_OPTS="$JAVA_OPTS $LOGGING_MANAGER" 
     fi 

     # ----- Execute The Requested Command ----------------------------------------- 

     # Bugzilla 37848: only output this if we have a TTY 
     if [ $have_tty -eq 1 ]; then 
      echo "Using CATALINA_BASE: $CATALINA_BASE" 
      echo "Using CATALINA_HOME: $CATALINA_HOME" 
      echo "Using CATALINA_TMPDIR: $CATALINA_TMPDIR" 
      if [ "$1" = "debug" ] ; then 
       echo "Using JAVA_HOME:  $JAVA_HOME" 
      else 
       echo "Using JRE_HOME:  $JRE_HOME" 
      fi 
      echo "Using CLASSPATH:  $CLASSPATH" 
      if [ ! -z "$CATALINA_PID" ]; then 
       # Added by Jignesh Gohel - Nov 08, 2011. 

       # There was an issue occuring when shutting down tomcat using 
       # command ./catalina.sh stop 

       # Issue mentioned at : http://stackoverflow.com/questions/7890197/facing-some-issues-regarding-tomcat-startup-and-shutdown-on-ubuntu-10-04 

       # Tomcat was shutting down properly but the process started using 
       # command ./catalina.sh start was not getting killed. 

       # To resolve this issue following steps taken :- 

       # 1) Exported an environment variable named CATALINA_PID which 
       # should point to a file in which the tomcat process id would be 
       # written. 

       # Note: Using the normal command to shutdown tomcat "./catalina.sh stop" 
       # following message was logged "Tomcat did not stop in time. PID file 
       # was not removed".Thus to shutdown the tomcat using following command 
       # "./catalina.sh stop -force" which forcefully kills the tomcat process 
       # and also removes the file pointed by environment variable 
       # "$CATALINA_PID".Thus executing a "touch" command when starting up 
       # tomcat to automatically create the file. 

       touch "$CATALINA_PID" 
       echo "Using CATALINA_PID: $CATALINA_PID" 
      fi 
     fi 

     if [ "$1" = "jpda" ] ; then 
      if [ -z "$JPDA_TRANSPORT" ]; then 
       JPDA_TRANSPORT="dt_socket" 
      fi 
      if [ -z "$JPDA_ADDRESS" ]; then 
       JPDA_ADDRESS="8000" 
      fi 
      if [ -z "$JPDA_SUSPEND" ]; then 
       JPDA_SUSPEND="n" 
      fi 
      if [ -z "$JPDA_OPTS" ]; then 
       JPDA_OPTS="-agentlib:jdwp=transport=$JPDA_TRANSPORT,address=$JPDA_ADDRESS,server=y,suspend=$JPDA_SUSPEND" 
      fi 
      CATALINA_OPTS="$CATALINA_OPTS $JPDA_OPTS" 
      shift 
     fi 

     if [ "$1" = "debug" ] ; then 
      if $os400; then 
       echo "Debug command not available on OS400" 
       exit 1 
      else 
       shift 
       if [ "$1" = "-security" ] ; then 
        if [ $have_tty -eq 1 ]; then 
         echo "Using Security Manager" 
        fi 
        shift 
        exec "$_RUNJDB" "$LOGGING_CONFIG" $JAVA_OPTS $CATALINA_OPTS \ 
         -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$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 "$@" start 
       else 
        exec "$_RUNJDB" "$LOGGING_CONFIG" $JAVA_OPTS $CATALINA_OPTS \ 
         -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$CLASSPATH" \ 
         -sourcepath "$CATALINA_HOME"/../../java \ 
         -Dcatalina.base="$CATALINA_BASE" \ 
         -Dcatalina.home="$CATALINA_HOME" \ 
         -Djava.io.tmpdir="$CATALINA_TMPDIR" \ 
         org.apache.catalina.startup.Bootstrap "$@" start 
       fi 
      fi 

     elif [ "$1" = "run" ]; then 

      shift 
      if [ "$1" = "-security" ] ; then 
       if [ $have_tty -eq 1 ]; then 
        echo "Using Security Manager" 
       fi 
       shift 
       exec "$_RUNJAVA" "$LOGGING_CONFIG" $JAVA_OPTS $CATALINA_OPTS \ 
        -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$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 
      else 
       exec "$_RUNJAVA" "$LOGGING_CONFIG" $JAVA_OPTS $CATALINA_OPTS \ 
        -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$CLASSPATH" \ 
        -Dcatalina.base="$CATALINA_BASE" \ 
        -Dcatalina.home="$CATALINA_HOME" \ 
        -Djava.io.tmpdir="$CATALINA_TMPDIR" \ 
        org.apache.catalina.startup.Bootstrap "$@" start 
      fi 

     elif [ "$1" = "start" ] ; then 

      if [ ! -z "$CATALINA_PID" ]; then 
       if [ -f "$CATALINA_PID" ]; then 
        if [ -s "$CATALINA_PID" ]; then 
         echo "Existing PID file found during start." 
         if [ -r "$CATALINA_PID" ]; then 
          PID=`cat "$CATALINA_PID"` 
          ps -p $PID >/dev/null 2>&1 
          if [ $? -eq 0 ] ; then 
           echo "Tomcat appears to still be running with PID $PID. Start aborted." 
           exit 1 
          else 
           echo "Removing/clearing stale PID file." 
           rm -f "$CATALINA_PID" >/dev/null 2>&1 
           if [ $? != 0 ]; then 
            if [ -w "$CATALINA_PID" ]; then 
             cat /dev/null > "$CATALINA_PID" 
            else 
             echo "Unable to remove or clear stale PID file. Start aborted." 
             exit 1 
            fi 
           fi 
          fi 
         else 
          echo "Unable to read PID file. Start aborted." 
          exit 1 
         fi 
        else 
         rm -f "$CATALINA_PID" >/dev/null 2>&1 
         if [ $? != 0 ]; then 
          if [ ! -w "$CATALINA_PID" ]; then 
           echo "Unable to remove or write to empty PID file. Start aborted." 
           exit 1 
          fi 
         fi 
        fi 
       fi 
      fi 

      shift 
      touch "$CATALINA_OUT" 
      if [ "$1" = "-security" ] ; then 
       if [ $have_tty -eq 1 ]; then 
        echo "Using Security Manager" 
       fi 
       shift 
       "$_RUNJAVA" "$LOGGING_CONFIG" $JAVA_OPTS $CATALINA_OPTS \ 
        -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$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 & 

      else 
       "$_RUNJAVA" "$LOGGING_CONFIG" $JAVA_OPTS $CATALINA_OPTS \ 
        -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$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 

      if [ ! -z "$CATALINA_PID" ]; then 
       echo $! > "$CATALINA_PID" 
      fi 

     elif [ "$1" = "stop" ] ; then 

      shift 

      SLEEP=5 
      if [ ! -z "$1" ]; then 
       echo $1 | grep "[^0-9]" >/dev/null 2>&1 
       if [ $? -gt 0 ]; then 
        SLEEP=$1 
        shift 
       fi 
      fi 

      FORCE=0 
      if [ "$1" = "-force" ]; then 
       shift 
       FORCE=1 
      fi 

      if [ ! -z "$CATALINA_PID" ]; then 
       if [ -s "$CATALINA_PID" ]; then 
        if [ -f "$CATALINA_PID" ]; then 
         kill -0 `cat "$CATALINA_PID"` >/dev/null 2>&1 
         if [ $? -gt 0 ]; then 
          echo "PID file found but no matching process was found. Stop aborted." 
          exit 1 
         fi 
        else 
         echo "\$CATALINA_PID was set but the specified file does not exist. Is Tomcat running? Stop aborted." 
         exit 1 
        fi 
       else 
        echo "PID file is empty and has been ignored." 
       fi 
      fi 

      "$_RUNJAVA" $JAVA_OPTS \ 
       -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$CLASSPATH" \ 
       -Dcatalina.base="$CATALINA_BASE" \ 
       -Dcatalina.home="$CATALINA_HOME" \ 
       -Djava.io.tmpdir="$CATALINA_TMPDIR" \ 
       org.apache.catalina.startup.Bootstrap "$@" stop 

      if [ ! -z "$CATALINA_PID" ]; then 
       if [ -f "$CATALINA_PID" ]; then 
        while [ $SLEEP -ge 0 ]; do 
         kill -0 `cat "$CATALINA_PID"` >/dev/null 2>&1 
         if [ $? -gt 0 ]; then 
          rm -f "$CATALINA_PID" >/dev/null 2>&1 
          if [ $? != 0 ]; then 
           if [ -w "$CATALINA_PID" ]; then 
            cat /dev/null > "$CATALINA_PID" 
           else 
            echo "Tomcat stopped but the PID file could not be removed or cleared." 
           fi 
          fi 
          break 
         fi 
         if [ $SLEEP -gt 0 ]; then 
          sleep 1 
         fi 
         if [ $SLEEP -eq 0 ]; then 
          if [ $FORCE -eq 0 ]; then 
           echo "Tomcat did not stop in time. PID file was not removed." 
          fi 
         fi 
         SLEEP=`expr $SLEEP - 1 ` 
        done 
       fi 
      fi 

      if [ $FORCE -eq 1 ]; then 
       if [ -z "$CATALINA_PID" ]; then 
        echo "Kill failed: \$CATALINA_PID not set" 
       else 
        if [ -f "$CATALINA_PID" ]; then 
         PID=`cat "$CATALINA_PID"` 
         echo "Killing Tomcat with the PID: $PID" 
         kill -9 $PID 
         rm -f "$CATALINA_PID" >/dev/null 2>&1 
         if [ $? != 0 ]; then 
          echo "Tomcat was killed but the PID file could not be removed." 
         fi 
        fi 
       fi 
      fi 

     elif [ "$1" = "version" ] ; then 

       "$_RUNJAVA" \ 
        -classpath "$CATALINA_HOME/lib/catalina.jar" \ 
        org.apache.catalina.util.ServerInfo 

     else 

      echo "Usage: catalina.sh (commands ...)" 
      echo "commands:" 
      if $os400; then 
       echo " debug    Start Catalina in a debugger (not available on OS400)" 
       echo " debug -security Debug Catalina with a security manager (not available on OS400)" 
      else 
       echo " debug    Start Catalina in a debugger" 
       echo " debug -security Debug Catalina with a security manager" 
      fi 
      echo " jpda start  Start Catalina under JPDA debugger" 
      echo " run    Start Catalina in the current window" 
      echo " run -security  Start in the current window with security manager" 
      echo " start    Start Catalina in a separate window" 
      echo " start -security Start in a separate window with security manager" 
      echo " stop    Stop Catalina, waiting up to 5 seconds for the process to end" 
      echo " stop n   Stop Catalina, waiting up to n seconds for the process to end" 
      echo " stop -force  Stop Catalina, wait up to 5 seconds and then use kill -KILL if still running" 
      echo " stop n -force  Stop Catalina, wait up to n seconds and then use kill -KILL if still running" 
      echo " version   What version of tomcat are you running?" 
      echo "Note: Waiting for the process to end and use of the -force option require that \$CATALINA_PID is defined" 
      exit 1 

     fi 

Gracias,

Jignesh

Answer 2

El problema es causado porque la dirección se utiliza para iniciar Tomcat (en modo normal o depuración) ya está siendo usado por otro proceso.

Debe verificar los puertos que está utilizando en el archivo conf (por ejemplo, your_TOMCAT_HOME_DIR_/conf/server.xml), para ver si no están ya utilizan

Aquí se puede ver en el puerto utilizado para

• iniciar Tomcat: valor por defecto 8080
• detener Tomcat: valor por defecto 8005
• utilizando con AJP protocol: valor por defecto 8009

y si está utilizando Tomcat en modo de depuración (a través de JDPA o jdwp), por favor asegúrese de usar un puerto diferente a todos los puertos configurados anteriores

Answer 3

En mi situación de este problema, hubo algunos subprocesos que no finalizaron con éxito con el mensaje de cierre publicado en tomcat, lo que hizo que el proceso de tomcat aún se quedara.

Así que comenzaría con la instancia simple de tomcat ... y seguiré agregando las "guerras" personalizadas o cambios uno por uno y me aseguraré de detener tomcat con éxito para reducir el problema.

Answer 4

Solución; En primer lugar establecer el pid del Tomcat CATALINA_PID = "/ id.pid" CATALINA_PID exportación

luego matarlo catalina.sh parada force

fuente: http://confluence.atlassian.com/pages/viewpage.action?pageId=216959212

de lo contrario sólo como usted ha mencionado, acaba de matarlo con el comando kill

ps aux | grep catalina 
kill <pid of tomcat> 

si las dos soluciones anteriores no se ajustan a su nee ds pruebe lo siguiente:

$ sudo service tomcat6 stop 
* Stopping Tomcat servlet engine tomcat6 [ OK ] 
$ sudo service tomcat6 start 
* Starting Tomcat servlet engine tomcat6 [ OK ] 
$ 

o, por supuesto, la forma más tradicional:

$ sudo /etc/init.d/tomcat6 stop 
* Stopping Tomcat servlet engine tomcat6 [ OK ] 
$ sudo /etc/init.d/tomcat6 start 
* Starting Tomcat ser 

Answer 5

Dont use /etc/bash.bashrc sólo hay que poner esto en su catalina.sh

Después:

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

poner esto:

export CATALINA_PID="$CATALINA_HOME/catalina_pid.txt" 

Y ahora serán matados a su gato cuando se utiliza catalina.sh dejar de force

Answer 6

Creo que la forma recomendada oficialmente (según catalina.sh comentarios en línea) es:

• crear un archivo setenv.sh menos de $ CATALINA_HOME/bin:

#!/Bin/sh

CATALINA_PID = "$ CATALINA_HOME/logs/catalina.pid"; exportación CATALINA_PID

• chmod como ejecutable:

  chmod u + x setenv.sh

• crear el archivo pid por:

  toque $ CATALINA_HOME/logs/catalina .pid

• luego de iniciar tomcat como de costumbre, el archivo pid se actualizará automáticamente. Y también puede detener tomcat mediante la opción "-force".

Answer 7

siguiente comando hace el truco:

service tomcat8 stop

Estos seres también sería útil:

service tomcat8 start

service tomcat8 restart